@spotlab/hand-matrix 0.2.0 → 0.4.0

package/README.md

@@ -95,6 +95,16 @@ goes in as props and changes come out through `on*Change` callbacks.
   produces).
 - `cellsToComboWeights(cells, actionIndex): Map<string, number>` — collapse
   one action back to absolute per-combo weights, ready to save as a range.
+- `cellsToRanges(original, seed, cells, avail?): HandFrequency[][]` — turn
+  the edited grid back into one hand-keyed range per action. `original`
+  holds each action's range (or `null`) in editor action order, `seed` the
+  cells the editor opened with, and `cells` the cells after editing.
+  `avail` is the parent range per hand (`null` for unconstrained); leave it
+  out when the parent gives every hand of a combo the same weight. Combos
+  whose cell still matches its seed keep each action's original hands
+  verbatim, and a `null` action takes what's left of each hand there.
+  Changed combos are rebuilt from the cells. Either way, each hand's
+  actions sum to its parent weight.
 - `comboWeightsToCells(cells, actionWeights, passive): EditorCell[]` — the
   inverse: re-derive the cells' conditional weights from absolute
   per-action ranges, keeping each cell's `avail`.
@@ -109,10 +119,10 @@ goes in as props and changes come out through `on*Change` callbacks.
   `WeightInputProps`.
 
 **The editor works at combo level.** A cell is one of the 169 combos (`AKs`,
-`AKo`, `QQ`), so suit-specific hands such as `AsKd` don't survive a round
-trip: `seedCells` takes combo weights, and `cellsToComboWeights` returns
-them. To keep suit-specific hands, set them aside before editing and add them
-back to the result yourself.
+`AKo`, `QQ`) at a whole-percent weight, so suit-specific hands such as
+`AsKd:0.7` and fractional weights such as `QQ:0.333` can't be shown exactly:
+`seedCells` takes combo weights, and `cellsToComboWeights` returns them. Save
+with `cellsToRanges` to keep them for every combo the user didn't repaint.
 
 ## Theming
 

package/dist/editor/cells.d.ts

@@ -1,3 +1,4 @@
+import { HandFrequency } from '@spotlab/range';
 export declare const COMBO_INDEX: Map<string, number>;
 /**
  * One matrix cell's painted state: `avail` is the combo's cap (its weight in the
@@ -8,6 +9,8 @@ export type EditorCell = {
     avail: number;
     weights: number[];
 };
+/** A copy of `cells` with `combo`'s cell replaced by `cell`. */
+export declare const withCell: (cells: EditorCell[], combo: string, cell: EditorCell) => EditorCell[];
 /**
  * Seed the 169-cell grid from a parent range's per-combo availability and each
  * action's own per-combo range, both expressed as absolute weights (a share of
@@ -24,3 +27,27 @@ export declare function cellsToComboWeights(cells: EditorCell[], actionIndex: nu
  * `actionWeights` naming the remainder action.
  */
 export declare function comboWeightsToCells(cells: EditorCell[], actionWeights: (Map<string, number> | null)[], passive: number): EditorCell[];
+/**
+ * Turn an edited grid back into one hand-keyed range per action, keeping each
+ * action's original hands wherever the editor didn't touch them. `original`
+ * holds each action's range in editor action order, `seed` the cells the
+ * editor opened with, and `cells` the cells after editing. `avail` is the
+ * parent range per hand, as passed (collapsed) to `seedCells`: `null` means
+ * unconstrained, and leaving it out takes each hand's weight from its cell's
+ * `avail`, which is exact whenever the parent gives every hand of a combo the
+ * same weight.
+ *
+ * A combo whose cell still equals its seed cell (same `avail`, same weights)
+ * keeps every action's original hands verbatim, so input the whole-percent grid
+ * can't represent — a single suit (`AhKh:0.7`) or a fractional weight
+ * (`QQ:0.333`) — survives a save. An action whose original is `null` (e.g. an
+ * implicit fold) takes what's left of each hand there: its parent weight minus
+ * the preserved originals, never below 0, split across `null` actions by their
+ * cell weights. A changed combo is rebuilt from its cell for every action, each
+ * hand getting the action's share of its own parent weight.
+ *
+ * Each rebuilt combo takes its first original hand's place, and combos the
+ * original didn't have follow in matrix order, so an unedited range formats
+ * back to the string it came from.
+ */
+export declare function cellsToRanges(original: (HandFrequency[] | null)[], seed: EditorCell[], cells: EditorCell[], avail?: HandFrequency[] | null): HandFrequency[][];

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export { RangeGrid } from './range-grid';
 export { RangeMatrixEditor, type RangeMatrixEditorProps, } from './editor/matrix-editor';
 export { ActionWeightSliders, type ActionWeightSlidersProps, type WeightInputProps, } from './editor/action-sliders';
 export { useRangePainting, type PaintTool } from './editor/use-range-painting';
