@weasel-js/theme 1.4.4 → 1.5.1

package/dist/engine.js

@@ -0,0 +1,1761 @@
+import { ALPHA_EXT } from './chunk-PJMTWM34.js';
+import { mergeAxes, fullSelection, pick, enumerateSelections, resolveTokens, pickAll, themeAxes, isByAxis, selectionKey } from './chunk-LL2ERJPZ.js';
+import { srgbU8ToOklab, oklabToOklch, oklchToOklab, oklabToSrgbU8 } from '@weasel-js/paint';
+
+var clamp255 = (v) => Math.max(0, Math.min(255, Math.round(v)));
+function hexToRgb(hex) {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function toHex(L, C, H) {
+  const [l, a, b] = oklchToOklab(L, C, H * Math.PI / 180);
+  const [r, g, bl] = oklabToSrgbU8(l, a, b);
+  return `#${[r, g, bl].map((v) => clamp255(v).toString(16).padStart(2, "0")).join("")}`;
+}
+function toLch(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  const [L, A, B] = srgbU8ToOklab(r, g, b);
+  const [l, c, h] = oklabToOklch(L, A, B);
+  return { L: l, C: c, H: (h * 180 / Math.PI % 360 + 360) % 360 };
+}
+function chromaCap(L, H) {
+  return toLch(toHex(L, 0.5, H)).C;
+}
+function luminance(hex) {
+  const [r, g, b] = hexToRgb(hex).map((v) => v / 255);
+  const f = (u) => u <= 0.04045 ? u / 12.92 : ((u + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * f(r) + 0.7152 * f(g) + 0.0722 * f(b);
+}
+function contrast(a, b) {
+  const [hi, lo] = [luminance(a), luminance(b)].sort((p, q) => q - p);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function hueGap(a, b) {
+  const d = Math.abs(a - b) % 360;
+  return Math.min(d, 360 - d);
+}
+function toLab(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return srgbU8ToOklab(r, g, b);
+}
+var CHROMA_WEIGHT = 3;
+function deltaE(a, b) {
+  const [l1, a1, b1] = toLab(a);
+  const [l2, a2, b2] = toLab(b);
+  return Math.hypot(l1 - l2, CHROMA_WEIGHT * (a1 - a2), CHROMA_WEIGHT * (b1 - b2));
+}
+function vividAt(L, H) {
+  return toHex(L, chromaCap(L, H), H);
+}
+
+// src/engine/color/generate.ts
+function peakLightness(H) {
+  let bestL = 0.5;
+  let bestC = -1;
+  for (let L = 0.32; L <= 0.96; L += 0.01) {
+    const c = chromaCap(L, H);
+    if (c > bestC) {
+      bestC = c;
+      bestL = L;
+    }
+  }
+  return bestL;
+}
+var PEAK = [];
+for (let H = 0; H < 360; H += 1) PEAK.push(peakLightness(H));
+var peakAt = (H) => PEAK[(Math.round(H) % 360 + 360) % 360];
+function place(H, c) {
+  const L = peakAt(H) + (c.lightnessTarget - peakAt(H)) * c.lightnessPull;
+  return toHex(L, chromaCap(L, H) * c.chromaFraction, H);
+}
+var HUE_NAMES = [
+  [15, "rose"],
+  [45, "red"],
+  [62, "orange"],
+  [85, "amber"],
+  [100, "gold"],
+  [122, "yellow"],
+  [138, "lime"],
+  [165, "green"],
+  [195, "teal"],
+  [218, "cyan"],
+  [245, "sky"],
+  [275, "blue"],
+  [310, "violet"],
+  [345, "fuchsia"]
+];
+function hueName(H) {
+  for (const [ceil, name] of HUE_NAMES) if (H < ceil) return name;
+  return "rose";
+}
+function uniqueNames(hues) {
+  const seen = /* @__PURE__ */ new Map();
+  return hues.map((h) => {
+    const base = hueName(h);
+    const n = (seen.get(base) ?? 0) + 1;
+    seen.set(base, n);
+    return n === 1 ? base : `${base}-${n}`;
+  });
+}
+function equalizeChroma(hexes, k, anchored) {
+  if (k <= 0) return hexes;
+  const lch = hexes.map(toLch);
+  const target = lch.reduce((sum, x) => sum + x.C, 0) / lch.length;
+  return lch.map((x, i) => {
+    const wanted = x.C + (target - x.C) * k;
+    if (anchored[i]) return toHex(x.L, Math.min(wanted, chromaCap(x.L, x.H)), x.H);
+    if (chromaCap(x.L, x.H) >= wanted) return toHex(x.L, wanted, x.H);
+    let bestL = x.L;
+    let bestDistance = Infinity;
+    for (let L = 0.3; L <= 0.96; L += 5e-3) {
+      if (chromaCap(L, x.H) >= wanted) {
+        const d = Math.abs(L - x.L);
+        if (d < bestDistance) {
+          bestDistance = d;
+          bestL = L;
+        }
+      }
+    }
+    if (bestDistance === Infinity) {
+      const pk = peakAt(x.H);
+      return toHex(pk, chromaCap(pk, x.H), x.H);
+    }
+    return toHex(bestL, wanted, x.H);
+  });
+}
+function farthestFirst(hues) {
+  const order = [0];
+  while (order.length < hues.length) {
+    let best = -1;
+    let bestGap = -1;
+    for (let i = 0; i < hues.length; i += 1) {
+      if (order.includes(i)) continue;
+      const gap = Math.min(...order.map((j) => hueGap(hues[i], hues[j])));
+      if (gap > bestGap) {
+        bestGap = gap;
+        best = i;
+      }
+    }
+    order.push(best);
+  }
+  return order;
+}
+function floorDegrees(c) {
+  return c.hueFloor <= 0 ? 0 : c.hueFloor * 360 / Math.max(1, c.count);
+}
+function searchHues(c) {
+  const minGapDeg = floorDegrees(c);
+  const anchorHues = c.anchors.map((a) => a.hue);
+  const anchorHexes = c.anchors.map(toHexPreview);
+  const freeCount = c.count - c.anchors.length;
+  if (freeCount < 0) return null;
+  if (freeCount === 0) return [];
+  const weighted = (hex) => {
+    const [L, a, b] = toLab(hex);
+    return [L, CHROMA_WEIGHT * a, CHROMA_WEIGHT * b];
+  };
+  const between = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+  const placed = /* @__PURE__ */ new Map();
+  const at = (H) => {
+    const key = (Math.round(H) % 360 + 360) % 360;
+    let v = placed.get(key);
+    if (!v) {
+      const hex = place(key, c);
+      const lch = toLch(hex);
+      v = {
+        hex,
+        hue: lch.H,
+        contrast: contrast(hex, c.surface),
+        chroma: lch.C,
+        surfaceDistance: deltaE(hex, c.surface),
+        lab: weighted(hex)
+      };
+      placed.set(key, v);
+    }
+    return v;
+  };
+  const anchorMeta = anchorHexes.map((hex) => {
+    const lch = toLch(hex);
+    return {
+      hex,
+      hue: lch.H,
+      contrast: contrast(hex, c.surface),
+      chroma: lch.C,
+      surfaceDistance: deltaE(hex, c.surface),
+      lab: weighted(hex)
+    };
+  });
+  const metaFor = (free) => [...anchorMeta, ...free.map(at)];
+  const penalty = (free) => {
+    const m = metaFor(free);
+    let p = 0;
+    if (minGapDeg > 0) {
+      for (let i = 0; i < m.length; i += 1) {
+        for (let j = i + 1; j < m.length; j += 1) {
+          const short = minGapDeg - hueGap(m[i].hue, m[j].hue);
+          if (short > 0) p += short;
+        }
+      }
+    }
+    if (c.minContrast > 0) {
+      for (const x of m) {
+        const short = c.minContrast - x.contrast;
+        if (short > 0) p += short * 40;
+      }
+    }
+    if (c.minSurfaceDistance > 0) {
+      for (const x of m) {
+        const short = c.minSurfaceDistance - x.surfaceDistance;
+        if (short > 0) p += short * 400;
+      }
+    }
+    if (c.minDistance > 0) {
+      for (let i = 0; i < m.length; i += 1) {
+        for (let j = i + 1; j < m.length; j += 1) {
+          const short = c.minDistance - between(m[i].lab, m[j].lab);
+          if (short > 0) p += short * 400;
+        }
+      }
+    }
+    return p;
+  };
+  const score = (free) => {
+    const m = metaFor(free);
+    return m.reduce((sum, x) => sum + x.chroma, 0) / m.length;
+  };
+  const seeds = [];
+  const seedStep = Math.max(6, Math.round(freeCount * 1.6));
+  for (let start = 0; start < 360; start += seedStep) {
+    seeds.push(Array.from({ length: freeCount }, (_, i) => Math.round((start + i * 360 / freeCount) % 360)));
+  }
+  if (anchorHues.length > 0) {
+    const base = anchorHues[0];
+    const span = 360 - 2 * Math.max(minGapDeg, 1);
+    for (let jitter = -8; jitter <= 8; jitter += 2) {
+      for (const divisor of [Math.max(1, freeCount - 1), freeCount]) {
+        seeds.push(
+          Array.from(
+            { length: freeCount },
+            (_, i) => Math.round(((base + minGapDeg + jitter + i * span / divisor) % 360 + 360) % 360)
+          )
+        );
+      }
+    }
+  }
+  const STEPS = [-16, -8, -4, -2, -1, 1, 2, 4, 8, 16];
+  const penaltyAt = (m, i) => {
+    let p = 0;
+    const x = m[i];
+    if (c.minContrast > 0) {
+      const short = c.minContrast - x.contrast;
+      if (short > 0) p += short * 40;
+    }
+    if (c.minSurfaceDistance > 0) {
+      const short = c.minSurfaceDistance - x.surfaceDistance;
+      if (short > 0) p += short * 400;
+    }
+    for (let j = 0; j < m.length; j += 1) {
+      if (j === i) continue;
+      if (minGapDeg > 0) {
+        const short = minGapDeg - hueGap(x.hue, m[j].hue);
+        if (short > 0) p += short;
+      }
+      if (c.minDistance > 0) {
+        const short = c.minDistance - between(x.lab, m[j].lab);
+        if (short > 0) p += short * 400;
+      }
+    }
+    return p;
+  };
+  const descend = (hues, useChroma, keepLegal) => {
+    const current = [...hues];
+    let meta = metaFor(current);
+    const offset = anchorMeta.length;
+    for (let iteration = 0; iteration < 120; iteration += 1) {
+      let improved = false;
+      for (let i = 0; i < freeCount; i += 1) {
+        const slot = offset + i;
+        const beforeP = penaltyAt(meta, slot);
+        const beforeC = meta[slot].chroma;
+        for (const delta of STEPS) {
+          const next = ((current[i] + delta) % 360 + 360) % 360;
+          if (next === current[i]) continue;
+          const candidate = at(next);
+          const trialMeta = meta.slice();
+          trialMeta[slot] = candidate;
+          const afterP = penaltyAt(trialMeta, slot);
+          const better = useChroma ? (keepLegal ? afterP <= beforeP : true) && candidate.chroma > beforeC : afterP < beforeP;
+          if (!better) continue;
+          if (keepLegal && afterP > beforeP) continue;
+          current[i] = next;
+          meta = trialMeta;
+          improved = true;
+          break;
+        }
+      }
+      if (!improved) break;
+    }
+    return current;
+  };
+  let best = null;
+  let bestScore = -1;
+  for (const seed of seeds) {
+    const repaired = penalty(seed) > 0 ? descend(seed, false, false) : seed;
+    if (penalty(repaired) > 0) continue;
+    const tuned = descend(repaired, true, true);
+    if (penalty(tuned) > 0) continue;
+    const s = score(tuned);
+    if (s > bestScore) {
+      bestScore = s;
+      best = tuned;
+    }
+  }
+  return best;
+}
+function pairwiseMin(hexes) {
+  if (hexes.length < 2) return 1;
+  let min = Infinity;
+  for (let i = 0; i < hexes.length; i += 1) {
+    for (let j = i + 1; j < hexes.length; j += 1) min = Math.min(min, deltaE(hexes[i], hexes[j]));
+  }
+  return min;
+}
+function summarize(swatches, surface) {
+  const cs = swatches.map((s) => s.lch.C);
+  const ls = swatches.map((s) => s.lch.L);
+  let gap = 360;
+  for (let i = 0; i < swatches.length; i += 1) {
+    for (let j = i + 1; j < swatches.length; j += 1) {
+      gap = Math.min(gap, hueGap(swatches[i].lch.H, swatches[j].lch.H));
+    }
+  }
+  return {
+    meanChroma: cs.reduce((a, b) => a + b, 0) / (cs.length || 1),
+    chromaSpread: Math.max(...cs) - Math.min(...cs),
+    lightnessSpread: Math.max(...ls) - Math.min(...ls),
+    minHueGap: swatches.length > 1 ? gap : 360,
+    hueFloorShare: swatches.length > 1 ? gap * swatches.length / 360 : 1,
+    minContrast: Math.min(...swatches.map((s) => contrast(s.hex, surface))),
+    minSurfaceDistance: Math.min(...swatches.map((s) => deltaE(s.hex, surface))),
+    minDistance: pairwiseMin(swatches.map((s) => s.hex))
+  };
+}
+function generate(c) {
+  const found = searchHues(c);
+  const feasible = found !== null;
+  const free = found ?? Array.from(
+    { length: Math.max(0, c.count - c.anchors.length) },
+    (_, i) => Math.round(i * 360 / Math.max(1, c.count - c.anchors.length))
+  );
+  const hues = [...c.anchors.map((a) => a.hue), ...free];
+  const anchoredFlags = [...c.anchors.map(() => true), ...free.map(() => false)];
+  const raw = [
+    ...c.anchors.map(toHexPreview),
+    ...free.map((h) => place(h, c))
+  ];
+  const hexes = equalizeChroma(raw, c.equalize, anchoredFlags);
+  const order = c.order === "farthest" ? farthestFirst(hues) : [...hues.keys()].sort((a, b) => hues[a] - hues[b]);
+  const names = uniqueNames(order.map((i) => toLch(hexes[i]).H));
+  const swatches = order.map((i, position) => ({
+    name: c.anchors[i]?.name ?? names[position],
+    hex: hexes[i],
+    lch: toLch(hexes[i]),
+    anchored: anchoredFlags[i],
+    contrast: contrast(hexes[i], c.surface)
+  }));
+  return { swatches, stats: summarize(swatches, c.surface), feasible };
+}
+var DEFAULT_CONSTRAINTS = {
+  count: 10,
+  hueFloor: 0.9,
+  minContrast: 4,
+  surface: "#181a1e",
+  lightnessTarget: 0.72,
+  lightnessPull: 0.4,
+  chromaFraction: 0.95,
+  equalize: 0,
+  minSurfaceDistance: 0.25,
+  minDistance: 0.22,
+  anchors: [],
+  order: "farthest"
+};
+function toHexPreview(a) {
+  const cap = chromaCap(a.lightness, a.hue);
+  return toHex(a.lightness, a.chroma === void 0 ? cap : Math.min(a.chroma, cap), a.hue);
+}
+function anchorFromHex(hex, name) {
+  const { L, C, H } = toLch(hex);
+  return {
+    name: name ?? hueName(H),
+    hue: Math.round(H),
+    lightness: Number(L.toFixed(3)),
+    chroma: Number(C.toFixed(4))
+  };
+}
+
+// src/engine/steps.ts
+var stepList = (x) => Array.isArray(x) ? [...new Set(x.filter((s) => typeof s === "string"))] : [];
+function inEveryBranch(v, read) {
+  if (!isByAxis(v)) return read(v);
+  const lists = Object.entries(v).filter(([k]) => k !== "by").map(([, x]) => inEveryBranch(x, read));
+  return lists.length === 0 ? [] : lists.reduce((kept, list) => kept.filter((s) => list.includes(s)));
+}
+function alwaysDeclaredSteps(entry) {
+  return inEveryBranch(entry, (e) => typeof e === "object" && e !== null ? inEveryBranch(e.steps, stepList) : []);
+}
+function declaredSteps(entry) {
+  const out = /* @__PURE__ */ new Set();
+  const branches = (v, visit) => {
+    if (!isByAxis(v)) {
+      visit(v);
+      return;
+    }
+    for (const [k, x] of Object.entries(v)) if (k !== "by") branches(x, visit);
+  };
+  branches(entry, (e) => {
+    if (typeof e !== "object" || e === null) return;
+    branches(e.steps, (steps) => {
+      if (Array.isArray(steps)) {
+        for (const s of steps) if (typeof s === "string") out.add(s);
+      }
+    });
+  });
+  return [...out];
+}
+
+// src/engine/merge.ts
+var LAYERS = ["seeds", "ramps", "scales", "semantics", "components", "pins"];
+function ownSteps(def) {
+  const names = /* @__PURE__ */ new Set();
+  for (const layer of [def.ramps, def.scales]) {
+    for (const [name, entry] of Object.entries(layer ?? {})) for (const step of alwaysDeclaredSteps(entry)) names.add(`${name}-${step}`);
+  }
+  return names;
+}
+function mergeChain(def, lookup, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(def.name)) throw new Error(`extends cycle at theme "${def.name}"`);
+  if (!def.extends) return def;
+  const parentDef = lookup?.(def.extends);
+  if (!parentDef) throw new Error(`Theme "${def.name}" extends "${def.extends}", which is not defined`);
+  const parent = mergeChain(parentDef, lookup, /* @__PURE__ */ new Set([...seen, def.name]));
+  const out = { ...def };
+  for (const layer of LAYERS) out[layer] = { ...parent[layer] ?? {}, ...def[layer] ?? {} };
+  const shadowed = ownSteps(def);
+  const inherited = Object.entries(parent.pins ?? {}).filter(([name]) => !shadowed.has(name));
+  out.pins = { ...Object.fromEntries(inherited), ...def.pins ?? {} };
+  out.axes = mergeAxes(parent.axes ?? {}, def.axes ?? {});
+  return out;
+}
+
+// src/engine/deps.ts
+var SEED_REF = /^\{seeds\.([\w-]+)\}$/;
+var TOKEN_REF = /^\{([^}.]+)\}$/;
+var node = () => ({ axes: /* @__PURE__ */ new Set(), seeds: /* @__PURE__ */ new Set(), edges: /* @__PURE__ */ new Set() });
+function scan(v, into) {
+  if (typeof v === "string") {
+    const s = v.trim();
+    const seed = SEED_REF.exec(s);
+    if (seed) into.seeds.add(seed[1]);
+    else {
+      const ref = TOKEN_REF.exec(s);
+      if (ref) into.edges.add(ref[1]);
+    }
+    return;
+  }
+  if (Array.isArray(v)) {
+    for (const x of v) scan(x, into);
+    return;
+  }
+  if (typeof v === "object" && v !== null) {
+    if (isByAxis(v)) into.axes.add(v.by);
+    for (const [k, x] of Object.entries(v)) if (k !== "by") scan(x, into);
+  }
+}
+function scanSteps(entry, into) {
+  if (isByAxis(entry)) {
+    into.axes.add(entry.by);
+    for (const [k, x] of Object.entries(entry)) if (k !== "by") scanSteps(x, into);
+  } else if (typeof entry === "object" && entry !== null) {
+    scan(entry.steps, into);
+  }
+}
+var stepsKey = (ramp) => `ramps.${ramp}`;
+function leaves(v) {
+  return isByAxis(v) ? Object.entries(v).filter(([k]) => k !== "by").flatMap(([, x]) => leaves(x)) : [v];
+}
+function axisDependencies(definition, lookup) {
+  const def = mergeChain(definition, lookup);
+  const nodes = /* @__PURE__ */ new Map();
+  const stepRamps = /* @__PURE__ */ new Map();
+  for (const [name, ramp] of Object.entries(def.ramps ?? {})) {
+    const shape = node();
+    scanSteps(ramp, shape);
+    nodes.set(stepsKey(name), shape);
+    const n = node();
+    scan(ramp, n);
+    for (const step of declaredSteps(ramp)) {
+      nodes.set(`${name}-${step}`, n);
+      stepRamps.set(`${name}-${step}`, (stepRamps.get(`${name}-${step}`) ?? /* @__PURE__ */ new Set()).add(name));
+    }
+  }
+  for (const [name, s] of Object.entries(def.scales ?? {})) {
+    const n = node();
+    scan(s, n);
+    for (const step of declaredSteps(s)) nodes.set(`${name}-${step}`, n);
+  }
+  const rampsOf = (name, seen = /* @__PURE__ */ new Set()) => {
+    const out = new Set(stepRamps.get(name));
+    if (seen.has(name)) return out;
+    seen.add(name);
+    const add = (from) => {
+      for (const r of rampsOf(from, seen)) out.add(r);
+    };
+    const rule = def.semantics?.[name];
+    for (const leaf of rule === void 0 ? [] : leaves(rule)) {
+      if (typeof leaf !== "object" || leaf === null) continue;
+      const l = leaf;
+      if ("ramp" in l) out.add(l.ramp);
+      else if ("from" in l) add(l.from);
+      else if ("ref" in l) add(l.ref);
+    }
+    const pin = def.pins?.[name];
+    if (pin !== void 0) {
+      const n = node();
+      scan(pin, n);
+      for (const e of n.edges) add(e);
+    }
+    return out;
+  };
+  for (const [name, rule] of Object.entries(def.semantics ?? {})) {
+    const n = node();
+    scan(rule, n);
+    for (const leaf of leaves(rule)) {
+      if ("ref" in leaf) n.edges.add(leaf.ref);
+      if ("from" in leaf) {
+        n.edges.add(leaf.from);
+        for (const r of rampsOf(leaf.from)) {
+          n.edges.add(stepsKey(r));
+          if (leaf.dir !== "away") for (const s of declaredSteps(def.ramps?.[r])) n.edges.add(`${r}-${s}`);
+        }
+      }
+      if ("step" in leaf) {
+        n.edges.add(stepsKey(leaf.ramp));
+        for (const s of leaves(leaf.step)) n.edges.add(`${leaf.ramp}-${String(s)}`);
+      }
+      if ("contrast" in leaf) {
+        n.edges.add(stepsKey(leaf.ramp));
+        for (const a of leaf.contrast.against) n.edges.add(a);
+        for (const s of declaredSteps(def.ramps?.[leaf.ramp])) n.edges.add(`${leaf.ramp}-${s}`);
+      }
+    }
+    nodes.set(name, n);
+  }
+  for (const layer of [def.components, def.pins]) {
+    for (const [name, v] of Object.entries(layer ?? {})) {
+      const n = node();
+      scan(v, n);
+      nodes.set(name, n);
+    }
+  }
+  const order = Object.keys(def.axes ?? {});
+  const sorted = (s) => order.filter((a) => s.has(a));
+  const ownOf = (n) => {
+    const out = new Set(n.axes);
+    for (const seed of n.seeds) {
+      const s = node();
+      scan(def.seeds?.[seed], s);
+      for (const a of s.axes) out.add(a);
+    }
+    return out;
+  };
+  const ownSets = /* @__PURE__ */ new Map();
+  for (const [name, n] of nodes) ownSets.set(name, ownOf(n));
+  const all = /* @__PURE__ */ new Map();
+  for (const [name, own] of ownSets) all.set(name, new Set(own));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, n] of nodes) {
+      const out = all.get(name);
+      for (const e of n.edges) {
+        const from = all.get(e);
+        if (!from) continue;
+        for (const a of from) if (!out.has(a)) {
+          out.add(a);
+          changed = true;
+        }
+      }
+    }
+  }
+  const result = {};
+  for (const name of nodes.keys()) if (!name.includes(".")) result[name] = { own: sorted(ownSets.get(name)), all: sorted(all.get(name)) };
+  return result;
+}
+
+// src/engine/ramps.ts
+var MAX_CHROMA = 0.4;
+var smoothstep = (t) => t * t * (3 - 2 * t);
+var envelope = (t, lightBias, darkBias) => Math.sin(Math.PI * t) + lightBias * (1 - t) + darkBias * t;
+function envelopeMax(lightBias, darkBias) {
+  let max = 0;
+  for (let i = 0; i <= 1e3; i += 1) max = Math.max(max, envelope(i / 1e3, lightBias, darkBias));
+  return max;
+}
+function lightnessRamp(p) {
+  const n = p.steps.length;
+  const at = (i) => n === 1 ? 0 : i / (n - 1);
+  const lightBias = p.lightBias ?? 0;
+  const max = envelopeMax(lightBias, p.darkBias);
+  let { hue, peak } = p;
+  const anchorIndex = p.steps.findIndex((s) => p.anchor?.[s] !== void 0);
+  if (anchorIndex !== -1) {
+    const a = toLch(p.anchor[p.steps[anchorIndex]]);
+    const e = envelope(at(anchorIndex), lightBias, p.darkBias);
+    hue = a.H;
+    peak = e > 1e-6 ? a.C * max / e : a.C;
+  }
+  const out = {};
+  p.steps.forEach((step, i) => {
+    const fixed = p.anchor?.[step];
+    if (fixed !== void 0) {
+      out[step] = fixed.toLowerCase();
+      return;
+    }
+    const t = at(i);
+    const L = p.lightness[0] + (p.lightness[1] - p.lightness[0]) * (t + (smoothstep(t) - t) * p.curve);
+    out[step] = toHex(L, Math.min(peak * envelope(t, lightBias, p.darkBias) / max, MAX_CHROMA), hue);
+  });
+  return out;
+}
+function categoricalRamp(steps, gates, anchors) {
+  const palette = generate({ ...DEFAULT_CONSTRAINTS, ...gates, count: steps.length, anchors });
+  const colors = {};
+  steps.forEach((step, i) => {
+    colors[step] = palette.swatches[i].hex.toLowerCase();
+  });
+  return { colors, feasible: palette.feasible };
+}
+
+// src/engine/scales.ts
+function scale(steps, p) {
+  if (p.step === void 0 === (p.ratio === void 0)) {
+    throw new Error("A scale takes exactly one of `step` and `ratio`");
+  }
+  const out = {};
+  steps.forEach((name, i) => {
+    const v = p.step !== void 0 ? p.base + p.step * i : p.base * p.ratio ** i;
+    out[name] = `${Math.round(v)}px`;
+  });
+  return out;
+}
+
+// src/engine/semantics.ts
+var TOKEN_REF2 = /^\{([^}.]+)\}$/;
+var HEX = /^#[0-9a-f]{6}$/i;
+var MAX_DEPTH = 32;
+var isRecord = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var refTarget = (value) => typeof value === "string" ? TOKEN_REF2.exec(value.trim())?.[1] : void 0;
+function deriveSemantics(rules, ctx) {
+  const done = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Set();
+  const inProgress = /* @__PURE__ */ new Set();
+  const get = (name) => {
+    if (done.has(name)) return done.get(name);
+    if (failed.has(name) || !Object.hasOwn(rules, name)) return void 0;
+    if (inProgress.has(name)) throw new Error(`Semantic cycle at "${name}" (${[...inProgress].join(" \u2192 ")})`);
+    inProgress.add(name);
+    const p = pick(rules[name], ctx.sel);
+    let derived;
+    if (!p.ok) {
+      ctx.issues.push({ kind: "missing-axis-value", path: `semantics.${name}`, axis: p.axis, value: p.value });
+    } else if (!isRecord(p.value)) {
+      ctx.issues.push({ kind: "invalid", path: `semantics.${name}`, message: "expected an object" });
+    } else {
+      derived = deriveOne(name, p.value, ctx, env);
+    }
+    inProgress.delete(name);
+    if (derived) done.set(name, derived);
+    else failed.add(name);
+    return derived;
+  };
+  const color = (value, depth = 0) => {
+    if (typeof value !== "string" || depth > MAX_DEPTH) return void 0;
+    const v = value.trim();
+    const m = TOKEN_REF2.exec(v);
+    if (!m) return HEX.test(v) ? v.toLowerCase() : void 0;
+    return solid(ctx.pinned(m[1]) ?? ctx.tokens[m[1]] ?? get(m[1])?.token ?? ctx.component(m[1]), depth + 1);
+  };
+  const solid = (t, depth = 0) => t && t.alpha === void 0 ? color(t.value, depth) : void 0;
+  const rampStep = (name) => {
+    if (!Object.hasOwn(ctx.tokens, name)) return void 0;
+    for (const [ramp, steps] of Object.entries(ctx.ramps)) {
+      const index = name.startsWith(`${ramp}-`) ? steps.indexOf(name.slice(ramp.length + 1)) : -1;
+      if (index >= 0) return { ramp, index };
+    }
+    return void 0;
+  };
+  const positionAt = (name, depth = 0) => {
+    if (depth > MAX_DEPTH) return void 0;
+    const step = rampStep(name);
+    if (step) return step;
+    const pin = ctx.pinned(name);
+    if (pin) {
+      const target = refTarget(pin.value);
+      return target === void 0 ? void 0 : positionAt(target, depth + 1);
+    }
+    return Object.hasOwn(rules, name) ? get(name)?.position : void 0;
+  };
+  const positionOf = (name) => Object.hasOwn(rules, name) ? positionAt(name) : void 0;
+  const env = { get, color, positionOf, positionAt };
+  for (const name of Object.keys(rules)) get(name);
+  return new Map(Object.keys(rules).filter((n) => done.has(n)).map((n) => [n, done.get(n)]));
+}
+var lightnessOf = (hex) => hex ? toLch(hex).L : Number.NaN;
+function deriveOne(name, r, ctx, env) {
+  const description = r.description;
+  const invalid = (message) => {
+    ctx.issues.push({ kind: "invalid", path: `semantics.${name}`, message });
+    return void 0;
+  };
+  if ("value" in r) {
+    return { rule: "value", token: { type: r.type ?? "unknown", value: r.value, alpha: void 0, description } };
+  }
+  if ("ref" in r) {
+    const type = r.type ?? ctx.tokens[r.ref]?.type ?? env.get(r.ref)?.token.type ?? "unknown";
+    return { rule: "ref", position: env.positionAt(r.ref), token: { type, value: `{${r.ref}}`, alpha: r.alpha, description } };
+  }
+  if ("step" in r) {
+    const picked = pick(r.step, ctx.sel);
+    if (!picked.ok) {
+      ctx.issues.push({ kind: "missing-axis-value", path: `semantics.${name}.step`, axis: picked.axis, value: picked.value });
+      return void 0;
+    }
+    return atStep(name, r.ramp, (ctx.ramps[r.ramp] ?? []).indexOf(picked.value), "step", description, ctx);
+  }
+  const rampColor = (ramp, step) => env.color(`{${ramp}-${step}}`);
+  const darkening = (ramp, steps) => {
+    const first = lightnessOf(rampColor(ramp, steps[0]));
+    const last = lightnessOf(rampColor(ramp, steps[steps.length - 1]));
+    if (Number.isNaN(first) || Number.isNaN(last) || first === last) return invalid(`cannot tell which end of ramp "${ramp}" is darker`);
+    return last < first ? 1 : -1;
+  };
+  if ("from" in r) {
+    const from = env.positionOf(r.from);
+    if (!from) return invalid(`"${r.from}" does not end on a ramp step`);
+    const { ramp, index } = from;
+    const steps = ctx.ramps[ramp];
+    const last = steps.length - 1;
+    let sign;
+    if (r.dir === "darker" || r.dir === "lighter") {
+      const darker = darkening(ramp, steps);
+      if (darker === void 0) return void 0;
+      sign = r.dir === "darker" ? darker : -darker;
+    } else {
+      sign = index <= last / 2 ? 1 : -1;
+    }
+    const target = index + sign * r.offset;
+    if (target < 0 || target > last) invalid(`offset ${r.offset} runs off ramp "${ramp}"`);
+    return atStep(name, ramp, Math.max(0, Math.min(last, target)), "offset", description, ctx);
+  }
+  if ("contrast" in r) {
+    for (const a of r.contrast.against) requireKnown(name, a, ctx.known);
+    const steps = ctx.ramps[r.ramp];
+    if (!steps) return invalid(`no ramp "${r.ramp}"`);
+    if (r.contrast.against.length === 0) return invalid("contrast needs at least one surface");
+    const colors = steps.map((s) => rampColor(r.ramp, s));
+    const against = r.contrast.against.map((a) => env.color(`{${a}}`));
+    if (colors.some((c) => !c) || against.some((hex) => !hex)) return invalid("contrast needs solid colors on both sides");
+    const darker = darkening(r.ramp, steps);
+    if (darker === void 0) return void 0;
+    const L = colors.map(lightnessOf);
+    const surfaces = against.map(lightnessOf);
+    const meanL = surfaces.reduce((sum, l) => sum + l, 0) / surfaces.length;
+    const last = steps.length - 1;
+    const sign = Math.abs(L[last] - meanL) >= Math.abs(L[0] - meanL) ? 1 : -1;
+    const lo = Math.min(...surfaces);
+    const hi = Math.max(...surfaces);
+    const worst = (i) => Math.min(...against.map((hex) => contrast(colors[i], hex)));
+    const walk = (toLast) => {
+      const order = steps.map((_, i) => toLast ? i : last - i);
+      const past = toLast === darker > 0 ? (l) => l < lo : (l) => l > hi;
+      const start = order.findIndex((i) => past(L[i]));
+      return start < 0 ? [] : order.slice(start);
+    };
+    const walked = [...walk(sign > 0), ...walk(sign < 0)];
+    const between = steps.map((_, i) => i).filter((i) => !walked.includes(i)).sort((a, b) => worst(b) - worst(a));
+    for (const i of [...walked, ...between]) {
+      if (worst(i) >= r.contrast.min) return atStep(name, r.ramp, i, "contrast", description, ctx);
+    }
+    let best = { index: sign > 0 ? 0 : last, ratio: -1 };
+    for (const i of steps.map((_, k) => sign > 0 ? k : last - k)) {
+      const ratio = worst(i);
+      if (ratio > best.ratio) best = { index: i, ratio };
+    }
+    ctx.issues.push({
+      kind: "contrast-unmet",
+      token: name,
+      min: r.contrast.min,
+      against: [...r.contrast.against],
+      picked: steps[best.index],
+      ratio: best.ratio
+    });
+    return atStep(name, r.ramp, best.index, "contrast", description, ctx);
+  }
+  return invalid("unrecognized rule");
+}
+function requireKnown(owner, name, known) {
+  if (!known(name)) throw new Error(`Semantic "${owner}" references "${name}", which is not defined`);
+}
+function checkSemantics(rules, sel, tokens, known, issues) {
+  const solid = (name) => {
+    for (let n = name; ; ) {
+      if (!Object.hasOwn(tokens, n)) return null;
+      const t = tokens[n];
+      if (t.alpha !== void 0 || typeof t.value !== "string") return void 0;
+      const v = t.value.trim();
+      const m = TOKEN_REF2.exec(v);
+      if (!m) return HEX.test(v) ? v.toLowerCase() : void 0;
+      n = m[1];
+    }
+  };
+  for (const name of Object.keys(rules)) {
+    const p = pick(rules[name], sel);
+    const check = p.ok && isRecord(p.value) ? p.value.check : void 0;
+    if (!check) continue;
+    for (const a of check.against) requireKnown(name, a, known);
+    if (!Object.hasOwn(tokens, name)) continue;
+    const path = `semantics.${name}.check`;
+    if (check.against.length === 0) {
+      issues.push({ kind: "invalid", path, message: "check needs at least one surface" });
+      continue;
+    }
+    const hex = solid(name);
+    if (hex === null) continue;
+    if (!hex) {
+      issues.push({ kind: "invalid", path, message: `"${name}" is not a solid color` });
+      continue;
+    }
+    for (const a of check.against) {
+      const other = solid(a);
+      if (other === null) continue;
+      if (!other) {
+        issues.push({ kind: "invalid", path, message: `"${a}" is not a solid color` });
+        continue;
+      }
+      const ratio = contrast(hex, other);
+      if (ratio < check.contrast) issues.push({ kind: "check-failed", token: name, against: a, min: check.contrast, ratio });
+    }
+  }
+}
+function atStep(name, ramp, index, rule, description, ctx) {
+  const steps = ctx.ramps[ramp];
+  if (!steps || index < 0 || index >= steps.length) {
+    ctx.issues.push({ kind: "invalid", path: `semantics.${name}`, message: `no such step on ramp "${ramp}"` });
+    return void 0;
+  }
+  return {
+    rule,
+    position: { ramp, index },
+    token: { type: "color", value: `{${ramp}-${steps[index]}}`, alpha: void 0, description }
+  };
+}
+
+// src/engine/derive.ts
+var SEED_REF2 = /^\{seeds\.([\w-]+)\}$/;
+var REF = /^\{([^}]+)\}$/;
+var HEX2 = /^#[0-9a-f]{6}$/i;
+var UNTYPED = "unknown";
+var PARAMS = ["kind", "steps", "lightness", "curve", "hue", "chroma", "anchor", "gates", "anchors", "base", "step", "ratio"];
+var has = (o, key) => Object.hasOwn(o, key);
+function refName(value) {
+  return typeof value === "string" ? REF.exec(value.trim())?.[1] : void 0;
+}
+function settle(v, path, ctx) {
+  if (isByAxis(v)) {
+    const picked = pick(v, ctx.sel);
+    if (!picked.ok) {
+      ctx.issues.push({ kind: "missing-axis-value", path, axis: picked.axis, value: picked.value });
+      return { value: void 0, ok: false };
+    }
+    return settle(picked.value, path, ctx);
+  }
+  if (Array.isArray(v)) {
+    let ok = true;
+    const value = v.map((x, i) => {
+      const s = settle(x, `${path}.${i}`, ctx);
+      ok = s.ok && ok;
+      return s.value;
+    });
+    return { value, ok };
+  }
+  if (typeof v === "object" && v !== null) {
+    let ok = true;
+    const value = {};
+    for (const [k, x] of Object.entries(v)) {
+      const s = settle(x, `${path}.${k}`, ctx);
+      ok = s.ok && ok;
+      value[k] = s.value;
+    }
+    return { value, ok };
+  }
+  if (typeof v === "string") {
+    const m = SEED_REF2.exec(v.trim());
+    if (!m) return { value: v, ok: true };
+    if (has(ctx.seeds, m[1])) return { value: ctx.seeds[m[1]], ok: true };
+    if (!ctx.declaredSeeds.has(m[1])) ctx.issues.push({ kind: "invalid", path, message: `unknown seed "${m[1]}"` });
+    return { value: void 0, ok: false };
+  }
+  return { value: v, ok: true };
+}
+var Reader = class {
+  ok = true;
+  issues;
+  constructor(issues) {
+    this.issues = issues;
+  }
+  fail(path, message) {
+    this.issues.push({ kind: "invalid", path, message });
+    this.ok = false;
+  }
+  num(x, path) {
+    if (typeof x === "number" && Number.isFinite(x)) return x;
+    this.fail(path, "expected a number");
+    return Number.NaN;
+  }
+  optNum(x, path, fallback) {
+    return x === void 0 ? fallback : this.num(x, path);
+  }
+  record(x, path) {
+    if (x === void 0) return {};
+    if (typeof x === "object" && x !== null && !Array.isArray(x)) return x;
+    this.fail(path, "expected an object");
+    return {};
+  }
+};
+var isRecord2 = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var stepNames = (x) => Array.isArray(x) && x.every((s) => typeof s === "string") ? x : void 0;
+function rampColors(name, r, steps, ctx) {
+  const path = `ramps.${name}`;
+  const read = new Reader(ctx.issues);
+  if (r.kind === "lightness") {
+    const l = r.lightness;
+    let lightness = [0, 0];
+    if (Array.isArray(l) && l.length === 2) lightness = [read.num(l[0], `${path}.lightness.0`), read.num(l[1], `${path}.lightness.1`)];
+    else read.fail(`${path}.lightness`, "expected two numbers");
+    const chroma = read.record(r.chroma, `${path}.chroma`);
+    const atLeastZero = (v, at) => {
+      if (v < 0) read.fail(at, "expected a number \u2265 0");
+      return v;
+    };
+    const peak = r.chroma === void 0 ? 0 : atLeastZero(read.num(chroma.peak, `${path}.chroma.peak`), `${path}.chroma.peak`);
+    const anchor = {};
+    for (const [step, v] of Object.entries(read.record(r.anchor, `${path}.anchor`))) {
+      if (typeof v === "string" && HEX2.test(v)) anchor[step] = v;
+      else read.fail(`${path}.anchor.${step}`, "expected a hex color");
+    }
+    const params = {
+      steps,
+      lightness,
+      curve: read.optNum(r.curve, `${path}.curve`, 0),
+      hue: read.optNum(r.hue, `${path}.hue`, 0),
+      peak,
+      lightBias: atLeastZero(read.optNum(chroma.lightBias, `${path}.chroma.lightBias`, 0), `${path}.chroma.lightBias`),
+      darkBias: atLeastZero(read.optNum(chroma.darkBias, `${path}.chroma.darkBias`, 0), `${path}.chroma.darkBias`),
+      anchor
+    };
+    return read.ok ? lightnessRamp(params) : void 0;
+  }
+  if (r.kind === "categorical") {
+    const gates = {};
+    for (const [k, v] of Object.entries(read.record(r.gates, `${path}.gates`))) {
+      if (!has(DEFAULT_CONSTRAINTS, k) || k === "count" || k === "anchors") read.fail(`${path}.gates.${k}`, "unknown gate");
+      else if (typeof v !== typeof DEFAULT_CONSTRAINTS[k]) {
+        read.fail(`${path}.gates.${k}`, `expected a ${typeof DEFAULT_CONSTRAINTS[k]}`);
+      } else gates[k] = v;
+    }
+    const anchors = [];
+    const rawAnchors = r.anchors ?? [];
+    if (!Array.isArray(rawAnchors)) read.fail(`${path}.anchors`, "expected a list");
+    else {
+      rawAnchors.forEach((a, i) => {
+        const at = `${path}.anchors.${i}`;
+        const o = read.record(a, at);
+        if (typeof o.name !== "string") read.fail(`${at}.name`, "expected a string");
+        anchors.push({
+          name: String(o.name),
+          hue: read.num(o.hue, `${at}.hue`),
+          lightness: read.num(o.lightness, `${at}.lightness`),
+          chroma: read.optNum(o.chroma, `${at}.chroma`)
+        });
+      });
+    }
+    if (!read.ok) return void 0;
+    const { colors, feasible } = categoricalRamp(steps, gates, anchors);
+    if (!feasible) ctx.issues.push({ kind: "infeasible-ramp", ramp: name });
+    return colors;
+  }
+  read.fail(`${path}.kind`, 'expected "lightness" or "categorical"');
+  return void 0;
+}
+function scaleValues(name, s, steps, issues) {
+  const path = `scales.${name}`;
+  const read = new Reader(issues);
+  const base = read.num(s.base, `${path}.base`);
+  const step = read.optNum(s.step, `${path}.step`);
+  const ratio = read.optNum(s.ratio, `${path}.ratio`);
+  if (!read.ok) return void 0;
+  try {
+    return { values: scale(steps, { base, step, ratio }), rule: step !== void 0 ? "linear" : "geometric" };
+  } catch (e) {
+    issues.push({ kind: "invalid", path, message: e.message });
+    return void 0;
+  }
+}
+function checkReferences(tokens, failed) {
+  const done = /* @__PURE__ */ new Set();
+  for (const start of Object.keys(tokens)) {
+    const trail = [];
+    let name = start;
+    while (name !== void 0 && !done.has(name)) {
+      if (trail.includes(name)) throw new Error(`Reference cycle at token "${name}" (${[...trail, name].join(" \u2192 ")})`);
+      trail.push(name);
+      const target = refName(tokens[name].value);
+      if (target !== void 0 && !has(tokens, target)) {
+        if (!failed.has(target)) throw new Error(`Token "${name}" references "${target}", which is not defined`);
+        name = void 0;
+      } else {
+        name = target;
+      }
+    }
+    for (const n of trail) done.add(n);
+  }
+}
+function inferTypes(tokens, provenance, failed, issues) {
+  for (let changed = true; changed; ) {
+    changed = false;
+    const memo = /* @__PURE__ */ new Map();
+    const typeOf = (start) => {
+      const trail = [];
+      let type = UNTYPED;
+      for (let name = start; name !== void 0 && has(tokens, name); name = refName(tokens[name].value)) {
+        const known = memo.get(name);
+        if (known !== void 0) {
+          type = known;
+          break;
+        }
+        trail.push(name);
+        if (tokens[name].type !== UNTYPED) {
+          type = tokens[name].type;
+          break;
+        }
+      }
+      for (const name of trail) {
+        if (type !== UNTYPED && tokens[name].type === UNTYPED) tokens[name] = { ...tokens[name], type };
+        memo.set(name, type);
+      }
+      return type;
+    };
+    for (const name of Object.keys(tokens)) typeOf(name);
+    for (const name of Object.keys(tokens)) {
+      const p = provenance[name];
+      const generated = p.generated;
+      const target = generated?.type === UNTYPED ? refName(generated.value) : void 0;
+      const type = target === void 0 ? UNTYPED : typeOf(target);
+      if (!generated || type === UNTYPED) continue;
+      provenance[name] = { ...p, generated: { ...generated, type } };
+      if (tokens[name].type === UNTYPED) {
+        tokens[name] = { ...tokens[name], type };
+        changed = true;
+      }
+    }
+  }
+  for (const [name, token] of Object.entries(tokens)) {
+    if (token.type !== UNTYPED || refName(token.value) !== void 0 || failed.has(name)) continue;
+    issues.push({ kind: "untyped-pin", token: name });
+  }
+}
+var isPinObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && "value" in v;
+var NAMED_LAYERS = ["ramps", "scales", "semantics", "components", "pins"];
+var SAFE_NAME = /^[A-Za-z0-9_-]+$/;
+var isSafeName = (name) => SAFE_NAME.test(name);
+var UNSAFE = (name) => `"${name}" cannot name a token: use letters, digits, "-" and "_"`;
+function withoutUnsafeNames(def, issues) {
+  let out = def;
+  for (const layer of NAMED_LAYERS) {
+    const entries = def[layer];
+    if (!entries || Object.keys(entries).every(isSafeName)) continue;
+    for (const n of Object.keys(entries)) {
+      if (!isSafeName(n)) issues.push({ kind: "invalid", path: `${layer}.${n}`, message: UNSAFE(n) });
+    }
+    out = { ...out, [layer]: Object.fromEntries(Object.entries(entries).filter(([n]) => isSafeName(n))) };
+  }
+  return out;
+}
+function derive(definition, selection = {}, lookup) {
+  const issues = [];
+  const def = withoutUnsafeNames(mergeChain(definition, lookup), issues);
+  const sel = fullSelection(def.axes ?? {}, selection);
+  const seeds = {};
+  for (const [k, v] of Object.entries(def.seeds ?? {})) {
+    const picked = pick(v, sel);
+    if (picked.ok) seeds[k] = picked.value;
+    else issues.push({ kind: "missing-axis-value", path: `seeds.${k}`, axis: picked.axis, value: picked.value });
+  }
+  const ctx = { sel, seeds, declaredSeeds: new Set(Object.keys(def.seeds ?? {})), issues };
+  const tokens = {};
+  const provenance = {};
+  const failed = /* @__PURE__ */ new Set();
+  const producer = /* @__PURE__ */ new Map();
+  const put = (name, token, layer, rule, path) => {
+    const earlier = producer.get(name);
+    if (earlier !== void 0) {
+      issues.push({ kind: "invalid", path, message: `"${name}" is already produced by ${earlier}` });
+      return;
+    }
+    producer.set(name, path);
+    tokens[name] = token;
+    provenance[name] = { layer, rule, pinned: false };
+  };
+  const failEntry = (name, entry, steps) => {
+    for (const step of steps ?? declaredSteps(entry)) failed.add(`${name}-${step}`);
+  };
+  const settleEntry = (entry, path) => {
+    let raw = entry;
+    if (isByAxis(raw)) {
+      const picked = pick(raw, sel);
+      if (!picked.ok) {
+        issues.push({ kind: "missing-axis-value", path, axis: picked.axis, value: picked.value });
+        return { ok: false };
+      }
+      raw = picked.value;
+    }
+    if (!isRecord2(raw)) {
+      issues.push({ kind: "invalid", path, message: "expected an object" });
+      return { ok: false };
+    }
+    const r = { ...raw };
+    let settled = true;
+    for (const key of PARAMS) {
+      if (!has(raw, key)) continue;
+      const s = settle(raw[key], `${path}.${key}`, ctx);
+      r[key] = s.value;
+      settled = s.ok && settled;
+    }
+    const steps = stepNames(r.steps);
+    if (!steps && settled) issues.push({ kind: "invalid", path: `${path}.steps`, message: "expected a list of step names" });
+    if (steps?.includes("by")) {
+      issues.push({ kind: "invalid", path: `${path}.steps`, message: '"by" is reserved and cannot name a step' });
+      return { ok: false, steps };
+    }
+    const unsafe = steps?.find((s) => !isSafeName(s));
+    if (unsafe !== void 0) {
+      issues.push({ kind: "invalid", path: `${path}.steps`, message: UNSAFE(unsafe) });
+      return { ok: false, steps };
+    }
+    return settled && steps ? { ok: true, r, steps } : { ok: false, steps };
+  };
+  const describe = (r, step) => {
+    const d = isRecord2(r.describe) ? r.describe[step] : void 0;
+    return typeof d === "string" ? d : void 0;
+  };
+  const rampSteps = {};
+  for (const [name, entry] of Object.entries(def.ramps ?? {})) {
+    const path = `ramps.${name}`;
+    const e = settleEntry(entry, path);
+    if (e.steps) rampSteps[name] = e.steps;
+    const colors = e.ok ? rampColors(name, e.r, e.steps, ctx) : void 0;
+    if (!e.ok || !colors) {
+      failEntry(name, entry, e.steps);
+      continue;
+    }
+    for (const step of e.steps) {
+      put(`${name}-${step}`, { type: "color", value: colors[step], alpha: void 0, description: describe(e.r, step) }, "ramps", String(e.r.kind), path);
+    }
+  }
+  for (const [name, entry] of Object.entries(def.scales ?? {})) {
+    const path = `scales.${name}`;
+    const e = settleEntry(entry, path);
+    const out = e.ok ? scaleValues(name, e.r, e.steps, issues) : void 0;
+    if (!e.ok || !out) {
+      failEntry(name, entry, e.steps);
+      continue;
+    }
+    for (const st of e.steps) {
+      put(`${name}-${st}`, { type: "dimension", value: out.values[st], alpha: void 0, description: describe(e.r, st) }, "scales", out.rule, path);
+    }
+  }
+  const seeded = (obj, path) => {
+    const m = typeof obj.value === "string" ? SEED_REF2.exec(obj.value.trim()) : null;
+    if (!m) return obj;
+    if (has(seeds, m[1])) return { ...obj, value: seeds[m[1]] };
+    if (path !== void 0 && !ctx.declaredSeeds.has(m[1])) issues.push({ kind: "invalid", path, message: `unknown seed "${m[1]}"` });
+    return void 0;
+  };
+  const pinned = (name) => {
+    const v = def.pins?.[name];
+    const picked = v === void 0 ? void 0 : pick(v, sel);
+    if (!picked?.ok) return void 0;
+    return seeded(isPinObject(picked.value) ? picked.value : { value: picked.value });
+  };
+  const semantics = def.semantics ?? {};
+  const components = def.components ?? {};
+  const component = (name) => {
+    const picked = has(components, name) ? pick(components[name], sel) : void 0;
+    if (!picked?.ok) return void 0;
+    return seeded(isPinObject(picked.value) ? picked.value : { value: picked.value });
+  };
+  const known = (name) => has(tokens, name) || failed.has(name) || has(semantics, name) || has(components, name) || has(def.pins ?? {}, name);
+  const derived = deriveSemantics(semantics, { sel, tokens, ramps: rampSteps, pinned, component, known, issues });
+  for (const name of Object.keys(semantics)) {
+    const d = derived.get(name);
+    if (d) put(name, d.token, "semantics", d.rule, `semantics.${name}`);
+    else failed.add(name);
+  }
+  const toToken = (v, path, prior) => {
+    const picked = pick(v, sel);
+    if (!picked.ok) {
+      issues.push({ kind: "missing-axis-value", path, axis: picked.axis, value: picked.value });
+      return void 0;
+    }
+    const obj = seeded(isPinObject(picked.value) ? picked.value : { value: picked.value }, path);
+    if (!obj) return void 0;
+    return { type: obj.type ?? prior?.type ?? UNTYPED, value: obj.value, alpha: obj.alpha, description: obj.description ?? prior?.description };
+  };
+  for (const [name, v] of Object.entries(components)) {
+    const path = `components.${name}`;
+    const token = toToken(v, path, void 0);
+    if (token) put(name, token, "components", "value", path);
+    else failed.add(name);
+  }
+  for (const [name, v] of Object.entries(def.pins ?? {})) {
+    const prior = has(tokens, name) ? tokens[name] : void 0;
+    const token = toToken(v, `pins.${name}`, prior);
+    if (!token) {
+      if (!prior) failed.add(name);
+      continue;
+    }
+    tokens[name] = token;
+    provenance[name] = prior ? { ...provenance[name], pinned: true, generated: prior } : { layer: "pins", rule: "value", pinned: false };
+  }
+  checkReferences(tokens, failed);
+  checkSemantics(semantics, sel, tokens, known, issues);
+  inferTypes(tokens, provenance, failed, issues);
+  return { tokens, provenance, issues };
+}
+
+// src/engine/bake.ts
+function normalize(t) {
+  return {
+    type: t.type,
+    value: t.value,
+    ...t.alpha !== void 0 ? { alpha: t.alpha } : {},
+    ...t.description !== void 0 ? { description: t.description } : {}
+  };
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function table(def, axes, lookup) {
+  const out = /* @__PURE__ */ new Map();
+  for (const sel of enumerateSelections(axes)) {
+    const { tokens } = derive(def, sel, lookup);
+    const normalized = {};
+    for (const [name, t] of Object.entries(tokens)) normalized[name] = normalize(t);
+    out.set(selectionKey(axes, sel), normalized);
+  }
+  return out;
+}
+function definitionOrder(def) {
+  const names = /* @__PURE__ */ new Set();
+  for (const layer of [def.ramps, def.scales]) {
+    for (const [name, entry] of Object.entries(layer ?? {})) for (const step of declaredSteps(entry)) names.add(`${name}-${step}`);
+  }
+  for (const layer of [def.semantics, def.components, def.pins]) for (const name of Object.keys(layer ?? {})) names.add(name);
+  return [...names];
+}
+function bake(definition, lookup) {
+  return bakeChain(definition, lookup).at(-1);
+}
+function bakeChain(definition, lookup) {
+  const merged = mergeChain(definition, lookup);
+  const parentDef = definition.extends ? lookup?.(definition.extends) : void 0;
+  const above = parentDef ? bakeChain(parentDef, lookup) : [];
+  return [...above, bakeOver(definition, merged, above, lookup)];
+}
+function bakeOver(definition, merged, above, lookup) {
+  const axes = merged.axes ?? {};
+  const own = table(definition, axes, lookup);
+  const at = (sel, name) => own.get(selectionKey(axes, sel))?.[name];
+  const inherited = (sel, name) => {
+    const full = fullSelection(axes, sel);
+    for (let i = above.length - 1; i >= 0; i--) {
+      const tokens2 = above[i].tokens;
+      if (!Object.hasOwn(tokens2, name)) continue;
+      const picked = pick(tokens2[name], full);
+      if (picked.ok) return picked.value;
+    }
+    return void 0;
+  };
+  const produced = new Set([...own.values()].flatMap((t) => Object.keys(t)));
+  const ordered = definitionOrder(merged).filter((n) => produced.has(n));
+  const names = [...ordered, ...[...produced].filter((n) => !ordered.includes(n))];
+  const selections = enumerateSelections(axes);
+  const tokens = {};
+  for (const name of names) {
+    if (selections.every((sel) => same(at(sel, name), inherited(sel, name)))) continue;
+    const varying = Object.keys(axes).filter(
+      (axis) => selections.some((sel) => Object.keys(axes[axis].values).some((v) => !same(at(sel, name), at({ ...sel, [axis]: v }, name))))
+    );
+    const build = (i, sel) => {
+      if (i === varying.length) return at(fullSelection(axes, sel), name);
+      const axis = varying[i];
+      const branch = { by: axis };
+      let any = false;
+      for (const v of Object.keys(axes[axis].values)) {
+        const x = build(i + 1, { ...sel, [axis]: v });
+        if (x !== void 0) {
+          branch[v] = x;
+          any = true;
+        }
+      }
+      return any ? branch : void 0;
+    };
+    const value = build(0, {});
+    if (value !== void 0) tokens[name] = value;
+  }
+  return { name: definition.name, extends: definition.extends ?? null, axes, tokens };
+}
+
+// src/engine/emit/css.ts
+var REF2 = /^\{([^}]+)\}$/;
+function refTarget2(token) {
+  const m = typeof token.value === "string" ? REF2.exec(token.value.trim()) : null;
+  if (!m) return null;
+  const path = m[1];
+  const dot = path.indexOf(".");
+  return dot === -1 ? path : path.slice(dot + 1);
+}
+function cssValue(name, token) {
+  const target = refTarget2(token);
+  if (target === null) return resolveTokens({ [name]: token })[name];
+  if (token.alpha === void 0) return `var(--wzl-${target})`;
+  return `color-mix(in srgb, var(--wzl-${target}) ${Math.round(token.alpha * 100)}%, transparent)`;
+}
+function axisSets(axes) {
+  const names = Object.keys(axes);
+  const sets = [];
+  for (let mask = 1; mask < 1 << names.length; mask += 1) sets.push(names.filter((_, i) => mask & 1 << i));
+  return sets.sort((a, b) => a.length - b.length);
+}
+function combinations(axes, set) {
+  let out = [{}];
+  for (const axis of set) out = out.flatMap((s) => Object.keys(axes[axis].values).map((v) => ({ ...s, [axis]: v })));
+  return out;
+}
+function schemeOf(axes, axis, value) {
+  const def = axes[axis];
+  if (!def) return void 0;
+  if (!(value in def.values)) return schemeOf(axes, axis, def.default);
+  return def.values[value].scheme ?? (Object.values(def.values).some((v) => v.scheme) ? "normal" : void 0);
+}
+function checkSchemes({ name, axes }) {
+  const carrying = Object.keys(axes).filter((a) => Object.values(axes[a].values).some((v) => v.scheme));
+  if (carrying.length > 1) throw new Error(`Theme "${name}": only one axis may carry a color scheme, but ${carrying.join(" and ")} do`);
+}
+function combineAxes(own, other) {
+  const out = {};
+  for (const [name, def] of Object.entries(own)) out[name] = { ...def, values: { ...other[name]?.values, ...def.values } };
+  for (const [name, def] of Object.entries(other)) if (!out[name]) out[name] = def;
+  return out;
+}
+var Resolved = class {
+  axes;
+  names;
+  chain;
+  memo = /* @__PURE__ */ new Map();
+  constructor(axes, chain) {
+    this.axes = axes;
+    this.chain = chain;
+    this.names = [...new Set([...chain].reverse().flatMap((t) => Object.keys(t.tokens)))];
+  }
+  token(name, sel) {
+    const full = fullSelection(this.axes, sel);
+    for (const t of this.chain) {
+      if (!Object.hasOwn(t.tokens, name)) continue;
+      const picked = pick(t.tokens[name], full);
+      if (picked.ok) return picked.value;
+    }
+    return void 0;
+  }
+  /** What a browser computes: every `var()` substituted, down to literals. */
+  expanded(name, sel, stack = []) {
+    const key = JSON.stringify(fullSelection(this.axes, sel));
+    const memo = this.memo.get(key) ?? this.memo.set(key, /* @__PURE__ */ new Map()).get(key);
+    const hit = memo.get(name);
+    if (hit !== void 0) return hit;
+    const token = this.token(name, sel);
+    if (!token) return `<unset ${name}>`;
+    if (stack.includes(name)) return "<cycle>";
+    const value = cssValue(name, token).replace(/var\(--wzl-([^)]+)\)/g, (_, n) => this.expanded(n, sel, [...stack, name]));
+    memo.set(name, value);
+    return value;
+  }
+};
+function chainOf(baked, byName) {
+  if (!baked.extends) return [baked];
+  const parent = byName.get(baked.extends);
+  if (!parent) throw new Error(`Theme "${baked.name}" extends "${baked.extends}", which is not being emitted`);
+  return [baked, ...chainOf(parent, byName)];
+}
+var union = (axes, ...sets) => {
+  const all = new Set(sets.flatMap((s) => s ?? []));
+  return Object.keys(axes).filter((a) => all.has(a));
+};
+function blocks(lines, plan, selector) {
+  const { axes, names } = plan;
+  for (const set of axisSets(axes)) {
+    const members = names.filter((n) => plan.all(n).join(",") === set.join(","));
+    const hasOwn = (n) => plan.own(n).length > 0;
+    const ownFirst = [...members.filter(hasOwn), ...members.filter((n) => !hasOwn(n))];
+    const schemeAxis = set.length === 1 ? set[0] : void 0;
+    for (const combo of combinations(axes, set)) {
+      const scheme = schemeAxis ? schemeOf(plan.schemes, schemeAxis, combo[schemeAxis]) : void 0;
+      if (ownFirst.length === 0 && !scheme) continue;
+      const attrs = set.map((a) => `[data-wzl-${a}='${combo[a]}']`).join("");
+      const decls = ownFirst.flatMap((name) => {
+        const token = plan.value(name, combo);
+        return token ? [`  --wzl-${name}: ${cssValue(name, token)};`] : [];
+      });
+      lines.push(...selector(attrs), ...scheme ? [`  color-scheme: ${scheme};`] : [], ...decls, "}", "");
+    }
+  }
+}
+function emitCss(themes) {
+  const defaults = themes.filter((t) => t.isDefault);
+  if (defaults.length !== 1) throw new Error(`emitCss needs exactly one default theme, got ${defaults.length}`);
+  for (const t of themes) checkSchemes(t.baked);
+  const byName = new Map(themes.map((t) => [t.baked.name, t.baked]));
+  const def = defaults[0];
+  const defResolved = new Resolved(def.baked.axes, [def.baked]);
+  const diffed = themes.filter((t) => !t.isDefault).map((t) => {
+    const axes2 = combineAxes(t.baked.axes, def.baked.axes);
+    const resolved = new Resolved(t.baked.axes, chainOf(t.baked, byName));
+    const selections = enumerateSelections(axes2);
+    const differs = resolved.names.filter(
+      (n) => selections.some((sel) => {
+        const mine = resolved.token(n, sel);
+        if (!mine) return false;
+        const theirs = defResolved.token(n, sel);
+        return !theirs || cssValue(n, mine) !== cssValue(n, theirs) || resolved.expanded(n, sel) !== defResolved.expanded(n, sel);
+      })
+    );
+    return { t, axes: axes2, resolved, differs };
+  });
+  const redeclared = new Set(diffed.flatMap((d) => d.differs));
+  const others = diffed.map(({ t, axes: axes2, resolved }) => ({
+    theme: t.baked.name,
+    axes: axes2,
+    schemes: t.baked.axes,
+    names: resolved.names.filter((n) => redeclared.has(n)),
+    all: (n) => union(axes2, t.deps[n]?.all, def.deps[n]?.all),
+    own: (n) => union(axes2, t.deps[n]?.own, def.deps[n]?.own),
+    value: (n, sel) => resolved.token(n, sel)
+  }));
+  const lines = [
+    "/* GENERATED by packages/theme/scripts/build-tokens.ts \u2014 do not edit.",
+    " * Source: packages/theme/themes/<theme>.json",
+    " */",
+    ""
+  ];
+  const { axes, name: theme } = def.baked;
+  const rootValues = pickAll(def.baked.tokens, fullSelection(axes, {}));
+  lines.push(":root {");
+  for (const axis of Object.values(axes)) {
+    const scheme = axis.values[axis.default]?.scheme;
+    if (scheme) lines.push(`  color-scheme: ${scheme};`);
+  }
+  for (const [name, token] of Object.entries(rootValues)) {
+    if (token.description) lines.push(`  /* ${token.description} */`);
+    lines.push(`  --wzl-${name}: ${cssValue(name, token)};`);
+  }
+  lines.push("}", "");
+  const reset = Object.keys(rootValues).filter((n) => redeclared.has(n) && (def.deps[n]?.all.length ?? 0) === 0);
+  if (reset.length > 0) {
+    lines.push(`[data-wzl-theme='${theme}'] {`, ...reset.map((n) => `  --wzl-${n}: ${cssValue(n, rootValues[n])};`), "}", "");
+  }
+  blocks(
+    lines,
+    {
+      theme,
+      axes,
+      schemes: axes,
+      names: Object.keys(def.baked.tokens),
+      all: (n) => def.deps[n]?.all ?? [],
+      own: (n) => def.deps[n]?.own ?? [],
+      value: (n, sel) => pickAll(def.baked.tokens, fullSelection(axes, sel))[n]
+    },
+    (attrs) => [`[data-wzl-theme='${theme}']${attrs},`, `${attrs} {`]
+  );
+  for (const plan of others) {
+    const invariant = plan.names.filter((n) => plan.all(n).length === 0);
+    if (invariant.length > 0) {
+      lines.push(`:root[data-wzl-theme='${plan.theme}'],`, `[data-wzl-theme='${plan.theme}'] {`);
+      for (const n of invariant) {
+        const token = plan.value(n, {});
+        if (token) lines.push(`  --wzl-${n}: ${cssValue(n, token)};`);
+      }
+      lines.push("}", "");
+    }
+    blocks(lines, plan, (attrs) => [`[data-wzl-theme='${plan.theme}']${attrs} {`]);
+  }
+  return lines.join("\n");
+}
+
+// src/engine/emit/dtcg.ts
+var REF3 = /^\{([^}.]+)\}$/;
+var modeOnly = (theme, what) => new Error(`DTCG export supports a mode axis only; ${theme} ${what}`);
+function toDTCG(theme) {
+  const axes = themeAxes(theme);
+  const typeOf = (name) => {
+    for (let t = theme; t; t = t.extends) {
+      if (!Object.hasOwn(t.tokens, name)) continue;
+      let v = t.tokens[name];
+      while (isByAxis(v)) v = Object.entries(v).find(([k]) => k !== "by")?.[1];
+      if (v !== void 0) return v.type;
+    }
+    return void 0;
+  };
+  const alias = (value) => {
+    const target = typeof value === "string" ? REF3.exec(value.trim())?.[1] : void 0;
+    const type = target === void 0 ? void 0 : typeOf(target);
+    return type === void 0 ? value : `{${type}.${target}}`;
+  };
+  const put = (into, name, t) => {
+    into[t.type] ??= { $type: t.type };
+    into[t.type][name] = {
+      $value: alias(t.value),
+      ...t.description ? { $description: t.description } : {},
+      ...t.alpha !== void 0 ? { $extensions: { [ALPHA_EXT]: t.alpha } } : {}
+    };
+  };
+  const branches = (name, v) => {
+    if (!isByAxis(v)) return [];
+    if (v.by !== "mode") throw modeOnly(`"${name}"`, `varies by ${v.by}`);
+    return Object.entries(v).flatMap(([mode, x]) => {
+      if (mode === "by") return [];
+      if (isByAxis(x)) throw modeOnly(`"${name}"`, `varies by ${x.by} inside mode`);
+      return [[mode, x]];
+    });
+  };
+  const modes = {};
+  for (const mode of Object.keys(axes.mode?.values ?? {})) modes[mode] = {};
+  const primitives = {};
+  for (const [name, v] of Object.entries(theme.tokens)) {
+    if (!isByAxis(v)) put(primitives, name, v);
+    else for (const [mode, t] of branches(name, v)) put(modes[mode] ??= {}, name, t);
+  }
+  return { name: theme.name, ...axes.mode ? { defaultMode: axes.mode.default } : {}, primitives, modes };
+}
+
+// src/hooks.ts
+var TOKEN_HOOKS = [
+  {
+    name: "disclosure-gap",
+    type: "dimension",
+    value: "4px",
+    description: "Gap between a Disclosure\u2019s twisty and its label."
+  },
+  {
+    name: "disclosure-target",
+    type: "dimension",
+    value: "20px",
+    description: "Hit-target square of a Disclosure twisty, and of a labkit LayerList row\u2019s."
+  },
+  {
+    name: "number-field-width",
+    type: "dimension",
+    value: "9ch",
+    description: "Width of a NumberField\u2019s input."
+  },
+  {
+    name: "prefs-column-width",
+    type: "dimension",
+    value: "300px",
+    description: "Width of the Prefs category column."
+  },
+  {
+    name: "prop-number-width",
+    type: "dimension",
+    value: "9ch",
+    description: "Width of a numeric field in the Properties panel."
+  },
+  {
+    name: "prop-text-width",
+    type: "dimension",
+    value: "16ch",
+    description: "Width of a text field in the Properties panel."
+  },
+  {
+    name: "property-readout-w",
+    type: "dimension",
+    value: "2.8em",
+    description: "Minimum width of a Properties row\u2019s value readout."
+  },
+  {
+    name: "swatch-size",
+    type: "dimension",
+    value: "28px",
+    description: "Minimum cell of a swatch grid \u2014 PatternPicker, and any panel laying swatches out the same way."
+  },
+  {
+    name: "timeline-label-w",
+    type: "dimension",
+    value: "120px",
+    description: "Width of the Timeline\u2019s track-label gutter."
+  },
+  {
+    name: "timeline-value-axis-w",
+    type: "dimension",
+    value: "32px",
+    description: "Width reserved for the Timeline\u2019s value axis."
+  }
+];
+
+// src/engine/emit/manifest.ts
+var groupOf = (name) => name.includes("-") ? name.slice(0, name.indexOf("-")) : name;
+var row = (name, type, value, description, hook) => `  { name: '--wzl-${name}', type: ${JSON.stringify(type)}, group: ${JSON.stringify(groupOf(name))}, defaultValue: ${JSON.stringify(value)}, description: ${JSON.stringify(description)}, hook: ${hook} },`;
+function emitManifest({ baked }) {
+  const all = pickAll(baked.tokens, fullSelection(baked.axes, {}));
+  const resolved = resolveTokens(all);
+  const rows = Object.entries(all).map(
+    ([name, token]) => row(name, token.type, resolved[name], token.description ?? "", false)
+  );
+  for (const h of [...TOKEN_HOOKS].sort((a, b) => a.name.localeCompare(b.name))) {
+    rows.push(row(h.name, h.type, h.value, h.description, true));
+  }
+  return [
+    "// GENERATED by packages/theme/scripts/build-tokens.ts \u2014 do not edit.",
+    "",
+    "/** One row of `TOKEN_MANIFEST`: a token, its DTCG type, the name-prefix",
+    " *  group it belongs to, its value in the default theme and selection, and",
+    " *  the description it was authored with (empty string if none). */",
+    "export interface TokenManifestEntry {",
+    "  readonly name: string;",
+    "  readonly type: string;",
+    "  readonly group: string;",
+    "  readonly defaultValue: string;",
+    "  readonly description: string;",
+    "  /** A consumer override hook rather than a theme token: no theme declares",
+    "   *  it, kit CSS reads it with `defaultValue` as the fallback, and setting",
+    "   *  it on any container is what changes it. */",
+    "  readonly hook: boolean;",
+    "}",
+    "",
+    "/** Every token of the default theme at its default selection, plus every",
+    " *  consumer override hook, described. Meant for tooling that presents the",
+    " *  token set \u2014 docs pages, token browsers, forge's CSS-vars panel \u2014 not",
+    " *  for resolving values at runtime. */",
+    "export const TOKEN_MANIFEST: readonly TokenManifestEntry[] = [",
+    rows.join("\n"),
+    "];",
+    ""
+  ].join("\n");
+}
+
+// src/engine/emit/themes.ts
+function chainOf2(baked, byName) {
+  const parent = baked.extends ? byName.get(baked.extends) : void 0;
+  if (baked.extends && !parent) throw new Error(`Theme "${baked.name}" extends "${baked.extends}", which is not in themes/`);
+  return [...parent ? chainOf2(parent, byName) : [], baked];
+}
+function tokensAt(chain, sel) {
+  return Object.assign({}, ...chain.map((t) => pickAll(t.tokens, sel)));
+}
+function emitThemes(themes) {
+  const byName = new Map(themes.map((t) => [t.baked.name, t.baked]));
+  const names = /* @__PURE__ */ new Set();
+  const entries = themes.map(({ baked }) => {
+    const chain = chainOf2(baked, byName);
+    const selections = enumerateSelections(baked.axes).map((sel) => {
+      const resolved = resolveTokens(tokensAt(chain, sel));
+      for (const n of Object.keys(resolved)) names.add(`--wzl-${n}`);
+      const body = Object.entries(resolved).map(([n, v]) => `        '--wzl-${n}': ${JSON.stringify(v)},`).join("\n");
+      return `      '${selectionKey(baked.axes, sel)}': {
+${body}
+      },`;
+    });
+    return [
+      `  ${JSON.stringify(baked.name)}: {`,
+      `    name: ${JSON.stringify(baked.name)},`,
+      `    axes: ${JSON.stringify(baked.axes)},`,
+      "    selections: {",
+      selections.join("\n"),
+      "    },",
+      "  },"
+    ].join("\n");
+  });
+  const sources = Object.fromEntries(themes.map((t) => [t.definition.name, t.definition]));
+  const bakedAll = Object.fromEntries(themes.map((t) => [t.baked.name, t.baked]));
+  return [
+    "// GENERATED by packages/theme/scripts/build-tokens.ts \u2014 do not edit.",
+    "",
+    "import type { AxisDefs } from '../axes';",
+    "import type { ThemeDefinition } from '../definition';",
+    "import type { BakedTheme } from '../engine/bake';",
+    "",
+    "/** Every design token the built-in themes declare, spelled as the CSS",
+    " *  custom property it becomes. */",
+    "export type TokenName =",
+    `${[...names].sort().map((n) => `  | '${n}'`).join("\n")};`,
+    "",
+    "/** A built-in theme with its aliases already collapsed: every selection",
+    " *  (keyed `mode=dark`, axes in declaration order) maps every token name to",
+    " *  a final CSS value. */",
+    "export interface GeneratedTheme {",
+    "  readonly name: string;",
+    "  readonly axes: AxisDefs;",
+    "  readonly selections: Readonly<Record<string, Readonly<Record<TokenName, string>>>>;",
+    "}",
+    "",
+    "/** The built-in themes, resolved, keyed by theme name. Read this to list",
+    " *  or preview themes without resolving a token graph yourself. */",
+    "export const THEMES = {",
+    entries.join("\n"),
+    "} as const satisfies Record<string, GeneratedTheme>;",
+    "",
+    "/** The built-in themes as authored: their unbaked definitions. */",
+    `export const THEME_SOURCES: Readonly<Record<string, ThemeDefinition>> = ${JSON.stringify(sources, null, 2)};`,
+    "",
+    "/** The built-in themes with every rule run and references intact. This is",
+    " *  what `weaselTheme` is built from, so the runtime entry bundles no generator. */",
+    `export const BAKED_THEMES: Readonly<Record<string, BakedTheme>> = ${JSON.stringify(bakedAll, null, 2)};`,
+    ""
+  ].join("\n");
+}
+
+// src/engine/emit/tokens.ts
+function generateTokens(definitions) {
+  const byName = new Map(definitions.map((d) => [d.name, d]));
+  const lookup = (name) => byName.get(name);
+  const roots = definitions.filter((d) => !d.extends);
+  if (roots.length !== 1) throw new Error(`themes/ needs exactly one theme that extends nothing; found ${roots.length}`);
+  const ordered = [roots[0], ...definitions.filter((d) => d.extends)];
+  const problems = ordered.flatMap(
+    (def) => enumerateSelections(mergeChain(def, lookup).axes ?? {}).flatMap(
+      (sel) => derive(def, sel, lookup).issues.map((issue) => `${def.name} ${JSON.stringify(sel)}: ${JSON.stringify(issue)}`)
+    )
+  );
+  if (problems.length > 0) return { ok: false, problems };
+  const themes = ordered.map((definition) => ({
+    definition,
+    baked: bake(definition, lookup),
+    deps: axisDependencies(definition, lookup),
+    isDefault: definition === roots[0]
+  }));
+  return {
+    ok: true,
+    files: { "tokens.css": emitCss(themes), "themes.ts": emitThemes(themes), "manifest.ts": emitManifest(themes[0]) }
+  };
+}
+
+export { CHROMA_WEIGHT, DEFAULT_CONSTRAINTS, anchorFromHex, axisDependencies, bake, bakeChain, categoricalRamp, chromaCap, contrast, cssValue, declaredSteps, deltaE, derive, emitCss, emitManifest, emitThemes, floorDegrees, generate, generateTokens, hexToRgb, hueGap, hueName, lightnessRamp, luminance, mergeChain, scale, toDTCG, toHex, toHexPreview, toLab, toLch, vividAt };
+//# sourceMappingURL=engine.js.map
+//# sourceMappingURL=engine.js.map