doubletwelve 0.1.0 → 0.3.1

package/dist/index.js

@@ -1,48 +1,73 @@
-import { jsx as b, Fragment as re, jsxs as T } from "react/jsx-runtime";
-import { useMemo as Se, useState as Y, useEffect as ye } from "react";
-const me = {
-  "3x3": { rows: [20, 50, 80], cols: [20, 50, 80], size: "18%" },
-  "3x4": { rows: [24, 50, 76], cols: [22, 40, 60, 78], size: "12%" },
-  "4x3": { rows: [15, 38, 62, 85], cols: [20, 50, 80], size: "14%" }
-};
-function ze(e) {
-  const o = me[e.gridSize];
-  return {
-    top: e.top ?? `${o.rows[e.row]}%`,
-    left: e.left ?? `${o.cols[e.col]}%`,
-    width: o.size,
-    height: o.size
-  };
+import { jsx as z, Fragment as we, jsxs as $ } from "react/jsx-runtime";
+import { useContext as Se, createContext as Ke, useEffect as ae, useMemo as He, useState as G, useRef as ve, useCallback as Ze } from "react";
+const Je = {};
+function ze(e, t) {
+  return t ? {
+    ...e,
+    ...t,
+    tileDataAttributes: {
+      ...e.tileDataAttributes,
+      ...t.tileDataAttributes
+    }
+  } : e;
+}
+function Qe(e) {
+  if (!e)
+    return {};
+  const t = {};
+  for (const [o, n] of Object.entries(e))
+    n === void 0 || n === !1 || (t[`data-${o}`] = n === !0 ? "true" : String(n));
+  return t;
 }
-const $e = ({
-  row: e,
-  col: o,
-  gridSize: t,
-  color: n,
-  hollow: r,
-  top: l,
-  left: i
+const le = Ke(Je), sn = ({
+  theme: e,
+  children: t
 }) => {
-  const s = ze({ row: e, col: o, gridSize: t, top: l, left: i });
-  return /* @__PURE__ */ b(
+  const o = Se(le), n = ze(o, e);
+  return /* @__PURE__ */ z(le.Provider, { value: n, children: t });
+};
+function Ie(e) {
+  const t = Se(le);
+  return ze(t, e);
+}
+const We = ({ ctx: e, theme: t }) => {
+  const { row: o, col: n, gridSize: r, color: i, hollow: l, positionStyle: s } = e, a = t?.pipStyle?.(e) ?? {};
+  return /* @__PURE__ */ z(
     "div",
     {
       "data-testid": "pip",
-      "data-row": e,
-      "data-col": o,
-      "data-grid": t,
+      "data-row": o,
+      "data-col": n,
+      "data-grid": r,
+      "data-pip-value": e.value,
+      "data-hollow": l ? "true" : void 0,
       style: {
         position: "absolute",
-        backgroundColor: r ? "transparent" : n,
-        border: r ? "2px solid #888" : void 0,
         borderRadius: "50%",
         transform: "translate(-50%, -50%)",
-        boxShadow: r ? void 0 : "1px 2px 3px rgba(0,0,0,0.3)",
-        ...s
+        backgroundColor: l ? "transparent" : i,
+        border: l ? `2px solid ${i}` : void 0,
+        boxShadow: l ? void 0 : "1px 2px 3px rgba(0,0,0,0.3)",
+        ...s,
+        ...a
       }
     }
   );
-}, Me = {
+}, et = {
+  "3x3": { rows: [20, 50, 80], cols: [20, 50, 80], size: "18%" },
+  "3x4": { rows: [24, 50, 76], cols: [22, 40, 60, 78], size: "12%" },
+  "4x3": { rows: [15, 38, 62, 85], cols: [20, 50, 80], size: "14%" }
+};
+function tt(e) {
+  const t = et[e.gridSize];
+  return {
+    top: e.top ?? `${t.rows[e.row]}%`,
+    left: e.left ?? `${t.cols[e.col]}%`,
+    width: t.size,
+    height: t.size
+  };
+}
+const nt = {
   0: [],
   1: [{ row: 1, col: 1, gridSize: "3x3" }],
   2: [
@@ -145,10 +170,10 @@ const $e = ({
     { row: 3, col: 2, gridSize: "4x3" }
   ]
 };
-function Ce(e) {
-  return Me[e] ?? [];
+function ot(e) {
+  return nt[e] ?? [];
 }
-const X = {
+const q = {
   0: { color: "transparent" },
   1: { color: "#1a1a1a" },
   2: { color: "#8B1A1A" },
@@ -162,44 +187,45 @@ const X = {
   10: { color: "#EA580C" },
   11: { color: "#166534" },
   12: { color: "#DC2626" }
-}, no = X;
-function ro(e) {
-  return { ...X, ...e };
+}, an = q;
+function un(e) {
+  return { ...q, ...e };
 }
-function le(e, o) {
-  if (o !== void 0)
-    return o[e] ?? X[e] ?? { color: "#1a1a1a" };
+function Pe(e, t) {
+  if (t !== void 0)
+    return t[e] ?? q[e] ?? { color: "#1a1a1a" };
 }
-function lo(e) {
-  return le(e, X);
+function cn(e) {
+  return Pe(e, q);
 }
-const ke = (e, o, t) => {
-  const n = le(e, t);
-  return n ? { color: n.color, hollow: n.hollow } : { color: o };
-}, De = ({
+const rt = (e, t, o) => {
+  const n = Pe(e, o);
+  return n ? { color: n.color, hollow: n.hollow } : { color: t };
+}, it = ({
   value: e,
-  pipColor: o,
-  pipColors: t
+  pipColor: t,
+  pipColors: o
 }) => {
-  const { color: n, hollow: r } = ke(e, o, t), l = Ce(e);
-  return /* @__PURE__ */ b(re, { children: l.map((i, s) => /* @__PURE__ */ b(
-    $e,
-    {
-      row: i.row,
-      col: i.col,
-      gridSize: i.gridSize,
-      color: n,
-      hollow: r,
-      top: i.top,
-      left: i.left
-    },
-    s
-  )) });
-}, ee = ({
+  const n = Ie(), { color: r, hollow: i } = rt(e, t, o), l = ot(e);
+  return /* @__PURE__ */ z(we, { children: l.map((s, a) => {
+    const c = {
+      value: e,
+      row: s.row,
+      col: s.col,
+      gridSize: s.gridSize,
+      color: r,
+      hollow: i,
+      top: s.top,
+      left: s.left,
+      positionStyle: tt(s)
+    };
+    return n.renderPip ? /* @__PURE__ */ z("span", { children: n.renderPip(c) }, a) : /* @__PURE__ */ z(We, { ctx: c, theme: n }, a);
+  }) });
+}, xe = ({
   value: e,
-  pipColor: o,
-  pipColors: t
-}) => /* @__PURE__ */ b(
+  pipColor: t,
+  pipColors: o
+}) => /* @__PURE__ */ z(
   "div",
   {
     style: {
@@ -209,25 +235,36 @@ const ke = (e, o, t) => {
       padding: "0",
       overflow: "hidden"
     },
-    children: /* @__PURE__ */ b(De, { value: e, pipColor: o, pipColors: t })
+    children: /* @__PURE__ */ z(it, { value: e, pipColor: t, pipColors: o })
   }
-), ie = ({
+), Te = ({
   value1: e = 0,
-  value2: o = 0,
-  width: t = 100,
+  value2: t = 0,
+  width: o = 100,
   height: n = 200,
   backgroundColor: r = "white",
-  pipColor: l = "black",
-  pipColors: i,
+  pipColor: i = "black",
+  pipColors: l,
   borderColor: s = "black",
-  rotation: a = 0
+  rotation: a = 0,
+  theme: c
 }) => {
-  const u = Math.min(Math.max(e, 0), 12), f = Math.min(Math.max(o, 0), 12);
-  return /* @__PURE__ */ T(
+  const d = Ie(c), u = Math.min(Math.max(e, 0), 12), f = Math.min(Math.max(t, 0), 12), p = {
+    value1: u,
+    value2: f,
+    width: o,
+    height: n,
+    backgroundColor: r,
+    borderColor: s,
+    rotation: a
+  }, v = d.tileStyle?.(p) ?? {}, S = d.halfDividerStyle?.(p) ?? {};
+  return /* @__PURE__ */ $(
     "div",
     {
+      className: d.tileClassName,
+      ...Qe(d.tileDataAttributes),
       style: {
-        width: `${t}px`,
+        width: `${o}px`,
         height: `${n}px`,
         backgroundColor: r,
         borderColor: s,
@@ -239,10 +276,11 @@ const ke = (e, o, t) => {
         boxShadow: "0 1px 2px rgba(0,0,0,0.2)",
         display: "flex",
         flexDirection: "column",
-        overflow: "hidden"
+        overflow: "hidden",
+        ...v
       },
       children: [
-        /* @__PURE__ */ b(
+        /* @__PURE__ */ z(
           "div",
           {
             style: {
@@ -250,347 +288,625 @@ const ke = (e, o, t) => {
               position: "relative",
               borderBottomWidth: "1px",
               borderBottomStyle: "solid",
-              borderBottomColor: s
+              borderBottomColor: s,
+              ...S
             },
-            children: /* @__PURE__ */ b(ee, { value: u, pipColor: l, pipColors: i })
+            children: /* @__PURE__ */ z(xe, { value: u, pipColor: i, pipColors: l })
           }
         ),
-        /* @__PURE__ */ b(
+        /* @__PURE__ */ z(
           "div",
           {
             style: {
               flex: 1,
               position: "relative"
             },
-            children: /* @__PURE__ */ b(ee, { value: f, pipColor: l, pipColors: i })
+            children: /* @__PURE__ */ z(xe, { value: f, pipColor: i, pipColors: l })
           }
         )
       ]
     }
   );
-}, D = 60, I = 120, Ie = [-45, 45];
-function oe(e, o = D, t = I) {
-  return e ? o / 2 : t / 2;
+}, C = 60, D = 120, lt = [-45, 45];
+function W(e, t = C, o = D) {
+  return e ? t / 2 : o / 2;
 }
-function k(e, o, t = D, n = I) {
-  return oe(e, t, n) + oe(o, t, n);
+function A(e, t, o = C, n = D) {
+  return W(e, o, n) + W(t, o, n);
 }
-function _(e) {
-  const o = e * Math.PI / 180;
+function Y(e) {
+  const t = e * Math.PI / 180;
   return {
-    dirX: Math.cos(o),
-    dirY: Math.sin(o)
+    dirX: Math.cos(t),
+    dirY: Math.sin(t)
   };
 }
-function N(e) {
-  const { dirX: o, dirY: t } = _(e);
-  return { perpX: -t, perpY: o };
+function L(e) {
+  const { dirX: t, dirY: o } = Y(e);
+  return { perpX: -o, perpY: t };
 }
-function Te(e, o) {
-  const t = e.map((n) => ({ ...n }));
-  for (let n = 1; n < t.length; n++) {
-    const r = t[n], i = t[n - 1].value2, s = r.value1 === r.value2;
-    if (o === "linear" && !s) {
-      t[n] = { value1: r.value2, value2: r.value1 };
-      continue;
-    }
-    o === "offset" && !s && r.value1 !== i && r.value2 === i && (t[n] = { value1: r.value2, value2: r.value1 });
+function st(e) {
+  const t = e.map((o) => ({ ...o }));
+  for (let o = 1; o < t.length; o++) {
+    const n = t[o], r = t[o - 1].value2;
+    !(n.value1 === n.value2) && n.value1 !== r && n.value2 === r && (t[o] = { value1: n.value2, value2: n.value1 });
   }
   return t;
 }
-function j(e) {
-  const { dirX: o, dirY: t } = _(e);
-  return Math.abs(o) >= Math.abs(t) ? o >= 0 ? 1 : -1 : t >= 0 ? 1 : -1;
+function K(e) {
+  const { dirX: t, dirY: o } = Y(e);
+  return Math.abs(t) >= Math.abs(o) ? t >= 0 ? 1 : -1 : o >= 0 ? 1 : -1;
 }
-function se(e, o) {
-  return e === 0 ? o : e === o ? -o : o;
+function Me(e, t) {
+  return e === 0 ? t : e === t ? -t : t;
 }
-function Oe({
-  startX: e,
+function ke({
+  orientedDominoes: e,
+  startX: t,
   startY: o,
-  angle: t,
-  dominoes: n,
+  angle: n,
   layoutStyle: r,
-  dominoWidth: l = D,
-  dominoHeight: i = I,
-  leadGap: s = i * 0.3,
+  dominoWidth: i,
+  dominoHeight: l,
+  leadGap: s,
   outwardSign: a,
-  hubIndex: u
+  hubIndex: c
 }) {
-  const f = [], { dirX: c, dirY: d } = _(t), { perpX: v, perpY: y } = N(t), x = Te([...n], r), w = a ?? j(t), z = r === "offset" && u != null, $ = [];
-  let m = e + c * s, p = o + d * s, h = 0, M = 0;
-  const O = l / 2, A = (g) => {
-    const S = (g - h) * O;
-    m += v * S, p += y * S, h = g;
+  const d = [], { dirX: u, dirY: f } = Y(n), { perpX: p, perpY: v } = L(n), S = r === "offset" && c != null, m = [];
+  let P = t + u * s, b = o + f * s, M = 0, g = 0;
+  const I = i / 2, k = (x) => {
+    const h = (x - M) * I;
+    P += p * h, b += v * h, M = x;
   };
-  for (let g = 0; g < x.length; g++) {
-    const S = x[g], E = S.value1 === S.value2, C = g > 0 && x[g - 1].value1 === x[g - 1].value2;
-    r === "linear" ? g > 0 && (E ? (m += c * k(C, !0, l, i), p += d * k(C, !0, l, i)) : C ? (m += c * k(!0, !1, l, i), p += d * k(!0, !1, l, i)) : (m += c * i, p += d * i)) : E ? g > 0 && (m += c * k(C, !0, l, i), p += d * k(C, !0, l, i)) : (g === 0 ? M = w : C ? (m += c * k(!0, !1, l, i), p += d * k(!0, !1, l, i)) : (m += c * (i / 2), p += d * (i / 2), M = se(M, w)), A(M)), $.push(h), f.push({
-      x: m,
-      y: p,
-      rotation: E ? t + 180 : t - 90,
-      isDouble: E,
-      value1: S.value1,
-      value2: S.value2
+  for (let x = 0; x < e.length; x++) {
+    const h = e[x], y = h.value1 === h.value2, T = x > 0 && e[x - 1].value1 === e[x - 1].value2;
+    r === "linear" ? x > 0 && (y ? (P += u * A(T, !0, i, l), b += f * A(T, !0, i, l)) : T ? (P += u * A(!0, !1, i, l), b += f * A(!0, !1, i, l)) : (P += u * l, b += f * l)) : y ? x > 0 && (P += u * A(T, !0, i, l), b += f * A(T, !0, i, l)) : (x === 0 ? g = a : T ? (P += u * A(!0, !1, i, l), b += f * A(!0, !1, i, l)) : (P += u * (l / 2), b += f * (l / 2), g = Me(g, a)), k(g)), m.push(M), d.push({
+      x: P,
+      y: b,
+      rotation: y ? n + 180 : n - 90,
+      isDouble: y,
+      value1: h.value1,
+      value2: h.value2
     });
   }
-  if (z && u != null) {
-    const g = -$[u] * O;
-    if (g !== 0)
-      for (let S = 0; S < f.length; S++)
-        f[S] = {
-          ...f[S],
-          x: f[S].x + v * g,
-          y: f[S].y + y * g
+  if (S && c != null) {
+    const x = -m[c] * I;
+    if (x !== 0)
+      for (let h = 0; h < d.length; h++)
+        d[h] = {
+          ...d[h],
+          x: d[h].x + p * x,
+          y: d[h].y + v * x
         };
   }
-  return f;
+  return d;
+}
+function Ce(e, t) {
+  if (!e || e.length === 0) return [];
+  const o = /* @__PURE__ */ new Map();
+  for (const n of e)
+    Number.isInteger(n.index) && (n.index <= 0 || n.index >= t || o.set(n.index, n.turn));
+  return [...o.entries()].map(([n, r]) => ({ index: n, turn: r })).sort((n, r) => n.index - r.index);
+}
+function at(e, t, o, n = 1 / 0) {
+  const r = Ce(t, Number.isFinite(n) ? n : o + 1);
+  let i = e;
+  for (const l of r)
+    if (l.index <= o) i += l.turn;
+    else break;
+  return i;
 }
-function te(e, o = D, t = I) {
-  const n = e.rotation * Math.PI / 180, r = Math.cos(n), l = Math.sin(n), i = o / 2, s = t / 2;
+function ut(e, t, o, n) {
+  const { startX: r, startY: i, angle: l, layoutStyle: s, dominoWidth: a, dominoHeight: c, leadGap: d, outwardSign: u } = t, f = [0, ...o.map((b) => b.index), e.length], p = [];
+  let v = l, S = r, m = i, P = d;
+  for (let b = 0; b < f.length - 1; b++) {
+    const M = e.slice(f[b], f[b + 1]);
+    if (M.length === 0) continue;
+    const g = b === 0 && n != null && n < f[1] ? n : void 0, I = ke({
+      orientedDominoes: M,
+      startX: S,
+      startY: m,
+      angle: v,
+      layoutStyle: s,
+      dominoWidth: a,
+      dominoHeight: c,
+      leadGap: P,
+      outwardSign: u,
+      hubIndex: g
+    });
+    if (p.push(...I), b >= f.length - 2) break;
+    const x = I[I.length - 1], h = Y(v), y = W(x.isDouble, a, c);
+    v += o[b].turn;
+    const T = e[f[b + 1]], O = T.value1 === T.value2, _ = W(O, a, c), U = Y(v), j = L(v), E = a / 2, oe = x.x + h.dirX * (y - E) + U.dirX * (_ + E), H = x.y + h.dirY * (y - E) + U.dirY * (_ + E), R = s === "offset" && !O, Z = R ? j.perpX * E * u : 0, J = R ? j.perpY * E * u : 0;
+    S = oe - Z, m = H - J, P = 0;
+  }
+  return p;
+}
+function ct({
+  startX: e,
+  startY: t,
+  angle: o,
+  dominoes: n,
+  layoutStyle: r,
+  dominoWidth: i = C,
+  dominoHeight: l = D,
+  leadGap: s = l * 0.3,
+  outwardSign: a,
+  hubIndex: c,
+  bends: d
+}) {
+  const u = st([...n]), f = a ?? K(o), p = Ce(d, u.length);
+  return p.length > 0 ? ut(
+    u,
+    {
+      startX: e,
+      startY: t,
+      angle: o,
+      layoutStyle: r,
+      dominoWidth: i,
+      dominoHeight: l,
+      leadGap: s,
+      outwardSign: f
+    },
+    p,
+    c
+  ) : ke({
+    orientedDominoes: u,
+    startX: e,
+    startY: t,
+    angle: o,
+    layoutStyle: r,
+    dominoWidth: i,
+    dominoHeight: l,
+    leadGap: s,
+    outwardSign: f,
+    hubIndex: c
+  });
+}
+function be(e, t = C, o = D) {
+  const n = e.rotation * Math.PI / 180, r = Math.cos(n), i = Math.sin(n), l = t / 2, s = o / 2;
   return [
-    [-i, -s],
-    [i, -s],
-    [i, s],
-    [-i, s]
-  ].map(([a, u]) => ({
-    x: e.x + a * r - u * l,
-    y: e.y + a * l + u * r
+    [-l, -s],
+    [l, -s],
+    [l, s],
+    [-l, s]
+  ].map(([a, c]) => ({
+    x: e.x + a * r - c * i,
+    y: e.y + a * i + c * r
   }));
 }
-function Pe(e, o, t) {
-  let n = 1 / 0, r = -1 / 0, l = 1 / 0, i = -1 / 0;
+function dt(e, t, o) {
+  let n = 1 / 0, r = -1 / 0, i = 1 / 0, l = -1 / 0;
   for (const s of e) {
-    const a = s.x * t.x + s.y * t.y;
+    const a = s.x * o.x + s.y * o.y;
     n = Math.min(n, a), r = Math.max(r, a);
   }
-  for (const s of o) {
-    const a = s.x * t.x + s.y * t.y;
-    l = Math.min(l, a), i = Math.max(i, a);
+  for (const s of t) {
+    const a = s.x * o.x + s.y * o.y;
+    i = Math.min(i, a), l = Math.max(l, a);
   }
-  return Math.min(r, i) - Math.max(n, l);
+  return Math.min(r, l) - Math.max(n, i);
 }
-function ae(e, o, t = 1, n = D, r = I) {
-  const l = te(e, n, r), i = te(o, n, r);
-  for (const s of [l, i])
+function ee(e, t, o = 1, n = C, r = D) {
+  const i = be(e, n, r), l = be(t, n, r);
+  for (const s of [i, l])
     for (let a = 0; a < 4; a++) {
-      const u = s[a], f = s[(a + 1) % 4], c = f.x - u.x, d = f.y - u.y, v = Math.hypot(c, d) || 1, y = { x: -d / v, y: c / v };
-      if (Pe(l, i, y) <= t)
+      const c = s[a], d = s[(a + 1) % 4], u = d.x - c.x, f = d.y - c.y, p = Math.hypot(u, f) || 1, v = { x: -f / p, y: u / p };
+      if (dt(i, l, v) <= o)
         return !1;
     }
   return !0;
 }
-function Ee(e, o, t, n) {
-  return o.some(
-    (r) => ae(e, r, 1, t, n)
+function ft(e, t, o, n) {
+  return t.some(
+    (r) => ee(e, r, 1, o, n)
+  );
+}
+function De(e, t, o = 1, n = C, r = D) {
+  return e.some(
+    (i) => t.some(
+      (l) => ee(i, l, o, n, r)
+    )
   );
 }
-const P = D / 4, ne = 24;
+function $e(e, t = 1, o = C, n = D) {
+  for (let r = 0; r < e.length; r++)
+    for (let i = r + 1; i < e.length; i++)
+      if (ee(e[r], e[i], t, o, n))
+        return !0;
+  return !1;
+}
+const F = C / 4, ye = 24;
 function ue({
   startX: e,
-  startY: o,
-  angle: t,
+  startY: t,
+  angle: o,
   branch: n,
   layoutStyle: r,
-  dominoWidth: l = D,
-  dominoHeight: i = I,
+  dominoWidth: i = C,
+  dominoHeight: l = D,
   leadGap: s,
   depth: a = 0,
-  anchor: u,
-  outwardSign: f,
-  placed: c = [],
-  pushAxis: d,
-  minPushSteps: v = 0
+  anchor: c,
+  outwardSign: d,
+  placed: u = [],
+  pushAxis: f,
+  minPushSteps: p = 0
 }) {
-  const y = f ?? j(t), x = n.feet ? Object.keys(n.feet).map(Number).filter((p) => {
-    const h = n.dominoes[p];
-    return h && h.value1 === h.value2;
-  }).sort((p, h) => p - h)[0] : void 0, w = (p, h) => Oe({
-    startX: p,
-    startY: h,
-    angle: t,
+  const v = d ?? K(o), S = n.feet ? Object.keys(n.feet).map(Number).filter((g) => {
+    const I = n.dominoes[g];
+    return I && I.value1 === I.value2;
+  }).sort((g, I) => g - I)[0] : void 0, m = (g, I) => ct({
+    startX: g,
+    startY: I,
+    angle: o,
     dominoes: n.dominoes,
     layoutStyle: r,
-    dominoWidth: l,
-    dominoHeight: i,
+    dominoWidth: i,
+    dominoHeight: l,
     leadGap: s,
-    outwardSign: y,
-    hubIndex: x
+    outwardSign: v,
+    hubIndex: S,
+    bends: n.bends
   });
-  let z = w(
-    e + (d?.x ?? 0) * P * v,
-    o + (d?.y ?? 0) * P * v
-  ), $ = u && d ? {
-    x: u.x + d.x * P * v,
-    y: u.y + d.y * P * v
-  } : u;
-  if (d && c.length > 0)
-    for (let p = v; p <= ne; p++) {
-      const h = e + d.x * P * p, M = o + d.y * P * p, O = w(h, M);
-      if (!O.some(
-        (g) => Ee(g, c, l, i)
-      ) || p === ne) {
-        z = O, $ = u && {
-          x: u.x + d.x * P * p,
-          y: u.y + d.y * P * p
+  let P = m(
+    e + (f?.x ?? 0) * F * p,
+    t + (f?.y ?? 0) * F * p
+  ), b = c && f ? {
+    x: c.x + f.x * F * p,
+    y: c.y + f.y * F * p
+  } : c;
+  if (f && u.length > 0)
+    for (let g = p; g <= ye; g++) {
+      const I = e + f.x * F * g, k = t + f.y * F * g, x = m(I, k);
+      if (!x.some(
+        (y) => ft(y, u, i, l)
+      ) || g === ye) {
+        P = x, b = c && {
+          x: c.x + f.x * F * g,
+          y: c.y + f.y * F * g
         };
         break;
       }
     }
-  c.push(...z);
-  const m = [
+  u.push(...P);
+  const M = [
     {
-      angle: t,
+      angle: o,
       depth: a,
       layoutStyle: r,
-      outwardSign: y,
+      outwardSign: v,
       dominoes: n.dominoes,
-      layout: z,
-      anchor: $
+      layout: P,
+      anchor: b
     }
   ];
   if (n.feet) {
-    const { dirX: p, dirY: h } = _(t), { perpX: M, perpY: O } = N(t), A = l / 2, g = i / 2;
-    for (const S of Object.keys(n.feet)) {
-      const E = Number(S), C = z[E], q = n.feet[E];
-      if (!(!C || !C.isDouble || !q))
-        for (let L = 0; L < q.length; L++) {
-          const he = q[L], J = Ie[L] ?? 0, R = Math.sign(J), Q = t + J, Z = N(Q), V = -R, be = C.x + p * (l / 2) + M * (i / 2) * R, we = C.y + h * (l / 2) + O * (i / 2) * R, H = be - Z.perpX * V * A, W = we - Z.perpY * V * A;
-          m.push(
-            ...ue({
-              startX: H,
-              startY: W,
-              angle: Q,
-              branch: he,
-              // Toes inherit the main style so they zigzag in offset mode.
-              layoutStyle: r,
-              dominoWidth: l,
-              dominoHeight: i,
-              leadGap: g,
-              outwardSign: V,
-              depth: a + 1,
-              anchor: { x: H, y: W },
-              placed: c,
-              // If the snug spot is still blocked (the offset center toe leans into
-              // one side), slide this toe along the double's open edge, away from
-              // center, until it clears. This keeps it butted against the double
-              // while stepping past the obstacle — independent per toe, so a foot
-              // ends up snug and only as asymmetric as the obstruction requires.
-              pushAxis: { x: M * R, y: O * R }
-            })
-          );
-        }
+    const g = i / 2, I = l / 2;
+    for (const k of Object.keys(n.feet)) {
+      const x = Number(k), h = P[x], y = n.feet[x];
+      if (!h || !h.isDouble || !y)
+        continue;
+      const T = at(
+        o,
+        n.bends,
+        x,
+        n.dominoes.length
+      ), { dirX: O, dirY: _ } = Y(T), { perpX: U, perpY: j } = L(T);
+      for (let E = 0; E < y.length; E++) {
+        const oe = y[E], H = lt[E] ?? 0, R = Math.sign(H), Z = T + H, J = L(Z), re = -R, Ge = h.x + O * (i / 2) + U * (l / 2) * R, qe = h.y + _ * (i / 2) + j * (l / 2) * R, he = Ge - J.perpX * re * g, ge = qe - J.perpY * re * g;
+        M.push(
+          ...ue({
+            startX: he,
+            startY: ge,
+            angle: Z,
+            branch: oe,
+            // Toes inherit the main style so they zigzag in offset mode.
+            layoutStyle: r,
+            dominoWidth: i,
+            dominoHeight: l,
+            leadGap: I,
+            outwardSign: re,
+            depth: a + 1,
+            anchor: { x: he, y: ge },
+            placed: u,
+            // If the snug spot is still blocked (the offset center toe leans into
+            // one side), slide this toe along the double's open edge, away from
+            // center, until it clears. This keeps it butted against the double
+            // while stepping past the obstacle — independent per toe, so a foot
+            // ends up snug and only as asymmetric as the obstruction requires.
+            pushAxis: { x: U * R, y: j * R }
+          })
+        );
+      }
     }
   }
-  return m;
+  return M;
 }
-function Fe(e) {
-  return e.flatMap((o) => o.layout);
+function Ee(e) {
+  return e.flatMap((t) => t.layout);
 }
-function io(e, o = 24, t = D, n = I) {
-  const r = Math.hypot(t, n) / 2;
+function dn(e, t = 24, o = C, n = D) {
+  const r = Math.hypot(o, n) / 2;
   if (e.length === 0)
     return {
-      width: o * 2 + t,
-      height: o * 2 + n,
-      offsetX: o,
-      offsetY: o
+      width: t * 2 + o,
+      height: t * 2 + n,
+      offsetX: t,
+      offsetY: t
     };
-  let l = 1 / 0, i = 1 / 0, s = -1 / 0, a = -1 / 0;
-  for (const u of e)
-    l = Math.min(l, u.x - r), i = Math.min(i, u.y - r), s = Math.max(s, u.x + r), a = Math.max(a, u.y + r);
+  let i = 1 / 0, l = 1 / 0, s = -1 / 0, a = -1 / 0;
+  for (const c of e)
+    i = Math.min(i, c.x - r), l = Math.min(l, c.y - r), s = Math.max(s, c.x + r), a = Math.max(a, c.y + r);
   return {
-    width: Math.ceil(s - l + o * 2),
-    height: Math.ceil(a - i + o * 2),
-    offsetX: o - l,
-    offsetY: o - i
+    width: Math.ceil(s - i + t * 2),
+    height: Math.ceil(a - l + t * 2),
+    offsetX: t - i,
+    offsetY: t - l
+  };
+}
+const te = 1;
+function Ae(e, t, o) {
+  const { dirX: n, dirY: r } = Y(o);
+  return e * n + t * r;
+}
+function pt(e, t, o) {
+  const { perpX: n, perpY: r } = L(o);
+  return e * n + t * r;
+}
+function ce(e) {
+  const t = [];
+  for (let o = 1; o < e.length; o++)
+    e[o].value1 !== e[o - 1].value2 && t.push({
+      code: "chain-break",
+      message: `Domino ${o} does not connect to domino ${o - 1}`,
+      index: o
+    });
+  for (let o = 1; o < e.length; o++) {
+    const n = e[o - 1].value1 === e[o - 1].value2, r = e[o].value1 === e[o].value2;
+    n && r && t.push({
+      code: "consecutive-doubles",
+      message: `Consecutive doubles at index ${o - 1} and ${o}`,
+      index: o
+    });
+  }
+  return { valid: t.length === 0, issues: t };
+}
+function Oe(e, t, o, n = C, r = D) {
+  const i = n / 2, l = e.map((u) => u.isDouble), s = [];
+  let a = 0, c = 0, d = 0;
+  for (let u = 0; u < e.length; u++) {
+    const f = l[u], p = u > 0 && l[u - 1];
+    t === "linear" ? (u > 0 && (a += A(p, f, n, r)), c = 0) : f ? u > 0 && (a += A(p, !0, n, r)) : u === 0 ? (d = o, c = d * i) : p ? a += A(!0, !1, n, r) : (a += r / 2, d = Me(d, o), c = d * i), s.push({ along: a, perp: c });
+  }
+  return s;
+}
+function ht(e, t, o, n = te, r) {
+  const i = [], l = r ?? K(t), s = Oe(e, o, l);
+  for (let a = 1; a < e.length; a++) {
+    const c = e[a - 1], d = e[a], u = d.x - c.x, f = d.y - c.y, p = Ae(u, f, t), v = pt(u, f, t), S = s[a].along - s[a - 1].along, m = s[a].perp - s[a - 1].perp;
+    Math.abs(p - S) > n && i.push({
+      code: "spacing-along-train",
+      message: `Along-train spacing between domino ${a - 1} and ${a} is ${p.toFixed(2)}px (expected ${S}px)`,
+      index: a
+    }), Math.abs(v - m) > n && i.push({
+      code: "spacing-perpendicular",
+      message: `Perpendicular spacing between domino ${a - 1} and ${a} is ${v.toFixed(2)}px (expected ${m}px)`,
+      index: a
+    });
+  }
+  return { valid: i.length === 0, issues: i };
+}
+function gt(e, t, o, n = te, r) {
+  const i = [], l = r ?? K(t), s = Oe(e, o, l);
+  for (let a = 1; a < e.length; a++) {
+    const c = e[a - 1], d = e[a], u = d.x - c.x, f = d.y - c.y, p = Math.hypot(u, f), v = s[a].along - s[a - 1].along, S = s[a].perp - s[a - 1].perp, m = Math.hypot(v, S) * 0.9;
+    p + n < m && i.push({
+      code: "overlap",
+      message: `Domino ${a - 1} and ${a} centers are ${p.toFixed(2)}px apart (minimum ${m.toFixed(2)}px)`,
+      index: a
+    });
+  }
+  return { valid: i.length === 0, issues: i };
+}
+function fn(e, t, o, n, r = te, i) {
+  const l = [
+    ...ce(t).issues,
+    ...ht(
+      e,
+      o,
+      n,
+      r,
+      i
+    ).issues,
+    ...gt(
+      e,
+      o,
+      n,
+      r,
+      i
+    ).issues
+  ];
+  return e.length !== t.length && l.push({
+    code: "layout-length",
+    message: `Layout length ${e.length} does not match domino count ${t.length}`
+  }), { valid: l.length === 0, issues: l };
+}
+function vt(e) {
+  const t = [], o = (n, r) => {
+    if (t.push(
+      ...ce(n.dominoes).issues.map((i) => ({
+        ...i,
+        message: `[${r}] ${i.message}`
+      }))
+    ), !!n.feet)
+      for (const i of Object.keys(n.feet)) {
+        const l = Number(i), s = n.dominoes[l], a = n.feet[l] ?? [];
+        if (!s) {
+          t.push({
+            code: "foot-host-missing",
+            message: `[${r}] Foot references missing tile ${l}`
+          });
+          continue;
+        }
+        s.value1 !== s.value2 && t.push({
+          code: "foot-host-not-double",
+          message: `[${r}] Foot host tile ${l} is not a double`
+        }), a.length > 2 && t.push({
+          code: "foot-too-many-toes",
+          message: `[${r}] Double ${l} has ${a.length} side toes (max 2; the center toe is the main line)`
+        }), a.forEach((c, d) => {
+          const u = c.dominoes[0];
+          u && u.value1 !== s.value1 && t.push({
+            code: "foot-connection",
+            message: `[${r}] Toe ${d} on double ${l} starts with ${u.value1} but the double is ${s.value1}`
+          }), o(c, `${r}.${l}.${d}`);
+        });
+      }
   };
+  return o(e, "main"), { valid: t.length === 0, issues: t };
 }
-const Ae = ({
+function pn(e, t = te) {
+  const o = [];
+  e.forEach((r, i) => {
+    if (o.push(
+      ...ce(r.dominoes).issues.map((l) => ({
+        ...l,
+        message: `[segment ${i} @${r.angle}°] ${l.message}`
+      }))
+    ), r.layout.length !== r.dominoes.length && o.push({
+      code: "layout-length",
+      message: `[segment ${i}] Layout length ${r.layout.length} does not match domino count ${r.dominoes.length}`
+    }), r.anchor && r.layout.length > 0) {
+      const l = r.layout[0], s = Ae(
+        l.x - r.anchor.x,
+        l.y - r.anchor.y,
+        r.angle
+      ), a = D / 2;
+      Math.abs(s - a) > t && o.push({
+        code: "foot-anchor",
+        message: `[segment ${i}] First toe tile sits ${s.toFixed(2)}px from the double along the toe (expected ${a}px)`,
+        index: 0
+      });
+    }
+  });
+  const n = e.flatMap((r) => r.layout);
+  for (let r = 0; r < n.length; r++)
+    for (let i = r + 1; i < n.length; i++)
+      ee(n[r], n[i]) && o.push({
+        code: "tile-overlap",
+        message: `Tiles ${r} and ${i} overlap`,
+        index: i
+      });
+  return { valid: o.length === 0, issues: o };
+}
+const xt = (() => {
+  try {
+    return !1;
+  } catch {
+    return !1;
+  }
+})(), bt = ({
   startX: e,
-  startY: o,
-  angle: t,
+  startY: t,
+  angle: o,
   trainData: n,
   layoutStyle: r,
-  tableWidth: l,
-  tableHeight: i,
+  tableWidth: i,
+  tableHeight: l,
   centerX: s,
   centerY: a,
-  pipColors: u
+  pipColors: c
 }) => {
-  const f = Se(
-    () => Fe(
+  ae(() => {
+    if (!xt) return;
+    const u = vt({
+      dominoes: n.dominoes,
+      feet: n.feet
+    });
+    u.valid || console.warn(
+      `DominoTrain: player ${n.playerId} train does not follow the rules:`,
+      u.issues.map((f) => f.message)
+    );
+  }, [n.dominoes, n.feet, n.playerId]);
+  const d = He(
+    () => Ee(
       ue({
         startX: e,
-        startY: o,
-        angle: t,
+        startY: t,
+        angle: o,
         branch: { dominoes: n.dominoes, feet: n.feet },
         layoutStyle: r
       })
     ),
     [
       e,
-      o,
       t,
+      o,
       n.dominoes,
       n.feet,
       r,
-      l,
-      i
+      i,
+      l
     ]
   );
-  return /* @__PURE__ */ b(re, { children: f.map((c, d) => {
-    const v = n.isPublic;
-    return /* @__PURE__ */ b(
+  return /* @__PURE__ */ z(we, { children: d.map((u, f) => {
+    const p = n.isPublic;
+    return /* @__PURE__ */ z(
       "div",
       {
         style: {
           position: "absolute",
-          left: `${c.x - D / 2}px`,
-          top: `${c.y - I / 2}px`,
+          left: `${u.x - C / 2}px`,
+          top: `${u.y - D / 2}px`,
           zIndex: 5
         },
-        children: /* @__PURE__ */ b(
-          ie,
+        children: /* @__PURE__ */ z(
+          Te,
           {
-            value1: c.value1,
-            value2: c.value2,
-            width: D,
-            height: I,
+            value1: u.value1,
+            value2: u.value2,
+            width: C,
+            height: D,
             backgroundColor: "white",
             pipColor: "black",
-            pipColors: u,
-            borderColor: v ? "red" : "black",
-            rotation: c.rotation
+            pipColors: c,
+            borderColor: p ? "red" : "black",
+            rotation: u.rotation
           }
         )
       },
-      `main-train-${n.playerId}-${d}`
+      `main-train-${n.playerId}-${f}`
     );
   }) });
-}, Re = ({
+};
+function yt(e, t, o, n) {
+  const r = o * (n === "offset" ? 2.5 : 1.3);
+  return Math.max(t + 20, Math.ceil(r * e / (2 * Math.PI)));
+}
+const mt = ({
   playerCount: e,
-  centerX: o,
-  centerY: t,
+  centerX: t,
+  centerY: o,
   radius: n,
   engineValue: r,
-  trains: l,
-  layoutStyle: i,
+  trains: i,
+  layoutStyle: l,
   tableWidth: s,
   tableHeight: a,
-  pipColors: u
+  pipColors: c
 }) => {
-  const f = Math.max(8, e), c = 120;
-  return /* @__PURE__ */ T("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
-    /* @__PURE__ */ b(
+  const d = Math.max(8, e), u = 120, f = 60, p = 120, v = yt(d, n, f, l);
+  return /* @__PURE__ */ $("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ z(
       "div",
       {
         style: {
           position: "absolute",
-          width: `${c}px`,
-          height: `${c}px`,
-          left: `${o - c / 2}px`,
-          top: `${t - c / 2}px`,
+          width: `${u}px`,
+          height: `${u}px`,
+          left: `${t - u / 2}px`,
+          top: `${o - u / 2}px`,
           backgroundColor: "#d1d5db",
           borderWidth: "3px",
           borderStyle: "solid",
@@ -602,186 +918,186 @@ const Ae = ({
           justifyContent: "center",
           alignItems: "center"
         },
-        children: /* @__PURE__ */ b("div", { style: { transform: "rotate(0deg)" }, children: /* @__PURE__ */ b(
-          ie,
+        children: /* @__PURE__ */ z("div", { style: { transform: "rotate(0deg)" }, children: /* @__PURE__ */ z(
+          Te,
           {
             value1: r,
             value2: r,
-            width: 60,
-            height: 120,
+            width: f,
+            height: p,
             backgroundColor: "white",
             pipColor: "black",
-            pipColors: u,
+            pipColors: c,
             borderColor: "#333"
           }
         ) })
       }
     ),
-    Array.from({ length: f }).map((y, x) => {
-      const w = x * 360 / f, z = w * Math.PI / 180, $ = o + (n + 20) * Math.cos(z), m = t + (n + 20) * Math.sin(z), p = l.find((h) => h.playerId === x) || {
+    Array.from({ length: d }).map((S, m) => {
+      const P = m * 360 / d, b = P * Math.PI / 180, M = t + v * Math.cos(b), g = o + v * Math.sin(b), I = i.find((k) => k.playerId === m) || {
         dominoes: [],
-        playerId: x,
+        playerId: m,
         isPublic: !1
       };
-      return /* @__PURE__ */ b(
-        Ae,
+      return /* @__PURE__ */ z(
+        bt,
         {
-          startX: $,
-          startY: m,
-          angle: w,
-          trainData: p,
-          layoutStyle: i,
+          startX: M,
+          startY: g,
+          angle: P,
+          trainData: I,
+          layoutStyle: l,
           tableWidth: s,
           tableHeight: a,
-          centerX: o,
-          centerY: t,
-          pipColors: u
+          centerX: t,
+          centerY: o,
+          pipColors: c
         },
-        x
+        m
       );
     })
   ] });
 };
-function F(e, o) {
-  return e <= o ? `${e}:${o}` : `${o}:${e}`;
+function V(e, t) {
+  return e <= t ? `${e}:${t}` : `${t}:${e}`;
 }
-function ce(e) {
-  return F(e.value1, e.value2);
+function B(e) {
+  return V(e.value1, e.value2);
 }
-function de(e) {
+function Re(e) {
   return e.value1 === e.value2;
 }
-function so(e, o) {
-  return e.value1 === o || e.value2 === o;
+function Fe(e, t) {
+  return e.value1 === t || e.value2 === t;
 }
-function ao(e, o) {
-  return e.value1 === o ? e.value2 : e.value2 === o ? e.value1 : null;
+function hn(e, t) {
+  return e.value1 === t ? e.value2 : e.value2 === t ? e.value1 : null;
 }
-function fe(e, o) {
-  return e.value1 === o ? { value1: e.value1, value2: e.value2 } : e.value2 === o ? { value1: e.value2, value2: e.value1 } : null;
+function de(e, t) {
+  return e.value1 === t ? { value1: e.value1, value2: e.value2 } : e.value2 === t ? { value1: e.value2, value2: e.value1 } : null;
 }
-function uo(e) {
-  const o = [];
-  for (let t = 0; t <= e; t++)
-    for (let n = t; n <= e; n++)
-      o.push({ value1: t, value2: n });
-  return o;
+function wt(e) {
+  const t = [];
+  for (let o = 0; o <= e; o++)
+    for (let n = o; n <= e; n++)
+      t.push({ value1: o, value2: n });
+  return t;
+}
+function gn(e) {
+  const t = e + 1;
+  return t * (t + 1) / 2;
 }
-function co(e) {
-  const o = e + 1;
-  return o * (o + 1) / 2;
-}
-function Xe(e, o = 12, t = {}) {
-  const n = /* @__PURE__ */ new Set([F(o, o)]), r = [];
-  for (let l = 0; l < e; l++) {
-    const i = 4 + Math.floor(Math.random() * 7), s = [];
-    let a = o, u = !1;
-    for (let c = 0; c < i; c++) {
-      const d = Ne(
+function St(e, t = 12, o = {}) {
+  const n = /* @__PURE__ */ new Set([V(t, t)]), r = [];
+  for (let i = 0; i < e; i++) {
+    const l = 4 + Math.floor(Math.random() * 7), s = [];
+    let a = t, c = !1;
+    for (let u = 0; u < l; u++) {
+      const f = Tt(
         a,
-        u,
-        c === 0,
-        o,
+        c,
+        u === 0,
+        t,
         n
       );
-      if (d === null)
+      if (f === null)
         break;
-      const v = d === a;
-      n.add(F(a, d)), s.push({ value1: a, value2: d }), u = v, a = d;
+      const p = f === a;
+      n.add(V(a, f)), s.push({ value1: a, value2: f }), c = p, a = f;
     }
-    const f = t.chickenFeet ? _e(s, n) : void 0;
+    const d = o.chickenFeet ? zt(s, n) : void 0;
     r.push({
-      playerId: l,
+      playerId: i,
       dominoes: s,
       isPublic: Math.random() > 0.7,
-      ...f ? { feet: f } : {}
+      ...d ? { feet: d } : {}
     });
   }
   return r;
 }
-function _e(e, o) {
-  const t = {};
+function zt(e, t) {
+  const o = {};
   for (let n = 0; n < e.length; n++) {
     if (e[n].value1 !== e[n].value2)
       continue;
-    const r = e[n].value1, l = [];
-    for (let i = 0; i < 2; i++) {
-      const s = Le(r, o);
-      s && l.push(s);
+    const r = e[n].value1, i = [];
+    for (let l = 0; l < 2; l++) {
+      const s = It(r, t);
+      s && i.push(s);
     }
-    l.length && (t[n] = l);
+    i.length && (o[n] = i);
   }
-  return Object.keys(t).length ? t : void 0;
+  return Object.keys(o).length ? o : void 0;
 }
-function Le(e, o) {
-  const t = 1 + Math.floor(Math.random() * 2), n = [];
+function It(e, t) {
+  const o = 1 + Math.floor(Math.random() * 2), n = [];
   let r = e;
-  for (let l = 0; l < t; l++) {
-    const i = Ye(r, o);
-    if (i === null)
+  for (let i = 0; i < o; i++) {
+    const l = Pt(r, t);
+    if (l === null)
       break;
-    o.add(F(r, i)), n.push({ value1: r, value2: i }), r = i;
+    t.add(V(r, l)), n.push({ value1: r, value2: l }), r = l;
   }
   return n.length ? { dominoes: n } : null;
 }
-function Ye(e, o) {
-  const t = [];
+function Pt(e, t) {
+  const o = [];
   for (let n = 0; n < 13; n++)
-    n !== e && (o.has(F(e, n)) || t.push(n));
-  return t.length === 0 ? null : t[Math.floor(Math.random() * t.length)];
+    n !== e && (t.has(V(e, n)) || o.push(n));
+  return o.length === 0 ? null : o[Math.floor(Math.random() * o.length)];
 }
-function Ne(e, o, t, n, r) {
-  const l = Array.from({ length: 13 }, (i, s) => s).filter(
-    (i) => je(
+function Tt(e, t, o, n, r) {
+  const i = Array.from({ length: 13 }, (l, s) => s).filter(
+    (l) => Mt(
       e,
-      i,
-      o,
+      l,
       t,
+      o,
       n,
       r
     )
   );
-  return l.length === 0 ? null : l[Math.floor(Math.random() * l.length)];
+  return i.length === 0 ? null : i[Math.floor(Math.random() * i.length)];
 }
-function je(e, o, t, n, r, l) {
-  const i = o === e;
-  return !(n && i && e === r || i && t || l.has(F(e, o)));
+function Mt(e, t, o, n, r, i) {
+  const l = t === e;
+  return !(n && l && e === r || l && o || i.has(V(e, t)));
 }
-const Be = {
+const kt = {
   playerCount: 8,
   trains: [],
   engineValue: 12
-}, fo = ({
-  initialState: e = Be,
-  width: o = 1200,
-  height: t = 800,
+}, vn = ({
+  initialState: e = kt,
+  width: t = 1200,
+  height: o = 800,
   pipColors: n,
   onPipColorsChange: r
 }) => {
-  const [l, i] = Y(e), [s, a] = Y("offset"), [u, f] = Y(!1), [c, d] = Y(void 0), v = n ?? c, y = r ?? d, x = v !== void 0, w = o / 2, z = t / 2, $ = (p = u) => {
-    const h = Xe(
-      l.playerCount,
-      l.engineValue,
-      { chickenFeet: p }
+  const [i, l] = G(e), [s, a] = G("offset"), [c, d] = G(!1), [u, f] = G(void 0), p = n ?? u, v = r ?? f, S = p !== void 0, m = t / 2, P = o / 2, b = (g = c) => {
+    const I = St(
+      i.playerCount,
+      i.engineValue,
+      { chickenFeet: g }
     );
-    i((M) => ({
-      ...M,
-      trains: h
+    l((k) => ({
+      ...k,
+      trains: I
     }));
   };
-  ye(() => {
-    $();
+  ae(() => {
+    b();
   }, []);
-  const m = () => {
-    const p = !u;
-    f(p), $(p);
+  const M = () => {
+    const g = !c;
+    d(g), b(g);
   };
-  return /* @__PURE__ */ T(
+  return /* @__PURE__ */ $(
     "div",
     {
       style: {
-        width: `${o}px`,
-        height: `${t}px`,
+        width: `${t}px`,
+        height: `${o}px`,
         position: "relative",
         backgroundColor: "#1f8a55",
         // Classic green felt background
@@ -790,15 +1106,15 @@ const Be = {
         overflow: "hidden"
       },
       children: [
-        /* @__PURE__ */ T(
+        /* @__PURE__ */ $(
           "div",
           {
             style: { position: "absolute", top: "10px", left: "10px", zIndex: 100 },
             children: [
-              /* @__PURE__ */ b(
+              /* @__PURE__ */ z(
                 "button",
                 {
-                  onClick: () => $(),
+                  onClick: () => b(),
                   style: {
                     padding: "8px 12px",
                     backgroundColor: "#fff",
@@ -810,7 +1126,7 @@ const Be = {
                   children: "New trains"
                 }
               ),
-              /* @__PURE__ */ T(
+              /* @__PURE__ */ $(
                 "button",
                 {
                   onClick: () => a(s === "offset" ? "linear" : "offset"),
@@ -828,45 +1144,45 @@ const Be = {
                   ]
                 }
               ),
-              /* @__PURE__ */ T(
+              /* @__PURE__ */ $(
                 "button",
                 {
-                  onClick: m,
+                  onClick: M,
                   style: {
                     padding: "8px 12px",
-                    backgroundColor: u ? "#fef3c7" : "#fff",
-                    border: `1px solid ${u ? "#f59e0b" : "#ccc"}`,
+                    backgroundColor: c ? "#fef3c7" : "#fff",
+                    border: `1px solid ${c ? "#f59e0b" : "#ccc"}`,
                     borderRadius: "4px",
                     marginRight: "10px",
                     cursor: "pointer"
                   },
                   children: [
                     "Chicken Feet: ",
-                    u ? "On" : "Off"
+                    c ? "On" : "Off"
                   ]
                 }
               ),
-              /* @__PURE__ */ T(
+              /* @__PURE__ */ $(
                 "button",
                 {
-                  onClick: () => y(x ? void 0 : X),
+                  onClick: () => v(S ? void 0 : q),
                   style: {
                     padding: "8px 12px",
-                    backgroundColor: x ? "#fef3c7" : "#fff",
-                    border: `1px solid ${x ? "#f59e0b" : "#ccc"}`,
+                    backgroundColor: S ? "#fef3c7" : "#fff",
+                    border: `1px solid ${S ? "#f59e0b" : "#ccc"}`,
                     borderRadius: "4px",
                     cursor: "pointer"
                   },
                   children: [
                     "Pip Colors: ",
-                    x ? "On" : "Off"
+                    S ? "On" : "Off"
                   ]
                 }
               )
             ]
           }
         ),
-        /* @__PURE__ */ T(
+        /* @__PURE__ */ $(
           "div",
           {
             style: {
@@ -880,191 +1196,270 @@ const Be = {
               fontSize: "14px"
             },
             children: [
-              /* @__PURE__ */ T("div", { children: [
+              /* @__PURE__ */ $("div", { children: [
                 "Engine: Double-",
-                l.engineValue
+                i.engineValue
               ] }),
-              /* @__PURE__ */ T("div", { children: [
+              /* @__PURE__ */ $("div", { children: [
                 "Players: ",
-                l.playerCount
+                i.playerCount
               ] })
             ]
           }
         ),
-        /* @__PURE__ */ b(
-          Re,
+        /* @__PURE__ */ z(
+          mt,
           {
-            playerCount: l.playerCount,
-            centerX: w,
-            centerY: z,
+            playerCount: i.playerCount,
+            centerX: m,
+            centerY: P,
             radius: 80,
-            engineValue: l.engineValue,
-            trains: l.trains,
+            engineValue: i.engineValue,
+            trains: i.trains,
             layoutStyle: s,
-            tableWidth: o,
-            tableHeight: t,
-            pipColors: v
+            tableWidth: t,
+            tableHeight: o,
+            pipColors: p
           }
         )
       ]
     }
   );
-}, B = 1;
-function pe(e, o, t) {
-  const { dirX: n, dirY: r } = _(t);
-  return e * n + o * r;
+}, fe = 90;
+function se(e, t = fe) {
+  return e === "right" ? t : -t;
 }
-function Ue(e, o, t) {
-  const { perpX: n, perpY: r } = N(t);
-  return e * n + o * r;
+function Ne(e) {
+  return e === "right" ? "left" : "right";
 }
-function K(e) {
-  const o = [];
-  for (let t = 1; t < e.length; t++)
-    e[t].value1 !== e[t - 1].value2 && o.push({
-      code: "chain-break",
-      message: `Domino ${t} does not connect to domino ${t - 1}`,
-      index: t
-    });
-  for (let t = 1; t < e.length; t++) {
-    const n = e[t - 1].value1 === e[t - 1].value2, r = e[t].value1 === e[t].value2;
-    n && r && o.push({
-      code: "consecutive-doubles",
-      message: `Consecutive doubles at index ${t - 1} and ${t}`,
-      index: t
-    });
-  }
-  return { valid: o.length === 0, issues: o };
+function xn(e, t) {
+  return (t ?? K(e)) >= 0 ? "left" : "right";
 }
-function ve(e, o, t, n = D, r = I) {
-  const l = n / 2, i = e.map((c) => c.isDouble), s = [];
-  let a = 0, u = 0, f = 0;
-  for (let c = 0; c < e.length; c++) {
-    const d = i[c], v = c > 0 && i[c - 1];
-    o === "linear" ? (c > 0 && (a += k(v, d, n, r)), u = 0) : d ? c > 0 && (a += k(v, !0, n, r)) : c === 0 ? (f = t, u = f * l) : v ? a += k(!0, !1, n, r) : (a += r / 2, f = se(f, t), u = f * l), s.push({ along: a, perp: u });
-  }
-  return s;
+function bn(e, t, o) {
+  const { perpX: n, perpY: r } = L(t), i = (a, c) => {
+    let d = 1 / 0;
+    return a > 0 ? d = Math.min(d, (o.width - e.x) / a) : a < 0 && (d = Math.min(d, (0 - e.x) / a)), c > 0 ? d = Math.min(d, (o.height - e.y) / c) : c < 0 && (d = Math.min(d, (0 - e.y) / c)), Number.isFinite(d) ? Math.max(0, d) : 1 / 0;
+  }, l = i(n, r), s = i(-n, -r);
+  return l >= s ? "right" : "left";
 }
-function qe(e, o, t, n = B, r) {
-  const l = [], i = r ?? j(o), s = ve(e, t, i);
-  for (let a = 1; a < e.length; a++) {
-    const u = e[a - 1], f = e[a], c = f.x - u.x, d = f.y - u.y, v = pe(c, d, o), y = Ue(c, d, o), x = s[a].along - s[a - 1].along, w = s[a].perp - s[a - 1].perp;
-    Math.abs(v - x) > n && l.push({
-      code: "spacing-along-train",
-      message: `Along-train spacing between domino ${a - 1} and ${a} is ${v.toFixed(2)}px (expected ${x}px)`,
-      index: a
-    }), Math.abs(y - w) > n && l.push({
-      code: "spacing-perpendicular",
-      message: `Perpendicular spacing between domino ${a - 1} and ${a} is ${y.toFixed(2)}px (expected ${w}px)`,
-      index: a
-    });
+function Ye(e, t) {
+  return Ee(
+    ue({
+      startX: t.startX,
+      startY: t.startY,
+      angle: t.angle,
+      branch: e,
+      layoutStyle: t.layoutStyle
+    })
+  );
+}
+function Q(e, t, o) {
+  const n = (e ?? []).filter((r) => r.index !== t);
+  return o === null ? n : [...n, { index: t, turn: o }].sort((r, i) => r.index - i.index);
+}
+function yn({
+  branch: e,
+  index: t,
+  build: o,
+  obstacles: n,
+  preferredSide: r,
+  degrees: i = fe
+}) {
+  const l = [r, Ne(r)];
+  for (const s of l) {
+    const a = se(s, i), c = {
+      ...e,
+      bends: Q(e.bends, t, a)
+    }, d = Ye(c, o);
+    if (!$e(d) && !De(d, n))
+      return { turn: a };
   }
-  return { valid: l.length === 0, issues: l };
+  return { turn: null, reason: "blocked" };
 }
-function Ve(e, o, t, n = B, r) {
-  const l = [], i = r ?? j(o), s = ve(e, t, i);
-  for (let a = 1; a < e.length; a++) {
-    const u = e[a - 1], f = e[a], c = f.x - u.x, d = f.y - u.y, v = Math.hypot(c, d), y = s[a].along - s[a - 1].along, x = s[a].perp - s[a - 1].perp, w = Math.hypot(y, x) * 0.9;
-    v + n < w && l.push({
-      code: "overlap",
-      message: `Domino ${a - 1} and ${a} centers are ${v.toFixed(2)}px apart (minimum ${w.toFixed(2)}px)`,
-      index: a
-    });
+function mn(e, t, o, n, r, i = fe) {
+  const l = (e.bends ?? []).find((u) => u.index === t), s = se(r, i), a = se(Ne(r), i), c = (u) => {
+    const f = {
+      ...e,
+      bends: Q(e.bends, t, u)
+    }, p = Ye(f, o);
+    return !$e(p) && !De(p, n);
+  };
+  let d;
+  l ? l.turn === s ? d = [a, null] : l.turn === a ? d = [null] : d = [s, a, null] : d = [s, a];
+  for (const u of d) {
+    if (u === null)
+      return { bends: Q(e.bends, t, null), changed: !0, blocked: !1 };
+    if (c(u))
+      return { bends: Q(e.bends, t, u), changed: !0, blocked: !1 };
   }
-  return { valid: l.length === 0, issues: l };
+  return { bends: e.bends ?? [], changed: !1, blocked: !0 };
 }
-function po(e, o, t, n, r = B, l) {
-  const i = [
-    ...K(o).issues,
-    ...qe(
-      e,
-      t,
-      n,
-      r,
-      l
-    ).issues,
-    ...Ve(
-      e,
-      t,
-      n,
-      r,
-      l
-    ).issues
-  ];
-  return e.length !== o.length && i.push({
-    code: "layout-length",
-    message: `Layout length ${e.length} does not match domino count ${o.length}`
-  }), { valid: i.length === 0, issues: i };
+function pe(e, t, o) {
+  return Math.min(o, Math.max(t, e));
 }
-function vo(e) {
-  const o = [], t = (n, r) => {
-    if (o.push(
-      ...K(n.dominoes).issues.map((l) => ({
-        ...l,
-        message: `[${r}] ${l.message}`
-      }))
-    ), !!n.feet)
-      for (const l of Object.keys(n.feet)) {
-        const i = Number(l), s = n.dominoes[i], a = n.feet[i] ?? [];
-        if (!s) {
-          o.push({
-            code: "foot-host-missing",
-            message: `[${r}] Foot references missing tile ${i}`
-          });
-          continue;
-        }
-        s.value1 !== s.value2 && o.push({
-          code: "foot-host-not-double",
-          message: `[${r}] Foot host tile ${i} is not a double`
-        }), a.length > 2 && o.push({
-          code: "foot-too-many-toes",
-          message: `[${r}] Double ${i} has ${a.length} side toes (max 2; the center toe is the main line)`
-        }), a.forEach((u, f) => {
-          const c = u.dominoes[0];
-          c && c.value1 !== s.value1 && o.push({
-            code: "foot-connection",
-            message: `[${r}] Toe ${f} on double ${i} starts with ${c.value1} but the double is ${s.value1}`
-          }), t(u, `${r}.${i}.${f}`);
-        });
-      }
+function me(e, t, o, n, r) {
+  const i = pe(e.scale * t, n, r), l = i / e.scale;
+  return {
+    scale: i,
+    x: o.x - (o.x - e.x) * l,
+    y: o.y - (o.y - e.y) * l
   };
-  return t(e, "main"), { valid: o.length === 0, issues: o };
 }
-function xo(e, o = B) {
-  const t = [];
-  e.forEach((r, l) => {
-    if (t.push(
-      ...K(r.dominoes).issues.map((i) => ({
-        ...i,
-        message: `[segment ${l} @${r.angle}°] ${i.message}`
-      }))
-    ), r.layout.length !== r.dominoes.length && t.push({
-      code: "layout-length",
-      message: `[segment ${l}] Layout length ${r.layout.length} does not match domino count ${r.dominoes.length}`
-    }), r.anchor && r.layout.length > 0) {
-      const i = r.layout[0], s = pe(
-        i.x - r.anchor.x,
-        i.y - r.anchor.y,
-        r.angle
-      ), a = I / 2;
-      Math.abs(s - a) > o && t.push({
-        code: "foot-anchor",
-        message: `[segment ${l}] First toe tile sits ${s.toFixed(2)}px from the double along the toe (expected ${a}px)`,
-        index: 0
-      });
-    }
-  });
-  const n = e.flatMap((r) => r.layout);
-  for (let r = 0; r < n.length; r++)
-    for (let l = r + 1; l < n.length; l++)
-      ae(n[r], n[l]) && t.push({
-        code: "tile-overlap",
-        message: `Tiles ${r} and ${l} overlap`,
-        index: l
-      });
-  return { valid: t.length === 0, issues: t };
+function Ct(e, t, o, n, r) {
+  const i = Math.max(1, e.width), l = Math.max(1, e.height), s = Math.min(
+    (t.width - o * 2) / i,
+    (t.height - o * 2) / l
+  ), a = pe(s, n, r);
+  return {
+    scale: a,
+    x: (t.width - i * a) / 2,
+    y: (t.height - l * a) / 2
+  };
 }
-const go = [
+function wn(e, t) {
+  return {
+    x: (t.x - e.x) / e.scale,
+    y: (t.y - e.y) / e.scale
+  };
+}
+const Dt = 3, Sn = ({
+  width: e,
+  height: t,
+  contentWidth: o,
+  contentHeight: n,
+  children: r,
+  minScale: i = 0.2,
+  maxScale: l = 4,
+  zoomStep: s = 1.15,
+  padding: a = 40,
+  background: c = "#1f8a55",
+  showControls: d = !0,
+  testId: u = "viewport"
+}) => {
+  const f = ve(null), p = Ze(
+    () => Ct(
+      { width: o, height: n },
+      { width: e, height: t },
+      a,
+      i,
+      l
+    ),
+    [o, n, e, t, a, i, l]
+  ), [v, S] = G(p);
+  ae(() => {
+    S(p());
+  }, [p]);
+  const m = ve(null), P = (h, y) => {
+    const T = f.current?.getBoundingClientRect();
+    return { x: h - (T?.left ?? 0), y: y - (T?.top ?? 0) };
+  }, b = (h) => {
+    m.current = {
+      pointerX: h.clientX,
+      pointerY: h.clientY,
+      startX: v.x,
+      startY: v.y,
+      moved: !1
+    };
+  }, M = (h) => {
+    const y = m.current;
+    if (!y) return;
+    const T = h.clientX - y.pointerX, O = h.clientY - y.pointerY;
+    !y.moved && Math.hypot(T, O) < Dt || (y.moved = !0, f.current?.setPointerCapture?.(h.pointerId), S((_) => ({ ..._, x: y.startX + T, y: y.startY + O })));
+  }, g = (h) => {
+    m.current?.moved && h.preventDefault(), m.current = null;
+  }, I = (h) => {
+    h.preventDefault();
+    const y = P(h.clientX, h.clientY), T = h.deltaY < 0 ? s : 1 / s;
+    S((O) => me(O, T, y, i, l));
+  }, k = (h) => S(
+    (y) => me(y, h, { x: e / 2, y: t / 2 }, i, l)
+  ), x = {
+    width: 32,
+    height: 32,
+    fontSize: 18,
+    lineHeight: "30px",
+    textAlign: "center",
+    cursor: "pointer",
+    background: "#fff",
+    border: "1px solid #d1d5db",
+    borderRadius: 6,
+    userSelect: "none"
+  };
+  return /* @__PURE__ */ $(
+    "div",
+    {
+      ref: f,
+      "data-testid": u,
+      onPointerDown: b,
+      onPointerMove: M,
+      onPointerUp: g,
+      onPointerLeave: g,
+      onWheel: I,
+      style: {
+        position: "relative",
+        width: e,
+        height: t,
+        overflow: "hidden",
+        background: c,
+        borderRadius: 8,
+        cursor: "grab",
+        touchAction: "none"
+      },
+      children: [
+        /* @__PURE__ */ z(
+          "div",
+          {
+            "data-testid": `${u}-content`,
+            style: {
+              position: "absolute",
+              left: 0,
+              top: 0,
+              transformOrigin: "0 0",
+              transform: `translate(${v.x}px, ${v.y}px) scale(${v.scale})`
+            },
+            children: r
+          }
+        ),
+        d && /* @__PURE__ */ $(
+          "div",
+          {
+            "data-testid": `${u}-controls`,
+            style: {
+              position: "absolute",
+              right: 12,
+              bottom: 12,
+              display: "flex",
+              flexDirection: "column",
+              gap: 6
+            },
+            children: [
+              /* @__PURE__ */ z("div", { style: x, role: "button", "aria-label": "Zoom in", onClick: () => k(s), children: "+" }),
+              /* @__PURE__ */ z("div", { style: x, role: "button", "aria-label": "Zoom out", onClick: () => k(1 / s), children: "−" }),
+              /* @__PURE__ */ z(
+                "div",
+                {
+                  style: { ...x, fontSize: 12, lineHeight: "30px" },
+                  role: "button",
+                  "aria-label": "Reset view",
+                  onClick: () => S(p()),
+                  children: "⤢"
+                }
+              ),
+              /* @__PURE__ */ z(
+                "div",
+                {
+                  "data-testid": `${u}-zoom-readout`,
+                  style: { ...x, fontSize: 11, cursor: "default" },
+                  children: Math.round(pe(v.scale, i, l) * 100)
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}, zn = [
   {
     id: "regular-after-double",
     name: "Regular after double",
@@ -1151,7 +1546,7 @@ const go = [
     ],
     layoutStyles: ["linear", "offset"]
   }
-], ho = [
+], In = [
   {
     id: "single-foot",
     name: "Single foot",
@@ -1259,7 +1654,7 @@ const go = [
     },
     layoutStyles: ["linear", "offset"]
   }
-], G = {
+], ie = {
   maxPips: 12,
   engineValue: 12,
   allowConsecutiveDoubles: !1,
@@ -1271,7 +1666,7 @@ const go = [
     sideToeAngles: [-45, 45]
   }
 };
-function Ge(e) {
+function $t(e) {
   switch (e.doubleObligation) {
     case "chicken-foot":
       return Math.max(1, e.chickenFoot.toeCount);
@@ -1281,89 +1676,89 @@ function Ge(e) {
       return 0;
   }
 }
-function Ke(e) {
+function Et(e) {
   return e.doubleObligation === "chicken-foot" ? Math.max(0, e.chickenFoot.toeCount - 1) : 0;
 }
-function bo(e = {}) {
-  const o = e.maxPips ?? G.maxPips;
+function Pn(e = {}) {
+  const t = e.maxPips ?? ie.maxPips;
   return {
-    ...G,
+    ...ie,
     ...e,
-    maxPips: o,
-    engineValue: e.engineValue ?? o,
+    maxPips: t,
+    engineValue: e.engineValue ?? t,
     chickenFoot: {
-      ...G.chickenFoot,
+      ...ie.chickenFoot,
       ...e.chickenFoot ?? {}
     }
   };
 }
-function Je(e, o) {
-  let t = e;
-  for (const n of o)
-    if (t = t?.feet?.[n.doubleIndex]?.[n.toeIndex], !t) return;
-  return t;
+function At(e, t) {
+  let o = e;
+  for (const n of t)
+    if (o = o?.feet?.[n.doubleIndex]?.[n.toeIndex], !o) return;
+  return o;
 }
-function U(e, o, t) {
-  if (t(e, o), !!e.feet)
+function ne(e, t, o) {
+  if (o(e, t), !!e.feet)
     for (const n of Object.keys(e.feet)) {
       const r = Number(n);
-      e.feet[r].forEach((l, i) => {
-        U(l, [...o, { doubleIndex: r, toeIndex: i }], t);
+      e.feet[r].forEach((i, l) => {
+        ne(i, [...t, { doubleIndex: r, toeIndex: l }], o);
       });
     }
 }
-function Qe(e) {
-  const o = [];
-  return U(e, [], (t, n) => {
-    t.dominoes.forEach((r, l) => {
+function Ot(e) {
+  const t = [];
+  return ne(e, [], (o, n) => {
+    o.dominoes.forEach((r, i) => {
       if (r.value1 !== r.value2) return;
-      const i = l < t.dominoes.length - 1, s = t.feet?.[l]?.length ?? 0;
-      o.push({
+      const l = i < o.dominoes.length - 1, s = o.feet?.[i]?.length ?? 0;
+      t.push({
         path: n,
-        doubleIndex: l,
+        doubleIndex: i,
         value: r.value1,
-        hasCenter: i,
+        hasCenter: l,
         sideToes: s,
-        answers: (i ? 1 : 0) + s
+        answers: (l ? 1 : 0) + s
       });
     });
-  }), o;
+  }), t;
 }
-function Ze(e, o) {
-  const t = Ge(o);
-  return t <= 0 ? [] : Qe(e).filter((n) => n.answers < t);
+function Rt(e, t) {
+  const o = $t(t);
+  return o <= 0 ? [] : Ot(e).filter((n) => n.answers < o);
 }
-function He(e) {
-  const o = /* @__PURE__ */ new Set();
-  return U(e, [], (t) => {
-    for (const n of t.dominoes)
-      o.add(ce(n));
-  }), o;
+function Xe(e) {
+  const t = /* @__PURE__ */ new Set();
+  return ne(e, [], (o) => {
+    for (const n of o.dominoes)
+      t.add(B(n));
+  }), t;
 }
-function We(e, o, t) {
+function Ft(e, t, o) {
   if (e.dominoes.length === 0)
     return [
       {
         path: [],
         attach: "run-tail",
-        value: o,
+        value: t,
         attachToDouble: !0,
         // a train starts off the engine double
         obligation: !1
       }
     ];
-  const n = Ze(e, t);
-  if (t.doubleObligation !== "none" && n.length > 0) {
-    const l = Ke(t), i = [];
+  const n = Rt(e, o);
+  if (o.doubleObligation !== "none" && n.length > 0) {
+    const i = Et(o), l = [];
     for (const s of n) {
-      const a = Je(e, s.path);
-      a && (!s.hasCenter && s.doubleIndex === a.dominoes.length - 1 && i.push({
+      const a = At(e, s.path);
+      a && (!s.hasCenter && s.doubleIndex === a.dominoes.length - 1 && l.push({
         path: s.path,
         attach: "run-tail",
         value: s.value,
         attachToDouble: !0,
         obligation: !0
-      }), s.sideToes < l && i.push({
+      }), s.sideToes < i && l.push({
         path: s.path,
         attach: "side-toe",
         value: s.value,
@@ -1373,109 +1768,431 @@ function We(e, o, t) {
         obligation: !0
       }));
     }
-    return i;
+    return l;
   }
   const r = [];
-  return U(e, [], (l, i) => {
-    const s = l.dominoes[l.dominoes.length - 1];
+  return ne(e, [], (i, l) => {
+    const s = i.dominoes[i.dominoes.length - 1];
     s && r.push({
-      path: i,
+      path: l,
       attach: "run-tail",
       value: s.value2,
-      attachToDouble: de(s),
+      attachToDouble: Re(s),
       obligation: !1
     });
   }), r;
 }
-function xe(e, o, t, n) {
-  const r = [], l = fe(e, o.value);
-  return n.requireSequential && !l && r.push("value-mismatch"), n.requireUniqueTiles && t.has(ce(e)) && r.push("duplicate-tile"), !n.allowConsecutiveDoubles && o.attachToDouble && de(e) && r.push("consecutive-doubles"), { legal: r.length === 0, violations: r };
+function _e(e, t, o, n) {
+  const r = [], i = de(e, t.value);
+  return n.requireSequential && !i && r.push("value-mismatch"), n.requireUniqueTiles && o.has(B(e)) && r.push("duplicate-tile"), !n.allowConsecutiveDoubles && t.attachToDouble && Re(e) && r.push("consecutive-doubles"), { legal: r.length === 0, violations: r };
 }
-function wo(e, o, t, n, r) {
-  const l = We(e, o, r), i = [];
-  for (const s of l)
-    for (const a of t)
-      xe(a, s, n, r).legal && i.push({ end: s, tile: a });
-  return i;
+function Nt(e, t, o, n, r) {
+  const i = Ft(e, t, r), l = [];
+  for (const s of i)
+    for (const a of o)
+      _e(a, s, n, r).legal && l.push({ end: s, tile: a });
+  return l;
 }
-function ge(e, o, t) {
-  if (o.length === 0)
-    return t(e);
-  const [n, ...r] = o, i = (e.feet?.[n.doubleIndex] ?? []).map(
-    (s, a) => a === n.toeIndex ? ge(s, r, t) : s
+function Le(e, t, o) {
+  if (t.length === 0)
+    return o(e);
+  const [n, ...r] = t, l = (e.feet?.[n.doubleIndex] ?? []).map(
+    (s, a) => a === n.toeIndex ? Le(s, r, o) : s
   );
   return {
     ...e,
-    feet: { ...e.feet, [n.doubleIndex]: i }
+    feet: { ...e.feet, [n.doubleIndex]: l }
   };
 }
-function eo(e, o, t) {
-  const n = fe(o.tile, o.end.value) ?? { ...o.tile };
-  return ge(e, o.end.path, (r) => {
-    if (o.end.attach === "run-tail")
+function Yt(e, t, o) {
+  const n = de(t.tile, t.end.value) ?? { ...t.tile };
+  return Le(e, t.end.path, (r) => {
+    if (t.end.attach === "run-tail")
       return { ...r, dominoes: [...r.dominoes, n] };
-    const l = o.end.doubleIndex ?? 0, i = o.end.toeSlot ?? r.feet?.[l]?.length ?? 0, s = r.feet?.[l] ? [...r.feet[l]] : [];
-    return s[i] = { dominoes: [n] }, {
+    const i = t.end.doubleIndex ?? 0, l = t.end.toeSlot ?? r.feet?.[i]?.length ?? 0, s = r.feet?.[i] ? [...r.feet[i]] : [];
+    return s[l] = { dominoes: [n] }, {
       ...r,
-      feet: { ...r.feet, [l]: s }
+      feet: { ...r.feet, [i]: s }
     };
   });
 }
-function So(e, o, t) {
-  const n = xe(
-    o.tile,
-    o.end,
-    He(e),
-    t
+function Tn(e, t, o) {
+  const n = _e(
+    t.tile,
+    t.end,
+    Xe(e),
+    o
+  );
+  return n.legal ? { ok: !0, board: Yt(e, t), violations: [] } : { ok: !1, board: e, violations: n.violations };
+}
+function X(e) {
+  return e.kind === "play";
+}
+function Xt(e) {
+  const t = [];
+  return e.trains.forEach((o, n) => {
+    (o.playerId === e.selfPlayerId || o.isPublic) && t.push(n);
+  }), t;
+}
+function Ve(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const o of e)
+    for (const n of Xe(o))
+      t.add(n);
+  return t;
+}
+function _t(e) {
+  const t = Ve(e.trains), o = [];
+  for (const n of Xt(e)) {
+    const r = e.trains[n], i = Nt(
+      r,
+      e.engineValue,
+      e.hand,
+      t,
+      e.rules
+    );
+    for (const l of i)
+      o.push({ kind: "play", trainIndex: n, move: l });
+  }
+  return o;
+}
+function Lt(e = {}) {
+  return (t) => {
+    const o = _t(t), n = [...o];
+    return (t.drawPileSize ?? Number.POSITIVE_INFINITY) > 0 && !t.turnDrawUsed && (o.length === 0 || e.allowOptionalDraw) && n.push({ kind: "draw" }), n.length === 0 && n.push({ kind: "pass" }), n;
+  };
+}
+const Vt = Lt(), N = {
+  preferPlay: "prefer-play",
+  dumpPips: "dump-pips",
+  doublesEarly: "play-doubles-early",
+  ownTrain: "own-train",
+  obligationRelief: "obligation-relief",
+  handFlexibility: "hand-flexibility",
+  defensivePublic: "defensive-public"
+};
+function Be(e) {
+  const t = de(e.move.tile, e.move.end.value);
+  return t ? t.value2 : e.move.tile.value2;
+}
+const Bt = {
+  id: N.preferPlay,
+  score(e) {
+    return e.kind === "play" ? 100 : e.kind === "draw" ? 0 : -50;
+  }
+}, Ut = {
+  id: N.dumpPips,
+  score(e) {
+    if (!X(e)) return 0;
+    const t = e.move.tile;
+    return t.value1 + t.value2;
+  }
+}, jt = {
+  id: N.doublesEarly,
+  score(e, t) {
+    if (!X(e)) return 0;
+    const o = e.move.tile;
+    return o.value1 !== o.value2 ? 0 : Math.min(t.obs.hand.length, 12);
+  }
+}, Gt = {
+  id: N.ownTrain,
+  score(e, t) {
+    if (!X(e)) return 0;
+    const o = t.obs.trains[e.trainIndex];
+    return o && o.playerId === t.obs.selfPlayerId ? 8 : 0;
+  }
+}, qt = {
+  id: N.obligationRelief,
+  score(e) {
+    return X(e) && e.move.end.obligation ? 10 : 0;
+  }
+}, Kt = {
+  id: N.handFlexibility,
+  score(e, t) {
+    if (!X(e)) return 0;
+    const o = Be(e), n = B(e.move.tile);
+    let r = !1, i = 0;
+    for (const l of t.obs.hand) {
+      if (!r && B(l) === n) {
+        r = !0;
+        continue;
+      }
+      Fe(l, o) && i++;
+    }
+    return i * 3;
+  }
+}, Ht = {
+  id: N.defensivePublic,
+  score(e, t) {
+    if (!X(e)) return 0;
+    const o = t.obs.trains[e.trainIndex];
+    if (!o || o.playerId === t.obs.selfPlayerId) return 0;
+    const n = Be(e);
+    let r = 0;
+    for (const i of t.unseen)
+      Fe(i, n) && r++;
+    return -r;
+  }
+}, Zt = [
+  Bt,
+  Ut,
+  jt,
+  Gt,
+  qt,
+  Kt,
+  Ht
+], w = N, Jt = {
+  beginner: {
+    id: "beginner",
+    temperature: 2.5,
+    blunderRate: 0.25,
+    lookaheadDepth: 0,
+    enabled: /* @__PURE__ */ new Set([w.preferPlay, w.dumpPips]),
+    weights: {
+      [w.preferPlay]: 1,
+      [w.dumpPips]: 0.2
+    }
+  },
+  intermediate: {
+    id: "intermediate",
+    temperature: 0.6,
+    blunderRate: 0.05,
+    lookaheadDepth: 0,
+    enabled: /* @__PURE__ */ new Set([w.preferPlay, w.dumpPips, w.doublesEarly, w.ownTrain]),
+    weights: {
+      [w.preferPlay]: 1,
+      [w.dumpPips]: 1,
+      [w.doublesEarly]: 1,
+      [w.ownTrain]: 1
+    }
+  },
+  advanced: {
+    id: "advanced",
+    temperature: 0.15,
+    blunderRate: 0,
+    lookaheadDepth: 0,
+    enabled: /* @__PURE__ */ new Set([
+      w.preferPlay,
+      w.dumpPips,
+      w.doublesEarly,
+      w.ownTrain,
+      w.obligationRelief,
+      w.handFlexibility,
+      w.defensivePublic
+    ]),
+    weights: {
+      [w.preferPlay]: 1,
+      [w.dumpPips]: 1.2,
+      [w.doublesEarly]: 1.5,
+      [w.ownTrain]: 1,
+      [w.obligationRelief]: 1.5,
+      [w.handFlexibility]: 1,
+      [w.defensivePublic]: 1.5
+    }
+  }
+};
+function Mn(e) {
+  return Jt[e];
+}
+function Qt(e, t, o, n) {
+  let r = 0;
+  for (const i of n.enabled) {
+    const l = o.get(i);
+    if (!l) continue;
+    const s = n.weights[i] ?? 1;
+    r += s * l.score(e, t);
+  }
+  return r;
+}
+function Wt(e, t) {
+  let o = Number.NEGATIVE_INFINITY, n = [];
+  return e.forEach((r, i) => {
+    r > o ? (o = r, n = [i]) : r === o && n.push(i);
+  }), n[Math.floor(t() * n.length)];
+}
+function en(e, t, o) {
+  const n = Math.max(...e), r = e.map((s) => Math.exp((s - n) / t)), i = r.reduce((s, a) => s + a, 0);
+  let l = o() * i;
+  for (let s = 0; s < r.length; s++)
+    if (l -= r[s], l <= 0) return s;
+  return r.length - 1;
+}
+function tn(e, t, o) {
+  return e.length <= 1 ? 0 : t.temperature <= 0 ? Wt(e, o) : en(e, t.temperature, o);
+}
+function nn(e) {
+  const { skill: t, generateCandidates: o, buildContext: n, fallback: r } = e, i = e.rng ?? Math.random, l = new Map(e.heuristics.map((s) => [s.id, s]));
+  return {
+    decide(s) {
+      const a = o(s);
+      if (a.length === 0) return r(s);
+      if (a.length === 1) return a[0];
+      if (t.blunderRate > 0 && i() < t.blunderRate)
+        return a[Math.floor(i() * a.length)];
+      const c = n(s, a), d = a.map(
+        (u) => Qt(u, c, l, t)
+      );
+      return a[tn(d, t, i)];
+    }
+  };
+}
+function on(e, t, o) {
+  const n = Ve(e.trains), r = new Set(n);
+  for (const l of e.hand)
+    r.add(B(l));
+  const i = wt(e.rules.maxPips).filter(
+    (l) => !r.has(B(l))
   );
-  return n.legal ? { ok: !0, board: eo(e, o), violations: [] } : { ok: !1, board: e, violations: n.violations };
+  return {
+    obs: e,
+    playedKeys: n,
+    candidates: t,
+    playCandidates: t.filter(X),
+    unseen: i,
+    rng: o
+  };
+}
+function kn(e) {
+  const t = e.heuristics ?? Zt, o = e.generateCandidates ?? Vt, n = e.rng ?? Math.random;
+  return nn({
+    skill: e.skill,
+    heuristics: t,
+    generateCandidates: o,
+    buildContext: (r, i) => on(r, i, n),
+    fallback: () => ({ kind: "pass" }),
+    rng: n
+  });
+}
+function Ue(e, t, o) {
+  let n = t.legalActions(e);
+  return t.orderActions && (n = t.orderActions(e, n)), Number.isFinite(o) && n.length > o && (n = n.slice(0, o)), n;
+}
+function je(e, t, o, n, r) {
+  if (o <= 0 || t.isTerminal(e))
+    return t.evaluate(e, n);
+  const i = Ue(e, t, r);
+  if (i.length === 0)
+    return t.evaluate(e, n);
+  const l = t.currentPlayer(e) === n;
+  let s = l ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+  for (const a of i) {
+    const c = je(
+      t.applyAction(e, a),
+      t,
+      o - 1,
+      n,
+      r
+    );
+    s = l ? Math.max(s, c) : Math.min(s, c);
+  }
+  return s;
+}
+function Cn(e, t, o) {
+  const n = o.rng ?? Math.random, r = Math.max(1, o.determinizations ?? 1), i = o.maxBranch ?? Number.POSITIVE_INFINITY, l = Math.max(1, o.depth);
+  return Ue(e, t, i).map((a) => {
+    let c = 0;
+    for (let d = 0; d < r; d++) {
+      const u = t.determinize ? t.determinize(e, o.perspective, n) : e;
+      c += je(
+        t.applyAction(u, a),
+        t,
+        l - 1,
+        o.perspective,
+        i
+      );
+    }
+    return { action: a, value: c / r };
+  });
 }
 export {
-  ho as CHICKEN_FOOT_FIXTURES,
-  Ie as CHICKEN_FOOT_TOE_ANGLES,
-  X as DEFAULT_PIP_COLORS,
-  G as DEFAULT_RULES,
-  Re as DominoHub,
-  Ae as DominoTrain,
-  ie as DoubleTwelve,
-  fo as MexicanTrainGame,
-  no as PIP_COLORS,
-  Me as PIP_LAYOUTS,
-  go as TRAIN_FIXTURES,
-  eo as applyMove,
-  He as collectPlayedKeys,
-  Oe as computeTrainLayout,
+  In as CHICKEN_FOOT_FIXTURES,
+  lt as CHICKEN_FOOT_TOE_ANGLES,
+  Je as DEFAULT_DOMINO_THEME,
+  Zt as DEFAULT_HEURISTICS,
+  q as DEFAULT_PIP_COLORS,
+  ie as DEFAULT_RULES,
+  We as DefaultPip,
+  mt as DominoHub,
+  sn as DominoThemeProvider,
+  bt as DominoTrain,
+  Te as DoubleTwelve,
+  N as HEURISTIC_IDS,
+  vn as MexicanTrainGame,
+  an as PIP_COLORS,
+  nt as PIP_LAYOUTS,
+  Jt as SKILL_PRESETS,
+  zn as TRAIN_FIXTURES,
+  fe as TURN_DEGREES,
+  Sn as Viewport,
+  Yt as applyMove,
+  Wt as argmaxIndex,
+  Ye as buildBranchTiles,
+  tn as chooseActionIndex,
+  pe as clampScale,
+  Ve as collectAllPlayedKeys,
+  Xe as collectPlayedKeys,
+  ct as computeTrainLayout,
   ue as computeTrainTree,
-  ce as dominoKey,
-  co as dominoSetSize,
-  xe as evaluatePlacement,
-  Fe as flattenSegments,
-  uo as generateDominoSet,
-  Je as getBranchAt,
-  wo as getLegalMoves,
-  We as getOpenEnds,
-  Ce as getPipLayout,
-  lo as getPipStyle,
-  io as getTrainLayoutBounds,
-  Ze as getUnsatisfiedDoubles,
-  de as isDouble,
-  ro as mergePipColors,
-  fe as orientForConnection,
-  ao as otherEnd,
-  j as outwardPerpSign,
-  So as playMove,
-  Ge as requiredDoubleAnswers,
-  ze as resolvePipPosition,
-  le as resolvePipStyle,
-  bo as resolveRules,
-  Ke as sideToeSlots,
-  k as stepAlongTrain,
-  te as tileCorners,
-  so as tileHasValue,
-  F as tileKey,
-  ae as tilesOverlap,
-  vo as validateChickenFootChain,
-  po as validateTrainLayout,
-  xo as validateTrainTree
+  kn as createAiPlayer,
+  Lt as createCandidateGenerator,
+  nn as createPolicyPlayer,
+  mn as cycleBendAt,
+  Vt as defaultCandidateGenerator,
+  B as dominoKey,
+  gn as dominoSetSize,
+  _e as evaluatePlacement,
+  Ct as fitToBounds,
+  Ee as flattenSegments,
+  wt as generateDominoSet,
+  _t as generatePlayActions,
+  St as generateSampleTrains,
+  Xt as getAccessibleTrainIndices,
+  At as getBranchAt,
+  Nt as getLegalMoves,
+  Ft as getOpenEnds,
+  ot as getPipLayout,
+  cn as getPipStyle,
+  Mn as getSkillProfile,
+  dn as getTrainLayoutBounds,
+  Rt as getUnsatisfiedDoubles,
+  at as headingAtIndex,
+  yt as hubTrainStartDistance,
+  Re as isDouble,
+  X as isPlayAction,
+  $e as layoutSelfIntersects,
+  De as layoutsCollide,
+  bn as linearDefaultSide,
+  ze as mergeDominoTheme,
+  un as mergePipColors,
+  Ce as normalizeBends,
+  xn as offsetDefaultSide,
+  Ne as oppositeSide,
+  de as orientForConnection,
+  hn as otherEnd,
+  K as outwardPerpSign,
+  Tn as playMove,
+  $t as requiredDoubleAnswers,
+  yn as resolveBend,
+  tt as resolvePipPosition,
+  Pe as resolvePipStyle,
+  Pn as resolveRules,
+  Qt as scoreWithHeuristics,
+  wn as screenToContent,
+  Cn as searchActionValues,
+  se as sideToTurn,
+  Et as sideToeSlots,
+  en as softmaxIndex,
+  A as stepAlongTrain,
+  Qe as themeDataAttributes,
+  be as tileCorners,
+  Fe as tileHasValue,
+  V as tileKey,
+  ee as tilesOverlap,
+  Ie as useDominoTheme,
+  vt as validateChickenFootChain,
+  fn as validateTrainLayout,
+  pn as validateTrainTree,
+  Q as withBendAt,
+  me as zoomAt
 };
 //# sourceMappingURL=index.js.map