@explorable-viz/fluid 0.7.100 → 0.7.102

package/dist/fluid/shared/load-figure.js

@@ -36216,7 +36216,7 @@ var unary = (dictBoundedJoinSemilattice) => {
               arity: 1,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (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))));
@@ -36365,7 +36365,7 @@ var binaryZero = (dictBoundedJoinSemilattice) => {
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (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);
@@ -36413,7 +36413,7 @@ var binary = (dictBoundedJoinSemilattice) => {
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
                     return $$new((a) => Val(a)(None))(insert3(ordVertex)(v._2._1._1)()($$$Map(
                       "Two",
@@ -39532,6 +39532,27 @@ var applyStateT = (dictMonad) => {
   };
 };
 var applicativeStateT = (dictMonad) => ({ pure: (a) => (s) => dictMonad.Applicative0().pure($Tuple(a, s)), Apply0: () => applyStateT(dictMonad) });
+var monadAskStateT = (dictMonadAsk) => {
+  const Monad0 = dictMonadAsk.Monad0();
+  const monadStateT1 = { Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0) };
+  return {
+    ask: (() => {
+      const $0 = dictMonadAsk.ask;
+      return (s) => Monad0.Bind1().bind($0)((x2) => Monad0.Applicative0().pure($Tuple(x2, s)));
+    })(),
+    Monad0: () => monadStateT1
+  };
+};
+var monadReaderStateT = (dictMonadReader) => {
+  const monadAskStateT1 = monadAskStateT(dictMonadReader.MonadAsk0());
+  return {
+    local: (x2) => {
+      const $0 = dictMonadReader.local(x2);
+      return (v) => (x$1) => $0(v(x$1));
+    },
+    MonadAsk0: () => monadAskStateT1
+  };
+};
 var monadEffectState = (dictMonadEffect) => {
   const Monad0 = dictMonadEffect.Monad0();
   const monadStateT1 = { Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0) };
@@ -39579,8 +39600,87 @@ var monadErrorStateT = (dictMonadError) => {
   return { catchError: (v) => (h) => (s) => dictMonadError.catchError(v(s))((e) => h(e)(s)), MonadThrow0: () => monadThrowStateT1 };
 };
 
+// output-es/Control.Monad.Reader.Trans/index.js
+var withReaderT = (f) => (v) => (x2) => v(f(x2));
+var bindReaderT = (dictBind) => {
+  const $0 = dictBind.Apply0();
+  const $1 = $0.Functor0();
+  const applyReaderT1 = (() => {
+    const functorReaderT1 = {
+      map: (x2) => {
+        const $2 = $1.map(x2);
+        return (v) => (x$1) => $2(v(x$1));
+      }
+    };
+    return { apply: (v) => (v1) => (r) => $0.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
+  })();
+  return { bind: (v) => (k) => (r) => dictBind.bind(v(r))((a) => k(a)(r)), Apply0: () => applyReaderT1 };
+};
+var monadReaderT = (dictMonad) => {
+  const $0 = dictMonad.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeReaderT1 = (() => {
+    const $2 = $1.Functor0();
+    const functorReaderT1 = {
+      map: (x2) => {
+        const $3 = $2.map(x2);
+        return (v) => (x$1) => $3(v(x$1));
+      }
+    };
+    const applyReaderT1 = { apply: (v) => (v1) => (r) => $1.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
+    return {
+      pure: (x2) => {
+        const $3 = $0.pure(x2);
+        return (v) => $3;
+      },
+      Apply0: () => applyReaderT1
+    };
+  })();
+  const bindReaderT1 = bindReaderT(dictMonad.Bind1());
+  return { Applicative0: () => applicativeReaderT1, Bind1: () => bindReaderT1 };
+};
+var monadReaderReaderT = (dictMonad) => {
+  const monadReaderT1 = monadReaderT(dictMonad);
+  const monadAskReaderT1 = { ask: dictMonad.Applicative0().pure, Monad0: () => monadReaderT1 };
+  return { local: withReaderT, MonadAsk0: () => monadAskReaderT1 };
+};
+var monadEffectReader = (dictMonadEffect) => {
+  const monadReaderT1 = monadReaderT(dictMonadEffect.Monad0());
+  return {
+    liftEffect: (x2) => {
+      const $0 = dictMonadEffect.liftEffect(x2);
+      return (v) => $0;
+    },
+    Monad0: () => monadReaderT1
+  };
+};
+var monadThrowReaderT = (dictMonadThrow) => {
+  const monadReaderT1 = monadReaderT(dictMonadThrow.Monad0());
+  return {
+    throwError: (x2) => {
+      const $0 = dictMonadThrow.throwError(x2);
+      return (v) => $0;
+    },
+    Monad0: () => monadReaderT1
+  };
+};
+var monadErrorReaderT = (dictMonadError) => {
+  const monadThrowReaderT1 = monadThrowReaderT(dictMonadError.MonadThrow0());
+  return { catchError: (v) => (h) => (r) => dictMonadError.catchError(v(r))((e) => h(e)(r)), MonadThrow0: () => monadThrowReaderT1 };
+};
+
 // output-es/Effect.Aff.Class/index.js
 var monadAffAff = { liftAff: (x2) => x2, MonadEffect0: () => monadEffectAff };
+var monadAffReader = (dictMonadAff) => {
+  const monadEffectReader2 = monadEffectReader(dictMonadAff.MonadEffect0());
+  return {
+    liftAff: (x2) => {
+      const $0 = dictMonadAff.liftAff(x2);
+      return (v) => $0;
+    },
+    MonadEffect0: () => monadEffectReader2
+  };
+};
 var monadAffState = (dictMonadAff) => {
   const MonadEffect0 = dictMonadAff.MonadEffect0();
   const monadEffectState2 = monadEffectState(MonadEffect0);
@@ -39986,23 +40086,28 @@ var closeDefs = (dictMonadWithGraphAlloc) => {
 };
 var new$p = (dictMonadWithGraphAlloc) => {
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-  const MonadWithGraph2 = dictMonadWithGraphAlloc.MonadWithGraph2();
-  const Monad0 = MonadWithGraph2.Monad0();
-  const Bind1 = Monad0.Bind1();
   const fresh = dictMonadWithGraphAlloc.MonadAlloc0().fresh;
-  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)(dictLoadFile)(unionWith((v$1) => identity18)(v)((() => {
-      const $0 = {};
-      $0.this = $Val(\u03B1, None, v3);
-      return $0;
-    })()))(v2))((vdoc) => Bind1.bind(MonadWithGraph2.extend($Tuple(\u03B1, pack10($Val(\u03B1, vdoc, v3))))(v1))(() => Monad0.Applicative0().pure($Val(\u03B1, vdoc, v3)))));
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Monad0 = dictMonadAff.MonadEffect0().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)(unionWith((v$1) => identity18)(v)((() => {
+        const $0 = {};
+        $0.this = $Val(\u03B1, None, v3);
+        return $0;
+      })()))(v2))((vdoc) => Bind1.bind(dictMonadWithGraphAlloc.MonadWithGraph2().extend($Tuple(\u03B1, pack10($Val(\u03B1, vdoc, v3))))(v1))(() => Monad0.Applicative0().pure($Val(
+        \u03B1,
+        vdoc,
+        v3
+      )))));
+    };
   };
 };
-var evalDocOpt = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
+var evalDocOpt = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
+  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   const Applicative0 = Monad0.Applicative0();
   const $0 = Monad0.Bind1().Apply0().Functor0();
   const sequence2 = traversableList.traverse(Applicative0)(identity7);
@@ -40016,7 +40121,7 @@ var evalDocOpt = (dictMonadWithGraphAlloc) => {
           return Applicative0.pure($DocCommentElem("Token", v2._1));
         }
         if (v2.tag === "Unquote") {
-          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v2._1)(setSet4.empty));
+          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v2._1)(setSet4.empty));
         }
         fail();
       })(v1._1)));
