         m))
 
 (defview RootWrapper
-  (query [{workflo/screen [workflo [forms layout]]}])
+  (query [{workflo/screen [workflo [forms sections]]}])
   (render
    (let [forms      (:workflo/forms screen)
-         layout     (realize-layout (:workflo/layout screen))
+         sections   (realize-sections (:workflo/sections screen))
          root-info  (root-component)]
      ((:factory root-info)
       (if (:js? root-info)
         (do
-          (clj->js (merge {:layout (camel-cased-prop-map layout)}
+          (clj->js (merge {:sections (camel-cased-prop-map sections)}
                           (camel-cased-prop-map forms))))
-        (merge {:layout layout} forms))))))
+        (merge {:sections sections} forms))))))
 
 ;;;; Routing
 
 (defn mount-screen
   "Mounts a screen with parameters by setting it as the active
    screen and updating the root wrapper's component query
-   according to the screen's layout."
+   according to the screen's sections."
   [app screen params]
   (let [c     (om/app-root (:reconciler (:config app)))
         query [{:workflo/screen
                 [:workflo/forms
-                 {:workflo/layout
+                 {:workflo/sections
                   (mapv (fn [[section view-name]]
-                          {section (or (some-> view-name resolve-view
-                                               :view om/get-query)
+                          {section (or (some-> view-name resolve-view :view om/get-query)
                                        [])})
-                        (:layout screen))}]}]]
+                        (:sections screen))}]}]]
     (set-active-screen! screen params)
     (some-> app :config :screen-mounted
             (apply [app screen params]))

   or not the root component is a JS component.

   The root component is expected to accept the properties
   defined for screens, so `:layout` and arbitrary other forms.
   `:layout` is a map of layout keys to instantiated components.
   The root component can then decide which of these components
   to render where based on these layout keys.

   During rendering, the provided root component is wrapped
   in an application component that handles the screen routing
   logic and generates the `:layout` and other form props
   based on the active screen."
  [{:keys [default-screen reconciler root
           root-js? target screen-mounted]

  [_ {:keys [screen]} _ _]
  {:value (:forms screen)})

(defn read-sections
  "Executes all queries for views in the sections of the
   active screen."
  [_ {:keys [parser query screen] :as env} _ _]
  {:value
   (reduce (fn [res section-item]
             (let [[section query] (first section-item)]
               (assoc res section
                      {:view  (-> screen :sections section resolve-view :factory)
                       :props (parser (dissoc env :path) query nil)})))
           {} query)})

