@kitlangton/knobs 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2651 @@
+// src/core/color.ts
+var round = (n, places) => Number(n.toFixed(places)), clamp01 = (n) => Math.min(1, Math.max(0, n)), gamma = (c) => c <= 0.0031308 ? 12.92 * c : 1.055 * c ** 0.4166666666666667 - 0.055, linear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function oklchToLinear({ l, c, h }) {
+  let a = c * Math.cos(h * Math.PI / 180), b = c * Math.sin(h * Math.PI / 180), l_ = (l + 0.3963377774 * a + 0.2158037573 * b) ** 3, m_ = (l - 0.1055613458 * a - 0.0638541728 * b) ** 3, s_ = (l - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    4.0767416621 * l_ - 3.3077115913 * m_ + 0.2309699292 * s_,
+    -1.2684380046 * l_ + 2.6097574011 * m_ - 0.3413193965 * s_,
+    -0.0041960863 * l_ - 0.7034186147 * m_ + 1.707614701 * s_
+  ];
+}
+var inGamut = (rgb) => rgb.every((v) => v >= -0.0001 && v <= 1.0001);
+function maxChroma(l, h) {
+  if (l <= 0 || l >= 1)
+    return 0;
+  let lo = 0, hi = 0.37;
+  if (inGamut(oklchToLinear({ l, c: hi, h })))
+    return hi;
+  for (let i = 0;i < 18; i++) {
+    let mid = (lo + hi) / 2;
+    if (inGamut(oklchToLinear({ l, c: mid, h })))
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return lo;
+}
+function oklchToRgb(color) {
+  let rgb = oklchToLinear(color);
+  if (!inGamut(rgb))
+    rgb = oklchToLinear({ ...color, c: Math.min(color.c, maxChroma(color.l, color.h)) });
+  let [r, g, b] = rgb;
+  return [clamp01(gamma(r)), clamp01(gamma(g)), clamp01(gamma(b))];
+}
+function rgbToOklch(r, g, b) {
+  let [lr, lg, lb] = [linear(r), linear(g), linear(b)], l_ = Math.cbrt(0.4122214708 * lr + 0.5363377612 * lg + 0.0514459929 * lb), m_ = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb), s_ = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb), L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_, a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_, bb = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_, c = Math.hypot(a, bb), h = c < 0.0001 ? 0 : (Math.atan2(bb, a) * 180 / Math.PI + 360) % 360;
+  return { l: L, c, h };
+}
+function parseColor(input) {
+  if (typeof input === "object" && input !== null) {
+    let { l, c, h } = input;
+    return [l, c, h].every((n) => typeof n === "number" && Number.isFinite(n)) ? { l, c, h } : void 0;
+  }
+  if (typeof input !== "string")
+    return;
+  let s = input.trim().toLowerCase(), hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(s)?.[1];
+  if (hex) {
+    let full = hex.length === 3 ? [...hex].map((d) => d + d).join("") : hex, [r, g, b] = [0, 2, 4].map((i) => parseInt(full.slice(i, i + 2), 16) / 255);
+    return rgbToOklch(r, g, b);
+  }
+  let m = /^oklch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(?:deg)?\s*\)$/.exec(s);
+  if (!m)
+    return;
+  let parts = [Number(m[1]) / (m[2] ? 100 : 1), Number(m[3]), Number(m[4])];
+  return parts.every(Number.isFinite) ? { l: parts[0], c: parts[1], h: parts[2] } : void 0;
+}
+function fitColor({ l, c, h }) {
+  let L = round(clamp01(l), 5), H = round((h % 360 + 360) % 360, 3) % 360, C0 = round(Math.min(0.37, Math.max(0, c)), 5);
+  if (inGamut(oklchToLinear({ l: L, c: C0, h: H })))
+    return { l: L, c: C0, h: H };
+  let max = Math.min(0.37, maxChroma(L, H));
+  return { l: L, c: Math.min(C0, Math.floor(max * 1e5) / 1e5), h: H };
+}
+function formatColor({ l, c, h }) {
+  return `oklch(${round(l, 5)} ${round(c, 5)} ${round(h, 3)})`;
+}
+function colorHex(value) {
+  let color = parseColor(value);
+  if (!color)
+    return "#000000";
+  return `#${oklchToRgb(color).map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/core/easing.ts
+var EASINGS = {
+  ease: [0.25, 0.1, 0.25, 1],
+  in: [0.42, 0, 1, 1],
+  out: [0, 0, 0.58, 1],
+  "in-out": [0.42, 0, 0.58, 1],
+  linear: [0, 0, 1, 1],
+  smooth: [0.65, 0, 0.35, 1],
+  snappy: [0.32, 0.72, 0, 1],
+  back: [0.34, 1.56, 0.64, 1]
+}, EASING_Y = [-0.6, 1.6];
+function namedEasing(name) {
+  let key = name.replace(/^ease-(?=in|out)/, "");
+  return Object.hasOwn(EASINGS, key) ? EASINGS[key] : void 0;
+}
+function bezierPoint([x1, y1, x2, y2], t) {
+  let u = 1 - t, a = 3 * u * u * t, b = 3 * u * t * t, c = t * t * t;
+  return [a * x1 + b * x2 + c, a * y1 + b * y2 + c];
+}
+var bezierCss = (b) => `cubic-bezier(${b.join(", ")})`;
+
+// src/core/keys.ts
+var MODS = ["Ctrl", "Alt", "Shift", "Meta"], ALIASES = {
+  ctrl: "Ctrl",
+  control: "Ctrl",
+  "⌃": "Ctrl",
+  alt: "Alt",
+  option: "Alt",
+  opt: "Alt",
+  "⌥": "Alt",
+  shift: "Shift",
+  "⇧": "Shift",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  "⌘": "Meta",
+  mod: "Mod"
+}, NAMED = {
+  " ": "Space",
+  space: "Space",
+  spacebar: "Space",
+  esc: "Escape",
+  escape: "Escape",
+  enter: "Enter",
+  return: "Enter",
+  tab: "Tab",
+  backspace: "Backspace",
+  delete: "Delete",
+  del: "Delete",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  arrowup: "ArrowUp",
+  arrowdown: "ArrowDown",
+  arrowleft: "ArrowLeft",
+  arrowright: "ArrowRight",
+  home: "Home",
+  end: "End",
+  pageup: "PageUp",
+  pagedown: "PageDown"
+}, isApple = () => typeof navigator < "u" && /mac|iphone|ipad|ipod/i.test(navigator.userAgentData?.platform ?? navigator.platform ?? ""), keyName = (raw) => {
+  if (!raw)
+    return "";
+  let named = NAMED[raw.toLowerCase()];
+  if (named)
+    return named;
+  if (raw.length === 1)
+    return raw.toUpperCase();
+  if (/^f\d{1,2}$/i.test(raw))
+    return raw.toUpperCase();
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+};
+function normalizeCombo(combo) {
+  let trimmed = combo.trim();
+  if (!trimmed)
+    return "";
+  let parts = trimmed === "+" ? ["+"] : trimmed.replace(/\+\+$/, "+plus").split("+"), mods = /* @__PURE__ */ new Set, key = "";
+  for (let part of parts) {
+    let alias = ALIASES[part.trim().toLowerCase()] ?? ALIASES[part.trim()];
+    if (alias === "Mod")
+      mods.add(isApple() ? "Meta" : "Ctrl");
+    else if (alias)
+      mods.add(alias);
+    else
+      key = part === "plus" ? "+" : keyName(part.trim() || part);
+  }
+  if (!key)
+    return "";
+  return [...MODS.filter((m) => mods.has(m)), key].join("+");
+}
+var layout = null, layoutAsked = !1;
+function askLayout() {
+  if (layoutAsked)
+    return;
+  layoutAsked = !0, globalThis.navigator?.keyboard?.getLayoutMap?.().then((map) => {
+    layout = map;
+  }).catch(() => {});
+}
+function letterOf(event) {
+  askLayout();
+  let code = event.code ?? "";
+  if (/^[a-z]$/i.test(event.key) && !event.altKey)
+    return event.key.toUpperCase();
+  let mapped = layout?.get(code);
+  if (mapped && /^[a-z]$/i.test(mapped))
+    return mapped.toUpperCase();
+  return /^Key[A-Z]$/.test(code) ? code.slice(3) : "";
+}
+function comboFromEvent(event) {
+  if (["Shift", "Alt", "Meta", "Control", "CapsLock", "Fn", "OS"].includes(event.key))
+    return "";
+  let code = event.code ?? "", letter = letterOf(event), key = letter ? letter : /^Digit\d$/.test(code) ? code.slice(5) : code === "Space" ? "Space" : keyName(event.key);
+  return [
+    event.ctrlKey ? "Ctrl" : "",
+    event.altKey ? "Alt" : "",
+    event.shiftKey ? "Shift" : "",
+    event.metaKey ? "Meta" : "",
+    key
+  ].filter(Boolean).join("+");
+}
+function matchesCombo(combo, event) {
+  let want = normalizeCombo(combo);
+  return want !== "" && want === comboFromEvent(event);
+}
+var GLYPHS = { Ctrl: "⌃", Alt: "⌥", Shift: "⇧", Meta: "⌘" }, WORDS = { Ctrl: "Ctrl", Alt: "Alt", Shift: "Shift", Meta: "Meta" }, KEY_GLYPHS = {
+  ArrowUp: "↑",
+  ArrowDown: "↓",
+  ArrowLeft: "←",
+  ArrowRight: "→",
+  Backspace: "⌫",
+  Delete: "⌦",
+  Enter: "↩",
+  Escape: "Esc",
+  Tab: "⇥",
+  PageUp: "PgUp",
+  PageDown: "PgDn"
+};
+function comboParts(combo, apple = isApple()) {
+  let norm = normalizeCombo(combo);
+  if (!norm)
+    return [];
+  let parts = norm === "+" ? ["+"] : norm.split("+");
+  if (norm.endsWith("++"))
+    parts.splice(-2, 2, "+");
+  let key = parts.pop(), mods = parts, shown = KEY_GLYPHS[key] ?? key;
+  return apple ? [...mods.map((m) => GLYPHS[m]), shown] : [...mods.map((m) => WORDS[m]), shown];
+}
+function comboLabel(combo, apple = isApple()) {
+  return comboParts(combo, apple).join(apple ? "" : "+");
+}
+
+// src/core/ramp.ts
+var MAX_STOPS = 32, MAX_POINTS = 64, GRADIENT_SAMPLES = 64;
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v)), finite = (v) => typeof v === "number" && Number.isFinite(v), round4 = (v) => Math.round(v * 1e4) / 1e4 || 0;
+function normalizeStops(input) {
+  if (!Array.isArray(input))
+    return;
+  let stops = [];
+  for (let s of input.slice(0, MAX_STOPS)) {
+    if (typeof s !== "object" || s === null)
+      continue;
+    let { at, color } = s, parsed = parseColor(color);
+    if (!finite(at) || !parsed)
+      continue;
+    stops.push(Object.freeze({ at: round4(clamp(at, 0, 1)), color: formatColor(fitColor(parsed)) }));
+  }
+  if (stops.length < 2)
+    return;
+  return Object.freeze(stops.map((s, i) => [s, i]).sort((a, b) => a[0].at - b[0].at || a[1] - b[1]).map(([s]) => s));
+}
+function normalizePoints(input, range) {
+  if (!Array.isArray(input))
+    return;
+  let pts = [], span = range[1] - range[0], roundY = (y) => span > 0 ? Number((range[0] + Math.round((y - range[0]) / span * 1e5) / 1e5 * span).toPrecision(12)) : range[0];
+  for (let p of input.slice(0, MAX_POINTS)) {
+    if (typeof p !== "object" || p === null)
+      continue;
+    let { x, y } = p;
+    if (!finite(x) || !finite(y))
+      continue;
+    pts.push({ x: round4(clamp(x, 0, 1)), y: roundY(clamp(y, range[0], range[1])) });
+  }
+  if (pts.length < 2)
+    return;
+  let sorted = pts.map((p, i) => [p, i]).sort((a, b) => a[0].x - b[0].x || a[1] - b[1]).map(([p]) => p);
+  return sorted[0] = { ...sorted[0], x: 0 }, sorted[sorted.length - 1] = { ...sorted[sorted.length - 1], x: 1 }, Object.freeze(sorted.map((p) => Object.freeze(p)));
+}
+var toLab = ({ l, c, h }) => [
+  l,
+  c * Math.cos(h * Math.PI / 180),
+  c * Math.sin(h * Math.PI / 180)
+], fromLab = ([l, a, b]) => {
+  let c = Math.hypot(a, b);
+  return { l, c, h: c < 0.00001 ? 0 : (Math.atan2(b, a) * 180 / Math.PI + 360) % 360 };
+}, linearOf = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function prepare(stops, space) {
+  let at = stops.map((s) => s.at), ok = stops.map((s) => parseColor(s.color) ?? { l: 0, c: 0, h: 0 }), lab = ok.map(toLab), rgb = ok.map((c) => oklchToRgb(c));
+  return (t) => {
+    let n = at.length, i = 0;
+    while (i < n && at[i] <= t)
+      i++;
+    if (i === 0)
+      return [...rgb[0]];
+    if (i === n)
+      return [...rgb[n - 1]];
+    let a = i - 1, span = at[i] - at[a], f = span > 0 ? (t - at[a]) / span : 1;
+    if (space === "srgb") {
+      let p = rgb[a], q = rgb[i];
+      return [p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f, p[2] + (q[2] - p[2]) * f];
+    }
+    let p = lab[a], q = lab[i];
+    return oklchToRgb(fromLab([p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f, p[2] + (q[2] - p[2]) * f]));
+  };
+}
+function sampleGradient(stops, t, options = {}) {
+  let valid = normalizeStops(stops) ?? stops;
+  if (!valid.length)
+    return options.as === "rgb" || options.as === "linear" ? [0, 0, 0] : "#000000";
+  let rgb = prepare(valid, options.space ?? "oklab")(clamp(Number.isFinite(t) ? t : 0, 0, 1));
+  if (options.as === "rgb")
+    return rgb;
+  if (options.as === "linear")
+    return [linearOf(rgb[0]), linearOf(rgb[1]), linearOf(rgb[2])];
+  let color = formatColor(fitColor(rgbToOklch(...rgb)));
+  return options.as === "hex" ? colorHex(color) : color;
+}
+function gradientSamples(stops, space, n = GRADIENT_SAMPLES) {
+  let at = prepare(stops, space), out = [];
+  for (let i = 0;i < n; i++)
+    out.push(...at(i / (n - 1)));
+  return out;
+}
+function gradientCss(stops, options = {}) {
+  let valid = normalizeStops(stops) ?? stops, s = gradientSamples(valid, options.space ?? "oklab", 17), parts = [];
+  for (let i = 0;i < 17; i++) {
+    let [r, g, b] = [s[i * 3], s[i * 3 + 1], s[i * 3 + 2]].map((v) => Math.round(v * 255));
+    parts.push(`rgb(${r} ${g} ${b}) ${round4(i / 16 * 100)}%`);
+  }
+  return `linear-gradient(${options.direction ?? "to right"},${parts.join(",")})`;
+}
+function tangents(xs, ys) {
+  let n = xs.length, h = [], s = [];
+  for (let i = 0;i < n - 1; i++)
+    h.push(xs[i + 1] - xs[i]), s.push(h[i] > 0 ? (ys[i + 1] - ys[i]) / h[i] : 0);
+  let m = Array(n).fill(0);
+  if (n === 2)
+    return m[0] = m[1] = s[0], m;
+  let sign = Math.sign;
+  for (let i = 1;i < n - 1; i++) {
+    let h0 = h[i - 1], h1 = h[i];
+    if (h0 <= 0 || h1 <= 0)
+      continue;
+    let p = (s[i - 1] * h1 + s[i] * h0) / (h0 + h1);
+    m[i] = (sign(s[i - 1]) + sign(s[i])) * Math.min(Math.abs(s[i - 1]), Math.abs(s[i]), 0.5 * Math.abs(p));
+  }
+  let end = (a, b, ha, hb) => {
+    if (ha <= 0)
+      return 0;
+    let p = a * (1 + ha / (ha + hb)) - b * ha / (ha + hb);
+    if (sign(p) !== sign(a))
+      return 0;
+    return Math.abs(p) > 2 * Math.abs(a) ? 2 * a : p;
+  };
+  return m[0] = end(s[0], s[1], h[0], h[1]), m[n - 1] = end(s[n - 2], s[n - 3], h[n - 2], h[n - 3]), m;
+}
+function prepareCurve(points, interp) {
+  let xs = points.map((p) => p.x), ys = points.map((p) => p.y), m = interp === "smooth" ? tangents(xs, ys) : [], n = xs.length;
+  return (x) => {
+    if (!n)
+      return 0;
+    if (x <= xs[0])
+      return ys[0];
+    if (x >= xs[n - 1])
+      return ys[n - 1];
+    let i = 0;
+    while (i < n - 2 && xs[i + 1] <= x)
+      i++;
+    let x0 = xs[i], span = xs[i + 1] - x0;
+    if (interp === "step" || span <= 0)
+      return ys[i];
+    let t = (x - x0) / span;
+    if (interp === "linear")
+      return ys[i] + (ys[i + 1] - ys[i]) * t;
+    let t2 = t * t, t3 = t2 * t;
+    return (2 * t3 - 3 * t2 + 1) * ys[i] + (t3 - 2 * t2 + t) * span * m[i] + (-2 * t3 + 3 * t2) * ys[i + 1] + (t3 - t2) * span * m[i + 1];
+  };
+}
+function sampleCurve(points, x, options = {}) {
+  return prepareCurve(points, options.interp ?? "smooth")(Number.isFinite(x) ? x : 0);
+}
+var CURVE_SHAPES = {
+  linear: [
+    { x: 0, y: 0 },
+    { x: 1, y: 1 }
+  ],
+  "ease-out": [
+    { x: 0, y: 0 },
+    { x: 0.35, y: 0.62 },
+    { x: 1, y: 1 }
+  ],
+  "inverse²": [
+    { x: 0, y: 1 },
+    { x: 0.1, y: 0.85 },
+    { x: 0.25, y: 0.47 },
+    { x: 0.5, y: 0.15 },
+    { x: 1, y: 0 }
+  ],
+  smoothstep: [
+    { x: 0, y: 0 },
+    { x: 0.25, y: 0.156 },
+    { x: 0.5, y: 0.5 },
+    { x: 0.75, y: 0.844 },
+    { x: 1, y: 1 }
+  ],
+  bell: [
+    { x: 0, y: 0 },
+    { x: 0.25, y: 0.25 },
+    { x: 0.5, y: 1 },
+    { x: 0.75, y: 0.25 },
+    { x: 1, y: 0 }
+  ]
+}, inRange = (shape, range) => shape.map((p) => ({ x: p.x, y: range[0] + p.y * (range[1] - range[0]) }));
+var between = (min, max, r) => min + (max - min) * r, signed = (random) => random() < 0.5 ? -1 : 1;
+function randomStops(count, random) {
+  let n = Math.max(2, count), hue = random() * 360, turn = signed(random) * between(20, 70, random()), rising = random() < 0.5, [l0, l1] = [between(0.2, 0.4, random()), between(0.75, 0.95, random())], vivid = between(0.3, 0.9, random());
+  return Array.from({ length: n }, (_, i) => {
+    let t = i / (n - 1), jitter = i === 0 || i === n - 1 ? 0 : (random() - 0.5) * (0.5 / (n - 1)), at = clamp(t + jitter, 0, 1), l = rising ? l0 + (l1 - l0) * t : l1 + (l0 - l1) * t, h = (hue + turn * t + 360) % 360, c = vivid * maxChroma(l, h) * between(0.7, 1, random());
+    return { at, color: formatColor(fitColor({ l, c, h })) };
+  });
+}
+function mutateStops(stops, random, hue, lightness) {
+  let out = stops.map((s) => ({ ...s }));
+  for (let [i, s] of out.entries()) {
+    let c = parseColor(s.color) ?? { l: 0.5, c: 0, h: 0 }, max0 = maxChroma(c.l, c.h), rel = max0 > 0.0001 ? clamp(c.c / max0, 0, 1) : 0.5, h = (c.h + signed(random) * between(hue[0], hue[1], random()) + 360) % 360, l = clamp(c.l + signed(random) * between(lightness[0], lightness[1], random()), 0, 1), r = clamp(rel + signed(random) * between(0.04, 0.1, random()), 0, 1);
+    s.color = formatColor(fitColor({ l, c: r * maxChroma(l, h), h }));
+    let lo = i > 0 ? out[i - 1].at : 0, hi = i < out.length - 1 ? stops[i + 1].at : 1;
+    s.at = round4(clamp(s.at + signed(random) * between(0.02, 0.05, random()), lo, hi));
+  }
+  return out;
+}
+function randomPoints(range, random) {
+  let shapes = Object.values(CURVE_SHAPES), shape = shapes[Math.floor(Math.min(0.999999, random()) * shapes.length)], flip = random() < 0.3;
+  return inRange(shape.map((p, i) => ({
+    x: p.x,
+    y: i === 0 || i === shape.length - 1 ? flip ? 1 - p.y : p.y : clamp((flip ? 1 - p.y : p.y) + (random() - 0.5) * 0.12, 0, 1)
+  })), range);
+}
+function mutatePoints(points, range, random, share) {
+  let span = range[1] - range[0], out = points.map((p) => ({ ...p }));
+  for (let [i, p] of out.entries()) {
+    let by = span * between(share[0], share[1], random()) * 0.6, y = p.y + signed(random) * by;
+    if (y > range[1] || y < range[0])
+      y = p.y - (y - p.y);
+    if (p.y = clamp(y, range[0], range[1]), i === 0 || i === out.length - 1)
+      continue;
+    let lo = out[i - 1].x + 0.01, hi = points[i + 1].x - 0.01;
+    if (hi > lo)
+      p.x = round4(clamp(p.x + signed(random) * between(0.02, 0.05, random()), lo, hi));
+  }
+  return out;
+}
+
+// src/core/schema.ts
+var META_KEYS = [
+  "label",
+  "group",
+  "groupLabel",
+  "section",
+  "sectionLabel",
+  "groupDescription",
+  "sectionDescription",
+  "shortcut",
+  "random",
+  "disabled",
+  "readOnly",
+  "folded",
+  "sectionFolded",
+  "tab",
+  "subsection"
+];
+function pickMeta(source, skip = []) {
+  let out = {};
+  if (source) {
+    for (let k of META_KEYS)
+      if (source[k] !== void 0 && !skip.includes(k))
+        out[k] = source[k];
+  }
+  return out;
+}
+var READOUT_KINDS = /* @__PURE__ */ new Set(["watch", "sparkline", "graph", "meter", "table", "log"]), isReadout = (field) => READOUT_KINDS.has(field.kind), hasValue = (field) => field.kind !== "action" && field.kind !== "toolbar" && !READOUT_KINDS.has(field.kind), SPRING = {
+  duration: { min: 0.05, max: 2, step: 0.01 },
+  bounce: { min: -0.5, max: 1, step: 0.01 }
+};
+function checkShortcut(shortcut) {
+  if (shortcut !== void 0 && !/^[a-z]$/i.test(shortcut))
+    throw Error("Shortcut must be a letter.");
+}
+function valueKeys(schema) {
+  return Object.keys(schema).filter((k) => hasValue(schema[k]));
+}
+function withMeta(base, meta) {
+  return checkShortcut(meta?.shortcut), Object.freeze({ ...base, ...pickMeta(meta) });
+}
+function knob(value, options) {
+  let step = options.step ?? ((options.max - options.min) / 100 || 1);
+  if (![value, options.min, options.max, step].every(Number.isFinite) || options.max < options.min || step <= 0)
+    throw Error("A knob needs finite bounds and a positive step.");
+  if (options.decimals !== void 0 && !(Number.isInteger(options.decimals) && options.decimals >= 0))
+    throw Error("A knob's decimals must be a whole number.");
+  checkShortcut(options.shortcut);
+  let field = { ...options, kind: "knob", value, step };
+  return Object.freeze({ ...field, value: normalizeField(field, value) });
+}
+function choice(value, options, meta) {
+  if (!options.includes(value) || new Set(options).size !== options.length)
+    throw Error("Invalid choice options/default.");
+  let labels = meta?.labels ? Object.freeze(Object.fromEntries(Object.entries(meta.labels).filter(([k, v]) => options.includes(k) && typeof v === "string" && v !== k))) : void 0;
+  return withMeta({
+    kind: "choice",
+    value,
+    options: Object.freeze([...options]),
+    ...labels && Object.keys(labels).length ? { labels } : {},
+    ...meta?.display ? { display: meta.display } : {}
+  }, meta);
+}
+function action(label, meta) {
+  let { shortcut, global, rebind, run, ...rest } = meta ?? {}, key = shortcutOf({ ...shortcut ? { shortcut } : {}, ...global ? { global } : {} }), combo = key ? normalizeCombo(key.key) : "";
+  if (key && !combo)
+    throw Error("An action's shortcut must name a key.");
+  return withMeta({
+    kind: "action",
+    ...run ? { run } : {},
+    ...key ? { shortcut: combo, scope: key.scope } : {},
+    ...rebind ? { rebind: !0 } : {}
+  }, { ...rest, ...label !== void 0 ? { label } : {} });
+}
+function flatSpring(parts = {}, meta = {}) {
+  let id = meta.id ?? meta.label ?? `spring-${++springIds}`, half = (part, input, fallback) => {
+    let base = typeof input === "object" ? input : knob(input ?? fallback, {
+      ...SPRING[part],
+      ...part === "duration" ? { unit: "s" } : {}
+    });
+    return Object.freeze({
+      ...base,
+      ...base.label === void 0 ? { label: part === "duration" ? "Duration" : "Bounce" } : {},
+      ...pickMeta(meta, ["label", "shortcut"]),
+      spring: Object.freeze({
+        id,
+        part,
+        ...meta.label !== void 0 ? { label: meta.label } : {}
+      })
+    });
+  };
+  return {
+    duration: half("duration", parts.duration, 0.5),
+    bounce: half("bounce", parts.bounce, 0)
+  };
+}
+var springIds = 0;
+function toggle(value, meta) {
+  return withMeta({ kind: "toggle", value }, { ...meta, random: meta?.random ?? !1 });
+}
+function spring(value = {}, meta) {
+  let field = { kind: "spring", value: { duration: 0.5, bounce: 0 } };
+  return withMeta({ ...field, value: normalizeField(field, value) }, meta);
+}
+function color(value, meta) {
+  let parsed = parseColor(value);
+  if (!parsed)
+    throw Error("A color needs #rgb, #rrggbb, oklch(L C H) or { l, c, h }.");
+  return withMeta({ kind: "color", value: formatColor(fitColor(parsed)) }, meta);
+}
+var axes = (v) => typeof v === "number" ? { x: v, y: v } : v;
+function point(value, options) {
+  let min = axes(options.min), max = axes(options.max), step = options.step === void 0 ? void 0 : axes(options.step), field = {
+    kind: "point",
+    value,
+    min: Object.freeze({ ...min }),
+    max: Object.freeze({ ...max }),
+    step: Object.freeze({
+      x: step?.x ?? ((max.x - min.x) / 100 || 1),
+      y: step?.y ?? ((max.y - min.y) / 100 || 1)
+    })
+  };
+  if (![value.x, value.y, min.x, min.y, max.x, max.y, field.step.x, field.step.y].every(Number.isFinite) || max.x < min.x || max.y < min.y || field.step.x <= 0 || field.step.y <= 0)
+    throw Error("A point needs finite bounds and positive steps.");
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function easing(value, meta) {
+  let curve = typeof value === "string" ? namedEasing(value) : value;
+  if (!curve || curve.length !== 4 || !curve.every(Number.isFinite))
+    throw Error("An easing needs four finite numbers or a known name.");
+  let field = { kind: "easing", value: curve };
+  return withMeta({ ...field, value: normalizeField(field, curve) }, meta);
+}
+function bounds(o, what) {
+  let step = o.step ?? ((o.max - o.min) / 100 || 1);
+  if (![o.min, o.max, step].every(Number.isFinite) || o.max < o.min || step <= 0)
+    throw Error(`${what} needs finite bounds and a positive step.`);
+  if (o.decimals !== void 0 && !(Number.isInteger(o.decimals) && o.decimals >= 0))
+    throw Error(`${what}'s decimals must be a whole number.`);
+  return step;
+}
+var numberMeta = (o) => ({
+  ...o.unit !== void 0 ? { unit: o.unit } : {},
+  ...o.decimals !== void 0 ? { decimals: o.decimals } : {}
+});
+function vec(axes, value, options) {
+  let step = bounds(options, "A vector"), names = options.axes;
+  if (names && (names.length !== axes || names.some((n) => typeof n !== "string" || !n.trim())))
+    throw Error(`A vector's axes need ${axes} names.`);
+  let field = {
+    kind: "vec",
+    axes,
+    value,
+    min: options.min,
+    max: options.max,
+    step,
+    ...numberMeta(options),
+    ...options.link || options.linked ? { link: !0 } : {},
+    ...options.linked ? { linked: !0 } : {},
+    ...names ? { axisLabels: Object.freeze(names.map((n) => n.trim())) } : {}
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function vec2(value, options) {
+  return vec(2, value, options);
+}
+function vec3(value, options) {
+  return vec(3, value, options);
+}
+function range(value, options) {
+  let step = bounds(options, "A range"), field = {
+    kind: "range",
+    value,
+    min: options.min,
+    max: options.max,
+    step,
+    ...numberMeta(options)
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function angle(value, options = {}) {
+  let min = options.min ?? 0, max = options.max ?? 360, step = options.step ?? 1;
+  bounds({ min, max, step }, "An angle");
+  let field = {
+    kind: "angle",
+    value,
+    min,
+    max,
+    step,
+    wrap: options.wrap ?? max - min === 360
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function seed(value, options = {}) {
+  let field = {
+    kind: "seed",
+    value,
+    min: Math.ceil(options.min ?? 0),
+    max: Math.floor(options.max ?? 999999)
+  };
+  return bounds({ min: field.min, max: field.max, step: 1 }, "A seed"), withMeta({ ...field, value: normalizeField(field, value) }, { random: !1, ...options });
+}
+function keybind(value = "", meta) {
+  let field = { kind: "keybind", value: normalizeCombo(value) };
+  return withMeta(field, { random: !1, ...meta });
+}
+function gradient(stops, options = {}) {
+  let value = normalizeStops(stops);
+  if (!value)
+    throw Error("A gradient needs at least two stops with a position and a colour.");
+  let presets = options.presets ? Object.freeze(Object.fromEntries(Object.entries(options.presets).flatMap(([name, p]) => {
+    let s = normalizeStops(p);
+    return s ? [[name, s]] : [];
+  }))) : void 0;
+  return withMeta({
+    kind: "gradient",
+    value,
+    space: options.space ?? "oklab",
+    ...presets && Object.keys(presets).length ? { presets } : {}
+  }, options);
+}
+function curve(points, options = {}) {
+  let range = options.range ?? [0, 1];
+  if (!(Number.isFinite(range[0]) && Number.isFinite(range[1]) && range[1] > range[0]))
+    throw Error("A curve's range needs finite bounds, max above min.");
+  let given = typeof points === "string" ? inRange(CURVE_SHAPES[points], range) : points, value = normalizePoints(given, range);
+  if (!value)
+    throw Error("A curve needs at least two points.");
+  let presets = options.presets ? Object.freeze(Object.fromEntries(Object.entries(options.presets).flatMap(([name, p]) => {
+    let s = normalizePoints(p, range);
+    return s ? [[name, s]] : [];
+  }))) : void 0;
+  return withMeta({
+    kind: "curve",
+    value,
+    range: Object.freeze([range[0], range[1]]),
+    interp: options.interp ?? "smooth",
+    shapes: options.shapes ?? !0,
+    ...presets && Object.keys(presets).length ? { presets } : {}
+  }, options);
+}
+function shortcutOf(o) {
+  let s = o.shortcut;
+  if (!s)
+    return;
+  if (typeof s === "string")
+    return { key: s, scope: o.global ? "page" : "panel" };
+  return s.key ? { key: s.key, scope: s.scope ?? (o.global ? "page" : "panel") } : void 0;
+}
+function toolbarShortcut(item) {
+  return shortcutOf(item);
+}
+function actionShortcut(field) {
+  return field.shortcut ? { key: field.shortcut, scope: field.scope ?? "panel" } : void 0;
+}
+function toolbar(items, meta) {
+  if (!items.length)
+    throw Error("A toolbar needs at least one item.");
+  return withMeta({
+    kind: "toolbar",
+    items: Object.freeze(items.map((item) => Object.freeze({ ...item })))
+  }, meta);
+}
+var readoutMeta = (o) => {
+  if (o.decimals !== void 0 && !(Number.isInteger(o.decimals) && o.decimals >= 0))
+    throw Error("A readout's decimals must be a whole number.");
+  if (o.hz !== void 0 && !(o.hz > 0))
+    throw Error("A readout's hz must be above 0.");
+  return {
+    ...pickMeta(o),
+    ...o.get ? { get: o.get } : {},
+    ...o.unit !== void 0 ? { unit: o.unit } : {},
+    ...o.decimals !== void 0 ? { decimals: o.decimals } : {},
+    ...o.format ? { format: o.format } : {},
+    ...o.hz !== void 0 ? { hz: o.hz } : {}
+  };
+}, whole = (n, fallback, what) => {
+  let v = n ?? fallback;
+  if (!(Number.isInteger(v) && v > 0))
+    throw Error(`${what} must be a whole number above 0.`);
+  return v;
+};
+function watch(options = {}) {
+  return Object.freeze({ kind: "watch", ...readoutMeta(options) });
+}
+function sparkline(options = {}) {
+  return Object.freeze({
+    kind: "sparkline",
+    ...readoutMeta(options),
+    history: whole(options.history, 60, "A sparkline's history"),
+    ...options.min !== void 0 ? { min: options.min } : {},
+    ...options.max !== void 0 ? { max: options.max } : {},
+    ...options.color ? { color: options.color } : {}
+  });
+}
+function graph(options = {}) {
+  let series = (options.series ?? [{ id: "value" }]).map((s) => Object.freeze(typeof s === "string" ? { id: s } : { ...s }));
+  if (!series.length || new Set(series.map((s) => s.id)).size !== series.length)
+    throw Error("A graph needs series with distinct ids.");
+  return Object.freeze({
+    kind: "graph",
+    ...readoutMeta(options),
+    series: Object.freeze(series),
+    history: whole(options.history, 120, "A graph's history"),
+    height: whole(options.height, 64, "A graph's height"),
+    ...options.min !== void 0 ? { min: options.min } : {},
+    ...options.max !== void 0 ? { max: options.max } : {},
+    thresholds: Object.freeze((options.thresholds ?? []).map((t) => Object.freeze(typeof t === "number" ? { value: t } : t)))
+  });
+}
+function meter(options = {}) {
+  let min = options.min ?? 0, max = options.max ?? 1;
+  if (!(Number.isFinite(min) && Number.isFinite(max) && max > min))
+    throw Error("A meter needs finite bounds, max above min.");
+  return Object.freeze({
+    kind: "meter",
+    ...readoutMeta(options),
+    min,
+    max,
+    ...options.segments !== void 0 ? { segments: whole(options.segments, 1, "A meter's segments") } : {},
+    ...options.warn !== void 0 ? { warn: options.warn } : {},
+    ...options.critical !== void 0 ? { critical: options.critical } : {}
+  });
+}
+function table(options = {}) {
+  if (options.columns && (options.columns.length < 1 || options.columns.length > 6))
+    throw Error("A table takes 1–6 columns.");
+  return Object.freeze({
+    kind: "table",
+    ...readoutMeta(options),
+    ...options.columns ? { columns: Object.freeze([...options.columns]) } : {}
+  });
+}
+function log(options = {}) {
+  return Object.freeze({
+    kind: "log",
+    ...readoutMeta(options),
+    lines: whole(options.lines, 8, "A log's lines"),
+    max: whole(options.max, 1000, "A log's max")
+  });
+}
+var keep = (v, min, max, step) => {
+  let clamped = Math.min(max, Math.max(min, v));
+  return Number.isInteger(step) && Number.isInteger(min) ? Math.round(clamped) : Number(clamped.toPrecision(14));
+}, wrapAngle = (v, min, max) => {
+  let span = max - min;
+  return span > 0 ? ((v - min) % span + span) % span + min : min;
+}, snap = (v, min, max, step) => {
+  let bounded = Math.max(min, Math.min(max, v)), steps = Math.min(Math.floor((max - min) / step + 0.000000001), Math.round((bounded - min) / step));
+  return Number((min + steps * step).toPrecision(14));
+}, num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+function normalizeField(field, input) {
+  switch (field.kind) {
+    case "knob":
+      if (typeof input !== "number" || !Number.isFinite(input))
+        return field.value;
+      {
+        let clamped = Math.min(field.max, Math.max(field.min, input));
+        return Number.isInteger(field.step) && Number.isInteger(field.min) ? Math.round(clamped) : Number(clamped.toPrecision(14));
+      }
+    case "choice":
+      return typeof input === "string" && field.options.includes(input) ? input : field.value;
+    case "toggle":
+      return typeof input === "boolean" ? input : field.value;
+    case "spring": {
+      let v = isRecord(input) ? input : {}, { duration: d, bounce: b } = SPRING;
+      return Object.freeze({
+        duration: snap(num(v.duration, field.value.duration), d.min, d.max, d.step),
+        bounce: snap(num(v.bounce, field.value.bounce), b.min, b.max, b.step)
+      });
+    }
+    case "color": {
+      let parsed = parseColor(input);
+      return parsed ? formatColor(fitColor(parsed)) : field.value;
+    }
+    case "point": {
+      let v = isRecord(input) ? input : {};
+      return Object.freeze({
+        x: snap(num(v.x, field.value.x), field.min.x, field.max.x, field.step.x),
+        y: snap(num(v.y, field.value.y), field.min.y, field.max.y, field.step.y)
+      });
+    }
+    case "easing": {
+      let v = Array.isArray(input) && input.length === 4 ? input : field.value;
+      return Object.freeze([0, 1, 2, 3].map((i) => i % 2 === 0 ? snap(num(v[i], field.value[i]), 0, 1, 0.01) : snap(num(v[i], field.value[i]), EASING_Y[0], EASING_Y[1], 0.01)));
+    }
+    case "vec": {
+      let v = isRecord(input) ? input : {}, base = field.value, axis = (k) => keep(num(v[k], base[k] ?? 0), field.min, field.max, field.step);
+      return Object.freeze(field.axes === 3 ? { x: axis("x"), y: axis("y"), z: axis("z") } : { x: axis("x"), y: axis("y") });
+    }
+    case "range": {
+      let v = Array.isArray(input) && input.length === 2 ? input : field.value, a = keep(num(v[0], field.value[0]), field.min, field.max, field.step), b = keep(num(v[1], field.value[1]), field.min, field.max, field.step);
+      return Object.freeze([Math.min(a, b), Math.max(a, b)]);
+    }
+    case "angle": {
+      if (typeof input !== "number" || !Number.isFinite(input))
+        return field.value;
+      let v = field.wrap ? wrapAngle(input, field.min, field.max) : input, kept = keep(v, field.min, field.max, field.step);
+      return field.wrap && kept >= field.max ? field.min : kept;
+    }
+    case "seed":
+      return typeof input === "number" && Number.isFinite(input) ? Math.round(Math.min(field.max, Math.max(field.min, input))) : field.value;
+    case "keybind":
+      return typeof input === "string" ? normalizeCombo(input) : field.value;
+    case "gradient":
+      return normalizeStops(input) ?? field.value;
+    case "curve":
+      return normalizePoints(input, field.range) ?? field.value;
+  }
+}
+function normalize(schema, input) {
+  let record = isRecord(input) ? input : {};
+  return Object.freeze(Object.fromEntries(Object.entries(schema).flatMap(([key, field]) => hasValue(field) ? [[key, normalizeField(field, record[key])]] : [])));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function same(a, b) {
+  if (a === b)
+    return !0;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+    return !1;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return !1;
+  let ka = Object.keys(a);
+  return ka.length === Object.keys(b).length && ka.every((k) => same(a[k], b[k]));
+}
+function equal(a, b) {
+  return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((key) => same(a[key], b[key]));
+}
+// src/core/spring.ts
+class Spring {
+  x;
+  omega;
+  zeta;
+  eps;
+  v = 0;
+  target;
+  next;
+  constructor(x, omega = 24, zeta = 0.86, eps = 0.005) {
+    this.x = x;
+    this.omega = omega;
+    this.zeta = zeta;
+    this.eps = eps;
+    this.target = x;
+  }
+  set(target, delay = 0) {
+    if (delay > 0) {
+      if (target !== (this.next?.target ?? this.target))
+        this.next = { target, at: performance.now() + delay };
+      return this;
+    }
+    return this.next = void 0, this.target = target, this;
+  }
+  snap(x) {
+    return this.next = void 0, this.x = this.target = x, this.v = 0, this;
+  }
+  step(dt) {
+    if (this.next && performance.now() >= this.next.at)
+      this.target = this.next.target, this.next = void 0;
+    if (this.x === this.target && this.v === 0)
+      return this.x;
+    let clampedDt = Math.min(dt, 0.1), h = 0.0020833333333333333;
+    for (let t = 0;t < clampedDt; t += h) {
+      let k = Math.min(h, clampedDt - t), a = -this.omega * this.omega * (this.x - this.target) - 2 * this.zeta * this.omega * this.v;
+      this.v += a * k, this.x += this.v * k;
+    }
+    if (this.resting)
+      this.x = this.target, this.v = 0;
+    return this.x;
+  }
+  get resting() {
+    return !this.next && Math.abs(this.x - this.target) < this.eps && Math.abs(this.v) < this.eps * 4;
+  }
+}
+function springMotion({ duration, bounce }) {
+  return {
+    omega: 2 * Math.PI / Math.max(0.01, duration),
+    zeta: bounce >= 0 ? 1 - bounce : 1 / (1 + bounce)
+  };
+}
+function springEasing(omega, zeta) {
+  let s = new Spring(0, omega, zeta).set(1), points = ["0"], dt = 0.016666666666666666, t = 0;
+  while (t < 4 && !(Math.abs(s.x - 1) < 0.002 && Math.abs(s.v) < 0.05))
+    s.step(0.016666666666666666), t += 0.016666666666666666, points.push(String(Math.round(s.x * 1000) / 1000));
+  return points[points.length - 1] = "1", { easing: `linear(${points.join(",")})`, ms: Math.round(t * 1000) };
+}
+function springCss(value) {
+  let { omega, zeta } = springMotion(value), { easing, ms } = springEasing(omega, zeta);
+  return { easing, duration: ms };
+}
+// src/core/random.ts
+var lattice = (min, max, step, r) => min + Math.floor(r * (Math.floor((max - min) / step + 0.000000001) + 1)) * step, between2 = (min, max, r) => min + (max - min) * r;
+function pick(field, random) {
+  let r = () => Math.max(0, Math.min(1 - Number.EPSILON, random()));
+  switch (field.kind) {
+    case "knob":
+      return lattice(field.min, field.max, field.step, r());
+    case "choice":
+      return field.options[Math.floor(r() * field.options.length)];
+    case "toggle":
+      return r() >= 0.5;
+    case "spring":
+      return { duration: between2(0.2, 0.9, r()), bounce: between2(0, 0.45, r()) };
+    case "color": {
+      let l = between2(0.5, 0.85, r()), h = between2(0, 360, r());
+      return { l, c: between2(0.25, 0.85, r()) * maxChroma(l, h), h };
+    }
+    case "point":
+      return {
+        x: lattice(field.min.x, field.max.x, field.step.x, r()),
+        y: lattice(field.min.y, field.max.y, field.step.y, r())
+      };
+    case "easing": {
+      let curves = Object.values(EASINGS);
+      return curves[Math.floor(r() * curves.length)];
+    }
+    case "vec": {
+      let axis = () => lattice(field.min, field.max, field.step, r());
+      return field.axes === 3 ? { x: axis(), y: axis(), z: axis() } : { x: axis(), y: axis() };
+    }
+    case "range":
+      return [
+        lattice(field.min, field.max, field.step, r()),
+        lattice(field.min, field.max, field.step, r())
+      ];
+    case "angle": {
+      let top = field.wrap ? field.max - field.step : field.max;
+      return lattice(field.min, Math.max(field.min, top), field.step, r());
+    }
+    case "seed":
+      return lattice(field.min, field.max, 1, r());
+    case "keybind":
+      return field.value;
+    case "gradient":
+      return randomStops(field.value.length, r);
+    case "curve":
+      return randomPoints(field.range, r);
+  }
+}
+var AROUND = {
+  spread: 0.35,
+  switch: 0.3,
+  hue: 20,
+  lightness: 0.06,
+  chroma: 0.15
+};
+function near(v, min, max, step, r, reach = max - min) {
+  let span = max - min;
+  if (!(span > 0))
+    return v;
+  let width = Math.min(span, reach * AROUND.spread), lo = Math.max(min, Math.min(max - width, v - width / 2)), top = Math.floor(span / step + 0.000000001), a = Math.max(0, Math.ceil((lo - min) / step - 0.000000001)), b = Math.min(top, Math.floor((lo + width - min) / step + 0.000000001)), n = b < a ? Math.round((v - min) / step) : a + Math.floor(r * (b - a + 1));
+  return Number((min + Math.max(0, Math.min(top, n)) * step).toPrecision(14));
+}
+var unit = (r) => r * 2 - 1;
+function around(field, base, random) {
+  let r = () => Math.max(0, Math.min(1 - Number.EPSILON, random()));
+  switch (field.kind) {
+    case "knob":
+      return near(base, field.min, field.max, field.step, r());
+    case "choice": {
+      if (field.options.length < 2 || r() >= AROUND.switch)
+        return base;
+      let rest = field.options.filter((o) => o !== base);
+      return rest[Math.floor(r() * rest.length)];
+    }
+    case "toggle":
+      return r() < AROUND.switch ? !base : base;
+    case "spring": {
+      let s = base, d = SPRING.duration, b = SPRING.bounce;
+      return {
+        duration: near(s.duration, d.min, d.max, d.step, r(), 0.7),
+        bounce: near(s.bounce, b.min, b.max, b.step, r(), 0.45)
+      };
+    }
+    case "color": {
+      let c = parseColor(base) ?? { l: 0.7, c: 0.1, h: 0 }, max0 = maxChroma(c.l, c.h), rel = max0 > 0.0001 ? Math.min(1, Math.max(0, c.c / max0)) : 0.5, h = (c.h + unit(r()) * AROUND.hue + 360) % 360, l = Math.min(1, Math.max(0, c.l + unit(r()) * AROUND.lightness)), k = Math.min(1, Math.max(0, rel + unit(r()) * AROUND.chroma));
+      return { l, c: k * maxChroma(l, h), h };
+    }
+    case "point": {
+      let p = base;
+      return {
+        x: near(p.x, field.min.x, field.max.x, field.step.x, r()),
+        y: near(p.y, field.min.y, field.max.y, field.step.y, r())
+      };
+    }
+    case "easing":
+      return base.map((v, i) => {
+        let [lo, hi] = i % 2 === 0 ? [0, 1] : EASING_Y;
+        return near(v, lo, hi, 0.001, r());
+      });
+    case "vec": {
+      let v = base, axis = (n) => near(n, field.min, field.max, field.step, r());
+      return field.axes === 3 ? { x: axis(v.x), y: axis(v.y), z: axis(v.z ?? 0) } : { x: axis(v.x), y: axis(v.y) };
+    }
+    case "range": {
+      let [a, b] = base;
+      return [
+        near(a, field.min, field.max, field.step, r()),
+        near(b, field.min, field.max, field.step, r())
+      ];
+    }
+    case "angle": {
+      let v = base;
+      if (!field.wrap)
+        return near(v, field.min, field.max, field.step, r());
+      let span = field.max - field.min;
+      return v + unit(r()) * span * (AROUND.spread / 2);
+    }
+    case "gradient":
+      return mutateStops(base, r, [AROUND.hue / 2, AROUND.hue], [AROUND.lightness / 2, AROUND.lightness]);
+    case "curve":
+      return mutatePoints(base, field.range, r, [
+        AROUND.spread / 2,
+        AROUND.spread
+      ]);
+    case "seed":
+    case "keybind":
+      return pick(field, random);
+  }
+}
+function randomValues(schema, random = Math.random) {
+  return normalize(schema, Object.fromEntries(Object.entries(schema).flatMap(([key, field]) => hasValue(field) ? [[key, pick(field, random)]] : [])));
+}
+// src/core/code.ts
+var literal = (value) => Array.isArray(value) ? `[${value.map(literal).join(", ")}]` : typeof value === "object" && value !== null ? `{ ${Object.entries(value).map(([k, v]) => `${k}: ${literal(v)}`).join(", ")} }` : JSON.stringify(value);
+function formatCode(values, format = "ts") {
+  if (format === "json")
+    return JSON.stringify(values, null, 2);
+  if (format === "jsx")
+    return Object.entries(values).map(([key, value]) => {
+      if (!/^[A-Za-z_$][\w$-]*$/.test(key))
+        throw Error(`Cannot serialize JSX prop: ${key}`);
+      return `${key}={${literal(value)}}`;
+    }).join(" ");
+  return `{ ${Object.entries(values).map(([key, value]) => `${/^[A-Za-z_$][\w$]*$/.test(key) && key !== "__proto__" ? key : `[${JSON.stringify(key)}]`}: ${literal(value)}`).join(", ")} }`;
+}
+
+// src/core/mutate.ts
+var MUTATE = {
+  min: 0.08,
+  max: 0.12,
+  flip: 0.15,
+  hue: [4, 12],
+  chroma: 0.02,
+  lightness: [0.015, 0.045],
+  bezier: [0.03, 0.06]
+}, between3 = (min, max, r) => min + (max - min) * r, signed2 = (random) => random() < 0.5 ? -1 : 1;
+function nudge(v, min, max, step, random, reach = max - min) {
+  let span = max - min;
+  if (!(span > 0))
+    return v;
+  let sign = signed2(random), by = reach * between3(MUTATE.min, MUTATE.max, random()), next = v + sign * by;
+  if (next > max || next < min)
+    next = v - sign * by;
+  let top = Math.floor(span / step + 0.000000001), at = (n) => Number((min + n * step).toPrecision(14)), steps = Math.max(0, Math.min(top, Math.round((next - min) / step)));
+  if (at(steps) === v) {
+    let dir = next >= v ? 1 : -1;
+    steps = Math.max(0, Math.min(top, steps + (steps + dir > top || steps + dir < 0 ? -dir : dir)));
+  }
+  return at(steps);
+}
+function shift(field, value, random) {
+  switch (field.kind) {
+    case "knob":
+      return nudge(value, field.min, field.max, field.step, random);
+    case "point": {
+      let p = value;
+      return {
+        x: nudge(p.x, field.min.x, field.max.x, field.step.x, random),
+        y: nudge(p.y, field.min.y, field.max.y, field.step.y, random)
+      };
+    }
+    case "spring": {
+      let s = value, d = SPRING.duration, b = SPRING.bounce;
+      return {
+        duration: nudge(s.duration, d.min, d.max, d.step, random, 0.7),
+        bounce: nudge(s.bounce, b.min, b.max, b.step, random, 0.45)
+      };
+    }
+    case "color": {
+      let c = parseColor(value) ?? { l: 0.7, c: 0.1, h: 0 }, max0 = maxChroma(c.l, c.h), rel0 = max0 > 0.0001 ? Math.min(1, Math.max(0, c.c / max0)) : 0.5, h = (c.h + signed2(random) * between3(MUTATE.hue[0], MUTATE.hue[1], random()) + 360) % 360, l = Math.min(1, Math.max(0, c.l + signed2(random) * between3(MUTATE.lightness[0], MUTATE.lightness[1], random())));
+      return { l, c: nudge(rel0, 0, 1, 0.01, random) * maxChroma(l, h), h };
+    }
+    case "easing":
+      return value.map((v, i) => {
+        let [lo, hi] = i % 2 === 0 ? [0, 1] : EASING_Y, next = v + signed2(random) * between3(MUTATE.bezier[0], MUTATE.bezier[1], random());
+        return Math.min(hi, Math.max(lo, next));
+      });
+    case "choice": {
+      if (random() >= MUTATE.flip || field.options.length < 2)
+        return value;
+      return other(field.options, value, random);
+    }
+    case "toggle":
+      return random() < MUTATE.flip ? !value : value;
+    case "vec": {
+      let v = value, axis = (n) => nudge(n, field.min, field.max, field.step, random);
+      return field.axes === 3 ? { x: axis(v.x), y: axis(v.y), z: axis(v.z ?? 0) } : { x: axis(v.x), y: axis(v.y) };
+    }
+    case "range": {
+      let [a, b] = value;
+      return [
+        nudge(a, field.min, field.max, field.step, random),
+        nudge(b, field.min, field.max, field.step, random)
+      ];
+    }
+    case "angle": {
+      let v = value;
+      if (!field.wrap)
+        return nudge(v, field.min, field.max, field.step, random);
+      let span = field.max - field.min;
+      return v + signed2(random) * span * between3(MUTATE.min, MUTATE.max, random());
+    }
+    case "seed":
+      return nudge(value, field.min, field.max, 1, random);
+    case "keybind":
+      return value;
+    case "gradient":
+      return mutateStops(value, random, MUTATE.hue, MUTATE.lightness);
+    case "curve":
+      return mutatePoints(value, field.range, random, [
+        MUTATE.min,
+        MUTATE.max
+      ]);
+  }
+}
+var other = (options, value, random) => {
+  let rest = options.filter((o) => o !== value);
+  return rest[Math.floor(Math.min(0.999999, random()) * rest.length)] ?? value;
+};
+function mutateValues(schema, current, keys = valueKeys(schema), random = Math.random) {
+  let out = {}, changed = !1;
+  for (let key of keys) {
+    let field = schema[key];
+    if (!field || !hasValue(field))
+      continue;
+    let before = current[key] ?? field.value, next = normalizeField(field, shift(field, before, random));
+    if (out[key] = next, !same(before, next))
+      changed = !0;
+  }
+  if (!changed) {
+    let discrete = keys.filter((k) => {
+      let f = schema[k];
+      return f?.kind === "toggle" || f?.kind === "choice" && f.options.length > 1;
+    }), key = discrete[Math.floor(Math.min(0.999999, random()) * discrete.length)], field = key ? schema[key] : void 0;
+    if (key && field?.kind === "toggle")
+      out[key] = !(current[key] ?? field.value);
+    else if (key && field?.kind === "choice")
+      out[key] = other(field.options, String(current[key] ?? field.value), random);
+  }
+  return out;
+}
+
+// src/core/internal.ts
+var RESHAPE = Symbol.for("knobs.reshape"), RESET_KEYS = Symbol.for("knobs.resetKeys"), REFRESHES = Symbol.for("knobs.refreshes");
+
+// src/core/readout.ts
+class Ring {
+  capacity;
+  data;
+  start = 0;
+  length = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.data = new Float64Array(Math.max(1, capacity));
+  }
+  push(v) {
+    let cap = this.data.length;
+    if (this.length < cap)
+      this.data[(this.start + this.length++) % cap] = v;
+    else
+      this.data[this.start] = v, this.start = (this.start + 1) % cap;
+  }
+  at(i) {
+    return this.data[(this.start + i) % this.data.length];
+  }
+  last() {
+    return this.length ? this.at(this.length - 1) : Number.NaN;
+  }
+  clear() {
+    this.start = this.length = 0;
+  }
+  extent() {
+    let lo = 1 / 0, hi = -1 / 0;
+    for (let i = 0;i < this.length; i++) {
+      let v = this.at(i);
+      if (!Number.isFinite(v))
+        continue;
+      if (v < lo)
+        lo = v;
+      if (v > hi)
+        hi = v;
+    }
+    return lo <= hi ? [lo, hi] : [Number.NaN, Number.NaN];
+  }
+  toArray() {
+    return Array.from({ length: this.length }, (_, i) => this.at(i));
+  }
+}
+
+class EntryLog {
+  max;
+  entries = [];
+  total = 0;
+  constructor(max) {
+    this.max = max;
+  }
+  push(entry) {
+    let time = entry.time ?? Date.now();
+    if (this.entries.push({ ...entry, level: entry.level ?? "info", time, seq: this.total++ }), this.entries.length > this.max)
+      this.entries.splice(0, this.entries.length - this.max);
+  }
+  clear() {
+    this.entries = [];
+  }
+}
+function readoutState(field) {
+  if (field.kind === "sparkline")
+    return { seq: 0, value: null, series: /* @__PURE__ */ new Map([["", new Ring(field.history ?? 60)]]) };
+  if (field.kind === "graph")
+    return {
+      seq: 0,
+      value: null,
+      series: new Map((field.series ?? []).map((s) => [s.id, new Ring(field.history ?? 120)]))
+    };
+  if (field.kind === "log")
+    return { seq: 0, value: null, log: new EntryLog(field.max ?? 1000) };
+  return { seq: 0, value: null };
+}
+var levels = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]), asEntry = (v) => typeof v === "string" ? { text: v } : v && typeof v === "object" && typeof v.text === "string" ? {
+  text: v.text,
+  ...levels.has(v.level) ? { level: v.level } : {},
+  ...typeof v.time === "number" ? { time: v.time } : {}
+} : void 0;
+function pushReadout(field, state, value) {
+  if (state.seq++, value === null || value === void 0) {
+    state.value = null;
+    for (let ring of state.series?.values() ?? [])
+      ring.clear();
+    state.log?.clear();
+    return;
+  }
+  if (field.kind === "sparkline") {
+    let ring = state.series.get("");
+    if (Array.isArray(value)) {
+      ring.clear();
+      for (let v of value)
+        ring.push(Number(v));
+    } else
+      ring.push(Number(value));
+    state.value = ring.last();
+    return;
+  }
+  if (field.kind === "graph") {
+    let record = typeof value === "number" ? { [field.series?.[0]?.id ?? ""]: value } : value;
+    for (let [id, ring] of state.series) {
+      let v = record[id];
+      ring.push(typeof v === "number" ? v : Number.NaN);
+    }
+    state.value = record;
+    return;
+  }
+  if (field.kind === "log") {
+    let list = Array.isArray(value) ? value : [value];
+    for (let item of list) {
+      let entry = asEntry(item);
+      if (entry)
+        state.log.push(entry);
+    }
+    state.value = state.log.entries.at(-1) ?? null;
+    return;
+  }
+  state.value = value;
+}
+var READOUT = Symbol.for("knobs.readout");
+
+// src/core/storage.ts
+function memoryStorage() {
+  let data = /* @__PURE__ */ new Map;
+  return {
+    getItem: (key) => data.get(key) ?? null,
+    setItem: (key, value) => {
+      data.set(key, value);
+    }
+  };
+}
+function browserStorage() {
+  return typeof window > "u" ? null : window.localStorage;
+}
+function urlFlag(name) {
+  return () => typeof location < "u" && new URLSearchParams(location.search).has(name);
+}
+var storageKey = (id, part) => `knobs:${encodeURIComponent(id)}:${part}:v1`;
+
+// src/core/variants.ts
+function createVariants(schema, id, key, storage, get, set, notify, enabled) {
+  let ready = !1, list = Object.freeze([]);
+  function parse(json) {
+    let data = JSON.parse(json);
+    if (!isRecord(data) || data.version !== 1 || data.controls !== id || !Array.isArray(data.variants))
+      throw Error("Expected a version 1 export for these controls.");
+    let ids = /* @__PURE__ */ new Set;
+    return Object.freeze(data.variants.map((item) => {
+      if (!isRecord(item) || typeof item.id !== "string" || !item.id || ids.has(item.id))
+        throw Error("Variant IDs must be unique nonempty strings.");
+      if (ids.add(item.id), item.name !== void 0 && (typeof item.name !== "string" || item.name.length > 100))
+        throw Error("Variant names must be at most 100 characters.");
+      if (!isRecord(item.values))
+        throw Error("Invalid variant values.");
+      let values = normalize(schema(), item.values);
+      if (!equal(values, item.values))
+        throw Error("Variant values do not match the schema, bounds, or step.");
+      return Object.freeze({
+        id: item.id,
+        ...typeof item.name === "string" ? { name: item.name } : {},
+        values
+      });
+    }));
+  }
+  let encode = (variants) => JSON.stringify({ version: 1, controls: id, variants }, null, 2);
+  function read() {
+    if (ready || !enabled())
+      return;
+    let json = storage()?.getItem(key);
+    list = json ? parse(json) : Object.freeze([]), ready = !0;
+  }
+  function persist(next) {
+    if (!enabled())
+      throw Error("Controls are disabled.");
+    if (!ready)
+      throw Error("Read variants with list() before writing; unread storage will not be overwritten.");
+    storage()?.setItem(key, encode(next)), list = Object.freeze(next), notify();
+  }
+  return {
+    get ready() {
+      return ready;
+    },
+    list() {
+      return read(), list;
+    },
+    save(name) {
+      if (read(), name !== void 0 && name.length > 100)
+        throw Error("Variant names must be at most 100 characters.");
+      let variant = Object.freeze({
+        id: crypto.randomUUID(),
+        ...name?.trim() ? { name: name.trim() } : {},
+        values: get()
+      });
+      return persist([...list, variant]), variant;
+    },
+    load(id, options) {
+      read();
+      let variant = list.find((v) => v.id === id);
+      if (!variant)
+        throw Error(`Unknown variant: ${id}`);
+      set(variant.values, id, Boolean(options?.coalesce));
+    },
+    rename(id, name) {
+      if (read(), name.length > 100)
+        throw Error("Variant names must be at most 100 characters.");
+      let at = list.findIndex((v) => v.id === id);
+      if (at < 0)
+        throw Error(`Unknown variant: ${id}`);
+      let was = list[at], trimmed = name.trim();
+      if ((was.name ?? "") === trimmed)
+        return;
+      let next = [...list];
+      next[at] = Object.freeze({
+        id: was.id,
+        ...trimmed ? { name: trimmed } : {},
+        values: was.values
+      }), persist(next);
+    },
+    remove(id) {
+      read(), persist(list.filter((v) => v.id !== id));
+    },
+    export() {
+      return read(), encode(list);
+    },
+    import(json) {
+      if (!ready)
+        throw Error("Read variants with list() before importing; unread storage will not be overwritten.");
+      let incoming = parse(json), ids = new Set(list.map((v) => v.id));
+      persist([...list, ...incoming.filter((v) => !ids.has(v.id))]);
+    }
+  };
+}
+
+// src/core/store.ts
+var devBuild = () => !1;
+function sameField(a, b) {
+  if (a === b)
+    return !0;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+    return !1;
+  let ka = Object.keys(a).filter((k) => k !== "run"), kb = Object.keys(b).filter((k) => k !== "run");
+  if (ka.length !== kb.length)
+    return !1;
+  return ka.every((k) => {
+    let x = a[k], y = b[k];
+    if (typeof x === "function" && typeof y === "function")
+      return !0;
+    return Array.isArray(x) && Array.isArray(y) ? x.length === y.length && x.every((v, i) => same(v, y[i]) || sameField(v, y[i])) : same(x, y) || typeof x === "object" && sameField(x, y);
+  });
+}
+function defineControls(id, input, options = {}) {
+  if (!id.trim())
+    throw Error("Controls need a stable, nonempty id.");
+  let schema = Object.freeze({ ...input }), locked = normalize(schema, {}), actions = Object.freeze([...options.actions ?? []]), theme = options.theme ?? "dark", density = options.density ?? "default", renderer = options.renderer ?? "auto", enabled = () => Boolean(options.ship) && (typeof options.enabled === "function" ? options.enabled() : options.enabled ?? (Boolean(options.ship) || typeof location < "u" && ["localhost", "127.0.0.1", "[::1]"].includes(location.hostname))), storage = () => options.storage === void 0 ? browserStorage() : options.storage, persistMode = options.persist ?? "all", valueStorage = () => persistMode === "all" ? storage() : null, variantStorage = () => persistMode === "none" ? null : storage(), draw = options.random ?? Math.random, hostHistory = options.history, unsubscribeHistory, listeners = /* @__PURE__ */ new Set, refreshes = 0, notify = () => {
+    for (let cb of [...listeners])
+      cb();
+  }, mixed = /* @__PURE__ */ new Set, current = locked, read = !1, error = null, locks = /* @__PURE__ */ new Set, bindings = /* @__PURE__ */ new Map, comparing = null, landing = !1, echo = Math.max(0, options.echo ?? 0), grabbed = /* @__PURE__ */ new Set, changedAt = /* @__PURE__ */ new Map, sent = /* @__PURE__ */ new Map, pending = /* @__PURE__ */ new Map, echoTimer, now = () => typeof performance < "u" ? performance.now() : Date.now(), isHeld = (key) => grabbed.has(key) || echo > 0 && now() - (changedAt.get(key) ?? -1 / 0) < echo, NO_BASE = Object.freeze({ preset: null, groups: Object.freeze({}) }), base = NO_BASE, past = [], future = [], HISTORY = 100, stateKey = storageKey(id, "state"), buildPresets = () => Object.freeze(Object.fromEntries([
+    ["default", locked],
+    ...Object.entries(options.presets ?? {}).map(([id, patch]) => {
+      if (id === "default" || id === "custom")
+        throw Error(`Reserved preset id: ${id}`);
+      return [id, normalize(schema, { ...locked, ...patch })];
+    })
+  ])), presets = buildPresets(), buildGroupPresets = () => Object.freeze(Object.fromEntries(Object.entries(options.groupPresets ?? {}).map(([group, list]) => {
+    let named = list.flatMap((p) => Object.keys(p.values).filter((k) => Object.hasOwn(schema, k))), covered = new Set((named.length ? named : Object.keys(schema).filter((k) => schema[k].group === group)).filter((k) => hasValue(schema[k])));
+    return [
+      group,
+      Object.freeze(list.map((p) => Object.freeze({
+        name: p.name,
+        values: Object.freeze(Object.fromEntries([...covered].map((k) => [
+          k,
+          normalizeField(schema[k], p.values[k] ?? locked[k])
+        ])))
+      })))
+    ];
+  }))), groupPresets = buildGroupPresets(), labelsOf, fieldLabels = () => {
+    if (labelsOf?.schema === schema)
+      return labelsOf;
+    let group = /* @__PURE__ */ new Map, section = /* @__PURE__ */ new Map, groupText = /* @__PURE__ */ new Map, sectionText = /* @__PURE__ */ new Map, first = (map, id, text) => {
+      if (id !== void 0 && text !== void 0 && !map.has(id))
+        map.set(id, text);
+    };
+    for (let f of Object.values(schema))
+      first(group, f.group, f.groupLabel), first(section, f.section, f.sectionLabel), first(groupText, f.group, f.groupDescription), first(sectionText, f.section, f.sectionDescription);
+    return labelsOf = { schema, group, section, groupText, sectionText }, labelsOf;
+  };
+  function load() {
+    if (!read) {
+      read = !0;
+      try {
+        let raw = valueStorage()?.getItem(stateKey);
+        if (raw) {
+          let data = JSON.parse(raw);
+          if (data?.version === 1) {
+            if (current = normalize(schema, data.values), Array.isArray(data.locks))
+              locks = new Set(data.locks.filter((k) => typeof k === "string" && Object.hasOwn(schema, k)));
+            if (data.bindings && typeof data.bindings === "object")
+              bindings = new Map(Object.entries(data.bindings).flatMap(([id, combo]) => typeof combo === "string" && bindable(id) ? [[id, normalizeCombo(combo)]] : []));
+            base = readBase(data.base);
+          }
+        }
+      } catch (cause) {
+        error = String(cause);
+      }
+    }
+    return current;
+  }
+  function get() {
+    if (!enabled())
+      return locked;
+    return comparing ?? load();
+  }
+  function persist() {
+    try {
+      valueStorage()?.setItem(stateKey, JSON.stringify({
+        version: 1,
+        values: current,
+        ...locks.size ? { locks: [...locks] } : {},
+        ...bindings.size ? { bindings: Object.fromEntries(bindings) } : {},
+        ...base !== NO_BASE ? { base } : {}
+      })), error = null;
+    } catch (cause) {
+      error = String(cause);
+    }
+  }
+  function commit(next) {
+    current = next, persist(), notify();
+  }
+  let makeBase = (preset, groups) => preset === null && Object.keys(groups).length === 0 ? NO_BASE : Object.freeze({ preset, groups: Object.freeze({ ...groups }) }), sameBase = (a, b) => a === b || a.preset?.kind === b.preset?.kind && a.preset?.id === b.preset?.id && Object.keys(a.groups).length === Object.keys(b.groups).length && Object.entries(a.groups).every(([g, i]) => b.groups[g] === i);
+  function validBase(b) {
+    let preset = b.preset?.kind === "preset" && !(b.preset.id !== "default" && Object.hasOwn(presets, b.preset.id)) ? null : b.preset, groups = Object.fromEntries(Object.entries(b.groups).filter(([g, i]) => groupPresets[g]?.[i] !== void 0)), next = makeBase(preset, groups);
+    return sameBase(next, b) ? b : next;
+  }
+  function readBase(raw) {
+    if (!raw || typeof raw !== "object")
+      return NO_BASE;
+    let { preset, groups } = raw, ref = preset && typeof preset === "object" && (preset.kind === "preset" || preset.kind === "variant") && typeof preset.id === "string" ? Object.freeze({ kind: preset.kind, id: preset.id }) : null, byGroup = groups && typeof groups === "object" ? Object.fromEntries(Object.entries(groups).filter((e) => Number.isInteger(e[1]))) : {};
+    return validBase(makeBase(ref, byGroup));
+  }
+  function activeBase() {
+    load();
+    let ref = base.preset;
+    if (ref?.kind === "variant" && !variants.list().some((v) => v.id === ref.id))
+      base = makeBase(null, base.groups);
+    return base;
+  }
+  let hasBase = () => activeBase() !== NO_BASE, baseCache;
+  function baseValues() {
+    if (!enabled())
+      return locked;
+    let b = activeBase();
+    if (b === NO_BASE)
+      return locked;
+    let list = b.preset?.kind === "variant" ? variants.list() : null, c = baseCache;
+    if (c && c.base === b && c.schema === schema && c.presets === presets && c.groupPresets === groupPresets && c.variants === list)
+      return c.values;
+    let out = locked, ref = b.preset;
+    if (ref?.kind === "preset" && Object.hasOwn(presets, ref.id))
+      out = presets[ref.id];
+    else if (ref?.kind === "variant") {
+      let found = list?.find((v) => v.id === ref.id);
+      if (found)
+        out = normalize(schema, found.values);
+    }
+    let groups = Object.entries(b.groups);
+    if (groups.length) {
+      out = { ...out };
+      for (let [g, i] of groups)
+        Object.assign(out, groupPresets[g]?.[i]?.values);
+    }
+    let values = Object.freeze(out);
+    return baseCache = { base: b, schema, presets, groupPresets, variants: list, values }, values;
+  }
+  let covered = (key) => {
+    let b = activeBase();
+    if (b.preset)
+      return !0;
+    let group = schema[key]?.group;
+    return group !== void 0 && Object.hasOwn(b.groups, group);
+  };
+  function declaredShortcut(id) {
+    let slash = id.indexOf("/"), key = slash < 0 ? id : id.slice(0, slash), field = Object.hasOwn(schema, key) ? schema[key] : void 0;
+    if (field?.kind === "action" && slash < 0)
+      return { found: !0, ...field.shortcut ? { combo: field.shortcut } : {} };
+    if (field?.kind === "toolbar" && slash >= 0) {
+      let item = field.items.find((i) => (i.id ?? i.label) === id.slice(slash + 1));
+      if (!item)
+        return { found: !1 };
+      let key = toolbarShortcut(item)?.key;
+      return { found: !0, ...key ? { combo: normalizeCombo(key) } : {} };
+    }
+    return { found: !1 };
+  }
+  function bindable(id) {
+    return declaredShortcut(id).found;
+  }
+  let fieldKeys = () => valueKeys(schema), valueField = (k) => {
+    let field = Object.hasOwn(schema, k) ? schema[k] : void 0;
+    return field && hasValue(field) ? field : void 0;
+  };
+  function changes(from, to) {
+    let diff = {};
+    for (let k of fieldKeys())
+      if (!same(from[k], to[k]))
+        diff[k] = to[k];
+    return diff;
+  }
+  function release() {
+    if (!comparing)
+      return;
+    let shown = comparing;
+    comparing = null, options.onChange?.(changes(shown, current), current, { source: "compare" }), notify();
+  }
+  let flag = (k, name) => {
+    let v = valueField(k)?.[name];
+    return typeof v === "function" ? Boolean(v(get())) : Boolean(v);
+  }, blocked = (k) => flag(k, "disabled") || flag(k, "readOnly"), rollable = (k) => {
+    let field = valueField(k);
+    return Boolean(field && !locks.has(k) && field.random !== !1 && !blocked(k) && (!options.tunable || options.tunable(k, get())));
+  }, pool = (keys) => (load(), (keys ?? fieldKeys()).filter(rollable));
+  function applyPatch(base, previous, patch) {
+    let out = { ...base }, diff = {}, changed = !1;
+    if (base === previous) {
+      for (let k of Object.keys(patch)) {
+        let field = valueField(k);
+        if (!field)
+          continue;
+        let raw = patch[k], val = raw === void 0 ? previous[k] : normalizeField(field, raw);
+        if (!same(previous[k], val))
+          out[k] = val, diff[k] = val, changed = !0;
+      }
+      return changed ? { next: Object.freeze(out), diff } : null;
+    }
+    for (let k of Object.keys(patch)) {
+      let field = valueField(k);
+      if (!field)
+        continue;
+      let raw = patch[k], val = raw === void 0 ? base[k] : normalizeField(field, raw);
+      out[k] = same(previous[k], val) ? previous[k] : val;
+    }
+    for (let k of fieldKeys())
+      if (!same(previous[k], out[k]))
+        diff[k] = out[k], changed = !0;
+      else
+        out[k] = previous[k];
+    return changed ? { next: Object.freeze(out), diff } : null;
+  }
+  let markChanged = (diff) => {
+    if (echo > 0) {
+      let at = now();
+      for (let k of Object.keys(diff))
+        changedAt.set(k, at), sent.set(k, diff[k]);
+      scheduleEcho();
+    }
+    for (let k of Object.keys(diff))
+      pending.delete(k);
+  };
+  function set(patch, setOpts) {
+    write(patch, setOpts);
+  }
+  function write(patch, setOpts, nextBase) {
+    if (!enabled())
+      return;
+    release();
+    let previous = load(), was = activeBase(), moves = nextBase !== void 0 && !sameBase(nextBase, was), forced = mixed.size ? Object.keys(patch).filter((k) => mixed.has(k) && valueField(k)) : [];
+    for (let k of forced)
+      mixed.delete(k);
+    let applied = applyPatch(previous, previous, patch) ?? {
+      next: previous,
+      diff: {}
+    }, { next, diff } = applied;
+    for (let k of forced)
+      if (!(k in diff))
+        diff[k] = next[k];
+    let changed = Object.keys(diff).length > 0;
+    if (!changed && !moves)
+      return;
+    if (next === previous && !moves) {
+      notify(), options.onChange?.(diff, next, {
+        source: setOpts?.source ?? "local",
+        ...setOpts?.key ? { key: setOpts.key } : {}
+      });
+      return;
+    }
+    if (!setOpts?.coalesce || past.length === 0) {
+      if (past.push({ values: previous, base: was }), past.length > HISTORY)
+        past.shift();
+    }
+    if (future.length = 0, moves)
+      base = nextBase;
+    if (markChanged(diff), commit(next), !changed)
+      return;
+    options.onChange?.(diff, next, {
+      source: setOpts?.source ?? "local",
+      ...setOpts?.coalesce ? { coalesce: !0 } : {},
+      ...setOpts?.key ? { key: setOpts.key } : {},
+      ...setOpts?.group ? { group: setOpts.group } : {},
+      ...setOpts?.base ? { base: !0 } : {}
+    });
+  }
+  function step(to, source) {
+    let before = load(), left = { values: before, base: activeBase() }, diff = changes(before, to.values);
+    if (base = validBase(to.base), markChanged(diff), commit(to.values), Object.keys(diff).length)
+      options.onChange?.(diff, to.values, { source });
+    return left;
+  }
+  function place(values, replace, land) {
+    let previous = load(), applied = applyPatch(replace ? locked : previous, previous, values);
+    if (!applied)
+      return;
+    landing = land;
+    try {
+      commit(applied.next), options.onChange?.(applied.diff, applied.next, { source: "remote" });
+    } finally {
+      landing = !1;
+    }
+  }
+  function acknowledges(key, value) {
+    if (!sent.has(key))
+      return !1;
+    let was = sent.get(key), field = schema[key];
+    if (field?.kind === "knob" && typeof value === "number" && typeof was === "number")
+      return Math.abs(value - was) <= (field.step ?? 0) / 2 + 0.000000001;
+    return same(value, was);
+  }
+  function incoming(values, replace) {
+    let current = load(), out = {};
+    for (let k of replace ? fieldKeys() : Object.keys(values)) {
+      if (!valueField(k))
+        continue;
+      let target = Object.hasOwn(values, k) ? values[k] : locked[k];
+      if (!grabbed.has(k) && changedAt.has(k) && acknowledges(k, target))
+        changedAt.delete(k), sent.delete(k);
+      if (isHeld(k))
+        pending.set(k, target), out[k] = current[k];
+      else
+        pending.delete(k), out[k] = target;
+    }
+    if (pending.size)
+      scheduleEcho();
+    return out;
+  }
+  function replaceMixed(keys) {
+    if (!keys)
+      return !1;
+    let next = new Set(keys.filter((k) => valueField(k)));
+    if (next.size === mixed.size && [...next].every((k) => mixed.has(k)))
+      return !1;
+    mixed.clear();
+    for (let k of next)
+      mixed.add(k);
+    return !0;
+  }
+  function sync(values, syncOpts) {
+    if (!enabled())
+      return;
+    release();
+    let land = Boolean(syncOpts?.land);
+    if (land)
+      settle();
+    let before = current, remixed = replaceMixed(syncOpts?.mixed);
+    if (place(incoming(values, Boolean(syncOpts?.replace)), !1, land), (land || remixed) && current === before)
+      announce(land);
+  }
+  function settle() {
+    past.length = 0, future.length = 0, changedAt.clear(), sent.clear();
+    for (let k of [...pending.keys()])
+      if (!grabbed.has(k))
+        pending.delete(k);
+    scheduleEcho();
+  }
+  function announce(land) {
+    landing = land;
+    try {
+      notify();
+    } finally {
+      landing = !1;
+    }
+  }
+  function flush() {
+    let ready = {};
+    for (let [k, v] of pending)
+      if (!isHeld(k))
+        ready[k] = v, pending.delete(k);
+    if (Object.keys(ready).length)
+      place(ready, !1, !1);
+    scheduleEcho();
+  }
+  function scheduleEcho() {
+    if (clearTimeout(echoTimer), echoTimer = void 0, echo <= 0 || pending.size === 0)
+      return;
+    let soonest = 1 / 0, t = now();
+    for (let k of pending.keys()) {
+      if (grabbed.has(k))
+        continue;
+      soonest = Math.min(soonest, (changedAt.get(k) ?? -1 / 0) + echo - t);
+    }
+    if (soonest === 1 / 0)
+      return;
+    echoTimer = setTimeout(flush, Math.max(0, soonest) + 1);
+  }
+  let reshape = (next, values, reshapeOpts) => {
+    if (!enabled())
+      return;
+    release();
+    let before = schema, changed = Object.keys(before).length !== Object.keys(next).length || Object.keys(next).some((k) => !sameField(before[k], next[k])), land = Boolean(reshapeOpts?.land), fresh = !changed && Object.keys(next).some((k) => {
+      let a = before[k], b = next[k];
+      return Object.keys(b).some((p) => typeof b[p] === "function" && a[p] !== b[p]);
+    });
+    if (fresh)
+      schema = Object.freeze({ ...next });
+    if (changed) {
+      let previous = load();
+      schema = Object.freeze({ ...next }), locked = normalize(schema, {}), presets = buildPresets(), groupPresets = buildGroupPresets(), base = validBase(base);
+      for (let k of [...locks])
+        if (!valueField(k))
+          locks.delete(k);
+      for (let k of [...pending.keys()])
+        if (!valueField(k))
+          pending.delete(k);
+      for (let k of [...mixed])
+        if (!valueField(k))
+          mixed.delete(k);
+      let kept = {};
+      for (let k of fieldKeys())
+        kept[k] = Object.hasOwn(previous, k) ? previous[k] : locked[k];
+      current = normalize(schema, kept);
+    }
+    if (land)
+      settle();
+    else if (changed)
+      past.length = 0, future.length = 0;
+    let remixed = replaceMixed(reshapeOpts?.mixed), target = incoming(values, !0), before2 = current;
+    if (place(target, !1, land), current === before2 && (changed || fresh || land || remixed))
+      announce(land);
+  }, readouts = /* @__PURE__ */ new Map, readoutListeners = /* @__PURE__ */ new Set, readoutOf = (key) => {
+    let field = Object.hasOwn(schema, key) ? schema[key] : void 0;
+    if (!field || !isReadout(field))
+      return;
+    let shape = `${field.kind}\x00${"history" in field ? field.history : ""}\x00${field.kind === "graph" ? field.series.map((s) => s.id).join("\x00") : ""}\x00${field.kind === "log" ? field.max : ""}`, entry = readouts.get(key);
+    if (!entry || entry.shape !== shape)
+      entry = { shape, state: readoutState(field) }, readouts.set(key, entry);
+    return { field, state: entry.state };
+  }, readoutPort = {
+    state: (key) => readoutOf(key)?.state,
+    listen(cb) {
+      return readoutListeners.add(cb), () => readoutListeners.delete(cb);
+    }
+  }, variants = createVariants(() => schema, id, storageKey(id, "variants"), variantStorage, get, (v, variant, coalesce) => write(v, { source: "variant", coalesce }, makeBase(Object.freeze({ kind: "variant", id: variant }), {})), notify, enabled), resettable = (keys) => (keys ?? fieldKeys()).filter((k) => valueField(k) && !blocked(k));
+  function offBase(keys) {
+    if (!hasBase())
+      return !1;
+    let cur = load(), b = baseValues();
+    return keys.some((k) => !same(cur[k], b[k]));
+  }
+  function toBase(keys, meta) {
+    let b = baseValues(), patch = Object.fromEntries(keys.map((k) => [k, b[k]]));
+    write(patch, { source: "reset", base: !0, ...meta });
+  }
+  function toDefaults(keys, nextBase) {
+    let patch = {};
+    for (let k of keys)
+      patch[k] = locked[k];
+    write(patch, { source: "reset" }, nextBase);
+    let resetKeys = options[RESET_KEYS];
+    if (resetKeys)
+      resetKeys(Object.keys(patch));
+    else
+      for (let key of Object.keys(patch))
+        options.onReset?.({ key });
+  }
+  let controls = {
+    id,
+    get schema() {
+      return schema;
+    },
+    get locked() {
+      return locked;
+    },
+    get presets() {
+      return presets;
+    },
+    actions,
+    theme,
+    density,
+    renderer,
+    keys: options.keys,
+    marks: options.marks !== !1,
+    chip: Object.freeze({
+      ...options.chip,
+      reveal: options.chip?.reveal ?? (devBuild() ? "hover" : "shortcut"),
+      shortcut: options.chip?.shortcut ?? "Alt+Shift+D"
+    }),
+    groupPresetDisplay: options.groupPresetDisplay ?? "auto",
+    groupLabel: (group) => options.groupLabels?.[group] ?? fieldLabels().group.get(group),
+    sectionLabel: (section) => options.sectionLabels?.[section] ?? fieldLabels().section.get(section),
+    groupDescription: (group) => options.groupDescriptions?.[group] ?? fieldLabels().groupText.get(group),
+    sectionDescription: (section) => options.sectionDescriptions?.[section] ?? fieldLabels().sectionText.get(section),
+    groupFolded: options.groupFolded,
+    sectionFolded: options.sectionFolded,
+    presetLabel: (presetId) => options.presetLabels?.[presetId] ?? (presetId === "default" ? options.defaultLabel : void 0) ?? presetId,
+    get,
+    set,
+    sync,
+    get enabled() {
+      return enabled();
+    },
+    get storage() {
+      return storage();
+    },
+    get error() {
+      return error;
+    },
+    get canUndo() {
+      return hostHistory ? hostHistory.canUndo() : past.length > 0;
+    },
+    get canRedo() {
+      return hostHistory ? hostHistory.canRedo() : future.length > 0;
+    },
+    persist: persistMode,
+    get comparing() {
+      return comparing !== null;
+    },
+    get landing() {
+      return landing;
+    },
+    [RESHAPE]: reshape,
+    [READOUT]: readoutPort,
+    watch(key, value) {
+      let found = readoutOf(key);
+      if (!found)
+        return;
+      pushReadout(found.field, found.state, value);
+      for (let cb of readoutListeners)
+        cb(key);
+    },
+    watched(key) {
+      let state = readouts.get(key)?.state;
+      return state && state.seq > 0 ? state.value : void 0;
+    },
+    hold(key, on = !0) {
+      if (on) {
+        if (grabbed.has(key))
+          return;
+        grabbed.add(key), options.onGesture?.({ key, phase: "start" });
+        return;
+      }
+      if (!grabbed.delete(key))
+        return;
+      options.onGesture?.({ key, phase: "end" }), flush();
+    },
+    isHeld,
+    action(key, item) {
+      let field = schema[key];
+      if (field?.kind === "toolbar") {
+        let found = field.items.find((i) => (i.id ?? i.label) === item);
+        if (!found)
+          throw Error(`Unknown toolbar item: ${key} ${item}`);
+        if (found.disabled)
+          return;
+        found.run?.(), options.onAction?.(found.id ?? found.label);
+        return;
+      }
+      if (!field || field.kind !== "action")
+        throw Error(`Unknown action: ${key}`);
+      field.run?.(), options.onAction?.(key);
+    },
+    undo() {
+      if (release(), hostHistory)
+        return hostHistory.undo();
+      let previous = past.pop();
+      if (!previous)
+        return;
+      future.push(step(previous, "undo"));
+    },
+    redo() {
+      if (release(), hostHistory)
+        return hostHistory.redo();
+      let next = future.pop();
+      if (!next)
+        return;
+      past.push(step(next, "redo"));
+    },
+    getServerSnapshot: () => locked,
+    subscribe(cb) {
+      if (listeners.add(cb), hostHistory?.subscribe && !unsubscribeHistory)
+        unsubscribeHistory = hostHistory.subscribe(notify);
+      return () => {
+        if (listeners.delete(cb), !listeners.size && unsubscribeHistory)
+          unsubscribeHistory(), unsubscribeHistory = void 0;
+      };
+    },
+    reset(keys) {
+      if (!enabled())
+        return;
+      let open = resettable(keys);
+      if (offBase(open))
+        return toBase(open, {});
+      let skipped = fieldKeys().some(blocked);
+      if (!keys && !skipped) {
+        write(locked, { source: "reset" }, NO_BASE), options.onReset?.({});
+        return;
+      }
+      toDefaults(open, keys ? void 0 : NO_BASE);
+    },
+    resetKey(key) {
+      if (!enabled())
+        return;
+      if (!valueField(key))
+        throw Error(`Unknown control key: ${key}`);
+      if (blocked(key))
+        return;
+      if (offBase([key]))
+        return toBase([key], { key });
+      set({ [key]: locked[key] }, { source: "reset", key }), options.onReset?.({ key });
+    },
+    resetGroup(group) {
+      if (!enabled())
+        return;
+      let keys = Object.keys(schema).filter((k) => schema[k].group === group && hasValue(schema[k])), open = keys.filter((k) => !blocked(k)), b = activeBase(), index = b.groups[group];
+      if (offBase(open)) {
+        toBase(open, { group });
+        let preset = index === void 0 ? void 0 : groupPresets[group]?.[index];
+        if (preset && index !== void 0)
+          options.onPreset?.({ group, index, name: preset.name });
+        return;
+      }
+      let { [group]: _, ...others } = b.groups, forget = index === void 0 ? void 0 : makeBase(b.preset, others);
+      if (open.length < keys.length)
+        return toDefaults(open, forget);
+      let patch = {};
+      for (let k of keys)
+        patch[k] = locked[k];
+      write(patch, { source: "reset", group }, forget), options.onReset?.({ group });
+    },
+    isModified(key) {
+      let cur = get(), b = baseValues();
+      if (key !== void 0)
+        return !same(cur[key], b[key]);
+      return !equal(cur, b);
+    },
+    canReset(keys) {
+      if (!enabled())
+        return !1;
+      let cur = get(), b = baseValues();
+      return resettable(keys).some((k) => !same(cur[k], b[k]) || !same(cur[k], locked[k])) || !keys && hasBase();
+    },
+    modified() {
+      let cur = get(), out = {};
+      for (let k of fieldKeys())
+        if (!same(cur[k], locked[k]))
+          out[k] = cur[k];
+      return Object.freeze(out);
+    },
+    randomize(keys) {
+      if (!enabled())
+        return;
+      let chosen = pool(keys);
+      if (chosen.length === 0)
+        return;
+      if (!hasBase()) {
+        let sub = Object.fromEntries(chosen.map((k) => [k, schema[k]]));
+        set(randomValues(sub, draw), { source: "randomize" });
+        return;
+      }
+      let b = baseValues(), patch = {};
+      for (let k of chosen) {
+        let field = valueField(k);
+        patch[k] = covered(k) ? around(field, b[k], draw) : pick(field, draw);
+      }
+      set(patch, { source: "randomize" });
+    },
+    mutate(keys) {
+      if (!enabled())
+        return;
+      release();
+      let chosen = pool(keys);
+      if (chosen.length === 0)
+        return;
+      set(mutateValues(schema, load(), chosen, draw), { source: "mutate" });
+    },
+    lock(keys, on = !0) {
+      if (!enabled())
+        return;
+      load();
+      let changed = !1;
+      for (let key of typeof keys === "string" ? [keys] : keys) {
+        if (!valueField(key))
+          throw Error(`Unknown control key: ${key}`);
+        if (locks.has(key) === on)
+          continue;
+        if (on)
+          locks.add(key);
+        else
+          locks.delete(key);
+        changed = !0;
+      }
+      if (!changed)
+        return;
+      persist(), notify();
+    },
+    isLocked(key) {
+      if (!enabled())
+        return !1;
+      return load(), locks.has(key);
+    },
+    shortcut(key, item) {
+      let id = item === void 0 ? key : `${key}/${item}`, declared = declaredShortcut(id);
+      if (!declared.found)
+        return;
+      if (enabled())
+        load();
+      return (enabled() ? bindings.get(id) : void 0) ?? declared.combo;
+    },
+    rebind(key, combo, item) {
+      let id = item === void 0 ? key : `${key}/${item}`, declared = declaredShortcut(id);
+      if (!declared.found)
+        throw Error(`Not an action or toolbar button: ${id}`);
+      if (!enabled())
+        return;
+      load();
+      let next = combo === void 0 ? void 0 : normalizeCombo(combo);
+      if (combo !== void 0 && combo.trim() && !next)
+        throw Error(`Not a key combination: ${combo}`);
+      let was = bindings.get(id);
+      if (next === void 0 || next === (declared.combo ?? ""))
+        bindings.delete(id);
+      else
+        bindings.set(id, next);
+      if (bindings.get(id) === was)
+        return;
+      persist(), notify();
+    },
+    canRoll(key) {
+      if (!enabled())
+        return !1;
+      return load(), rollable(key);
+    },
+    isDisabled: (key) => flag(key, "disabled"),
+    isReadOnly: (key) => flag(key, "readOnly"),
+    refresh() {
+      refreshes++, notify();
+    },
+    get [REFRESHES]() {
+      return refreshes;
+    },
+    setMixed(keys, on = !0) {
+      let changed = !1;
+      for (let key of typeof keys === "string" ? [keys] : keys) {
+        if (!valueField(key) || mixed.has(key) === on)
+          continue;
+        if (on)
+          mixed.add(key);
+        else
+          mixed.delete(key);
+        changed = !0;
+      }
+      if (changed)
+        notify();
+    },
+    isMixed: (key) => mixed.has(key),
+    compare(hold) {
+      if (!enabled())
+        return;
+      if (!hold)
+        return release();
+      let before = past.at(-1)?.values, now = load();
+      if (comparing || !before || equal(before, now))
+        return;
+      comparing = before, options.onChange?.(changes(now, before), before, { source: "compare" }), notify();
+    },
+    preset(id, presetOptions) {
+      if (!Object.hasOwn(presets, id))
+        throw Error(`Unknown preset: ${id}`);
+      write(presets[id], { source: "preset", coalesce: presetOptions?.coalesce }, id === "default" ? NO_BASE : makeBase(Object.freeze({ kind: "preset", id }), {}));
+    },
+    matchingPreset: () => Object.keys(presets).find((id) => equal(get(), presets[id])) ?? "custom",
+    get groupPresets() {
+      return groupPresets;
+    },
+    groupPreset(group, index, presetOptions) {
+      let preset = groupPresets[group]?.[index];
+      if (!preset)
+        throw Error(`Unknown preset ${index + 1} for group ${group}`);
+      if (!enabled())
+        return;
+      let b = activeBase();
+      write(preset.values, { source: "preset", group, coalesce: presetOptions?.coalesce }, makeBase(b.preset, { ...b.groups, [group]: index })), options.onPreset?.({ group, index, name: preset.name });
+    },
+    activePreset() {
+      if (!enabled())
+        return null;
+      return activeBase().preset;
+    },
+    activeGroupPreset(group) {
+      if (!enabled())
+        return -1;
+      return activeBase().groups[group] ?? -1;
+    },
+    baseValues,
+    matchingGroupPreset(group) {
+      let cur = get();
+      return (groupPresets[group] ?? []).findIndex((p) => Object.entries(p.values).every(([k, v]) => same(cur[k], v)));
+    },
+    code: (format, values) => formatCode(values ?? get(), format),
+    variants,
+    attach(element, chip) {
+      let load = options.ship ? () => options.ship().then((m) => m.attach) : void 0;
+      if (!load || !enabled())
+        return () => {};
+      let disposed = !1, detach;
+      return load().then((attach) => {
+        if (!disposed && enabled())
+          detach = attach(controls, element, chip);
+      }).catch((cause) => {
+        error = String(cause), notify();
+      }), () => {
+        disposed = !0, detach?.();
+      };
+    },
+    mount(container, mountOptions) {
+      let load = options.ship ? () => options.ship().then((m) => m.mountPanel) : void 0;
+      if (!load || !enabled())
+        return () => {};
+      let disposed = !1, panel;
+      return load().then((mountPanel) => {
+        if (!disposed && enabled())
+          panel = mountPanel(controls, container, mountOptions), mountOptions?.onReady?.(panel);
+      }).catch((cause) => {
+        error = String(cause), notify();
+      }), () => {
+        disposed = !0, panel?.dispose();
+      };
+    }
+  };
+  return Object.freeze(controls);
+}
+// src/core/remote.ts
+var readoutDescriptor = (d) => isReadout(d);
+function readoutField(d) {
+  let { key: _key, kind, default: _d, bind: _b, ...rest } = d, opts = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== void 0));
+  if (kind === "watch")
+    return watch(opts);
+  if (kind === "sparkline")
+    return sparkline(opts);
+  if (kind === "graph")
+    return graph(opts);
+  if (kind === "meter")
+    return meter(opts);
+  if (kind === "table")
+    return table(opts);
+  return log(opts);
+}
+var optionId = (o) => typeof o === "string" ? o : String(o.id ?? o.value ?? o.label ?? "");
+function descriptorToField(d) {
+  let meta = pickMeta(d);
+  if (d.kind === "action")
+    return action(d.label, {
+      ...meta,
+      ...d.global ? { global: !0 } : {},
+      ...d.rebind ? { rebind: !0 } : {}
+    });
+  if (readoutDescriptor(d))
+    return readoutField(d);
+  if (d.kind === "toolbar")
+    return toolbar(d.items.map(({ key, ...item }) => ({ ...item, id: key })), meta);
+  if (d.bind)
+    return flatSpring({}, { ...meta, id: d.key }).duration;
+  if (d.kind === "knob" || d.kind === "number") {
+    let def = typeof d.default === "number" && Number.isFinite(d.default) ? d.default : 0, min = d.min ?? Math.min(0, def * 2), max = d.max ?? Math.max(1, def * 2), step = d.step ?? (d.swiftType === "Int" ? 1 : (max - min) / 100 || 1);
+    return knob(def, {
+      min,
+      max,
+      step,
+      ...d.unit !== void 0 ? { unit: d.unit } : {},
+      ...d.decimals !== void 0 ? { decimals: d.decimals } : {},
+      ...meta
+    });
+  }
+  if (d.kind === "choice") {
+    let given = d.options ?? d.choices ?? [String(d.default)];
+    if (given.length === 0)
+      throw Error(`Choice descriptor ${d.key} needs options.`);
+    let list = given.map(optionId), labels = Object.fromEntries(given.flatMap((o) => typeof o === "string" || o.label === void 0 ? [] : [[optionId(o), o.label]])), def = list.includes(String(d.default)) ? String(d.default) : list[0];
+    return choice(def, list, {
+      ...meta,
+      labels,
+      ...d.display ? { display: d.display } : {}
+    });
+  }
+  if (d.kind === "spring")
+    return spring(d.default, meta);
+  if (d.kind === "color")
+    return color(parseColor(d.default) ? d.default : "#808080", meta);
+  if (d.kind === "point")
+    return point(d.default, { min: d.min ?? 0, max: d.max ?? 1, step: d.step, ...meta });
+  if (d.kind === "easing")
+    return easing(d.default, meta);
+  let numbers = {
+    ...d.unit !== void 0 ? { unit: d.unit } : {},
+    ...d.decimals !== void 0 ? { decimals: d.decimals } : {},
+    ...d.step !== void 0 ? { step: d.step } : {}
+  };
+  if (d.kind === "vec2" || d.kind === "vec3") {
+    let v = d.default ?? {}, opts = {
+      min: d.min ?? -1,
+      max: d.max ?? 1,
+      ...numbers,
+      ...d.link ? { link: !0 } : {},
+      ...d.linked ? { linked: !0 } : {},
+      ...d.axes ? { axes: d.axes } : {},
+      ...meta
+    };
+    return d.kind === "vec3" ? vec3({ x: v.x ?? 0, y: v.y ?? 0, z: v.z ?? 0 }, opts) : vec2({ x: v.x ?? 0, y: v.y ?? 0 }, opts);
+  }
+  if (d.kind === "range") {
+    let v = Array.isArray(d.default) ? d.default : [d.min ?? 0, d.max ?? 1];
+    return range([Number(v[0]), Number(v[1])], {
+      min: d.min ?? 0,
+      max: d.max ?? 1,
+      ...numbers,
+      ...meta
+    });
+  }
+  if (d.kind === "angle")
+    return angle(typeof d.default === "number" ? d.default : 0, {
+      ...d.min !== void 0 ? { min: d.min } : {},
+      ...d.max !== void 0 ? { max: d.max } : {},
+      ...d.step !== void 0 ? { step: d.step } : {},
+      ...d.wrap !== void 0 ? { wrap: d.wrap } : {},
+      ...meta
+    });
+  if (d.kind === "seed")
+    return seed(typeof d.default === "number" ? d.default : 0, {
+      ...d.min !== void 0 ? { min: d.min } : {},
+      ...d.max !== void 0 ? { max: d.max } : {},
+      ...meta
+    });
+  if (d.kind === "keybind")
+    return keybind(typeof d.default === "string" ? d.default : "", meta);
+  if (d.kind === "gradient") {
+    let fallback = [
+      { at: 0, color: "#000000" },
+      { at: 1, color: "#ffffff" }
+    ], stops = Array.isArray(d.default) ? d.default : fallback, opts = {
+      ...d.space ? { space: d.space } : {},
+      ...d.presets ? { presets: d.presets } : {},
+      ...meta
+    };
+    try {
+      return gradient(stops, opts);
+    } catch {
+      return gradient(fallback, opts);
+    }
+  }
+  if (d.kind === "curve") {
+    let opts = {
+      range: d.range ?? [d.min ?? 0, d.max ?? 1],
+      ...d.interp ? { interp: d.interp } : {},
+      ...d.shapes !== void 0 ? { shapes: d.shapes } : {},
+      ...d.presets ? { presets: d.presets } : {},
+      ...meta
+    }, points = Array.isArray(d.default) ? d.default : [];
+    return points.length >= 2 ? curve(points, opts) : curve("linear", opts);
+  }
+  return toggle(Boolean(d.default), meta);
+}
+function fromDescriptors(descriptors) {
+  let byKey = new Map(descriptors.map((d) => [d.key, d])), bound = /* @__PURE__ */ new Set;
+  for (let d of descriptors)
+    if (d.bind) {
+      if (d.bind.duration === d.bind.bounce)
+        throw Error(`Spring ${d.key} binds one key twice.`);
+      bound.add(d.bind.duration).add(d.bind.bounce);
+    }
+  let entries = [];
+  for (let d of descriptors) {
+    if (bound.has(d.key) && !d.bind)
+      continue;
+    if (!d.bind) {
+      entries.push([d.key, descriptorToField(d)]);
+      continue;
+    }
+    let half = (part) => {
+      let own = byKey.get(d.bind[part]);
+      if (own && !own.bind && (own.kind === "number" || own.kind === "knob"))
+        return descriptorToField({
+          ...own,
+          group: d.group ?? own.group,
+          groupLabel: d.groupLabel ?? own.groupLabel
+        });
+      return d.default?.[part] ?? (part === "duration" ? 0.5 : 0);
+    }, pair = flatSpring({ duration: half("duration"), bounce: half("bounce") }, { id: d.key, ...pickMeta(d, ["shortcut"]) });
+    entries.push([d.bind.duration, pair.duration], [d.bind.bounce, pair.bounce]);
+  }
+  return Object.freeze(Object.fromEntries(entries));
+}
+var decimal = (n) => String(Math.round(n * 1e4) / 1e4), swiftLiteral = (d, v) => {
+  if (d.kind === "color") {
+    let [r, g, b] = oklchToRgb(parseColor(v) ?? { l: 0, c: 0, h: 0 }).map(decimal);
+    return `Color(red: ${r}, green: ${g}, blue: ${b})`;
+  }
+  if (d.kind === "point") {
+    let p = v;
+    return `CGPoint(x: ${decimal(p.x)}, y: ${decimal(p.y)})`;
+  }
+  if (d.kind === "easing") {
+    let [x1, y1, x2, y2] = v.map(decimal);
+    return `.bezier(startControlPoint: UnitPoint(x: ${x1}, y: ${y1}), endControlPoint: UnitPoint(x: ${x2}, y: ${y2}))`;
+  }
+  if (d.kind === "vec2" || d.kind === "vec3") {
+    let p = v;
+    return d.kind === "vec3" ? `SIMD3<Double>(${decimal(p.x)}, ${decimal(p.y)}, ${decimal(p.z)})` : `SIMD2<Double>(${decimal(p.x)}, ${decimal(p.y)})`;
+  }
+  if (d.kind === "range") {
+    let [a, b] = v;
+    return `${decimal(a)}...${decimal(b)}`;
+  }
+  if (d.kind === "keybind")
+    return JSON.stringify(v);
+  if (d.kind === "gradient")
+    return `Gradient(stops: [${(Array.isArray(v) ? v : []).map((s) => {
+      let [r, g, b] = oklchToRgb(parseColor(s.color) ?? { l: 0, c: 0, h: 0 }).map(decimal);
+      return `.init(color: Color(red: ${r}, green: ${g}, blue: ${b}), location: ${decimal(s.at)})`;
+    }).join(", ")}])`;
+  if (d.kind === "curve")
+    return `[${(Array.isArray(v) ? v : []).map((p) => `CGPoint(x: ${decimal(p.x)}, y: ${decimal(p.y)})`).join(", ")}]`;
+  if (d.kind === "seed")
+    return String(Math.round(v));
+  if (typeof v === "boolean")
+    return String(v);
+  if (typeof v === "string")
+    return `.${v}`;
+  if (typeof v !== "number")
+    return JSON.stringify(v);
+  if (d.swiftType === "Int")
+    return String(Math.round(v));
+  return decimal(v);
+}, swiftTypes = {
+  color: "Color",
+  point: "CGPoint",
+  easing: "UnitCurve",
+  vec2: "SIMD2<Double>",
+  vec3: "SIMD3<Double>",
+  range: "ClosedRange<Double>",
+  seed: "Int",
+  keybind: "String",
+  gradient: "Gradient",
+  curve: "[CGPoint]"
+};
+function formatSwift(descriptors, values, group) {
+  let byKey = new Map(descriptors.map((d) => [d.key, d])), done = /* @__PURE__ */ new Set, lines = [];
+  for (let d of descriptors) {
+    if (d.kind === "action" || d.kind === "toolbar" || d.bind)
+      continue;
+    if (readoutDescriptor(d))
+      continue;
+    if (!((d.key in values) && !same(values[d.key], d.default)) || done.has(d.key) || group && d.group !== group)
+      continue;
+    let base = d.key.replace(/\.(duration|bounce)$/, ""), duration = byKey.get(`${base}.duration`), bounce = byKey.get(`${base}.bounce`);
+    if (base !== d.key && duration && bounce) {
+      done.add(duration.key).add(bounce.key);
+      let label = (duration.label ?? duration.key).replace(/ duration$/i, ""), dv = values[duration.key] ?? duration.default, bv = values[bounce.key] ?? bounce.default;
+      lines.push(`TunableSpring(${JSON.stringify(base)}, ${JSON.stringify(label)}, duration: ${swiftLiteral(duration, dv)}, bounce: ${swiftLiteral(bounce, bv)})  // was duration: ${swiftLiteral(duration, duration.default)}, bounce: ${swiftLiteral(bounce, bounce.default)}`);
+      continue;
+    }
+    if (done.add(d.key), d.kind === "spring") {
+      let v = values[d.key], was = d.default;
+      lines.push(`TunableSpring(${JSON.stringify(d.key)}, ${JSON.stringify(d.label ?? d.key)}, duration: ${decimal(v.duration)}, bounce: ${decimal(v.bounce)})  // was duration: ${decimal(was.duration)}, bounce: ${decimal(was.bounce)}`);
+      continue;
+    }
+    let call = `Tunable<${d.swiftType ?? (d.kind === "bool" || d.kind === "toggle" ? "Bool" : (d.kind in swiftTypes) ? swiftTypes[d.kind] : "Double")}>(${JSON.stringify(d.key)}, ${JSON.stringify(d.label ?? d.key)}, default: ${swiftLiteral(d, values[d.key])}`;
+    if (d.kind === "knob" || d.kind === "number") {
+      if (d.min !== void 0 && d.max !== void 0)
+        call += `, in: ${decimal(d.min)}...${decimal(d.max)}`;
+      if (d.step !== void 0)
+        call += `, step: ${decimal(d.step)}`;
+    }
+    let note = d.kind === "color" ? `${colorHex(values[d.key])} · ` : "";
+    lines.push(`${call})  // ${note}was ${swiftLiteral(d, d.default)}`);
+  }
+  return lines.join(`
+`);
+}
+var ECHO_MS = 600;
+function extend(source, extra) {
+  return Object.freeze(Object.defineProperties({}, {
+    ...Object.getOwnPropertyDescriptors(source),
+    ...Object.getOwnPropertyDescriptors(extra)
+  }));
+}
+function createRemoteControls(id, descriptors, options = {}) {
+  let frozenDescriptors = Object.freeze([...descriptors]), given = descriptors, nullDefaults = options.nullDefaults !== !1, send = (changes, meta) => {
+    if (changes.length === 0)
+      return;
+    if (options.onSetBatch && (changes.length > 1 || !options.onSet))
+      return options.onSetBatch(changes, meta);
+    for (let { key, value } of changes)
+      options.onSet?.(key, value, meta);
+  }, onReset = (target) => {
+    if (target.key && nullDefaults)
+      send([{ key: target.key, value: null }], { source: "reset", key: target.key });
+    options.onReset?.(target);
+  }, resetKeys = (keys) => {
+    if (!options.onSetBatch || !nullDefaults)
+      return keys.forEach((key) => onReset({ key }));
+    for (let key of keys)
+      options.onReset?.({ key });
+    send(keys.map((key) => ({ key, value: null })), { source: "reset" });
+  }, controls = defineControls(id, fromDescriptors(frozenDescriptors), {
+    enabled: options.enabled ?? !0,
+    ship: options.ship,
+    echo: options.echo ?? ECHO_MS,
+    storage: options.storage ?? null,
+    persist: options.persist,
+    random: options.random,
+    tunable: options.tunable,
+    history: options.history,
+    presets: options.presets,
+    groupPresets: options.groupPresets,
+    onPreset: options.onPreset,
+    actions: options.actions,
+    theme: options.theme,
+    density: options.density,
+    renderer: options.renderer,
+    keys: options.keys,
+    marks: options.marks,
+    groupLabels: options.groupLabels,
+    sectionLabels: options.sectionLabels,
+    presetLabels: options.presetLabels,
+    defaultLabel: options.defaultLabel,
+    groupPresetDisplay: options.groupPresetDisplay,
+    groupDescriptions: options.groupDescriptions,
+    sectionDescriptions: options.sectionDescriptions,
+    groupFolded: options.groupFolded,
+    sectionFolded: options.sectionFolded,
+    onChange(patch, _values, meta) {
+      if (meta.source === "remote")
+        return;
+      if (meta.source === "reset" && !meta.base)
+        return;
+      if ((meta.source === "preset" || meta.base && meta.group !== void 0 && controls.activeGroupPreset(meta.group) >= 0) && meta.group !== void 0 && options.onPreset)
+        return;
+      let changes = [];
+      for (let [key, val] of Object.entries(patch)) {
+        if (val === void 0)
+          continue;
+        changes.push({ key, value: nullDefaults && same(val, controls.locked[key]) ? null : val });
+      }
+      send(changes, meta);
+    },
+    onReset,
+    onGesture: options.onGesture,
+    ...{ [RESET_KEYS]: resetKeys },
+    onAction: (key) => options.onAction?.(key)
+  });
+  if (options.values)
+    controls.sync(options.values, { replace: !0 });
+  let reshape = controls[RESHAPE];
+  return extend(controls, {
+    get descriptors() {
+      return frozenDescriptors;
+    },
+    update(next, values = {}, opts) {
+      if (next === given || next === frozenDescriptors)
+        return controls.sync(values, { replace: !0, land: opts?.land, mixed: opts?.mixed });
+      given = next, frozenDescriptors = Object.freeze([...next]), reshape(fromDescriptors(frozenDescriptors), values, opts);
+    },
+    sync: (values, syncOptions) => controls.sync(values, syncOptions),
+    swift: (group) => formatSwift(frozenDescriptors, controls.modified(), group)
+  });
+}
+function fromSettings(groups, home = {}) {
+  let descriptors = [], values = {};
+  for (let g of groups)
+    for (let item of g.items) {
+      let meta = { key: item.id, label: item.label, ...g.title ? { group: g.title } : {} };
+      if (item.kind === "action")
+        descriptors.push({ ...meta, kind: "action" });
+      else if (item.kind === "toggle") {
+        values[item.id] = Boolean(item.value);
+        let def = home[item.id];
+        descriptors.push({
+          ...meta,
+          kind: "toggle",
+          default: typeof def === "boolean" ? def : values[item.id]
+        });
+      } else if (item.choices.length) {
+        let ids = item.choices.map((c) => c.id);
+        values[item.id] = item.value != null && ids.includes(item.value) ? item.value : ids[0];
+        let def = home[item.id];
+        descriptors.push({
+          ...meta,
+          kind: "choice",
+          default: typeof def === "string" && ids.includes(def) ? def : values[item.id],
+          choices: item.choices
+        });
+      }
+    }
+  return { descriptors, values };
+}
+export {
+  AROUND,
+  CURVE_SHAPES,
+  EASINGS,
+  SPRING,
+  action,
+  actionShortcut,
+  angle,
+  bezierCss,
+  bezierPoint,
+  choice,
+  color,
+  colorHex,
+  comboFromEvent,
+  comboLabel,
+  comboParts,
+  createRemoteControls,
+  curve,
+  defineControls,
+  descriptorToField,
+  easing,
+  flatSpring,
+  formatCode,
+  formatSwift,
+  fromDescriptors,
+  fromSettings,
+  gradient,
+  gradientCss,
+  graph,
+  hasValue,
+  isReadout,
+  keybind,
+  knob,
+  letterOf,
+  log,
+  matchesCombo,
+  memoryStorage,
+  meter,
+  normalizeCombo,
+  parseColor,
+  point,
+  range,
+  sampleCurve,
+  sampleGradient,
+  seed,
+  sparkline,
+  spring,
+  springCss,
+  springMotion,
+  table,
+  toggle,
+  toolbar,
+  toolbarShortcut,
+  urlFlag,
+  vec2,
+  vec3,
+  watch,
+  wrapAngle
+};