7 files changed, 240 insertions, 159 deletions

diff --git a/src/Data/JLD.hs b/src/Data/JLD.hs
index d60e5a1..1f894bb 100644
--- a/src/Data/JLD.hs
+++ b/src/Data/JLD.hs
@@ -2,22 +2,22 @@ module Data.JLD (
     module Data.JLD.Mime,
     module Data.JLD.Error,
     module Data.JLD.Options,
-    JLDExpandParams (..),
+    JLDExpansionParams (..),
     expand,
 ) where
 
 import Data.JLD.Prelude
 
-import Data.JLD.Context (buildActiveContext)
 import Data.JLD.Control.Monad.RES (evalREST, runREST)
 import Data.JLD.Error
 import Data.JLD.Expansion (JLDEParams (..))
 import Data.JLD.Expansion qualified as E (expand)
+import Data.JLD.Expansion.Context (buildActiveContext)
+import Data.JLD.Expansion.Global (JLDExpansionEnv (..), JLDExpansionState (..))
 import Data.JLD.Mime
 import Data.JLD.Model.ActiveContext (ActiveContext (..), newActiveContext)
 import Data.JLD.Model.Keyword (Keyword (..))
 import Data.JLD.Model.URI (uriToIri)
-import Data.JLD.Monad (JLDEnv, JLDState, newEnv, newState)
 import Data.JLD.Options
 import Data.JLD.Util (flattenSingletonArray, valueToArray)
 
@@ -26,31 +26,46 @@ import Data.Aeson.KeyMap qualified as KM
 import Data.Vector qualified as V (singleton)
 import Text.URI (URI)
 