@@ -40028,195 +40133,210 @@ var $$eval = (dictMonadWithGraphAlloc) => {
   const MonadError1 = dictMonadWithGraphAlloc.MonadError1();
   const withMsg2 = withMsg(MonadError1);
   const MonadThrow0 = MonadError1.MonadThrow0();
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().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 checkArity2 = checkArity(MonadError1);
-  const sequence2 = traversableArray.traverse(Applicative0)(identity5);
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
-  return (dictLoadFile) => (v) => (v1) => (v2) => {
-    if (v1.tag === "Var") {
-      return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
-    }
-    if (v1.tag === "Op") {
-      return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
-    }
-    if (v1.tag === "Int") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert3(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Int", v1._3));
-    }
-    if (v1.tag === "Float") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert3(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Float", v1._3));
-    }
-    if (v1.tag === "Str") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert3(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)(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)(dictLoadFile)(v)(insert3(ordVertex)($2)()(v2))($1)($BaseVal(
-          "Dictionary",
-          fromFoldable110(zipWith2(Tuple)(v4._1)(zipWith2(Tuple)(v4._2)(v3._2)))
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Monad0 = dictMonadAff.MonadEffect0().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 sequence2 = traversableArray.traverse(Applicative0)(identity5);
+    return (dictLoadFile) => (v) => (v1) => (v2) => {
+      if (v1.tag === "Var") {
+        return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
+      }
+      if (v1.tag === "Op") {
+        return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
+      }
+      if (v1.tag === "Int") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert3(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
+          "Int",
+          v1._3
         ));
-      });
-    }
-    if (v1.tag === "Constr") {
-      const $1 = v1._3;
-      const $2 = v1._2;
-      const $3 = v1._4;
-      const $4 = v1._1;
-      return Bind1.bind(checkArity2($1)((() => {
-        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 = b + 1 | 0;
-              go$a1 = v$1._2;
-              continue;
+      }
+      if (v1.tag === "Float") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert3(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
+          "Float",
+          v1._3
+        ));
+      }
+      if (v1.tag === "Str") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert3(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 (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)(insert3(ordVertex)($2)()(v2))($1)($BaseVal(
+            "Dictionary",
+            fromFoldable110(zipWith2(Tuple)(v4._1)(zipWith2(Tuple)(v4._2)(v3._2)))
+          ));
+        });
+      }
+      if (v1.tag === "Constr") {
+        const $1 = v1._3;
+        const $2 = v1._2;
+        const $3 = v1._4;
+        const $4 = v1._1;
+        return Bind1.bind(checkArity2($1)((() => {
+          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 = b + 1 | 0;
+                go$a1 = v$1._2;
+                continue;
+              }
+              fail();
             }
-            fail();
-          }
-          return go$r;
-        };
-        return go(0)($3);
-      })()))(() => Bind1.bind(traverse2((() => {
-        const $5 = $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v);
-        return (a) => $5(a)(v2);
-      })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert3(ordVertex)($4)()(v2))($2)($BaseVal("Constr", $1, vs))));
-    }
-    if (v1.tag === "Matrix") {
-      const $1 = v1._2;
-      const $2 = v1._3;
-      const $3 = v1._4._1;
-      const $4 = v1._4._2;
-      const $5 = v1._1;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._5)(v2))((v3) => {
-        const v5 = intPair.unpack(v3._3);
-        const $6 = v5._1._1;
-        const $7 = v5._2._1;
-        const $8 = v5._1._2;
-        const $9 = v5._2._2;
-        return Bind1.bind(check(MonadThrow0)(greaterThanOrEq($Tuple($6, $7))($Tuple(1, 1)))("array must be at least (" + show32($Tuple(1, 1)) + "); got (" + show32($Tuple(
-          $6,
-          $7
-        )) + ")"))(() => Bind1.bind(sequence2(arrayBind(range(1)($6))((i) => [
-          sequence2(arrayBind(range(1)($7))((j) => [
-            $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith((v$1) => identity18)(v)(disjointUnion2((() => {
-              const $10 = {};
-              $10[$3] = $Val($8, None, $BaseVal("Int", i));
-              return $10;
-            })())((() => {
-              const $10 = {};
-              $10[$4] = $Val($9, None, $BaseVal("Int", j));
-              return $10;
-            })())))($2)(v2)
-          ]))
-        ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert3(ordVertex)($5)()(v2))($1)($BaseVal(
-          "Matrix",
-          $Tuple(vss, $Tuple($Tuple($6, $8), $Tuple($7, $9)))
+            return go$r;
+          };
+          return go(0)($3);
+        })()))(() => Bind1.bind(traverse2((() => {
+          const $5 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v);
+          return (a) => $5(a)(v2);
+        })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert3(ordVertex)($4)()(v2))($2)($BaseVal(
+          "Constr",
+          $1,
+          vs
         ))));
-      });
-    }
-    if (v1.tag === "Lambda") {
-      return $$new((a) => Val(a)(None))(insert3(ordVertex)(v1._1)()(v2))($BaseVal(
-        "Fun",
-        $Fun(
-          "Closure",
-          (() => {
-            const $1 = fVElim.fv(v1._2);
-            return filterWithKey((x2) => {
-              const $2 = setSet(ordString).member(x2)($1);
-              return (v$1) => $2;
-            })(v);
-          })(),
-          empty,
-          v1._2
-        )
-      ));
-    }
-    if (v1.tag === "Project") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(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);
-            if ($3.tag === "Just") {
-              return $Maybe("Just", $3._1._2);
-            }
-            return Nothing;
-          })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v$p)($1));
-        }
-        return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dictionary"));
-      });
-    }
-    if (v1.tag === "DProject") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(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')((() => {
-              const $3 = _lookup(Nothing, Just, v$p._3._1, v3._3._1);
+      }
+      if (v1.tag === "Matrix") {
+        const $1 = v1._2;
+        const $2 = v1._3;
+        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) => {
+          const v5 = intPair.unpack(v3._3);
+          const $6 = v5._1._1;
+          const $7 = v5._2._1;
+          const $8 = v5._1._2;
+          const $9 = v5._2._2;
+          return Bind1.bind(check(MonadThrow0)(greaterThanOrEq($Tuple($6, $7))($Tuple(1, 1)))("array must be at least (" + show32($Tuple(
+            1,
+            1
+          )) + "); got (" + show32($Tuple($6, $7)) + ")"))(() => Bind1.bind(sequence2(arrayBind(range(1)($6))((i) => [
+            sequence2(arrayBind(range(1)($7))((j) => [
+              $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith((v$1) => identity18)(v)(disjointUnion2((() => {
+                const $10 = {};
+                $10[$3] = $Val($8, None, $BaseVal("Int", i));
+                return $10;
+              })())((() => {
+                const $10 = {};
+                $10[$4] = $Val($9, None, $BaseVal("Int", j));
+                return $10;
+              })())))($2)(v2)
+            ]))
+          ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert3(ordVertex)($5)()(v2))($1)($BaseVal(
+            "Matrix",
+            $Tuple(vss, $Tuple($Tuple($6, $8), $Tuple($7, $9)))
+          ))));
+        });
+      }
+      if (v1.tag === "Lambda") {
+        return $$new((a) => Val(a)(None))(insert3(ordVertex)(v1._1)()(v2))($BaseVal(
+          "Fun",
+          $Fun(
+            "Closure",
+            (() => {
+              const $1 = fVElim.fv(v1._2);
+              return filterWithKey((x2) => {
+                const $2 = setSet(ordString).member(x2)($1);
+                return (v$1) => $2;
+              })(v);
+            })(),
+            empty,
+            v1._2
+          )
+        ));
+      }
+      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) => {
+          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);
               if ($3.tag === "Just") {
                 return $Maybe("Just", $3._1._2);
               }
               return Nothing;