-export { seedCells, cellsToComboWeights, comboWeightsToCells, type EditorCell, } from './editor/cells';
+export { seedCells, cellsToComboWeights, cellsToRanges, comboWeightsToCells, type EditorCell, } from './editor/cells';
 export { rebalance, type EditorActionSpec } from './editor/weights';

package/dist/index.js

@@ -1,69 +1,69 @@
-import { useCallback as g, useEffect as y, useLayoutEffect as I, useMemo as x, useRef as v } from "react";
-import { COMBOS as b, parseRange as S, toComboWeights as A } from "@spotlab/range";
-import { jsx as h, jsxs as w } from "react/jsx-runtime";
-var P = (t, e) => Array.from({ length: Math.ceil(t.length / e) }, (n, r) => t.slice(r * e, r * e + e)), D = "to right", N = (t) => t.length === 0 ? "transparent" : `linear-gradient(${D}, ${t.join(", ")})`, W = (t) => {
+import { useCallback as M, useEffect as x, useLayoutEffect as P, useMemo as T, useRef as $ } from "react";
+import { COMBOS as C, comboOf as W, handsOfCombo as D, parseRange as F, toComboWeights as B } from "@spotlab/range";
+import { jsx as g, jsxs as y } from "react/jsx-runtime";
+var X = (t, e) => Array.from({ length: Math.ceil(t.length / e) }, (n, r) => t.slice(r * e, r * e + e)), _ = "to right", L = (t) => t.length === 0 ? "transparent" : `linear-gradient(${_}, ${t.join(", ")})`, j = (t) => {
   const e = t.target;
   e.hasPointerCapture(t.pointerId) && e.releasePointerCapture(t.pointerId);
-}, M = (t, e, n) => {
+}, E = (t, e, n) => {
   const r = t.ownerDocument.elementFromPoint(e, n)?.closest("[data-combo]");
   return !r || !t.contains(r) ? null : r.getAttribute("data-combo");
-}, T = ({ combo: t, onPointerDown: e, comboStyle: n }) => /* @__PURE__ */ h("div", {
+}, q = ({ combo: t, onPointerDown: e, comboStyle: n }) => /* @__PURE__ */ g("div", {
   className: "spotlab-hm-cell",
   "data-combo": t,
   style: n?.(t),
   onPointerDown: e && ((r) => {
-    W(r), e(t, r);
+    j(r), e(t, r);
   }),
-  children: /* @__PURE__ */ h("div", {
+  children: /* @__PURE__ */ g("div", {
     className: "spotlab-hm-cell-inner",
-    children: /* @__PURE__ */ h("div", {
+    children: /* @__PURE__ */ g("div", {
       "data-combo": t,
       children: t
     })
   })
-}), B = ({ row: t, ...e }) => /* @__PURE__ */ h("div", {
+}), G = ({ row: t, ...e }) => /* @__PURE__ */ g("div", {
   className: "spotlab-hm-row",
-  children: t.map((n, r) => /* @__PURE__ */ h(T, {
+  children: t.map((n, r) => /* @__PURE__ */ g(q, {
     combo: n,
     ...e
   }, r))
-}), F = {
+}), U = {
   touchAction: "none",
   userSelect: "none",
   WebkitUserSelect: "none",
   WebkitTouchCallout: "none"
-}, R = ({ className: t, onPointerDown: e, onPointerEnter: n, ...r }) => {
-  const a = v(null), o = (i) => {
-    const l = M(i.currentTarget, i.clientX, i.clientY);
-    l !== a.current && (a.current = l, l && n?.(l, i));
+}, S = ({ className: t, onPointerDown: e, onPointerEnter: n, ...r }) => {
+  const a = $(null), o = (c) => {
+    const s = E(c.currentTarget, c.clientX, c.clientY);
+    s !== a.current && (a.current = s, s && n?.(s, c));
   };
-  return /* @__PURE__ */ h("div", {
+  return /* @__PURE__ */ g("div", {
     className: ["spotlab-hm-root", t].filter(Boolean).join(" "),
-    style: e ? F : void 0,
-    onPointerDown: n && ((i) => {
-      a.current = M(i.currentTarget, i.clientX, i.clientY);
+    style: e ? U : void 0,
+    onPointerDown: n && ((c) => {
+      a.current = E(c.currentTarget, c.clientX, c.clientY);
     }),
     onPointerMove: n && o,
     onPointerLeave: n && (() => a.current = null),
-    children: P(b, 13).map((i, l) => /* @__PURE__ */ h(B, {
-      row: i,
+    children: X(C, 13).map((c, s) => /* @__PURE__ */ g(G, {
+      row: c,
       onPointerDown: e,
       ...r
-    }, l))
+    }, s))
   });
-}, O = (t, e) => ({ background: N([`${t} 0 ${e * 100}%`, `transparent ${e * 100}% 100%`]) }), V = ({ range: t, fill: e = "var(--spotlab-hm-fill)", className: n }) => {
-  const r = x(() => {
-    const a = typeof t == "string" ? S(t) : t;
-    return A(a);
+}, Y = (t, e) => ({ background: L([`${t} 0 ${e * 100}%`, `transparent ${e * 100}% 100%`]) }), ot = ({ range: t, fill: e = "var(--spotlab-hm-fill)", className: n }) => {
+  const r = T(() => {
+    const a = typeof t == "string" ? F(t) : t;
+    return B(a);
   }, [t]);
-  return /* @__PURE__ */ h(R, {
+  return /* @__PURE__ */ g(S, {
     className: n,
     comboStyle: (a) => {
       const o = r.get(a);
-      return o ? O(e, o) : {};
+      return o ? Y(e, o) : {};
     }
   });
-}, X = (t) => Math.max(0, Math.min(100, Math.round(t))), j = (t, e) => {
+}, H = (t) => Math.max(0, Math.min(100, Math.round(t))), Q = (t, e) => {
   const n = t.map(Math.round);
   let r = 100 - n.reduce((a, o) => a + o, 0);
   if (r !== 0) {
@@ -80,55 +80,58 @@ var P = (t, e) => Array.from({ length: Math.ceil(t.length / e) }, (n, r) => t.sl
     }
   }
   return n;
-}, _ = (t, e, n, r) => {
-  const a = X(n), o = t.slice();
+}, J = (t, e, n, r) => {
+  const a = H(n), o = t.slice();
   o[e] = a;
-  const i = 100 - a, l = [];
-  for (let s = 0; s < t.length; s++) s !== e && l.push(s);
-  const u = l.reduce((s, p) => s + t[p], 0);
-  if (u <= 0) {
-    l.forEach((p) => o[p] = 0);
-    const s = e === r ? l[0] : r;
-    s != null && (o[s] = i);
-  } else l.forEach((s) => o[s] = Math.round(t[s] / u * i));
-  return j(o, e);
-}, $ = (t, e) => t.reduce((n, r, a) => a === e ? n : n + r, 0), k = new Map(b.map((t, e) => [t, e])), L = (t, e) => {
+  const c = 100 - a, s = [];
+  for (let h = 0; h < t.length; h++) h !== e && s.push(h);
+  const d = s.reduce((h, p) => h + t[p], 0);
+  if (d <= 0) {
+    s.forEach((p) => o[p] = 0);
+    const h = e === r ? s[0] : r;
+    h != null && (o[h] = c);
+  } else s.forEach((h) => o[h] = Math.round(t[h] / d * c));
+  return Q(o, e);
+}, N = (t, e) => t.reduce((n, r, a) => a === e ? n : n + r, 0), k = new Map(C.map((t, e) => [t, e])), K = (t, e, n) => {
+  const r = t.slice();
+  return r[k.get(e)] = n, r;
+}, I = (t, e) => {
   const n = t.slice();
-  let r = $(n, e);
+  let r = N(n, e);
   if (r > 100) {
     const a = 100 / r;
     for (let o = 0; o < n.length; o++) o !== e && (n[o] = Math.round(n[o] * a));
-    r = $(n, e);
+    r = N(n, e);
   }
   return n[e] = Math.max(0, 100 - r), n;
 };
-function Z(t, e, n) {
-  return b.map((r) => {
+function lt(t, e, n) {
+  return C.map((r) => {
     const a = t ? t.get(r) ?? 0 : 1, o = e.map(() => 0);
     return a <= 0 ? (o[n] = 100, {
       avail: 0,
       weights: o
-    }) : (e.forEach((i, l) => {
-      const u = i?.get(r) ?? 0;
-      o[l] = Math.round(u / a * 100);
+    }) : (e.forEach((c, s) => {
+      const d = c?.get(r) ?? 0;
+      o[s] = Math.round(d / a * 100);
     }), {
       avail: a,
-      weights: L(o, n)
+      weights: I(o, n)
     });
   });
 }
-var q = 8;
-function z(t, e) {
+var A = 8;
+function st(t, e) {
   const n = /* @__PURE__ */ new Map();
   return t.forEach((r, a) => {
     if (r.avail <= 0) return;
-    const o = r.weights.reduce((l, u) => l + u, 0);
+    const o = r.weights.reduce((s, d) => s + d, 0);
     if (!o) return;
-    const i = Number((r.weights[e] / o * r.avail).toFixed(q));
-    i && n.set(b[a], i);
+    const c = Number((r.weights[e] / o * r.avail).toFixed(A));
+    c && n.set(C[a], c);
   }), n;
 }
-function tt(t, e, n) {
+function ct(t, e, n) {
   return t.map((r, a) => {
     const o = e.map(() => 0);
     if (r.avail <= 0)
@@ -136,127 +139,153 @@ function tt(t, e, n) {
         avail: r.avail,
         weights: o
       };
-    const i = b[a];
-    return e.forEach((l, u) => {
-      const s = l?.get(i) ?? 0;
-      o[u] = Math.round(s / r.avail * 100);
+    const c = C[a];
+    return e.forEach((s, d) => {
+      const h = s?.get(c) ?? 0;
+      o[d] = Math.round(h / r.avail * 100);
     }), {
       avail: r.avail,
-      weights: L(o, n)
+      weights: I(o, n)
     };
   });
 }
-function G(t) {
-  const { cells: e, brush: n, tool: r, onCellsChange: a, onBrushChange: o, onToolChange: i } = t, l = v(null), u = g(() => {
-    l.current?.abort(), l.current = null;
+var V = (t, e) => t.avail !== e.avail || t.weights.length !== e.weights.length || t.weights.some((n, r) => n !== e.weights[r]);
+function it(t, e, n, r) {
+  const a = r && new Map(r.map(({ hand: l, frequency: i }) => [l, i])), o = (l, i) => r === void 0 ? i.avail : a ? a.get(l) ?? 0 : 1, c = t.map((l) => l && new Map(l.map(({ hand: i, frequency: f }) => [i, f]))), s = (l) => c.reduce((i, f) => i + (f?.get(l) ?? 0), 0), d = t.flatMap((l, i) => l ? [] : [i]), h = (l, i) => D(l).flatMap((f) => {
+    const b = Number(i(f).toFixed(A));
+    return b > 0 ? [{
+      hand: f,
+      frequency: b
+    }] : [];
+  }), p = (l, i) => {
+    const f = n[k.get(l)], b = f.weights.reduce((v, w) => v + w, 0);
+    return f.avail <= 0 || !b ? [] : h(l, (v) => f.weights[i] / b * o(v, f));
+  }, m = (l, i) => {
+    const f = n[k.get(l)], b = d.reduce((w, O) => w + f.weights[O], 0), v = b ? f.weights[i] / b : 1 / d.length;
+    return h(l, (w) => Math.max(0, o(w, f) - s(w)) * v);
+  }, u = new Set(C.filter((l, i) => V(e[i], n[i])));
+  return t.map((l, i) => {
+    if (l === null) return C.flatMap((v) => u.has(v) ? p(v, i) : m(v, i));
+    const f = [], b = /* @__PURE__ */ new Set();
+    for (const v of l) {
+      const w = W(v.hand);
+      u.has(w) ? b.has(w) || (b.add(w), f.push(...p(w, i))) : f.push(v);
+    }
+    for (const v of u) b.has(v) || f.push(...p(v, i));
+    return f;
+  });
+}
+function Z(t) {
+  const { cells: e, brush: n, tool: r, onCellsChange: a, onBrushChange: o, onToolChange: c } = t, s = $(null), d = M(() => {
+    s.current?.abort(), s.current = null;
   }, []);
-  y(() => u, [u]);
-  const s = v(e);
-  I(() => {
-    s.current = e;
+  x(() => d, [d]);
+  const h = $(e);
+  P(() => {
+    h.current = e;
   }, [e]);
-  const p = g((c) => {
-    const d = s.current, f = k.get(c);
-    if (d[f].avail <= 0) return;
-    const C = d.slice();
-    C[f] = {
-      avail: d[f].avail,
+  const p = M((u) => {
+    const l = h.current, { avail: i } = l[k.get(u)];
+    if (i <= 0) return;
+    const f = K(l, u, {
+      avail: i,
       weights: [...n]
-    }, s.current = C, a(C);
-  }, [n, a]), m = g((c) => {
-    const d = k.get(c);
-    e[d].avail <= 0 || (o([...e[d].weights]), i("brush"));
+    });
+    h.current = f, a(f);
+  }, [n, a]), m = M((u) => {
+    const l = k.get(u);
+    e[l].avail <= 0 || (o([...e[l].weights]), c("brush"));
   }, [
     e,
     o,
-    i
+    c
   ]);
   return {
-    onCellDown: g((c) => {
+    onCellDown: M((u) => {
       if (r === "eyedropper") {
-        m(c);
+        m(u);
         return;
       }
-      u();
-      const d = new AbortController();
-      l.current = d, window.addEventListener("pointerup", u, { signal: d.signal }), window.addEventListener("pointercancel", u, { signal: d.signal }), p(c);
+      d();
+      const l = new AbortController();
+      s.current = l, window.addEventListener("pointerup", d, { signal: l.signal }), window.addEventListener("pointercancel", d, { signal: l.signal }), p(u);
     }, [
       r,
       m,
       p,
-      u
+      d
     ]),
-    onCellEnter: g((c) => {
-      l.current && r === "brush" && p(c);
+    onCellEnter: M((u) => {
+      s.current && r === "brush" && p(u);
     }, [r, p])
   };
 }
-var E = (t, e, n) => {
+var R = (t, e, n) => {
   const r = [];
   let a = 0;
   return n.forEach((o) => {
-    const i = (t.weights[o] || 0) / 100;
-    if (i <= 0) return;
-    const l = e[o].color;
-    r.push(`${l} ${a * 100}%`), r.push(`${l} ${(a + i) * 100}%`), a += i;
-  }), r.length > 0 && a < 1 - 1e-9 && r.push(`transparent ${a * 100}% 100%`), N(r);
-}, et = ({ cells: t, actions: e, order: n, brush: r, tool: a, onCellsChange: o, onBrushChange: i, onToolChange: l, className: u }) => {
-  const { onCellDown: s, onCellEnter: p } = G({
+    const c = (t.weights[o] || 0) / 100;
+    if (c <= 0) return;
+    const s = e[o].color;
+    r.push(`${s} ${a * 100}%`), r.push(`${s} ${(a + c) * 100}%`), a += c;
+  }), r.length > 0 && a < 1 - 1e-9 && r.push(`transparent ${a * 100}% 100%`), L(r);
+}, ut = ({ cells: t, actions: e, order: n, brush: r, tool: a, onCellsChange: o, onBrushChange: c, onToolChange: s, className: d }) => {
+  const { onCellDown: h, onCellEnter: p } = Z({
     cells: t,
     brush: r,
     tool: a,
     onCellsChange: o,
-    onBrushChange: i,
-    onToolChange: l
+    onBrushChange: c,
+    onToolChange: s
   });
-  return /* @__PURE__ */ h(R, {
-    className: u,
+  return /* @__PURE__ */ g(S, {
+    className: d,
     comboStyle: (m) => {
-      const c = t[k.get(m)];
-      if (c.avail <= 0) return {
+      const u = t[k.get(m)];
+      if (u.avail <= 0) return {
         background: "var(--spotlab-hm-dead-hatch)",
         backgroundColor: "var(--spotlab-hm-muted-bg)",
         cursor: "not-allowed",
         color: "var(--spotlab-hm-muted-fg)"
       };
-      const d = a === "eyedropper" ? "copy" : "pointer";
-      if (c.avail < 1) {
-        const f = `${c.avail * 100}%`;
+      const l = a === "eyedropper" ? "copy" : "pointer";
+      if (u.avail < 1) {
+        const i = `${u.avail * 100}%`;
         return {
-          background: `repeating-linear-gradient(180deg, var(--spotlab-hm-muted-fg) 0 4px, transparent 4px 8px), var(--spotlab-hm-dead-hatch), ${E(c, e, n)}`,
-          backgroundSize: `1px 100%, ${(1 - c.avail) * 100}% 100%, ${c.avail * 100}% 100%`,
-          backgroundPosition: `${f} center, right center, left center`,
+          background: `repeating-linear-gradient(180deg, var(--spotlab-hm-muted-fg) 0 4px, transparent 4px 8px), var(--spotlab-hm-dead-hatch), ${R(u, e, n)}`,
+          backgroundSize: `1px 100%, ${(1 - u.avail) * 100}% 100%, ${u.avail * 100}% 100%`,
+          backgroundPosition: `${i} center, right center, left center`,
           backgroundRepeat: "no-repeat, no-repeat, no-repeat",
-          cursor: d
+          cursor: l
         };
       }
       return {
-        background: E(c, e, n),
-        cursor: d
+        background: R(u, e, n),
+        cursor: l
       };
     },
-    onPointerDown: s,
+    onPointerDown: h,
     onPointerEnter: p
   });
-}, U = (t) => /* @__PURE__ */ h("input", {
+}, z = (t) => /* @__PURE__ */ g("input", {
   type: "number",
   className: "spotlab-hm-weight-input",
   ...t
-}), Y = ({ value: t, color: e, passive: n, onChange: r }) => {
-  const a = v(null), o = v(!1), i = g((l) => {
-    const u = a.current;
-    if (!u) return;
-    const s = u.getBoundingClientRect();
-    r((l - s.left) / s.width * 100);
+}), tt = ({ value: t, color: e, passive: n, onChange: r }) => {
+  const a = $(null), o = $(!1), c = M((s) => {
+    const d = a.current;
+    if (!d) return;
+    const h = d.getBoundingClientRect();
+    r((s - h.left) / h.width * 100);
   }, [r]);
-  return y(() => {
-    const l = (s) => {
-      o.current && i(s.clientX);
-    }, u = () => o.current = !1;
-    return window.addEventListener("pointermove", l), window.addEventListener("pointerup", u), () => {
-      window.removeEventListener("pointermove", l), window.removeEventListener("pointerup", u);
+  return x(() => {
+    const s = (h) => {
+      o.current && c(h.clientX);
+    }, d = () => o.current = !1;
+    return window.addEventListener("pointermove", s), window.addEventListener("pointerup", d), () => {
+      window.removeEventListener("pointermove", s), window.removeEventListener("pointerup", d);
     };
-  }, [i]), /* @__PURE__ */ h("div", {
+  }, [c]), /* @__PURE__ */ g("div", {
     ref: a,
     role: "slider",
     "aria-valuenow": t,
@@ -264,10 +293,10 @@ var E = (t, e, n) => {
     "aria-valuemax": 100,
     className: "spotlab-hm-slider-track",
     style: { background: `linear-gradient(to right, ${e} 0 ${t}%, var(--spotlab-hm-track-bg) ${t}% 100%)` },
-    onPointerDown: (l) => {
-      o.current = !0, i(l.clientX);
+    onPointerDown: (s) => {
+      o.current = !0, c(s.clientX);
     },
-    children: /* @__PURE__ */ h("div", {
+    children: /* @__PURE__ */ g("div", {
       className: "spotlab-hm-slider-thumb",
       style: {
         left: `${t}%`,
@@ -275,60 +304,61 @@ var E = (t, e, n) => {
       }
     })
   });
-}, H = (t, e) => /* @__PURE__ */ w("span", {
+}, et = (t, e) => /* @__PURE__ */ y("span", {
   className: "spotlab-hm-slider-label",
-  children: [t.label, e && /* @__PURE__ */ h("span", {
+  children: [t.label, e && /* @__PURE__ */ g("span", {
     className: "spotlab-hm-slider-remainder",
     children: " · remainder"
   })]
-}), rt = ({ actions: t, order: e, weights: n, passive: r, onWeightsChange: a, renderActionLabel: o, renderActionExtra: i, components: l, className: u }) => {
-  const s = l?.WeightInput ?? U, p = (m, c) => {
-    a(_(n, m, c, r));
+}), ht = ({ actions: t, order: e, weights: n, passive: r, onWeightsChange: a, renderActionLabel: o, renderActionExtra: c, components: s, className: d }) => {
+  const h = s?.WeightInput ?? z, p = (m, u) => {
+    a(J(n, m, u, r));
   };
-  return /* @__PURE__ */ h("div", {
-    className: ["spotlab-hm-root spotlab-hm-sliders", u].filter(Boolean).join(" "),
+  return /* @__PURE__ */ g("div", {
+    className: ["spotlab-hm-root spotlab-hm-sliders", d].filter(Boolean).join(" "),
     children: e.map((m) => {
-      const c = t[m], d = m === r;
-      return /* @__PURE__ */ w("div", {
+      const u = t[m], l = m === r;
+      return /* @__PURE__ */ y("div", {
         className: "spotlab-hm-slider-row",
-        "data-passive": d,
-        children: [/* @__PURE__ */ w("div", {
+        "data-passive": l,
+        children: [/* @__PURE__ */ y("div", {
           className: "spotlab-hm-slider-header",
           children: [
-            /* @__PURE__ */ h("span", {
+            /* @__PURE__ */ g("span", {
               className: "spotlab-hm-slider-swatch",
-              style: { background: c.color }
+              style: { background: u.color }
             }),
-            o?.(c, m, d) ?? H(c, d),
-            i?.(c, m)
+            o?.(u, m, l) ?? et(u, l),
+            c?.(u, m)
           ]
-        }), /* @__PURE__ */ w("div", {
+        }), /* @__PURE__ */ y("div", {
           className: "spotlab-hm-slider-track-row",
-          children: [/* @__PURE__ */ h(Y, {
+          children: [/* @__PURE__ */ g(tt, {
             value: n[m],
-            color: c.color,
-            passive: d,
-            onChange: (f) => p(m, f)
-          }), /* @__PURE__ */ h(s, {
+            color: u.color,
+            passive: l,
+            onChange: (i) => p(m, i)
+          }), /* @__PURE__ */ g(h, {
             value: n[m],
-            "aria-label": `${c.label} weight`,
-            onChange: (f) => p(m, parseInt(f.target.value || "0", 10))
+            "aria-label": `${u.label} weight`,
+            onChange: (i) => p(m, parseInt(i.target.value || "0", 10))
           })]
         })]
-      }, c.id);
+      }, u.id);
     })
   });
 };
 export {
-  rt as ActionWeightSliders,
-  D as CELL_FILL_DIRECTION,
-  R as HandMatrix,
-  V as RangeGrid,
-  et as RangeMatrixEditor,
-  N as cellFillGradient,
-  z as cellsToComboWeights,
-  tt as comboWeightsToCells,
-  _ as rebalance,
-  Z as seedCells,
-  G as useRangePainting
+  ht as ActionWeightSliders,
+  _ as CELL_FILL_DIRECTION,
+  S as HandMatrix,
+  ot as RangeGrid,
+  ut as RangeMatrixEditor,
+  L as cellFillGradient,
+  st as cellsToComboWeights,
+  it as cellsToRanges,
+  ct as comboWeightsToCells,
+  J as rebalance,
+  lt as seedCells,
+  Z as useRangePainting
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spotlab/hand-matrix",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A 13x13 poker hand-matrix React component: the read-only grid primitive and a range-string-aware display component, themed through CSS custom properties.",
   "type": "module",
   "license": "MIT",
@@ -40,19 +40,19 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "@spotlab/range": "^0.2.0",
+    "@spotlab/range": "^0.3.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@spotlab/range": "0.2.0",
+    "@spotlab/range": "0.3.0",
     "@storybook/addon-vitest": "^10.5.5",
     "@storybook/react-vite": "^10.5.5",
     "@types/react": "^19.2.16",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.0",
-    "@vitest/browser": "^4.1.4",
-    "@vitest/browser-playwright": "4.1.11",
+    "@vitest/browser": "^5.0.0",
+    "@vitest/browser-playwright": "^5.0.0",
     "playwright": "^1.49.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -60,7 +60,7 @@
     "typescript": "^6.0.0",
     "vite": "^8.3.1",
     "vite-plugin-dts": "^5.1.2",
-    "vitest": "^4.1.4"
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"