diff --git a/src/crawl/artifactgenctx.py b/src/crawl/artifactgenctx.py
new file mode 100644
index 0000000..ca5d290
--- /dev/null
+++ b/src/crawl/artifactgenctx.py
@@ -0,0 +1,78 @@
+import crawl.pom
+
+
+class ArtifactGenerationContext:
+    """
+    Information about a single artifact that was crawled.
+    """
+
+    def __init__(self, workspace, pom_template, artifact_def, dependency):
+        self._artifact_def = artifact_def
+        self._dependency = dependency
+
+        self._direct_dependencies = []
+        self._artifact_transitive_closure = []
+        self._library_transitive_closure = []
+
+        # TODO remove/make this factory/config based
+        self._generator = crawl.pom.get_pom_generator(
+            workspace, pom_template, artifact_def, dependency)
+
+    @property
+    def artifact_def(self):
+        """
+        The artifact that this context is for.
+        """
+        return self._artifact_def
+
+    @property
+    def dependency(self):
+        """
+        The dependency that points at this artifact (that dragged it in).
+        """
+        return self._dependency
+
+    @property
+    def direct_dependencies(self):
+        return self._direct_dependencies
+
+    @property
+    def artifact_transitive_closure(self):
+        return self._artifact_transitive_closure
+
+    @property
+    def library_transitive_closure(self):
+        return self._library_transitive_closure
+
+    @property
+    def generator(self):
+        return self._generator
+
+    def register_artifact_directs(self, dependencies):
+        """
+        Registers the dependencies this artifact references explicitly.
+        """
+        self._direct_dependencies = dependencies
+        self._generator.register_dependencies(dependencies)
+
+    def register_artifact_transitive_closure(self, dependencies):
+        """
+        Registers the transitive closure of dependencies of this artifact.
+        """
+        self._artifact_transitive_closure = dependencies
+        self._generator.register_dependencies_transitive_closure__artifact(dependencies)
+
+    def register_library_transitive_closure(self, dependencies):
+        """
+        Registers the transitive closure of dependencies of the library
+        that this artifact belongs to.
+        """
+        self._library_transitive_closure = dependencies
+        self._generator.register_dependencies_transitive_closure__library(dependencies)
+
+    def gen_goldfile_manifest(self):
+        """
+        TODO - fix abstraction - move to after crawling?
+        """
+        import crawl.pom
+        return self._generator.gen(crawl.pom.PomContentType.GOLDFILE)
diff --git a/src/crawl/crawler.py b/src/crawl/crawler.py
index 76631b6..3502d05 100644
--- a/src/crawl/crawler.py
+++ b/src/crawl/crawler.py
@@ -9,9 +9,9 @@
 """
 from collections import defaultdict
 from common import logger
+from crawl import artifactgenctx
 from crawl import dependency
 from crawl import bazel
-from crawl import pom
 from crawl import pomparser
 from crawl.releasereason import ReleaseReason
 import difflib
@@ -50,11 +50,10 @@ class CrawlerResult:
     """
     Useful bits and pieces that are the outcome of crawling Bazel BUILD files.
     """
+    def __init__(self, genctxs, nodes, crawled_bazel_packages):
 
-    def __init__(self, pomgens, nodes, crawled_bazel_packages):
-
-        # list of pom generators, for poms that need to be generated:
-        self.pomgens = pomgens
+        # artifactgenctx.ArtifactGenerationContext instances
+        self.artifact_generation_contexts = genctxs
 
         # list of root nodes
         self.nodes = nodes
@@ -75,7 +74,7 @@ def __init__(self, workspace, pom_template, verbose=False):
         self.target_to_node = {} # bazel target -> Node for that target
         self.target_to_dependencies = {} # bazel_target -> target's deps
 
-        self.pomgens = [] # all pomgen instances
+        self.genctxs = [] # ArtifactGenerationContext instances
         self.leafnodes = [] # all leafnodes discovered while crawling
 
     def crawl(self, packages, follow_references=True, force_release=False):
@@ -149,14 +148,14 @@ def crawl(self, packages, follow_references=True, force_release=False):
         target_to_transitive_closure_deps = self._compute_transitive_closures_of_deps()
 
 
-        # augment pom generators with deps discovered while crawling
-        self._register_dependencies_with_pomgen_instances(target_to_transitive_closure_deps)
+        # add discovered deps to artifact generation contexts
+        self._register_dependencies(target_to_transitive_closure_deps)
 
 
-        # for each artifact, if its pom changed since the last release
-        # (tracked by pom.xml.released), mark the artifact is requiring to be
-        # released
-        self._check_for_pom_changes()
+        # for each artifact, if its manifest (for ex pom.xml) has changed since
+        # the last release (tracked by pom.xml.released), mark the artifact as
+        # requiring to be released
+        self._check_for_artifact_manifest_changes()
 
 
         # figure out whether artifacts need to be released because a transitive
@@ -164,44 +163,34 @@ def crawl(self, packages, follow_references=True, force_release=False):
         self._calculate_artifact_release_flag(force_release)
 
 
-        # only pomgen instances for artifacts that need to be released are
+        # include only contexts for artifacts that need to be released
         # included in the result
-        result_pomgens = []
-        for p in self.pomgens:
-            if p.artifact_def.requires_release:
-                result_pomgens.append(p)
+        ctxs = [ctx for ctx in self.genctxs if ctx.artifact_def.requires_release]
 
         crawled_bazel_packages = self._get_crawled_packages_as_deps()
 
-        return CrawlerResult(result_pomgens, nodes, crawled_bazel_packages)
+        return CrawlerResult(ctxs, nodes, crawled_bazel_packages)
 
-    def _register_dependencies_with_pomgen_instances(self, target_to_transitive_closure_deps):
+    def _register_dependencies(self, target_to_transitive_closure_deps):
         """
