fix(turn): block cross-pointer reorder (BUG-13)

reorderParticipants allowed dragging across current pointer mid-round.
nextTurn walks turnOrderIds forward from pointer, so cross-pointer drag
= ambiguous who-acts-next: upcoming dragged ahead of pointer = skipped
(walk wraps past), acted dragged behind pointer = double-act.

Full fix needs actedThisRound tracking. Pragmatic now: block both
directions during active encounter. Pre-combat: free reorder (no pointer).

reorderParticipants: added pointer check (currentTurn index). If drag
crosses pointer, return null patch (no-op). Same-side reorder allowed.
syncTurnOrder now always mirrors (was started-only — pre-combat reorder
left turnOrderIds stale).

Tests:
- turn.bug13.test.js: cross-pointer blocked (both dirs), same-side allowed,
  pre-combat free.
- turn.reorder.test.js: 3 tests updated to pre-combat (cross-pointer now
  blocked post-start).
- turn.invariant.test.js: reorder test uses same-side upcoming pair.

214 tests green.

shared/tests/turn.bug13.test.js

@@ -0,0 +1,72 @@
+// BUG-13: cross-pointer reorder blocked (skip/double-act otherwise).
+// nextTurn walks turnOrderIds forward from current pointer. Dragging across
+// pointer = ambiguous who-acts-next:
+//   - upcoming dragged ahead of pointer → walk wraps past → SKIPPED
+//   - acted dragged behind pointer → acts again → DOUBLE-ACT
+// Full fix needs actedThisRound tracking. Pragmatic now: block both dirs
+// during active encounter. Pre-combat: free reorder (no pointer).
+
+'use strict';
+
+const shared = require('@ttrpg/shared');
+const {
+  makeParticipant,
+  startEncounter, nextTurn, reorderParticipants,
+} = shared;
+
+function p(id, init) {
+  return makeParticipant({ id, name: id, type: 'monster',
+    initiative: init, maxHp: 100, currentHp: 100 });
+}
+function enc(ps) {
+  return { name:'t', participants:ps, isStarted:false, isPaused:false,
+    round:0, currentTurnParticipantId:null, turnOrderIds:[] };
+}
+const apply = (e, r) => r && r.patch ? { ...e, ...r.patch } : e;
+
+describe('BUG-13: cross-pointer reorder blocked during active encounter', () => {
+  test('dragging not-yet-acted participant ahead of pointer = no-op', () => {
+    // [a(10), b(10), c(10)]. a acts -> b current. c not yet acted.
+    let e = enc([p('a',10),p('b',10),p('c',10)]);
+    e = apply(e, startEncounter(e)); // a (idx0, pointer)
+    e = apply(e, nextTurn(e)); // b (idx1, pointer)
+    expect(e.currentTurnParticipantId).toBe('b');
+
+    // Drag c (idx2, behind pointer) before b (idx1, pointer). Crosses pointer.
+    // Would let c act by initiative-reinsert but nextTurn forward-walk skips.
+    // Blocked instead.
+    const r = reorderParticipants(e, 'c', 'b');
+    expect(r.patch).toBeNull();
+    expect(e.turnOrderIds).toEqual(['a','b','c']); // unchanged
+  });
+
+  test('dragging already-acted participant behind pointer = no-op', () => {
+    // [a(10), b(10), c(10)]. a acts (idx0, ahead of pointer).
+    let e = enc([p('a',10),p('b',10),p('c',10)]);
+    e = apply(e, startEncounter(e)); // a (pointer idx0)
+    e = apply(e, nextTurn(e)); // b (pointer idx1)
+    // Drag a (already acted, ahead of pointer) after c (behind pointer).
+    // Crosses pointer. Would let a act again. Blocked.
+    const r = reorderParticipants(e, 'a', 'c');
+    expect(r.patch).toBeNull();
+  });
+
+  test('reorder within same side of pointer = allowed', () => {
+    // [a(10), b(10), c(10), d(10)]. a current (pointer idx0).
+    // b,c,d all behind pointer (upcoming). Reorder among them = safe.
+    let e = enc([p('a',10),p('b',10),p('c',10),p('d',10)]);
+    e = apply(e, startEncounter(e)); // a (idx0)
+    // swap b,c (both idx1,2 — behind pointer). No cross.
+    const r = reorderParticipants(e, 'c', 'b');
+    expect(r.patch).not.toBeNull();
+    expect(r.patch.participants.map(p => p.id)).toEqual(['a','c','b','d']);
+  });
+
+  test('pre-combat: free reorder (no pointer)', () => {
+    // isStarted=false. No pointer. Reorder allowed freely.
+    let e = enc([p('a',10),p('b',10),p('c',10)]);
+    const r = reorderParticipants(e, 'c', 'a');
+    expect(r.patch).not.toBeNull();
+    expect(r.patch.participants.map(p => p.id)).toEqual(['c','a','b']);
+  });
+});

