@pixerate/editor 0.28.0 → 0.30.0

package/dist/parameters/index.cjs

@@ -0,0 +1,1320 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
+
+
+var _chunkXZ4L3R4Kcjs = require('../chunk-XZ4L3R4K.cjs');
+
+// src/parameters/schema.ts
+function humanizeParameterId(id) {
+  const words = id.replace(/^u(?=[A-Z])/, "").replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function parameterLabel(item) {
+  return _nullishCoalesce(item.label, () => ( humanizeParameterId(item.id)));
+}
+var HEX = /^#?([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function normalizeHexColor(input, alpha = false) {
+  const m = HEX.exec(input.trim());
+  if (!m) return null;
+  let digits = m[1].toLowerCase();
+  if (digits.length <= 4) digits = [...digits].map((c) => c + c).join("");
+  const rgb = digits.slice(0, 6);
+  const a = digits.length === 8 ? digits.slice(6) : "ff";
+  return alpha ? `#${rgb}${a}` : `#${rgb}`;
+}
+function hexToRgba01(hex, alpha = false) {
+  const n = normalizeHexColor(hex, true);
+  if (!n) return null;
+  const parts = [1, 3, 5, 7].map((i) => parseInt(n.slice(i, i + 2), 16) / 255);
+  return alpha ? parts : parts.slice(0, 3);
+}
+function rgba01ToHex(components, alpha = false) {
+  const byte = (c) => Math.round(Math.min(1, Math.max(0, Number.isFinite(c) ? c : 0)) * 255).toString(16).padStart(2, "0");
+  const rgb = [0, 1, 2].map((i) => byte(_nullishCoalesce(components[i], () => ( 0)))).join("");
+  return alpha ? `#${rgb}${byte(_nullishCoalesce(components[3], () => ( 1)))}` : `#${rgb}`;
+}
+var isParameterGroup = (item) => item.type === "group";
+function getParameterFields(schema) {
+  const out = [];
+  const walk = (items) => {
+    for (const item of items) {
+      if (isParameterGroup(item)) walk(item.fields);
+      else out.push(item);
+    }
+  };
+  walk(Array.isArray(schema) ? schema : schema.fields);
+  return out;
+}
+function getParameterGroups(schema) {
+  const out = [];
+  const walk = (items) => {
+    for (const item of items) {
+      if (isParameterGroup(item)) {
+        out.push(item);
+        walk(item.fields);
+      }
+    }
+  };
+  walk(schema.fields);
+  return out;
+}
+var ParameterSchemaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParameterSchemaError";
+  }
+};
+var FIELD_TYPES = /* @__PURE__ */ new Set(["number", "int", "boolean", "choice", "color", "vector", "image", "text"]);
+function checkParameterSchema(schema) {
+  const problems = [];
+  const ids = /* @__PURE__ */ new Set();
+  const visit = (items) => {
+    for (const item of items) {
+      if (!item || typeof item.id !== "string" || item.id === "") {
+        problems.push("Every field and group needs an id.");
+        continue;
+      }
+      if (ids.has(item.id)) problems.push(`The id "${item.id}" is used twice.`);
+      ids.add(item.id);
+      if (isParameterGroup(item)) {
+        visit(_nullishCoalesce(item.fields, () => ( [])));
+        continue;
+      }
+      if (!FIELD_TYPES.has(item.type)) {
+        problems.push(`Field "${item.id}" has an unknown type "${item.type}".`);
+        continue;
+      }
+      if (item.type === "choice" && (!item.options || item.options.length === 0)) {
+        problems.push(`Field "${item.id}" needs at least one option.`);
+        continue;
+      }
+      if (item.type === "vector") {
+        const size = vectorSize(item);
+        if (size < 2 || size > 4) {
+          problems.push(`Field "${item.id}" must have 2 to 4 components.`);
+          continue;
+        }
+      }
+      const error = validateParameterValue(item, item.default);
+      if (error) problems.push(`Field "${item.id}" has an invalid default: ${error.message}`);
+    }
+  };
+  visit(_nullishCoalesce(schema.fields, () => ( [])));
+  const presetNames = /* @__PURE__ */ new Set();
+  for (const preset of _nullishCoalesce(schema.presets, () => ( []))) {
+    if (presetNames.has(preset.name)) problems.push(`The preset name "${preset.name}" is used twice.`);
+    presetNames.add(preset.name);
+  }
+  return problems;
+}
+function getParameterDefaults(schema) {
+  const values = {};
+  for (const field of getParameterFields(schema)) {
+    const result = coerceParameterValue(field, field.default);
+    values[field.id] = result.ok ? result.value : cloneValue(field.default);
+  }
+  return values;
+}
+var cloneValue = (value) => Array.isArray(value) ? [...value] : value;
+function parameterValuesEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => v === b[i]);
+  return false;
+}
+var truthy = (v) => Array.isArray(v) ? v.some((c) => c !== 0) : v !== void 0 && v !== false && v !== 0 && v !== "";
+function testCondition(value, test) {
+  if (Array.isArray(test)) return test.some((option) => parameterValuesEqual(value, option));
+  if (typeof test !== "object" || test === null) return parameterValuesEqual(value, test);
+  const t = test;
+  if (t.eq !== void 0 && !parameterValuesEqual(value, t.eq)) return false;
+  if (t.ne !== void 0 && parameterValuesEqual(value, t.ne)) return false;
+  if (t.in && !t.in.some((option) => parameterValuesEqual(value, option))) return false;
+  if (t.notIn && t.notIn.some((option) => parameterValuesEqual(value, option))) return false;
+  if (t.truthy !== void 0 && truthy(value) !== t.truthy) return false;
+  const n = typeof value === "number" ? value : NaN;
+  if (t.gt !== void 0 && !(n > t.gt)) return false;
+  if (t.gte !== void 0 && !(n >= t.gte)) return false;
+  if (t.lt !== void 0 && !(n < t.lt)) return false;
+  if (t.lte !== void 0 && !(n <= t.lte)) return false;
+  return true;
+}
+function evaluateParameterCondition(condition, values) {
+  if (!condition) return true;
+  if (typeof condition === "function") {
+    try {
+      return condition(values) !== false;
+    } catch (e2) {
+      return true;
+    }
+  }
+  return Object.entries(condition).every(([id, test]) => testCondition(values[id], test));
+}
+function getParameterVisibility(schema, values) {
+  const visible = {};
+  const walk = (items, parentVisible) => {
+    for (const item of items) {
+      const shown = parentVisible && evaluateParameterCondition(item.showIf, values);
+      visible[item.id] = shown;
+      if (isParameterGroup(item)) walk(item.fields, shown);
+    }
+  };
+  walk(schema.fields, true);
+  return visible;
+}
+function getChoiceOptions(field) {
+  return field.options.map((o) => typeof o === "object" ? o : { value: o });
+}
+var choiceOptionLabel = (option) => _nullishCoalesce(option.label, () => ( (typeof option.value === "string" ? humanizeParameterId(option.value) : String(option.value))));
+function vectorSize(field) {
+  return _nullishCoalesce(field.size, () => ( (Array.isArray(field.default) ? field.default.length : 2)));
+}
+var pick = (bound, i) => typeof bound === "number" ? bound : _optionalChain([bound, 'optionalAccess', _2 => _2[i]]);
+function vectorComponentField(field, index) {
+  const labels = _nullishCoalesce(field.labels, () => ( ["x", "y", "z", "w"]));
+  return {
+    id: `${field.id}.${index}`,
+    type: "number",
+    label: _nullishCoalesce(labels[index], () => ( String(index))),
+    default: _nullishCoalesce(field.default[index], () => ( 0)),
+    min: pick(field.min, index),
+    max: pick(field.max, index),
+    step: field.step,
+    unit: field.unit,
+    decimals: field.decimals,
+    control: "input"
+  };
+}
+function parameterStep(field) {
+  if (field.step !== void 0 && field.step > 0) return field.type === "int" ? Math.max(1, Math.round(field.step)) : field.step;
+  if (field.type === "int") return 1;
+  if (field.min !== void 0 && field.max !== void 0 && field.max > field.min) return (field.max - field.min) / 100;
+  return 0.01;
+}
+function parameterDecimals(field) {
+  if (field.decimals !== void 0) return field.decimals;
+  if (field.type === "int") return 0;
+  const step = parameterStep(field);
+  for (let d = 0; d <= 4; d++) if (Math.abs(Math.round(step * 10 ** d) - step * 10 ** d) < 1e-9) return d;
+  return 4;
+}
+var isSliderField = (field) => field.control ? field.control === "slider" : field.min !== void 0 && field.max !== void 0;
+function formatParameterNumber(field, value) {
+  const fixed = (Number.isFinite(value) ? value : 0).toFixed(parameterDecimals(field));
+  const trimmed = fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
+  return `${trimmed === "-0" ? "0" : trimmed}${_nullishCoalesce(field.unit, () => ( ""))}`;
+}
+function clampParameterNumber(field, value) {
+  let v = Number.isFinite(value) ? value : field.default;
+  if (field.min !== void 0) v = Math.max(field.min, v);
+  if (field.max !== void 0) v = Math.min(field.max, v);
+  if (field.type === "int") return Math.round(v);
+  return Math.round(v * 1e6) / 1e6;
+}
+function parseParameterNumberInput(field, text) {
+  let t = text.trim();
+  if (field.unit && t.endsWith(field.unit)) t = t.slice(0, -field.unit.length).trim();
+  if (t === "") return null;
+  const n = Number(t.replace(",", "."));
+  return Number.isFinite(n) ? clampParameterNumber(field, n) : null;
+}
+function formatParameterValue(field, value) {
+  if (value === void 0) return "";
+  switch (field.type) {
+    case "number":
+    case "int":
+      return formatParameterNumber(field, value);
+    case "boolean":
+      return value ? "On" : "Off";
+    case "choice": {
+      const option = getChoiceOptions(field).find((o) => o.value === value);
+      return option ? choiceOptionLabel(option) : String(value);
+    }
+    case "vector":
+      return value.map((v, i) => formatParameterNumber(vectorComponentField(field, i), v)).join(", ");
+    default:
+      return String(value);
+  }
+}
+var describe = (v) => v === null ? "null" : Array.isArray(v) ? "a list" : typeof v === "string" ? `"${v.length > 40 ? `${v.slice(0, 40)}\u2026` : v}"` : String(v);
+function err(field, message, index) {
+  return { id: field.id, path: index === void 0 ? `/${field.id}` : `/${field.id}/${index}`, message };
+}
+function numberError(field, name, v, opts, index) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return err(field, `${name} must be a number, not ${describe(v)}.`, index);
+  if (opts.int && !Number.isInteger(v)) return err(field, `${name} must be a whole number.`, index);
+  if (opts.min !== void 0 && v < opts.min) return err(field, `${name} must be at least ${opts.min}.`, index);
+  if (opts.max !== void 0 && v > opts.max) return err(field, `${name} must be at most ${opts.max}.`, index);
+  return null;
+}
+function validateParameterValue(field, value) {
+  const name = parameterLabel(field);
+  switch (field.type) {
+    case "number":
+    case "int":
+      return numberError(field, name, value, { int: field.type === "int", min: field.min, max: field.max });
+    case "boolean":
+      return typeof value === "boolean" ? null : err(field, `${name} must be true or false.`);
+    case "choice": {
+      const options = getChoiceOptions(field);
+      if (options.some((o) => o.value === value)) return null;
+      return err(field, `${name} must be one of ${options.map((o) => JSON.stringify(o.value)).join(", ")}, not ${describe(value)}.`);
+    }
+    case "color": {
+      const example = field.alpha ? '"#77c16aff"' : '"#77c16a"';
+      if (typeof value !== "string" || normalizeHexColor(value, !!field.alpha) === null) {
+        return err(field, `${name} must be a hex colour like ${example}.`);
+      }
+      return null;
+    }
+    case "vector": {
+      const size = vectorSize(field);
+      if (!Array.isArray(value) || value.length !== size) return err(field, `${name} must be a list of ${size} numbers.`);
+      for (let i = 0; i < size; i++) {
+        const component = `${name} ${_nullishCoalesce((_nullishCoalesce(field.labels, () => ( ["x", "y", "z", "w"])))[i], () => ( i))}`;
+        const e = numberError(field, component, value[i], { int: false, min: pick(field.min, i), max: pick(field.max, i) }, i);
+        if (e) return e;
+      }
+      return null;
+    }
+    case "image":
+      return typeof value === "string" ? null : err(field, `${name} must be an image URL (or "" for none).`);
+    case "text": {
+      if (typeof value !== "string") return err(field, `${name} must be text.`);
+      if (field.minLength !== void 0 && value.length < field.minLength) {
+        return err(field, `${name} must be at least ${field.minLength} characters.`);
+      }
+      if (field.maxLength !== void 0 && value.length > field.maxLength) {
+        return err(field, `${name} must be at most ${field.maxLength} characters.`);
+      }
+      if (field.pattern !== void 0) {
+        let regex = null;
+        try {
+          regex = new RegExp(`^(?:${field.pattern})$`, "u");
+        } catch (e3) {
+        }
+        if (regex && !regex.test(value)) return err(field, `${name} must match the pattern ${field.pattern}.`);
+      }
+      return null;
+    }
+    default:
+      return err(field, `${name} has an unknown type.`);
+  }
+}
+function coerceParameterValue(field, raw) {
+  let value = raw;
+  if (field.type === "int" && typeof raw === "number" && Number.isFinite(raw)) value = Math.round(raw);
+  if (field.type === "color" && typeof raw === "string") value = _nullishCoalesce(normalizeHexColor(raw, !!field.alpha), () => ( raw));
+  if (field.type === "vector" && Array.isArray(raw)) value = [...raw];
+  const error = validateParameterValue(field, value);
+  return error ? { ok: false, error } : { ok: true, value };
+}
+function validateParameterValues(schema, values) {
+  const errors = [];
+  for (const field of getParameterFields(schema)) {
+    const value = values[field.id];
+    if (value === void 0) {
+      errors.push(err(field, `${parameterLabel(field)} is missing.`));
+      continue;
+    }
+    const error = validateParameterValue(field, value);
+    if (error) errors.push(error);
+  }
+  return errors;
+}
+function parameterFieldToJsonSchema(field) {
+  const description = [parameterLabel(field), field.description].filter(Boolean).join(": ");
+  const base = { title: parameterLabel(field), description, default: field.default };
+  switch (field.type) {
+    case "number":
+    case "int": {
+      const unit = field.unit ? ` (${field.unit})` : "";
+      return {
+        ...base,
+        description: description + unit,
+        type: field.type === "int" ? "integer" : "number",
+        ...field.min !== void 0 ? { minimum: field.min } : {},
+        ...field.max !== void 0 ? { maximum: field.max } : {}
+      };
+    }
+    case "boolean":
+      return { ...base, type: "boolean" };
+    case "choice": {
+      const options = getChoiceOptions(field);
+      return { ...base, enum: options.map((o) => o.value) };
+    }
+    case "color":
+      return {
+        ...base,
+        type: "string",
+        description: `${description} (hex colour${field.alpha ? " with alpha, #rrggbbaa" : ", #rrggbb"})`,
+        pattern: field.alpha ? "^#?([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$" : "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
+      };
+    case "vector": {
+      const size = vectorSize(field);
+      const items = { type: "number" };
+      if (typeof field.min === "number") items.minimum = field.min;
+      if (typeof field.max === "number") items.maximum = field.max;
+      return { ...base, type: "array", items, minItems: size, maxItems: size };
+    }
+    case "image":
+      return { ...base, type: "string", description: `${description} (image URL, "" for none)` };
+    case "text":
+      return {
+        ...base,
+        type: "string",
+        ...field.minLength !== void 0 ? { minLength: field.minLength } : {},
+        ...field.maxLength !== void 0 ? { maxLength: field.maxLength } : {}
+      };
+  }
+}
+function parameterSchemaToJsonSchema(schema) {
+  const properties = {};
+  for (const field of getParameterFields(schema)) properties[field.id] = parameterFieldToJsonSchema(field);
+  return { type: "object", properties, additionalProperties: false };
+}
+
+// src/parameters/keyframes.ts
+var PARAMETER_KEY_TOLERANCE = 0.5;
+function findParameterKeyframe(track, time, tolerance = PARAMETER_KEY_TOLERANCE) {
+  if (!track) return -1;
+  return track.keyframes.findIndex((k) => Math.abs(k.time - time) <= tolerance);
+}
+function getParameterKeyState(track, time, tolerance = PARAMETER_KEY_TOLERANCE) {
+  if (!track || track.keyframes.length === 0) return "none";
+  return findParameterKeyframe(track, time, tolerance) >= 0 ? "keyed" : "animated";
+}
+var sortKeys = (keys) => keys.sort((a, b) => a.time - b.time);
+function withParameterKeyframe(track, key, tolerance = PARAMETER_KEY_TOLERANCE) {
+  const keyframes = [..._nullishCoalesce(_optionalChain([track, 'optionalAccess', _3 => _3.keyframes]), () => ( []))];
+  const at = findParameterKeyframe(track, key.time, tolerance);
+  if (at >= 0) keyframes[at] = { ...keyframes[at], value: key.value, ...key.easing !== void 0 ? { easing: key.easing } : {} };
+  else keyframes.push({ ...key });
+  return { ..._nullishCoalesce(track, () => ( {})), keyframes: sortKeys(keyframes) };
+}
+function withoutParameterKeyframe(track, time, tolerance = PARAMETER_KEY_TOLERANCE) {
+  if (!track) return void 0;
+  const keyframes = track.keyframes.filter((k) => Math.abs(k.time - time) > tolerance);
+  return keyframes.length ? { ...track, keyframes } : void 0;
+}
+function createParameterKeyframeStore(initial = {}) {
+  let tracks = { ...initial };
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((l) => l());
+  return {
+    getTrack: (id) => tracks[id],
+    getTracks: () => tracks,
+    setTrack(id, track) {
+      const next = { ...tracks };
+      if (track && track.keyframes.length > 0) next[id] = { ...track, keyframes: sortKeys([...track.keyframes]) };
+      else delete next[id];
+      tracks = next;
+      emit();
+    },
+    setTracks(next, silent) {
+      tracks = { ...next };
+      if (!silent) emit();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/parameters/controller.ts
+function seededRandom(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var unknownMessage = (id, fields) => `There is no parameter "${id}"; expected one of ${fields.map((f) => `"${f.id}"`).join(", ")}.`;
+var ParametersController = (_class = class {
+  
+  
+  __init() {this.fields = []}
+  __init2() {this.fieldMap = /* @__PURE__ */ new Map()}
+  __init3() {this.defaults = {}}
+  __init4() {this.values = {}}
+  
+  __init5() {this.collapsed = {}}
+  __init6() {this.errors = {}}
+  
+  
+  
+  
+  
+  __init7() {this.listeners = /* @__PURE__ */ new Set()}
+  __init8() {this.cleanups = []}
+  __init9() {this.gestureId = null}
+  __init10() {this.gestureCount = 0}
+  __init11() {this.revision = 0}
+  __init12() {this.applying = false}
+  
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);
+    this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
+    this.schema = options.schema;
+    this.userPresets = (_nullishCoalesce(options.presets, () => ( []))).map((p) => ({ ...p, values: { ...p.values }, builtIn: false }));
+    this.time = _nullishCoalesce(options.time, () => ( 0));
+    this.keyframes = options.keyframes;
+    this.keyTolerance = _nullishCoalesce(options.keyTolerance, () => ( PARAMETER_KEY_TOLERANCE));
+    this.random = _nullishCoalesce(options.random, () => ( Math.random));
+    this.onChange = options.onChange;
+    this.indexSchema(options.schema);
+    for (const group of getParameterGroups(this.schema)) if (group.collapsed) this.collapsed[group.id] = true;
+    this.values = this.adopt(_nullishCoalesce(options.values, () => ( {})), this.defaults);
+    this.state = this.computeState();
+    this.cleanups.push(
+      this.history.subscribe((h) => {
+        const s = this.state;
+        if (this.applying || s.canUndo === h.canUndo && s.canRedo === h.canRedo && s.undoLabel === h.undoName && s.redoLabel === h.redoName) return;
+        this.notify();
+      })
+    );
+    this.watchKeyframes();
+  }
+  
+  watchKeyframes() {
+    _optionalChain([this, 'access', _4 => _4.unwatchKeyframes, 'optionalCall', _5 => _5()]);
+    this.unwatchKeyframes = _optionalChain([this, 'access', _6 => _6.keyframes, 'optionalAccess', _7 => _7.subscribe, 'optionalCall', _8 => _8(() => {
+      if (!this.applying) this.notify();
+    })]);
+  }
+  // -------------------------------------------------------------------------
+  // State
+  // -------------------------------------------------------------------------
+  /** The current snapshot (stable until the next change). */
+  __init13() {this.getState = () => this.state}
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  __init14() {this.subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }}
+  getSchema() {
+    return this.schema;
+  }
+  getField(id) {
+    return this.fieldMap.get(id);
+  }
+  getValue(id) {
+    return this.values[id];
+  }
+  getValues() {
+    return this.values;
+  }
+  indexSchema(schema) {
+    const problems = checkParameterSchema(schema);
+    if (problems.length) throw new ParameterSchemaError(problems.join(" "));
+    this.fields = getParameterFields(schema);
+    this.fieldMap = new Map(this.fields.map((f) => [f.id, f]));
+    this.defaults = getParameterDefaults(schema);
+  }
+  /** Values for every field: valid entries of `values`, else `fallback`. Invalid ones are reported. */
+  adopt(values, fallback) {
+    const out = {};
+    for (const field of this.fields) {
+      const raw = values[field.id];
+      if (raw === void 0) {
+        out[field.id] = cloneValue(_nullishCoalesce(fallback[field.id], () => ( field.default)));
+        continue;
+      }
+      const result = coerceParameterValue(field, raw);
+      if (result.ok) out[field.id] = result.value;
+      else {
+        out[field.id] = cloneValue(_nullishCoalesce(fallback[field.id], () => ( field.default)));
+        this.errors = { ...this.errors, [field.id]: result.error.message };
+      }
+    }
+    return out;
+  }
+  allPresets() {
+    const builtIn = (_nullishCoalesce(this.schema.presets, () => ( []))).map((p) => ({ ...p, builtIn: true }));
+    const names = new Set(builtIn.map((p) => p.name));
+    return [...builtIn, ...this.userPresets.filter((p) => !names.has(p.name))];
+  }
+  presetValues(preset, base) {
+    const out = { ...base };
+    for (const field of this.fields) {
+      const raw = preset.values[field.id];
+      if (raw === void 0) continue;
+      const result = coerceParameterValue(field, raw);
+      if (result.ok) out[field.id] = result.value;
+    }
+    return out;
+  }
+  computeState() {
+    const history = this.history.getState();
+    const presets = this.allPresets();
+    const keys = {};
+    if (this.keyframes) {
+      for (const field of this.fields) keys[field.id] = getParameterKeyState(this.keyframes.getTrack(field.id), this.time, this.keyTolerance);
+    }
+    const same = (a) => this.fields.every((f) => parameterValuesEqual(a[f.id], this.values[f.id]));
+    return {
+      schema: this.schema,
+      fields: this.fields,
+      values: this.values,
+      defaults: this.defaults,
+      visible: getParameterVisibility(this.schema, this.values),
+      collapsed: this.collapsed,
+      errors: this.errors,
+      presets,
+      activePreset: _nullishCoalesce(_optionalChain([presets, 'access', _9 => _9.find, 'call', _10 => _10((p) => same(this.presetValues(p, this.defaults))), 'optionalAccess', _11 => _11.name]), () => ( null)),
+      modified: !same(this.defaults),
+      time: this.time,
+      keyframesEnabled: !!this.keyframes,
+      keys,
+      gesture: this.gestureId,
+      canUndo: history.canUndo,
+      canRedo: history.canRedo,
+      undoLabel: history.undoName,
+      redoLabel: history.redoName,
+      revision: this.revision
+    };
+  }
+  notify(changed = []) {
+    this.revision++;
+    this.state = this.computeState();
+    if (changed.length) _optionalChain([this, 'access', _12 => _12.onChange, 'optionalCall', _13 => _13(this.values, changed)]);
+    const state = this.state;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[ParametersController] Error in state listener:", error);
+      }
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Changes (all edits go through one undoable command shape)
+  // -------------------------------------------------------------------------
+  apply(change, side) {
+    const changed = [];
+    this.applying = true;
+    try {
+      if (change.values) {
+        const patch = change.values[side];
+        const next = { ...this.values };
+        for (const [id, value] of Object.entries(patch)) {
+          if (!this.fieldMap.has(id) || value === void 0) continue;
+          next[id] = cloneValue(value);
+          changed.push(id);
+          if (id in this.errors) {
+            const { [id]: _, ...rest } = this.errors;
+            this.errors = rest;
+          }
+        }
+        this.values = next;
+      }
+      if (change.presets) this.userPresets = change.presets[side].map((p) => ({ ...p }));
+      if (change.tracks && this.keyframes) {
+        for (const [id, t] of Object.entries(change.tracks)) this.keyframes.setTrack(id, t[side]);
+      }
+    } finally {
+      this.applying = false;
+    }
+    this.notify(changed);
+  }
+  command(name, change, tag) {
+    return {
+      name,
+      tag,
+      execute: () => this.apply(change, "after"),
+      undo: () => this.apply(change, "before"),
+      redo: () => this.apply(change, "after")
+    };
+  }
+  /** Track updates that keep keys at the playhead in step with new values. */
+  keyUpdates(after) {
+    if (!this.keyframes) return void 0;
+    let tracks;
+    for (const [id, value] of Object.entries(after)) {
+      const track = this.keyframes.getTrack(id);
+      if (value === void 0 || findParameterKeyframe(track, this.time, this.keyTolerance) < 0) continue;
+      (tracks ??= {})[id] = { before: track, after: withParameterKeyframe(track, { time: this.time, value }, this.keyTolerance) };
+    }
+    return tracks;
+  }
+  record(name, after, extra = {}) {
+    const before = {};
+    for (const id of Object.keys(after)) before[id] = cloneValue(this.values[id]);
+    const tracks = { ..._nullishCoalesce(this.keyUpdates(after), () => ( {})), ..._nullishCoalesce(extra.tracks, () => ( {})) };
+    const change = { values: { before, after }, ...extra, ...Object.keys(tracks).length ? { tracks } : {} };
+    this.history.execute(this.command(name, change));
+  }
+  reject(errors) {
+    const next = { ...this.errors };
+    for (const e of errors) next[e.id] = e.message;
+    this.errors = next;
+    this.notify();
+  }
+  /** Only the entries of `values` that differ from the current values. */
+  diff(values) {
+    const out = {};
+    for (const [id, value] of Object.entries(values)) {
+      if (value !== void 0 && !parameterValuesEqual(this.values[id], value)) out[id] = value;
+    }
+    return out;
+  }
+  clearErrors(ids) {
+    if (!ids.some((id) => id in this.errors)) return false;
+    const next = { ...this.errors };
+    for (const id of ids) delete next[id];
+    this.errors = next;
+    return true;
+  }
+  /**
+   * Sets one value after validating it (`int`s round, colours normalise). Invalid values are
+   * not stored; the error is returned and shown in `state.errors`. One undo step, or part of
+   * the current gesture (see `beginGesture`).
+   */
+  setValue(id, value, options = {}) {
+    const field = this.fieldMap.get(id);
+    if (!field) {
+      const message = unknownMessage(id, this.fields);
+      return { ok: false, error: { id, path: `/${id}`, message }, message };
+    }
+    const result = coerceParameterValue(field, value);
+    if (!result.ok) {
+      this.reject([result.error]);
+      return { ok: false, error: result.error, message: result.error.message };
+    }
+    if (parameterValuesEqual(this.values[id], result.value)) {
+      if (this.clearErrors([id])) this.notify();
+      return { ok: true, value: result.value };
+    }
+    const name = _nullishCoalesce(options.label, () => ( `Change ${parameterLabel(field)}`));
+    if (this.gestureId !== null) {
+      const after = { [id]: result.value };
+      const before = { [id]: cloneValue(this.values[id]) };
+      const tracks = this.keyUpdates(after);
+      const change = { values: { before, after }, ...tracks ? { tracks } : {} };
+      this.history.executeMerged(this.command(name, change, `parameters.set:${id}`), {
+        key: `parameters.gesture:${this.gestureId}:${this.gestureCount}`
+      });
+    } else {
+      this.record(name, { [id]: result.value });
+    }
+    return { ok: true, value: result.value };
+  }
+  /**
+   * Sets several values as one undo step. All-or-nothing: if any id is unknown or any value
+   * invalid, nothing changes and every error is returned.
+   */
+  setValues(values, options = {}) {
+    const errors = [];
+    const coerced = {};
+    for (const [id, raw] of Object.entries(values)) {
+      if (raw === void 0) continue;
+      const field = this.fieldMap.get(id);
+      if (!field) {
+        errors.push({ id, path: `/${id}`, message: unknownMessage(id, this.fields) });
+        continue;
+      }
+      const result = coerceParameterValue(field, raw);
+      if (result.ok) coerced[id] = result.value;
+      else errors.push(result.error);
+    }
+    if (errors.length) {
+      this.reject(errors.filter((e) => this.fieldMap.has(e.id)));
+      return { ok: false, errors, message: errors.map((e) => e.message).join(" ") };
+    }
+    const after = this.diff(coerced);
+    const changed = Object.keys(after);
+    if (changed.length) {
+      const label = _nullishCoalesce(options.label, () => ( (changed.length === 1 ? `Change ${parameterLabel(this.fieldMap.get(changed[0]))}` : "Change parameters")));
+      this.record(label, after);
+    } else if (this.clearErrors(Object.keys(coerced))) this.notify();
+    return { ok: true, values: coerced, changed };
+  }
+  /**
+   * Starts a continuous edit of `id` (a slider drag): every `setValue` until `endGesture()`
+   * merges into one undo step.
+   */
+  beginGesture(id) {
+    if (this.gestureId === id) return;
+    this.history.endGesture();
+    this.gestureId = id;
+    this.gestureCount++;
+    this.notify();
+  }
+  /** Ends the current gesture; the next change is a new undo step. */
+  endGesture() {
+    if (this.gestureId === null) return;
+    this.gestureId = null;
+    this.history.endGesture();
+    this.notify();
+  }
+  /** Puts fields (default: all) back to their defaults as one undo step. */
+  reset(ids) {
+    const targets = _nullishCoalesce(ids, () => ( this.fields.map((f) => f.id)));
+    const unknown = targets.find((id) => !this.fieldMap.has(id));
+    if (unknown) return { ok: false, message: unknownMessage(unknown, this.fields) };
+    const after = this.diff(Object.fromEntries(targets.map((id) => [id, cloneValue(this.defaults[id])])));
+    const changed = Object.keys(after);
+    if (changed.length) {
+      const label = ids && changed.length === 1 ? `Reset ${parameterLabel(this.fieldMap.get(changed[0]))}` : "Reset parameters";
+      this.record(label, after);
+    } else if (this.clearErrors(targets)) this.notify();
+    return { ok: true };
+  }
+  /**
+   * Picks random values within each field's range, snapped to its step, as one undo step.
+   * Skips hidden fields, `randomize: false`, `readOnly`, image and text fields, and numbers
+   * without both `min` and `max`.
+   */
+  randomize(options = {}) {
+    const rand = _nullishCoalesce(options.random, () => ( (options.seed !== void 0 ? seededRandom(options.seed) : this.random)));
+    const visible = this.state.visible;
+    const explicit = options.ids !== void 0;
+    const errors = [];
+    const after = {};
+    for (const id of _nullishCoalesce(options.ids, () => ( this.fields.map((f) => f.id)))) {
+      const field = this.fieldMap.get(id);
+      if (!field) {
+        errors.push({ id, path: `/${id}`, message: unknownMessage(id, this.fields) });
+        continue;
+      }
+      if (!explicit && (!visible[id] || field.randomize === false || field.readOnly)) continue;
+      const value = randomValue(field, this.values[id], rand);
+      if (value !== void 0) after[id] = value;
+    }
+    if (errors.length) return { ok: false, errors, message: errors.map((e) => e.message).join(" ") };
+    const diff = this.diff(after);
+    const changed = Object.keys(diff);
+    if (changed.length) this.record("Randomize parameters", diff);
+    return { ok: true, values: after, changed };
+  }
+  // -------------------------------------------------------------------------
+  // Presets
+  // -------------------------------------------------------------------------
+  /** Applies a preset as one undo step. Fields it leaves out return to their defaults unless `merge`. */
+  applyPreset(name, options = {}) {
+    const preset = this.allPresets().find((p) => p.name === name);
+    if (!preset) return { ok: false, message: this.unknownPreset(name) };
+    const target = this.presetValues(preset, options.merge ? this.values : this.defaults);
+    const after = this.diff(target);
+    if (Object.keys(after).length) this.record(`Apply preset "${name}"`, after);
+    return { ok: true };
+  }
+  /** Saves the current values (all fields) as a user preset, replacing one with the same name. Undoable. */
+  savePreset(name, options = {}) {
+    const trimmed = name.trim();
+    if (!trimmed) return { ok: false, message: "A preset needs a name." };
+    if ((_nullishCoalesce(this.schema.presets, () => ( []))).some((p) => p.name === trimmed)) {
+      return { ok: false, message: `"${trimmed}" is a built-in preset; save under another name.` };
+    }
+    const preset = { name: trimmed, values: Object.fromEntries(this.fields.map((f) => [f.id, cloneValue(this.values[f.id])])) };
+    if (options.description) preset.description = options.description;
+    const before = this.userPresets;
+    const at = before.findIndex((p) => p.name === trimmed);
+    const after = at >= 0 ? before.map((p, i) => i === at ? preset : p) : [...before, preset];
+    this.history.execute(this.command(`Save preset "${trimmed}"`, { presets: { before, after } }));
+    return { ok: true };
+  }
+  /** Deletes a user preset (built-in presets cannot be deleted). Undoable. */
+  deletePreset(name) {
+    if ((_nullishCoalesce(this.schema.presets, () => ( []))).some((p) => p.name === name)) {
+      return { ok: false, message: `"${name}" is a built-in preset and cannot be deleted.` };
+    }
+    const before = this.userPresets;
+    if (!before.some((p) => p.name === name)) return { ok: false, message: this.unknownPreset(name) };
+    const after = before.filter((p) => p.name !== name);
+    this.history.execute(this.command(`Delete preset "${name}"`, { presets: { before, after } }));
+    return { ok: true };
+  }
+  unknownPreset(name) {
+    const names = this.allPresets().map((p) => `"${p.name}"`);
+    return `There is no preset "${name}"; ${names.length ? `expected one of ${names.join(", ")}` : "none are saved yet"}.`;
+  }
+  // -------------------------------------------------------------------------
+  // Keyframes
+  // -------------------------------------------------------------------------
+  /** Moves the playhead. `values` (e.g. evaluated from the tracks) are shown without an undo step. */
+  setTime(time, values) {
+    const t = Number.isFinite(time) ? Math.max(0, time) : 0;
+    const changed = [];
+    if (values) {
+      const next = { ...this.values };
+      for (const [id, raw] of Object.entries(values)) {
+        const field = this.fieldMap.get(id);
+        if (!field || raw === void 0) continue;
+        const result = coerceParameterValue(field, raw);
+        if (result.ok && !parameterValuesEqual(next[id], result.value)) {
+          next[id] = result.value;
+          changed.push(id);
+        }
+      }
+      this.values = next;
+    }
+    if (t === this.time && changed.length === 0) return;
+    this.time = t;
+    this.notify(changed);
+  }
+  /** `keyed`, `animated` or `none` for a field at `time` (default: the playhead). */
+  keyState(id, time = this.time) {
+    if (!this.keyframes) return "none";
+    return getParameterKeyState(this.keyframes.getTrack(id), time, this.keyTolerance);
+  }
+  /** Attaches (or with `undefined` detaches) a keyframes adapter. */
+  setKeyframes(keyframes) {
+    this.keyframes = keyframes;
+    this.watchKeyframes();
+    this.notify();
+  }
+  /**
+   * Adds a keyframe with the field's current value at `time` (default: the playhead), or
+   * removes the one already there. One undo step.
+   */
+  toggleKeyframe(id, time = this.time) {
+    if (!this.keyframes) return { ok: false, message: "Keyframes are not available here." };
+    const field = this.fieldMap.get(id);
+    if (!field) return { ok: false, message: unknownMessage(id, this.fields) };
+    const before = this.keyframes.getTrack(id);
+    const keyed = findParameterKeyframe(before, time, this.keyTolerance) >= 0;
+    const after = keyed ? withoutParameterKeyframe(before, time, this.keyTolerance) : withParameterKeyframe(before, { time, value: cloneValue(this.values[id]) }, this.keyTolerance);
+    const label = `${keyed ? "Remove keyframe from" : "Add keyframe to"} ${parameterLabel(field)}`;
+    this.history.execute(this.command(label, { tracks: { [id]: { before, after } } }));
+    return { ok: true, keyed: !keyed };
+  }
+  // -------------------------------------------------------------------------
+  // Groups, schema, persistence, history
+  // -------------------------------------------------------------------------
+  /** Collapses or expands a group (view state; not an undo step). */
+  setCollapsed(groupId, collapsed) {
+    if (!!this.collapsed[groupId] === collapsed) return;
+    const next = { ...this.collapsed };
+    if (collapsed) next[groupId] = true;
+    else delete next[groupId];
+    this.collapsed = next;
+    this.notify();
+  }
+  toggleCollapsed(groupId) {
+    this.setCollapsed(groupId, !this.collapsed[groupId]);
+  }
+  /**
+   * Replaces the schema (e.g. after a shader recompiles). Values that still fit their field
+   * are kept; others reset to the new default. Not an undo step; throws a
+   * `ParameterSchemaError` for an invalid schema.
+   */
+  setSchema(schema) {
+    const old = this.values;
+    this.indexSchema(schema);
+    this.schema = schema;
+    const kept = {};
+    for (const field of this.fields) {
+      const result = old[field.id] === void 0 ? null : coerceParameterValue(field, old[field.id]);
+      kept[field.id] = _optionalChain([result, 'optionalAccess', _14 => _14.ok]) ? result.value : cloneValue(this.defaults[field.id]);
+    }
+    const changed = this.fields.filter((f) => !parameterValuesEqual(old[f.id], kept[f.id])).map((f) => f.id);
+    this.values = kept;
+    this.errors = Object.fromEntries(Object.entries(this.errors).filter(([id]) => this.fieldMap.has(id)));
+    for (const group of getParameterGroups(schema)) if (group.collapsed && !(group.id in this.collapsed)) this.collapsed[group.id] = true;
+    this.collapsed = { ...this.collapsed };
+    this.notify(changed);
+  }
+  /** Values and user presets, for saving. */
+  toJSON() {
+    return {
+      values: Object.fromEntries(this.fields.map((f) => [f.id, cloneValue(this.values[f.id])])),
+      presets: this.userPresets.map(({ builtIn: _, ...p }) => ({ ...p, values: { ...p.values } }))
+    };
+  }
+  /**
+   * Replaces values (and user presets, when given) without an undo step, e.g. when opening a
+   * document. Missing values use defaults; invalid ones use defaults and are reported in
+   * `state.errors`. Clears the history when `clearHistory` is true.
+   */
+  load(snapshot, options = {}) {
+    const old = this.values;
+    this.errors = {};
+    this.values = this.adopt(_nullishCoalesce(snapshot.values, () => ( {})), this.defaults);
+    if (snapshot.presets) this.userPresets = snapshot.presets.map((p) => ({ ...p, values: { ...p.values }, builtIn: false }));
+    const changed = this.fields.filter((f) => !parameterValuesEqual(old[f.id], this.values[f.id])).map((f) => f.id);
+    if (options.clearHistory) {
+      this.applying = true;
+      try {
+        this.history.clear();
+      } finally {
+        this.applying = false;
+      }
+    }
+    this.notify(changed);
+  }
+  undo() {
+    this.endGesture();
+    return this.history.undo();
+  }
+  redo() {
+    this.endGesture();
+    return this.history.redo();
+  }
+  /** Stops listening to the history and keyframes adapter. */
+  destroy() {
+    this.cleanups.splice(0).forEach((fn) => fn());
+    _optionalChain([this, 'access', _15 => _15.unwatchKeyframes, 'optionalCall', _16 => _16()]);
+    this.unwatchKeyframes = void 0;
+    this.listeners.clear();
+  }
+}, _class);
+function createParametersController(options) {
+  return new ParametersController(options);
+}
+function randomNumber(rand, min, max, step, int) {
+  const raw = min + rand() * (max - min);
+  const snapped = step > 0 ? min + Math.round((raw - min) / step) * step : raw;
+  const v = Math.min(max, Math.max(min, snapped));
+  return int ? Math.round(v) : Math.round(v * 1e6) / 1e6;
+}
+function randomValue(field, current, rand) {
+  switch (field.type) {
+    case "number":
+    case "int":
+      if (field.min === void 0 || field.max === void 0) return void 0;
+      return randomNumber(rand, field.min, field.max, parameterStep(field), field.type === "int");
+    case "boolean":
+      return rand() < 0.5;
+    case "choice": {
+      const options = getChoiceOptions(field);
+      return options[Math.min(options.length - 1, Math.floor(rand() * options.length))].value;
+    }
+    case "color": {
+      const rgb = Array.from({ length: 3 }, () => Math.floor(rand() * 256).toString(16).padStart(2, "0")).join("");
+      const alpha = field.alpha ? (_nullishCoalesce(normalizeHexColor(String(_nullishCoalesce(current, () => ( field.default))), true), () => ( "#000000ff"))).slice(7) : "";
+      return `#${rgb}${alpha}`;
+    }
+    case "vector": {
+      const out = [];
+      for (let i = 0; i < vectorSize(field); i++) {
+        const c = vectorComponentField(field, i);
+        const now = Array.isArray(current) ? current[i] : c.default;
+        out.push(c.min === void 0 || c.max === void 0 ? now : randomNumber(rand, c.min, c.max, parameterStep(c), false));
+      }
+      return out;
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/parameters/commands.ts
+var fail = (message) => {
+  throw new Error(message);
+};
+var IDS = { type: "array", items: { type: "string" }, description: "Parameter ids (default: all)." };
+function createParameterCommands(controller, options = {}) {
+  const prefix = _nullishCoalesce(options.prefix, () => ( "parameters."));
+  const group = _nullishCoalesce(_nullishCoalesce(options.group, () => ( controller.getSchema().title)), () => ( "Parameters"));
+  const base = { group, ...options.scope ? { scope: options.scope } : {} };
+  const presetNames = () => controller.getState().presets.map((p) => p.name);
+  const set = {
+    ...base,
+    id: `${prefix}set`,
+    label: "Set Parameters\u2026",
+    keywords: ["change", "value", "control", "slider"],
+    description: "Sets one or more parameter values as one undo step. Invalid values change nothing and return why.",
+    // A getter so agents always see the current schema (it can change with `setSchema`).
+    get params() {
+      return {
+        type: "object",
+        properties: { values: { ...parameterSchemaToJsonSchema(controller.getSchema()), description: "Parameter id \u2192 new value." } },
+        required: ["values"]
+      };
+    },
+    run: (_ctx, params) => {
+      const result = controller.setValues(params.values);
+      if (!result.ok) fail(result.message);
+      return { changed: result.ok ? result.changed : [], values: controller.getValues() };
+    }
+  };
+  const commands = [
+    {
+      ...base,
+      id: `${prefix}list`,
+      label: "List Parameters",
+      readOnly: true,
+      keywords: ["controls", "values", "schema"],
+      description: "Lists every parameter with its type, constraints, current value and default.",
+      run: () => {
+        const state = controller.getState();
+        return {
+          parameters: state.fields.map((field) => ({
+            id: field.id,
+            label: parameterLabel(field),
+            type: field.type,
+            ...field.description ? { description: field.description } : {},
+            value: state.values[field.id],
+            default: state.defaults[field.id],
+            visible: state.visible[field.id] !== false,
+            ...state.keyframesEnabled ? { keyframe: state.keys[field.id] } : {},
+            schema: {
+              ...parameterFieldToJsonSchema(field),
+              ...field.type === "choice" ? { options: getChoiceOptions(field) } : {},
+              ...field.type === "vector" ? { size: vectorSize(field) } : {}
+            }
+          })),
+          presets: presetNames(),
+          time: state.time
+        };
+      }
+    },
+    set,
+    {
+      ...base,
+      id: `${prefix}reset`,
+      label: "Reset Parameters",
+      keywords: ["default", "revert", "clear"],
+      description: "Puts parameters back to their defaults.",
+      params: { type: "object", properties: { ids: IDS } },
+      enabled: (_ctx, params) => _optionalChain([params, 'optionalAccess', _17 => _17.ids]) || controller.getState().modified ? true : "Every parameter is already at its default.",
+      run: (_ctx, params) => {
+        const result = controller.reset(_optionalChain([params, 'optionalAccess', _18 => _18.ids]));
+        if (!result.ok) fail(result.message);
+        return { values: controller.getValues() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}randomize`,
+      label: "Randomize Parameters",
+      keywords: ["random", "shuffle", "surprise", "explore"],
+      description: "Picks random values within each parameter range (visible fields only unless `ids` is given).",
+      params: {
+        type: "object",
+        properties: { ids: IDS, seed: { type: "integer", description: "Seed for a repeatable result." } }
+      },
+      run: (_ctx, params) => {
+        const result = controller.randomize({ ids: _optionalChain([params, 'optionalAccess', _19 => _19.ids]), seed: _optionalChain([params, 'optionalAccess', _20 => _20.seed]) });
+        if (!result.ok) fail(result.message);
+        return { changed: result.ok ? result.changed : [], values: controller.getValues() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}applyPreset`,
+      label: "Apply Parameter Preset\u2026",
+      keywords: ["preset", "look", "style"],
+      description: "Applies a preset; parameters it leaves out return to their defaults unless `merge` is true.",
+      params: {
+        type: "object",
+        properties: { name: { type: "string", description: "Preset name (see parameters list)." }, merge: { type: "boolean" } },
+        required: ["name"]
+      },
+      enabled: () => presetNames().length ? true : "There are no presets.",
+      run: (_ctx, params) => {
+        const result = controller.applyPreset(params.name, { merge: params.merge });
+        if (!result.ok) fail(result.message);
+        return { values: controller.getValues() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}savePreset`,
+      label: "Save Parameter Preset\u2026",
+      keywords: ["preset", "store", "remember"],
+      description: "Saves the current values as a preset (replacing a user preset with the same name).",
+      params: {
+        type: "object",
+        properties: { name: { type: "string", minLength: 1 }, description: { type: "string" } },
+        required: ["name"]
+      },
+      run: (_ctx, params) => {
+        const result = controller.savePreset(params.name, { description: params.description });
+        if (!result.ok) fail(result.message);
+        return { presets: presetNames() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}deletePreset`,
+      label: "Delete Parameter Preset\u2026",
+      keywords: ["preset", "remove"],
+      params: { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
+      enabled: () => controller.getState().presets.some((p) => !p.builtIn) ? true : "There are no saved presets.",
+      run: (_ctx, params) => {
+        const result = controller.deletePreset(params.name);
+        if (!result.ok) fail(result.message);
+        return { presets: presetNames() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}toggleKeyframe`,
+      label: "Toggle Parameter Keyframe\u2026",
+      keywords: ["key", "animate", "diamond"],
+      description: "Adds a keyframe with the current value at `time` (default: the playhead), or removes the one there.",
+      params: {
+        type: "object",
+        properties: { id: { type: "string", description: "Parameter id." }, time: { type: "number", minimum: 0, description: "Time in ms." } },
+        required: ["id"]
+      },
+      enabled: () => controller.getState().keyframesEnabled ? true : "Keyframes are not available here.",
+      run: (_ctx, params) => {
+        const result = controller.toggleKeyframe(params.id, params.time);
+        if (!result.ok) fail(result.message);
+        return { keyed: result.ok && result.keyed, time: _nullishCoalesce(params.time, () => ( controller.getState().time)) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}undo`,
+      label: "Undo Parameter Change",
+      hidden: true,
+      enabled: () => controller.getState().canUndo ? true : "Nothing to undo.",
+      run: () => controller.undo()
+    },
+    {
+      ...base,
+      id: `${prefix}redo`,
+      label: "Redo Parameter Change",
+      hidden: true,
+      enabled: () => controller.getState().canRedo ? true : "Nothing to redo.",
+      run: () => controller.redo()
+    }
+  ];
+  return commands;
+}
+
+// src/parameters/shader.ts
+var SIZES = { vec2: 2, vec3: 3, vec4: 4 };
+function parameterFieldFromShaderControl(control) {
+  const common = {
+    id: control.name,
+    ...control.label ? { label: control.label } : {},
+    ...control.description ? { description: control.description } : {}
+  };
+  switch (control.type) {
+    case "bool":
+      return { ...common, type: "boolean", default: control.default === true };
+    case "sampler2D":
+      return { ...common, type: "image", default: typeof control.default === "string" ? control.default : "" };
+    case "float":
+    case "int":
+      return {
+        ...common,
+        type: control.type === "int" ? "int" : "number",
+        default: typeof control.default === "number" ? control.default : 0,
+        ...control.min !== void 0 ? { min: control.min } : {},
+        ...control.max !== void 0 ? { max: control.max } : {},
+        ...control.step !== void 0 ? { step: control.step } : {}
+      };
+    default: {
+      const size = SIZES[control.type];
+      const components = Array.isArray(control.default) ? control.default : Array.from({ length: size }, () => 0);
+      if (control.color && size >= 3) {
+        return { ...common, type: "color", alpha: size === 4, default: rgba01ToHex(components, size === 4) };
+      }
+      return {
+        ...common,
+        type: "vector",
+        size,
+        default: Array.from({ length: size }, (_, i) => _nullishCoalesce(components[i], () => ( 0))),
+        ...control.min !== void 0 ? { min: control.min } : {},
+        ...control.max !== void 0 ? { max: control.max } : {},
+        ...control.step !== void 0 ? { step: control.step } : {}
+      };
+    }
+  }
+}
+function parameterSchemaFromShaderControls(controls, options = {}) {
+  return { ...options.title ? { title: options.title } : {}, fields: controls.map(parameterFieldFromShaderControl) };
+}
+function shaderControlValue(control, value) {
+  if (control.color && typeof value === "string") {
+    return _nullishCoalesce(hexToRgba01(value, control.type === "vec4"), () => ( control.default));
+  }
+  return value;
+}
+function parameterValueFromShaderControl(control, value) {
+  if (control.color && Array.isArray(value)) return rgba01ToHex(value, control.type === "vec4");
+  return value;
+}
+
+// src/parameters/rangeMapper.ts
+function createRangeMapper(options = {}) {
+  const [inMin, inMax] = _nullishCoalesce(options.from, () => ( [0, 1]));
+  const [outMin, outMax] = _nullishCoalesce(options.to, () => ( [0, 1]));
+  const shouldClamp = _nullishCoalesce(options.clamp, () => ( true));
+  const easing = options.easing;
+  const inSpan = inMax - inMin;
+  const outSpan = outMax - outMin;
+  return function map(value) {
+    if (!Number.isFinite(value)) return outMin;
+    if (Math.abs(inSpan) < 1e-12) {
+      return outMin;
+    }
+    let normalized = (value - inMin) / inSpan;
+    if (shouldClamp) {
+      normalized = Math.min(1, Math.max(0, normalized));
+    }
+    let progress = normalized;
+    if (easing !== void 0 && easing !== null) {
+      if (typeof easing === "function") {
+        progress = easing(normalized);
+      } else {
+        progress = _chunkXZ4L3R4Kcjs.evaluateEasing.call(void 0, easing, normalized);
+      }
+    }
+    return outMin + progress * outSpan;
+  };
+}
+function mapRange(value, from, to, options) {
+  return createRangeMapper({ from, to, ...options })(value);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.PARAMETER_KEY_TOLERANCE = PARAMETER_KEY_TOLERANCE; exports.ParameterSchemaError = ParameterSchemaError; exports.ParametersController = ParametersController; exports.checkParameterSchema = checkParameterSchema; exports.choiceOptionLabel = choiceOptionLabel; exports.clampParameterNumber = clampParameterNumber; exports.cloneValue = cloneValue; exports.coerceParameterValue = coerceParameterValue; exports.createParameterCommands = createParameterCommands; exports.createParameterKeyframeStore = createParameterKeyframeStore; exports.createParametersController = createParametersController; exports.createRangeMapper = createRangeMapper; exports.evaluateParameterCondition = evaluateParameterCondition; exports.findParameterKeyframe = findParameterKeyframe; exports.formatParameterNumber = formatParameterNumber; exports.formatParameterValue = formatParameterValue; exports.getChoiceOptions = getChoiceOptions; exports.getParameterDefaults = getParameterDefaults; exports.getParameterFields = getParameterFields; exports.getParameterGroups = getParameterGroups; exports.getParameterKeyState = getParameterKeyState; exports.getParameterVisibility = getParameterVisibility; exports.hexToRgba01 = hexToRgba01; exports.humanizeParameterId = humanizeParameterId; exports.isParameterGroup = isParameterGroup; exports.isSliderField = isSliderField; exports.mapRange = mapRange; exports.normalizeHexColor = normalizeHexColor; exports.parameterDecimals = parameterDecimals; exports.parameterFieldFromShaderControl = parameterFieldFromShaderControl; exports.parameterFieldToJsonSchema = parameterFieldToJsonSchema; exports.parameterLabel = parameterLabel; exports.parameterSchemaFromShaderControls = parameterSchemaFromShaderControls; exports.parameterSchemaToJsonSchema = parameterSchemaToJsonSchema; exports.parameterStep = parameterStep; exports.parameterValueFromShaderControl = parameterValueFromShaderControl; exports.parameterValuesEqual = parameterValuesEqual; exports.parseParameterNumberInput = parseParameterNumberInput; exports.rgba01ToHex = rgba01ToHex; exports.seededRandom = seededRandom; exports.shaderControlValue = shaderControlValue; exports.validateParameterValue = validateParameterValue; exports.validateParameterValues = validateParameterValues; exports.vectorComponentField = vectorComponentField; exports.vectorSize = vectorSize; exports.withParameterKeyframe = withParameterKeyframe; exports.withoutParameterKeyframe = withoutParameterKeyframe;
+//# sourceMappingURL=index.cjs.map