monolith

public

Star0

Fork 0

Watch0

4 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `440b67836dd5`

tarball

atagen <boss@atagen.co>2026-10-16 07:58 UTC

1 file changed+49-8

design: keep coupled edges together and make plans reversible

A two-phase plan could remove a window in phase 1 while its neighbour only absorbed the space in phase 2, opening a hole that read as a two-axis move. Plans now keep touching neighbours together and are computed in a canonical direction, so undoing a change replays it backwards.

Modified file: design/planner.html+49 additions−8 deletions@@ -48,6 +48,8 @@
   <li>Phases are synchronised. Everything in a phase starts and stops together.</li>
   <li>In orthogonal style, the default, a window moves or resizes along one axis per phase.</li>
   <li>An interrupt throws the plan away and replans from what is on screen. Plans never stack.</li>
+  <li>Neighbours whose edges touch at both ends of a transition keep touching throughout. No holes open mid-plan.</li>
+  <li>Planning B to A is the exact reverse of planning A to B, so undoing a change looks like rewinding it.</li>
 </ul>
 <p>New requirements wry never met.</p>
 <ul>
@@ -89,6 +91,8 @@
 <h2>5. Two phases, axis order</h2>
 <p>When a pair turns a corner (left of becomes above), the middle keyframe is built from a <em>mixed</em> rectangle. Each window takes its horizontal extent from one end and its vertical extent from the other. "X first" means the window takes its target horizontal extent in phase 1 and its target vertical extent in phase 2. "Y first" is the reverse. Every window then moves along exactly one axis per phase.</p>
 <p>Each window's choice is one boolean. Every pair rules out some of the four combinations, and each forbidden combination is a clause over two variables. That makes it a <strong>2-SAT problem, solvable in linear time</strong> with no search. Windows that only change one axis use the same boolean to choose whether they move in phase 1 or phase 2, and the planner prefers phase 1 so nothing waits needlessly.</p>
+<p><strong>Coupled edges.</strong> Avoiding overlap is not enough. A window can vanish in phase 1 while the neighbour that absorbs its space only moves in phase 2, leaving a hole in between. Any two neighbours whose edges touch at both ends must also touch in the middle keyframe. Among valid orderings the solver picks one that keeps every such edge together, and only accepts a hole if none exists. In the 6,000-case stress test no two-phase plan needed one.</p>
+<p><strong>Rewind symmetry.</strong> Every pair of layouts is planned in one canonical direction, and the other direction plays that plan backwards. Insert D and split B with E together, and D arrives first, then E. Undo it, and E leaves first, then D.</p>
 <div class="demo" id="d4a"></div>
 <p>Growing a window in both directions inside a grid. Orthogonal makes space along one axis and then grows along the other. Direct does it in one diagonal phase.</p>
 <div class="demo" id="d4b"></div>
@@ -145,12 +149,13 @@
 
 <h2>14. Algorithm</h2>
 <pre>plan(from, to):
+  if from > to in a canonical order: return reverse(plan(to, from))
   groups = motion groups (windows whose swept areas can touch, transitively)
   for each group:
     if every pair shares a relation between from and to
        and (style is direct or every window changes only one axis):
       return [from, to]                                    # 1 phase
-    if 2-SAT over axis order finds K1:                     # mixed rects
+    if 2-SAT over axis order finds K1, preferring no holes: # mixed rects
       return [from, K1, to]                                # 2 phases
     for lane_axis in [y, x]:                               # strips, then columns
       for set in [windows in reversals, all movers, all]:
@@ -271,10 +276,18 @@ function pureOk(keys) {
   return true;
 }
 