-        This method sets various dependency lists on all pomgen instances:
+        This method sets dependency lists on generaton contexts:
 
-        - the direct dependencies that typically go into the generated pom
+        - the direct dependencies of the artifact
         - the transitive closure of the direct dependenices
         - the transitive closure of the library's dependencies
         """
-        # register the direct dependencies
-        for p in self.pomgens:
-            target_key = self._get_target_key(p.bazel_package, p.dependency)
-            dependencies = self.target_to_dependencies[target_key]
-            p.register_dependencies(dependencies)
-
-        # register the transitive closure of dependencies belonging to the
-        # artifact
-        for p in self.pomgens:
-
-            target_key = self._get_target_key(p.artifact_def.bazel_package, p.dependency)
-            art_deps = target_to_transitive_closure_deps[target_key]
-            p.register_dependencies_transitive_closure__artifact(art_deps)
-
-        # register the transitive closure of dependencies belonging to the
-        # library
-        for p in self.pomgens:
-            lib_deps = self._get_deps_transitive_closure_for_library(p.artifact_def.library_path, target_to_transitive_closure_deps)
-            p.register_dependencies_transitive_closure__library(lib_deps)
+        for ctx in self.genctxs:
+            target_key = self._get_target_key(
+                ctx.artifact_def.bazel_package, ctx.dependency)
+            directs = self.target_to_dependencies[target_key]
+            ctx.register_artifact_directs(directs)
+            transitive_closure = target_to_transitive_closure_deps[target_key]
+            ctx.register_artifact_transitive_closure(transitive_closure)
+            lib_transitive_closure = self\
+                ._get_deps_transitive_closure_for_library(
+                    ctx.artifact_def.library_path,
+                    target_to_transitive_closure_deps)
+            ctx.register_library_transitive_closure(lib_transitive_closure)
 
     def _get_deps_transitive_closure_for_library(self, library_path,
                                                  target_to_transitive_closure_deps):
@@ -245,31 +234,33 @@ def _get_unprocessed_packages(self):
                 missing_packages += all_library_packages.difference(all_packages_already_processed)
         return missing_packages
 
-    def _check_for_pom_changes(self):
+    def _check_for_artifact_manifest_changes(self):
         """
         For each artifact def not flagged as needing to be released, check 
