@kitlangton/knobs 0.0.0-stage → 0.1.0

package/dist/dev/index.js

@@ -0,0 +1,1389 @@
+import {
+  __preload,
+  __chunks,
+  maxChroma,
+  oklchToRgb,
+  parseColor2,
+  colorHex2,
+  EASINGS2,
+  EASING_Y,
+  bezierPoint2,
+  bezierCss2,
+  normalizeCombo2,
+  letterOf2,
+  comboFromEvent2,
+  matchesCombo2,
+  comboParts2,
+  comboLabel2,
+  sampleGradient2,
+  gradientCss2,
+  sampleCurve2,
+  CURVE_SHAPES2,
+  randomStops,
+  mutateStops,
+  randomPoints,
+  mutatePoints,
+  pickMeta,
+  isReadout2,
+  hasValue2,
+  SPRING2,
+  valueKeys,
+  knob2,
+  choice2,
+  action2,
+  flatSpring2,
+  toggle2,
+  spring2,
+  color2,
+  point2,
+  easing2,
+  vec22,
+  vec32,
+  range2,
+  angle2,
+  seed2,
+  keybind2,
+  gradient2,
+  curve2,
+  toolbarShortcut2,
+  toolbar2,
+  watch2,
+  sparkline2,
+  graph2,
+  meter2,
+  table2,
+  log2,
+  wrapAngle2,
+  normalizeField,
+  normalize,
+  isRecord,
+  same,
+  equal,
+  springMotion2,
+  springCss2,
+  RESHAPE,
+  RESET_KEYS,
+  REFRESHES,
+  readoutState,
+  pushReadout,
+  READOUT,
+  memoryStorage2,
+  browserStorage,
+  urlFlag2,
+  storageKey
+} from "./chunk-qtt698hp.js";
+__chunks(import.meta.url,["yfpdrfyw","ktsn42p7","e13znr7c","qtt698hp","kdewv0mt"],[["./index.js",3],["./chunk-ktsn42p7.js",3,4],["./chunk-e13znr7c.js",3,4],["./chunk-qtt698hp.js"],["./chunk-kdewv0mt.js",3]],0);
+// 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]
+}, between = (min, max, r) => min + (max - min) * r, signed = (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 = signed(random), by = reach * between(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 = SPRING2.duration, b = SPRING2.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 = parseColor2(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 + signed(random) * between(MUTATE.hue[0], MUTATE.hue[1], random()) + 360) % 360, l = Math.min(1, Math.max(0, c.l + signed(random) * between(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 + signed(random) * between(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 + signed(random) * span * between(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 || !hasValue2(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/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(EASINGS2);
+      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);
+  }
+}
+function randomValues(schema, random = Math.random) {
+  return normalize(schema, Object.fromEntries(Object.entries(schema).flatMap(([key, field]) => hasValue2(field) ? [[key, pick(field, random)]] : [])));
+}
+
+// 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) {
+      read();
+      let variant = list.find((v) => v.id === id);
+      if (!variant)
+        throw Error(`Unknown variant: ${id}`);
+      set(variant.values);
+    },
+    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 = () => !0;
+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 = () => 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, 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, 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) => hasValue2(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)));
+          }
+        }
+      } 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] } : {}
+      })), error = null;
+    } catch (cause) {
+      error = String(cause);
+    }
+  }
+  function commit(next) {
+    current = next, persist(), notify();
+  }
+  let fieldKeys = () => valueKeys(schema), valueField = (k) => {
+    let field = Object.hasOwn(schema, k) ? schema[k] : void 0;
+    return field && hasValue2(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) {
+    if (!enabled())
+      return;
+    release();
+    let previous = load(), 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];
+    if (Object.keys(diff).length === 0)
+      return;
+    if (next === previous) {
+      notify(), options.onChange?.(diff, next, {
+        source: setOpts?.source ?? "local",
+        ...setOpts?.key ? { key: setOpts.key } : {}
+      });
+      return;
+    }
+    if (!setOpts?.coalesce || past.length === 0) {
+      if (past.push(previous), past.length > HISTORY)
+        past.shift();
+    }
+    future.length = 0, markChanged(diff), commit(next), options.onChange?.(diff, next, {
+      source: setOpts?.source ?? "local",
+      ...setOpts?.coalesce ? { coalesce: !0 } : {},
+      ...setOpts?.key ? { key: setOpts.key } : {},
+      ...setOpts?.group ? { group: setOpts.group } : {}
+    });
+  }
+  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();
+      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 || !isReadout2(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);
+    }
+  }, 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;
+      let before = load(), diff = changes(before, previous);
+      future.push(before), markChanged(diff), commit(previous), options.onChange?.(diff, previous, { source: "undo" });
+    },
+    redo() {
+      if (release(), hostHistory)
+        return hostHistory.redo();
+      let next = future.pop();
+      if (!next)
+        return;
+      let before = load(), diff = changes(before, next);
+      past.push(before), markChanged(diff), commit(next), options.onChange?.(diff, next, { source: "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 skipped = fieldKeys().some(blocked);
+      if (!keys && !skipped) {
+        set(locked, { source: "reset" }), options.onReset?.({});
+        return;
+      }
+      let patch = {};
+      for (let k of keys ?? fieldKeys())
+        if (valueField(k) && !blocked(k))
+          patch[k] = locked[k];
+      set(patch, { source: "reset" });
+      let resetKeys = options[RESET_KEYS];
+      if (resetKeys)
+        resetKeys(Object.keys(patch));
+      else
+        for (let key of Object.keys(patch))
+          options.onReset?.({ key });
+    },
+    resetKey(key) {
+      if (!enabled())
+        return;
+      if (!valueField(key))
+        throw Error(`Unknown control key: ${key}`);
+      if (blocked(key))
+        return;
+      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 && hasValue2(schema[k])), open = keys.filter((k) => !blocked(k));
+      if (open.length < keys.length)
+        return controls.reset(open);
+      let patch = {};
+      for (let k of keys)
+        patch[k] = locked[k];
+      set(patch, { source: "reset", group }), options.onReset?.({ group });
+    },
+    isModified(key) {
+      let cur = get();
+      if (key !== void 0)
+        return !same(cur[key], locked[key]);
+      return !equal(cur, locked);
+    },
+    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;
+      let sub = Object.fromEntries(chosen.map((k) => [k, schema[k]]));
+      set(randomValues(sub, draw), { 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);
+    },
+    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), now = load();
+      if (comparing || !before || equal(before, now))
+        return;
+      comparing = before, options.onChange?.(changes(now, before), before, { source: "compare" }), notify();
+    },
+    preset(id) {
+      if (!Object.hasOwn(presets, id))
+        throw Error(`Unknown preset: ${id}`);
+      set(presets[id], { source: "preset" });
+    },
+    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;
+      set(preset.values, { source: "preset", group, coalesce: presetOptions?.coalesce }), options.onPreset?.({ group, index, name: preset.name });
+    },
+    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: createVariants(() => schema, id, storageKey(id, "variants"), variantStorage, get, (v) => set(v, { source: "variant" }), notify, enabled),
+    attach(element, chip) {
+      let load = options.ship ? () => options.ship().then((m) => m.attach) : () => (__preload("e13znr7c"), import("./chunk-e13znr7c.js")).then((m) => m.attach);
+      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) : () => (__preload("ktsn42p7"), import("./chunk-ktsn42p7.js")).then((m) => m.mountPanel);
+      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) => isReadout2(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 watch2(opts);
+  if (kind === "sparkline")
+    return sparkline2(opts);
+  if (kind === "graph")
+    return graph2(opts);
+  if (kind === "meter")
+    return meter2(opts);
+  if (kind === "table")
+    return table2(opts);
+  return log2(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 action2(d.label, meta);
+  if (readoutDescriptor(d))
+    return readoutField(d);
+  if (d.kind === "toolbar")
+    return toolbar2(d.items.map(({ key, ...item }) => ({ ...item, id: key })), meta);
+  if (d.bind)
+    return flatSpring2({}, { ...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 knob2(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 choice2(def, list, {
+      ...meta,
+      labels,
+      ...d.display ? { display: d.display } : {}
+    });
+  }
+  if (d.kind === "spring")
+    return spring2(d.default, meta);
+  if (d.kind === "color")
+    return color2(parseColor2(d.default) ? d.default : "#808080", meta);
+  if (d.kind === "point")
+    return point2(d.default, { min: d.min ?? 0, max: d.max ?? 1, step: d.step, ...meta });
+  if (d.kind === "easing")
+    return easing2(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" ? vec32({ x: v.x ?? 0, y: v.y ?? 0, z: v.z ?? 0 }, opts) : vec22({ 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 range2([Number(v[0]), Number(v[1])], {
+      min: d.min ?? 0,
+      max: d.max ?? 1,
+      ...numbers,
+      ...meta
+    });
+  }
+  if (d.kind === "angle")
+    return angle2(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 seed2(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 keybind2(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 gradient2(stops, opts);
+    } catch {
+      return gradient2(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 ? curve2(points, opts) : curve2("linear", opts);
+  }
+  return toggle2(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 = flatSpring2({ 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(parseColor2(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(parseColor2(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" ? `${colorHex2(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" || meta.source === "reset")
+        return;
+      if (meta.source === "preset" && 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 {
+  CURVE_SHAPES2 as CURVE_SHAPES,
+  EASINGS2 as EASINGS,
+  SPRING2 as SPRING,
+  action2 as action,
+  angle2 as angle,
+  bezierCss2 as bezierCss,
+  bezierPoint2 as bezierPoint,
+  choice2 as choice,
+  color2 as color,
+  colorHex2 as colorHex,
+  comboFromEvent2 as comboFromEvent,
+  comboLabel2 as comboLabel,
+  comboParts2 as comboParts,
+  createRemoteControls,
+  curve2 as curve,
+  defineControls,
+  descriptorToField,
+  easing2 as easing,
+  flatSpring2 as flatSpring,
+  formatCode,
+  formatSwift,
+  fromDescriptors,
+  fromSettings,
+  gradient2 as gradient,
+  gradientCss2 as gradientCss,
+  graph2 as graph,
+  hasValue2 as hasValue,
+  isReadout2 as isReadout,
+  keybind2 as keybind,
+  knob2 as knob,
+  letterOf2 as letterOf,
+  log2 as log,
+  matchesCombo2 as matchesCombo,
+  memoryStorage2 as memoryStorage,
+  meter2 as meter,
+  normalizeCombo2 as normalizeCombo,
+  parseColor2 as parseColor,
+  point2 as point,
+  range2 as range,
+  sampleCurve2 as sampleCurve,
+  sampleGradient2 as sampleGradient,
+  seed2 as seed,
+  sparkline2 as sparkline,
+  spring2 as spring,
+  springCss2 as springCss,
+  springMotion2 as springMotion,
+  table2 as table,
+  toggle2 as toggle,
+  toolbar2 as toolbar,
+  toolbarShortcut2 as toolbarShortcut,
+  urlFlag2 as urlFlag,
+  vec22 as vec2,
+  vec32 as vec3,
+  watch2 as watch,
+  wrapAngle2 as wrapAngle
+};