three-slicer-viewer 0.3.3 → 0.3.5

package/dist/toolpath.js

@@ -1,113 +1,133 @@
-import { a as Z, b as It, p as at, h as St, T as wt, r as Nt, D as Pt } from "./toolpath_palette-B8xEl-qa.js";
-import { b as Bt, a as Vt } from "./viewer_defaults-B7UUZ582.js";
-import { r as At, S as lt, R as et, t as _t } from "./toolpath_encoding-BuYs95qZ.js";
-import { T as kt } from "./theme-2oyfMuvf.js";
-const ct = {};
-for (const t of Object.keys(Z)) ct[t] = at(Z[t]);
+import { a as R, b as Bt, p as lt, h as _t, T as wt, r as kt, D as Ot } from "./toolpath_palette-B8xEl-qa.js";
+import { b as Vt, a as jt } from "./viewer_defaults-B7UUZ582.js";
+import { r as At, S as ct, R as ot, t as Tt } from "./toolpath_encoding-BuYs95qZ.js";
+import { T as Ut } from "./theme-2oyfMuvf.js";
+const ft = {};
+for (const t of Object.keys(R)) ft[t] = lt(R[t]);
 function Wt(t) {
   const e = new Float32Array(t.length);
-  for (let o = 0; o < t.length; o++) {
-    const n = Number(t[o]?.z) || 0, r = o > 0 && Number(t[o - 1]?.z) || 0, c = o > 0 ? n - r : n;
-    e[o] = c > 1e-6 ? c : Vt;
+  for (let n = 0; n < t.length; n++) {
+    const o = Number(t[n]?.z) || 0, r = n > 0 && Number(t[n - 1]?.z) || 0, l = n > 0 ? o - r : o;
+    e[n] = l > 1e-6 ? l : jt;
   }
   return e;
 }
-const ft = (t) => t?.paths?.length ? t.paths : null, gt = (t) => {
-  const e = ft(t);
-  return e ? Math.floor(e.length / lt) : 0;
-};
-function Ht(t, e) {
-  const o = Array.isArray(t) ? t : [], n = o.length, r = Number(e) > 0 ? Number(e) : Bt, c = Wt(o), h = new Uint32Array(n + 1), d = new Uint32Array(n + 1), u = new Uint32Array(n + 1);
-  let m = 0, s = 0, f = 0;
-  for (let p = 0; p < n; p++) {
-    const P = ft(o[p]), C = gt(o[p]);
-    for (let A = 0; A < C; A++)
-      At(P[A * lt + 3]) === et.TRAVEL ? s++ : m++;
-    f += C, h[p + 1] = m, d[p + 1] = s, u[p + 1] = f;
+const ut = (t) => t?.paths?.length ? t.paths : null, Lt = (t) => {
+  const e = ut(t);
+  return e ? Math.floor(e.length / ct) : 0;
+}, xt = (t, e) => {
+  const n = e * 8, o = n + 4;
+  return Math.atan2(t[o + 1] - t[n + 1], t[o] - t[n]);
+}, Mt = (t, e) => {
+  const n = e * 8, o = n + 4;
+  return Math.hypot(t[o] - t[n], t[o + 1] - t[n + 1]);
+}, zt = (t, e, n) => t[e] === t[n] && t[e + 1] === t[n + 1] && t[e + 2] === t[n + 2];
+function Dt(t, e, n, o) {
+  const r = (a, h) => {
+    e[a * 8 + 4 + 2] = xt(t, h), e[h * 8 + 2] = xt(t, a);
+  }, l = (a, h) => n[a * 2] === n[h * 2] && zt(t, a * 8 + 4, h * 8) && Mt(t, a) > 0 && Mt(t, h) > 0;
+  let m = 0;
+  for (let a = 0; a < o; a++) {
+    if (a + 1 < o && l(a, a + 1)) {
+      r(a, a + 1);
+      continue;
+    }
+    m < a && l(a, m) && r(a, m), m = a + 1;
   }
-  const l = m * 2, L = new Float32Array(l * 4), I = new Float32Array(l * 4), v = new Uint32Array(l * 2), q = new Uint8Array(l), B = new Uint8Array(l), V = new Float32Array(l), ot = new Float32Array(l), T = new Int32Array(l), F = new Float32Array(s * 6), _ = new Float32Array(f * 3), j = new Uint8Array(f), nt = new Float64Array(16);
-  let J = !1, Y = 0, z = 1 / 0, k = 1 / 0, X = 1 / 0, W = -1 / 0, D = -1 / 0, i = -1 / 0, a = 0, b = 0, w = 0, x = 0;
-  for (let p = 0; p < n; p++) {
-    const P = o[p], C = ft(P), A = gt(P), Q = P?.widths, O = c[p], y = O / 2;
-    for (let g = 0; g < A; g++) {
-      const S = g * lt, G = C[S], rt = C[S + 1], it = C[S + 2], $ = C[S + 4], H = C[S + 5], R = C[S + 6], ht = C[S + 3] | 0, E = At(ht), Ct = _t(ht);
-      if (Number.isFinite(G + rt + it + $ + H + R) || (J = !0), j[x] = E === et.TRAVEL ? 0 : 1, _[x * 3] = $, _[x * 3 + 1] = H, _[x * 3 + 2] = R, x++, E === et.TRAVEL) {
-        const M = w * 6;
-        F[M] = G, F[M + 1] = rt, F[M + 2] = it, F[M + 3] = $, F[M + 4] = H, F[M + 5] = R, w++;
+}
+function le(t, e) {
+  const n = Array.isArray(t) ? t : [], o = n.length, r = Number(e) > 0 ? Number(e) : Vt, l = Wt(n), m = new Uint32Array(o + 1), a = new Uint32Array(o + 1), h = new Uint32Array(o + 1);
+  let p = 0, s = 0, d = 0;
+  for (let u = 0; u < o; u++) {
+    const v = ut(n[u]), g = Lt(n[u]);
+    for (let M = 0; M < g; M++)
+      At(v[M * ct + 3]) === ot.TRAVEL ? s++ : p++;
+    d += g, m[u + 1] = p, a[u + 1] = s, h[u + 1] = d;
+  }
+  const c = p * 2, L = new Float32Array(c * 4), S = new Float32Array(c * 4), W = new Uint32Array(c * 2), b = new Uint8Array(c), H = new Uint8Array(c), B = new Float32Array(c), _ = new Float32Array(c), E = new Int32Array(c), F = new Float32Array(s * 6), I = new Float32Array(d * 3), z = new Uint8Array(d), D = new Float64Array(16);
+  let it = !1, K = 0, G = 1 / 0, Z = 1 / 0, N = 1 / 0, q = -1 / 0, k = -1 / 0, O = -1 / 0, x = 0, J = 0, st = 0, i = 0;
+  for (let u = 0; u < o; u++) {
+    const v = n[u], g = ut(v), M = Lt(v), V = v?.widths, X = l[u], tt = X / 2;
+    for (let Y = 0; Y < M; Y++) {
+      const w = Y * ct, $ = g[w], P = g[w + 1], y = g[w + 2], A = g[w + 4], j = g[w + 5], T = g[w + 6], mt = g[w + 3] | 0, et = At(mt), It = Tt(mt);
+      if (Number.isFinite($ + P + y + A + j + T) || (it = !0), z[i] = et === ot.TRAVEL ? 0 : 1, I[i * 3] = A, I[i * 3 + 1] = j, I[i * 3 + 2] = T, i++, et === ot.TRAVEL) {
+        const C = st * 6;
+        F[C] = $, F[C + 1] = P, F[C + 2] = y, F[C + 3] = A, F[C + 4] = j, F[C + 5] = T, st++;
         continue;
       }
-      const st = Q ? Number(Q[g]) : NaN, mt = Number.isFinite(st) && st > 0 ? st : r, pt = $ - G, yt = H - rt, Mt = Math.atan2(yt, pt), vt = Math.hypot(pt, yt, R - it);
-      Number.isFinite(vt) && (nt[E] += vt);
-      const Ft = ct[E] ?? ct[1];
-      for (const [M, K, dt] of [[G, rt, it], [$, H, R]]) {
-        const U = a * 4;
-        L[U] = M, L[U + 1] = K, L[U + 2] = dt - y, L[U + 3] = 0, I[U] = O, I[U + 1] = mt, I[U + 2] = Mt, I[U + 3] = Ft, v[a * 2] = b, v[a * 2 + 1] = p, q[a] = E, B[a] = Ct, V[a] = mt, ot[a] = O, T[a] = p, a++;
-        const tt = dt - y;
-        M < z && (z = M), M > W && (W = M), K < k && (k = K), K > D && (D = K), tt < X && (X = tt), tt > i && (i = tt);
-        const bt = Math.max(Math.abs(M), Math.abs(K), Math.abs(tt));
-        bt > Y && (Y = bt);
+      const at = V ? Number(V[Y]) : NaN, dt = Number.isFinite(at) && at > 0 ? at : r, vt = A - $, yt = j - P, Nt = Math.atan2(yt, vt), pt = Math.hypot(vt, yt, T - y);
+      Number.isFinite(pt) && (D[et] += pt);
+      const Pt = ft[et] ?? ft[1];
+      for (const [C, Q, bt] of [[$, P, y], [A, j, T]]) {
+        const U = x * 4;
+        L[U] = C, L[U + 1] = Q, L[U + 2] = bt - tt, L[U + 3] = 0, S[U] = X, S[U + 1] = dt, S[U + 2] = Nt, S[U + 3] = Pt, W[x * 2] = J, W[x * 2 + 1] = u, b[x] = et, H[x] = It, B[x] = dt, _[x] = X, E[x] = u, x++;
+        const nt = bt - tt;
+        C < G && (G = C), C > q && (q = C), Q < Z && (Z = Q), Q > k && (k = Q), nt < N && (N = nt), nt > O && (O = nt);
+        const gt = Math.max(Math.abs(C), Math.abs(Q), Math.abs(nt));
+        gt > K && (K = gt);
       }
-      b++;
+      J++;
     }
   }
-  const N = l > 0 && Number.isFinite(z) ? { min: [z, k, X], max: [W, D, i] } : null;
+  Dt(L, S, E, p);
+  const f = c > 0 && Number.isFinite(G) ? { min: [G, Z, N], max: [q, k, O] } : null;
   return {
     position: L,
-    hwa: I,
-    segIndex: v,
-    nV: l,
-    nSeg: m,
-    layerSegPrefix: h,
+    hwa: S,
+    segIndex: W,
+    nV: c,
+    nSeg: p,
+    layerSegPrefix: m,
     travelPos: F,
-    travelPrefix: d,
+    travelPrefix: a,
     nTrav: s,
-    movePos: _,
-    moveKind: j,
-    movePrefix: u,
-    layerCount: n,
-    maxAbs: Y,
-    hasNaN: J,
-    typeLengths: nt,
-    bbox: N,
-    meta: { vType: q, vTool: B, vWidth: V, vHeight: ot, vLayer: T }
+    movePos: I,
+    moveKind: z,
+    movePrefix: h,
+    layerCount: o,
+    maxAbs: K,
+    hasNaN: it,
+    typeLengths: D,
+    bbox: f,
+    meta: { vType: b, vTool: H, vWidth: B, vHeight: _, vLayer: E }
   };
 }
-function Rt(t) {
+function ce(t) {
   const e = t ?? [];
-  let o = 0;
-  for (let r = 0; r < 16; r++) o += Number(e[r]) || 0;
-  if (o <= 0) return [];
-  const n = [];
+  let n = 0;
+  for (let r = 0; r < 16; r++) n += Number(e[r]) || 0;
+  if (n <= 0) return [];
+  const o = [];
   for (let r = 0; r < 16; r++) {
-    const c = Number(e[r]) || 0;
-    c <= 0 || n.push({ type: r, label: It[r] ?? String(r), pct: c / o * 100, color: Z[r] ?? Z[1] });
+    const l = Number(e[r]) || 0;
+    l <= 0 || o.push({ type: r, label: Bt[r] ?? String(r), pct: l / n * 100, color: R[r] ?? R[1] });
   }
-  return n.sort((r, c) => c.pct - r.pct);
+  return o.sort((r, l) => l.pct - r.pct);
 }
-const ut = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
-function Et(t, e) {
-  return ut(t, e);
+const ht = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
+function fe(t, e) {
+  return ht(t, e);
 }
-function te(t, e, o) {
-  const n = Math.min(o, t.layerCount - 1);
-  for (let r = n; r >= e; r--) if (ut(t, r) > 0) return r;
+function Gt(t, e, n) {
+  const o = Math.min(n, t.layerCount - 1);
+  for (let r = o; r >= e; r--) if (ht(t, r) > 0) return r;
   return e;
 }
-function ee(t, e, o) {
-  const n = ut(t, e), r = Math.max(0, Math.min(Number(o) || 0, n)), c = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
-  let h = 0, d = 0;
-  for (let m = 0; m < r; m++)
-    t.moveKind[c + m] === 0 ? d++ : h++;
+function Jt(t, e, n) {
+  const o = ht(t, e), r = Math.max(0, Math.min(Number(n) || 0, o)), l = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
+  let m = 0, a = 0;
+  for (let p = 0; p < r; p++)
+    t.moveKind[l + p] === 0 ? a++ : m++;
   if (r === 0) return { point: null, segCount: 0, travCount: 0, onTravel: !1 };
-  const u = c + r - 1;
+  const h = l + r - 1;
   return {
-    point: [t.movePos[u * 3], t.movePos[u * 3 + 1], t.movePos[u * 3 + 2]],
-    segCount: h,
-    travCount: d,
-    onTravel: t.moveKind[u] === 0
+    point: [t.movePos[h * 3], t.movePos[h * 3 + 1], t.movePos[h * 3 + 2]],
+    segCount: m,
+    travCount: a,
+    onTravel: t.moveKind[h] === 0
   };
 }
-const Lt = [
+const Ct = [
   { key: "feature", label: "Feature type", cont: !1, unit: "" },
   { key: "speed", label: "Speed", cont: !0, unit: "mm/s" },
   { key: "height", label: "Layer Height", cont: !0, unit: "mm" },
@@ -119,47 +139,51 @@ const Lt = [
   //  extruder index is a label, and a heatmap over it would imply tool 2 sits "between" tools 1 and 3.
   { key: "filament", label: "Filament", cont: !1, unit: "" }
 ];
-function Ot(t, e, o, n) {
-  const r = e.vType[o], c = e.vLayer[o], h = c === 0;
+function Xt(t, e, n, o) {
+  const r = e.vType[n], l = e.vLayer[n], m = l === 0;
   switch (t) {
     case "height":
-      return e.vHeight[o];
+      return e.vHeight[n];
     case "width":
-      return e.vWidth[o];
+      return e.vWidth[n];
     case "speed":
-      return h ? n.firstLayerSpeed : n.speedByType[r] ?? n.speedByType[1];
+      return m ? o.firstLayerSpeed : o.speedByType[r] ?? o.speedByType[1];
     case "fan":
-      return c < n.closeFanLayers ? 0 : r === 9 ? 100 : n.fanNormal;
+      return l < o.closeFanLayers ? 0 : r === 9 ? 100 : o.fanNormal;
     case "temp":
-      return h ? n.tempFirst : n.tempNormal;
+      return m ? o.tempFirst : o.tempNormal;
     default:
       return 0;
   }
 }
-function oe(t, e, o) {
-  const { meta: n, nV: r } = t, c = new Float32Array(r * 4), h = Lt.find((s) => s.key === e) || Lt[0];
-  if (!h.cont) {
-    const s = (o?.toolColors ?? []).map((l) => l && St(l)), f = h.key === "filament" ? (l) => {
-      const L = n.vTool ? n.vTool[l] : 0;
+function ue(t, e, n) {
+  const { meta: o, nV: r } = t, l = new Float32Array(r * 4), m = Ct.find((s) => s.key === e) || Ct[0];
+  if (!m.cont) {
+    const s = (n?.toolColors ?? []).map((c) => c && _t(c)), d = m.key === "filament" ? (c) => {
+      const L = o.vTool ? o.vTool[c] : 0;
       return s[L] || wt[L % wt.length];
-    } : (l) => Z[n.vType[l]] || Z[1];
-    for (let l = 0; l < r; l++) c[l * 4] = at(f(l));
-    return { color: c, min: 0, max: 0, viewType: e, label: h.label, unit: h.unit, cont: !1 };
+    } : (c) => R[o.vType[c]] || R[1];
+    for (let c = 0; c < r; c++) l[c * 4] = lt(d(c));
+    return { color: l, min: 0, max: 0, viewType: e, label: m.label, unit: m.unit, cont: !1 };
   }
-  let d = 1 / 0, u = -1 / 0;
-  const m = new Float32Array(r);
+  let a = 1 / 0, h = -1 / 0;
+  const p = new Float32Array(r);
   for (let s = 0; s < r; s++) {
-    const f = Ot(e, n, s, o), l = Number.isFinite(f) ? f : 0;
-    m[s] = l, l < d && (d = l), l > u && (u = l);
+    const d = Xt(e, o, s, n), c = Number.isFinite(d) ? d : 0;
+    p[s] = c, c < a && (a = c), c > h && (h = c);
   }
-  Number.isFinite(d) || (d = 0, u = 1);
+  Number.isFinite(a) || (a = 0, h = 1);
   for (let s = 0; s < r; s++) {
-    const f = Nt(m[s], d, u, Pt);
-    c[s * 4] = at(f);
+    const d = kt(p[s], a, h, Ot);
+    l[s * 4] = lt(d);
   }
-  return { color: c, min: d, max: u, viewType: e, label: h.label, unit: h.unit, cont: !0 };
+  return { color: l, min: a, max: h, viewType: e, label: m.label, unit: m.unit, cont: !0 };
 }
-const Ut = `
+const rt = 4096, Yt = 140 * Math.PI / 180, $t = 45 * Math.PI / 180, St = (t) => Math.round((t + Math.PI) / (2 * Math.PI) * (rt - 1));
+function Kt(t, e) {
+  return St(t) * rt + St(e);
+}
+const Zt = `
 precision highp float;
 
 uniform mat4 projectionMatrix;
@@ -173,6 +197,7 @@ in vec3  iEnd;
 in vec2  iHW;       // [height, width]
 in float iColor;    // r<<16 | g<<8 | b
 in float iLayer;
+in float iJoin;     // packJoin(start heading, end heading)
 
 out vec3 vColor;
 out vec3 vNormal;
@@ -199,8 +224,26 @@ void main() {
   vec3 axis = iEnd - iStart;
   // A zero-length segment has no direction to orient against; pick one rather than emitting NaN.
   vec2 flat2 = axis.xy;
-  vec2 dir = length(flat2) > 1e-9 ? normalize(flat2) : vec2(1.0, 0.0);
-  vec3 side = vec3(-dir.y, dir.x, 0.0);
+  vec2 dir = vec2(1.0, 0.0);
+  if (length(flat2) > 1e-9) dir = normalize(flat2);
+  vec2 ownSide = vec2(-dir.y, dir.x);
+
+  float joinStart = floor(iJoin / ${rt}.0);
+  float joined = joinStart;
+  if (tpl.x > 0.5) joined = iJoin - joinStart * ${rt}.0;
+  joined = joined * (6.283185307179586 / ${rt - 1}.0) - 3.141592653589793;
+  vec2 bisector = dir + vec2(cos(joined), sin(joined));
+  vec2 side2 = ownSide;
+  vec2 facing2 = ownSide;
+  if (length(bisector) > 1e-6) {
+    vec2 tangent = normalize(bisector);
+    vec2 miterSide = vec2(-tangent.y, tangent.x);
+    float halfTurnCos = dot(miterSide, ownSide);
+    if (halfTurnCos > ${Math.cos(Yt / 2)}) side2 = miterSide / halfTurnCos;
+    if (halfTurnCos > ${Math.cos($t / 2)}) facing2 = miterSide;
+  }
+  vec3 side = vec3(side2, 0.0);
+  vec3 facing = vec3(facing2, 0.0);
   vec3 up   = vec3(0.0, 0.0, 1.0);
 
   float halfHeight = iHW.x * 0.5;
@@ -208,18 +251,19 @@ void main() {
 
   float ring = tpl.y;
   vec3 offset;
-  if (ring < 0.5)      offset =  side * halfWidth;
-  else if (ring < 1.5) offset =  up   * halfHeight;
-  else if (ring < 2.5) offset = -side * halfWidth;
-  else                 offset = -up   * halfHeight;
+  vec3 normal;
+  if (ring < 0.5)      { offset =  side * halfWidth;  normal =  facing; }
+  else if (ring < 1.5) { offset =  up   * halfHeight; normal =  up; }
+  else if (ring < 2.5) { offset = -side * halfWidth;  normal = -facing; }
+  else                 { offset = -up   * halfHeight; normal = -up; }
 
   vec3 world = mix(iStart, iEnd, tpl.x) + offset;
 
-  vNormal = normalize(mat3(modelViewMatrix) * normalize(offset));
+  vNormal = normalize(mat3(modelViewMatrix) * normal);
   vColor = unpackColor(iColor);
   gl_Position = projectionMatrix * modelViewMatrix * vec4(world, 1.0);
 }
-`, zt = `
+`, qt = `
 precision highp float;
 
 in vec3 vColor;
@@ -234,41 +278,41 @@ void main() {
   float lambert = max(dot(n, normalize(vec3(0.35, 0.35, 1.0))), 0.0);
   fragColor = vec4(vColor * (0.55 + 0.45 * lambert), 1.0);
 }
-`, xt = [2, 4], Dt = 1.5;
-function Gt(t, e) {
-  let o = 0;
-  for (let n = 0; n < t.length; n += 2)
-    (t[n] === et.RAFT || t[n] === et.SKIRT) && e[n] > o && (o = e[n]);
-  return o;
+`, Ft = [2, 4], Qt = 1.5;
+function Rt(t, e) {
+  let n = 0;
+  for (let o = 0; o < t.length; o += 2)
+    (t[o] === ot.RAFT || t[o] === ot.SKIRT) && e[o] > n && (n = e[o]);
+  return n;
 }
-function Tt(t, e, o, n) {
+function Ht(t, e, n, o) {
   let r = 0;
   for (let s = 0; s < e; s++) t(s) > r && (r = t(s));
-  const c = (s) => s <= n || (r - s) % o === 0;
-  let h = 0;
-  for (let s = 0; s < e; s++) c(t(s)) && h++;
-  const d = new Uint32Array(h), u = new Uint8Array(h);
+  const l = (s) => s <= o || (r - s) % n === 0;
   let m = 0;
+  for (let s = 0; s < e; s++) l(t(s)) && m++;
+  const a = new Uint32Array(m), h = new Uint8Array(m);
+  let p = 0;
   for (let s = 0; s < e; s++) {
-    const f = t(s);
-    c(f) && (d[m] = s, u[m] = 1, f > n && (u[m] = Math.min(o, f - n)), m++);
+    const d = t(s);
+    l(d) && (a[p] = s, h[p] = 1, d > o && (h[p] = Math.min(n, d - o)), p++);
   }
-  return { source: d, layers: u };
+  return { source: a, layers: h };
 }
-function jt(t, e) {
-  const o = Math.max(1, Math.floor(e / 4096)), n = [];
-  for (let r = 0; r < e; r += o) n.push(t(r));
-  return n.length ? (n.sort((r, c) => r - c), n[n.length >> 1]) : 0;
+function Et(t, e) {
+  const n = Math.max(1, Math.floor(e / 4096)), o = [];
+  for (let r = 0; r < e; r += n) o.push(t(r));
+  return o.length ? (o.sort((r, l) => r - l), o[o.length >> 1]) : 0;
 }
-function Yt(t, e, o, n) {
-  return e > 0 ? t * (n / 2) / (e * Math.tan(o * Math.PI / 360)) : 1 / 0;
+function te(t, e, n, o) {
+  return e > 0 ? t * (o / 2) / (e * Math.tan(n * Math.PI / 360)) : 1 / 0;
 }
-function Xt(t, e = xt) {
-  let o = 1;
-  for (const n of e) n * t <= Dt && n > o && (o = n);
-  return o;
+function ee(t, e = Ft) {
+  let n = 1;
+  for (const o of e) o * t <= Qt && o > n && (n = o);
+  return n;
 }
-const Kt = new Float32Array([
+const ne = new Float32Array([
   0,
   0,
   0,
@@ -287,119 +331,129 @@ const Kt = new Float32Array([
   1,
   3
   // end ring
-]), Zt = (() => {
+]), oe = (() => {
   const t = [];
   for (let e = 0; e < 4; e++) {
-    const o = e, n = (e + 1) % 4, r = 4 + (e + 1) % 4, c = 4 + e;
-    t.push(o, n, r, o, r, c);
+    const n = e, o = (e + 1) % 4, r = 4 + (e + 1) % 4, l = 4 + e;
+    t.push(n, o, r, n, r, l);
   }
   return t;
 })();
-function ne(t, e) {
-  const { nSeg: o, nV: n, position: r, hwa: c, travelPos: h, travelPrefix: d, layerCount: u, meta: m } = e, s = new Float32Array(o * 3), f = new Float32Array(o * 3), l = new Float32Array(o * 2), L = new Float32Array(o), I = new Float32Array(o);
-  for (let i = 0; i < o; i++) {
-    const a = i * 2 * 4, b = (i * 2 + 1) * 4;
-    s[i * 3] = r[a], s[i * 3 + 1] = r[a + 1], s[i * 3 + 2] = r[a + 2], f[i * 3] = r[b], f[i * 3 + 1] = r[b + 1], f[i * 3 + 2] = r[b + 2], l[i * 2] = c[a], l[i * 2 + 1] = c[a + 1], L[i] = c[a + 3], I[i] = m.vLayer[i * 2];
+function he(t, e) {
+  const { nSeg: n, nV: o, position: r, hwa: l, travelPos: m, travelPrefix: a, layerCount: h, meta: p } = e, s = new Float32Array(n * 3), d = new Float32Array(n * 3), c = new Float32Array(n * 2), L = new Float32Array(n), S = new Float32Array(n), W = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const f = i * 2 * 4, u = (i * 2 + 1) * 4;
+    s[i * 3] = r[f], s[i * 3 + 1] = r[f + 1], s[i * 3 + 2] = r[f + 2], d[i * 3] = r[u], d[i * 3 + 1] = r[u + 1], d[i * 3 + 2] = r[u + 2], c[i * 2] = l[f], c[i * 2 + 1] = l[f + 1], L[i] = l[f + 3], S[i] = p.vLayer[i * 2], W[i] = Kt(l[f + 2], l[u + 2]);
   }
-  const v = new t.InstancedBufferGeometry();
-  v.setAttribute("tpl", new t.BufferAttribute(Kt, 2)), v.setIndex(Zt), v.setAttribute("iStart", new t.InstancedBufferAttribute(s, 3)), v.setAttribute("iEnd", new t.InstancedBufferAttribute(f, 3)), v.setAttribute("iHW", new t.InstancedBufferAttribute(l, 2));
-  const q = new t.InstancedBufferAttribute(L, 1);
-  v.setAttribute("iColor", q), v.setAttribute("iLayer", new t.InstancedBufferAttribute(I, 1)), v.instanceCount = o, v.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
+  const b = new t.InstancedBufferGeometry();
+  b.setAttribute("tpl", new t.BufferAttribute(ne, 2)), b.setIndex(oe), b.setAttribute("iStart", new t.InstancedBufferAttribute(s, 3)), b.setAttribute("iEnd", new t.InstancedBufferAttribute(d, 3)), b.setAttribute("iHW", new t.InstancedBufferAttribute(c, 2));
+  const H = new t.InstancedBufferAttribute(L, 1);
+  b.setAttribute("iColor", H), b.setAttribute("iLayer", new t.InstancedBufferAttribute(S, 1)), b.setAttribute("iJoin", new t.InstancedBufferAttribute(W, 1)), b.instanceCount = n, b.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
   const B = new t.RawShaderMaterial({
-    vertexShader: Ut,
-    fragmentShader: zt,
+    vertexShader: Zt,
+    fragmentShader: qt,
     glslVersion: t.GLSL3,
     // Every face of the template winds outward (test_toolpath_contract.mjs), so a back face is only ever the
     //  inside of a bead seen through its open end. Drawing those doubled the GPU time of a frame: measured on a
     //  14.6M-segment scene (6 plates, M5 Pro, DPR 2), 53.6 -> 29.4 ms with back faces culled.
     side: t.FrontSide,
-    uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, u - 1) } }
-  }), V = new t.Mesh(v, B);
-  V.frustumCulled = !1;
-  const ot = Gt(m.vType, m.vLayer), T = xt.map((i) => {
-    const { source: a, layers: b } = Tt((y) => I[y], o, i, ot), w = a.length, x = new Float32Array(w * 3), N = new Float32Array(w * 3), p = new Float32Array(w * 2), P = new Float32Array(w), C = new Float32Array(w);
-    for (let y = 0; y < w; y++) {
-      const g = a[y], S = l[g * 2], G = (b[y] - 1) * S / 2;
-      x[y * 3] = s[g * 3], x[y * 3 + 1] = s[g * 3 + 1], x[y * 3 + 2] = s[g * 3 + 2] - G, N[y * 3] = f[g * 3], N[y * 3 + 1] = f[g * 3 + 1], N[y * 3 + 2] = f[g * 3 + 2] - G, p[y * 2] = S * b[y], p[y * 2 + 1] = l[g * 2 + 1], P[y] = L[g], C[y] = I[g];
+    uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, h - 1) } }
+  }), _ = new t.Mesh(b, B);
+  _.frustumCulled = !1;
+  const E = Rt(p.vType, p.vLayer), F = Ft.map((i) => {
+    const { source: f, layers: u } = Ht((y) => S[y], n, i, E), v = f.length, g = new Float32Array(v * 3), M = new Float32Array(v * 3), V = new Float32Array(v * 2), X = new Float32Array(v), tt = new Float32Array(v), Y = new Float32Array(v);
+    for (let y = 0; y < v; y++) {
+      const A = f[y], j = c[A * 2], T = (u[y] - 1) * j / 2;
+      g[y * 3] = s[A * 3], g[y * 3 + 1] = s[A * 3 + 1], g[y * 3 + 2] = s[A * 3 + 2] - T, M[y * 3] = d[A * 3], M[y * 3 + 1] = d[A * 3 + 1], M[y * 3 + 2] = d[A * 3 + 2] - T, V[y * 2] = j * u[y], V[y * 2 + 1] = c[A * 2 + 1], X[y] = L[A], tt[y] = S[A], Y[y] = W[A];
     }
-    const A = new t.InstancedBufferGeometry();
-    A.setAttribute("tpl", v.attributes.tpl), A.setIndex(v.index), A.setAttribute("iStart", new t.InstancedBufferAttribute(x, 3)), A.setAttribute("iEnd", new t.InstancedBufferAttribute(N, 3)), A.setAttribute("iHW", new t.InstancedBufferAttribute(p, 2));
-    const Q = new t.InstancedBufferAttribute(P, 1);
-    A.setAttribute("iColor", Q), A.setAttribute("iLayer", new t.InstancedBufferAttribute(C, 1)), A.instanceCount = w;
-    const O = new t.Mesh(A, B);
-    return O.frustumCulled = !1, O.visible = !1, V.add(O), { k: i, mesh: O, source: a, colors: P, colorAttr: Q };
+    const w = new t.InstancedBufferGeometry();
+    w.setAttribute("tpl", b.attributes.tpl), w.setIndex(b.index), w.setAttribute("iStart", new t.InstancedBufferAttribute(g, 3)), w.setAttribute("iEnd", new t.InstancedBufferAttribute(M, 3)), w.setAttribute("iHW", new t.InstancedBufferAttribute(V, 2));
+    const $ = new t.InstancedBufferAttribute(X, 1);
+    w.setAttribute("iColor", $), w.setAttribute("iLayer", new t.InstancedBufferAttribute(tt, 1)), w.setAttribute("iJoin", new t.InstancedBufferAttribute(Y, 1)), w.instanceCount = v;
+    const P = new t.Mesh(w, B);
+    return P.frustumCulled = !1, P.visible = !1, _.add(P), { k: i, mesh: P, source: f, colors: X, colorAttr: $ };
   });
-  let F = 1, _ = !0;
-  const j = (i) => {
-    if (i !== F) {
-      F = i;
-      for (const a of T) a.mesh.visible = a.k === i;
-      v.instanceCount = 0, i === 1 && (v.instanceCount = o);
+  let I = 1, z = !0;
+  const D = (i) => {
+    if (i !== I) {
+      I = i;
+      for (const f of F) f.mesh.visible = f.k === i;
+      b.instanceCount = 0, i === 1 && (b.instanceCount = n);
     }
-  }, nt = jt((i) => l[i * 2], o), J = e.bbox && new t.Box3(new t.Vector3(...e.bbox.min), new t.Vector3(...e.bbox.max)), Y = new t.Box3(), z = (i, a) => {
-    if (!_ || !J || !i?.isPerspectiveCamera) {
-      j(1);
+  }, it = Et((i) => c[i * 2], n), K = e.bbox && new t.Box3(new t.Vector3(...e.bbox.min), new t.Vector3(...e.bbox.max)), G = new t.Box3(), Z = (i, f) => {
+    if (!z || !K || !i?.isPerspectiveCamera) {
+      D(1);
       return;
     }
-    Y.copy(J).applyMatrix4(V.matrixWorld), j(Xt(Yt(nt, Y.distanceToPoint(i.position), i.fov, a)));
+    G.copy(K).applyMatrix4(_.matrixWorld), D(ee(te(it, G.distanceToPoint(i.position), i.fov, f)));
   };
-  V.userData.updateLod = z;
-  const k = new t.BufferGeometry();
-  k.setAttribute("position", new t.BufferAttribute(h, 3));
-  const X = new t.LineBasicMaterial({ color: kt.travel, transparent: !0, opacity: 0.6 }), W = new t.LineSegments(k, X);
-  W.visible = !1, W.frustumCulled = !1;
-  const D = (i, a) => {
-    const b = Math.max(0, u - 1), w = Math.max(0, Math.min(i | 0, b)), x = Math.max(w, Math.min(a | 0, b));
-    B.uniforms.uLayerLo.value = w, B.uniforms.uLayerHi.value = x, _ = w === 0 && x === b, _ || j(1);
-    const N = d[w] * 2, p = d[x + 1] * 2;
-    k.setDrawRange(N, Math.max(0, p - N));
+  _.userData.updateLod = Z;
+  const N = new t.BufferGeometry();
+  N.setAttribute("position", new t.BufferAttribute(m, 3));
+  const q = new t.LineBasicMaterial({ color: Ut.travel, transparent: !0, opacity: 0.6 }), k = new t.LineSegments(N, q);
+  k.visible = !1, k.frustumCulled = !1;
+  let O = 0, x = Math.max(0, h - 1);
+  const J = (i, f) => {
+    const u = Math.max(0, h - 1), v = Math.max(0, Math.min(i | 0, u)), g = Math.max(v, Math.min(f | 0, u));
+    O = v, x = g, I === 1 && (b.instanceCount = n), B.uniforms.uLayerLo.value = v, B.uniforms.uLayerHi.value = g, z = v === 0 && g === u, z || D(1);
+    const M = a[v] * 2, V = a[g + 1] * 2;
+    N.setDrawRange(M, Math.max(0, V - M));
   };
-  return D(0, u - 1), {
-    mesh: V,
-    travLines: W,
-    setLayerRange: D,
-    setVisibleLayers: (i) => D(0, (i | 0) - 1),
+  return J(0, h - 1), {
+    mesh: _,
+    travLines: k,
+    setLayerRange: J,
+    setMoveRange: (i) => {
+      if (i == null)
+        return J(O, x), null;
+      const f = Gt(e, O, x), u = Jt(e, f, i);
+      z = !1, D(1), b.instanceCount = e.layerSegPrefix[f] + u.segCount;
+      const v = a[O] * 2;
+      return N.setDrawRange(v, Math.max(0, (a[f] + u.travCount) * 2 - v)), { ...u, layer: f };
+    },
+    data: e,
+    setVisibleLayers: (i) => J(0, (i | 0) - 1),
     setTravelVisible: (i) => {
-      W.visible = !!i;
+      k.visible = !!i;
     },
     /** color is Float32Array(nV*4) with the packed value in .r — computeColors' output shape. One instance
      *  takes the colour of its first vertex; the two agree, since a segment is one colour. */
     setColors: (i) => {
-      if (!(!i || i.length < n * 4)) {
-        for (let a = 0; a < o; a++) L[a] = i[a * 2 * 4];
-        q.needsUpdate = !0;
-        for (const a of T) {
-          for (let b = 0; b < a.source.length; b++) a.colors[b] = L[a.source[b]];
-          a.colorAttr.needsUpdate = !0;
+      if (!(!i || i.length < o * 4)) {
+        for (let f = 0; f < n; f++) L[f] = i[f * 2 * 4];
+        H.needsUpdate = !0;
+        for (const f of F) {
+          for (let u = 0; u < f.source.length; u++) f.colors[u] = L[f.source[u]];
+          f.colorAttr.needsUpdate = !0;
         }
       }
     },
     /** Call once per frame before rendering; viewportPixels is the drawing buffer's height. */
-    updateLod: z,
-    lodLevel: () => F,
+    updateLod: Z,
+    lodLevel: () => I,
     dispose: () => {
-      for (const i of T) i.mesh.geometry.dispose();
-      v.dispose(), B.dispose(), k.dispose(), X.dispose();
+      for (const i of F) i.mesh.geometry.dispose();
+      b.dispose(), B.dispose(), N.dispose(), q.dispose();
     },
-    nSeg: o,
-    layerCount: u
+    nSeg: n,
+    layerCount: h
   };
 }
 export {
-  Pt as DEFAULT_RANGES_COLORS,
+  Ot as DEFAULT_RANGES_COLORS,
   wt as TOOL_COLOR,
-  Z as TYPE_COLOR,
-  It as TYPE_LABEL,
-  Zt as VERTEX_DATA,
-  Lt as VIEW_TYPES,
-  Ht as buildSegmentData,
-  oe as computeColors,
-  St as hexToRgb,
-  Et as layerMoveCount,
-  ne as makeToolpath,
-  ee as moveCursor,
-  at as packColor,
-  Nt as rangeColorAt,
-  Rt as roleRatios,
-  te as topMoveLayer
+  R as TYPE_COLOR,
+  Bt as TYPE_LABEL,
+  oe as VERTEX_DATA,
+  Ct as VIEW_TYPES,
+  le as buildSegmentData,
+  ue as computeColors,
+  _t as hexToRgb,
+  fe as layerMoveCount,
+  he as makeToolpath,
+  Jt as moveCursor,
+  lt as packColor,
+  kt as rangeColorAt,
+  ce as roleRatios,
+  Gt as topMoveLayer
 };