jrvieira/nove - Change ANAAF3LVFG2YCTAWUZKMT75XQN6YNS4CLLZIXSVGKJQRWJVNBMEAC

scope prototype, loop lock, ready for push mechanics

Created by DNKjbgcFg8vYaePJFMA2HX1r4RTt4b6cKSYfFZjQtnKc on February 19, 2026

ANAAF3LVFG2YCTAWUZKMT75XQN6YNS4CLLZIXSVGKJQRWJVNBMEAC

Dependencies

[2] 7QP2V7ZBVZ7SKQ3SYV6NYA7V77G3Y7GF5V6EPIXLIYFSMFRWR4VAC

In channels

main

Change contents

Replacement in test/Test.hs at line 1 [2.19]
B:BD[2.19] → [2.20:38]
```
module Test where
```
[2.19]
[2.38]
```
module Main where
```

Replacement in test/Test.hs at line 6 [2.19]

B:BD[2.73] → [2.73:101]

main = exitWith ExitSuccess

[2.73]

main = do
   print "ok"
   exitWith ExitSuccess

Replacement in test/Demo.hs at line 11 [2.135]

B:BD[2.308] → [2.308:361]

import Data.Map as Map ( Map, elems, filterWithKey )

[2.308]

[2.361]

import Data.IntMap as IntMap ( filter, keys )
import Data.Map as Map ( Map, (!) )

Replacement in test/Demo.hs at line 24 [2.135]

B:BD[2.599] → [2.599:705]

      gInitState = (State { rand = r , center = 0 , keys = (Nothing,mempty) } , generate (verse 11) rs) ,

[2.599]

[2.705]

      gInitState = (State { rand = r , center = 0 , input = (Nothing,mempty) } , generate (verse 11) rs) ,

Insertion in test/Demo.hs at line 29 [2.135]
[2.775]
[2.775]
```
   --Demo Universe
```

Insertion in test/Demo.hs at line 39 [2.135]

[2.1382]

      : set Robot { name = "L0" , ops = Move <$> repeat L } (shift v 17 H 0)
      : set Robot { name = "L1" , ops = Move <$> repeat L } (shift v 18 H 0)
      : set Robot { name = "L2" , ops = Move <$> repeat L } (shift v 19 H 0)

Replacement in test/Demo.hs at line 66 [2.135]
B:BD[2.1925] → [2.1925:1962]
```
   , keys :: (Maybe Char,Queue Char)
```
[2.1925]
[2.1962]
```
   , input :: (Maybe Char,Queue Char)
```

Replacement in test/Demo.hs at line 73 [2.135]

B:BD[2.2090] → [2.2090:2150]