-            })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v$p$p)($1));
+            })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p)($1));
           }
-          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v$p)).lines) + ", expected string"));
-        }
-        return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dict"));
-      }));
-    }
-    if (v1.tag === "App") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)($2)(v2))((v$p) => Bind1.bind(apply2(dictMonadWithGraphAlloc)(dictLoadFile)(v3)(v$p))((v4) => {
-        const $3 = v4._3;
-        const $4 = v4._1;
-        return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith((v$1) => identity18)(v)((() => {
-          const $5 = {};
-          $5.this = v4;
-          return $5;
-        })()))($1))((vdoc) => Applicative0.pure($Val($4, vdoc, $3)));
-      })));
-    }
-    if (v1.tag === "Let") {
-      const $1 = v1._2;
-      const $2 = v1._1._1;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._1._2)(v2))((v3) => Bind1.bind(match1(v3)($2))((v4) => $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith((v$1) => identity18)(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)(insert3(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith((v$1) => identity18)(v)(\u03B3$p))($1)(insert3(ordVertex)($2)()(v2)));
-    }
-    fail();
+          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dictionary"));
+        });
+      }
+      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) => {
+          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')((() => {
+                const $3 = _lookup(Nothing, Just, v$p._3._1, v3._3._1);
+                if ($3.tag === "Just") {
+                  return $Maybe("Just", $3._1._2);
+                }
+                return Nothing;
+              })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p$p)($1));
+            }
+            return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v$p)).lines) + ", expected string"));
+          }
+          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dict"));
+        }));
+      }
+      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) => {
+          const $3 = v4._3;
+          const $4 = v4._1;
+          return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith((v$1) => identity18)(v)((() => {
+            const $5 = {};
+            $5.this = v4;
+            return $5;
+          })()))($1))((vdoc) => Applicative0.pure($Val($4, vdoc, $3)));
+        })));
+      }
+      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)(unionWith((v$1) => identity18)(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)(insert3(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith((v$1) => identity18)(v)(\u03B3$p))($1)(insert3(ordVertex)($2)()(v2)));
+      }
+      fail();
+    };
   };
 };
-var concatDocs = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
+var concatDocs = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
+  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   return (dictLoadFile) => (\u03B3) => (v) => (doc2) => {
     const $0 = v._3;
     const $1 = v._2;
     const $2 = v._1;
-    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith((v$1) => identity18)(\u03B3)((() => {
+    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith((v$1) => identity18)(\u03B3)((() => {
       const $3 = {};
       $3.this = $Val($2, None, $0);
       return $3;
@@ -40224,163 +40344,183 @@ var concatDocs = (dictMonadWithGraphAlloc) => {
   };
 };
 var apply2 = (dictMonadWithGraphAlloc) => {
-  const Bind1 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0().Bind1();
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
   const match1 = match(dictMonadWithGraphAlloc);
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const MonadError1 = dictMonadWithGraphAlloc.MonadError1();
   const MonadThrow0 = MonadError1.MonadThrow0();
-  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") {
-      if (v._3._1.tag === "Closure") {
-        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)(dictLoadFile)(unionWith((v$1) => identity18)(unionWith((v$1) => identity18)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert3(ordVertex)($1)()(v3._2._2))));
-      }
-      if (v._3._1.tag === "Foreign") {
-        const $1 = v._3._1._1._2;
-        const vs$p = foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2);
-        if ((() => {
-          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 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Bind1 = dictMonadAff.MonadEffect0().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") {
+        if (v._3._1.tag === "Closure") {
+          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)(unionWith((v$1) => identity18)(unionWith((v$1) => identity18)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert3(ordVertex)($1)()(v3._2._2))));
+        }
+        if (v._3._1.tag === "Foreign") {
+          const $1 = v._3._1._1._2;
+          const vs$p = foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2);
+          if ((() => {
+            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 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              fail();
-            }
-            return go$r;
-          };
-          return $1._1.arity > go(0)(vs$p);
-        })()) {
-          return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1, void 0, Leaf2))($BaseVal(
-            "Fun",
-            $Fun("Foreign", $Tuple(v._3._1._1._1, $1), vs$p)
-          ));
+              return go$r;
+            };
+            return $1._1.arity > go(0)(vs$p);
+          })()) {
+            return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1, void 0, Leaf2))($BaseVal(
+              "Fun",
+              $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)(dictLoadFile)(vs$p);
-      }
-      if (v._3._1.tag === "PartialConstr") {
-        const $1 = v._1;
-        const n = defined(arity(monadThrowExceptT(monadIdentity))(v._3._1._1));
-        const v$p = (() => {
-          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 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
+        if (v._3._1.tag === "PartialConstr") {
+          const $1 = v._1;
+          const n = defined(arity(monadThrowExceptT(monadIdentity))(v._3._1._1));
+          const v$p = (() => {
+            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 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              fail();
-            }
-            return go$r;
-          };
-          return go(0)(v._3._1._2) < (n - 1 | 0);
-        })() ? $BaseVal(
-          "Fun",
-          $Fun(
-            "PartialConstr",
+              return go$r;
+            };
+            return go(0)(v._3._1._2) < (n - 1 | 0);
+          })() ? $BaseVal(
+            "Fun",
+            $Fun(
+              "PartialConstr",
+              v._3._1._1,
+              foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2)
+            )
+          ) : $BaseVal(
+            "Constr",
             v._3._1._1,
             foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2)
-          )
-        ) : $BaseVal("Constr", v._3._1._1, foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2));
-        return Bind1.bind(check(MonadThrow0)((() => {
-          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 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
+          );
+          return Bind1.bind(check(MonadThrow0)((() => {
+            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 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              fail();
-            }
-            return go$r;
-          };
-          return go(0)(v._3._1._2) < n;
-        })())("Too many arguments to " + showCtr(v._3._1._1)))(() => $$new((a) => Val(a)(None))($$$Map(
-          "Two",
-          Leaf2,
-          $1,
-          void 0,
-          Leaf2
-        ))(v$p));
+              return go$r;
+            };
+            return go(0)(v._3._1._2) < n;
+          })())("Too many arguments to " + showCtr(v._3._1._1)))(() => $$new((a) => Val(a)(None))($$$Map(
+            "Two",
+            Leaf2,
+            $1,
+            void 0,
+            Leaf2
+          ))(v$p));
+        }
       }
-    }
-    return $0(v1);
+      return $0(v1);
+    };
   };
 };
 var eval_module = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const $0 = Monad0.Bind1();
   const eval1 = $$eval(dictMonadWithGraphAlloc);
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
-  return (dictLoadFile) => {
-    const eval2 = eval1(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(eval2(unionWith((v$1) => identity18)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith((v$1) => identity18)(v)(v4._1))($1)(v4._2._2)));
-          }
-          if (v1._1.tag === "Right") {
-            const $1 = v1._2;
-            return $0.bind(closeDefs1(unionWith((v$1) => identity18)(\u03B3)(v))(v1._1._1._2)(insert3(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith((v$1) => identity18)(v)(\u03B3$p$p))($1)(v2));
-          }
-        }
-        fail();
+  return (dictMonadReader) => {
+    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);
+            }
+            if (v1.tag === "Cons") {
+              if (v1._1.tag === "Left") {
+                const $1 = v1._2;
+                const $2 = v1._1._1._1;
+                return $0.bind(eval4(unionWith((v$1) => identity18)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith((v$1) => identity18)(v)(v4._1))($1)(v4._2._2)));
+              }
+              if (v1._1.tag === "Right") {
+                const $1 = v1._2;
+                return $0.bind(closeDefs1(unionWith((v$1) => identity18)(\u03B3)(v))(v1._1._1._2)(insert3(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith((v$1) => identity18)(v)(\u03B3$p$p))($1)(v2));
+              }
+            }
+            fail();
+          };
+          return go(empty);
+        };
       };