-        whether its current pom is different than the previously released pom.
-        If the pom has changed, mark the artifact def as needing to be released.
+        whether its current manifest (for ex pom.xml) is different the
+        previously released manifest. If it has changed, mark the artifact def
+        as needing to be released.
         """
-
-        for pomgen in self.pomgens:
-            art_def = pomgen.artifact_def
+        for ctx in self.genctxs:
+            art_def = ctx.artifact_def
             if not art_def.requires_release and art_def.released_pom_content is not None:
-                current_pom = pomparser.format_for_comparison(pomgen.gen(pom.PomContentType.GOLDFILE))
-                previous_pom = pomparser.format_for_comparison(art_def.released_pom_content)
-                pom_changed = current_pom != previous_pom
-                if pom_changed:
+                # TODO pomparser
+                current_manifest = pomparser.format_for_comparison(ctx.gen_goldfile_manifest())
+                previous_manifest = pomparser.format_for_comparison(art_def.released_pom_content)
+                manifest_changed = current_manifest != previous_manifest
+                if manifest_changed:
                     art_def.requires_release = True
+                    # TODO release reason
                     art_def.release_reason = ReleaseReason.POM
 
                     if self.verbose:
                         logger.debug("pom diff %s %s" % (art_def, art_def.bazel_package))
-                        diff = difflib.unified_diff(previous_pom.splitlines(True), current_pom.splitlines(True))
+                        diff = difflib.unified_diff(previous_manifest.splitlines(True), current_manifest.splitlines(True))
                         logger.raw(''.join(diff))
-                        logger.debug("%s computed pom:" % art_def)
-                        logger.raw(current_pom)
-                        logger.debug("%s released pom:" % art_def)
-                        logger.raw(previous_pom)
+                        logger.debug("%s computed manifest:" % art_def)
+                        logger.raw(current_manifest)
+                        logger.debug("%s released manifest:" % art_def)
+                        logger.raw(previous_manifest)
 
 
     def _compute_transitive_closures_of_deps(self):
@@ -539,9 +530,9 @@ def _crawl(self, package, dep, parent_node, follow_references):
                 # this is a bootstrapping problem: the root
                 # artifacts (that we start with) have nothing pointing at them
                 dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
-            pomgen = pom.get_pom_generator(self.workspace, self.pom_template,
-                                           artifact_def, dep)
-            self.pomgens.append(pomgen)
+            artifactctx = artifactgenctx.ArtifactGenerationContext(
+                self.workspace, self.pom_template, artifact_def, dep)
+            self.genctxs.append(artifactctx)
             source_deps, ext_deps, all_deps = self._discover_dependencies(artifact_def, dep)
             self.target_to_dependencies[target_key] = all_deps
             if self.verbose:
@@ -549,7 +540,7 @@ def _crawl(self, package, dep, parent_node, follow_references):
                 logger.debug("Source deps: %s" % "\n".join([str(d) for d in source_deps]))
                 logger.debug("Ext deps: %s" % "\n".join([str(d) for d in ext_deps]))
                 logger.debug("All deps: %s" % "\n".join([str(d) for d in all_deps]))
-            node = Node(parent_node, artifact_def, pomgen.dependency)
+            node = Node(parent_node, artifact_def, dep)
             if follow_references:
                 # crawl BUILD file dependencies
                 for source_dep in source_deps:
diff --git a/src/crawl/pom.py b/src/crawl/pom.py
index 716a42b..b0eccae 100644
--- a/src/crawl/pom.py
+++ b/src/crawl/pom.py
@@ -344,7 +344,7 @@ def _get_version_properties(self, pomcontenttype):
                 del key_to_version[key]
             version_from_dep = self._dep_version(pomcontenttype, dep)
             if not version_ref_must_be_fq:
-                # the key (groupId:artficatId:version) is not fully qualified,
+                # the key (groupId:artifactId:version) is not fully qualified,
                 # only the name prefixed with the maven_install rule name is
                 key_to_version[key] = version_from_dep
             key_to_dep[key] = dep
@@ -578,7 +578,7 @@ def gen(self, pomcontenttype):
         content = self.pom_template.replace("#{group_id}", self._artifact_def.group_id)
         # by convention, we add the suffix ".depmanagement" to the artifactId
         # so com.blah is the real jar artifact and com.blah.depmanagement
-        # is the dependency management pom for that artficat
+        # is the dependency management pom for that artifact
         content = content.replace("#{artifact_id}", "%s.depmanagement" % self._artifact_def.artifact_id)
         version = self._artifact_def_version(pomcontenttype)
         content = content.replace("#{version}", version)
diff --git a/src/pomgen.py b/src/pomgen.py
index 735f8f8..08ab3db 100755
--- a/src/pomgen.py
+++ b/src/pomgen.py
@@ -54,7 +54,7 @@ def main(args):
     crawler = crawlerm.Crawler(ws, cfg.pom_template, args.verbose)
     result = crawler.crawl(packages, follow_references=not args.ignore_references, force_release=args.force)
 
-    if len(result.pomgens) == 0:
+    if len(result.artifact_generation_contexts) == 0:
         logger.info("No releases are required. pomgen will not generate any pom files. To force pom generation, use pomgen's --force option.")
     else:
         output_dir = _get_output_dir(args)
@@ -71,7 +71,10 @@ def main(args):
                     path = lib_paths[0]
                     _write_all_libraries_hint_files(result, output_dir, path)
 
-        for pomgen in result.pomgens:
+        # hardcoded to pom.xml files right here, but in the future pluggable?
+        pomgens = [ctx.generator for ctx in result.artifact_generation_contexts]
+
+        for pomgen in pomgens:
             pom_dest_dir = os.path.join(output_dir, pomgen.bazel_package)
             if not os.path.exists(pom_dest_dir):
                 os.makedirs(pom_dest_dir)
diff --git a/tests/crawlertest.py b/tests/crawlertest.py
index 0574de9..f39e910 100644
--- a/tests/crawlertest.py
+++ b/tests/crawlertest.py
@@ -146,7 +146,7 @@ def test_no_lib_changed(self):
         """
         result = self.crawler.crawl(["libs/a/a1"])
 
