@explorable-viz/fluid 0.8.0 → 0.8.1

package/dist/fluid/shared/fluid.mjs

@@ -122,6 +122,23 @@ var arrayMap = function(f) {
 // output-es/Data.Functor/index.js
 var functorArray = { map: arrayMap };
 
+// output-es/Control.Apply/foreign.js
+var arrayApply = function(fs) {
+  return function(xs) {
+    var l = fs.length;
+    var k = xs.length;
+    var result = new Array(l * k);
+    var n = 0;
+    for (var i = 0; i < l; i++) {
+      var f = fs[i];
+      for (var j = 0; j < k; j++) {
+        result[n++] = f(xs[j]);
+      }
+    }
+    return result;
+  };
+};
+
 // output-es/Control.Apply/index.js
 var identity = (x) => x;
 
@@ -289,15 +306,7 @@ var applyMaybe = {
   },
   Functor0: () => functorMaybe
 };
-var altMaybe = {
-  alt: (v) => (v1) => {
-    if (v.tag === "Nothing") {
-      return v1;
-    }
-    return v;
-  },
-  Functor0: () => functorMaybe
-};
+var applicativeMaybe = { pure: Just, Apply0: () => applyMaybe };
 
 // output-es/Data.Either/index.js
 var $Either = (tag, _1) => ({ tag, _1 });
@@ -603,6 +612,12 @@ var lookup = (dictFoldable) => {
     return Nothing;
   });
 };
+var find = (dictFoldable) => (p) => dictFoldable.foldl((v) => (v1) => {
+  if (v.tag === "Nothing" && p(v1)) {
+    return $Maybe("Just", v1);
+  }
+  return v;
+})(Nothing);
 
 // output-es/Data.Eq/foreign.js
 var refEq = function(r1) {
@@ -1010,6 +1025,7 @@ var groupBy = (op) => (xs) => {
   })();
   return result;
 };
+var foldM = (dictMonad) => (f) => (b) => unconsImpl((v) => dictMonad.Applicative0().pure(b))((a) => (as) => dictMonad.Bind1().bind(f(b)(a))((b$p) => foldM(dictMonad)(f)(b$p)(as)));
 var findIndex = /* @__PURE__ */ findIndexImpl(Just)(Nothing);
 var notElem = (dictEq) => (a) => (arr) => {
   const $0 = findIndex((v) => dictEq.eq(v)(a))(arr);
@@ -1256,7 +1272,7 @@ var foldableNonEmptyList = {
   foldr: (f) => (b) => (v) => f(v._1)(foldableList.foldr(f)(b)(v._2))
 };
 var showList = (dictShow) => {
-  const show4 = dictShow.show;
+  const show5 = dictShow.show;
   return {
     show: (v) => {
       if (v.tag === "Nil") {
@@ -1280,7 +1296,7 @@ var showList = (dictShow) => {
         }
         return go$r;
       };
-      return "(" + go({ init: true, acc: "" })(listMap(show4)(v)).acc + " : Nil)";
+      return "(" + go({ init: true, acc: "" })(listMap(show5)(v)).acc + " : Nil)";
     }
   };
 };
@@ -3098,6 +3114,16 @@ var groupBy2 = (v) => (v1) => {
   }
   fail();
 };