-      return go(empty);
     };
   };
 };
 var eval_progCxt = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const $0 = Monad0.Bind1();
   const eval_module1 = eval_module(dictMonadWithGraphAlloc);
-  const $1 = Monad0.Applicative0();
   const eval1 = $$eval(dictMonadWithGraphAlloc);
-  const concatM1 = concatM(Monad0);
-  return (dictLoadFile) => {
-    const eval_module2 = eval_module1(dictLoadFile);
-    const eval2 = eval1(dictLoadFile);
-    return (v) => concatM1(foldableList.foldr(Cons)(listMap((v1) => (\u03B3) => {
-      const $2 = v1._1;
-      return $0.bind(eval2(\u03B3)(v1._2)(setSet4.empty))((v2) => $1.pure(unionWith((v$1) => identity18)(\u03B3)((() => {
-        const $3 = {};
-        $3[$2] = v2;
-        return $3;
-      })())));
-    })(reverse2(v.datasets)))(listMap((mod) => (\u03B3) => $0.bind(eval_module2(\u03B3)(mod)(setSet4.empty))((\u03B3$p) => $1.pure(unionWith((v$1) => identity18)(\u03B3)(\u03B3$p))))(reverse2(v.mods))))(v.primitives);
+  return (dictMonadReader) => {
+    const eval_module2 = eval_module1(dictMonadReader);
+    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(unionWith((v$1) => identity18)(\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(unionWith((v$1) => identity18)(\u03B3)(\u03B3$p))))(reverse2(v.mods))))(v.primitives);
+      };
+    };
   };
 };
 var graphEval = (dictMonadAff) => {
@@ -40393,50 +40533,85 @@ var graphEval = (dictMonadAff) => {
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const $1 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
+  const monadAffState2 = monadAffState(dictMonadAff);
+  const monadAffState1 = monadAffState(monadAffState2);
+  const $1 = monadAffState2.MonadEffect0().Monad0();
   const $2 = dictMonadAff.MonadEffect0().Monad0();
-  return (dictLoadFile) => (dictMonadError) => {
-    const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))((() => {
-      const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-      return {
-        loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-          const $3 = loadFile1(folders);
-          return (x2) => {
-            const $4 = $3(x2);
-            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
-            )));
-          };
-        }
+  return (dictMonadReader) => {
+    const monadReaderStateT2 = monadReaderStateT(monadReaderStateT(dictMonadReader));
+    return (dictLoadFile) => (dictMonadError) => {
+      const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))(monadReaderStateT2)(monadAffState1)((() => {
+        const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+        return {
+          loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
+            const $3 = loadFile1(folders);
+            return (x2) => {
+              const $4 = $3(x2);
+              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
+              )));
+            };
+          }
+        };
+      })());
+      const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
+      return (v) => (e) => {
+        const $3 = v["\u03B3"];
+        const $4 = spyFunWhen(false)("fwdSlice")((x2) => $Tuple(showVertices(x2._1), showEdgeList(toEdgeList(graphGraphImpl)(x2._2))))(showGraph(graphGraphImpl))(fwdSlice2);
+        const $5 = spyFunWhen(false)("bwdSlice")((x2) => $Tuple(showVertices(x2._1), showEdgeList(toEdgeList(graphGraphImpl)(x2._2))))(showGraph(graphGraphImpl))(bwdSlice2);
+        return Monad0.Bind1().bind(runAllocT(Monad0)(bindStateT2.bind(alloc(e))((e\u03B1) => bindStateT2.bind(runWithGraphT_spy2(eval1($3)(e\u03B1)(Leaf2))(verticesEnvExprVertex.vertices($EnvExpr(
+          $3,
+          e\u03B1
+        ))))((v1) => {
+          const $6 = v1._1;
+          const $7 = v1._2;
+          return bindStateT2.bind(check2(difference2(ordDVertex$p)(verticesValVertex.vertices($7))(verticesGraphImpl.vertices($6)).tag === "Leaf")("outputs in graph"))(() => applicativeStateT(Monad0).pure($Tuple(
+            $6,
+            $Tuple($EnvExpr($3, e\u03B1), $7)
+          )));
+        })))(v.n))((v1) => Monad0.Applicative0().pure({
+          g: v1._2._2._1,
+          graph_fwd: (a) => (b) => $4($Tuple(a, b)),
+          graph_bwd: (a) => (b) => $5($Tuple(a, b)),
+          "in\u03B1": v1._2._2._2._1,
+          "out\u03B1": v1._2._2._2._2
+        }));
       };
-    })());
-    const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
-    return (v) => (e) => {
-      const $3 = v["\u03B3"];
-      const $4 = spyFunWhen(false)("fwdSlice")((x2) => $Tuple(showVertices(x2._1), showEdgeList(toEdgeList(graphGraphImpl)(x2._2))))(showGraph(graphGraphImpl))(fwdSlice2);
-      const $5 = spyFunWhen(false)("bwdSlice")((x2) => $Tuple(showVertices(x2._1), showEdgeList(toEdgeList(graphGraphImpl)(x2._2))))(showGraph(graphGraphImpl))(bwdSlice2);
-      return Monad0.Bind1().bind(runAllocT(Monad0)(bindStateT2.bind(alloc(e))((e\u03B1) => bindStateT2.bind(runWithGraphT_spy2(eval1($3)(e\u03B1)(Leaf2))(verticesEnvExprVertex.vertices($EnvExpr(
-        $3,
-        e\u03B1
-      ))))((v1) => {
-        const $6 = v1._1;
-        const $7 = v1._2;
-        return bindStateT2.bind(check2(difference2(ordDVertex$p)(verticesValVertex.vertices($7))(verticesGraphImpl.vertices($6)).tag === "Leaf")("outputs in graph"))(() => applicativeStateT(Monad0).pure($Tuple(
-          $6,
-          $Tuple($EnvExpr($3, e\u03B1), $7)
-        )));
-      })))(v.n))((v1) => Monad0.Applicative0().pure({
-        g: v1._2._2._1,
-        graph_fwd: (a) => (b) => $4($Tuple(a, b)),
-        graph_bwd: (a) => (b) => $5($Tuple(a, b)),
-        "in\u03B1": v1._2._2._2._1,
-        "out\u03B1": v1._2._2._2._2
-      }));
     };
   };
 };
 
+// output-es/Data.Argonaut.Decode.Error/index.js
+var $JsonDecodeError = (tag, _1, _2) => ({ tag, _1, _2 });
+var AtIndex = (value0) => (value1) => $JsonDecodeError("AtIndex", value0, value1);
+var AtKey = (value0) => (value1) => $JsonDecodeError("AtKey", value0, value1);
+var Named = (value0) => (value1) => $JsonDecodeError("Named", value0, value1);
+var MissingValue = /* @__PURE__ */ $JsonDecodeError("MissingValue");
+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.CodePoint.Unicode/index.js
 var isUpper = (x2) => checkAttr([512, 524288])(x2);
 var isSpace = (c) => {
@@ -43721,7 +43896,7 @@ var matrixUpdate = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (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(
@@ -43740,12 +43915,12 @@ var matrixLookup = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (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 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 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.throwError(error("Matrix and pair of integers expected"));
+        return $$throw2("Matrix and pair of integers expected");
       };
     }
   })
@@ -43759,6 +43934,32 @@ var log3 = (v2) => {
   }
   fail();
 };