-        self.assertEqual(0, len(result.pomgens))
+        self.assertEqual(0, len(result.artifact_generation_contexts))
 
     def test_no_lib_changed__force_release(self):
         """
@@ -155,10 +155,10 @@ def test_no_lib_changed__force_release(self):
         """
         result = self.crawler.crawl(["libs/a/a1"], force_release=True)
 
-        self.assertEqual(6, len(result.pomgens))
-        for p in result.pomgens:
+        self.assertEqual(6, len(result.artifact_generation_contexts))
+        for ctx in result.artifact_generation_contexts:
             self.assertEqual(rr.ReleaseReason.ALWAYS,
-                p.artifact_def.release_reason)
+                ctx.artifact_def.release_reason)
 
     def test_all_libs_changed(self):
         """
@@ -171,10 +171,10 @@ def test_all_libs_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         all = set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2", "libs/c/a1", "libs/c/a2"])
-        self.assertEqual(all, set([p.artifact_def.bazel_package for p in result.pomgens]))
-        for p in result.pomgens:
+        self.assertEqual(all, set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
+        for ctx in result.artifact_generation_contexts:
             self.assertEqual(rr.ReleaseReason.ARTIFACT,
-                p.artifact_def.release_reason)
+                ctx.artifact_def.release_reason)
 
     def test_all_libs_changed__force_release(self):
         """
@@ -187,10 +187,10 @@ def test_all_libs_changed__force_release(self):
         result = self.crawler.crawl(["libs/a/a1"], force_release=True)
 
         all = set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2", "libs/c/a1", "libs/c/a2"])
