doubletwelve 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,39 +1,39 @@
-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 = {
+import { jsx as M, Fragment as xe, jsxs as D } from "react/jsx-runtime";
+import { useEffect as ne, useMemo as Ye, useState as B, useRef as ce, useCallback as Re } from "react";
+const Ae = {
   "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];
+function Fe(e) {
+  const t = Ae[e.gridSize];
   return {
-    top: e.top ?? `${o.rows[e.row]}%`,
-    left: e.left ?? `${o.cols[e.col]}%`,
-    width: o.size,
-    height: o.size
+    top: e.top ?? `${t.rows[e.row]}%`,
+    left: e.left ?? `${t.cols[e.col]}%`,
+    width: t.size,
+    height: t.size
   };
 }
-const $e = ({
+const Le = ({
   row: e,
-  col: o,
-  gridSize: t,
-  color: n,
+  col: t,
+  gridSize: n,
+  color: o,
   hollow: r,
-  top: l,
-  left: i
+  top: i,
+  left: l
 }) => {
-  const s = ze({ row: e, col: o, gridSize: t, top: l, left: i });
-  return /* @__PURE__ */ b(
+  const s = Fe({ row: e, col: t, gridSize: n, top: i, left: l });
+  return /* @__PURE__ */ M(
     "div",
     {
       "data-testid": "pip",
       "data-row": e,
-      "data-col": o,
-      "data-grid": t,
+      "data-col": t,
+      "data-grid": n,
       style: {
         position: "absolute",
-        backgroundColor: r ? "transparent" : n,
+        backgroundColor: r ? "transparent" : o,
         border: r ? "2px solid #888" : void 0,
         borderRadius: "50%",
         transform: "translate(-50%, -50%)",
@@ -42,7 +42,7 @@ const $e = ({
       }
     }
   );
-}, Me = {
+}, _e = {
   0: [],
   1: [{ row: 1, col: 1, gridSize: "3x3" }],
   2: [
@@ -145,10 +145,10 @@ const $e = ({
     { row: 3, col: 2, gridSize: "4x3" }
   ]
 };
-function Ce(e) {
-  return Me[e] ?? [];
+function Ne(e) {
+  return _e[e] ?? [];
 }
-const X = {
+const j = {
   0: { color: "transparent" },
   1: { color: "#1a1a1a" },
   2: { color: "#8B1A1A" },
@@ -162,44 +162,44 @@ const X = {
   10: { color: "#EA580C" },
   11: { color: "#166534" },
   12: { color: "#DC2626" }
-}, no = X;
-function ro(e) {
-  return { ...X, ...e };
+}, Mt = j;
+function $t(e) {
+  return { ...j, ...e };
 }
-function le(e, o) {
-  if (o !== void 0)
-    return o[e] ?? X[e] ?? { color: "#1a1a1a" };
+function ge(e, t) {
+  if (t !== void 0)
+    return t[e] ?? j[e] ?? { color: "#1a1a1a" };
 }
-function lo(e) {
-  return le(e, X);
+function kt(e) {
+  return ge(e, j);
 }
-const ke = (e, o, t) => {
-  const n = le(e, t);
-  return n ? { color: n.color, hollow: n.hollow } : { color: o };
-}, De = ({
+const Be = (e, t, n) => {
+  const o = ge(e, n);
+  return o ? { color: o.color, hollow: o.hollow } : { color: t };
+}, je = ({
   value: e,
-  pipColor: o,
-  pipColors: t
+  pipColor: t,
+  pipColors: n
 }) => {
-  const { color: n, hollow: r } = ke(e, o, t), l = Ce(e);
-  return /* @__PURE__ */ b(re, { children: l.map((i, s) => /* @__PURE__ */ b(
-    $e,
+  const { color: o, hollow: r } = Be(e, t, n), i = Ne(e);
+  return /* @__PURE__ */ M(xe, { children: i.map((l, s) => /* @__PURE__ */ M(
+    Le,
     {
-      row: i.row,
-      col: i.col,
-      gridSize: i.gridSize,
-      color: n,
+      row: l.row,
+      col: l.col,
+      gridSize: l.gridSize,
+      color: o,
       hollow: r,
-      top: i.top,
-      left: i.left
+      top: l.top,
+      left: l.left
     },
     s
   )) });
-}, ee = ({
+}, de = ({
   value: e,
-  pipColor: o,
-  pipColors: t
-}) => /* @__PURE__ */ b(
+  pipColor: t,
+  pipColors: n
+}) => /* @__PURE__ */ M(
   "div",
   {
     style: {
@@ -209,26 +209,26 @@ const ke = (e, o, t) => {
       padding: "0",
       overflow: "hidden"
     },
-    children: /* @__PURE__ */ b(De, { value: e, pipColor: o, pipColors: t })
+    children: /* @__PURE__ */ M(je, { value: e, pipColor: t, pipColors: n })
   }
-), ie = ({
+), ve = ({
   value1: e = 0,
-  value2: o = 0,
-  width: t = 100,
-  height: n = 200,
+  value2: t = 0,
+  width: n = 100,
+  height: o = 200,
   backgroundColor: r = "white",
-  pipColor: l = "black",
-  pipColors: i,
+  pipColor: i = "black",
+  pipColors: l,
   borderColor: s = "black",
   rotation: a = 0
 }) => {
-  const u = Math.min(Math.max(e, 0), 12), f = Math.min(Math.max(o, 0), 12);
-  return /* @__PURE__ */ T(
+  const c = Math.min(Math.max(e, 0), 12), d = Math.min(Math.max(t, 0), 12);
+  return /* @__PURE__ */ D(
     "div",
     {
       style: {
-        width: `${t}px`,
-        height: `${n}px`,
+        width: `${n}px`,
+        height: `${o}px`,
         backgroundColor: r,
         borderColor: s,
         borderWidth: "1px",
@@ -242,7 +242,7 @@ const ke = (e, o, t) => {
         overflow: "hidden"
       },
       children: [
-        /* @__PURE__ */ b(
+        /* @__PURE__ */ M(
           "div",
           {
             style: {
@@ -252,345 +252,622 @@ const ke = (e, o, t) => {
               borderBottomStyle: "solid",
               borderBottomColor: s
             },
-            children: /* @__PURE__ */ b(ee, { value: u, pipColor: l, pipColors: i })
+            children: /* @__PURE__ */ M(de, { value: c, pipColor: i, pipColors: l })
           }
         ),
-        /* @__PURE__ */ b(
+        /* @__PURE__ */ M(
           "div",
           {
             style: {
               flex: 1,
               position: "relative"
             },
-            children: /* @__PURE__ */ b(ee, { value: f, pipColor: l, pipColors: i })
+            children: /* @__PURE__ */ M(de, { value: d, pipColor: i, pipColors: l })
           }
         )
       ]
     }
   );
-}, D = 60, I = 120, Ie = [-45, 45];
-function oe(e, o = D, t = I) {
-  return e ? o / 2 : t / 2;
+}, T = 60, I = 120, Ue = [-45, 45];
+function Z(e, t = T, n = I) {
+  return e ? t / 2 : n / 2;
 }
-function k(e, o, t = D, n = I) {
-  return oe(e, t, n) + oe(o, t, n);
+function O(e, t, n = T, o = I) {
+  return Z(e, n, o) + Z(t, n, o);
 }
-function _(e) {
-  const o = e * Math.PI / 180;
+function R(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 F(e) {
+  const { dirX: t, dirY: n } = R(e);
+  return { perpX: -n, perpY: t };
 }
-function Te(e, o) {
+function Ve(e) {
   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 });
+    const o = t[n], r = t[n - 1].value2;
+    !(o.value1 === o.value2) && o.value1 !== r && o.value2 === r && (t[n] = { value1: o.value2, value2: o.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 U(e) {
+  const { dirX: t, dirY: n } = R(e);
+  return Math.abs(t) >= Math.abs(n) ? t >= 0 ? 1 : -1 : n >= 0 ? 1 : -1;
 }
-function se(e, o) {
-  return e === 0 ? o : e === o ? -o : o;
+function be(e, t) {
+  return e === 0 ? t : e === t ? -t : t;
 }
-function Oe({
-  startX: e,
-  startY: o,
-  angle: t,
-  dominoes: n,
+function ye({
+  orientedDominoes: e,
+  startX: t,
+  startY: n,
+  angle: o,
   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 } = R(o), { perpX: p, perpY: b } = F(o), m = r === "offset" && c != null, w = [];
+  let z = t + u * s, v = n + f * s, k = 0, x = 0;
+  const S = i / 2, C = (g) => {
+    const h = (g - k) * S;
+    z += p * h, v += b * h, k = g;
   };
-  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 g = 0; g < e.length; g++) {
+    const h = e[g], y = h.value1 === h.value2, $ = g > 0 && e[g - 1].value1 === e[g - 1].value2;
+    r === "linear" ? g > 0 && (y ? (z += u * O($, !0, i, l), v += f * O($, !0, i, l)) : $ ? (z += u * O(!0, !1, i, l), v += f * O(!0, !1, i, l)) : (z += u * l, v += f * l)) : y ? g > 0 && (z += u * O($, !0, i, l), v += f * O($, !0, i, l)) : (g === 0 ? x = a : $ ? (z += u * O(!0, !1, i, l), v += f * O(!0, !1, i, l)) : (z += u * (l / 2), v += f * (l / 2), x = be(x, a)), C(x)), w.push(k), d.push({
+      x: z,
+      y: v,
+      rotation: y ? o + 180 : o - 90,
+      isDouble: y,
+      value1: h.value1,
+      value2: h.value2
     });
   }
-  if (z && u != null) {
-    const g = -$[u] * O;
+  if (m && c != null) {
+    const g = -w[c] * S;
     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
+      for (let h = 0; h < d.length; h++)
+        d[h] = {
+          ...d[h],
+          x: d[h].x + p * g,
+          y: d[h].y + b * g
         };
   }
-  return f;
+  return d;
+}
+function we(e, t) {
+  if (!e || e.length === 0) return [];
+  const n = /* @__PURE__ */ new Map();
+  for (const o of e)
+    Number.isInteger(o.index) && (o.index <= 0 || o.index >= t || n.set(o.index, o.turn));
+  return [...n.entries()].map(([o, r]) => ({ index: o, turn: r })).sort((o, r) => o.index - r.index);
+}
+function Ge(e, t, n, o = 1 / 0) {
+  const r = we(t, Number.isFinite(o) ? o : n + 1);
+  let i = e;
+  for (const l of r)
+    if (l.index <= n) i += l.turn;
+    else break;
+  return i;
+}
+function qe(e, t, n, o) {
+  const { startX: r, startY: i, angle: l, layoutStyle: s, dominoWidth: a, dominoHeight: c, leadGap: d, outwardSign: u } = t, f = [0, ...n.map((v) => v.index), e.length], p = [];
+  let b = l, m = r, w = i, z = d;
+  for (let v = 0; v < f.length - 1; v++) {
+    const k = e.slice(f[v], f[v + 1]);
+    if (k.length === 0) continue;
+    const x = v === 0 && o != null && o < f[1] ? o : void 0, S = ye({
+      orientedDominoes: k,
+      startX: m,
+      startY: w,
+      angle: b,
+      layoutStyle: s,
+      dominoWidth: a,
+      dominoHeight: c,
+      leadGap: z,
+      outwardSign: u,
+      hubIndex: x
+    });
+    if (p.push(...S), v >= f.length - 2) break;
+    const g = S[S.length - 1], h = R(b), y = Z(g.isDouble, a, c);
+    b += n[v].turn;
+    const $ = e[f[v + 1]], E = $.value1 === $.value2, A = Z(E, a, c), _ = R(b), N = F(b), P = a / 2, W = g.x + h.dirX * (y - P) + _.dirX * (A + P), V = g.y + h.dirY * (y - P) + _.dirY * (A + P), X = s === "offset" && !E, G = X ? N.perpX * P * u : 0, q = X ? N.perpY * P * u : 0;
+    m = W - G, w = V - q, z = 0;
+  }
+  return p;
 }
-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 Ke({
+  startX: e,
+  startY: t,
+  angle: n,
+  dominoes: o,
+  layoutStyle: r,
+  dominoWidth: i = T,
+  dominoHeight: l = I,
+  leadGap: s = l * 0.3,
+  outwardSign: a,
+  hubIndex: c,
+  bends: d
+}) {
+  const u = Ve([...o]), f = a ?? U(n), p = we(d, u.length);
+  return p.length > 0 ? qe(
+    u,
+    {
+      startX: e,
+      startY: t,
+      angle: n,
+      layoutStyle: r,
+      dominoWidth: i,
+      dominoHeight: l,
+      leadGap: s,
+      outwardSign: f
+    },
+    p,
+    c
+  ) : ye({
+    orientedDominoes: u,
+    startX: e,
+    startY: t,
+    angle: n,
+    layoutStyle: r,
+    dominoWidth: i,
+    dominoHeight: l,
+    leadGap: s,
+    outwardSign: f,
+    hubIndex: c
+  });
+}
+function fe(e, t = T, n = I) {
+  const o = e.rotation * Math.PI / 180, r = Math.cos(o), i = Math.sin(o), l = t / 2, s = n / 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 Ze(e, t, n) {
+  let o = 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;
-    n = Math.min(n, a), r = Math.max(r, a);
+    const a = s.x * n.x + s.y * n.y;
+    o = Math.min(o, 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 * n.x + s.y * n.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(o, 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 J(e, t, n = 1, o = T, r = I) {
+  const i = fe(e, o, r), l = fe(t, o, 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, b = { x: -f / p, y: u / p };
+      if (Ze(i, l, b) <= n)
         return !1;
     }
   return !0;
 }
-function Ee(e, o, t, n) {
-  return o.some(
-    (r) => ae(e, r, 1, t, n)
+function Je(e, t, n, o) {
+  return t.some(
+    (r) => J(e, r, 1, n, o)
   );
 }
-const P = D / 4, ne = 24;
-function ue({
+function Se(e, t, n = 1, o = T, r = I) {
+  return e.some(
+    (i) => t.some(
+      (l) => J(i, l, n, o, r)
+    )
+  );
+}
+function me(e, t = 1, n = T, o = I) {
+  for (let r = 0; r < e.length; r++)
+    for (let i = r + 1; i < e.length; i++)
+      if (J(e[r], e[i], t, n, o))
+        return !0;
+  return !1;
+}
+const Y = T / 4, pe = 24;
+function re({
   startX: e,
-  startY: o,
-  angle: t,
-  branch: n,
+  startY: t,
+  angle: n,
+  branch: o,
   layoutStyle: r,
-  dominoWidth: l = D,
-  dominoHeight: i = I,
+  dominoWidth: i = T,
+  dominoHeight: l = I,
   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,
-    dominoes: n.dominoes,
+  const b = d ?? U(n), m = o.feet ? Object.keys(o.feet).map(Number).filter((x) => {
+    const S = o.dominoes[x];
+    return S && S.value1 === S.value2;
+  }).sort((x, S) => x - S)[0] : void 0, w = (x, S) => Ke({
+    startX: x,
+    startY: S,
+    angle: n,
+    dominoes: o.dominoes,
     layoutStyle: r,
-    dominoWidth: l,
-    dominoHeight: i,
+    dominoWidth: i,
+    dominoHeight: l,
     leadGap: s,
-    outwardSign: y,
-    hubIndex: x
+    outwardSign: b,
+    hubIndex: m,
+    bends: o.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
+    e + (f?.x ?? 0) * Y * p,
+    t + (f?.y ?? 0) * Y * p
+  ), v = c && f ? {
+    x: c.x + f.x * Y * p,
+    y: c.y + f.y * Y * p
+  } : c;
+  if (f && u.length > 0)
+    for (let x = p; x <= pe; x++) {
+      const S = e + f.x * Y * x, C = t + f.y * Y * x, g = w(S, C);
+      if (!g.some(
+        (y) => Je(y, u, i, l)
+      ) || x === pe) {
+        z = g, v = c && {
+          x: c.x + f.x * Y * x,
+          y: c.y + f.y * Y * x
         };
         break;
       }
     }
-  c.push(...z);
-  const m = [
+  u.push(...z);
+  const k = [
     {
-      angle: t,
+      angle: n,
       depth: a,
       layoutStyle: r,
-      outwardSign: y,
-      dominoes: n.dominoes,
+      outwardSign: b,
+      dominoes: o.dominoes,
       layout: z,
-      anchor: $
+      anchor: v
     }
   ];
-  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 }
-            })
-          );
-        }
+  if (o.feet) {
+    const x = i / 2, S = l / 2;
+    for (const C of Object.keys(o.feet)) {
+      const g = Number(C), h = z[g], y = o.feet[g];
+      if (!h || !h.isDouble || !y)
+        continue;
+      const $ = Ge(
+        n,
+        o.bends,
+        g,
+        o.dominoes.length
+      ), { dirX: E, dirY: A } = R($), { perpX: _, perpY: N } = F($);
+      for (let P = 0; P < y.length; P++) {
+        const W = y[P], V = Ue[P] ?? 0, X = Math.sign(V), G = $ + V, q = F(G), ee = -X, Ee = h.x + E * (i / 2) + _ * (l / 2) * X, Xe = h.y + A * (i / 2) + N * (l / 2) * X, ae = Ee - q.perpX * ee * x, ue = Xe - q.perpY * ee * x;
+        k.push(
+          ...re({
+            startX: ae,
+            startY: ue,
+            angle: G,
+            branch: W,
+            // Toes inherit the main style so they zigzag in offset mode.
+            layoutStyle: r,
+            dominoWidth: i,
+            dominoHeight: l,
+            leadGap: S,
+            outwardSign: ee,
+            depth: a + 1,
+            anchor: { x: ae, y: ue },
+            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: _ * X, y: N * X }
+          })
+        );
+      }
     }
   }
-  return m;
+  return k;
 }
-function Fe(e) {
-  return e.flatMap((o) => o.layout);
+function ze(e) {
+  return e.flatMap((t) => t.layout);
 }
-function io(e, o = 24, t = D, n = I) {
-  const r = Math.hypot(t, n) / 2;
+function Ct(e, t = 24, n = T, o = I) {
+  const r = Math.hypot(n, o) / 2;
   if (e.length === 0)
     return {
-      width: o * 2 + t,
-      height: o * 2 + n,
-      offsetX: o,
-      offsetY: o
+      width: t * 2 + n,
+      height: t * 2 + o,
+      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 Ae = ({
+const Q = 1;
+function Me(e, t, n) {
+  const { dirX: o, dirY: r } = R(n);
+  return e * o + t * r;
+}
+function Qe(e, t, n) {
+  const { perpX: o, perpY: r } = F(n);
+  return e * o + t * r;
+}
+function ie(e) {
+  const t = [];
+  for (let n = 1; n < e.length; n++)
+    e[n].value1 !== e[n - 1].value2 && t.push({
+      code: "chain-break",
+      message: `Domino ${n} does not connect to domino ${n - 1}`,
+      index: n
+    });
+  for (let n = 1; n < e.length; n++) {
+    const o = e[n - 1].value1 === e[n - 1].value2, r = e[n].value1 === e[n].value2;
+    o && r && t.push({
+      code: "consecutive-doubles",
+      message: `Consecutive doubles at index ${n - 1} and ${n}`,
+      index: n
+    });
+  }
+  return { valid: t.length === 0, issues: t };
+}
+function $e(e, t, n, o = T, r = I) {
+  const i = o / 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 += O(p, f, o, r)), c = 0) : f ? u > 0 && (a += O(p, !0, o, r)) : u === 0 ? (d = n, c = d * i) : p ? a += O(!0, !1, o, r) : (a += r / 2, d = be(d, n), c = d * i), s.push({ along: a, perp: c });
+  }
+  return s;
+}
+function He(e, t, n, o = Q, r) {
+  const i = [], l = r ?? U(t), s = $e(e, n, 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 = Me(u, f, t), b = Qe(u, f, t), m = s[a].along - s[a - 1].along, w = s[a].perp - s[a - 1].perp;
+    Math.abs(p - m) > o && i.push({
+      code: "spacing-along-train",
+      message: `Along-train spacing between domino ${a - 1} and ${a} is ${p.toFixed(2)}px (expected ${m}px)`,
+      index: a
+    }), Math.abs(b - w) > o && i.push({
+      code: "spacing-perpendicular",
+      message: `Perpendicular spacing between domino ${a - 1} and ${a} is ${b.toFixed(2)}px (expected ${w}px)`,
+      index: a
+    });
+  }
+  return { valid: i.length === 0, issues: i };
+}
+function We(e, t, n, o = Q, r) {
+  const i = [], l = r ?? U(t), s = $e(e, n, 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), b = s[a].along - s[a - 1].along, m = s[a].perp - s[a - 1].perp, w = Math.hypot(b, m) * 0.9;
+    p + o < w && i.push({
+      code: "overlap",
+      message: `Domino ${a - 1} and ${a} centers are ${p.toFixed(2)}px apart (minimum ${w.toFixed(2)}px)`,
+      index: a
+    });
+  }
+  return { valid: i.length === 0, issues: i };
+}
+function Tt(e, t, n, o, r = Q, i) {
+  const l = [
+    ...ie(t).issues,
+    ...He(
+      e,
+      n,
+      o,
+      r,
+      i
+    ).issues,
+    ...We(
+      e,
+      n,
+      o,
+      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 et(e) {
+  const t = [], n = (o, r) => {
+    if (t.push(
+      ...ie(o.dominoes).issues.map((i) => ({
+        ...i,
+        message: `[${r}] ${i.message}`
+      }))
+    ), !!o.feet)
+      for (const i of Object.keys(o.feet)) {
+        const l = Number(i), s = o.dominoes[l], a = o.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}`
+          }), n(c, `${r}.${l}.${d}`);
+        });
+      }
+  };
+  return n(e, "main"), { valid: t.length === 0, issues: t };
+}
+function It(e, t = Q) {
+  const n = [];
+  e.forEach((r, i) => {
+    if (n.push(
+      ...ie(r.dominoes).issues.map((l) => ({
+        ...l,
+        message: `[segment ${i} @${r.angle}°] ${l.message}`
+      }))
+    ), r.layout.length !== r.dominoes.length && n.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 = Me(
+        l.x - r.anchor.x,
+        l.y - r.anchor.y,
+        r.angle
+      ), a = I / 2;
+      Math.abs(s - a) > t && n.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 o = e.flatMap((r) => r.layout);
+  for (let r = 0; r < o.length; r++)
+    for (let i = r + 1; i < o.length; i++)
+      J(o[r], o[i]) && n.push({
+        code: "tile-overlap",
+        message: `Tiles ${r} and ${i} overlap`,
+        index: i
+      });
+  return { valid: n.length === 0, issues: n };
+}
+const tt = (() => {
+  try {
+    return !1;
+  } catch {
+    return !1;
+  }
+})(), ot = ({
   startX: e,
-  startY: o,
-  angle: t,
-  trainData: n,
+  startY: t,
+  angle: n,
+  trainData: o,
   layoutStyle: r,
-  tableWidth: l,
-  tableHeight: i,
+  tableWidth: i,
+  tableHeight: l,
   centerX: s,
   centerY: a,
-  pipColors: u
+  pipColors: c
 }) => {
-  const f = Se(
-    () => Fe(
-      ue({
+  ne(() => {
+    if (!tt) return;
+    const u = et({
+      dominoes: o.dominoes,
+      feet: o.feet
+    });
+    u.valid || console.warn(
+      `DominoTrain: player ${o.playerId} train does not follow the rules:`,
+      u.issues.map((f) => f.message)
+    );
+  }, [o.dominoes, o.feet, o.playerId]);
+  const d = Ye(
+    () => ze(
+      re({
         startX: e,
-        startY: o,
-        angle: t,
-        branch: { dominoes: n.dominoes, feet: n.feet },
+        startY: t,
+        angle: n,
+        branch: { dominoes: o.dominoes, feet: o.feet },
         layoutStyle: r
       })
     ),
     [
       e,
-      o,
       t,
-      n.dominoes,
-      n.feet,
+      n,
+      o.dominoes,
+      o.feet,
       r,
-      l,
-      i
+      i,
+      l
     ]
   );
-  return /* @__PURE__ */ b(re, { children: f.map((c, d) => {
-    const v = n.isPublic;
-    return /* @__PURE__ */ b(
+  return /* @__PURE__ */ M(xe, { children: d.map((u, f) => {
+    const p = o.isPublic;
+    return /* @__PURE__ */ M(
       "div",
       {
         style: {
           position: "absolute",
-          left: `${c.x - D / 2}px`,
-          top: `${c.y - I / 2}px`,
+          left: `${u.x - T / 2}px`,
+          top: `${u.y - I / 2}px`,
           zIndex: 5
         },
-        children: /* @__PURE__ */ b(
-          ie,
+        children: /* @__PURE__ */ M(
+          ve,
           {
-            value1: c.value1,
-            value2: c.value2,
-            width: D,
+            value1: u.value1,
+            value2: u.value2,
+            width: T,
             height: I,
             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-${o.playerId}-${f}`
     );
   }) });
-}, Re = ({
+};
+function nt(e, t, n, o) {
+  const r = n * (o === "offset" ? 2.5 : 1.3);
+  return Math.max(t + 20, Math.ceil(r * e / (2 * Math.PI)));
+}
+const rt = ({
   playerCount: e,
-  centerX: o,
-  centerY: t,
-  radius: n,
+  centerX: t,
+  centerY: n,
+  radius: o,
   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, b = nt(d, o, f, l);
+  return /* @__PURE__ */ D("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ M(
       "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: `${n - u / 2}px`,
           backgroundColor: "#d1d5db",
           borderWidth: "3px",
           borderStyle: "solid",
@@ -602,186 +879,186 @@ const Ae = ({
           justifyContent: "center",
           alignItems: "center"
         },
-        children: /* @__PURE__ */ b("div", { style: { transform: "rotate(0deg)" }, children: /* @__PURE__ */ b(
-          ie,
+        children: /* @__PURE__ */ M("div", { style: { transform: "rotate(0deg)" }, children: /* @__PURE__ */ M(
+          ve,
           {
             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((m, w) => {
+      const z = w * 360 / d, v = z * Math.PI / 180, k = t + b * Math.cos(v), x = n + b * Math.sin(v), S = i.find((C) => C.playerId === w) || {
         dominoes: [],
-        playerId: x,
+        playerId: w,
         isPublic: !1
       };
-      return /* @__PURE__ */ b(
-        Ae,
+      return /* @__PURE__ */ M(
+        ot,
         {
-          startX: $,
-          startY: m,
-          angle: w,
-          trainData: p,
-          layoutStyle: i,
+          startX: k,
+          startY: x,
+          angle: z,
+          trainData: S,
+          layoutStyle: l,
           tableWidth: s,
           tableHeight: a,
-          centerX: o,
-          centerY: t,
-          pipColors: u
+          centerX: t,
+          centerY: n,
+          pipColors: c
         },
-        x
+        w
       );
     })
   ] });
 };
-function F(e, o) {
-  return e <= o ? `${e}:${o}` : `${o}:${e}`;
+function L(e, t) {
+  return e <= t ? `${e}:${t}` : `${t}:${e}`;
 }
-function ce(e) {
-  return F(e.value1, e.value2);
+function ke(e) {
+  return L(e.value1, e.value2);
 }
-function de(e) {
+function Ce(e) {
   return e.value1 === e.value2;
 }
-function so(e, o) {
-  return e.value1 === o || e.value2 === o;
-}
-function ao(e, o) {
-  return e.value1 === o ? e.value2 : e.value2 === o ? 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 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 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 Dt(e, t) {
+  return e.value1 === t || e.value2 === t;
+}
+function Pt(e, t) {
+  return e.value1 === t ? e.value2 : e.value2 === t ? e.value1 : null;
+}
+function Te(e, t) {
+  return e.value1 === t ? { value1: e.value1, value2: e.value2 } : e.value2 === t ? { value1: e.value2, value2: e.value1 } : null;
+}
+function Ot(e) {
+  const t = [];
+  for (let n = 0; n <= e; n++)
+    for (let o = n; o <= e; o++)
+      t.push({ value1: n, value2: o });
+  return t;
+}
+function Et(e) {
+  const t = e + 1;
+  return t * (t + 1) / 2;
+}
+function it(e, t = 12, n = {}) {
+  const o = /* @__PURE__ */ new Set([L(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 = ut(
         a,
-        u,
-        c === 0,
-        o,
-        n
+        c,
+        u === 0,
+        t,
+        o
       );
-      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;
+      o.add(L(a, f)), s.push({ value1: a, value2: f }), c = p, a = f;
     }
-    const f = t.chickenFeet ? _e(s, n) : void 0;
+    const d = n.chickenFeet ? lt(s, o) : 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 = {};
-  for (let n = 0; n < e.length; n++) {
-    if (e[n].value1 !== e[n].value2)
+function lt(e, t) {
+  const n = {};
+  for (let o = 0; o < e.length; o++) {
+    if (e[o].value1 !== e[o].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[o].value1, i = [];
+    for (let l = 0; l < 2; l++) {
+      const s = st(r, t);
+      s && i.push(s);
     }
-    l.length && (t[n] = l);
+    i.length && (n[o] = i);
   }
-  return Object.keys(t).length ? t : void 0;
+  return Object.keys(n).length ? n : void 0;
 }
-function Le(e, o) {
-  const t = 1 + Math.floor(Math.random() * 2), n = [];
+function st(e, t) {
+  const n = 1 + Math.floor(Math.random() * 2), o = [];
   let r = e;
-  for (let l = 0; l < t; l++) {
-    const i = Ye(r, o);
-    if (i === null)
+  for (let i = 0; i < n; i++) {
+    const l = at(r, t);
+    if (l === null)
       break;
-    o.add(F(r, i)), n.push({ value1: r, value2: i }), r = i;
+    t.add(L(r, l)), o.push({ value1: r, value2: l }), r = l;
   }
-  return n.length ? { dominoes: n } : null;
+  return o.length ? { dominoes: o } : null;
 }
-function Ye(e, o) {
-  const t = [];
-  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)];
+function at(e, t) {
+  const n = [];
+  for (let o = 0; o < 13; o++)
+    o !== e && (t.has(L(e, o)) || n.push(o));
+  return n.length === 0 ? null : n[Math.floor(Math.random() * n.length)];
 }
-function Ne(e, o, t, n, r) {
-  const l = Array.from({ length: 13 }, (i, s) => s).filter(
-    (i) => je(
+function ut(e, t, n, o, r) {
+  const i = Array.from({ length: 13 }, (l, s) => s).filter(
+    (l) => ct(
       e,
-      i,
-      o,
+      l,
       t,
       n,
+      o,
       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 ct(e, t, n, o, r, i) {
+  const l = t === e;
+  return !(o && l && e === r || l && n || i.has(L(e, t)));
 }
-const Be = {
+const dt = {
   playerCount: 8,
   trains: [],
   engineValue: 12
-}, fo = ({
-  initialState: e = Be,
-  width: o = 1200,
-  height: t = 800,
-  pipColors: n,
+}, Xt = ({
+  initialState: e = dt,
+  width: t = 1200,
+  height: n = 800,
+  pipColors: o,
   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] = B(e), [s, a] = B("offset"), [c, d] = B(!1), [u, f] = B(void 0), p = o ?? u, b = r ?? f, m = p !== void 0, w = t / 2, z = n / 2, v = (x = c) => {
+    const S = it(
+      i.playerCount,
+      i.engineValue,
+      { chickenFeet: x }
     );
-    i((M) => ({
-      ...M,
-      trains: h
+    l((C) => ({
+      ...C,
+      trains: S
     }));
   };
-  ye(() => {
-    $();
+  ne(() => {
+    v();
   }, []);
-  const m = () => {
-    const p = !u;
-    f(p), $(p);
+  const k = () => {
+    const x = !c;
+    d(x), v(x);
   };
-  return /* @__PURE__ */ T(
+  return /* @__PURE__ */ D(
     "div",
     {
       style: {
-        width: `${o}px`,
-        height: `${t}px`,
+        width: `${t}px`,
+        height: `${n}px`,
         position: "relative",
         backgroundColor: "#1f8a55",
         // Classic green felt background
@@ -790,15 +1067,15 @@ const Be = {
         overflow: "hidden"
       },
       children: [
-        /* @__PURE__ */ T(
+        /* @__PURE__ */ D(
           "div",
           {
             style: { position: "absolute", top: "10px", left: "10px", zIndex: 100 },
             children: [
-              /* @__PURE__ */ b(
+              /* @__PURE__ */ M(
                 "button",
                 {
-                  onClick: () => $(),
+                  onClick: () => v(),
                   style: {
                     padding: "8px 12px",
                     backgroundColor: "#fff",
@@ -810,7 +1087,7 @@ const Be = {
                   children: "New trains"
                 }
               ),
-              /* @__PURE__ */ T(
+              /* @__PURE__ */ D(
                 "button",
                 {
                   onClick: () => a(s === "offset" ? "linear" : "offset"),
@@ -828,45 +1105,45 @@ const Be = {
                   ]
                 }
               ),
-              /* @__PURE__ */ T(
+              /* @__PURE__ */ D(
                 "button",
                 {
-                  onClick: m,
+                  onClick: k,
                   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__ */ D(
                 "button",
                 {
-                  onClick: () => y(x ? void 0 : X),
+                  onClick: () => b(m ? void 0 : j),
                   style: {
                     padding: "8px 12px",
-                    backgroundColor: x ? "#fef3c7" : "#fff",
-                    border: `1px solid ${x ? "#f59e0b" : "#ccc"}`,
+                    backgroundColor: m ? "#fef3c7" : "#fff",
+                    border: `1px solid ${m ? "#f59e0b" : "#ccc"}`,
                     borderRadius: "4px",
                     cursor: "pointer"
                   },
                   children: [
                     "Pip Colors: ",
-                    x ? "On" : "Off"
+                    m ? "On" : "Off"
                   ]
                 }
               )
             ]
           }
         ),
-        /* @__PURE__ */ T(
+        /* @__PURE__ */ D(
           "div",
           {
             style: {
@@ -880,191 +1157,270 @@ const Be = {
               fontSize: "14px"
             },
             children: [
-              /* @__PURE__ */ T("div", { children: [
+              /* @__PURE__ */ D("div", { children: [
                 "Engine: Double-",
-                l.engineValue
+                i.engineValue
               ] }),
-              /* @__PURE__ */ T("div", { children: [
+              /* @__PURE__ */ D("div", { children: [
                 "Players: ",
-                l.playerCount
+                i.playerCount
               ] })
             ]
           }
         ),
-        /* @__PURE__ */ b(
-          Re,
+        /* @__PURE__ */ M(
+          rt,
           {
-            playerCount: l.playerCount,
+            playerCount: i.playerCount,
             centerX: w,
             centerY: z,
             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: n,
+            pipColors: p
           }
         )
       ]
     }
   );
-}, B = 1;
-function pe(e, o, t) {
-  const { dirX: n, dirY: r } = _(t);
-  return e * n + o * r;
-}
-function Ue(e, o, t) {
-  const { perpX: n, perpY: r } = N(t);
-  return e * n + o * r;
-}
-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 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;
+}, le = 90;
+function oe(e, t = le) {
+  return e === "right" ? t : -t;
 }
-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 Ie(e) {
+  return e === "right" ? "left" : "right";
+}
+function Yt(e, t) {
+  return (t ?? U(e)) >= 0 ? "left" : "right";
+}
+function Rt(e, t, n) {
+  const { perpX: o, perpY: r } = F(t), i = (a, c) => {
+    let d = 1 / 0;
+    return a > 0 ? d = Math.min(d, (n.width - e.x) / a) : a < 0 && (d = Math.min(d, (0 - e.x) / a)), c > 0 ? d = Math.min(d, (n.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(o, r), s = i(-o, -r);
+  return l >= s ? "right" : "left";
+}
+function De(e, t) {
+  return ze(
+    re({
+      startX: t.startX,
+      startY: t.startY,
+      angle: t.angle,
+      branch: e,
+      layoutStyle: t.layoutStyle
+    })
+  );
+}
+function K(e, t, n) {
+  const o = (e ?? []).filter((r) => r.index !== t);
+  return n === null ? o : [...o, { index: t, turn: n }].sort((r, i) => r.index - i.index);
+}
+function At({
+  branch: e,
+  index: t,
+  build: n,
+  obstacles: o,
+  preferredSide: r,
+  degrees: i = le
+}) {
+  const l = [r, Ie(r)];
+  for (const s of l) {
+    const a = oe(s, i), c = {
+      ...e,
+      bends: K(e.bends, t, a)
+    }, d = De(c, n);
+    if (!me(d) && !Se(d, o))
+      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 Ft(e, t, n, o, r, i = le) {
+  const l = (e.bends ?? []).find((u) => u.index === t), s = oe(r, i), a = oe(Ie(r), i), c = (u) => {
+    const f = {
+      ...e,
+      bends: K(e.bends, t, u)
+    }, p = De(f, n);
+    return !me(p) && !Se(p, o);
+  };
+  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: K(e.bends, t, null), changed: !0, blocked: !1 };
+    if (c(u))
+      return { bends: K(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 se(e, t, n) {
+  return Math.min(n, 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 he(e, t, n, o, r) {
+  const i = se(e.scale * t, o, r), l = i / e.scale;
+  return {
+    scale: i,
+    x: n.x - (n.x - e.x) * l,
+    y: n.y - (n.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 ft(e, t, n, o, r) {
+  const i = Math.max(1, e.width), l = Math.max(1, e.height), s = Math.min(
+    (t.width - n * 2) / i,
+    (t.height - n * 2) / l
+  ), a = se(s, o, r);
+  return {
+    scale: a,
+    x: (t.width - i * a) / 2,
+    y: (t.height - l * a) / 2
+  };
+}
+function Lt(e, t) {
+  return {
+    x: (t.x - e.x) / e.scale,
+    y: (t.y - e.y) / e.scale
+  };
 }
-const go = [
+const pt = 3, _t = ({
+  width: e,
+  height: t,
+  contentWidth: n,
+  contentHeight: o,
+  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 = ce(null), p = Re(
+    () => ft(
+      { width: n, height: o },
+      { width: e, height: t },
+      a,
+      i,
+      l
+    ),
+    [n, o, e, t, a, i, l]
+  ), [b, m] = B(p);
+  ne(() => {
+    m(p());
+  }, [p]);
+  const w = ce(null), z = (h, y) => {
+    const $ = f.current?.getBoundingClientRect();
+    return { x: h - ($?.left ?? 0), y: y - ($?.top ?? 0) };
+  }, v = (h) => {
+    w.current = {
+      pointerX: h.clientX,
+      pointerY: h.clientY,
+      startX: b.x,
+      startY: b.y,
+      moved: !1
+    };
+  }, k = (h) => {
+    const y = w.current;
+    if (!y) return;
+    const $ = h.clientX - y.pointerX, E = h.clientY - y.pointerY;
+    !y.moved && Math.hypot($, E) < pt || (y.moved = !0, f.current?.setPointerCapture?.(h.pointerId), m((A) => ({ ...A, x: y.startX + $, y: y.startY + E })));
+  }, x = (h) => {
+    w.current?.moved && h.preventDefault(), w.current = null;
+  }, S = (h) => {
+    h.preventDefault();
+    const y = z(h.clientX, h.clientY), $ = h.deltaY < 0 ? s : 1 / s;
+    m((E) => he(E, $, y, i, l));
+  }, C = (h) => m(
+    (y) => he(y, h, { x: e / 2, y: t / 2 }, i, l)
+  ), g = {
+    width: 32,
+    height: 32,
+    fontSize: 18,
+    lineHeight: "30px",
+    textAlign: "center",
+    cursor: "pointer",
+    background: "#fff",
+    border: "1px solid #d1d5db",
+    borderRadius: 6,
+    userSelect: "none"
+  };
+  return /* @__PURE__ */ D(
+    "div",
+    {
+      ref: f,
+      "data-testid": u,
+      onPointerDown: v,
+      onPointerMove: k,
+      onPointerUp: x,
+      onPointerLeave: x,
+      onWheel: S,
+      style: {
+        position: "relative",
+        width: e,
+        height: t,
+        overflow: "hidden",
+        background: c,
+        borderRadius: 8,
+        cursor: "grab",
+        touchAction: "none"
+      },
+      children: [
+        /* @__PURE__ */ M(
+          "div",
+          {
+            "data-testid": `${u}-content`,
+            style: {
+              position: "absolute",
+              left: 0,
+              top: 0,
+              transformOrigin: "0 0",
+              transform: `translate(${b.x}px, ${b.y}px) scale(${b.scale})`
+            },
+            children: r
+          }
+        ),
+        d && /* @__PURE__ */ D(
+          "div",
+          {
+            "data-testid": `${u}-controls`,
+            style: {
+              position: "absolute",
+              right: 12,
+              bottom: 12,
+              display: "flex",
+              flexDirection: "column",
+              gap: 6
+            },
+            children: [
+              /* @__PURE__ */ M("div", { style: g, role: "button", "aria-label": "Zoom in", onClick: () => C(s), children: "+" }),
+              /* @__PURE__ */ M("div", { style: g, role: "button", "aria-label": "Zoom out", onClick: () => C(1 / s), children: "−" }),
+              /* @__PURE__ */ M(
+                "div",
+                {
+                  style: { ...g, fontSize: 12, lineHeight: "30px" },
+                  role: "button",
+                  "aria-label": "Reset view",
+                  onClick: () => m(p()),
+                  children: "⤢"
+                }
+              ),
+              /* @__PURE__ */ M(
+                "div",
+                {
+                  "data-testid": `${u}-zoom-readout`,
+                  style: { ...g, fontSize: 11, cursor: "default" },
+                  children: Math.round(se(b.scale, i, l) * 100)
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}, Nt = [
   {
     id: "regular-after-double",
     name: "Regular after double",
@@ -1151,7 +1507,7 @@ const go = [
     ],
     layoutStyles: ["linear", "offset"]
   }
-], ho = [
+], Bt = [
   {
     id: "single-foot",
     name: "Single foot",
@@ -1259,7 +1615,7 @@ const go = [
     },
     layoutStyles: ["linear", "offset"]
   }
-], G = {
+], te = {
   maxPips: 12,
   engineValue: 12,
   allowConsecutiveDoubles: !1,
@@ -1271,7 +1627,7 @@ const go = [
     sideToeAngles: [-45, 45]
   }
 };
-function Ge(e) {
+function ht(e) {
   switch (e.doubleObligation) {
     case "chicken-foot":
       return Math.max(1, e.chickenFoot.toeCount);
@@ -1281,89 +1637,89 @@ function Ge(e) {
       return 0;
   }
 }
-function Ke(e) {
+function xt(e) {
   return e.doubleObligation === "chicken-foot" ? Math.max(0, e.chickenFoot.toeCount - 1) : 0;
 }
-function bo(e = {}) {
-  const o = e.maxPips ?? G.maxPips;
+function jt(e = {}) {
+  const t = e.maxPips ?? te.maxPips;
   return {
-    ...G,
+    ...te,
     ...e,
-    maxPips: o,
-    engineValue: e.engineValue ?? o,
+    maxPips: t,
+    engineValue: e.engineValue ?? t,
     chickenFoot: {
-      ...G.chickenFoot,
+      ...te.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 gt(e, t) {
+  let n = e;
+  for (const o of t)
+    if (n = n?.feet?.[o.doubleIndex]?.[o.toeIndex], !n) return;
+  return n;
 }
-function U(e, o, t) {
-  if (t(e, o), !!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);
+function H(e, t, n) {
+  if (n(e, t), !!e.feet)
+    for (const o of Object.keys(e.feet)) {
+      const r = Number(o);
+      e.feet[r].forEach((i, l) => {
+        H(i, [...t, { doubleIndex: r, toeIndex: l }], n);
       });
     }
 }
-function Qe(e) {
-  const o = [];
-  return U(e, [], (t, n) => {
-    t.dominoes.forEach((r, l) => {
+function vt(e) {
+  const t = [];
+  return H(e, [], (n, o) => {
+    n.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({
-        path: n,
-        doubleIndex: l,
+      const l = i < n.dominoes.length - 1, s = n.feet?.[i]?.length ?? 0;
+      t.push({
+        path: o,
+        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 bt(e, t) {
+  const n = ht(t);
+  return n <= 0 ? [] : vt(e).filter((o) => o.answers < n);
 }
-function He(e) {
-  const o = /* @__PURE__ */ new Set();
-  return U(e, [], (t) => {
-    for (const n of t.dominoes)
-      o.add(ce(n));
-  }), o;
+function yt(e) {
+  const t = /* @__PURE__ */ new Set();
+  return H(e, [], (n) => {
+    for (const o of n.dominoes)
+      t.add(ke(o));
+  }), t;
 }
-function We(e, o, t) {
+function wt(e, t, n) {
   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 = [];
-    for (const s of n) {
-      const a = Je(e, s.path);
-      a && (!s.hasCenter && s.doubleIndex === a.dominoes.length - 1 && i.push({
+  const o = bt(e, n);
+  if (n.doubleObligation !== "none" && o.length > 0) {
+    const i = xt(n), l = [];
+    for (const s of o) {
+      const a = gt(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 +1729,129 @@ 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 H(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: Ce(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 Pe(e, t, n, o) {
+  const r = [], i = Te(e, t.value);
+  return o.requireSequential && !i && r.push("value-mismatch"), o.requireUniqueTiles && n.has(ke(e)) && r.push("duplicate-tile"), !o.allowConsecutiveDoubles && t.attachToDouble && Ce(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 Ut(e, t, n, o, r) {
+  const i = wt(e, t, r), l = [];
+  for (const s of i)
+    for (const a of n)
+      Pe(a, s, o, 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 Oe(e, t, n) {
+  if (t.length === 0)
+    return n(e);
+  const [o, ...r] = t, l = (e.feet?.[o.doubleIndex] ?? []).map(
+    (s, a) => a === o.toeIndex ? Oe(s, r, n) : s
   );
   return {
     ...e,
-    feet: { ...e.feet, [n.doubleIndex]: i }
+    feet: { ...e.feet, [o.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")
-      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] }, {
+function St(e, t, n) {
+  const o = Te(t.tile, t.end.value) ?? { ...t.tile };
+  return Oe(e, t.end.path, (r) => {
+    if (t.end.attach === "run-tail")
+      return { ...r, dominoes: [...r.dominoes, o] };
+    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: [o] }, {
       ...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 Vt(e, t, n) {
+  const o = Pe(
+    t.tile,
+    t.end,
+    yt(e),
+    n
   );
-  return n.legal ? { ok: !0, board: eo(e, o), violations: [] } : { ok: !1, board: e, violations: n.violations };
+  return o.legal ? { ok: !0, board: St(e, t), violations: [] } : { ok: !1, board: e, violations: o.violations };
 }
 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,
-  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
+  Bt as CHICKEN_FOOT_FIXTURES,
+  Ue as CHICKEN_FOOT_TOE_ANGLES,
+  j as DEFAULT_PIP_COLORS,
+  te as DEFAULT_RULES,
+  rt as DominoHub,
+  ot as DominoTrain,
+  ve as DoubleTwelve,
+  Xt as MexicanTrainGame,
+  Mt as PIP_COLORS,
+  _e as PIP_LAYOUTS,
+  Nt as TRAIN_FIXTURES,
+  le as TURN_DEGREES,
+  _t as Viewport,
+  St as applyMove,
+  De as buildBranchTiles,
+  se as clampScale,
+  yt as collectPlayedKeys,
+  Ke as computeTrainLayout,
+  re as computeTrainTree,
+  Ft as cycleBendAt,
+  ke as dominoKey,
+  Et as dominoSetSize,
+  Pe as evaluatePlacement,
+  ft as fitToBounds,
+  ze as flattenSegments,
+  Ot as generateDominoSet,
+  it as generateSampleTrains,
+  gt as getBranchAt,
+  Ut as getLegalMoves,
+  wt as getOpenEnds,
+  Ne as getPipLayout,
+  kt as getPipStyle,
+  Ct as getTrainLayoutBounds,
+  bt as getUnsatisfiedDoubles,
+  Ge as headingAtIndex,
+  nt as hubTrainStartDistance,
+  Ce as isDouble,
+  me as layoutSelfIntersects,
+  Se as layoutsCollide,
+  Rt as linearDefaultSide,
+  $t as mergePipColors,
+  we as normalizeBends,
+  Yt as offsetDefaultSide,
+  Ie as oppositeSide,
+  Te as orientForConnection,
+  Pt as otherEnd,
+  U as outwardPerpSign,
+  Vt as playMove,
+  ht as requiredDoubleAnswers,
+  At as resolveBend,
+  Fe as resolvePipPosition,
+  ge as resolvePipStyle,
+  jt as resolveRules,
+  Lt as screenToContent,
+  oe as sideToTurn,
+  xt as sideToeSlots,
+  O as stepAlongTrain,
+  fe as tileCorners,
+  Dt as tileHasValue,
+  L as tileKey,
+  J as tilesOverlap,
+  et as validateChickenFootChain,
+  Tt as validateTrainLayout,
+  It as validateTrainTree,
+  K as withBendAt,
+  he as zoomAt
 };
 //# sourceMappingURL=index.js.map