+var loadJson = /* @__PURE__ */ $Tuple(
+  "loadJson",
+  /* @__PURE__ */ $ForeignOp$p({
+    arity: 1,
+    op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => {
+        const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+        const $0 = 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) => Monad0.Applicative0().pure(throwException(error($1))())));
+              }
+              return $$throw2("String expected");
+            };
+          };
+        };
+      };
+    }
+  })
+);
 var lessThanEquals = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 <= a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 <= a2)((a1) => (a2) => a1 <= a2));
 var lessThan = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 < a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 < a2)((a1) => (a2) => a1 < a2));
 var greaterThanEquals = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 >= a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 >= a2)((a1) => (a2) => a1 >= a2));
@@ -43773,12 +43974,12 @@ var error_ = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Nil") {
-          return MonadThrow0.Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
+          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
         }
-        return MonadThrow0.throwError(error("String expected"));
+        return $$throw2("String expected");
       };
     }
   })
@@ -43791,26 +43992,28 @@ var dims = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const $0 = MonadThrow0.Monad0().Bind1();
-        return (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"));
+        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");
+          };
         };
       };
     }
@@ -43824,25 +44027,30 @@ var dict_map = /* @__PURE__ */ $Tuple(
       const apply3 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        const Bind1 = Monad0.Bind1();
-        const traverse1 = traversableDict.traverse(Monad0.Applicative0());
-        return (dictLoadFile) => {
-          const apply1 = apply3(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))(apply1($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"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+          const Bind1 = Monad0.Bind1();
+          const traverse1 = traversableDict.traverse(Monad0.Applicative0());
+          return (dictMonadReader) => {
+            const apply1 = apply3(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply1(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 $$throw2("Function and dictionary expected");
+              };
+            };
           };
         };
       };
@@ -43857,38 +44065,43 @@ var dict_intersectionWith = /* @__PURE__ */ $Tuple(
       const apply3 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        const Bind1 = Monad0.Bind1();
-        const Applicative0 = Monad0.Applicative0();
-        const $0 = Bind1.Apply0().Functor0();
-        return (dictLoadFile) => {
-          const apply1 = apply3(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)(identity19)(intersectionWith_Object((v2) => (v3) => {
-                const $4 = v3._2;
-                const $5 = v2._1;
-                const $6 = v3._1;
-                return Bind1.bind(Bind1.bind(apply1($1)(v2._2))((a) => apply1(a)($4)))((v4) => Bind1.bind($$new((a) => Val(a)(None))(insert3(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))(insert3(ordVertex)($3)()($$$Map(
-                "Two",
-                Leaf2,
-                $2,
-                void 0,
-                Leaf2
-              )))(v$p));
-            }
-            return MonadThrow0.throwError(error("Function and two dictionaries expected"));
+        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 apply1 = apply3(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply1(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)(identity19)(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))(insert3(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))(insert3(ordVertex)($3)()($$$Map(
+                    "Two",
+                    Leaf2,
+                    $2,
+                    void 0,
+                    Leaf2
+                  )))(v$p));
+                }
+                return $$throw2("Function and two dictionaries expected");
+              };
+            };
           };
         };
       };
@@ -43901,7 +44114,7 @@ var dict_get = /* @__PURE__ */ $Tuple(
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
       const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      return (dictMonadAff) => (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);
@@ -43923,19 +44136,24 @@ var dict_foldl = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const apply3 = apply2(dictMonadWithGraphAlloc);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        return (dictLoadFile) => {
-          const apply1 = apply3(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(apply1($0)(u1))((a) => apply1(a)($1));
-              })(v._2._1)(v._2._2._1._3._1);
-            }
-            return MonadThrow0.throwError(error("Function, value and dictionary expected"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+          return (dictMonadReader) => {
+            const apply1 = apply3(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply1(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");
+              };
+            };
           };
         };
       };
@@ -43950,7 +44168,7 @@ var dict_disjointUnion = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (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))(insert3(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -43974,7 +44192,7 @@ var dict_difference = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (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))(insert3(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -43995,13 +44213,13 @@ var debugLog = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._2.tag === "Nil") {
           const $0 = v._1;
-          return MonadThrow0.Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
+          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
         }
-        return MonadThrow0.throwError(error("Single value expected"));
+        return $$throw2("Single value expected");
       };
     }
   })
@@ -44015,6 +44233,7 @@ var primitives = /* @__PURE__ */ fromFoldable(foldableArray)([
   /* @__PURE__ */ extern1(debugLog),
   /* @__PURE__ */ extern1(dims),
   /* @__PURE__ */ extern1(error_),
+  /* @__PURE__ */ extern1(loadJson),
   /* @__PURE__ */ unary2("floor")({ i: number5, o: $$int, fwd: floor2 }),
   /* @__PURE__ */ unary2("log")({ i: intOrNumber, o: number5, fwd: log3 }),
   /* @__PURE__ */ unary2("numToStr")({ i: intOrNumber, o: string2, fwd: numToStr }),
@@ -44092,7 +44311,6 @@ var verticesProgCxtVertex = {
 };
 var functorProgCxt = {
   map: (f) => (m) => ({
-    fluidSrcPaths: m.fluidSrcPaths,
     primitives: _fmapObject(m.primitives, functorVal.map(f)),
     mods: listMap(functorModule.map(f))(m.mods),
     datasets: listMap((m$1) => $Tuple(m$1._1, functorExpr.map(f)(m$1._2)))(m.datasets)
@@ -44162,7 +44380,7 @@ var traversableProgCxt = {
     const traverse7 = traversableExpr.traverse(dictApplicative);
     const traverse8 = traversableModule.traverse(dictApplicative);
     const traverse9 = traversableEnv.traverse(dictApplicative);
-    return (f) => (m) => Apply0.apply(Apply0.apply(Apply0.Functor0().map((v1) => (v2) => (v3) => ({ fluidSrcPaths: m.fluidSrcPaths, primitives: v3, mods: v2, datasets: v1 }))(traverse5(traversableTuple.traverse(dictApplicative)(traverse7(f)))(m.datasets)))(traverse5(traverse8(f))(m.mods)))(traverse9(f)(m.primitives));
+    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)(identity32)(v),
   Functor0: () => functorProgCxt,
@@ -44208,7 +44426,6 @@ var module_2 = (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({
-          fluidSrcPaths: v.fluidSrcPaths,
           primitives: v.primitives,
           mods: $List("Cons", mod, $0),
           datasets: v.datasets
@@ -44229,36 +44446,41 @@ var initialConfig = (dictMonadAff) => {
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const $2 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
+  const monadAffState2 = monadAffState(dictMonadAff);
+  const monadAffState1 = monadAffState(monadAffState2);
+  const $2 = monadAffState2.MonadEffect0().Monad0();
   const $3 = dictMonadAff.MonadEffect0().Monad0();
   return (dictMonadError) => {
     const eval_progCxt2 = eval_progCxt(monadWithGraphAllocWithGr(dictMonadError));
-    return (dictLoadFile) => {
-      const eval_progCxt1 = eval_progCxt2((() => {
-        const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-        return {
-          loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-            const $4 = loadFile1(folders);
-            return (x2) => {
-              const $5 = $4(x2);
-              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
-              )));
-            };
-          }
-        };
-      })());
-      return (dictFV) => (e) => (progCxt) => Bind1.bind(Applicative0.pure())(() => Bind1.bind(runAllocT(Monad0)($1.bind(alloc(progCxt))((progCxt$p) => $1.bind(runWithGraphT_spy2(eval_progCxt1(progCxt$p))(verticesProgCxtVertex.vertices(progCxt$p)))((v) => applicativeStateT(Monad0).pure($Tuple(
-        progCxt$p,
-        (() => {
-          const $4 = dictFV.fv(e);
-          return filterWithKey((x2) => {
-            const $5 = setSet(ordString).member(x2)($4);
-            return (v$1) => $5;
-          })(v._2);
-        })()
-      )))))(0))((v) => Applicative0.pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2 })));
+    return (dictMonadReader) => {
+      const eval_progCxt1 = eval_progCxt2(monadReaderStateT(monadReaderStateT(dictMonadReader)))(monadAffState1);
+      return (dictLoadFile) => {
+        const eval_progCxt22 = eval_progCxt1((() => {
+          const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+          return {
+            loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
+              const $4 = loadFile1(folders);
+              return (x2) => {
+                const $5 = $4(x2);
+                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
+                )));
+              };
+            }
+          };
+        })());
+        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(
+          progCxt$p,
+          (() => {
+            const $4 = dictFV.fv(e);
+            return filterWithKey((x2) => {
+              const $5 = setSet(ordString).member(x2)($4);
+              return (v$1) => $5;
+            })(v._2);
+          })()
+        )))))(0))((v) => Applicative0.pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2 })));
+      };
     };
   };
 };