-        self.assertEqual(all, set([p.artifact_def.bazel_package for p in result.pomgens]))
-        for p in result.pomgens:
+        self.assertEqual(all, set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
+        for ctx in result.artifact_generation_contexts:
             self.assertEqual(rr.ReleaseReason.ALWAYS,
-                p.artifact_def.release_reason)
+                ctx.artifact_def.release_reason)
 
     def test_all_libs_changed__dont_follow_refs(self):
         """
@@ -202,7 +202,7 @@ def test_all_libs_changed__dont_follow_refs(self):
         result = self.crawler.crawl(["libs/a/a1"], follow_references=False)
 
         self.assertEqual(set(["libs/a/a1"]),
-                         set([p.artifact_def.bazel_package for p in result.pomgens]))
+                         set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
 
     def test_register_dependencies(self):
         """
@@ -258,7 +258,7 @@ def test_version_references_in_pom_template(self):
 
         result = self.crawler.crawl(["libs/a/a1"])
 
-        pom = result.pomgens[0].gen(pomm.PomContentType.RELEASE)
+        pom = result.artifact_generation_contexts[0].generator.gen(pomm.PomContentType.RELEASE)
         
         self.assertIn("<version>0.0.2</version>", pom)
         self.assertIn("<version>0.0.3</version>", pom)
@@ -273,7 +273,7 @@ def test_A_a1_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2"]),
-                          set([p.artifact_def.bazel_package for p in result.pomgens]))
+                          set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.ARTIFACT)
         a_a2 = self._get_node_by_bazel_package(result.nodes, "libs/a/a2")
@@ -303,7 +303,7 @@ def test_A_a2_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2"]),
-                          set([p.artifact_def.bazel_package for p in result.pomgens]))
+                          set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.ARTIFACT)
         a_a2 = self._get_node_by_bazel_package(result.nodes, "libs/a/a2")