logic _ (s,v) (KeyPress k) = Right (s { keys = keys' } , v)

[2.2090]

[2.2150]

logic _ (s,v) (KeyPress k) = Right (s { input = input' } , v)

Replacement in test/Demo.hs at line 77 [2.135]

B:BD[2.2193] → [2.2193:2333]

   keys' :: (Maybe Char,Queue Char)
      | Just (q,_) <- dequeue $ snd $ keys s , k == q = keys s
      | otherwise = enqueue k <$> keys s

[2.2193]

[2.2333]

   input' :: (Maybe Char,Queue Char)
      | Just (q,_) <- dequeue $ snd $ input s , k == q = input s
      | otherwise = enqueue k <$> input s

Replacement in test/Demo.hs at line 85 [2.135]

B:BD[2.2417] → [2.2417:2546]

      | Just (c,q) <- dequeue (snd $ keys s) = s { keys = (Just c , q) }
      | otherwise = s { keys = (Nothing,snd $ keys s) }

[2.2417]

[2.2546]

      | Just (c,q) <- dequeue (snd $ input s) = s { input = (Just c , q) }
      | otherwise = s { input = (Nothing,snd $ input s) }

Replacement in test/Demo.hs at line 95 [2.135]
B:BD[2.2844] → [2.2844:2868]
```
      k = fst $ keys z
```
[2.2844]
[2.2868]
```
      k :: Maybe Char
      k = fst $ input z
```

Deletion in test/Demo.hs at line 107 [2.135]

B:BD[2.3054] → [2.3054:3249]

   canvas :: Plane
   canvas = blankPlane (2 * succ (2 * r) + 2) (succ (2 * r) + 2)
   hex :: Plane
   hex = foldl (&) canvas $ [ write (x,y) | x <- [-r..r] , y <- [-r..r] , abs (x + y) <= r ]

Replacement in test/Demo.hs at line 108 [2.135]

B:BD[2.3279] → [2.3279:3324]

   write (x,y) = c %.< cell grapheme # style

[2.3279]

[2.3324]

   write (x,y) = c %.< cell (grapheme a) # style a

Replacement in test/Demo.hs at line 112 [2.135]
B:BD[2.3353] → [2.3353:3372]
```
      a = node n v
```
[2.3353]
[2.3372]
```
      a = node v n
```

Replacement in test/Demo.hs at line 125 [2.135]

B:BD[2.3762] → [2.3762:3911]

      grapheme :: Char
         | None     <- a = '∙'
         | Wall     <- a = '#'
         | Box      <- a = 'o'
         | Robot {} <- a = '@'

[2.3762]

[2.3911]

   canvas :: Plane
   canvas = blankPlane (2 * succ (2 * r) + 2) (succ (2 * r) + 2)

Replacement in test/Demo.hs at line 128 [2.135]

B:BD[2.3912] → [2.3912:4732]

      style :: Draw
         | None     <- a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
         | Wall     <- a = rgbColor $ sRGB24 0x99 0x99 0x99  -- #999999
         | Box      <- a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
         | Robot {} <- a , "@" <- name a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
         | Robot {} <- a , "r" <- name a = rgbColor $ sRGB24 0x99 0x66 0x66  -- #996666
         | Robot {} <- a , "g" <- name a = rgbColor $ sRGB24 0x66 0x99 0x66  -- #669966
         | Robot {} <- a , "b" <- name a = rgbColor $ sRGB24 0x66 0x66 0x99  -- #666699
         | Robot {} <- a , "n" <- name a = rgbColor $ sRGB24 0x99 0x99 0x66  -- #999966
         | Robot {} <- a , "i" <- name a = rgbColor $ sRGB24 0x66 0x99 0x99  -- #669999
         | otherwise = rgbColor $ sRGB24 0x66 0x66 0x66

[2.3912]

[2.4732]

   hex :: Plane
   hex = foldl (&) canvas [ write (x,y) | x <- [-r..r] , y <- [-r..r] , abs (x + y) <= r ]

Replacement in test/Demo.hs at line 133 [2.135]

B:BD[2.4783] → [2.4783:4859]

   ui = foldl (&) canvas [(1,1) % vcat (intersperse (cell ' ') [key,info])]

[2.4783]

[2.4859]

   ui = foldl (&) canvas
      [ (1,1) % vcat (intersperse (cell ' ')
         [ key
         , hcat
            [ scope $ take 1 $ IntMap.keys $ IntMap.filter me $ nodes v
            , cell ' '
            , vcat [word "",info]
            ]
         ])
      ]

Replacement in test/Demo.hs at line 145 [2.135]

B:BD[2.4872] → [2.4872:4937]

      key = word (maybe id (:) c $ toList q) # color Black Vivid

[2.4872]

[2.4937]

      (c,q) = input s

Replacement in test/Demo.hs at line 147 [2.135]

B:BD[2.4938] → [2.4938:4959]

      (c,q) = keys s

[2.4938]

[2.4959]

      key :: Plane
      key = word (maybe id (:) c $ toList q) # color Black Vivid

Replacement in test/Demo.hs at line 150 [2.135]
B:BD[2.4960] → [2.4960:4971]
```
      info
```
[2.4960]
[2.4971]
```
      info :: Plane
```

Insertion in test/Demo.hs at line 154 [2.135]

[2.5108]

   scope :: [Int] -> Plane
   scope n
      | i : _ <- n = foldl (&) (blankPlane 5 3)
         [ (1,2) % let a = adjacents v i Map.! U in cell (grapheme a) # style a
         , (1,4) % let a = adjacents v i Map.! I in cell (grapheme a) # style a
         , (2,1) % let a = adjacents v i Map.! H in cell (grapheme a) # style a
         , (2,3) % let a = node v i in cell (grapheme a)
         , (2,5) % let a = adjacents v i Map.! L in cell (grapheme a) # style a
         , (3,2) % let a = adjacents v i Map.! N in cell (grapheme a) # style a
         , (3,4) % let a = adjacents v i Map.! M in cell (grapheme a) # style a
         ]
      | otherwise = blankPlane 5 3
-- render
grapheme :: Unit -> Char
grapheme a
   | None     <- a = '∙'
   | Wall     <- a = '#'
   | Box      <- a = 'o'
   | Robot {} <- a = '@'
style :: Unit -> Draw
style a
   | None     <- a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
   | Wall     <- a = rgbColor $ sRGB24 0x99 0x99 0x99  -- #999999
   | Box      <- a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
   | Robot {} <- a , "@"   <- name a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666
   | Robot {} <- a , "r"   <- name a = rgbColor $ sRGB24 0x66 0x66 0x99  -- #666699
   | Robot {} <- a , "g"   <- name a = rgbColor $ sRGB24 0x99 0x66 0x99  -- #996699
   | Robot {} <- a , "b"   <- name a = rgbColor $ sRGB24 0x99 0x66 0x66  -- #996666
   | Robot {} <- a , "n"   <- name a = rgbColor $ sRGB24 0x99 0x99 0x66  -- #999966
   | Robot {} <- a , "i"   <- name a = rgbColor $ sRGB24 0x66 0x99 0x66  -- #669966
   | Robot {} <- a , 'L':_ <- name a = rgbColor $ sRGB24 0x66 0x99 0x99  -- #669999
   | otherwise = rgbColor $ sRGB24 0x66 0x66 0x66

Replacement in test/Demo.hs at line 207 [2.135]

B:BD[2.5371] → [2.5371:5602]

   me'
      | Just 'h' <- fst $ keys s = u { ops = [Move H] }
      | Just 'j' <- fst $ keys s = u { ops = [Move N] }
      | Just 'k' <- fst $ keys s = u { ops = [Move I] }
      | Just 'l' <- fst $ keys s = u { ops = [Move L] }

[2.5371]

[2.5602]

   me' :: Unit
      | Just 'h' <- fst $ input s = u { ops = [Move H] }
      | Just 'j' <- fst $ input s = u { ops = [Move N] }
      | Just 'k' <- fst $ input s = u { ops = [Move I] }
      | Just 'l' <- fst $ input s = u { ops = [Move L] }

Replacement in src/Nove/Verse.hs at line 3 [2.6595]

B:BD[2.6621] → [2.6621:6703]

import Data.IntMap as IntMap ( IntMap, fromDistinctAscList, (!), adjust, insert )

[2.6621]

[2.6703]

import Zero ( total )

Insertion in src/Nove/Verse.hs at line 5 [2.6595]

[2.6730]

import Data.IntMap as IntMap ( IntMap, fromDistinctAscList, (!), adjust, insert )
import Data.Map as Map ( Map, fromList )

Replacement in src/Nove/Verse.hs at line 90 [2.6595]

B:BD[2.9156] → [2.9156:9174]

-- | Manipulation

[2.9156]

[2.9174]

node :: Atom a => Verse a -> Int -> a
node v i = nodes v IntMap.! i
adjacents :: Atom a => Verse a -> Int -> Map Dir a
adjacents v i = Map.fromList [(dir , node v (shift v 1 dir i)) | dir <- total]

Replacement in src/Nove/Verse.hs at line 96 [2.6595]
B:BD[2.9175] → [2.9175:9243]
```
node :: Atom a => Int -> Verse a -> a
node i v = nodes v IntMap.! i
```
[2.9175]
[2.9243]
```
-- | Manipulation
```
Replacement in src/Nove/Logic.hs at line 5 [2.10194]
B:BD[2.10239] → [2.10239:10268]
```
import Zero ( total, floyd )
```
[2.10239]
[2.10268]
```
import Zero ( floyd )
```
Replacement in src/Nove/Logic.hs at line 7 [2.10194]
B:BD[2.10348] → [2.10348:10394]
```
import Data.Map as Map ( Map, fromList, (!) )
```
[2.10348]
[2.10394]
```
import Data.Map as Map ( Map, (!), filterWithKey, keys )
```

Replacement in src/Nove/Logic.hs at line 33 [2.10194]

B:BD[2.10982] → [2.10982:11082]

      ns :: Map Dir a
      ns = fromList [(dir , nodes v IntMap.! shift v 1 dir i) | dir <- total]

[2.10982]

[2.11082]

      ns = adjacents v i

Replacement in src/Nove/Logic.hs at line 49 [2.10194]

B:BD[2.11418] → [2.11418:11517]

      mvin = filter (\dir -> move (nodes v IntMap.! shift v 1 dir i) == Just (opposite dir)) total

[2.11418]

[2.11517]

      mvin = Map.keys $ Map.filterWithKey (\k w -> move w == Just (opposite k)) ns

Replacement in src/Nove/Logic.hs at line 55 [2.10194]

B:BD[2.11675] → [2.11675:11836]

         | Just (_,d) <- floyd $ i : dest = i == d  -- loops back to itself , floyd $ cycle [0,1] => Just (2,1) , so (i /= d) which means stall when reciprocal)

[2.11675]

[2.11836]

         | Just (_,d) <- floyd $ i : dest = False  -- i == d  -- loops back to itself , floyd $ cycle [0,1] => Just (2,1) , so (i /= d) which means stall when reciprocal)
      -- ^temporary