@@ -44269,13 +44491,17 @@ var prepConfig = (dictMonadAff) => {
   return (dictMonadError) => {
     const desug1 = exprFwd(boundedLattice2)(dictMonadError)(joinSemilatticeUnit);
     const initialConfig2 = initialConfig1(dictMonadError);
-    return (dictLoadFile) => {
-      const initialConfig3 = initialConfig2(dictLoadFile)(fVExpr);
-      return (v) => (file) => (progCxt) => $0.bind(parseProgram(dictLoadFile)(v.fluidSrcPaths)(file)(dictMonadAff)(dictMonadError))((s) => $0.bind(desug1(s))((e) => $0.bind(initialConfig3(e)(progCxt))((gconfig) => Monad0.Applicative0().pure({
-        s,
-        e,
-        gconfig
-      }))));
+    return (dictMonadReader) => {
+      const ask = dictMonadReader.MonadAsk0().ask;
+      const initialConfig3 = initialConfig2(dictMonadReader);
+      return (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
+        })))));
+      };
     };
   };
 };
@@ -44288,7 +44514,6 @@ var datasetAs = (dictMonadAff) => {
       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({
-        fluidSrcPaths: v1.fluidSrcPaths,
         primitives: v1.primitives,
         mods: v1.mods,
         datasets: $List("Cons", $Tuple($2, e\u03B1), $1)
@@ -44305,18 +44530,20 @@ var loadProgCxt = (dictMonadAff) => {
   return (dictMonadError) => {
     const module_22 = module_1(dictMonadError);
     const datasetAs2 = datasetAs1(dictMonadError);
-    return (dictLoadFile) => {
-      const module_3 = module_22(dictLoadFile);
-      const datasetAs3 = datasetAs2(dictLoadFile);
-      return (v) => (mods) => (datasets) => $0.bind($0.bind(Monad0.Applicative0().pure({
-        fluidSrcPaths: v.fluidSrcPaths,
-        primitives,
-        mods: Nil,
-        datasets: Nil
-      }))(concatM1(arrayMap(module_3(v.fluidSrcPaths))(["lib/prelude", ...mods]))))(concatM1(arrayMap((() => {
-        const $1 = datasetAs3(v.fluidSrcPaths);
-        return (x2) => $1($Tuple(x2._1, x2._2));
-      })())(datasets)));
+    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({
+          primitives,
+          mods: Nil,
+          datasets: Nil
+        }))(concatM1(arrayMap(module_3(v.fluidSrcPaths))(["lib/prelude", ...mods]))))(concatM1(arrayMap((() => {
+          const $1 = datasetAs3(v.fluidSrcPaths);
+          return (x2) => $1($Tuple(x2._1, x2._2));
+        })())(datasets))));
+      };
     };
   };
 };