@@ -333,7 +333,7 @@ def test_B_a1_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2"]),
-                         set([p.artifact_def.bazel_package for p in result.pomgens]))
+                         set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
 
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.TRANSITIVE)
@@ -364,7 +364,7 @@ def test_B_a2_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2"]),
-                         set([p.artifact_def.bazel_package for p in result.pomgens]))
+                         set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
 
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.TRANSITIVE)
@@ -395,7 +395,7 @@ def test_C_a1_changed(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2", "libs/c/a1", "libs/c/a2"]),
-                         set([p.artifact_def.bazel_package for p in result.pomgens]))
+                         set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
 
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.TRANSITIVE)
@@ -426,7 +426,7 @@ def test_C_a2_changed(self):
         result = self.crawler.crawl(["libs/a/a2"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2", "libs/c/a1", "libs/c/a2"]),
-                         set([p.artifact_def.bazel_package for p in result.pomgens]))
+                         set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
 
         a_a1 = self._get_node_by_bazel_package(result.nodes, "libs/a/a1")
         self.assertIs(a_a1.artifact_def.release_reason, rr.ReleaseReason.TRANSITIVE)
@@ -461,7 +461,7 @@ def test_released_pom_exists_without_changes(self):
 
         result = self.crawler.crawl(["libs/a/a1"])
 
-        self.assertEqual(0, len(result.pomgens))
+        self.assertEqual(0, len(result.artifact_generation_contexts))
         
     def test_one_lib_changed__lib_b__pom_changes_only(self):
         """
@@ -479,7 +479,7 @@ def test_one_lib_changed__lib_b__pom_changes_only(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         self.assertEqual(set(["libs/a/a1", "libs/a/a2", "libs/b/a1", "libs/b/a2"]),
-                          set([p.artifact_def.bazel_package for p in result.pomgens]))
+                          set([ctx.artifact_def.bazel_package for ctx in result.artifact_generation_contexts]))
         node_a_a1 = result.nodes[0]
         self.assertIs(node_a_a1.artifact_def.release_reason, rr.ReleaseReason.TRANSITIVE)
         node_b_a1 = node_a_a1.children[0]
@@ -499,23 +499,23 @@ def test_pomgen_dependencies_state(self):
         result = self.crawler.crawl(["libs/a/a1"])
 
         # LIB A A1
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/a/a1"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/a/a1"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(2, len(dependency_paths))
         self.assertIn("libs/b/a1", dependency_paths)
         self.assertIn("libs/c/a1", dependency_paths)
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(3, len(dependency_paths))
         self.assertIn("libs/b/a1", dependency_paths)
         self.assertIn("libs/c/a1", dependency_paths)
         self.assertIn("libs/d/a1", dependency_paths)
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(5, len(dependency_paths))
         self.assertIn("libs/a/a1", dependency_paths) # own artifact included
         self.assertIn("libs/a/a2", dependency_paths) # own artifact included
@@ -524,18 +524,18 @@ def test_pomgen_dependencies_state(self):
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB A A2
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/a/a2"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/a/a2"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(5, len(dependency_paths))
         self.assertIn("libs/a/a1", dependency_paths) # own artifact included
         self.assertIn("libs/a/a2", dependency_paths) # own artifact included
@@ -544,21 +544,21 @@ def test_pomgen_dependencies_state(self):
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB B A1
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/b/a1"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/b/a1"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(1, len(dependency_paths))
         self.assertIn("libs/c/a1", dependency_paths)
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(2, len(dependency_paths))
         self.assertIn("libs/c/a1", dependency_paths)
         self.assertIn("libs/d/a1", dependency_paths)
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(4, len(dependency_paths))
         self.assertIn("libs/b/a1", dependency_paths) # own artifact included
         self.assertIn("libs/b/a2", dependency_paths) # own artifact included
@@ -566,18 +566,18 @@ def test_pomgen_dependencies_state(self):
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB B A2
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/b/a2"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/b/a2"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(4, len(dependency_paths))
         self.assertIn("libs/b/a1", dependency_paths) # own artifact included
         self.assertIn("libs/b/a2", dependency_paths) # own artifact included
@@ -585,73 +585,73 @@ def test_pomgen_dependencies_state(self):
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB C A1
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/c/a1"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/c/a1"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(1, len(dependency_paths))
         self.assertIn("libs/d/a1", dependency_paths)
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(1, len(dependency_paths))
         self.assertIn("libs/d/a1", dependency_paths)
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(3, len(dependency_paths))
         self.assertIn("libs/c/a1", dependency_paths) # own artifact included
         self.assertIn("libs/c/a2", dependency_paths) # own artifact included
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB C A2
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/c/a2"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/c/a2"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(3, len(dependency_paths))
         self.assertIn("libs/c/a1", dependency_paths) # own artifact included
         self.assertIn("libs/c/a2", dependency_paths) # own artifact included
         self.assertIn("libs/d/a1", dependency_paths)
 
         # LIB D A1
-        pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/d/a1"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/d/a1"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(2, len(dependency_paths))
         self.assertIn("libs/d/a1", dependency_paths) # own artifact included
         self.assertIn("libs/d/a2", dependency_paths) # own artifact included
 
         # LIB D A2
-        _pomgen = [p for p in result.pomgens if p.artifact_def.bazel_package == "libs/d/a2"][0]
+        ctx = [ctx for ctx in result.artifact_generation_contexts if ctx.artifact_def.bazel_package == "libs/d/a2"][0]
 
         # direct dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies]
+        dependency_paths = [d.bazel_package for d in ctx.direct_dependencies]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of artifact dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_artifact_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.artifact_transitive_closure]
         self.assertEqual(0, len(dependency_paths))
 
         # transitive closure of library dependencies
-        dependency_paths = [d.bazel_package for d in pomgen.dependencies_library_transitive_closure]
+        dependency_paths = [d.bazel_package for d in ctx.library_transitive_closure]
         self.assertEqual(2, len(dependency_paths))
         self.assertIn("libs/d/a1", dependency_paths) # own artifact included
         self.assertIn("libs/d/a2", dependency_paths) # own artifact included