anchor.diff:                  ErroredFields = errors |> Array.map (function (f,_) as err -> f.ToString(), state.Serializer.PickleTyped err)
               }
   
  -        let pkg = state.AssemblyCache.WriteStaticInitializers(sliceInfo.Assembly, initializers, metadata)
  -        let generationIndex = state.AssemblyExportState.Add(id, metadata)
  -
  -        { state with AssemblyExportState = generationIndex }, pkg
  -
  -    | Some(_, sliceInfo) -> 
  -        let va = state.AssemblyCache.CreateVagabondAssembly(sliceInfo.Assembly)
  -        state, va
  +        let va = state.AssemblyCache.WriteStaticInitializers(sliceInfo.Assembly, initializers, metadata)
  +        let exportState = state.AssemblyExportState.Add(id, va)
  +        { state with AssemblyExportState = exportState }, va
  +
  +    | Some(_, sliceInfo) ->
  +        match state.AssemblyExportState.TryFind id with
  +        | Some va -> state, va
  +        | None ->
  +            // does not require static initialization, return as is
  +            let va = state.AssemblyCache.CreateVagabondAssembly sliceInfo.Assembly
  +            let exportState = state.AssemblyExportState.Add(id, va)
  +            { state with AssemblyExportState = exportState }, va
   
       | None ->
           // assembly not a local dynamic assembly slice, need to lookup cache and AppDomain in that order; 
           // this is because cache contains vagabond metadata while AppDomain does not.
  -        match state.AssemblyCache.TryGetCachedAssemblyInfo id with
  -        | Some pkg -> state, pkg
  +        match state.AssemblyExportState.TryFind id with
  +        | Some va -> state, va
           | None ->
  -            // finally, attempt to resolve from AppDomain
  -            let localAssembly =
  -                if id.CanBeResolvedLocally policy then tryLoadAssembly id.FullName
  -                else tryGetLoadedAssembly id.FullName
  -
  -            match localAssembly with
  -            | Some a when policy.HasFlag AssemblyLoadPolicy.RequireIdentical && a.AssemblyId <> id ->
  -                let msg = sprintf "an incompatible version of '%s' has been loaded." id.FullName
  -                raise <| VagabondException(msg)
  -
  -            | Some asmb -> 
  -                let pkg = state.AssemblyCache.CreateVagabondAssembly asmb
  -                state, pkg
  -
  +            match state.AssemblyCache.TryGetCachedAssemblyInfo id with
  +            | Some pkg -> state, pkg
               | None ->
  -                let msg = sprintf "could not retrieve assembly '%s' from local environment." id.FullName
  -                raise <| VagabondException(msg)
  +                // finally, attempt to resolve from AppDomain
  +                let localAssembly =
  +                    if id.CanBeResolvedLocally policy then tryLoadAssembly id.FullName
  +                    else tryGetLoadedAssembly id.FullName
  +
  +                match localAssembly with
  +                | Some a when policy.HasFlag AssemblyLoadPolicy.RequireIdentical && a.AssemblyId <> id ->
  +                    let msg = sprintf "an incompatible version of '%s' has been loaded." id.FullName
  +                    raise <| VagabondException(msg)
  +
  +                | Some asmb -> 
  +                    let va = state.AssemblyCache.CreateVagabondAssembly asmb
  +                    let exportState = state.AssemblyExportState.Add(id, va)
  +                    { state with AssemblyExportState = exportState }, va
  +
  +                | None ->
  +                    let msg = sprintf "could not retrieve assembly '%s' from local environment." id.FullName
  +                    raise <| VagabondException(msg)
   
   
   ///
  
positive.code:     match state.CompilerState.TryFindSliceInfo id.FullName with
      // is dynamic assembly slice which requires static initialization
      | Some (dynAssembly, sliceInfo) when sliceInfo.RequiresStaticInitialization ->
  
          let generation =
              match state.AssemblyExportState.TryFind id with
              | None -> 0
              | Some md -> md.Generation + 1
                  
          let tryPickle (fI : FieldInfo) =
              try
  
negative.code: 
          let initializers, errors = Array.map tryPickle sliceInfo.StaticFields |> Choice.split
  
          let metadata =
              {
                  Generation = generation
  