@@ -44669,114 +44896,118 @@ var loadFig = (dictMonadAff) => {
   return (dictMonadError) => {
     const loadProgCxt1 = loadProgCxt2(dictMonadError);
     const prepConfig1 = prepConfig2(dictMonadError);
-    return (dictLoadFile) => {
-      const loadProgCxt22 = loadProgCxt1(dictLoadFile);
-      const prepConfig22 = prepConfig1(dictLoadFile);
-      const graphEval1 = graphEval2(dictLoadFile)(dictMonadError);
-      return (v) => {
-        const $1 = v.file;
-        const $2 = v.fluidSrcPaths;
-        const $3 = v.inputs;
-        const $4 = v.linking;
-        return $0.bind(loadProgCxt22({ fluidSrcPaths: $2 })(v.imports)(v.datasets))((progCxt) => $0.bind(prepConfig22({ fluidSrcPaths: $2 })($1)(progCxt))((v1) => {
-          const $5 = v1.s;
-          return $0.bind(graphEval1(v1.gconfig)(v1.e))((v2) => {
-            const $6 = v2.g;
-            const $7 = v2["out\u03B1"];
-            const $8 = v2["in\u03B1"]._1;
-            const opEval = {
-              g: $GraphImpl({ out: v2.g._1.in_, in_: v2.g._1.out, sinks: v2.g._1.sources, sources: v2.g._1.sinks, vertices: v2.g._1.vertices }),
-              graph_fwd: v2.graph_fwd,
-              graph_bwd: v2.graph_bwd,
-              "in\u03B1": v2["out\u03B1"],
-              "out\u03B1": v2["in\u03B1"]
-            };
-            const inputs$p = fromFoldable25($3);
-            const v3 = functorEnvExpr.map((v$1) => {
-            })(v2["in\u03B1"]);
-            const $9 = unrestrictGC(boundedMeetSemilatticeBoo)(v3._1)(inputs$p);
-            const $10 = unprojExpr(boundedMeetSemilatticeBoo)($EnvExpr(v3._1, v3._2));
-            const $11 = filterWithKey((x2) => {
-              const $112 = setSet(ordString).member(x2)(inputs$p);
-              return (v$1) => $112;
-            })($8);
-            const $12 = _fmapObject($8, functorVal.map((v$1) => false));
-            const $13 = functorVal.map((v$1) => false)($7);
-            const graphgc_op = graphGC1(opEval);
-            const graphgc = graphGC22(v2);
-            const inertFwd = verticesGraphImpl.vertices(graphgc.fwd($10.fwd($9.fwd($12)))._2);
-            const inertBwd = setSet5.difference(verticesGraphImpl.vertices($6))(verticesGraphImpl.vertices(graphgc.bwd(functorVal.map((v$1) => true)($7))._2));
-            const $14 = select\u03B1s\u{1D539}Vertex2["select\u{1D539}s"]($8)(inertBwd);
-            const $15 = select\u{1D539}s($7)(inertFwd);
-            const $16 = _fmapObject($14, functorVal.map(selState));
-            const $17 = functorVal.map(selState)($15);
-            const demands = lift1($16)((v6) => {
-              const $18 = graphgc.bwd(v6);
-              return $Tuple($9.bwd($10.bwd($18._1)), $18._2);
-            });
-            const demandedBy = lift2($17)((\u03B31) => graphgc_op.bwd(deMorgan((x2) => $10.fwd($9.fwd(x2)))(\u03B31)));
-            return Monad0.Applicative0().pure({
-              spec: v,
-              s: $5,
-              "\u03B3": intersectionWith_Object(apply)(_fmapObject(
-                intersectionWith_Object(apply)(_fmapObject(
-                  _fmapObject($14, functorVal.map(selStates)),
+    return (dictMonadReader) => {
+      const loadProgCxt22 = loadProgCxt1(dictMonadReader);
+      const prepConfig22 = prepConfig1(dictMonadReader);
+      const graphEval1 = graphEval2(dictMonadReader);
+      return (dictLoadFile) => {
+        const loadProgCxt3 = loadProgCxt22(dictLoadFile);
+        const prepConfig3 = prepConfig22(dictLoadFile);
+        const graphEval22 = graphEval1(dictLoadFile)(dictMonadError);
+        return (v) => {
+          const $1 = v.file;
+          const $2 = v.inputs;
+          const $3 = v.linking;
+          return $0.bind(loadProgCxt3(v.imports)(v.datasets))((progCxt) => $0.bind(prepConfig3($1)(progCxt))((v1) => {
+            const $4 = v1.s;
+            return $0.bind(graphEval22(v1.gconfig)(v1.e))((v2) => {
+              const $5 = v2.g;
+              const $6 = v2["out\u03B1"];
+              const $7 = v2["in\u03B1"]._1;
+              const opEval = {
+                g: $GraphImpl({ out: v2.g._1.in_, in_: v2.g._1.out, sinks: v2.g._1.sources, sources: v2.g._1.sinks, vertices: v2.g._1.vertices }),
+                graph_fwd: v2.graph_fwd,
+                graph_bwd: v2.graph_bwd,
+                "in\u03B1": v2["out\u03B1"],
+                "out\u03B1": v2["in\u03B1"]
+              };
+              const inputs$p = fromFoldable25($2);
+              const v3 = functorEnvExpr.map((v$1) => {
+              })(v2["in\u03B1"]);
+              const $8 = unrestrictGC(boundedMeetSemilatticeBoo)(v3._1)(inputs$p);
+              const $9 = unprojExpr(boundedMeetSemilatticeBoo)($EnvExpr(v3._1, v3._2));
+              const $10 = filterWithKey((x2) => {
+                const $102 = setSet(ordString).member(x2)(inputs$p);
+                return (v$1) => $102;
+              })($7);
+              const $11 = _fmapObject($7, functorVal.map((v$1) => false));
+              const $12 = functorVal.map((v$1) => false)($6);
+              const graphgc_op = graphGC1(opEval);
+              const graphgc = graphGC22(v2);
+              const inertFwd = verticesGraphImpl.vertices(graphgc.fwd($9.fwd($8.fwd($11)))._2);
+              const inertBwd = setSet5.difference(verticesGraphImpl.vertices($5))(verticesGraphImpl.vertices(graphgc.bwd(functorVal.map((v$1) => true)($6))._2));
+              const $13 = select\u03B1s\u{1D539}Vertex2["select\u{1D539}s"]($7)(inertBwd);
+              const $14 = select\u{1D539}s($6)(inertFwd);
+              const $15 = _fmapObject($13, functorVal.map(selState));
+              const $16 = functorVal.map(selState)($14);
+              const demands = lift1($15)((v6) => {
+                const $17 = graphgc.bwd(v6);
+                return $Tuple($8.bwd($9.bwd($17._1)), $17._2);
+              });
+              const demandedBy = lift2($16)((\u03B31) => graphgc_op.bwd(deMorgan((x2) => $9.fwd($8.fwd(x2)))(\u03B31)));
+              return Monad0.Applicative0().pure({
+                spec: v,
+                s: $4,
+                "\u03B3": intersectionWith_Object(apply)(_fmapObject(
+                  intersectionWith_Object(apply)(_fmapObject(
+                    _fmapObject($13, functorVal.map(selStates)),
+                    applyVal.apply
+                  ))($11),
                   applyVal.apply
-                ))($12),
-                applyVal.apply
-              ))($12),
-              v: applyVal.apply(applyVal.apply(functorVal.map(selStates)($15))($13))($13),
-              "\u03B9": empty,
-              linkedOutputs: (selType) => (v6) => {
-                const v$p = functorVal.map(getSel(selType))(v6);
-                const v7 = demands(v$p);
-                return $Tuple(v7._1, $Tuple($4 ? demandedBy(v7._1)._1 : v$p, verticesGraphImpl.vertices(v7._2)));
-              },
-              linkedInputs: (selType) => (\u03B31) => {
-                const \u03B3$p = _fmapObject(\u03B31, functorVal.map(getSel(selType)));
-                const v6 = demandedBy(\u03B3$p);
-                return $Tuple($4 ? demands(v6._1)._1 : \u03B3$p, $Tuple(v6._1, verticesGraphImpl.vertices(v6._2)));
-              },
-              linkIntermediates: (\u03B9) => {
-                const \u03B1s = select\u03B1s\u{1D539}Vertex2["select\u03B1s"](_fmapObject(
-                  \u03B9,
-                  functorVal.map((x2) => {
-                    const $18 = getSel(Transient)(x2);
-                    if ($18.tag === "Inert") {
-                      return false;
-                    }
-                    if ($18.tag === "Reactive") {
-                      return $18._1;
-                    }
-                    fail();
-                  })
-                ))(\u03B9from\u03B1s(graphGraphImpl)($6)(mapObjectString.keys(\u03B9)));
-                return $Tuple(
-                  intersectionWith_Object(apply)(_fmapObject($16, applyVal.apply))(select\u03B1s\u{1D539}Vertex2["select\u{1D539}s"]($8)(verticesGraphImpl.vertices(bwdSlice3($Tuple(
-                    \u03B1s,
-                    v2.g
-                  ))))),
-                  $Tuple(
-                    applyVal.apply($17)(select\u{1D539}s($7)(verticesGraphImpl.vertices(bwdSlice3($Tuple(\u03B1s, opEval.g))))),
-                    map2(ordDVertex$p)((\u03B1) => $Tuple(
-                      \u03B1,
-                      definitely("in graph")(_lookup(Nothing, Just, \u03B1, $6._1.out))._2
-                    ))(\u03B1s)
-                  )
-                );
-              },
-              dir: { persistent: LinkedOutputs, transient: LinkedOutputs },
-              in_views: _fmapObject($11, (v$1) => Nothing),
-              out_view: Nothing,
-              intermediate_views: empty,
-              in_roots: fold((z) => (v$1) => (a) => insert3(ordVertex)(a)()(z))(Leaf2)(_fmapObject(
-                $11,
-                (v6) => v6._1
-              )),
-              inerts: intersection3(inertFwd)(inertBwd)
+                ))($11),
+                v: applyVal.apply(applyVal.apply(functorVal.map(selStates)($14))($12))($12),
+                "\u03B9": empty,
+                linkedOutputs: (selType) => (v6) => {
+                  const v$p = functorVal.map(getSel(selType))(v6);
+                  const v7 = demands(v$p);
+                  return $Tuple(v7._1, $Tuple($3 ? demandedBy(v7._1)._1 : v$p, verticesGraphImpl.vertices(v7._2)));
+                },
+                linkedInputs: (selType) => (\u03B31) => {
+                  const \u03B3$p = _fmapObject(\u03B31, functorVal.map(getSel(selType)));
+                  const v6 = demandedBy(\u03B3$p);
+                  return $Tuple($3 ? demands(v6._1)._1 : \u03B3$p, $Tuple(v6._1, verticesGraphImpl.vertices(v6._2)));
+                },
+                linkIntermediates: (\u03B9) => {
+                  const \u03B1s = select\u03B1s\u{1D539}Vertex2["select\u03B1s"](_fmapObject(
+                    \u03B9,
+                    functorVal.map((x2) => {
+                      const $17 = getSel(Transient)(x2);
+                      if ($17.tag === "Inert") {
+                        return false;
+                      }
+                      if ($17.tag === "Reactive") {
+                        return $17._1;
+                      }
+                      fail();
+                    })
+                  ))(\u03B9from\u03B1s(graphGraphImpl)($5)(mapObjectString.keys(\u03B9)));
+                  return $Tuple(
+                    intersectionWith_Object(apply)(_fmapObject($15, applyVal.apply))(select\u03B1s\u{1D539}Vertex2["select\u{1D539}s"]($7)(verticesGraphImpl.vertices(bwdSlice3($Tuple(
+                      \u03B1s,
+                      v2.g
+                    ))))),
+                    $Tuple(
+                      applyVal.apply($16)(select\u{1D539}s($6)(verticesGraphImpl.vertices(bwdSlice3($Tuple(\u03B1s, opEval.g))))),
+                      map2(ordDVertex$p)((\u03B1) => $Tuple(
+                        \u03B1,
+                        definitely("in graph")(_lookup(Nothing, Just, \u03B1, $5._1.out))._2
+                      ))(\u03B1s)
+                    )
+                  );
+                },
+                dir: { persistent: LinkedOutputs, transient: LinkedOutputs },
+                in_views: _fmapObject($10, (v$1) => Nothing),
+                out_view: Nothing,
+                intermediate_views: empty,
+                in_roots: fold((z) => (v$1) => (a) => insert3(ordVertex)(a)()(z))(Leaf2)(_fmapObject(
+                  $10,
+                  (v6) => v6._1
+                )),
+                inerts: intersection3(inertFwd)(inertBwd)
+              });
             });
-          });
-        }));
+          }));
+        };
       };
     };
   };
@@ -44934,36 +45165,6 @@ var drawFile = (v) => {
   };
 };
 
-// output-es/Data.Argonaut.Decode.Error/index.js
-var $JsonDecodeError = (tag, _1, _2) => ({ tag, _1, _2 });
-var AtIndex = (value0) => (value1) => $JsonDecodeError("AtIndex", value0, value1);
-var AtKey = (value0) => (value1) => $JsonDecodeError("AtKey", value0, value1);
-var Named = (value0) => (value1) => $JsonDecodeError("Named", value0, value1);
-var MissingValue = /* @__PURE__ */ $JsonDecodeError("MissingValue");
-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.Decode.Decoders/index.js
 var traverseWithIndex = /* @__PURE__ */ (() => traversableWithIndexArray.traverseWithIndex(applicativeEither))();
 var decodeJArray = (x2) => {
@@ -45109,15 +45310,17 @@ var Folder = (x2) => x2;
 
 // output-es/Module.Web/index.js
 var findM = (xs) => (f) => (base2) => foldrArray((x2) => (acc) => applyAff.apply(_map(altEither.alt)(acc))(f(x2)))(_pure(base2))(xs);
-var loadFileWebT = (dictMonadAff) => {
-  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-  const bindExceptT2 = bindExceptT(Monad0);
-  const applicativeExceptT2 = applicativeExceptT(Monad0);
-  const pure22 = Monad0.Applicative0().pure;
-  return (dictMonadError) => ({
-    loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => (v) => Monad0.Bind1().bind(bindExceptT2.bind(dictMonadAff1.liftAff(findM(arrayMap((() => {
-      const $0 = v + ".fld";
-      return (a) => a + "/" + $0;
+var loadFileWebT = (dictMonadThrow) => {
+  const Monad0 = dictMonadThrow.Monad0();
+  const bind1 = bindReaderT(Monad0.Bind1()).bind;
+  const monadWebT1 = monadReaderT(Monad0);
+  const bindExceptT2 = bindExceptT(monadWebT1);
+  const applicativeExceptT2 = applicativeExceptT(monadWebT1);
+  const $0 = Monad0.Applicative0();
+  return {
+    loadFile: (dictMonadError) => (dictMonadAff) => (folders) => (v) => bind1(bindExceptT2.bind(dictMonadAff.liftAff(findM(arrayMap((() => {
+      const $1 = v + ".fld";
+      return (a) => a + "/" + $1;
     })())(folders))((v1) => _bind(request(driver)({
       method: $Either("Left", HEAD),
       url: v1,
@@ -45140,10 +45343,10 @@ var loadFileWebT = (dictMonadAff) => {
       }
       fail();
     })())))($Either("Left", RequestFailedError))))((v1) => {
-      const $0 = v1._2;
-      return bindExceptT2.bind(applicativeExceptT2.pure())(() => bindExceptT2.bind(dictMonadAff1.liftAff(request(driver)({
+      const $1 = v1._2;
+      return bindExceptT2.bind(applicativeExceptT2.pure())(() => bindExceptT2.bind(dictMonadAff.liftAff(request(driver)({
         method: $Either("Left", GET),
-        url: $0,
+        url: $1,
         headers: [],
         content: Nothing,
         username: Nothing,
@@ -45154,14 +45357,15 @@ var loadFileWebT = (dictMonadAff) => {
       })))((contents) => applicativeExceptT2.pure(contents.body)));
     }))((result) => {
       if (result.tag === "Left") {
-        return dictMonadError.MonadThrow0().throwError(error(printError(result._1)));
+        return monadThrowReaderT(dictMonadThrow).throwError(error(printError(result._1)));
       }
       if (result.tag === "Right") {
-        return pure22(result._1);
+        const $1 = $0.pure(result._1);
+        return (v$1) => $1;
       }
       fail();
     })
-  });
+  };
 };
 
 // output-es/App.LoadFigure/index.js
@@ -45234,8 +45438,10 @@ var decodeJson = /* @__PURE__ */ (() => decodeRecord(gDecodeJsonCons((() => {
 })()())({ reflectSymbol: () => "inputs" })()())({ reflectSymbol: () => "imports" })()())({ reflectSymbol: () => "fluidSrcPath" })()())({ reflectSymbol: () => "file" })()())({
   reflectSymbol: () => "datasets"
 })()())().decodeJson)();
-var loadFileWebT2 = /* @__PURE__ */ loadFileWebT(monadAffAff)(monadErrorAff);
-var loadFig2 = /* @__PURE__ */ loadFig(monadAffAff)(monadErrorAff)(loadFileWebT2);
+var monadAffWebT = /* @__PURE__ */ monadAffReader(monadAffAff);
+var monadErrorErrorWebT = /* @__PURE__ */ monadErrorReaderT(monadErrorAff);
+var loadFileWebT2 = /* @__PURE__ */ loadFileWebT(monadThrowAff);
+var loadFig2 = /* @__PURE__ */ loadFig(monadAffWebT)(monadErrorErrorWebT)(/* @__PURE__ */ monadReaderReaderT(monadAff))(loadFileWebT2);
 var loadFile$p = (folders) => (file) => (dictMonadAff) => (dictMonadError) => dictMonadAff.MonadEffect0().Monad0().Bind1().Apply0().Functor0().map((v) => $Tuple(file, v))(loadFileWebT2.loadFile(dictMonadError)(dictMonadAff)(folders)(file));
 var figSpecFromJson = (v) => ({
   fluidSrcPaths: arrayMap(Folder)(v.fluidSrcPath),
@@ -45272,13 +45478,14 @@ var loadFigure = (fileName) => runAffs_((v) => drawFig(v._1)(v._2))([
         return throwException(error("JSON decoding failed with " + showJsonDecodeError.show(v._1)))();
       }
       if (v.tag === "Right") {
-        return _map((v1) => $Tuple("fig", v1))(loadFig2(figSpecFromJson(v._1)));
+        const v1 = figSpecFromJson(v._1);
+        return _map((v2) => $Tuple("fig", v2))(loadFig2(v1)({ fluidSrcPaths: v1.fluidSrcPaths }));
       }
     }
     fail();
   })
 ]);
-var drawCode2 = (folder) => (file) => runAffs_(drawFile)([loadFile$p([folder])(file)(monadAffAff)(monadErrorAff)]);
+var drawCode2 = (folder) => (file) => runAffs_(drawFile)([loadFile$p([folder])(file)(monadAffWebT)(monadErrorErrorWebT)({ fluidSrcPaths: [folder] })]);
 export {
   decodeJson,
   drawCode2 as drawCode,
@@ -45288,5 +45495,7 @@ export {
   loadFig2 as loadFig,
   loadFigure,
   loadFile$p,
-  loadFileWebT2 as loadFileWebT
+  loadFileWebT2 as loadFileWebT,
+  monadAffWebT,
+  monadErrorErrorWebT
 };