+function signature(L) { return Object.keys(L).sort().map(id => { const r = L[id]; return [r.x, r.y, r.w, r.h].map(v => v.toFixed(1)).join(','); }).join(';'); }
+
 function plan(from, to, opts = {}) {
+  if (opts.naive) return { kind: 'naive lerp', keys: [from, to], durs: [PHASE_MS] };
+  if (signature(from) <= signature(to)) return planOneWay(from, to);
+  const p = planOneWay(to, from);
+  return { kind: p.kind, keys: [...p.keys].reverse(), durs: [...p.durs].reverse() };
+}
+
+function planOneWay(from, to) {
   const list = Object.keys(to);
   const T = PHASE_MS;
-  if (opts.naive) return { kind: 'naive lerp', keys: [from, to], durs: [T] };
   const movers = list.filter(id => { const c = chg(from[id], to[id]); return c.x || c.y; });
   if (!movers.length) return { kind: 'no-op', keys: [from, to], durs: [0] };
   const pure = movers.every(id => { const c = chg(from[id], to[id]); return !(c.x && c.y); });
@@ -333,24 +346,52 @@ function grid(from, to, list, movers) {
 
 function mixed(f, t, xFirst) { return xFirst ? R(t.x, f.y, t.w, f.h) : R(f.x, t.y, f.w, t.h); }
 
+function adjBits(a, b) {
+  const ovX = a.x < b.x + b.w + EPS && b.x < a.x + a.w + EPS;
+  const ovY = a.y < b.y + b.h + EPS && b.y < a.y + a.h + EPS;
+  let s = 0;
+  if (ovY && Math.abs(b.x - (a.x + a.w)) <= G + EPS) s |= 1;
+  if (ovY && Math.abs(a.x - (b.x + b.w)) <= G + EPS) s |= 2;
+  if (ovX && Math.abs(b.y - (a.y + a.h)) <= G + EPS) s |= 4;
+  if (ovX && Math.abs(a.y - (b.y + b.h)) <= G + EPS) s |= 8;
+  return s;
+}
+function coupledEdges(from, to, list) {
+  const out = [];
+  for (let i = 0; i < list.length; i++)
+    for (let j = i + 1; j < list.length; j++) {
+      const a = list[i], b = list[j], s = adjBits(from[a], from[b]) & adjBits(to[a], to[b]);
+      if (s) out.push([a, b, s]);
+    }
+  return out;
+}
+function holes(K, coupled) {
+  let n = 0;
+  for (const [a, b, s] of coupled) if ((adjBits(K[a], K[b]) & s) !== s) n++;
+  return n;
+}
+
 function axisOrder(from, to, list, movers) {
   const n = movers.length;
   if (n > 14) return null;
+  const coupled = coupledEdges(from, to, list);
   let best = null, bestScore = Infinity;
   for (let mask = 0; mask < (1 << n); mask++) {
     const K1 = { ...from };
-    let score = 0;
+    let late = 0;
     movers.forEach((id, i) => {
       const xf = !!(mask & (1 << i));
       const c = chg(from[id], to[id]);
       K1[id] = mixed(from[id], to[id], xf);
-      if (c.x && !c.y && !xf) score++;
-      if (c.y && !c.x && xf) score++;
+      if (c.x && !c.y && !xf) late++;
+      if (c.y && !c.x && xf) late++;
     });
-    if (score >= bestScore) continue;
-    if (phaseOk(from, K1, list) && phaseOk(K1, to, list)) { best = K1; bestScore = score; if (score === 0) break; }
+    if (late >= bestScore) continue;
+    if (!phaseOk(from, K1, list) || !phaseOk(K1, to, list)) continue;
+    const score = holes(K1, coupled) * 1000 + late;
+    if (score < bestScore) { best = K1; bestScore = score; if (score === 0) break; }
   }
-  return best ? { kind: '2 phases (axis order)', keys: [from, best, to], durs: [PHASE_MS, PHASE_MS] } : null;
+  return best ? { kind: '2 phases (axis order)' + (bestScore >= 1000 ? ', opens a hole' : ''), keys: [from, best, to], durs: [PHASE_MS, PHASE_MS] } : null;
 }
 
 function lanes(from, to, list, movers, ax) {

monolith

Commit 440b67836dd5

Commit `440b67836dd5`