+var foldM2 = (dictMonad) => (v) => (v1) => (v2) => {
+  if (v2.tag === "Nil") {
+    return dictMonad.Applicative0().pure(v1);
+  }
+  if (v2.tag === "Cons") {
+    const $0 = v2._2;
+    return dictMonad.Bind1().bind(v(v1)(v2._1))((b$p) => foldM2(dictMonad)(v)(b$p)($0));
+  }
+  fail();
+};
 var drop3 = (drop$a0$copy) => (drop$a1$copy) => {
   let drop$a0 = drop$a0$copy, drop$a1 = drop$a1$copy, drop$c = true, drop$r;
   while (drop$c) {
@@ -3331,7 +3357,10 @@ var replicate2 = (dictUnfoldable) => (n) => (v) => dictUnfoldable.unfoldr((i) =>
 var $KickUp = (_1, _2, _3, _4) => ({ tag: "KickUp", _1, _2, _3, _4 });
 var $$$Map = (tag, _1, _2, _3, _4, _5, _6, _7) => ({ tag, _1, _2, _3, _4, _5, _6, _7 });
 var $TreeContext = (tag, _1, _2, _3, _4, _5, _6) => ({ tag, _1, _2, _3, _4, _5, _6 });
+var identity9 = (x) => x;
 var Leaf2 = /* @__PURE__ */ $$$Map("Leaf");
+var Two = (value0) => (value1) => (value2) => (value3) => $$$Map("Two", value0, value1, value2, value3);
+var Three = (value0) => (value1) => (value2) => (value3) => (value4) => (value5) => (value6) => $$$Map("Three", value0, value1, value2, value3, value4, value5, value6);
 var size = (v) => {
   if (v.tag === "Leaf") {
     return 0;
@@ -3450,6 +3479,20 @@ var lookup2 = (dictOrd) => (k) => {
   };
   return go;
 };
+var functorMap = {
+  map: (v) => (v1) => {
+    if (v1.tag === "Leaf") {
+      return Leaf2;
+    }
+    if (v1.tag === "Two") {
+      return $$$Map("Two", functorMap.map(v)(v1._1), v1._2, v(v1._3), functorMap.map(v)(v1._4));
+    }
+    if (v1.tag === "Three") {
+      return $$$Map("Three", functorMap.map(v)(v1._1), v1._2, v(v1._3), functorMap.map(v)(v1._4), v1._5, v(v1._6), functorMap.map(v)(v1._7));
+    }
+    fail();
+  }
+};
 var fromZipper = (fromZipper$a0$copy) => (fromZipper$a1$copy) => (fromZipper$a2$copy) => {
   let fromZipper$a0 = fromZipper$a0$copy, fromZipper$a1 = fromZipper$a1$copy, fromZipper$a2 = fromZipper$a2$copy, fromZipper$c = true, fromZipper$r;
   while (fromZipper$c) {
@@ -4236,6 +4279,27 @@ var foldableWithIndexMap = {
   },
   Foldable0: () => foldableMap
 };
+var traversableMap = {
+  traverse: (dictApplicative) => {
+    const Apply0 = dictApplicative.Apply0();
+    const $0 = Apply0.Functor0();
+    return (v) => (v1) => {
+      if (v1.tag === "Leaf") {
+        return dictApplicative.pure(Leaf2);
+      }
+      if (v1.tag === "Two") {
+        return Apply0.apply(Apply0.apply(Apply0.apply($0.map(Two)(traversableMap.traverse(dictApplicative)(v)(v1._1)))(dictApplicative.pure(v1._2)))(v(v1._3)))(traversableMap.traverse(dictApplicative)(v)(v1._4));
+      }
+      if (v1.tag === "Three") {
+        return Apply0.apply(Apply0.apply(Apply0.apply(Apply0.apply(Apply0.apply(Apply0.apply($0.map(Three)(traversableMap.traverse(dictApplicative)(v)(v1._1)))(dictApplicative.pure(v1._2)))(v(v1._3)))(traversableMap.traverse(dictApplicative)(v)(v1._4)))(dictApplicative.pure(v1._5)))(v(v1._6)))(traversableMap.traverse(dictApplicative)(v)(v1._7));
+      }
+      fail();
+    };
+  },
+  sequence: (dictApplicative) => traversableMap.traverse(dictApplicative)(identity9),
+  Functor0: () => functorMap,
+  Foldable1: () => foldableMap
+};
 var findMin = /* @__PURE__ */ (() => {
   const go = (go$a0$copy) => (go$a1$copy) => {
     let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
@@ -4268,10 +4332,10 @@ var eqMap = (dictEq) => (dictEq1) => {
 };
 var fromFoldable = (dictOrd) => (dictFoldable) => dictFoldable.foldl((m) => (v) => insert(dictOrd)(v._1)(v._2)(m))(Leaf2);
 var filterWithKey = (dictOrd) => {
-  const fromFoldable112 = fromFoldable(dictOrd)(foldableList2);
+  const fromFoldable111 = fromFoldable(dictOrd)(foldableList2);
   return (predicate) => {
     const $0 = filter2((v) => predicate(v._1)(v._2));
-    return (x) => fromFoldable112($0(toUnfoldable3(unfoldableList2)(x)));
+    return (x) => fromFoldable111($0(toUnfoldable3(unfoldableList2)(x)));
   };
 };
 var $$delete = (dictOrd) => (k) => (m) => {
@@ -9679,7 +9743,7 @@ var keys = Object.keys || toArrayWithKey(function(k) {
 });
 
 // output-es/Foreign.Object/index.js
-var identity9 = (x) => x;
+var identity10 = (x) => x;
 var values = /* @__PURE__ */ toArrayWithKey((v) => (v1) => v1);
 var toAscUnfoldable = (dictUnfoldable) => {
   const $0 = sortWith(ordString)(fst);
@@ -9708,20 +9772,20 @@ var insert2 = (k) => (v) => mutate(($0) => () => {
 var functorObject = { map: (f) => (m) => _fmapObject(m, f) };
 var functorWithIndexObject = { mapWithIndex: mapWithKey, Functor0: () => functorObject };
 var fromFoldable2 = (dictFoldable) => {
-  const fromFoldable112 = fromFoldableImpl(dictFoldable.foldr);
+  const fromFoldable111 = fromFoldableImpl(dictFoldable.foldr);
   return (l) => {
     const s = {};
-    for (const v of fromFoldable112(l)) {
+    for (const v of fromFoldable111(l)) {
       s[v._1] = v._2;
     }
     return s;
   };
 };
-var foldM = (dictMonad) => {
+var foldM3 = (dictMonad) => {
   const bind12 = dictMonad.Bind1().bind;
   return (f) => (z) => _foldM(bind12)(f)(dictMonad.Applicative0().pure(z));
 };
-var foldM1 = /* @__PURE__ */ foldM(monadST);
+var foldM1 = /* @__PURE__ */ foldM3(monadST);
 var union2 = (m) => mutate((s) => foldM1((s$p) => (k) => (v) => () => {
   s$p[k] = v;
   return s$p;
@@ -9769,7 +9833,7 @@ var traversableObject = {
     const $0 = traversableWithIndexObject.traverseWithIndex(dictApplicative);
     return (x) => $0((v) => x);
   },
-  sequence: (dictApplicative) => traversableObject.traverse(dictApplicative)(identity9),
+  sequence: (dictApplicative) => traversableObject.traverse(dictApplicative)(identity10),
   Functor0: () => functorObject,
   Foldable1: () => foldableObject
 };
@@ -9982,7 +10046,7 @@ var intercalate2 = (sep) => (xs) => {
   };
   return go({ init: true, acc: Nil })(xs).acc;
 };
-var identity12 = (x) => x;
+var identity13 = (x) => x;
 var isEmptySet = { isEmpty };
 var isEmptyObject = { isEmpty: isEmpty2 };
 var $$throw = (dictMonadThrow) => (x) => dictMonadThrow.throwError(error(x));
@@ -10082,13 +10146,13 @@ var bind2Flipped = (dictMonad) => {
 };
 var assertWith = (v) => (v1) => {
   if (v1) {
-    return identity12;
+    return identity13;
   }
   return (v2) => throwException(error("Assertion failure: " + v))();
 };
 var assertWhen = (v) => (v1) => {
   if (!v) {
-    return (v$1) => identity12;
+    return (v$1) => identity13;
   }
   if (v) {
     return (x) => assertWith(v1)(x());
@@ -10135,7 +10199,7 @@ function intersectionWith_Object(f) {
 }
 
 // output-es/Util.Map/index.js
-var identity13 = (x) => x;
+var identity14 = (x) => x;
 var mapObjectString = {
   maplet: singleton2,
   keys: /* @__PURE__ */ (() => {
@@ -10170,9 +10234,9 @@ var mapFObjectString = {
   mapWithKey
 };
 var asMaplet = (dictMap) => {
-  const toUnfoldable16 = dictMap.toUnfoldable(unfoldableList);
+  const toUnfoldable15 = dictMap.toUnfoldable(unfoldableList);
   return (m) => assertWith("")(dictMap.Set0().size(m) === 1)(definitely("singleton map")((() => {
-    const $0 = toUnfoldable16(m);
+    const $0 = toUnfoldable15(m);
     if ($0.tag === "Nil") {
       return Nothing;
     }
@@ -10287,7 +10351,7 @@ var checkArity = (dictMonadError) => {
 };
 
 // output-es/Dict/index.js
-var identity14 = (x) => x;
+var identity15 = (x) => x;
 var isEmptyDict = { isEmpty: (v) => isEmpty2(v) };
 var setDictString = {
   empty,
@@ -10340,7 +10404,7 @@ var traversableDict = {
     const $0 = traversableWithIndexObject.traverseWithIndex(dictApplicative);
     return (f) => (m) => dictApplicative.Apply0().Functor0().map((v1) => v1)($0((v) => f)(m));
   },
-  sequence: (dictApplicative) => (v) => traversableDict.traverse(dictApplicative)(identity14)(v),
+  sequence: (dictApplicative) => (v) => traversableDict.traverse(dictApplicative)(identity15)(v),
   Functor0: () => functorDict,
   Foldable1: () => foldableDict
 };
@@ -10464,9 +10528,9 @@ var toTuple = (v) => $Tuple(v._1, v._2);
 var unzip3 = (xys) => unzip(listMap(toTuple)(xys));
 
 // output-es/Lattice/index.js
-var identity15 = (x) => x;
-var meetSemilatticeUnit = { meet: (v) => identity15 };
-var joinSemilatticeUnit = { join: (v) => identity15 };
+var identity16 = (x) => x;
+var meetSemilatticeUnit = { meet: (v) => identity16 };
+var joinSemilatticeUnit = { join: (v) => identity16 };
 var boundedMeetSemilatticeUni = { top: void 0, MeetSemilattice0: () => meetSemilatticeUnit };
 var boundedJoinSemilatticeUni = { bot: void 0, JoinSemilattice0: () => joinSemilatticeUnit };
 
@@ -10494,7 +10558,7 @@ var unions = /* @__PURE__ */ (() => {
   };
   return go(Leaf2);
 })();
-var identity16 = (x) => x;
+var identity17 = (x) => x;
 var Unquote = (value0) => $DocCommentElem("Unquote", value0);
 var None = /* @__PURE__ */ $DocOpt("None");
 var Doc = (value0) => $DocOpt("Doc", value0);
@@ -10701,18 +10765,18 @@ var traversableDocCommentElem = (dictTraversable) => {
   };
   return {
     traverse: (dictApplicative) => {
-      const traverse2 = dictTraversable.traverse(dictApplicative);
+      const traverse22 = dictTraversable.traverse(dictApplicative);
       return (f) => (m) => {
         if (m.tag === "Token") {
           return dictApplicative.pure($DocCommentElem("Token", m._1));
         }
         if (m.tag === "Unquote") {
-          return dictApplicative.Apply0().Functor0().map((v1) => $DocCommentElem("Unquote", v1))(traverse2(f)(m._1));
+          return dictApplicative.Apply0().Functor0().map((v1) => $DocCommentElem("Unquote", v1))(traverse22(f)(m._1));
         }
         fail();
       };
     },
-    sequence: (dictApplicative) => (v) => traversableDocCommentElem(dictTraversable).traverse(dictApplicative)(identity16)(v),
+    sequence: (dictApplicative) => (v) => traversableDocCommentElem(dictTraversable).traverse(dictApplicative)(identity17)(v),
     Functor0: () => functorDocCommentElem1,
     Foldable1: () => foldableDocCommentElem1
   };
@@ -10722,19 +10786,19 @@ var traversableDocOpt = (dictTraversable) => {
   const foldableDocOpt1 = foldableDocOpt(dictTraversable.Foldable1());
   return {
     traverse: (dictApplicative) => {
-      const traverse2 = traversableList.traverse(dictApplicative);
+      const traverse22 = traversableList.traverse(dictApplicative);
       const traverse3 = traversableDocCommentElem(dictTraversable).traverse(dictApplicative);
       return (f) => (m) => {
         if (m.tag === "None") {
           return dictApplicative.pure(None);
         }
         if (m.tag === "Doc") {
-          return dictApplicative.Apply0().Functor0().map((v1) => $DocOpt("Doc", v1))(traverse2(traverse3(f))(m._1));
+          return dictApplicative.Apply0().Functor0().map((v1) => $DocOpt("Doc", v1))(traverse22(traverse3(f))(m._1));
         }
         fail();
       };
     },
-    sequence: (dictApplicative) => (v) => traversableDocOpt(dictTraversable).traverse(dictApplicative)(identity16)(v),
+    sequence: (dictApplicative) => (v) => traversableDocOpt(dictTraversable).traverse(dictApplicative)(identity17)(v),
     Functor0: () => functorDocOpt1,
     Foldable1: () => foldableDocOpt1
   };
@@ -10768,7 +10832,7 @@ var unions12 = /* @__PURE__ */ (() => {
   };
   return go(Leaf2);
 })();
-var identity17 = (x) => x;
+var identity18 = (x) => x;
 var setSet2 = /* @__PURE__ */ setSet(ordString);
 var fromFoldable5 = /* @__PURE__ */ (() => foldableSet.foldl((m) => (a) => insert(ordString)(a)()(m))(Leaf2))();
 var unions3 = /* @__PURE__ */ (() => {
@@ -11279,7 +11343,7 @@ var traversableVarDef = {
     const Apply0 = dictApplicative.Apply0();
     return (f) => (m) => Apply0.apply(Apply0.Functor0().map((v2) => (v3) => $VarDef(v2, v3))(traversableElim.traverse(dictApplicative)(f)(m._1)))(traversableExpr.traverse(dictApplicative)(f)(m._2));
   },
-  sequence: (dictApplicative) => (v) => traversableVarDef.traverse(dictApplicative)(identity17)(v),
+  sequence: (dictApplicative) => (v) => traversableVarDef.traverse(dictApplicative)(identity18)(v),
   Functor0: () => functorVarDef,
   Foldable1: () => foldableVarDef
 };
@@ -11289,7 +11353,7 @@ var traversableRecDefs = {
     const traverse5 = traversableDict.traverse(dictApplicative);
     return (f) => (m) => Apply0.apply(Apply0.Functor0().map((v2) => (v3) => $RecDefs(v2, v3))(f(m._1)))(traverse5(traversableElim.traverse(dictApplicative)(f))(m._2));
   },
-  sequence: (dictApplicative) => (v) => traversableRecDefs.traverse(dictApplicative)(identity17)(v),
+  sequence: (dictApplicative) => (v) => traversableRecDefs.traverse(dictApplicative)(identity18)(v),
   Functor0: () => functorRecDefs,
   Foldable1: () => foldableRecDefs
 };
@@ -11351,7 +11415,7 @@ var traversableExpr = {
       fail();
     };
   },
-  sequence: (dictApplicative) => (v) => traversableExpr.traverse(dictApplicative)(identity17)(v),
+  sequence: (dictApplicative) => (v) => traversableExpr.traverse(dictApplicative)(identity18)(v),
   Functor0: () => functorExpr,
   Foldable1: () => foldableExpr
 };
@@ -11374,7 +11438,7 @@ var traversableElim = {
       fail();
     };
   },
-  sequence: (dictApplicative) => (v) => traversableElim.traverse(dictApplicative)(identity17)(v),
+  sequence: (dictApplicative) => (v) => traversableElim.traverse(dictApplicative)(identity18)(v),
   Functor0: () => functorElim,
   Foldable1: () => foldableElim
 };
@@ -11391,7 +11455,7 @@ var traversableCont = {
       fail();
     };
   },
-  sequence: (dictApplicative) => (v) => traversableCont.traverse(dictApplicative)(identity17)(v),
+  sequence: (dictApplicative) => (v) => traversableCont.traverse(dictApplicative)(identity18)(v),
   Functor0: () => functorCont,
   Foldable1: () => foldableCont
 };
@@ -12251,7 +12315,7 @@ var bwdSlice = (dictGraph) => {
 };
 
 // output-es/Data.Profunctor.Choice/index.js
-var identity18 = (x) => x;
+var identity19 = (x) => x;
 var fanin = (dictCategory) => {
   const identity1 = dictCategory.identity;
   const $0 = dictCategory.Semigroupoid0();
@@ -12264,7 +12328,7 @@ var fanin = (dictCategory) => {
       return v2._1;
     }
     fail();
-  })(identity18)(identity1))($1.compose(dictChoice.right(r))(dictChoice.left(l)));
+  })(identity19)(identity1))($1.compose(dictChoice.right(r))(dictChoice.left(l)));
 };
 var choiceFn = /* @__PURE__ */ (() => ({
   left: (v) => (v1) => {
@@ -12908,7 +12972,7 @@ var between = (open2) => (close2) => (p) => (state1, more, lift12, $$throw2, don
 var $Assoc = (tag) => tag;
 var $Operator = (tag, _1, _2) => ({ tag, _1, _2 });
 var choice2 = /* @__PURE__ */ choice(foldableList);
-var identity19 = (x) => x;
+var identity20 = (x) => x;
 var AssocNone = /* @__PURE__ */ $Assoc("AssocNone");
 var AssocLeft = /* @__PURE__ */ $Assoc("AssocLeft");
 var AssocRight = /* @__PURE__ */ $Assoc("AssocRight");
@@ -13089,7 +13153,7 @@ var makeParser = (term) => (ops) => {
               if ($7) {
                 return $22(v4, $6);
               }
-              return $32(v2$1, identity19);
+              return $32(v2$1, identity20);
             });
           },
           $32
@@ -13107,7 +13171,7 @@ var makeParser = (term) => (ops) => {
               if ($7) {
                 return $22(v4, $6);
               }
-              return $32(v2$1, identity19);
+              return $32(v2$1, identity20);
             });
           },
           $32
@@ -13126,7 +13190,7 @@ var makeParser = (term) => (ops) => {
               if ($8) {
                 return $32(v4, $7);
               }
-              return $42(v2$1, identity19);
+              return $42(v2$1, identity20);
             });
           },
           $42
@@ -13144,7 +13208,7 @@ var makeParser = (term) => (ops) => {
               if ($8) {
                 return $32(v4, $7);
               }
-              return $42(v2$1, identity19);
+              return $42(v2$1, identity20);
             });
           },
           $42
@@ -13163,7 +13227,7 @@ var makeParser = (term) => (ops) => {
               if ($9) {
                 return $42(v4, $8);
               }
-              return $52(v2$1, identity19);
+              return $52(v2$1, identity20);
             });
           },
           $52
@@ -13181,7 +13245,7 @@ var makeParser = (term) => (ops) => {
               if ($9) {
                 return $42(v4, $8);
               }
-              return $52(v2$1, identity19);
+              return $52(v2$1, identity20);
             });
           },
           $52
@@ -13276,7 +13340,7 @@ var makeParser = (term) => (ops) => {
             if ($5) {
               return $$throw2(v4, $4);
             }
-            return $1(state1, identity19);
+            return $1(state1, identity20);
           });
         },
         $1
@@ -15851,13 +15915,13 @@ var varDefFwd = (dictMonadError) => {
 };
 var recDefsFwd = (dictMonadError) => {
   const Monad0 = dictMonadError.MonadThrow0().Monad0();
-  const traverse2 = traversableNonEmptyList.traverse(Monad0.Applicative0());
+  const traverse22 = traversableNonEmptyList.traverse(Monad0.Applicative0());
   return (dictBoundedLattice) => {
     const top = dictBoundedLattice.BoundedMeetSemilattice1().top;
     return (xcs) => Monad0.Bind1().Apply0().Functor0().map((() => {
       const $0 = RecDefs(top);
       return (x) => $0(fromFoldable16(x));
-    })())(traverse2(recDefFwd(dictMonadError)(dictBoundedLattice))((() => {
+    })())(traverse22(recDefFwd(dictMonadError)(dictBoundedLattice))((() => {
       const $0 = wrappedOperation("groupBy")(groupBy2((x) => (y) => x._1 === y._1))(xcs);
       return $NonEmpty($0._1, listMap(RecDef)($0._2));
     })()));
@@ -16059,7 +16123,7 @@ var exprFwd = (dictBoundedLattice) => {
     const Bind1 = Monad0.Bind1();
     const Apply0 = Bind1.Apply0();
     const Functor0 = Apply0.Functor0();
-    const traverse2 = traversableList.traverse(Applicative0);
+    const traverse22 = traversableList.traverse(Applicative0);
     return (dictJoinSemilattice) => (v) => {
       if (v.tag === "Var") {
         return Applicative0.pure($Expr("Var", v._1));
@@ -16086,14 +16150,14 @@ var exprFwd = (dictBoundedLattice) => {
         const $0 = v._3;
         const $1 = v._4;
         const $2 = v._1;
-        return Bind1.bind(desugComment(dictBoundedLattice)(dictMonadError)(v._2))((edoc) => Functor0.map(Constr($2)(edoc)($0))(traverse2(exprFwd(dictBoundedLattice)(dictMonadError)(dictBoundedLattice.BoundedJoinSemilattice0().JoinSemilattice0()))($1)));
+        return Bind1.bind(desugComment(dictBoundedLattice)(dictMonadError)(v._2))((edoc) => Functor0.map(Constr($2)(edoc)($0))(traverse22(exprFwd(dictBoundedLattice)(dictMonadError)(dictBoundedLattice.BoundedJoinSemilattice0().JoinSemilattice0()))($1)));
       }
       if (v.tag === "Dictionary") {
         const $0 = v._2;
         const $1 = v._1;
         const v1 = unzip(v._3);
         const $2 = v1._2;
-        return Bind1.bind(traverse2(desugarableDictEntryExpr.desug(dictMonadError)(dictBoundedLattice))(v1._1))((ks$p) => Bind1.bind(traverse2(exprFwd(dictBoundedLattice)(dictMonadError)(dictBoundedLattice.BoundedJoinSemilattice0().JoinSemilattice0()))($2))((es) => Bind1.bind(desugComment(dictBoundedLattice)(dictMonadError)($0))((edoc) => Functor0.map(Dictionary($1)(edoc))(Applicative0.pure(zipWith2((k) => (v2) => $Pair(
+        return Bind1.bind(traverse22(desugarableDictEntryExpr.desug(dictMonadError)(dictBoundedLattice))(v1._1))((ks$p) => Bind1.bind(traverse22(exprFwd(dictBoundedLattice)(dictMonadError)(dictBoundedLattice.BoundedJoinSemilattice0().JoinSemilattice0()))($2))((es) => Bind1.bind(desugComment(dictBoundedLattice)(dictMonadError)($0))((edoc) => Functor0.map(Dictionary($1)(edoc))(Applicative0.pure(zipWith2((k) => (v2) => $Pair(
           k,
           v2
         ))(ks$p)(es))))));
@@ -16628,11 +16692,11 @@ var moduleFwd = (dictMonadError) => {
   const $0 = Monad0.Bind1().Apply0().Functor0();
   const varDefFwd1 = varDefFwd(dictMonadError);
   const recDefsFwd1 = recDefsFwd(dictMonadError);
-  const traverse2 = traversableList.traverse(Monad0.Applicative0());
+  const traverse22 = traversableList.traverse(Monad0.Applicative0());
   return (dictBoundedLattice) => {
     const varDefFwd2 = varDefFwd1(dictBoundedLattice);
     const recDefsFwd2 = recDefsFwd1(dictBoundedLattice);
-    return (v) => $0.map(Module)(traverse2((v1) => {
+    return (v) => $0.map(Module)(traverse22((v1) => {
       if (v1.tag === "Left") {
         return $0.map(Left)(varDefFwd2(v1._1));
       }
@@ -16729,7 +16793,7 @@ var toUnfoldable13 = /* @__PURE__ */ toAscUnfoldable(unfoldableList);
 var Simple = /* @__PURE__ */ $ExprType("Simple");
 var Expression = /* @__PURE__ */ $ExprType("Expression");
 var vert = (dictFoldable) => {
-  const fromFoldable27 = dictFoldable.foldr(Cons)(Nil);
+  const fromFoldable26 = dictFoldable.foldr(Cons)(Nil);
   return (delim) => {
     const vert$p = (v) => {
       if (v.tag === "Nil") {
@@ -16745,7 +16809,7 @@ var vert = (dictFoldable) => {
       }
       fail();
     };
-    return (x) => vert$p(fromFoldable27(x));
+    return (x) => vert$p(fromFoldable26(x));
   };
 };
 var vert1 = /* @__PURE__ */ vert(foldableArray);
@@ -17474,7 +17538,7 @@ var unions13 = /* @__PURE__ */ (() => {
   return go(Leaf2);
 })();
 var foldMap2 = /* @__PURE__ */ foldMap({ mempty: Leaf2, Semigroup0: () => ({ append: union(ordDVertex$p) }) });
-var identity22 = (x) => x;
+var identity23 = (x) => x;
 var boundedLattice = { BoundedJoinSemilattice0: () => boundedJoinSemilatticeUni, BoundedMeetSemilattice1: () => boundedMeetSemilatticeUni };
 var setSet1 = /* @__PURE__ */ setSet(ordString);
 var toUnfoldable14 = /* @__PURE__ */ toUnfoldable4(unfoldableList);
@@ -17600,7 +17664,7 @@ var mapEnvStringVal = {
 var highlightableVertex = {
   highlightIf: (v) => (doc) => beside(beside(doc)(checkOneLine(split("\n")(" _"))))(checkOneLine(split("\n")(" \u27E8" + v + "\u27E9")))
 };
-var highlightableUnit = { highlightIf: (v) => identity22 };
+var highlightableUnit = { highlightIf: (v) => identity23 };
 var functorMatrixDim = { map: (f) => (m) => $Tuple(m._1, f(m._2)) };
 var functorVal = { map: (f) => (m) => $Val(f(m._1), functorDocOpt(functorVal).map(f)(m._2), functorBaseVal.map(f)(m._3)) };
 var functorMatrixRep = {
@@ -17654,7 +17718,7 @@ var functorBaseVal = {
 var foldableMatrixDim = { foldl: (f) => (z) => (m) => f(z)(m._2), foldr: (f) => (z) => (m) => f(m._2)(z), foldMap: (dictMonoid) => (f) => (m) => f(m._2) };
 var traversableMatrixDim = {
   traverse: (dictApplicative) => (f) => (m) => dictApplicative.Apply0().Functor0().map((v1) => v1)(traversableTuple.traverse(dictApplicative)(f)(m)),
-  sequence: (dictApplicative) => (v) => traversableMatrixDim.traverse(dictApplicative)(identity22)(v),
+  sequence: (dictApplicative) => (v) => traversableMatrixDim.traverse(dictApplicative)(identity23)(v),
   Functor0: () => functorMatrixDim,
   Foldable1: () => foldableMatrixDim
 };
@@ -17871,7 +17935,7 @@ var traversableVal = {
     const Apply0 = dictApplicative.Apply0();
     return (f) => (m) => Apply0.apply(Apply0.apply(Apply0.Functor0().map((v3) => (v4) => (v5) => $Val(v3, v4, v5))(f(m._1)))(traversableDocOpt(traversableVal).traverse(dictApplicative)(f)(m._2)))(traversableBaseVal.traverse(dictApplicative)(f)(m._3));
   },
-  sequence: (dictApplicative) => (v) => traversableVal.traverse(dictApplicative)(identity22)(v),
+  sequence: (dictApplicative) => (v) => traversableVal.traverse(dictApplicative)(identity23)(v),
   Functor0: () => functorVal,
   Foldable1: () => foldableVal
 };
@@ -17907,7 +17971,7 @@ var traversableFun = {
       fail();
     };
   },
-  sequence: (dictApplicative) => (v) => traversableFun.traverse(dictApplicative)(identity22)(v),
+  sequence: (dictApplicative) => (v) => traversableFun.traverse(dictApplicative)(identity23)(v),
   Functor0: () => functorFun,
   Foldable1: () => foldableFun
 };
@@ -17916,7 +17980,7 @@ var traversableEnv = {
     const traverse8 = traversableDict.traverse(dictApplicative);
     return (f) => (m) => dictApplicative.Apply0().Functor0().map((v1) => v1)(traverse8(traversableVal.traverse(dictApplicative)(f))(m));
   },
-  sequence: (dictApplicative) => (v) => traversableEnv.traverse(dictApplicative)(identity22)(v),
+  sequence: (dictApplicative) => (v) => traversableEnv.traverse(dictApplicative)(identity23)(v),
   Functor0: () => functorEnv,
   Foldable1: () => foldableEnv
 };
@@ -17960,7 +18024,7 @@ var traversableBaseVal = {
       fail();
     };
   },
-  sequence: (dictApplicative) => (v) => traversableBaseVal.traverse(dictApplicative)(identity22)(v),
+  sequence: (dictApplicative) => (v) => traversableBaseVal.traverse(dictApplicative)(identity23)(v),
   Functor0: () => functorBaseVal,
   Foldable1: () => foldableBaseVal
 };
@@ -18038,7 +18102,7 @@ var unary = (dictBoundedJoinSemilattice) => {
               arity: 1,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Nil") {
                     const $0 = v._1._2;
                     return $$new((a) => Val(a)($0))($$$Map("Two", Leaf2, v._1._1, void 0, Leaf2))(f.o.pack(f.fwd(f.i.unpack(v._1._3))));
@@ -18187,7 +18251,7 @@ var binaryZero = (dictBoundedJoinSemilattice) => {
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
                     const $0 = f.i.unpack(v._1._3);
                     const $1 = f.i.unpack(v._2._1._3);
@@ -18235,7 +18299,7 @@ var binary = (dictBoundedJoinSemilattice) => {
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
                     return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
                       "Two",
@@ -18299,6 +18363,7 @@ var greaterThanOrEq = /* @__PURE__ */ (() => {
   return (a1) => (a2) => $0.compare(a1)(a2) !== "LT";
 })();
 var show3 = (v) => "(Tuple " + showIntImpl(v._1) + " " + showIntImpl(v._2) + ")";
+var traverse2 = /* @__PURE__ */ (() => traversableList.traverse(applicativeMaybe))();
 var concatM = (dictMonad) => foldableList.foldr((() => {
   const $0 = dictMonad.Bind1();
   return (f) => (g) => (a) => $0.bind(f(a))(g);
@@ -18412,9 +18477,9 @@ var match = (dictMonadWithGraphAlloc) => {
 };
 var closeDefs = (dictMonadWithGraphAlloc) => {
   const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const traverse2 = traversableDict.traverse(Monad0.Applicative0());
+  const traverse2$1 = traversableDict.traverse(Monad0.Applicative0());
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-  return (\u03B3) => (\u03C1) => (\u03B1s) => Monad0.Bind1().Apply0().Functor0().map(Env)(traverse2((\u03C3) => {
+  return (\u03B3) => (\u03C1) => (\u03B1s) => Monad0.Bind1().Apply0().Functor0().map(Env)(traverse2$1((\u03C3) => {
     const \u03C1$p = forDefs(\u03C1)(\u03C3);
     return $$new((a) => Val(a)(None))(\u03B1s)($BaseVal(
       "Fun",
@@ -18436,14 +18501,14 @@ var closeDefs = (dictMonadWithGraphAlloc) => {
 var new$p = (dictMonadWithGraphAlloc) => {
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const fresh = dictMonadWithGraphAlloc.MonadAlloc0().fresh;
-  return (dictMonadReader) => (dictMonadAff) => {
-    const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+  return (dictMonadReader) => {
+    const Monad0 = dictMonadReader.MonadAsk0().Monad0();
     const Bind1 = Monad0.Bind1();
     return (dictLoadFile) => (v) => (v1) => (v2) => (v3) => {
       if (v2.tag === "None") {
         return $$new((\u03B1s$p) => (u$p) => $Val(\u03B1s$p, None, u$p))(v1)(v3);
       }
-      return Bind1.bind(fresh)((\u03B1) => Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
+      return Bind1.bind(fresh)((\u03B1) => Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(v)((() => {
         const $0 = {};
         $0.this = $Val(\u03B1, None, v3);
         return $0;
@@ -18455,8 +18520,8 @@ var new$p = (dictMonadWithGraphAlloc) => {
     };
   };
 };
-var evalDocOpt = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
-  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+var evalDocOpt = (dictMonadWithGraphAlloc) => (dictMonadReader) => {
+  const Monad0 = dictMonadReader.MonadAsk0().Monad0();
   const Applicative0 = Monad0.Applicative0();
   const $0 = Monad0.Bind1().Apply0().Functor0();
   const sequence2 = traversableList.traverse(Applicative0)(identity5);
@@ -18470,7 +18535,7 @@ var evalDocOpt = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff
           return Applicative0.pure($DocCommentElem("Token", v2._1));
         }
         if (v2.tag === "Unquote") {
-          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v2._1)(setSet4.empty));
+          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v2._1)(setSet4.empty));
         }
         fail();
       })(v1._1)));
@@ -18486,13 +18551,13 @@ var $$eval = (dictMonadWithGraphAlloc) => {
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
-  return (dictMonadReader) => (dictMonadAff) => {
-    const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+  return (dictMonadReader) => {
+    const Monad0 = dictMonadReader.MonadAsk0().Monad0();
     const Bind1 = Monad0.Bind1();
     const $0 = Bind1.Apply0().Functor0();
     const Applicative0 = Monad0.Applicative0();
-    const traverse2 = traversableList.traverse(Applicative0);
-    const traverse3 = traversablePair.traverse(Applicative0);
+    const traverse3 = traversableList.traverse(Applicative0);
+    const traverse4 = traversablePair.traverse(Applicative0);
     const sequence2 = traversableArray.traverse(Applicative0)(identity4);
     return (dictLoadFile) => (v) => (v1) => (v2) => {
       if (v1.tag === "Var") {
@@ -18502,32 +18567,23 @@ var $$eval = (dictMonadWithGraphAlloc) => {
         return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
       }
       if (v1.tag === "Int") {
-        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
-          "Int",
-          v1._3
-        ));
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Int", v1._3));
       }
       if (v1.tag === "Float") {
-        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
-          "Float",
-          v1._3
-        ));
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Float", v1._3));
       }
       if (v1.tag === "Str") {
-        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
-          "Str",
-          v1._3
-        ));
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Str", v1._3));
       }
       if (v1.tag === "Dictionary") {
         const $1 = v1._2;
         const $2 = v1._1;
-        return Bind1.bind($0.map(unzip3)(traverse2(traverse3((() => {
-          const $3 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v);
+        return Bind1.bind($0.map(unzip3)(traverse3(traverse4((() => {
+          const $3 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v);
           return (a) => $3(a)(v2);
         })()))(v1._3)))((v3) => {
           const v4 = unzip(listMap((v$1) => $Tuple(v$1._3.tag === "Str" ? v$1._3._1 : typeError(v$1._3)("Str"), v$1._1))(v3._1));
-          return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($2)()(v2))($1)($BaseVal(
+          return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)($2)()(v2))($1)($BaseVal(
             "Dictionary",
             fromFoldable17(zipWith2(Tuple)(v4._1)(zipWith2(Tuple)(v4._2)(v3._2)))
           ));
@@ -18558,14 +18614,10 @@ var $$eval = (dictMonadWithGraphAlloc) => {
             return go$r;
           };
           return go(0)($3);
-        })()))(() => Bind1.bind(traverse2((() => {
-          const $5 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v);
+        })()))(() => Bind1.bind(traverse3((() => {
+          const $5 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v);
           return (a) => $5(a)(v2);
-        })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($4)()(v2))($2)($BaseVal(
-          "Constr",
-          $1,
-          vs
-        ))));
+        })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)($4)()(v2))($2)($BaseVal("Constr", $1, vs))));
       }
       if (v1.tag === "Matrix") {
         const $1 = v1._2;
@@ -18573,7 +18625,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
         const $3 = v1._4._1;
         const $4 = v1._4._2;
         const $5 = v1._1;
-        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._5)(v2))((v3) => {
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v1._5)(v2))((v3) => {
           const v5 = intPair.unpack(v3._3);
           const $6 = v5._1._1;
           const $7 = v5._2._1;
@@ -18584,7 +18636,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
             1
           )) + "); got (" + show3($Tuple($6, $7)) + ")"))(() => Bind1.bind(sequence2(arrayBind(range(1)($6))((i) => [
             sequence2(arrayBind(range(1)($7))((j) => [
-              $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(disjointUnion2((() => {
+              $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(v)(disjointUnion2((() => {
                 const $10 = {};
                 $10[$3] = $Val($8, None, $BaseVal("Int", i));
                 return $10;
@@ -18594,7 +18646,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
                 return $10;
               })())))($2)(v2)
             ]))
-          ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($5)()(v2))($1)($BaseVal(
+          ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(insert(ordVertex)($5)()(v2))($1)($BaseVal(
             "Matrix",
             $Tuple(vss, $Tuple($Tuple($6, $8), $Tuple($7, $9)))
           ))));
@@ -18620,7 +18672,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
       if (v1.tag === "Project") {
         const $1 = v1._1;
         const $2 = v1._3;
-        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => {
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v1._2)(v2))((v3) => {
           if (v3._3.tag === "Dictionary") {
             return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + $2 + '" not found')((() => {
               const $3 = _lookup(Nothing, Just, $2, v3._3._1);
@@ -18628,7 +18680,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
                 return $Maybe("Just", $3._1._2);
               }
               return Nothing;
-            })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p)($1));
+            })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v$p)($1));
           }
           return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dictionary"));
         });
@@ -18636,7 +18688,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
       if (v1.tag === "DProject") {
         const $1 = v1._1;
         const $2 = v1._3;
-        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)($2)(v2))((v$p) => {
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)($2)(v2))((v$p) => {
           if (v3._3.tag === "Dictionary") {
             if (v$p._3.tag === "Str") {
               return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + v$p._3._1 + '" not found')((() => {
@@ -18645,7 +18697,7 @@ var $$eval = (dictMonadWithGraphAlloc) => {
                   return $Maybe("Just", $3._1._2);
                 }
                 return Nothing;
-              })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p$p)($1));
+              })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v$p$p)($1));
             }
             return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v$p)).lines) + ", expected string"));
           }
@@ -18655,10 +18707,10 @@ var $$eval = (dictMonadWithGraphAlloc) => {
       if (v1.tag === "App") {
         const $1 = v1._1;
         const $2 = v1._3;
-        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)($2)(v2))((v$p) => Bind1.bind(apply2(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v3)(v$p))((v4) => {
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)($2)(v2))((v$p) => Bind1.bind(apply2(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v3)(v$p))((v4) => {
           const $3 = v4._3;
           const $4 = v4._1;
-          return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
+          return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(v)((() => {
             const $5 = {};
             $5.this = v4;
             return $5;
@@ -18668,24 +18720,24 @@ var $$eval = (dictMonadWithGraphAlloc) => {
       if (v1.tag === "Let") {
         const $1 = v1._2;
         const $2 = v1._1._1;
-        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._1._2)(v2))((v3) => Bind1.bind(match1(v3)($2))((v4) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(v)(v1._1._2)(v2))((v3) => Bind1.bind(match1(v3)($2))((v4) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(v)(v4._1))($1)(v4._2._2)));
       }
       if (v1.tag === "LetRec") {
         const $1 = v1._2;
         const $2 = v1._1._1;
-        return Bind1.bind(closeDefs1(v)(v1._1._2)(insert(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(\u03B3$p))($1)(insert(ordVertex)($2)()(v2)));
+        return Bind1.bind(closeDefs1(v)(v1._1._2)(insert(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(v)(\u03B3$p))($1)(insert(ordVertex)($2)()(v2)));
       }
       fail();
     };
   };
 };
-var concatDocs = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
-  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+var concatDocs = (dictMonadWithGraphAlloc) => (dictMonadReader) => {
+  const Monad0 = dictMonadReader.MonadAsk0().Monad0();
   return (dictLoadFile) => (\u03B3) => (v) => (doc) => {
     const $0 = v._3;
     const $1 = v._2;
     const $2 = v._1;
-    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(\u03B3)((() => {
+    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(\u03B3)((() => {
       const $3 = {};
       $3.this = $Val($2, None, $0);
       return $3;
@@ -18698,8 +18750,8 @@ var apply2 = (dictMonadWithGraphAlloc) => {
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const MonadError1 = dictMonadWithGraphAlloc.MonadError1();
   const MonadThrow0 = MonadError1.MonadThrow0();
-  return (dictMonadReader) => (dictMonadAff) => {
-    const Bind1 = dictMonadAff.MonadEffect0().Monad0().Bind1();
+  return (dictMonadReader) => {
+    const Bind1 = dictMonadReader.MonadAsk0().Monad0().Bind1();
     return (dictLoadFile) => (v) => (v1) => {
       const $0 = (v2) => MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v2)).lines) + ", expected function"));
       if (v._3.tag === "Fun") {
@@ -18707,7 +18759,7 @@ var apply2 = (dictMonadWithGraphAlloc) => {
           const $1 = v._1;
           const $2 = v._3._1._1;
           const $3 = v._3._1._3;
-          return Bind1.bind(closeDefs1($2)(v._3._1._2)($$$Map("Two", Leaf2, $1, void 0, Leaf2)))((\u03B32) => Bind1.bind(match1(v1)($3))((v3) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(unionWith2((v$1) => identity13)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert(ordVertex)($1)()(v3._2._2))));
+          return Bind1.bind(closeDefs1($2)(v._3._1._2)($$$Map("Two", Leaf2, $1, void 0, Leaf2)))((\u03B32) => Bind1.bind(match1(v1)($3))((v3) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictLoadFile)(unionWith2((v$1) => identity14)(unionWith2((v$1) => identity14)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert(ordVertex)($1)()(v3._2._2))));
         }
         if (v._3._1.tag === "Foreign") {
           const $1 = v._3._1._1._2;
@@ -18738,7 +18790,7 @@ var apply2 = (dictMonadWithGraphAlloc) => {
               $Fun("Foreign", $Tuple(v._3._1._1._1, $1), vs$p)
             ));
           }
-          return $1._1.op(dictMonadWithGraphAlloc)(MonadError1)(dictMonadAff)(dictMonadReader)(dictLoadFile)(vs$p);
+          return $1._1.op(dictMonadWithGraphAlloc)(MonadError1)(dictMonadReader)(dictLoadFile)(vs$p);
         }
         if (v._3._1.tag === "PartialConstr") {
           const $1 = v._1;
@@ -18813,33 +18865,30 @@ var eval_module = (dictMonadWithGraphAlloc) => {
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
   return (dictMonadReader) => {
+    const Monad0 = dictMonadReader.MonadAsk0().Monad0();
+    const $0 = Monad0.Bind1();
     const eval2 = eval1(dictMonadReader);
-    return (dictMonadAff) => {
-      const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-      const $0 = Monad0.Bind1();
-      const eval3 = eval2(dictMonadAff);
-      return (dictLoadFile) => {
-        const eval4 = eval3(dictLoadFile);
-        return (\u03B3) => {
-          const go = (v) => (v1) => (v2) => {
-            if (v1.tag === "Nil") {
-              return Monad0.Applicative0().pure(v);
+    return (dictLoadFile) => {
+      const eval3 = eval2(dictLoadFile);
+      return (\u03B3) => {
+        const go = (v) => (v1) => (v2) => {
+          if (v1.tag === "Nil") {
+            return Monad0.Applicative0().pure(v);
+          }
+          if (v1.tag === "Cons") {
+            if (v1._1.tag === "Left") {
+              const $1 = v1._2;
+              const $2 = v1._1._1._1;
+              return $0.bind(eval3(unionWith2((v$1) => identity14)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith2((v$1) => identity14)(v)(v4._1))($1)(v4._2._2)));
             }
-            if (v1.tag === "Cons") {
-              if (v1._1.tag === "Left") {
-                const $1 = v1._2;
-                const $2 = v1._1._1._1;
-                return $0.bind(eval4(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
-              }
-              if (v1._1.tag === "Right") {
-                const $1 = v1._2;
-                return $0.bind(closeDefs1(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(insert(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith2((v$1) => identity13)(v)(\u03B3$p$p))($1)(v2));
-              }
+            if (v1._1.tag === "Right") {
+              const $1 = v1._2;
+              return $0.bind(closeDefs1(unionWith2((v$1) => identity14)(\u03B3)(v))(v1._1._1._2)(insert(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith2((v$1) => identity14)(v)(\u03B3$p$p))($1)(v2));
             }
-            fail();
-          };
-          return go(empty);
+          }
+          fail();
         };
+        return go(empty);
       };
     };
   };
@@ -18848,26 +18897,95 @@ var eval_progCxt = (dictMonadWithGraphAlloc) => {
   const eval_module1 = eval_module(dictMonadWithGraphAlloc);
   const eval1 = $$eval(dictMonadWithGraphAlloc);
   return (dictMonadReader) => {
+    const Monad0 = dictMonadReader.MonadAsk0().Monad0();
+    const $0 = Monad0.Bind1();
     const eval_module2 = eval_module1(dictMonadReader);
+    const $1 = Monad0.Applicative0();
     const eval2 = eval1(dictMonadReader);
-    return (dictMonadAff) => {
-      const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-      const $0 = Monad0.Bind1();
-      const eval_module3 = eval_module2(dictMonadAff);
-      const $1 = Monad0.Applicative0();
-      const eval3 = eval2(dictMonadAff);
-      const concatM1 = concatM(Monad0);
-      return (dictLoadFile) => {
-        const eval_module4 = eval_module3(dictLoadFile);
-        const eval4 = eval3(dictLoadFile);
-        return (v) => concatM1(foldableList.foldr(Cons)(listMap((v1) => (\u03B3) => {
-          const $2 = v1._1;
-          return $0.bind(eval4(\u03B3)(v1._2)(setSet4.empty))((v2) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)((() => {
-            const $3 = {};
-            $3[$2] = v2;
-            return $3;
-          })())));
-        })(reverse2(v.datasets)))(listMap((mod) => (\u03B3) => $0.bind(eval_module4(\u03B3)(mod)(setSet4.empty))((\u03B3$p) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)(\u03B3$p))))(reverse2(v.mods))))(v.primitives);
+    const concatM1 = concatM(Monad0);
+    return (dictLoadFile) => {
+      const eval_module3 = eval_module2(dictLoadFile);
+      const eval3 = eval2(dictLoadFile);
+      return (v) => (v1) => {
+        const $2 = v.datasets;
+        const $3 = v1.graph;
+        const $4 = v1.modules;
+        const $5 = v.primitives;
+        const $6 = v1.roots;
+        return $0.bind(foldM2(Monad0)((\u03B3s) => (name2) => {
+          const v2 = definitely("deps evaluated")((() => {
+            const $7 = lookup2(ordString)(name2)($3);
+            if ($7.tag === "Just") {
+              const $8 = traverse2((dep) => lookup2(ordString)(dep)(\u03B3s))($7._1);
+              if ($8.tag === "Just") {
+                const $9 = lookup2(ordString)(name2)($4);
+                if ($9.tag === "Just") {
+                  return $Maybe("Just", $Tuple($9._1, $8._1));
+                }
+                if ($9.tag === "Nothing") {
+                  return Nothing;
+                }
+                fail();
+              }
+              if ($8.tag === "Nothing") {
+                return Nothing;
+              }
+              fail();
+            }
+            if ($7.tag === "Nothing") {
+              return Nothing;
+            }
+            fail();
+          })());
+          return $0.bind(eval_module3((() => {
+            const go = (go$a0$copy) => (go$a1$copy) => {
+              let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+              while (go$c) {
+                const b = go$a0, v$1 = go$a1;
+                if (v$1.tag === "Nil") {
+                  go$c = false;
+                  go$r = b;
+                  continue;
+                }
+                if (v$1.tag === "Cons") {
+                  go$a0 = unionWith2((v$2) => identity14)(b)(v$1._1);
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
+              }
+              return go$r;
+            };
+            return go($5)(v2._2);
+          })())(v2._1)(setSet4.empty))((\u03B3$p) => $1.pure(insert(ordString)(name2)(\u03B3$p)(\u03B3s)));
+        })(Leaf2)(v1.topsorted))((\u03B3s) => {
+          const go = (go$a0$copy) => (go$a1$copy) => {
+            let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+            while (go$c) {
+              const b = go$a0, v$1 = go$a1;
+              if (v$1.tag === "Nil") {
+                go$c = false;
+                go$r = b;
+                continue;
+              }
+              if (v$1.tag === "Cons") {
+                go$a0 = unionWith2((v$2) => identity14)(b)(v$1._1);
+                go$a1 = v$1._2;
+                continue;
+              }
+              fail();
+            }
+            return go$r;
+          };
+          return concatM1(listMap((v2) => (\u03B3) => {
+            const $7 = v2._1;
+            return $0.bind(eval3(\u03B3)(v2._2)(setSet4.empty))((v3) => $1.pure(unionWith2((v$1) => identity14)(\u03B3)((() => {
+              const $8 = {};
+              $8[$7] = v3;
+              return $8;
+            })())));
+          })(reverse2($2)))(go($5)(listMap((dep) => definitely("has env")(lookup2(ordString)(dep)(\u03B3s)))($6)));
+        });
       };
     };
   };
@@ -18882,25 +19000,20 @@ var graphEval = (dictMonadAff) => {
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const monadAffState2 = monadAffState(dictMonadAff);
-  const monadAffState1 = monadAffState(monadAffState2);
-  const $1 = monadAffState2.MonadEffect0().Monad0();
+  const $1 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
   const $2 = dictMonadAff.MonadEffect0().Monad0();
   return (dictMonadReader) => {
     const monadReaderStateT2 = monadReaderStateT(monadReaderStateT(dictMonadReader));
     return (dictLoadFile) => (dictMonadError) => {
-      const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))(monadReaderStateT2)(monadAffState1)((() => {
-        const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+      const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))(monadReaderStateT2)((() => {
+        const loadFileFromPath1 = dictLoadFile.loadFileFromPath(dictMonadError)(dictMonadAff);
         return {
-          loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-            const $3 = loadFile1(folders);
-            return (x) => {
-              const $4 = $3(x);
-              return (s) => $1.Bind1().bind((s$1) => $2.Bind1().bind($4)((x$1) => $2.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $1.Applicative0().pure($Tuple(
-                x$1,
-                s
-              )));
-            };
+          loadFileFromPath: (dictMonadError1) => (dictMonadAff1) => (x) => {
+            const $3 = loadFileFromPath1(x);
+            return (s) => $1.Bind1().bind((s$1) => $2.Bind1().bind($3)((x$1) => $2.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $1.Applicative0().pure($Tuple(
+              x$1,
+              s
+            )));
           }
         };
       })());
@@ -19764,8 +19877,49 @@ var monoidRecord = () => (dictMonoidRecord) => {
   return { mempty: dictMonoidRecord.memptyRecord($$Proxy), Semigroup0: () => semigroupRecord1 };
 };
 
+// output-es/Data.Nullable/foreign.js
+function nullable(a, r, f) {
+  return a == null ? r : f(a);
+}
+
+// output-es/Foreign/foreign.js
+var isArray = Array.isArray || function(value) {
+  return Object.prototype.toString.call(value) === "[object Array]";
+};
+
 // output-es/File/index.js
 var Folder = (x) => x;
+var show4 = /* @__PURE__ */ showArrayImpl(showStringImpl);
+var prependFolder = (v) => (v1) => v + "/" + v1;
+var loadFile = (dictLoadFile) => (dictMonad) => {
+  const $0 = dictMonad.Applicative0();
+  return (dictMonadError) => {
+    const loadFileFromPath2 = dictLoadFile.loadFileFromPath(dictMonadError);
+    return (dictMonadAff) => {
+      const loadFileFromPath3 = loadFileFromPath2(dictMonadAff);
+      return (folders) => (file) => {
+        const paths = arrayApply(arrayMap(prependFolder)(folders))([file]);
+        return dictMonad.Bind1().bind(foldM(dictMonad)((v) => (v1) => {
+          if (v.tag === "Just") {
+            return $0.pure($Maybe("Just", v._1));
+          }
+          if (v.tag === "Nothing") {
+            return loadFileFromPath3(v1);
+          }
+          fail();
+        })(Nothing)(paths))((result) => {
+          if (result.tag === "Just") {
+            return $0.pure(result._1);
+          }
+          if (result.tag === "Nothing") {
+            return throwException(error("File not found in any path: " + show4(paths)))();
+          }
+          fail();
+        });
+      };
+    };
+  };
+};
 
 // output-es/Data.CodePoint.Unicode/index.js
 var isUpper = (x) => checkAttr([512, 524288])(x);
@@ -19954,7 +20108,7 @@ var toLowerSimple = /* @__PURE__ */ convert(uTowlower);
 var toUpperSimple = /* @__PURE__ */ convert(uTowupper);
 
 // output-es/Parsing.Token/index.js
-var identity23 = (x) => x;
+var identity25 = (x) => x;
 var choice3 = /* @__PURE__ */ choice(foldableArray);
 var toUnfoldable10 = /* @__PURE__ */ toUnfoldable2(unfoldableArray);
 var theReservedNames = (v) => {
@@ -20267,10 +20421,10 @@ var makeTokenParser = (v) => {
                 if ($132) {
                   return $42(v4$1, $122);
                 }
-                return $52(v2, identity23);
+                return $52(v2, identity25);
               });
             },
-            (state2, a) => $22((v2$1) => $52(state2, identity23))
+            (state2, a) => $22((v2$1) => $52(state2, identity25))
           )));
         });
       },
@@ -21536,7 +21690,7 @@ var onlyIf = (b) => (a) => {
 };
 var choose2 = /* @__PURE__ */ choose(altParserT);
 var fanin3 = /* @__PURE__ */ fanin(categoryFn)(choiceFn);
-var identity24 = (x) => x;
+var identity26 = (x) => x;
 var operators = (binaryOp) => fromFoldable18(listMap(arrayMap((v) => $Operator(
   "Infix",
   (() => {
@@ -21560,6 +21714,10 @@ var operators = (binaryOp) => fromFoldable18(listMap(arrayMap((v) => $Operator(
   }
   fail();
 })(foldableMap.foldr(Cons)(Nil)(opDefs))))));
+var letters = ($$char) => {
+  const $0 = some(alternativeParserT)(lazyParserT)($$char);
+  return (state1, more, lift12, $$throw2, done) => more((v1) => $0(state1, more, lift12, $$throw2, (state2, a) => more((v2) => done(state2, fromCharArray(a)))));
+};
 var languageDef = /* @__PURE__ */ (() => {
   const opChar = oneOf([":", "!", "#", "$", "%", "&", "*", "+", ".", "/", "<", "=", ">", "?", "@", "\\", "^", "|", "-", "~"]);
   return {
@@ -21613,7 +21771,7 @@ var languageDef = /* @__PURE__ */ (() => {
     })(),
     opStart: opChar,
     opLetter: opChar,
-    reservedNames: ["as", "else", "fun", "if", "in", "let", "match", "then"],
+    reservedNames: ["as", "else", "fun", "if", "in", "let", "match", "then", "import"],
     reservedOpNames: ["|", "..", "=", "<-", "->"],
     caseSensitive: true
   };
@@ -21648,6 +21806,34 @@ var keyword = (str$p) => {
   }
   return throwException(error(str$p + " is not a reserved word"))();
 };
+var imports_ = /* @__PURE__ */ manyRec2(/* @__PURE__ */ (() => {
+  const $0 = keyword("import");
+  const $1 = joinWith("/");
+  const $2 = sepBy1(token.identifier)(token.reservedOp("."));
+  return (state1, more, lift12, $$throw2, done) => more((v2) => more((v1) => $0(
+    state1,
+    more,
+    lift12,
+    $$throw2,
+    (state2, a) => more((v2$1) => more((v3) => more((v1$1) => $2(
+      state2,
+      more,
+      lift12,
+      $$throw2,
+      (state2$1, a$1) => more((v2$2) => {
+        const $3 = $1(fromFoldable19(a$1));
+        return more((v4) => done(state2$1, $3));
+      })
+    ))))
+  )));
+})());
+var withImports = (p) => topLevel((state1, more, lift12, $$throw2, done) => more((v1) => imports_(
+  state1,
+  more,
+  lift12,
+  $$throw2,
+  (state2, a) => more((v2) => more((v1$1) => p(state2, more, lift12, $$throw2, (state2$1, a$1) => more((v2$1) => done(state2$1, $Tuple(a$1, a))))))
+)));
 var ident = (state1, more, lift12, $$throw2, done) => more((v1) => token.identifier(
   state1,
   more,
@@ -21949,17 +22135,8 @@ var varDefs = (expr$p) => {
   )));
 };
 var commentToken = /* @__PURE__ */ (() => {
-  const $0 = some(alternativeParserT)(lazyParserT)(docCommentLetter);
-  return (state1, more, lift12, $$throw2, done) => more((v1) => more((v1$1) => $0(
-    state1,
-    more,
-    lift12,
-    $$throw2,
-    (state2, a) => more((v2) => {
-      const $1 = fromCharArray(a);
-      return more((v2$1) => done(state2, $DocCommentElem("Token", $1)));
-    })
-  )));
+  const $0 = letters(docCommentLetter);
+  return (state1, more, lift12, $$throw2, done) => more((v1) => $0(state1, more, lift12, $$throw2, (state2, a) => more((v2) => done(state2, $DocCommentElem("Token", a)))));
 })();
 var commentExpr = (expr$p) => (state1, more, lift12, $$throw2, done) => more((v2) => more((v1) => string2("$")(
   state1,
@@ -22639,10 +22816,10 @@ var expr_$lazy = /* @__PURE__ */ binding(() => {
                                                         if ($47) {
                                                           return $42($ParseState(v4$5._1, v4$5._2, false), $46);
                                                         }
-                                                        return $43($ParseState($29, $30, false), identity24);
+                                                        return $43($ParseState($29, $30, false), identity26);
                                                       });
                                                     },
-                                                    (state2, a) => $25((v2$3) => $43(state2, identity24))
+                                                    (state2, a) => $25((v2$3) => $43(state2, identity26))
                                                   )));
                                                 });
                                               },
@@ -22683,10 +22860,10 @@ var expr_$lazy = /* @__PURE__ */ binding(() => {
                                                   if ($45) {
                                                     return $40($ParseState(v4$4._1, v4$4._2, false), $44);
                                                   }
-                                                  return $41($ParseState($29, $30, false), identity24);
+                                                  return $41($ParseState($29, $30, false), identity26);
                                                 });
                                               },
-                                              (state2, a) => $25((v2$3) => $41(state2, identity24))
+                                              (state2, a) => $25((v2$3) => $41(state2, identity26))
                                             )));
                                           });
                                         },
@@ -23030,105 +23207,23 @@ var expr_$lazy = /* @__PURE__ */ binding(() => {
   return go;
 });
 var expr_ = /* @__PURE__ */ expr_$lazy();
-var module_ = /* @__PURE__ */ (() => {
-  const $0 = topLevel((() => {
-    const $02 = sepBy_try(defs(expr_))(token.semi);
-    return (state1, more, lift12, $$throw2, done) => more((v2) => more((v1) => $02(
-      state1,
-      more,
-      lift12,
-      $$throw2,
-      (state2, a) => more((v2$1) => more((v3) => token.semi(state2, more, lift12, $$throw2, (state3, a$1) => more((v4) => done(state3, a)))))
-    )));
-  })());
-  return (state1, more, lift12, $$throw2, done) => more((v1) => $0(
+var module_ = /* @__PURE__ */ withImports(/* @__PURE__ */ (() => {
+  const $0 = sepBy_try(defs(expr_))(token.semi);
+  return (state1, more, lift12, $$throw2, done) => more((v2) => more((v1) => more((v1$1) => $0(
     state1,
     more,
     lift12,
     $$throw2,
-    (state2, a) => more((v2) => done(state2, $Module(bindList.bind(a)(identity7))))
-  ));
-})();
-
-// output-es/Data.Argonaut.Core/foreign.js
-function stringify(j) {
-  return JSON.stringify(j);
-}
-function _caseJson(isNull2, isBool, isNum, isStr, isArr, isObj, j) {
-  if (j == null)
-    return isNull2();
-  else if (typeof j === "boolean")
-    return isBool(j);
-  else if (typeof j === "number")
-    return isNum(j);
-  else if (typeof j === "string")
-    return isStr(j);
-  else if (Object.prototype.toString.call(j) === "[object Array]")
-    return isArr(j);
-  else
-    return isObj(j);
-}
-
-// output-es/Data.Argonaut.Core/index.js
-var caseJson = (a) => (b) => (c) => (d) => (e) => (f) => (json) => _caseJson(a, b, c, d, e, f, json);
-
-// output-es/Data.Argonaut.Decode.Error/index.js
-var $JsonDecodeError = (tag, _1, _2) => ({ tag, _1, _2 });
-var showJsonDecodeError = {
-  show: (v) => {
-    if (v.tag === "TypeMismatch") {
-      return "(TypeMismatch " + showStringImpl(v._1) + ")";
-    }
-    if (v.tag === "UnexpectedValue") {
-      return "(UnexpectedValue " + stringify(v._1) + ")";
-    }
-    if (v.tag === "AtIndex") {
-      return "(AtIndex " + showIntImpl(v._1) + " " + showJsonDecodeError.show(v._2) + ")";
-    }
-    if (v.tag === "AtKey") {
-      return "(AtKey " + showStringImpl(v._1) + " " + showJsonDecodeError.show(v._2) + ")";
-    }
-    if (v.tag === "Named") {
-      return "(Named " + showStringImpl(v._1) + " " + showJsonDecodeError.show(v._2) + ")";
-    }
-    if (v.tag === "MissingValue") {
-      return "MissingValue";
-    }
-    fail();
-  }
-};
-
-// output-es/Data.Argonaut.Parser/foreign.js
-function _jsonParser(fail3, succ, s) {
-  try {
-    return succ(JSON.parse(s));
-  } catch (e) {
-    return fail3(e.message);
-  }
-}
-
-// output-es/Data.Argonaut.Decode.Parser/index.js
-var parseJson = (x) => {
-  const $0 = _jsonParser(Left, Right, x);
-  if ($0.tag === "Left") {
-    return $Either("Left", $JsonDecodeError("TypeMismatch", "JSON"));
-  }
-  if ($0.tag === "Right") {
-    return $Either("Right", $0._1);
-  }
-  fail();
-};
+    (state2, a) => more((v2$1) => {
+      const $1 = $Module(bindList.bind(a)(identity7));
+      return more((v2$2) => more((v3) => token.semi(state2, more, lift12, $$throw2, (state3, a$1) => more((v4) => done(state3, $1)))));
+    })
+  ))));
+})());
 
 // output-es/Primitive.Defs/index.js
 var foldM4 = (dictMonad) => (f) => (b0) => foldableDict.foldl((b) => (a) => dictMonad.Bind1().bind(b)((a$1) => f(a$1)(a)))(dictMonad.Applicative0().pure(b0));
 var disjointUnion3 = /* @__PURE__ */ disjointUnion(mapDictString);
-var fromFoldable20 = /* @__PURE__ */ foldlArray((m) => (a) => insert(ordVertex)(a)()(m))(Leaf2);
-var pretty = /* @__PURE__ */ (() => prettyVal(highlightableVertex).pretty)();
-var toUnfoldable15 = /* @__PURE__ */ (() => {
-  const $0 = toArrayWithKey(Tuple);
-  return (x) => toUnfoldable(unfoldableArray)($0(x));
-})();
-var fromFoldable110 = /* @__PURE__ */ fromFoldable2(foldableArray);
 var unary2 = /* @__PURE__ */ unary(boundedJoinSemilatticeUni);
 var binary2 = /* @__PURE__ */ binary(boundedJoinSemilatticeUni);
 var binaryZero2 = /* @__PURE__ */ binaryZero(boundedJoinSemilatticeUni);
@@ -23153,7 +23248,7 @@ var matrixUpdate = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+        return (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Cons" && v._2._1._3.tag === "Constr" && v._2._1._3._2.tag === "Cons" && v._2._1._3._2._1._3.tag === "Int" && v._2._1._3._2._2.tag === "Cons" && v._2._1._3._2._2._1._3.tag === "Int" && v._2._1._3._2._2._2.tag === "Nil" && v._2._2.tag === "Cons" && v._2._2._2.tag === "Nil" && v._2._1._3._1 === "Pair") {
             const $0 = v._2._2._1;
             return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._1, void 0, Leaf2))($BaseVal(
@@ -23172,12 +23267,12 @@ var matrixLookup = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+      const MonadThrow0 = dictMonadError.MonadThrow0();
+      return (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Cons" && v._2._1._3.tag === "Constr" && v._2._1._3._2.tag === "Cons" && v._2._1._3._2._1._3.tag === "Int" && v._2._1._3._2._2.tag === "Cons" && v._2._1._3._2._2._1._3.tag === "Int" && v._2._1._3._2._2._2.tag === "Nil" && v._2._2.tag === "Nil" && v._2._1._3._1 === "Pair") {
-          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(matrixGet(v._2._1._3._2._1._3._1)(v._2._1._3._2._2._1._3._1)(v._1._3._1));
+          return MonadThrow0.Monad0().Applicative0().pure(matrixGet(v._2._1._3._2._1._3._1)(v._2._1._3._2._2._1._3._1)(v._1._3._1));
         }
-        return $$throw2("Matrix and pair of integers expected");
+        return MonadThrow0.throwError(error("Matrix and pair of integers expected"));
       };
     }
   })
@@ -23205,12 +23300,12 @@ var error_ = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+      const MonadThrow0 = dictMonadError.MonadThrow0();
+      return (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Nil") {
-          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
+          return MonadThrow0.Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
         }
-        return $$throw2("String expected");
+        return MonadThrow0.throwError(error("String expected"));
       };
     }
   })
@@ -23223,28 +23318,26 @@ var dims = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => {
-          const $0 = dictMonadAff.MonadEffect0().Monad0().Bind1();
-          return (dictMonadReader) => (dictLoadFile) => (v) => {
-            if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Nil") {
-              const $1 = v._1._3._1._2._2._1;
-              const $2 = v._1._1;
-              const $3 = v._1._3._1._2._2._2;
-              return $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._3._1._2._1._2, void 0, Leaf2))($BaseVal(
-                "Int",
-                v._1._3._1._2._1._1
-              )))((v1) => $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $3, void 0, Leaf2))($BaseVal(
-                "Int",
-                $1
-              )))((v2) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $2, void 0, Leaf2))($BaseVal(
-                "Constr",
-                "Pair",
-                $List("Cons", v1, $List("Cons", v2, Nil))
-              ))));
-            }
-            return $$throw2("Matrix expected");
-          };
+        const MonadThrow0 = dictMonadError.MonadThrow0();
+        const $0 = MonadThrow0.Monad0().Bind1();
+        return (dictMonadReader) => (dictLoadFile) => (v) => {
+          if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Nil") {
+            const $1 = v._1._3._1._2._2._1;
+            const $2 = v._1._1;
+            const $3 = v._1._3._1._2._2._2;
+            return $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._3._1._2._1._2, void 0, Leaf2))($BaseVal(
+              "Int",
+              v._1._3._1._2._1._1
+            )))((v1) => $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $3, void 0, Leaf2))($BaseVal(
+              "Int",
+              $1
+            )))((v2) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $2, void 0, Leaf2))($BaseVal(
+              "Constr",
+              "Pair",
+              $List("Cons", v1, $List("Cons", v2, Nil))
+            ))));
+          }
+          return MonadThrow0.throwError(error("Matrix expected"));
         };
       };
     }
@@ -23258,29 +23351,27 @@ var dict_map = /* @__PURE__ */ $Tuple(
       const apply5 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => {
-          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-          const Bind1 = Monad0.Bind1();
-          const traverse2 = traversableDict.traverse(Monad0.Applicative0());
-          return (dictMonadReader) => {
-            const apply12 = apply5(dictMonadReader)(dictMonadAff);
-            return (dictLoadFile) => {
-              const apply22 = apply12(dictLoadFile);
-              return (v) => {
-                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
-                  const $0 = v._1;
-                  const $1 = v._2._1._1;
-                  return Bind1.bind(traverse2((v2) => {
-                    const $2 = v2._1;
-                    return Bind1.Apply0().Functor0().map((v3) => $Tuple($2, v3))(apply22($0)(v2._2));
-                  })(v._2._1._3._1))((d$p) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $1, void 0, Leaf2))($BaseVal(
-                    "Dictionary",
-                    d$p
-                  )));
-                }
-                return $$throw2("Function and dictionary expected");
-              };
+        const MonadThrow0 = dictMonadError.MonadThrow0();
+        const Monad0 = MonadThrow0.Monad0();
+        const Bind1 = Monad0.Bind1();
+        const traverse1 = traversableDict.traverse(Monad0.Applicative0());
+        return (dictMonadReader) => {
+          const apply12 = apply5(dictMonadReader);
+          return (dictLoadFile) => {
+            const apply22 = apply12(dictLoadFile);
+            return (v) => {
+              if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
+                const $0 = v._1;
+                const $1 = v._2._1._1;
+                return Bind1.bind(traverse1((v2) => {
+                  const $2 = v2._1;
+                  return Bind1.Apply0().Functor0().map((v3) => $Tuple($2, v3))(apply22($0)(v2._2));
+                })(v._2._1._3._1))((d$p) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $1, void 0, Leaf2))($BaseVal(
+                  "Dictionary",
+                  d$p
+                )));
+              }
+              return MonadThrow0.throwError(error("Function and dictionary expected"));
             };
           };
         };
@@ -23296,42 +23387,40 @@ var dict_intersectionWith = /* @__PURE__ */ $Tuple(
       const apply5 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => {
-          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-          const Bind1 = Monad0.Bind1();
-          const Applicative0 = Monad0.Applicative0();
-          const $0 = Bind1.Apply0().Functor0();
-          return (dictMonadReader) => {
-            const apply12 = apply5(dictMonadReader)(dictMonadAff);
-            return (dictLoadFile) => {
-              const apply22 = apply12(dictLoadFile);
-              return (v) => {
-                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
-                  const $1 = v._1;
-                  const $2 = v._2._1._1;
-                  const $3 = v._2._2._1._1;
-                  return Bind1.bind($0.map(Dictionary3)($0.map(DictRep)(traversableDict.traverse(Applicative0)(identity14)(intersectionWith_Object((v2) => (v3) => {
-                    const $4 = v3._2;
-                    const $5 = v2._1;
-                    const $6 = v3._1;
-                    return Bind1.bind(Bind1.bind(apply22($1)(v2._2))((a) => apply22(a)($4)))((v4) => Bind1.bind($$new((a) => Val(a)(None))(insert(ordVertex)($6)()($$$Map(
-                      "Two",
-                      Leaf2,
-                      $5,
-                      void 0,
-                      Leaf2
-                    )))(v4._3))((v5) => Applicative0.pure($Tuple(v5._1, v4))));
-                  })(v._2._1._3._1)(v._2._2._1._3._1)))))((v$p) => $$new((a) => Val(a)(None))(insert(ordVertex)($3)()($$$Map(
+        const MonadThrow0 = dictMonadError.MonadThrow0();
+        const Monad0 = MonadThrow0.Monad0();
+        const Bind1 = Monad0.Bind1();
+        const Applicative0 = Monad0.Applicative0();
+        const $0 = Bind1.Apply0().Functor0();
+        return (dictMonadReader) => {
+          const apply12 = apply5(dictMonadReader);
+          return (dictLoadFile) => {
+            const apply22 = apply12(dictLoadFile);
+            return (v) => {
+              if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
+                const $1 = v._1;
+                const $2 = v._2._1._1;
+                const $3 = v._2._2._1._1;
+                return Bind1.bind($0.map(Dictionary3)($0.map(DictRep)(traversableDict.traverse(Applicative0)(identity15)(intersectionWith_Object((v2) => (v3) => {
+                  const $4 = v3._2;
+                  const $5 = v2._1;
+                  const $6 = v3._1;
+                  return Bind1.bind(Bind1.bind(apply22($1)(v2._2))((a) => apply22(a)($4)))((v4) => Bind1.bind($$new((a) => Val(a)(None))(insert(ordVertex)($6)()($$$Map(
                     "Two",
                     Leaf2,
-                    $2,
+                    $5,
                     void 0,
                     Leaf2
-                  )))(v$p));
-                }
-                return $$throw2("Function and two dictionaries expected");
-              };
+                  )))(v4._3))((v5) => Applicative0.pure($Tuple(v5._1, v4))));
+                })(v._2._1._3._1)(v._2._2._1._3._1)))))((v$p) => $$new((a) => Val(a)(None))(insert(ordVertex)($3)()($$$Map(
+                  "Two",
+                  Leaf2,
+                  $2,
+                  void 0,
+                  Leaf2
+                )))(v$p));
+              }
+              return MonadThrow0.throwError(error("Function and two dictionaries expected"));
             };
           };
         };
@@ -23345,7 +23434,7 @@ var dict_get = /* @__PURE__ */ $Tuple(
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
       const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+      return (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
           return orElse(MonadThrow0)('Key "' + v._1._3._1 + '" not found')((() => {
             const $0 = _lookup(Nothing, Just, v._1._3._1, v._2._1._3._1);
@@ -23367,23 +23456,21 @@ var dict_foldl = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const apply5 = apply2(dictMonadWithGraphAlloc);
       return (dictMonadError) => {
-        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => {
-          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-          return (dictMonadReader) => {
-            const apply12 = apply5(dictMonadReader)(dictMonadAff);
-            return (dictLoadFile) => {
-              const apply22 = apply12(dictLoadFile);
-              return (v) => {
-                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
-                  const $0 = v._1;
-                  return foldM4(Monad0)((u1) => (v2) => {
-                    const $1 = v2._2;
-                    return Monad0.Bind1().bind(apply22($0)(u1))((a) => apply22(a)($1));
-                  })(v._2._1)(v._2._2._1._3._1);
-                }
-                return $$throw2("Function, value and dictionary expected");
-              };
+        const MonadThrow0 = dictMonadError.MonadThrow0();
+        const Monad0 = MonadThrow0.Monad0();
+        return (dictMonadReader) => {
+          const apply12 = apply5(dictMonadReader);
+          return (dictLoadFile) => {
+            const apply22 = apply12(dictLoadFile);
+            return (v) => {
+              if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
+                const $0 = v._1;
+                return foldM4(Monad0)((u1) => (v2) => {
+                  const $1 = v2._2;
+                  return Monad0.Bind1().bind(apply22($0)(u1))((a) => apply22(a)($1));
+                })(v._2._1)(v._2._2._1._3._1);
+              }
+              return MonadThrow0.throwError(error("Function, value and dictionary expected"));
             };
           };
         };
@@ -23399,7 +23486,7 @@ var dict_disjointUnion = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+        return (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Dictionary" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
             return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -23423,7 +23510,7 @@ var dict_difference = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+        return (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Dictionary" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
             return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -23444,103 +23531,18 @@ var debugLog = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
+      const MonadThrow0 = dictMonadError.MonadThrow0();
+      return (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._2.tag === "Nil") {
           const $0 = v._1;
-          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
+          return MonadThrow0.Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
         }
-        return $$throw2("Single value expected");
-      };
-    }
-  })
-);
-var arrVtoVal$p = (dictMonadWithGraphAlloc) => {
-  const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-  return (v) => {
-    if (v.tag === "Nil") {
-      return $$new((a) => Val(a)(None))(Leaf2)($BaseVal("Constr", "Nil", Nil));
-    }
-    if (v.tag === "Cons") {
-      const $0 = v._1;
-      return dictMonadWithGraphAlloc.MonadWithGraph2().Monad0().Bind1().bind(arrVtoVal$p(dictMonadWithGraphAlloc)(v._2))((tailV) => $$new((a) => Val(a)(None))(fromFoldable20([
-        $0._1,
-        tailV._1
-      ]))($BaseVal("Constr", ":", $List("Cons", $0, $List("Cons", tailV, Nil)))));
-    }
-    fail();
-  };
-};
-var fromJsonVal$p = (dictMonadWithGraphAlloc) => {
-  const $$throw2 = $$throw(dictMonadWithGraphAlloc.MonadError1().MonadThrow0());
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const $0 = Monad0.Bind1();
-  const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-  const Applicative0 = Monad0.Applicative0();
-  const traverse2 = traversableArray.traverse(Applicative0);
-  const arrVtoVal$p1 = arrVtoVal$p(dictMonadWithGraphAlloc);
-  return caseJson((v) => $$throw2("Error, Null JSON value cannot be converted to Val Vertex"))((b) => $0.bind($$new((a) => Val(a)(None))(Leaf2)($BaseVal(
-    "Constr",
-    b ? "True" : "False",
-    Nil
-  )))((v) => Applicative0.pure(spyWhen(true)("Processing boolean")((x) => intercalate4("\n")(pretty(x).lines))(v))))((n) => $0.bind((() => {
-    const v = fromNumber(n);
-    if (v.tag === "Just") {
-      return $$new((a) => Val(a)(None))(Leaf2)($BaseVal("Int", v._1));
-    }
-    if (v.tag === "Nothing") {
-      return $$new((a) => Val(a)(None))(Leaf2)($BaseVal("Float", n));
-    }
-    fail();
-  })())((v) => Applicative0.pure(spyWhen(true)("Processing number")((x) => intercalate4("\n")(pretty(x).lines))(v))))((s) => $0.bind($$new((a) => Val(a)(None))(Leaf2)($BaseVal(
-    "Str",
-    s
-  )))((v) => Applicative0.pure(spyWhen(true)("Processing string")((x) => intercalate4("\n")(pretty(x).lines))(v))))((arr) => $0.bind(traverse2(fromJsonVal$p(dictMonadWithGraphAlloc))(arr))((vs) => $0.bind(arrVtoVal$p1(toUnfoldable(unfoldableList)(vs)))((v) => Applicative0.pure(spyWhen(true)("Processing array")((x) => intercalate4("\n")(pretty(x).lines))(v)))))((obj) => $0.bind(traverse2((v) => {
-    const $1 = v._1;
-    return $0.bind(fromJsonVal$p(dictMonadWithGraphAlloc)(v._2))((vv) => Applicative0.pure($Tuple($1, $Tuple(vv._1, vv))));
-  })(toUnfoldable15(obj)))((entries) => $0.bind($$new((a) => Val(a)(None))(fromFoldable20(arrayMap((v) => v._2._1)(entries)))($BaseVal(
-    "Dictionary",
-    fromFoldable110(entries)
-  )))((v) => Applicative0.pure(spyWhen(true)("Processing object")((x) => intercalate4("\n")(pretty(x).lines))(v)))));
-};
-var loadJson = /* @__PURE__ */ $Tuple(
-  "loadJson",
-  /* @__PURE__ */ $ForeignOp$p({
-    arity: 1,
-    op: (dictMonadWithGraphAlloc) => {
-      const fromJsonVal$p1 = fromJsonVal$p(dictMonadWithGraphAlloc);
-      return (dictMonadError) => {
-        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictMonadAff) => {
-          const $0 = dictMonadAff.MonadEffect0().Monad0().Bind1();
-          return (dictMonadReader) => {
-            const ask = dictMonadReader.MonadAsk0().ask;
-            return (dictLoadFile) => {
-              const loadFile = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-              return (v) => {
-                if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Nil") {
-                  const $1 = v._1._3._1;
-                  return $0.bind(ask)((v1) => $0.bind(loadFile(v1.fluidSrcPaths)($1))((str) => {
-                    const v2 = parseJson(str);
-                    if (v2.tag === "Left") {
-                      return $$throw2("Failed to parse JSON: " + showJsonDecodeError.show(v2._1));
-                    }
-                    if (v2.tag === "Right") {
-                      return fromJsonVal$p1(v2._1);
-                    }
-                    fail();
-                  }));
-                }
-                return $$throw2("String expected");
-              };
-            };
-          };
-        };
+        return MonadThrow0.throwError(error("Single value expected"));
       };
     }
   })
 );
-var primitives = /* @__PURE__ */ fromFoldable110([
+var primitives = /* @__PURE__ */ fromFoldable2(foldableArray)([
   /* @__PURE__ */ $Tuple(
     ":",
     /* @__PURE__ */ $Val(void 0, None, /* @__PURE__ */ $BaseVal("Fun", /* @__PURE__ */ $Fun("PartialConstr", ":", Nil)))
@@ -23549,7 +23551,6 @@ var primitives = /* @__PURE__ */ fromFoldable110([
   /* @__PURE__ */ extern1(debugLog),
   /* @__PURE__ */ extern1(dims),
   /* @__PURE__ */ extern1(error_),
-  /* @__PURE__ */ extern1(loadJson),
   /* @__PURE__ */ unary2("floor")({ i: number, o: $$int, fwd: floor2 }),
   /* @__PURE__ */ unary2("log")({ i: intOrNumber, o: number, fwd: log3 }),
   /* @__PURE__ */ unary2("numToStr")({ i: intOrNumber, o: string, fwd: numToStr }),
@@ -23621,7 +23622,7 @@ var unions4 = /* @__PURE__ */ (() => {
   };
   return go(Leaf2);
 })();
-var identity25 = (x) => x;
+var identity27 = (x) => x;
 var verticesProgCxtVertex = {
   vertices: (v) => union7(unions13(listMap(verticesValVertex.vertices)(mapObjectString.values(v.primitives))))(union7(unions4(listMap(verticesModuleVertex.vertices)(v.mods)))(unions4(listMap((x) => verticesExprVertex.vertices(x._2))(v.datasets))))
 };
@@ -23698,13 +23699,47 @@ var traversableProgCxt = {
     const traverse9 = traversableEnv.traverse(dictApplicative);
     return (f) => (m) => Apply0.apply(Apply0.apply(Apply0.Functor0().map((v1) => (v2) => (v3) => ({ primitives: v3, mods: v2, datasets: v1 }))(traverse5(traversableTuple.traverse(dictApplicative)(traverse7(f)))(m.datasets)))(traverse5(traverse8(f))(m.mods)))(traverse9(f)(m.primitives));
   },
-  sequence: (dictApplicative) => (v) => traversableProgCxt.traverse(dictApplicative)(identity25)(v),
+  sequence: (dictApplicative) => (v) => traversableProgCxt.traverse(dictApplicative)(identity27)(v),
   Functor0: () => functorProgCxt,
   Foldable1: () => foldableProgCxt
 };
 
 // output-es/Module/index.js
+var all3 = /* @__PURE__ */ (() => foldableList.foldMap((() => {
+  const semigroupConj1 = { append: (v) => (v1) => v && v1 };
+  return { mempty: true, Semigroup0: () => semigroupConj1 };
+})()))();
+var elem2 = /* @__PURE__ */ (() => {
+  const any1 = foldableList.foldMap((() => {
+    const semigroupDisj1 = { append: (v) => (v1) => v || v1 };
+    return { mempty: false, Semigroup0: () => semigroupDisj1 };
+  })());
+  return (x) => any1(($0) => x === $0);
+})();
+var fromFoldable20 = /* @__PURE__ */ (() => foldableSet.foldr(Cons)(Nil))();
 var boundedLattice2 = { BoundedJoinSemilattice0: () => boundedJoinSemilatticeUni, BoundedMeetSemilattice1: () => boundedMeetSemilatticeUni };
+var unions5 = /* @__PURE__ */ (() => {
+  const go = (go$a0$copy) => (go$a1$copy) => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+    while (go$c) {
+      const b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = unionWith(ordDVertex$p)($$const)(b)(v._1);
+        go$a1 = v._2;
+        continue;
+      }
+      fail();
+    }
+    return go$r;
+  };
+  return go(Leaf2);
+})();
+var union8 = /* @__PURE__ */ (() => setSet(ordDVertex$p).union)();
 var concatM2 = (dictMonad) => foldrArray((() => {
   const $0 = dictMonad.Bind1();
   return (f) => (g) => (a) => $0.bind(f(a))(g);
@@ -23726,76 +23761,146 @@ var parse = (dictMonadError) => {
     };
   };
 };
-var parseProgram = (dictLoadFile) => (folders) => (file) => (dictMonadAff) => (dictMonadError) => dictMonadAff.MonadEffect0().Monad0().Bind1().bind(dictLoadFile.loadFile(dictMonadError)(dictMonadAff)(folders)(file))((() => {
-  const $0 = parse(dictMonadError);
-  return (a) => $0(a)(topLevel(expr_));
-})());
-var module_2 = (dictMonadAff) => {
+var loadModuleGraph = (dictMonadAff) => {
   const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-  const Bind1 = Monad0.Bind1();
-  const Applicative0 = Monad0.Applicative0();
+  const $0 = Monad0.Bind1();
+  const $1 = Monad0.Applicative0();
   return (dictMonadError) => {
     const parse1 = parse(dictMonadError);
     const desugarModuleFwd = moduleFwd(dictMonadError)(boundedLattice2);
-    return (dictLoadFile) => {
-      const loadFile = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-      return (folders) => (file) => (v) => {
-        const $0 = v.mods;
-        return Bind1.bind(Applicative0.pure())(() => Bind1.bind(loadFile(folders)(file))((src) => Bind1.bind(Bind1.bind(parse1(src)(module_))(desugarModuleFwd))((mod) => Applicative0.pure({
-          primitives: v.primitives,
-          mods: $List("Cons", mod, $0),
-          datasets: v.datasets
-        }))));
+    return (dictMonadReader) => {
+      const ask = dictMonadReader.MonadAsk0().ask;
+      return (dictLoadFile) => {
+        const loadFile3 = loadFile(dictLoadFile)(Monad0)(dictMonadError)(dictMonadAff);
+        return (roots) => {
+          const collectModules = (visited) => (graph) => (modules) => (imports) => {
+            if (imports.tag === "Nil") {
+              return $1.pure($Tuple(graph, modules));
+            }
+            if (imports.tag === "Cons") {
+              if ((() => {
+                const $2 = lookup2(ordString)(imports._1)(visited);
+                if ($2.tag === "Nothing") {
+                  return false;
+                }
+                if ($2.tag === "Just") {
+                  return true;
+                }
+                fail();
+              })()) {
+                return collectModules(visited)(graph)(modules)(imports._2);
+              }
+              return $0.bind($0.bind(ask)((v) => $0.bind(loadFile3(v.fluidSrcPaths)(imports._1 + ".fld"))((src) => $0.bind(parse1(src)(module_))((v1) => {
+                const $2 = v1._2;
+                return $0.bind(desugarModuleFwd(v1._1))((mod$p) => $1.pure($Tuple(
+                  mod$p,
+                  imports._1 === "lib/prelude" ? $2 : $List("Cons", "lib/prelude", $2)
+                )));
+              }))))((v) => collectModules(insert(ordString)(imports._1)()(visited))(insert(ordString)(imports._1)(v._2)(graph))(insert(ordString)(imports._1)(v._1)(modules))(foldableList.foldr(Cons)(imports._2)(v._2)));
+            }
+            fail();
+          };
+          return $0.bind(collectModules(Leaf2)(Leaf2)(Leaf2)(roots))((v) => {
+            const $2 = v._1;
+            return $1.pure({
+              roots,
+              topsorted: (() => {
+                const go = (go$a0$copy) => (go$a1$copy) => {
+                  let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+                  while (go$c) {
+                    const v$1 = go$a0, v1 = go$a1;
+                    if (v$1.tag === "Nil") {
+                      go$c = false;
+                      go$r = reverse2(v1);
+                      continue;
+                    }
+                    const v2 = find(foldableList)((mod) => {
+                      const v22 = lookup2(ordString)(mod)($2);
+                      if (v22.tag === "Nothing") {
+                        return true;
+                      }
+                      if (v22.tag === "Just") {
+                        return all3((dep) => !elem2(dep)(v$1))(v22._1);
+                      }
+                      fail();
+                    })(v$1);
+                    if (v2.tag === "Nothing") {
+                      go$c = false;
+                      go$r = throwException(error("Modules contain circular imports"))();
+                      continue;
+                    }
+                    if (v2.tag === "Just") {
+                      go$a0 = deleteBy(eqStringImpl)(v2._1)(v$1);
+                      go$a1 = $List("Cons", v2._1, v1);
+                      continue;
+                    }
+                    fail();
+                  }
+                  return go$r;
+                };
+                return go(fromFoldable20(functorMap.map((v$1) => {
+                })($2)))(Nil);
+              })(),
+              graph: $2,
+              modules: v._2
+            });
+          });
+        };
       };
     };
   };
 };
 var initialConfig = (dictMonadAff) => {
   const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-  const Bind1 = Monad0.Bind1();
-  const Applicative0 = Monad0.Applicative0();
-  const $0 = monadAllocAllocT(Monad0);
-  const fresh1 = $0.fresh;
-  const alloc = traversableProgCxt.traverse($0.Monad0().Applicative0())((v) => fresh1);
-  const $1 = bindStateT(Monad0);
+  const $0 = bindStateT(Monad0);
+  const $1 = monadAllocAllocT(Monad0);
+  const Applicative0 = $1.Monad0().Applicative0();
+  const fresh1 = $1.fresh;
+  const alloc1 = traversableProgCxt.traverse(Applicative0)((v) => fresh1);
+  const applicativeStateT2 = applicativeStateT(Monad0);
+  const traverse1 = traversableMap.traverse(applicativeStateT2);
+  const alloc2 = traversableModule.traverse(Applicative0)((v) => fresh1);
   const runWithGraphT_spy2 = runWithGraphT_spy({
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const monadAffState2 = monadAffState(dictMonadAff);
-  const monadAffState1 = monadAffState(monadAffState2);
-  const $2 = monadAffState2.MonadEffect0().Monad0();
+  const $2 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
   const $3 = dictMonadAff.MonadEffect0().Monad0();
   return (dictMonadError) => {
     const eval_progCxt2 = eval_progCxt(monadWithGraphAllocWithGr(dictMonadError));
     return (dictMonadReader) => {
-      const eval_progCxt1 = eval_progCxt2(monadReaderStateT(monadReaderStateT(dictMonadReader)))(monadAffState1);
+      const eval_progCxt1 = eval_progCxt2(monadReaderStateT(monadReaderStateT(dictMonadReader)));
       return (dictLoadFile) => {
         const eval_progCxt22 = eval_progCxt1((() => {
-          const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+          const loadFileFromPath1 = dictLoadFile.loadFileFromPath(dictMonadError)(dictMonadAff);
           return {
-            loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-              const $4 = loadFile1(folders);
-              return (x) => {
-                const $5 = $4(x);
-                return (s) => $2.Bind1().bind((s$1) => $3.Bind1().bind($5)((x$1) => $3.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $2.Applicative0().pure($Tuple(
-                  x$1,
-                  s
-                )));
-              };
+            loadFileFromPath: (dictMonadError1) => (dictMonadAff1) => (x) => {
+              const $4 = loadFileFromPath1(x);
+              return (s) => $2.Bind1().bind((s$1) => $3.Bind1().bind($4)((x$1) => $3.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $2.Applicative0().pure($Tuple(
+                x$1,
+                s
+              )));
             }
           };
         })());
-        return (dictFV) => (e) => (progCxt) => Bind1.bind(Applicative0.pure())(() => Bind1.bind(runAllocT(Monad0)($1.bind(alloc(progCxt))((progCxt$p) => $1.bind(runWithGraphT_spy2(eval_progCxt22(progCxt$p))(verticesProgCxtVertex.vertices(progCxt$p)))((v) => applicativeStateT(Monad0).pure($Tuple(
+        return (dictFV) => (e) => (progCxt) => (moduleCxt) => Monad0.Bind1().bind(runAllocT(Monad0)($0.bind(alloc1(progCxt))((progCxt$p) => $0.bind(traverse1(alloc2)(moduleCxt.modules))((modules$p) => $0.bind(runWithGraphT_spy2(eval_progCxt22(progCxt$p)({
+          modules: modules$p,
+          graph: moduleCxt.graph,
+          roots: moduleCxt.roots,
+          topsorted: moduleCxt.topsorted
+        }))(union8(verticesProgCxtVertex.vertices(progCxt$p))(unions5(listMap(verticesModuleVertex.vertices)(foldableMap.foldr(Cons)(Nil)(modules$p))))))((v) => applicativeStateT2.pure($Tuple(
           progCxt$p,
-          (() => {
-            const $4 = dictFV.fv(e);
-            return filterWithKey2((x) => {
-              const $5 = setSet(ordString).member(x)($4);
-              return (v$1) => $5;
-            })(v._2);
-          })()
-        )))))(0))((v) => Applicative0.pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2 })));
+          $Tuple(
+            modules$p,
+            (() => {
+              const $4 = dictFV.fv(e);
+              return filterWithKey2((x) => {
+                const $5 = setSet(ordString).member(x)($4);
+                return (v$1) => $5;
+              })(v._2);
+            })()
+          )
+        ))))))(0))((v) => Monad0.Applicative0().pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2._2 }));
       };
     };
   };
@@ -23803,37 +23908,46 @@ var initialConfig = (dictMonadAff) => {
 var prepConfig = (dictMonadAff) => {
   const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   const $0 = Monad0.Bind1();
+  const loadModuleGraph1 = loadModuleGraph(dictMonadAff);
   const initialConfig1 = initialConfig(dictMonadAff);
   return (dictMonadError) => {
+    const loadModuleGraph2 = loadModuleGraph1(dictMonadError);
     const desug1 = exprFwd(boundedLattice2)(dictMonadError)(joinSemilatticeUnit);
     const initialConfig2 = initialConfig1(dictMonadError);
     return (dictMonadReader) => {
-      const ask = dictMonadReader.MonadAsk0().ask;
+      const loadModuleGraph3 = loadModuleGraph2(dictMonadReader);
       const initialConfig3 = initialConfig2(dictMonadReader);
       return (dictLoadFile) => {
+        const loadModuleGraph4 = loadModuleGraph3(dictLoadFile);
         const initialConfig4 = initialConfig3(dictLoadFile)(fVExpr);
-        return (file) => (progCxt) => $0.bind(ask)((v) => $0.bind(parseProgram(dictLoadFile)(v.fluidSrcPaths)(file)(dictMonadAff)(dictMonadError))((s) => $0.bind(desug1(s))((e) => $0.bind(initialConfig4(e)(progCxt))((gconfig) => Monad0.Applicative0().pure({
-          s,
-          e,
-          gconfig
-        })))));
+        return (progCxt) => (fluidSrc) => $0.bind(parse(dictMonadError)(fluidSrc)(withImports(expr_)))((v) => {
+          const $1 = v._1;
+          return $0.bind(loadModuleGraph4($List("Cons", "lib/prelude", v._2)))((moduleCxt) => $0.bind(desug1($1))((e) => $0.bind(initialConfig4(e)(progCxt)(moduleCxt))((gconfig) => Monad0.Applicative0().pure({
+            s: $1,
+            e,
+            gconfig
+          }))));
+        });
       };
     };
   };
 };
 var datasetAs = (dictMonadAff) => {
   const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-  const $0 = Monad0.Bind1();
+  const Bind1 = Monad0.Bind1();
   return (dictMonadError) => {
     const desug1 = exprFwd(boundedLattice2)(dictMonadError)(joinSemilatticeUnit);
-    return (dictLoadFile) => (folders) => (v) => (v1) => {
-      const $1 = v1.datasets;
-      const $2 = v._1;
-      return $0.bind($0.bind(parseProgram(dictLoadFile)(folders)(v._2)(dictMonadAff)(dictMonadError))(desug1))((e\u03B1) => Monad0.Applicative0().pure({
-        primitives: v1.primitives,
-        mods: v1.mods,
-        datasets: $List("Cons", $Tuple($2, e\u03B1), $1)
-      }));
+    return (dictLoadFile) => {
+      const loadFile3 = loadFile(dictLoadFile)(Monad0)(dictMonadError)(dictMonadAff);
+      return (folders) => (v) => (v1) => {
+        const $0 = v1.datasets;
+        const $1 = v._1;
+        return Bind1.bind(loadFile3(folders)(v._2))((src) => Bind1.bind(Bind1.bind(Bind1.Apply0().Functor0().map(fst)(parse(dictMonadError)(src)(withImports(expr_))))(desug1))((e\u03B1) => Monad0.Applicative0().pure({
+          primitives: v1.primitives,
+          mods: v1.mods,
+          datasets: $List("Cons", $Tuple($1, e\u03B1), $0)
+        })));
+      };
     };
   };
 };
@@ -23841,21 +23955,18 @@ var loadProgCxt = (dictMonadAff) => {
   const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   const $0 = Monad0.Bind1();
   const concatM1 = concatM2(Monad0);
-  const module_1 = module_2(dictMonadAff);
   const datasetAs1 = datasetAs(dictMonadAff);
   return (dictMonadError) => {
-    const module_22 = module_1(dictMonadError);
     const datasetAs2 = datasetAs1(dictMonadError);
     return (dictMonadReader) => {
       const ask = dictMonadReader.MonadAsk0().ask;
       return (dictLoadFile) => {
-        const module_3 = module_22(dictLoadFile);
         const datasetAs3 = datasetAs2(dictLoadFile);
-        return (mods) => (datasets) => $0.bind(ask)((v) => $0.bind($0.bind(Monad0.Applicative0().pure({
+        return (datasets) => $0.bind(ask)((v) => $0.bind(Monad0.Applicative0().pure({
           primitives,
           mods: Nil,
           datasets: Nil
-        }))(concatM1(arrayMap(module_3(v.fluidSrcPaths))(["lib/prelude", ...mods]))))(concatM1(arrayMap((() => {
+        }))(concatM1(arrayMap((() => {
           const $1 = datasetAs3(v.fluidSrcPaths);
           return (x) => $1($Tuple(x._1, x._2));
         })())(datasets))));
@@ -23868,11 +23979,6 @@ var loadProgCxt = (dictMonadAff) => {
 var $Encoding = (tag) => tag;
 var UTF8 = /* @__PURE__ */ $Encoding("UTF8");
 
-// output-es/Data.Nullable/foreign.js
-function nullable(a, r, f) {
-  return a == null ? r : f(a);
-}
-
 // output-es/Node.FS.Constants/foreign.js
 import { constants } from "node:fs";
 var f_OK = constants.F_OK;
@@ -23980,47 +24086,24 @@ var toAff2 = (f) => (a) => (b) => {
   });
 };
 
-// output-es/Foreign/foreign.js
-var isArray = Array.isArray || function(value) {
-  return Object.prototype.toString.call(value) === "[object Array]";
-};
-
 // output-es/Node.FS.Stats/foreign.js
 var isFileImpl = (s) => s.isFile();
 
 // output-es/Module.Node/index.js
 var $$try3 = /* @__PURE__ */ $$try(monadErrorAff);
-var findM = (dictMonad) => {
-  const $0 = dictMonad.Bind1().Apply0();
-  return (dictFoldable) => (xs) => (f) => (base) => dictFoldable.foldr((x) => (acc) => $0.apply($0.Functor0().map(altMaybe.alt)(acc))(f(x)))(dictMonad.Applicative0().pure(base))(xs);
-};
 var loadFileNodeT = (dictMonad) => {
-  const bind4 = bindReaderT(dictMonad.Bind1()).bind;
-  const $0 = dictMonad.Applicative0();
-  const findM1 = findM(monadReaderT(dictMonad))(foldableArray);
+  const Bind1 = dictMonad.Bind1();
+  const $0 = Bind1.Apply0().Functor0();
+  const $1 = dictMonad.Applicative0();
   return {
-    loadFile: (dictMonadError) => (dictMonadAff) => (folders) => (v) => bind4(findM1(arrayMap((() => {
-      const $1 = v + ".fld";
-      return (a) => a + "/" + $1;
-    })())(folders))((v1) => bind4(dictMonadAff.liftAff($$try3(toAff1(stat2)(v1))))((stats) => {
-      const $1 = $0.pure((() => {
-        if (stats.tag === "Left") {
-          return false;
-        }
-        if (stats.tag === "Right") {
-          return isFileImpl(stats._1);
-        }
-        fail();
-      })() ? $Maybe("Just", v1) : Nothing);
-      return (v$1) => $1;
-    }))(Nothing))((url) => {
-      if (url.tag === "Nothing") {
-        return throwException(error("File " + v + " not found."))();
-      }
-      if (url.tag === "Just") {
-        return dictMonadAff.liftAff(toAff2(readTextFile)(UTF8)(url._1));
-      }
-      fail();
+    loadFileFromPath: (dictMonadError) => (dictMonadAff) => (v) => bindReaderT(Bind1).bind(dictMonadAff.liftAff($$try3(toAff1(stat2)(v))))((stats) => {
+      if (stats.tag === "Right" && isFileImpl(stats._1)) {
+        const $22 = $0.map(Just);
+        const $3 = dictMonadAff.liftAff(toAff2(readTextFile)(UTF8)(v));
+        return (x) => $22($3(x));
+      }
+      const $2 = $1.pure(Nothing);
+      return (v$1) => $2;
     })
   };
 };
@@ -24808,7 +24891,7 @@ var manyM = (p) => freeMonadRec.tailRecM((acc) => $Free(
 var $DefaultProp = (_1, _2) => ({ tag: "DefaultProp", _1, _2 });
 var $Mod = (_1, _2, _3) => ({ tag: "Mod", _1, _2, _3 });
 var lookup4 = /* @__PURE__ */ lookup(foldableArray)(eqString);
-var identity26 = (x) => x;
+var identity28 = (x) => x;
 var Mod = (value0) => (value1) => (value2) => $Mod(value0, value1, value2);
 var optionFieldsHasName = { name: (n) => (fields) => ({ optNames: [n, ...fields.optNames], optCompleter: fields.optCompleter, optNoArgError: fields.optNoArgError }) };
 var mkCommand = (m) => {
@@ -24819,8 +24902,8 @@ var mkCommand = (m) => {
 var modSemigroup = {
   append: (v) => (v1) => $Mod((x) => v1._1(v._1(x)), $DefaultProp(v1._2._1.tag === "Nothing" ? v._2._1 : v1._2._1, v1._2._2.tag === "Nothing" ? v._2._2 : v1._2._2), (x) => v1._3(v._3(x)))
 };
-var modMonoid = { mempty: /* @__PURE__ */ $Mod(identity26, /* @__PURE__ */ $DefaultProp(Nothing, Nothing), identity26), Semigroup0: () => modSemigroup };
-var optionMod = /* @__PURE__ */ Mod(identity26)(/* @__PURE__ */ $DefaultProp(Nothing, Nothing));
+var modMonoid = { mempty: /* @__PURE__ */ $Mod(identity28, /* @__PURE__ */ $DefaultProp(Nothing, Nothing), identity28), Semigroup0: () => modSemigroup };
+var optionMod = /* @__PURE__ */ Mod(identity28)(/* @__PURE__ */ $DefaultProp(Nothing, Nothing));
 var internal = /* @__PURE__ */ optionMod((p) => ({ propVisibility: Internal, propDescMod: p.propDescMod, propHelp: p.propHelp, propMetaVar: p.propMetaVar, propShowDefault: p.propShowDefault }));
 var baseProps = /* @__PURE__ */ (() => ({
   propMetaVar: "",
@@ -24851,7 +24934,7 @@ var mkParser = (v) => (g) => (rdr) => {
 };
 
 // output-es/Options.Applicative.Builder/index.js
-var identity27 = (x) => x;
+var identity29 = (x) => x;
 var mempty12 = /* @__PURE__ */ (() => chunkMonoid(docSemigroup).mempty)();
 var min3 = (x) => (y) => {
   const v = optVisibilityOrd.compare(x)(y);
@@ -24951,19 +25034,19 @@ var defaultPrefs = {
 var command = (cmd) => (pinfo) => $Mod(
   (p) => ({ cmdCommands: [$Tuple(cmd, pinfo), ...p.cmdCommands], cmdGroup: p.cmdGroup }),
   $DefaultProp(Nothing, Nothing),
-  identity26
+  identity28
 );
 var abortOption = (err) => (m) => {
   const $0 = fold3([
     $Mod(
       (p) => ({ optNoArgError: (v) => err, optCompleter: p.optCompleter, optNames: p.optNames }),
       $DefaultProp(Nothing, Nothing),
-      identity26
+      identity28
     ),
     $Mod(
-      identity27,
-      $DefaultProp($Maybe("Just", identity27), Nothing),
-      identity27
+      identity29,
+      $DefaultProp($Maybe("Just", identity29), Nothing),
+      identity29
     ),
     optionMod((p) => ({ propMetaVar: "", propDescMod: p.propDescMod, propHelp: p.propHelp, propShowDefault: p.propShowDefault, propVisibility: p.propVisibility }))
   ]);
@@ -25043,7 +25126,7 @@ var modify_ = /* @__PURE__ */ (() => {
   return (f) => $0.state((s) => $Tuple(void 0, f(s)));
 })();
 var throwError = /* @__PURE__ */ (() => monadThrowExceptT(monadStateT).throwError)();
-var identity28 = (x) => x;
+var identity30 = (x) => x;
 var TNil = /* @__PURE__ */ $TStep("TNil");
 var ComplResult = (value0) => $ComplResult("ComplResult", value0);
 var runListT = (dictMonad) => (xs) => dictMonad.Bind1().bind(xs)((s) => {
@@ -25294,10 +25377,10 @@ var nondetTAltOp = (dictMonad) => {
   const monadStateT1 = { Applicative0: () => applicativeStateT(dictMonad), Bind1: () => bindStateT(dictMonad) };
   const listTBind1 = listTBind(monadStateT1);
   const lift6 = listTMonadTrans.lift(monadStateT1);
-  const $$get2 = monadStateStateT(dictMonad).state((s) => $Tuple(s, s));
+  const $$get3 = monadStateStateT(dictMonad).state((s) => $Tuple(s, s));
   const $0 = listTAlternative(monadStateT1);
   const empty3 = $0.Plus1().empty;
-  return (m1) => (m2) => listTAlt(monadStateT1).alt(m1)(listTBind1.bind(lift6($$get2))((s) => listTBind1.bind(!s ? $0.Applicative0().pure() : empty3)(() => m2)));
+  return (m1) => (m2) => listTAlt(monadStateT1).alt(m1)(listTBind1.bind(lift6($$get3))((s) => listTBind1.bind(!s ? $0.Applicative0().pure() : empty3)(() => m2)));
 };
 var nondetTFunctor = (dictMonad) => ({ map: (f) => listTFunctor({ Applicative0: () => applicativeStateT(dictMonad), Bind1: () => bindStateT(dictMonad) }).map(f) });
 var nondetTAlt = (dictMonad) => {
@@ -25341,7 +25424,7 @@ var takeListT = (dictMonad) => {
     if (v === 0) {
       return (v$1) => empty3;
     }
-    const $0 = bimapTStep(identity28)(takeListT(dictMonad)(v - 1 | 0));
+    const $0 = bimapTStep(identity30)(takeListT(dictMonad)(v - 1 | 0));
     return (x) => dictMonad.Bind1().bind(x)((a$p) => dictMonad.Applicative0().pure($0(a$p)));
   };
 };
@@ -25360,7 +25443,7 @@ var any2 = /* @__PURE__ */ (() => foldableArray.foldMap((() => {
   const semigroupDisj1 = { append: (v) => (v1) => v || v1 };
   return { mempty: false, Semigroup0: () => semigroupDisj1 };
 })()))();
-var elem2 = /* @__PURE__ */ (() => {
+var elem3 = /* @__PURE__ */ (() => {
   const any1 = foldableArray.foldMap((() => {
     const semigroupDisj1 = { append: (v) => (v1) => v || v1 };
     return { mempty: false, Semigroup0: () => semigroupDisj1 };
@@ -25469,16 +25552,16 @@ var optMatches = (dictMonadP) => {
   const Monad0 = dictMonadP.Monad0();
   const bindStateT2 = bindStateT(Monad0);
   const monadStateStateT2 = monadStateStateT(Monad0);
-  const $$get2 = monadStateStateT2.state((s) => $Tuple(s, s));
+  const $$get3 = monadStateStateT2.state((s) => $Tuple(s, s));
   const $0 = applicativeStateT(Monad0);
   const $1 = dictMonadP.Monad0().Applicative0().pure;
   return (disambiguate) => (opt) => (v) => {
     if (opt.tag === "OptReader") {
-      const $2 = (disambiguate ? any2(isOptionPrefix(v._1))(opt._1) : elem2(v._1)(opt._1)) ? $Maybe("Just", void 0) : Nothing;
+      const $2 = (disambiguate ? any2(isOptionPrefix(v._1))(opt._1) : elem3(v._1)(opt._1)) ? $Maybe("Just", void 0) : Nothing;
       if ($2.tag === "Just") {
         return $Maybe(
           "Just",
-          bindStateT2.bind($$get2)((args) => {
+          bindStateT2.bind($$get3)((args) => {
             const missing_arg = dictMonadP.missingArgP(opt._3(showOption(v._1)))(opt._2.crCompleter);
             return bindStateT2.bind((() => {
               if (v._2.tag === "Nothing") {
@@ -25518,7 +25601,7 @@ var optMatches = (dictMonadP) => {
       }
       fail();
     }
-    if (opt.tag === "FlagReader" && (disambiguate ? any2(isOptionPrefix(v._1))(opt._1) : elem2(v._1)(opt._1)) && ((() => {
+    if (opt.tag === "FlagReader" && (disambiguate ? any2(isOptionPrefix(v._1))(opt._1) : elem3(v._1)(opt._1)) && ((() => {
       if (v._1.tag === "OptShort") {
         return true;
       }
@@ -25537,7 +25620,7 @@ var optMatches = (dictMonadP) => {
     })())) {
       return $Maybe(
         "Just",
-        bindStateT2.bind($$get2)((args) => bindStateT2.bind((() => {
+        bindStateT2.bind($$get3)((args) => bindStateT2.bind((() => {
           if (v._2.tag === "Just") {
             const $2 = $List("Cons", fromCharArray(["-", ...toCharArray(v._2._1)]), args);
             return monadStateStateT2.state((v$1) => $Tuple(void 0, $2));
@@ -25687,7 +25770,7 @@ var searchArg = (dictMonadP) => {
   const bindStateT2 = bindStateT(Monad0);
   const $1 = applyStateT(Monad0);
   const monadStateStateT2 = monadStateStateT(Monad0);
-  const $$get2 = monadStateStateT2.state((s) => $Tuple(s, s));
+  const $$get3 = monadStateStateT2.state((s) => $Tuple(s, s));
   const $2 = dictMonadP.Alt1().Functor0();
   const Apply0 = Monad0.Bind1().Apply0();
   const exitContext = dictMonadP.exitContext;
@@ -25700,7 +25783,7 @@ var searchArg = (dictMonadP) => {
       if ($5.tag === "Just") {
         if (prefs.prefBacktrack === "NoBacktrack") {
           const $6 = $5._1;
-          return lift2(bindStateT2.bind($1.apply($1.Functor0().map($$const)($$get2))(monadStateStateT2.state((v) => $Tuple(void 0, Nil))))((args) => {
+          return lift2(bindStateT2.bind($1.apply($1.Functor0().map($$const)($$get3))(monadStateStateT2.state((v) => $Tuple(void 0, Nil))))((args) => {
             const $7 = Apply0.apply(Apply0.Functor0().map($$const)(Apply0.apply(Apply0.Functor0().map((v) => identity)(dictMonadP.enterContext(arg)($6)))(runParserInfo(dictMonadP)($6)(args))))(exitContext);
             return (s) => $2.map((v1) => $Tuple($Parser("NilP", v1._1), v1._2))(Monad0.Bind1().bind($7)((x) => Monad0.Applicative0().pure($Tuple(
               x,
@@ -25916,7 +25999,7 @@ var mapParser = (f) => {
 // output-es/Options.Applicative.BashCompletion/index.js
 var $Richness = (tag, _1, _2) => ({ tag, _1, _2 });
 var fromFoldable24 = /* @__PURE__ */ foldrArray(Cons)(Nil);
-var identity29 = (x) => x;
+var identity31 = (x) => x;
 var fold4 = /* @__PURE__ */ (() => foldableArray.foldMap(monoidArray)(identity3))();
 var sequence = /* @__PURE__ */ (() => traversableArray.traverse(applicativeEffect)(identity4))();
 var unLines = (xs) => foldlArray((v) => (v1) => {
@@ -25925,7 +26008,7 @@ var unLines = (xs) => foldlArray((v) => (v1) => {
   }
   return { init: false, acc: v.acc + "\n" + v1 };
 })({ init: true, acc: "" })(xs).acc;
-var fromFoldable111 = /* @__PURE__ */ (() => fromFoldableImpl(foldableList.foldr))();
+var fromFoldable110 = /* @__PURE__ */ (() => fromFoldableImpl(foldableList.foldr))();
 var Standard = /* @__PURE__ */ $Richness("Standard");
 var Enriched = (value0) => (value1) => $Richness("Enriched", value0, value1);
 var zshCompletionScript = (prog) => (progn) => {
@@ -26029,7 +26112,7 @@ var bashCompletionQuery = (pinfo) => (pprefs) => (richness) => (ws) => (i) => (v
   const $0 = arrayMap(showOption);
   const add_opt_help1 = (opt) => {
     if (richness.tag === "Standard") {
-      return identity29;
+      return identity31;
     }
     if (richness.tag === "Enriched") {
       const $1 = richness._1;
@@ -26102,7 +26185,7 @@ var bashCompletionQuery = (pinfo) => (pprefs) => (richness) => (ws) => (i) => (v
           }
           const $22 = (() => {
             if (richness.tag === "Standard") {
-              return identity29;
+              return identity31;
             }
             if (richness.tag === "Enriched") {
               const $23 = richness._2;
@@ -26238,7 +26321,7 @@ var bashCompletionParser = (pinfo) => (pprefs) => $Parser(
             ),
             $Parser("NilP", Standard)
           )),
-          parserFunctor.map(fromFoldable111)($Parser(
+          parserFunctor.map(fromFoldable110)($Parser(
             "BindP",
             manyM(option(readerAsk)($Mod(
               (x) => internal._1({
@@ -26383,7 +26466,7 @@ var helpText = (v) => {
 var fold5 = /* @__PURE__ */ (() => foldableArray.foldMap(monoidArray)(identity3))();
 var chunkMonoid3 = /* @__PURE__ */ chunkMonoid(docSemigroup);
 var listToChunk2 = /* @__PURE__ */ listToChunk(docMonoid);
-var identity30 = (x) => x;
+var identity32 = (x) => x;
 var mempty2 = /* @__PURE__ */ (() => $Tuple(monoidMaybe(semigroupString).mempty, chunkMonoid3.mempty))();
 var usageHelp = (chunk) => ({
   helpUsage: chunk,
@@ -26423,7 +26506,7 @@ var optDesc = (pprefs) => (style) => (info2) => (opt) => {
   })()));
   return (() => {
     if (opt.optProps.propDescMod.tag === "Nothing") {
-      return identity30;
+      return identity32;
     }
     if (opt.optProps.propDescMod.tag === "Just") {
       return functorMaybe.map(opt.optProps.propDescMod._1);
@@ -27103,12 +27186,12 @@ var helper = /* @__PURE__ */ (() => abortOption(ShowHelpText)(foldableArray.fold
   $Mod(
     optionFieldsHasName.name($OptName("OptLong", "help")),
     $DefaultProp(Nothing, Nothing),
-    identity26
+    identity28
   ),
   $Mod(
     optionFieldsHasName.name($OptName("OptShort", "h")),
     $DefaultProp(Nothing, Nothing),
-    identity26
+    identity28
   ),
   help("Show this help text"),
   hidden
@@ -27194,9 +27277,9 @@ var monadErrorErrorNodeT = /* @__PURE__ */ monadErrorReaderT(monadErrorAff);
 var monadReaderFileCxtNodeT = /* @__PURE__ */ monadReaderReaderT(monadAff);
 var loadFileNodeT2 = /* @__PURE__ */ loadFileNodeT(monadAff);
 var loadProgCxt2 = /* @__PURE__ */ loadProgCxt(monadAffNodeT)(monadErrorErrorNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2);
+var loadFile2 = /* @__PURE__ */ loadFile(loadFileNodeT2)(/* @__PURE__ */ monadReaderT(monadAff))(monadErrorErrorNodeT)(monadAffNodeT);
 var prepConfig2 = /* @__PURE__ */ prepConfig(monadAffNodeT)(monadErrorErrorNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2);
 var graphEval2 = /* @__PURE__ */ graphEval(monadAffNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2)(monadErrorErrorNodeT);
-var fromFoldable26 = /* @__PURE__ */ (() => fromFoldableImpl(foldableList.foldr))();
 var Evaluate = (value0) => $Command(value0);
 var parseLocal = /* @__PURE__ */ $Parser(
   "AltP",
@@ -27215,30 +27298,14 @@ var parseLocal = /* @__PURE__ */ $Parser(
   })()),
   /* @__PURE__ */ $Parser("NilP", false)
 );
-var parseImports = /* @__PURE__ */ $Parser(
-  "BindP",
-  /* @__PURE__ */ manyM(/* @__PURE__ */ option(readerAsk)(/* @__PURE__ */ (() => {
-    const $0 = help("Comma-separated list of files to import");
-    const $1 = $0._2._1.tag === "Nothing" ? Nothing : $0._2._1;
-    const $2 = $0._2._2.tag === "Nothing" ? Nothing : $0._2._2;
-    return $Mod(
-      (x) => $0._1({
-        optNames: [$OptName("OptShort", "i"), $OptName("OptLong", "imports"), ...x.optNames],
-        optCompleter: x.optCompleter,
-        optNoArgError: x.optNoArgError
-      }),
-      $DefaultProp($1.tag === "Nothing" ? Nothing : $1, $2.tag === "Nothing" ? Nothing : $2),
-      (x) => $0._3(x)
-    );
-  })()))
-);
 var evaluate = (v) => {
   const $0 = v._1.fileName;
-  return bind3(loadProgCxt2(v._1.imports)(v._1.datasets))((progCxt) => bind3(prepConfig2($0)(progCxt))((v1) => bind3(graphEval2(v1.gconfig)(v1.e))((v2) => {
+  const fluidSrcPaths = [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []];
+  return bind3(loadProgCxt2(v._1.datasets))((progCxt) => bind3(loadFile2(fluidSrcPaths)($0))((fluidSrc) => bind3(prepConfig2(progCxt)(fluidSrc))((v1) => bind3(graphEval2(v1.gconfig)(v1.e))((v2) => {
     const $1 = _pure(functorVal.map((v$1) => {
     })(v2["out\u03B1"]));
     return (v$1) => $1;
-  })))({ fluidSrcPaths: [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []] });
+  }))))({ fluidSrcPaths });
 };
 var dispatchCommand = (v) => _bind(evaluate(v._1))((v1) => _liftEffect(log(intercalate4("\n")(removeDocWS(prettyVal(highlightableUnit).pretty(v1)).lines))));
 var callback = (v) => {
@@ -27303,14 +27370,8 @@ var parseEvaluate = /* @__PURE__ */ (() => $Parser(
         $Parser(
           "MultP",
           $MultPE(
-            $Parser(
-              "MultP",
-              $MultPE(
-                parserFunctor.map((v) => (v1) => (v2) => (v3) => (v4) => $EvalArgs({ local: v, imports: v1, datasets: v2, fileName: v3, fluidSrcPath: v4 }))(parseLocal),
-                parserFunctor.map(fromFoldable26)(parseImports)
-              )
-            ),
-            parserFunctor.map(fromFoldable26)(parseDatasets)
+            parserFunctor.map((v) => (v1) => (v2) => (v3) => $EvalArgs({ local: v, datasets: v1, fileName: v2, fluidSrcPath: v3 }))(parseLocal),
+            parserFunctor.map(fromFoldableImpl(foldableList.foldr))(parseDatasets)
           )
         ),
         option(readerAsk)((() => {