shared/tests/turn.invariant.test.js

@@ -90,12 +90,15 @@ describe('1-list model: turnOrderIds === participants.map(id), no re-sort', () =
     expect(e.turnOrderIds).toEqual(['a','b','c']); // unchanged
   });
 
-  test('reorder same-init: rotation follows new list order', () => {
-    let e = enc([p('a',10),p('b',10),p('c',3)]); // a,b tie
-    e = apply(e, startEncounter(e)); // [a,b,c], cur=a
-    e = apply(e, reorderParticipants(e, 'b', 'a')); // [b,a,c], cur still a
-    const rot = walkRotation(e); // start a, next c (wrap), next b, back a
-    expect(rot).toEqual(['a','c','b']);
+  test('reorder same-init: within upcoming side of pointer follows new order', () => {
+    let e = enc([p('a',10),p('b',10),p('c',10),p('d',3)]); // a,b,c tie
+    e = apply(e, startEncounter(e)); // [a,b,c,d], cur=a (idx0)
+    // Reorder c before b (both upcoming idx1,2). Within same side = allowed.
+    e = apply(e, reorderParticipants(e, 'c', 'b')); // [a,c,b,d], cur=a
+    expect(e.turnOrderIds).toEqual(['a','c','b','d']);
+    // walk: a current, next c, next b, next d, wrap a
+    e = apply(e, nextTurn(e));
+    expect(e.currentTurnParticipantId).toBe('c');
   });
 
   test('toggle inactive: list unchanged (stays in rotation slot)', () => {

shared/tests/turn.reorder.test.js

@@ -18,15 +18,12 @@ function enc(ps) {
 }
 
 describe('reorderParticipants', () => {
-  test('drag before target (1-list model)', () => {
+  test('drag before target (1-list model, pre-combat)', () => {
     const ps = [p('a', 10), p('b', 20), p('c', 20)]; // b,c tie
-    let e = enc(ps);
-    e = { ...e, ...startEncounter(e).patch };
-    // initial order: b,c,a (init 20,20,10)
-    expect(e.turnOrderIds).toEqual(['b', 'c', 'a']);
+    let e = enc(ps); // pre-combat, no pointer
     const r = reorderParticipants(e, 'c', 'b');
-    // drag c before b: remove c → [b,a], insert before b → [c,b,a]
-    expect(r.patch.participants.map(p => p.id)).toEqual(['c', 'b', 'a']);
+    // drag c before b: remove c → [a,b], insert before b → [a,c,b]
+    expect(r.patch.participants.map(p => p.id)).toEqual(['a', 'c', 'b']);
   });
 
   test('cross-init drag blocked (no-op)', () => {
@@ -47,21 +44,22 @@ describe('reorderParticipants', () => {
   test('syncs turnOrderIds = participants order (1-list, fixes BUG-6)', () => {
     const ps = [p('a', 10), p('b', 20), p('c', 20)];
     let e = enc(ps);
-    e = { ...e, ...startEncounter(e).patch };
-    const r = reorderParticipants(e, 'c', 'b');
-    expect(r.patch.turnOrderIds).toEqual(['c', 'b', 'a']);
-    expect(r.patch.turnOrderIds).toEqual(r.patch.participants.map(p => p.id));
+    e = { ...e, ...startEncounter(e).patch }; // started, but reorder pre-pointer advance
+    // startEncounter sets current=b (idx0). reorder c before b crosses pointer.
+    // Use pre-combat to test syncTurnOrder.
+    let pre = enc(ps);
+    pre = { ...pre, ...reorderParticipants(pre, 'c', 'b').patch };
+    expect(pre.turnOrderIds).toEqual(['a','c','b']);
+    expect(pre.turnOrderIds).toEqual(pre.participants.map(p => p.id));
   });
 
   // BUG-6 candidate: reorder should affect turnOrderIds so mid-combat
   // drag-drop changes who goes next within same-initiative tie.
   // Currently RED (turnOrderIds not in patch).
-  test('reorder updates turnOrderIds to reflect new participant order', () => {
+  test('reorder updates turnOrderIds to reflect new participant order (pre-combat)', () => {
     const ps = [p('a', 10), p('b', 20), p('c', 20)];
-    let e = enc(ps);
-    e = { ...e, ...startEncounter(e).patch };
-    // order: b,c,a
+    let e = enc(ps); // pre-combat, no pointer
     e = { ...e, ...reorderParticipants(e, 'c', 'b').patch };
-    expect(e.turnOrderIds).toEqual(['c', 'b', 'a']);
+    expect(e.turnOrderIds).toEqual(['a', 'c', 'b']);
   });
 });