-data JLDExpandParams e m = JLDExpandParams
-    { jldExpandParamsExpandContext :: Maybe Value
-    , jldExpandParamsFrameExpansion :: Bool
-    , jldExpandParamsEnv :: JLDEnv e m
-    , jldExpandParamsState :: JLDState
+data JLDExpansionParams e m = JLDExpansionParams
+    { jldExpansionParamsDocumentLoader :: DocumentLoader e m
+    , jldExpansionParamsProcessingMode :: JLDVersion
+    , jldExpansionParamsMaxRemoteContexts :: Int
+    , jldExpansionParamsExpandContext :: Maybe Value
+    , jldExpansionParamsFrameExpansion :: Bool
+    , jldExpansionParamsState :: JLDExpansionState
     }
     deriving (Show)
 
-expand :: Monad m => Value -> URI -> (JLDExpandParams () m -> JLDExpandParams e m) -> m (Either (JLDError e) Value, JLDState)
+expand :: Monad m => Value -> URI -> (JLDExpansionParams () m -> JLDExpansionParams e m) -> m (Either (JLDError e) Value, JLDExpansionState)
 expand document baseUrl paramsFn = do
-    let JLDExpandParams{..} =
+    let JLDExpansionParams{..} =
             paramsFn
-                JLDExpandParams
-                    { jldExpandParamsExpandContext = Nothing
-                    , jldExpandParamsFrameExpansion = False
-                    , jldExpandParamsEnv = newEnv id
-                    , jldExpandParamsState = newState id
+                JLDExpansionParams
+                    { jldExpansionParamsDocumentLoader = DocumentLoader <. const <. pure <| Left ()
+                    , jldExpansionParamsProcessingMode = JLD1_1
+                    , jldExpansionParamsMaxRemoteContexts = 20
+                    , jldExpansionParamsExpandContext = Nothing
+                    , jldExpansionParamsFrameExpansion = False
+                    , jldExpansionParamsState =
+                        JLDExpansionState
+                            { jldExpansionStateContextCache = mempty
+                            , jldExpansionStateDocumentCache = mempty
+                            }
                     }
 
+        env =
+            JLDExpansionEnv
+                { jldExpansionEnvDocumentLoader = jldExpansionParamsDocumentLoader
+                , jldExpansionEnvProcessingMode = jldExpansionParamsProcessingMode
+                , jldExpansionEnvMaxRemoteContexts = jldExpansionParamsMaxRemoteContexts
+                }
+
         activeContext = newActiveContext \ac -> ac{activeContextBaseUrl = Just baseUrl, activeContextBaseIri = uriToIri baseUrl}
-        expansionParams p = p{jldeParamsFrameExpansion = jldExpandParamsFrameExpansion}
+        expansionParams p = p{jldeParamsFrameExpansion = jldExpansionParamsFrameExpansion}
 
     -- 6.
     let maybeExpandContext =
-            jldExpandParamsExpandContext <&> flattenSingletonArray .> \case
+            jldExpansionParamsExpandContext <&> flattenSingletonArray .> \case
                 Array expandedContext -> Array expandedContext
                 (Object expandedContext) | Just ctx <- KM.lookup (show KeywordContext) expandedContext -> ctx
                 expandedContext -> Array <| V.singleton expandedContext
@@ -58,14 +73,14 @@ expand document baseUrl paramsFn = do
     activeContext' <- case maybeExpandContext of
         Just expandContext ->
             buildActiveContext activeContext expandContext (Just baseUrl) id
-                |> evalREST jldExpandParamsEnv jldExpandParamsState
+                |> evalREST env jldExpansionParamsState
                 |> fmap (fromRight activeContext)
         Nothing -> pure activeContext
 
     -- 8.
     (result, state') <-
         E.expand activeContext' document baseUrl expansionParams
-            |> runREST jldExpandParamsEnv jldExpandParamsState
+            |> runREST env jldExpansionParamsState
 
     let result' = case result of
             -- 8.1.
diff --git a/src/Data/JLD/Control/Monad/RES.hs b/src/Data/JLD/Control/Monad/RES.hs
index 1c96d46..b9f8f22 100644
--- a/src/Data/JLD/Control/Monad/RES.hs
+++ b/src/Data/JLD/Control/Monad/RES.hs
@@ -2,6 +2,7 @@ module Data.JLD.Control.Monad.RES (
     REST,
     runREST,
     evalREST,
+    execREST,
     withEnvRES,
     withErrorRES,
     withErrorRES',
@@ -20,6 +21,9 @@ runREST env st = flip runReaderT env .> runExceptT .> flip runStateT st
 evalREST :: Monad m => r -> s -> REST r e s m a -> m (Either e a)
 evalREST env st = flip runReaderT env .> runExceptT .> flip evalStateT st
 
+execREST :: Monad m => r -> s -> REST r e s m a -> m s
+execREST env st = flip runReaderT env .> runExceptT .> flip execStateT st
+
 withEnvRES :: (r -> r') -> REST r' e s m a -> REST r e s m a
 withEnvRES fn (ReaderT m) = ReaderT <| fn .> m
 
diff --git a/src/Data/JLD/Expansion.hs b/src/Data/JLD/Expansion.hs
index 18d7fc6..ff2d9c3 100644
--- a/src/Data/JLD/Expansion.hs
+++ b/src/Data/JLD/Expansion.hs
@@ -3,19 +3,19 @@ module Data.JLD.Expansion (JLDEParams (..), expand) where
 import Data.JLD.Prelude
 
 import Data.JLD.Control.Monad.RES (REST, withEnvRES, withStateRES)
-import Data.JLD.Context (BACParams (..), EIParams (..), buildActiveContext, expandIri)
+import Data.JLD.Error (JLDError (..))
+import Data.JLD.Expansion.Context (BACParams (..), EIParams (..), buildActiveContext, expandIri)
+import Data.JLD.Expansion.Global (JLDExpansionEnv (..), JLDExpansionState, JLDExpansionT)
 import Data.JLD.Model.ActiveContext (ActiveContext (..), lookupTerm)
 import Data.JLD.Model.Direction (Direction (..))
-import Data.JLD.Error (JLDError (..))
 import Data.JLD.Model.GraphObject (isNotGraphObject, toGraphObject)
 import Data.JLD.Model.Keyword (Keyword (..), isKeyword, isNotKeyword, parseKeyword)
 import Data.JLD.Model.Language (Language (..))
 import Data.JLD.Model.ListObject (isListObject, isNotListObject, toListObject)
-import Data.JLD.Monad (JLDEEnv (..), JLDEState (..), JLDET, JLDEnv (..), JLDT, modifyActiveContext)
 import Data.JLD.Model.NodeObject (isNotNodeObject)
-import Data.JLD.Options (JLDVersion (..))
 import Data.JLD.Model.TermDefinition (TermDefinition (..))
 import Data.JLD.Model.ValueObject (isNotValueObject', isValueObject, isValueObject')
+import Data.JLD.Options (JLDVersion (..))
 import Data.JLD.Util (
     allStrings,
     getMapDefault,
@@ -44,6 +44,36 @@ import Data.Vector qualified as V (catMaybes, concat, cons, filter, fromList, ma
 import Data.Vector.Algorithms.Merge qualified as V
 import Text.URI (URI)
 
+type JLDET e m = REST (JLDEEnv e m) (JLDError e) JLDEState m
+
+data JLDEEnv e m = JLDEEnv
+    { jldeEnvGlobal :: JLDExpansionEnv e m
+    , jldeEnvFrameExpansion :: Bool
+    , jldeEnvFromMap :: Bool
+    , jldeEnvBaseUrl :: URI
+    , jldeEnvActiveProperty :: Maybe Text
+    }
+    deriving (Show)
+
+data JLDEState = JLDEState
+    { jldeStateGlobal :: JLDExpansionState
+    , jldeStateActiveContext :: ActiveContext
+    }
+    deriving (Show, Eq)
+
+data JLDEParams = JLDEParams
+    { jldeParamsFrameExpansion :: Bool
+    , jldeParamsFromMap :: Bool
+    , jldeParamsBaseUrl :: URI
+    , jldeParamsActiveProperty :: Maybe Text
+    }
+    deriving (Show, Eq)
+
+modifyActiveContext :: MonadState JLDEState m => (ActiveContext -> ActiveContext) -> m ()
+modifyActiveContext fn = modify \s -> s{jldeStateActiveContext = fn (jldeStateActiveContext s)}
+
+--
+
 type EO1314T e m = REST (JLDEEnv e m) (JLDError e) EO1314State m
 
 data EO1314State = EO1314State
@@ -141,7 +171,7 @@ eo1314ExpandValue activeProperty value = do
 eo1314ExpandKeywordItem :: Monad m => Maybe Text -> Key -> Keyword -> Value -> EO1314T e m ()
 eo1314ExpandKeywordItem inputType key keyword value = do
     JLDEEnv{..} <- ask
-    let JLDEnv{..} = jldeEnvGlobal
+    let JLDExpansionEnv{..} = jldeEnvGlobal
 
     -- 13.4.1.
     when (jldeEnvActiveProperty == Just (show KeywordReverse)) <| throwError InvalidReversePropertyMap
@@ -222,7 +252,7 @@ eo1314ExpandKeywordItem inputType key keyword value = do
         -- 13.4.6.
         KeywordIncluded
             -- 13.4.6.1.
-            | JLD1_0 <- jldEnvProcessingMode -> pure Nothing
+            | JLD1_0 <- jldExpansionEnvProcessingMode -> pure Nothing
             -- 13.4.6.2.
             | otherwise -> do
                 expandedValue <- valueToArray <$> eo1314ExpandAC Nothing value id
@@ -242,7 +272,7 @@ eo1314ExpandKeywordItem inputType key keyword value = do
             expandedValue <- case value of
                 -- 13.4.7.1.
                 _ | inputType == Just (show KeywordJson) -> do
-                    if jldEnvProcessingMode == JLD1_0
+                    if jldExpansionEnvProcessingMode == JLD1_0
                         then throwError InvalidValueObjectValue
                         else pure value
                 -- 13.4.7.2.
@@ -269,7 +299,7 @@ eo1314ExpandKeywordItem inputType key keyword value = do
             _ -> throwError InvalidLanguageTaggedString
         -- 13.4.9.
         KeywordDirection
-            | JLD1_0 <- jldEnvProcessingMode -> pure Nothing
+            | JLD1_0 <- jldExpansionEnvProcessingMode -> pure Nothing
             | otherwise -> case value of
                 String ((`elem` ["ltr", "rtl"]) -> True)
                     | jldeEnvFrameExpansion -> pure <. Just <. Array <| V.singleton value
@@ -815,14 +845,6 @@ expandValue activeProperty value = do
 
 --
 
-data JLDEParams = JLDEParams
-    { jldeParamsFrameExpansion :: Bool
-    , jldeParamsFromMap :: Bool
-    , jldeParamsBaseUrl :: URI
-    , jldeParamsActiveProperty :: Maybe Text
-    }
-    deriving (Show, Eq)
-
 exModifyActiveContext :: Monad m => (ActiveContext -> ActiveContext) -> JLDET e m ()
 exModifyActiveContext fn = modify \st -> st{jldeStateActiveContext = fn (jldeStateActiveContext st)}
 
@@ -911,7 +933,7 @@ expand' = \case
                 -- 4.3.
                 | otherwise -> Object <$> expandValue activeProperty value
 
-expand :: Monad m => ActiveContext -> Value -> URI -> (JLDEParams -> JLDEParams) -> JLDT e m Value
+expand :: Monad m => ActiveContext -> Value -> URI -> (JLDEParams -> JLDEParams) -> JLDExpansionT e m Value
 expand activeContext value baseUrl paramsFn =
     expand' value
         |> withEnvRES env
diff --git a/src/Data/JLD/Context.hs b/src/Data/JLD/Expansion/Context.hs
index a999395..ce61644 100644
--- a/src/Data/JLD/Context.hs
+++ b/src/Data/JLD/Expansion/Context.hs
@@ -1,19 +1,19 @@
-module Data.JLD.Context (BTDParams (..), EIParams (..), BACParams (..), buildTermDefinition, expandIri, buildActiveContext) where
+module Data.JLD.Expansion.Context (BTDParams (..), EIParams (..), BACParams (..), buildTermDefinition, expandIri, buildActiveContext) where
 
 import Data.JLD.Prelude
 
 import Data.JLD.Control.Monad.RES (REST, withEnvRES, withErrorRES, withErrorRES', withStateRES)
+import Data.JLD.Error (JLDError (..))
+import Data.JLD.Expansion.Global (JLDExpansionEnv (..), JLDExpansionState (..), JLDExpansionT, hoistEnv, modifyContextCache, modifyDocumentCache)
 import Data.JLD.Model.ActiveContext (ActiveContext (..), containsProtectedTerm, lookupTerm, newActiveContext)
 import Data.JLD.Model.Direction (Direction (..))
-import Data.JLD.Error (JLDError (..))
 import Data.JLD.Model.IRI (CompactIRI (..), endsWithGenericDelim, isBlankIri, parseCompactIri)
 import Data.JLD.Model.Keyword (Keyword (..), allKeywords, isKeyword, isKeywordLike, isNotKeyword, parseKeyword)
 import Data.JLD.Model.Language (Language (..))
-import Data.JLD.Monad (JLDEnv (..), JLDState (..), JLDT, hoistEnv, modifyContextCache, modifyDocumentCache)
-import Data.JLD.Options (ContextCache, Document (..), DocumentCache, DocumentLoader (..), JLDVersion (..))
 import Data.JLD.Model.TermDefinition (TermDefinition (..), newTermDefinition)
-import Data.JLD.Util (flattenSingletonArray, valueContains, valueContainsAny, valueIsTrue, valueToArray)
 import Data.JLD.Model.URI (parseUri, uriToIri)
+import Data.JLD.Options (ContextCache, Document (..), DocumentCache, DocumentLoader (..), JLDVersion (..))
+import Data.JLD.Util (flattenSingletonArray, valueContains, valueContainsAny, valueIsTrue, valueToArray)
 
 import Control.Monad.Except (MonadError (..))
 import Data.Aeson (Object, Value (..))
@@ -30,7 +30,7 @@ import Text.URI qualified as U (render)
 type BACT e m = REST (BACEnv e m) (Either (JLDError e) ()) BACState m
 
 data BACEnv e m = BACEnv
-    { bacEnvGlobal :: JLDEnv e m
+    { bacEnvGlobal :: JLDExpansionEnv e m
     , bacEnvOverrideProtected :: Bool
     , bacEnvValidateScopedContext :: Bool
     , bacEnvPropagate :: Bool
@@ -38,7 +38,7 @@ data BACEnv e m = BACEnv
     deriving (Show)
 
 data BACState = BACState
-    { bacStateGlobal :: JLDState
+    { bacStateGlobal :: JLDExpansionState
     , bacStateActiveContext :: ActiveContext
     , bacStateRemoteContexts :: Set Text
     }
@@ -103,7 +103,7 @@ bacBuildActiveContext context uri = do
 bacProcessItem :: Monad m => Maybe URI -> Value -> BACT e m ()
 bacProcessItem baseUrl item = do
     BACEnv{..} <- ask
-    let JLDEnv{..} = hoistEnv (lift .> lift .> lift) bacEnvGlobal
+    let JLDExpansionEnv{..} = hoistEnv (lift .> lift .> lift) bacEnvGlobal
 
     result <- gets bacStateActiveContext
 
@@ -133,10 +133,10 @@ bacProcessItem baseUrl item = do
             -- 5.5. 5.5.1. 5.5.2.
             case KM.lookup (show KeywordVersion) contextDefinition of
                 Just (String "1.1")
-                    | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left ProcessingModeConflict
+                    | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left ProcessingModeConflict
                     | otherwise -> pure ()
                 Just (Number 1.1)
-                    | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left ProcessingModeConflict
+                    | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left ProcessingModeConflict
                     | otherwise -> pure ()
                 Just value -> throwError <. Left <| InvalidKeywordValue KeywordVersion value
                 --
@@ -145,12 +145,12 @@ bacProcessItem baseUrl item = do
             -- 5.6.
             contextDefinition' <- case KM.lookup (show KeywordImport) contextDefinition of
                 -- 5.6.1.
-                Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidContextEntry
+                Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidContextEntry
                 -- 5.6.3.
                 Just (String value)
                     | Just importUri <- parseUri value
                     , Just contextUri <- relativeTo importUri =<< baseUrl ->
-                        runDocumentLoader jldEnvDocumentLoader contextUri >>= \case
+                        runDocumentLoader jldExpansionEnvDocumentLoader contextUri >>= \case
                             Right (Object document) -> case KM.lookup (show KeywordContext) document of
                                 Just (Object remoteContext)
                                     -- 5.6.7.
@@ -226,7 +226,7 @@ bacProcessItem baseUrl item = do
             -- 5.10. 5.10.2.
             case KM.lookup (show KeywordDirection) contextDefinition' of
                 -- 5.10.1.
-                Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidContextEntry
+                Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidContextEntry
                 -- 5.10.3.
                 Just Null -> bacModifyActiveContext \ac -> ac{activeContextDefaultBaseDirection = Nothing}
                 --
@@ -239,7 +239,7 @@ bacProcessItem baseUrl item = do
             -- 5.11.
             case KM.lookup (show KeywordPropagate) contextDefinition' of
                 -- 5.11.1.
-                Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidContextEntry
+                Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidContextEntry
                 Just (Bool _) -> pure ()
                 Just invalid -> throwError <. Left <| InvalidKeywordValue KeywordPropagate invalid
                 --
@@ -271,7 +271,7 @@ bacFetchRemoteContext url maybeBaseUrl
     , isPathAbsolute contextUri
     , contextKey <- U.render contextUri = do
         BACEnv{..} <- ask
-        let JLDEnv{..} = hoistEnv (lift .> lift .> lift) bacEnvGlobal
+        let JLDExpansionEnv{..} = hoistEnv (lift .> lift .> lift) bacEnvGlobal
 
         remoteContexts <- gets bacStateRemoteContexts
 
@@ -279,12 +279,12 @@ bacFetchRemoteContext url maybeBaseUrl
         when (not bacEnvValidateScopedContext && S.member contextKey remoteContexts) <| throwError (Right ())
 
         -- 5.2.3.
-        when (S.size remoteContexts > jldEnvMaxRemoteContexts) <| throwError (Left ContextOverflow)
+        when (S.size remoteContexts > jldExpansionEnvMaxRemoteContexts) <| throwError (Left ContextOverflow)
 
         bacModifyRemoteContexts <| S.insert contextKey
 
         -- 5.2.4.
-        gets (bacStateGlobal .> jldStateContextCache .> M.lookup contextKey) >>= \case
+        gets (bacStateGlobal .> jldExpansionStateContextCache .> M.lookup contextKey) >>= \case
             Just cachedContext -> do
                 bacBuildActiveContext cachedContext contextUri
                 throwError <| Right ()
@@ -293,10 +293,10 @@ bacFetchRemoteContext url maybeBaseUrl
 
         -- 5.2.5.
         document <-
-            gets (bacStateGlobal .> jldStateDocumentCache .> M.lookup contextKey) >>= \case
+            gets (bacStateGlobal .> jldExpansionStateDocumentCache .> M.lookup contextKey) >>= \case
                 Just document -> pure document
                 Nothing ->
-                    runDocumentLoader jldEnvDocumentLoader contextUri >>= \case
+                    runDocumentLoader jldExpansionEnvDocumentLoader contextUri >>= \case
                         Right (Object document) -> pure <| Document contextUri document
                         -- 5.2.5.2.
                         Right _ -> throwError <| Left InvalidRemoteContext
@@ -341,7 +341,7 @@ buildActiveContext' localContext baseUrl = do
         .> withEnvRES (\env -> env{bacEnvPropagate = propagate})
         .> withErrorRES' (either (Left .> throwError) pure)
 
-buildActiveContext :: Monad m => ActiveContext -> Value -> Maybe URI -> (BACParams -> BACParams) -> JLDT e m ActiveContext
+buildActiveContext :: Monad m => ActiveContext -> Value -> Maybe URI -> (BACParams -> BACParams) -> JLDExpansionT e m ActiveContext
 buildActiveContext activeContext localContext baseUrl paramsFn = do
     BACState{..} <-
         (buildActiveContext' localContext baseUrl >> get)
@@ -379,7 +379,7 @@ buildActiveContext activeContext localContext baseUrl paramsFn = do
 type EIT e m = REST (EIEnv e m) (JLDError e) EIState m
 
 data EIEnv e m = EIEnv
-    { eiEnvGlobal :: JLDEnv e m
+    { eiEnvGlobal :: JLDExpansionEnv e m
     , eiEnvDocumentRelative :: Bool
     , eiEnvVocab :: Bool
     , eiEnvLocalContext :: Maybe Object
@@ -387,7 +387,7 @@ data EIEnv e m = EIEnv
     deriving (Show)
 
 data EIState = EIState
-    { eiStateGlobal :: JLDState
+    { eiStateGlobal :: JLDExpansionState
     , eiStateDefined :: Map Text Bool
     , eiStateActiveContext :: ActiveContext
     }
@@ -500,7 +500,7 @@ expandIri' value
             --
             _ -> eiExpandResult value
 
-expandIri :: Monad m => ActiveContext -> Text -> (EIParams -> EIParams) -> JLDT e m (Maybe Text, ActiveContext, Map Text Bool)
+expandIri :: Monad m => ActiveContext -> Text -> (EIParams -> EIParams) -> JLDExpansionT e m (Maybe Text, ActiveContext, Map Text Bool)
 expandIri activeContext value paramsFn = do
     (value', EIState{..}) <-
         (expandIri' value >>= \v -> gets (v,))
@@ -537,7 +537,7 @@ expandIri activeContext value paramsFn = do
 type BTDT e m = REST (BTDEnv e m) (Either (JLDError e) ()) BTDState m
 
 data BTDEnv e m = BTDEnv
-    { btdEnvGlobal :: JLDEnv e m
+    { btdEnvGlobal :: JLDExpansionEnv e m
     , btdEnvLocalContext :: Object
     , btdEnvBaseUrl :: Maybe URI
     , btdEnvProtectedFlag :: Bool
@@ -547,7 +547,7 @@ data BTDEnv e m = BTDEnv
     deriving (Show)
 
 data BTDState = BTDState
-    { btdStateGlobal :: JLDState
+    { btdStateGlobal :: JLDExpansionState
     , btdStateDefined :: Map Text Bool
     , btdStateTermDefinition :: TermDefinition
     , btdStateActiveContext :: ActiveContext
@@ -573,10 +573,10 @@ btdModifyTermDefinition fn = modify \s -> s{btdStateTermDefinition = fn (btdStat
 btdModifyDefined :: Monad m => (Map Text Bool -> Map Text Bool) -> BTDT e m ()
 btdModifyDefined fn = modify \s -> s{btdStateDefined = fn (btdStateDefined s)}
 
-btdValidateContainer :: JLDEnv e m -> Value -> Bool
+btdValidateContainer :: JLDExpansionEnv e m -> Value -> Bool
 btdValidateContainer _ Null = False
-btdValidateContainer JLDEnv{..} value
-    | JLD1_0 <- jldEnvProcessingMode = case value of
+btdValidateContainer JLDExpansionEnv{..} value
+    | JLD1_0 <- jldExpansionEnvProcessingMode = case value of
         String value' -> isNotKeyword value' [KeywordGraph, KeywordId, KeywordType]
         _ -> False
     | otherwise = case flattenSingletonArray value of
@@ -647,7 +647,7 @@ buildTermDefinition' :: Monad m => Text -> BTDT e m ()
 buildTermDefinition' "" = throwError <| Left InvalidTermDefinition -- 2.
 buildTermDefinition' term = do
     BTDEnv{..} <- ask
-    let JLDEnv{..} = btdEnvGlobal
+    let JLDExpansionEnv{..} = btdEnvGlobal
 
     -- 1.
     gets (btdStateDefined .> M.lookup term) >>= \case
@@ -664,7 +664,7 @@ buildTermDefinition' term = do
     -- 4.
     case term of
         ((`isKeyword` [KeywordType]) -> True)
-            | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left KeywordRedefinition
+            | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left KeywordRedefinition
             | Object map' <- value ->
                 if
                         | KM.size map' == 1
@@ -699,7 +699,7 @@ buildTermDefinition' term = do
 
     -- 11.
     case KM.lookup (show KeywordProtected) valueObject of
-        Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidTermDefinition
+        Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidTermDefinition
         Just (Bool protected) -> btdModifyTermDefinition \d -> d{termDefinitionProtectedFlag = protected}
         Just invalid -> throwError <. Left <| InvalidKeywordValue KeywordProtected invalid
         Nothing -> pure ()
@@ -713,7 +713,7 @@ buildTermDefinition' term = do
                 Just expandedType
                     -- 12.3.
                     | isKeyword expandedType [KeywordJson, KeywordNone]
-                    , JLD1_0 <- jldEnvProcessingMode ->
+                    , JLD1_0 <- jldExpansionEnvProcessingMode ->
                         throwError <| Left InvalidTypeMapping
                     -- 12.4.
                     | isNotKeyword expandedType [KeywordId, KeywordJson, KeywordNone, KeywordVocab]
@@ -866,7 +866,7 @@ buildTermDefinition' term = do
     containerMapping <- gets (btdStateTermDefinition .> termDefinitionContainerMapping)
     case KM.lookup (show KeywordIndex) valueObject of
         -- 20.1.
-        Just _ | jldEnvProcessingMode == JLD1_0 || S.notMember (show KeywordIndex) containerMapping -> throwError <| Left InvalidTermDefinition
+        Just _ | jldExpansionEnvProcessingMode == JLD1_0 || S.notMember (show KeywordIndex) containerMapping -> throwError <| Left InvalidTermDefinition
         -- 20.2.
         Just (String index) ->
             btdExpandIri index >>= \case
@@ -879,7 +879,7 @@ buildTermDefinition' term = do
     -- 21.
     case KM.lookup (show KeywordContext) valueObject of
         -- 21.1.
-        Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidTermDefinition
+        Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidTermDefinition
         -- 21.2.
         Just context -> do
             -- 21.3.
@@ -925,7 +925,7 @@ buildTermDefinition' term = do
     -- 24.
     case KM.lookup (show KeywordNest) valueObject of
         -- 24.1.
-        Just _ | JLD1_0 <- jldEnvProcessingMode -> throwError <| Left InvalidTermDefinition
+        Just _ | JLD1_0 <- jldExpansionEnvProcessingMode -> throwError <| Left InvalidTermDefinition
         Just (String nest)
             | parseKeyword nest /= Just KeywordNest -> throwError <. Left <| InvalidKeywordValue KeywordNest (String nest)
             | otherwise -> btdModifyTermDefinition \d -> d{termDefinitionNestValue = Just nest}
@@ -937,7 +937,7 @@ buildTermDefinition' term = do
     case KM.lookup (show KeywordPrefix) valueObject of
         -- 25.1.
         Just _
-            | jldEnvProcessingMode == JLD1_0 || T.elem ':' term || T.elem '/' term ->
+            | jldExpansionEnvProcessingMode == JLD1_0 || T.elem ':' term || T.elem '/' term ->
                 throwError <| Left InvalidTermDefinition
         Just (Bool prefix)
             | prefix, Just _ <- parseKeyword =<< maybeIriMapping -> throwError <| Left InvalidTermDefinition
@@ -981,7 +981,7 @@ buildTermDefinition' term = do
 
     btdModifyDefined <| M.insert term True
 
-buildTermDefinition :: Monad m => ActiveContext -> Object -> Text -> (BTDParams -> BTDParams) -> JLDT e m (ActiveContext, Map Text Bool)
+buildTermDefinition :: Monad m => ActiveContext -> Object -> Text -> (BTDParams -> BTDParams) -> JLDExpansionT e m (ActiveContext, Map Text Bool)
 buildTermDefinition activeContext localContext term paramsFn = do
     BTDState{..} <-
         (buildTermDefinition' term >> get)
diff --git a/src/Data/JLD/Expansion/Global.hs b/src/Data/JLD/Expansion/Global.hs
new file mode 100644
index 0000000..b92b4af
--- /dev/null
+++ b/src/Data/JLD/Expansion/Global.hs
@@ -0,0 +1,38 @@
+module Data.JLD.Expansion.Global (
+    JLDExpansionT,
+    JLDExpansionEnv (..),
+    JLDExpansionState (..),
+    hoistEnv,
+    modifyContextCache,
+    modifyDocumentCache,
+) where
+
+import Data.JLD.Prelude
+
+import Data.JLD.Control.Monad.RES (REST)
+import Data.JLD.Error (JLDError)
+import Data.JLD.Options (ContextCache, DocumentCache, DocumentLoader (..), JLDVersion (..), hoistDocumentLoader)
+
+type JLDExpansionT e m = REST (JLDExpansionEnv e m) (JLDError e) JLDExpansionState m
+
+data JLDExpansionEnv e m = JLDExpansionEnv
+    { jldExpansionEnvDocumentLoader :: DocumentLoader e m
+    , jldExpansionEnvProcessingMode :: JLDVersion
+    , jldExpansionEnvMaxRemoteContexts :: Int
+    }
+    deriving (Show)
+
+data JLDExpansionState = JLDExpansionState
+    { jldExpansionStateContextCache :: ContextCache
+    , jldExpansionStateDocumentCache :: DocumentCache
+    }
+    deriving (Show, Eq)
+
+hoistEnv :: (forall a. m a -> n a) -> JLDExpansionEnv e m -> JLDExpansionEnv e n
+hoistEnv map' options = options{jldExpansionEnvDocumentLoader = options |> jldExpansionEnvDocumentLoader .> hoistDocumentLoader map'}
+
+modifyContextCache :: MonadState JLDExpansionState m => (ContextCache -> ContextCache) -> m ()
+modifyContextCache fn = modify \s -> s{jldExpansionStateContextCache = fn (jldExpansionStateContextCache s)}
+
+modifyDocumentCache :: MonadState JLDExpansionState m => (DocumentCache -> DocumentCache) -> m ()
+modifyDocumentCache fn = modify \s -> s{jldExpansionStateDocumentCache = fn (jldExpansionStateDocumentCache s)}
diff --git a/src/Data/JLD/Monad.hs b/src/Data/JLD/Monad.hs
deleted file mode 100644
index 3ae929d..0000000
--- a/src/Data/JLD/Monad.hs
+++ /dev/null
@@ -1,86 +0,0 @@
-module Data.JLD.Monad (
-    JLDT,
-    JLDEnv (..),
-    JLDState (..),
-    newEnv,
-    newState,
-    hoistEnv,
-    modifyContextCache,
-    modifyDocumentCache,
-    JLDET,
-    JLDEEnv (..),
-    JLDEState (..),
-    modifyActiveContext,
-) where
-
-import Data.JLD.Prelude
-
-import Data.JLD.Control.Monad.RES (REST)
-import Data.JLD.Error (JLDError)
-import Data.JLD.Model.ActiveContext (ActiveContext)
-import Data.JLD.Options (ContextCache, DocumentCache, DocumentLoader (..), JLDVersion (..), hoistDocumentLoader)
-
-import Text.URI (URI)
-
-type JLDT e m = REST (JLDEnv e m) (JLDError e) JLDState m
-
-data JLDEnv e m = JLDEnv
-    { jldEnvDocumentLoader :: DocumentLoader e m
-    , jldEnvProcessingMode :: JLDVersion
-    , jldEnvMaxRemoteContexts :: Int
-    }
-    deriving (Show)
-
-data JLDState = JLDState
-    { jldStateContextCache :: ContextCache
-    , jldStateDocumentCache :: DocumentCache
-    }
-    deriving (Show, Eq)
-
-newEnv :: Applicative m => (JLDEnv () m -> JLDEnv e m) -> JLDEnv e m
-newEnv fn =
-    fn
-        JLDEnv
-            { jldEnvDocumentLoader = DocumentLoader (const <. pure <| Left ())
-            , jldEnvProcessingMode = JLD1_1
-            , jldEnvMaxRemoteContexts = 20
-            }
-
-newState :: (JLDState -> JLDState) -> JLDState
-newState fn =
-    fn
-        JLDState
-            { jldStateContextCache = mempty
-            , jldStateDocumentCache = mempty
-            }
-
-hoistEnv :: (forall a. m a -> n a) -> JLDEnv e m -> JLDEnv e n
-hoistEnv map' options = options{jldEnvDocumentLoader = options |> jldEnvDocumentLoader .> hoistDocumentLoader map'}
-
-modifyContextCache :: MonadState JLDState m => (ContextCache -> ContextCache) -> m ()
-modifyContextCache fn = modify \s -> s{jldStateContextCache = fn (jldStateContextCache s)}
-
-modifyDocumentCache :: MonadState JLDState m => (DocumentCache -> DocumentCache) -> m ()
-modifyDocumentCache fn = modify \s -> s{jldStateDocumentCache = fn (jldStateDocumentCache s)}
-
---
-
-type JLDET e m = REST (JLDEEnv e m) (JLDError e) JLDEState m
-
-data JLDEEnv e m = JLDEEnv
-    { jldeEnvGlobal :: JLDEnv e m
-    , jldeEnvFrameExpansion :: Bool
-    , jldeEnvFromMap :: Bool
-    , jldeEnvBaseUrl :: URI
-    , jldeEnvActiveProperty :: Maybe Text
-    }
-    deriving (Show)
-
-data JLDEState = JLDEState
-    { jldeStateGlobal :: JLDState
-    , jldeStateActiveContext :: ActiveContext
-    }
-    deriving (Show, Eq)
-
-modifyActiveContext :: MonadState JLDEState m => (ActiveContext -> ActiveContext) -> m ()
-modifyActiveContext fn = modify \s -> s{jldeStateActiveContext = fn (jldeStateActiveContext s)}
diff --git a/src/Data/JLD/NodeMap.hs b/src/Data/JLD/NodeMap.hs
new file mode 100644
index 0000000..0c40c9a
--- /dev/null
+++ b/src/Data/JLD/NodeMap.hs
@@ -0,0 +1,88 @@
+module Data.JLD.NodeMap (NodeMap, BNMParams (..)) where
+
+import Data.JLD.Prelude
+
+import Data.JLD.Control.Monad.RES (REST, execREST, runREST, withEnvRES, withErrorRES, withErrorRES', withStateRES)
+import Data.JLD.Error (JLDError (..))
+import Data.JLD.Model.ActiveContext (ActiveContext (..), containsProtectedTerm, lookupTerm, newActiveContext)
+import Data.JLD.Model.Direction (Direction (..))
+import Data.JLD.Model.IRI (CompactIRI (..), endsWithGenericDelim, isBlankIri, parseCompactIri)
+import Data.JLD.Model.Keyword (Keyword (..), allKeywords, isKeyword, isKeywordLike, isNotKeyword, parseKeyword)
+import Data.JLD.Model.Language (Language (..))
+import Data.JLD.Model.TermDefinition (TermDefinition (..), newTermDefinition)
+import Data.JLD.Model.URI (parseUri, uriToIri)
+import Data.JLD.Options (ContextCache, Document (..), DocumentCache, DocumentLoader (..), JLDVersion (..))
+import Data.JLD.Util (flattenSingletonArray, valueContains, valueContainsAny, valueIsTrue, valueToArray)
+
+import Control.Monad.Except (MonadError (..))
+import Data.Aeson (Object, Value (..))
+import Data.Aeson.Key qualified as K (fromText, toText)
+import Data.Aeson.KeyMap qualified as KM (delete, keys, lookup, member, size)
+import Data.Map.Strict qualified as M (delete, insert, lookup)
+import Data.RDF (parseIRI, parseRelIRI, resolveIRI, serializeIRI, validateIRI)
+import Data.Set qualified as S (insert, member, notMember, size)
+import Data.Text qualified as T (drop, dropEnd, elem, findIndex, isPrefixOf, null, take, toLower)
+import Data.Vector qualified as V (length)
+import Text.URI (URI, isPathAbsolute, relativeTo)
+import Text.URI qualified as U (render)
+
+type NodeMap = Map (Text, Text, Text) Value
+
+type BNMT e m = REST BNMEnv (JLDError e) BNMState m
+
+data BNMEnv = BNMEnv
+    { bnmEnvDocument :: Value
+    , bnmEnvActiveGraph :: Text
+    , bnmEnvActiveSubject :: Maybe Text
+    , bnmEnvActiveProperty :: Maybe Text
+    }
+    deriving (Show)
+
+newtype BNMState = BNMState
+    { bnmStateNodeMap :: NodeMap
+    }
+    deriving (Show, Eq)
+
+data BNMParams = BNMParams
+    { bnmParamsNodeMap :: NodeMap
+    , bnmParamsActiveGraph :: Text
+    , bnmParamsActiveSubject :: Maybe Text
+    , bnmParamsActiveProperty :: Maybe Text
+    , bnmParamsList :: Map Text Value
+    }
+    deriving (Show, Eq)
+
+bnmModifyNodeMap :: Monad m => (NodeMap -> NodeMap) -> BNMT e m ()
+bnmModifyNodeMap fn = modify \s -> s{bnmStateNodeMap = fn (bnmStateNodeMap s)}
+
+buildNodeMap' :: Monad m => BNMT e m ()
+buildNodeMap' = do
+    pure ()
+
+buildNodeMap :: Monad m => Value -> (BNMParams -> BNMParams) -> m NodeMap
+buildNodeMap document paramsFn = do
+    BNMState{..} <- buildNodeMap' |> execREST env st
+    pure bnmStateNodeMap
+  where
+    BNMParams{..} =
+        paramsFn
+            BNMParams
+                { bnmParamsNodeMap = mempty
+                , bnmParamsActiveGraph = show KeywordDefault
+                , bnmParamsActiveSubject = Nothing
+                , bnmParamsActiveProperty = Nothing
+                , bnmParamsList = mempty
+                }
+
+    env =
+        BNMEnv
+            { bnmEnvDocument = document
+            , bnmEnvActiveGraph = bnmParamsActiveGraph
+            , bnmEnvActiveSubject = bnmParamsActiveSubject
+            , bnmEnvActiveProperty = bnmParamsActiveProperty
+            }
+
+    st =
+        BNMState
+            { bnmStateNodeMap = bnmParamsNodeMap
+            }