diff --git a/packages/rules_prerender/prerender_component2.bzl b/packages/rules_prerender/prerender_component2.bzl
new file mode 100644
index 00000000..f2433f11
--- /dev/null
+++ b/packages/rules_prerender/prerender_component2.bzl
@@ -0,0 +1,268 @@
+"""Defines `prerender_component()` functionality."""
+
+load("@aspect_rules_js//js:defs.bzl", "js_library")
+load("@aspect_rules_js//js:providers.bzl", "JsInfo", "js_info")
+load("@aspect_rules_ts//ts:defs.bzl", "ts_project")
+load("//common:label.bzl", "absolute")
+load("//common:paths.bzl", "is_js_file", "is_ts_file", "is_ts_declaration_file")
+load("//packages/rules_prerender/css:css_binaries.bzl", "css_binaries")
+load("//packages/rules_prerender/css:css_group.bzl", "css_group")
+load("//packages/rules_prerender/css:css_library.bzl", "css_library")
+load(
+    ":prerender_metadata.bzl",
+    "PrerenderMetadataInfo",
+    "alias_with_metadata",
+    "prerender_metadata",
+)
+load(":web_resources.bzl", "web_resources")
+
+visibility("public")
+
+def prerender_component(
+    name,
+    prerender,
+    scripts = None,
+    styles = None,
+    resources = None,
+    testonly = None,
+    visibility = None,
+):
+    """Encapsulates an HTML/JS/CSS component for use in prerendering a web page.
+
+    This rule encapsulates the HTML, JavaScript, CSS, and static resources used
+    by a logical "component". A "component" is effectively a prerendered
+    fragment of HTML which provides some functionality (via JavaScript) and
+    styling (via CSS) with any required static files (ex. an image) at a
+    specific path (ex. /my-logo.png). Components are reusable pieces of UI which
+    can be composed together to build a complex static site.
+
+    IMPORTANT: `prerender_component()` has some special rules about _how_ it can
+    be used. It doesn't inherently _do_ anything special. It only collects all
+    the various parts of a component (HTML, scripts, styles, resources) with
+    some extra metadata for the bundling process and re-exports them at
+    `%{name}_prerender`, `%{name}_scripts`, `%{name}_styles`, and
+    `%{name}_resources`.
+    
+    A `prerender_component()` should _not_ be depended upon directly, instead
+    you should depend on the re-exports for the specific parts of the component
+    you need. The bundling process will bundle the entire component for you as
+    expected. For example:
+
+    ```BUILD
+    # my_component/BUILD.bazel
+
+    prerender_component(
+        name = "my_component",
+        prerender = ":prerender",
+    )
+
+    # IMPORTANT! No target except `:my_component` should depend on this. If they
+    # do, the generated site may be missing scripts, styles, resources, etc.
+    ts_project(
+        name = "prerender",
+        srcs = ["my_component_prerender.mts"],
+    )
+    ```
+
+    ```BUILD
+    # my_other_component/BUILD.bazel
+
+    prerender_component(
+        name = "my_other_component",
+        prerender = ":my_other_component_prerender_lib",
+
+        # No dependency on `//my_component/...` here.
+    )
+
+    ts_project(
+        name = "prerender",
+        srcs = ["my_other_component_prerender.mts"],
+
+        # IMPORTANT! Depend on the `_prerender` alias generated by
+        # `prerender_component()`. DON'T depend on `//my_component:prerender`
+        # directly.
+        deps = ["//my_component:my_component_prerender"],
+    )
+    ```
+
+    The rules here are:
+    1.  Any direct dependency of a `prerender_component()` target should _only_
+        be used by that `prerender_component()`.
+    2.  Any additional desired dependencies, should go through the relevant
+        `_prerender`, `_scripts`, `_styles`, `_resources` re-export generated by
+        the `prerender_component()` macro.
+        *   Exception: Unit tests may directly depend on targets provided they
+            do not use any `prerender_*` rules in the test.
+    3.  Never depend on a `prerender_component()` directly, always depend on the
+        specific re-export you want.
+        *   Exception: You may `bazel build` a `prerender_component()` target or
+            have a `build_test()` depend on it to verify that it is buildable.
+    
+    Args:
+        name: The name of this rule.
+        prerender: Required. A `ts_project()` target which acts as a library for
+            prerendering at build time.
+        scripts: A `ts_project()` holding client-side scripts for this
+            component.
+        styles: A `css_library()` holding the styles for this component.
+        resources: A `web_resources()` target holding other static files needed
+            by this component at runtime.
+        testonly: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+        visibility: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+    
+    Outputs:
+        %{name}: A library which verifies that all the different aspects of the
+                 component are buildable and runs various sanity checks.
+        %{name}_prerender: A reexport of the `prerender` attribute.
+        %{name}_scripts: A reexport of the `scripts` attribute.
+        %{name}_styles: A reexport of the `styles` attribute.
+        %{name}_resources: A reexport of the `resources` attribute.
+    """
+    styles_reexport = "%s_styles_reexport" % name
+    if styles:
+        _inline_css_reexport(
+            name = styles_reexport,
+            styles = styles,
+            visibility = visibility,
+            testonly = testonly,
+        )
+
+    # Metadata provider.
+    metadata = "%s_metadata" % name
+    prerender_metadata(
+        name = metadata,
+        prerender = prerender,
+        scripts = scripts,
+        styles = ":%s" % styles_reexport if styles else None,
+        styles_import_map = ":%s" % styles_reexport if styles else None,
+        resources = resources,
+        testonly = testonly,
+    )
+
+    # Prerendering JavaScript.
+    alias_with_metadata(
+        name = "%s_prerender" % name,
+        metadata = ":%s" % metadata,
+        actual = prerender,
+        visibility = visibility,
+        testonly = testonly,
+    )
+
+    # Client-side JavaScript.
+    scripts_target = "%s_scripts" % name
+    if scripts:
+        alias_with_metadata(
+            name = scripts_target,
+            metadata = ":%s" % metadata,
+            actual = scripts,
+            visibility = visibility,
+            testonly = testonly,
+        )
+    else:
+        js_library(
+            name = scripts_target,
+            srcs = [],
+            visibility = visibility,
+            testonly = testonly,
+        )
+
+    # CSS styles.
+    styles_target = "%s_styles" % name
+    if styles:
+        alias_with_metadata(
+            name = styles_target,
+            metadata = metadata,
+            actual = ":%s" % styles_reexport,
+            testonly = testonly,
+            visibility = visibility,
+        )
+
+    # Resources.
+    resources_target = "%s_resources" % name
+    if resources:
+        alias_with_metadata(
+            name = resources_target,
+            metadata = ":%s" % metadata,
+            actual = resources,
+            visibility = visibility,
+            testonly = testonly,
+        )
+
+def _js_reexport_impl(ctx):
+    merged_js_info = js_info(
+        declarations = depset([],
+            transitive = [src[JsInfo].declarations
+                          for src in ctx.attr.srcs],
+        ),
+        npm_linked_package_files = depset([],
+            transitive = [src[JsInfo].npm_linked_package_files
+                          for src in ctx.attr.srcs],
+        ),
+        npm_linked_packages = depset([],
+            transitive = [src[JsInfo].npm_linked_packages
+                          for src in ctx.attr.srcs],
+        ),
+        npm_package_store_deps = depset([],
+            transitive = [src[JsInfo].npm_package_store_deps
+                          for src in ctx.attr.srcs],
+        ),
+        sources = depset([],
+            transitive = [src[JsInfo].sources
+                          for src in ctx.attr.srcs],
+        ),
+        transitive_declarations = depset([],
+            transitive = [dep[JsInfo].transitive_declarations
+                          for dep in ctx.attr.srcs + ctx.attr.deps],
+        ),
+        transitive_npm_linked_package_files = depset([],
+            transitive = [dep[JsInfo].transitive_npm_linked_package_files
+                          for dep in ctx.attr.srcs + ctx.attr.deps],
+        ),
+        transitive_npm_linked_packages = depset([],
+            transitive = [dep[JsInfo].transitive_npm_linked_packages
+                          for dep in ctx.attr.srcs + ctx.attr.deps],
+        ),
+        transitive_sources = depset([],
+            transitive = [dep[JsInfo].transitive_sources
+                          for dep in ctx.attr.srcs + ctx.attr.deps],
+        ),
+    )
+
+    return [
+        DefaultInfo(files = merged_js_info.sources),
+        merged_js_info,
+    ]
+
+_js_reexport = rule(
+    implementation = _js_reexport_impl,
+    attrs = {
+        "srcs": attr.label_list(
+            default = [],
+            providers = [JsInfo],
+        ),
+        "deps": attr.label_list(
+            default = [],
+            providers = [JsInfo],
+        ),
+    },
+    doc = """
+        Re-exports the given `ts_project()` and `js_library()` targets. Targets
+        in `srcs` have their direct sources re-exported as the direct sources of
+        this target, while targets in `deps` are only included as transitive
+        sources.
+
+        This rule serves two purposes:
+        1.  It re-exports **both** `ts_project()` and `js_library()`.
+        2.  It merges multiple targets together, depending on all of them but
+            only re-exporting direct sources from the `srcs` attribute. Even
+            with `ts_project()` re-export it is not possible to re-export only
+            some of the given targets.
+    """,
+)
+
+def _inline_css_reexport(name, styles, testonly = None, visibility = None):
+    css_binaries(
+        name = name,
+        testonly = testonly,
+        deps = [styles],
+    )
diff --git a/packages/rules_prerender/prerender_metadata.bzl b/packages/rules_prerender/prerender_metadata.bzl
new file mode 100644
index 00000000..5a78df01
--- /dev/null
+++ b/packages/rules_prerender/prerender_metadata.bzl
@@ -0,0 +1,92 @@
+load("@aspect_rules_js//js:providers.bzl", "JsInfo")
+load(
+    "//packages/rules_prerender/css:css_providers.bzl",
+    "CssInfo",
+    "CssImportMapInfo",
+)
+load("//packages/rules_prerender:web_resources.bzl", "WebResourceInfo")
+
+PrerenderMetadataInfo = provider(
+    "Holds all the providers for each component \"slice\".",
+    fields = {
+        "prerender": "The JSInfo of the prerender target.",
+        "scripts": "The JSInfo of the scripts target.",
+        "styles": "The CssInfo of the styles target.",
+        "styles_import_map": "The CssImportMapInfo of the styles target.",
+        "resources": "The WebResourceInfo of the resources target.",
+    },
+)
+
+def _prerender_metadata_impl(ctx):
+    return PrerenderMetadataInfo(
+        prerender = _safe_get(ctx.attr.prerender, JsInfo),
+        scripts = _safe_get(ctx.attr.scripts, JsInfo),
+        styles = _safe_get(ctx.attr.styles, CssInfo),
+        styles_import_map = _safe_get(ctx.attr.styles_import_map, CssImportMapInfo),
+        resources = _safe_get(ctx.attr.resources, WebResourceInfo),
+    )
+
+prerender_metadata = rule(
+    implementation = _prerender_metadata_impl,
+    attrs = {
+        "prerender": attr.label(
+            mandatory = True,
+            providers = [JsInfo],
+        ),
+        "scripts": attr.label(providers = [JsInfo]),
+        "styles": attr.label(providers = [CssInfo]),
+        "styles_import_map": attr.label(providers = [CssImportMapInfo]),
+        "resources": attr.label(providers = [WebResourceInfo]),
+    },
+    doc = """
+        Collects all the various "slices" of a component together into a single
+        target and returns a `PrerenderMetadataInfo` linking to all their
+        providers.
+    """,
+)
+
+def _alias_with_metadata_impl(ctx):
+    # Re-export the metadata provider.
+    providers = [ctx.attr.metadata[PrerenderMetadataInfo]]
+
+    # Re-export all additional known providers from the actual target.
+    providers.extend(_safe_get_all(ctx.attr.actual, [
+        DefaultInfo,
+        JsInfo,
+        CssInfo,
+        CssImportMapInfo,
+        WebResourceInfo,
+    ]))
+
+    return providers
+
+alias_with_metadata = rule(
+    implementation = _alias_with_metadata_impl,
+    attrs = {
+        "metadata": attr.label(
+            mandatory = True,
+            providers = [PrerenderMetadataInfo],
+        ),
+        "actual": attr.label(
+            mandatory = True,
+        ),
+    },
+    doc = """
+        Creates an alias to the given `actual` target additionally providing the
+        `PrerenderMetadataInfo` from the `metadata` target.
+    """,
+)
+
+def _safe_get(target, provider):
+    if target and provider in target: return target[provider]
+
+    return None
+
+def _safe_get_all(target, providers):
+    output = []
+
+    for provider in providers:
+        if provider in target:
+            output.append(target[provider])
+
+    return output
diff --git a/packages/rules_prerender/prerender_pages2.bzl b/packages/rules_prerender/prerender_pages2.bzl
new file mode 100644
index 00000000..43482fdf
--- /dev/null
+++ b/packages/rules_prerender/prerender_pages2.bzl
@@ -0,0 +1,133 @@
+"""Defines `prerender_pages()` functionality."""
+
+load(":multi_inject_resources.bzl", "multi_inject_resources")
+load(":prerender_pages_unbundled2.bzl", "prerender_pages_unbundled")
+load(":scripts_bundle.bzl", "scripts_bundle")
+load(":web_resources.bzl", "web_resources")
+
+visibility("public")
+
+def prerender_pages(
+    name,
+    entry_point,
+    prerender,
+    scripts = None,
+    styles = None,
+    resources = None,
+    bundle_js = True,
+    testonly = None,
+    visibility = None,
+    debug_target = None,
+):
+    """Renders multiple resources at build time and bundles client-side content.
+
+    This provides a higher-level implementation of `prerender_pages_unbundled`,
+    automatically bundling client-side resources.
+
+    This invokes the default export function of the given `entry_point` and
+    generates a directory of files with the result.
+
+    The file listed in `entry_point` must compile to an ESM module with a
+    default export of the type:
+    
+    ```
+    () => Iterable<PrerenderResource> | Promise<Iterable<PrerenderResource>>
+        | AsyncIterable<PrerenderResource>
+    ```
+
+    Note: You may want to write this using the `Generator` or `AsyncGenerator`
+    types, as they are allowed subtypes and will enable TypeScript to catch some
+    foot-guns with `return` and `yield` that come with generators.
+
+    ```typescript
+    export default function*(): Generator<PrerenderResource, void, void> {
+        // ...
+    }
+
+    // OR
+
+    export default async function*():
+            AsyncGenerator<PrerenderResource, void, void> {
+        // ...
+    }
+    ```
+
+    Any scripts on each page that are included with `includeScript()` are
+    bundled together into a single JavaScript file and inserted into that page
+    as a `<script />` tag.
+
+    Any styles that are included with `inlineStyle()` are inlined as a
+    `<style />` tag at the inserted location in the document.
+    
+    Outputs:
+        %{name}: A `web_resources()`-compatible rule which includes all the
+            prerendered files, with all HTML files injected with `<script />`
+            and `<style />` tags, each with a JavaScript file including all
+            transitive sources bundled together, and all transitive resources
+            included. CSS is inlined directly in the HTML documents in a
+            `<style />` tag. Non-HTML files are included as well, but not
+            modified in the bundling process.
+    
+    Args:
+        name: The name of this rule.
+        entry_point: The JavaScript file to invoke as the entry point of the
+            binary.
+        prerender: Passed through to `prerender_pages_unbundled()`.
+        scripts: Passed through to `prerender_pages_unbundled()`.
+        styles: Passed through to `prerender_pages_unbundled()`.
+        resources: Passed through to `prerender_pages_unbundled()`.
+        bundle_js: Whether or not to bundle and inject JavaScript files.
+            Defaults to `True`.
+        testonly: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+        visibility: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+        debug_target: The label to check
+            `@rules_prerender//tools/flags:debug_prerender` for. If the flag is
+            set to this label, then the renderer binary with open a debugger for
+            local debugging. Defaults to this target's label. Useful for
+            providing intuitive flag behavior in macros.
+    """
+    # Render the site and collect all the scripts/styles/resources together.
+    prerender_name = "%s_unbundled" % name
+    prerender_pages_unbundled(
+        name = prerender_name,
+        entry_point = entry_point,
+        prerender = prerender,
+        scripts = scripts,
+        styles = styles,
+        resources = resources,
+        testonly = testonly,
+        visibility = visibility,
+        debug_target = debug_target or "//%s:%s" % (native.package_name(), name),
+    )
+
+    bundle = "%s_bundle" % name
+    if bundle_js:
+        # Bundle all client-side scripts in a `TreeArtifact` at `%{name}_bundle`.
+        scripts_bundle(
+            name = bundle,
+            entry_points = ":%s_scripts_entries" % prerender_name,
+            testonly = testonly,
+            deps = [":%s_scripts" % prerender_name],
+        )
+
+    # Inject bundled JS and CSS into the HTML.
+    injected_dir = "%s_injected" % name
+    multi_inject_resources(
+        name = injected_dir,
+        input_dir = ":%s" % prerender_name,
+        bundles = ":%s" % bundle if bundle_js else None,
+        styles = ":%s_styles" % prerender_name,
+        testonly = testonly,
+    )
+
+    # Output a resources directory of the HTML, bundled JavaScript, and any
+    # resource dependencies.
+    web_resources(
+        name = name,
+        testonly = testonly,
+        visibility = visibility,
+        deps = [
+            ":%s" % injected_dir,
+            ":%s_resources" % prerender_name,
+        ],
+    )
diff --git a/packages/rules_prerender/prerender_pages_unbundled2.bzl b/packages/rules_prerender/prerender_pages_unbundled2.bzl
new file mode 100644
index 00000000..aa8926ad
--- /dev/null
+++ b/packages/rules_prerender/prerender_pages_unbundled2.bzl
@@ -0,0 +1,405 @@
+"""Defines `prerender_pages_unbundled()` functionality."""
+
+load("@aspect_rules_js//js:defs.bzl", "js_library")
+load("@aspect_rules_js//js:providers.bzl", "JsInfo", "js_info")
+load("//common:label.bzl", "absolute", "file_path_of", "rel_path")
+load("//common:paths.bzl", "js_output", "is_js_file")
+load("//packages/rules_prerender/css:css_group.bzl", "merge_import_maps")
+load("//packages/rules_prerender/css:css_providers.bzl", "CssImportMapInfo", "CssInfo")
+load(":prerender_component2.bzl", "prerender_component")
+load(":prerender_metadata.bzl", "PrerenderMetadataInfo")
+load(":prerender_resources.bzl", "prerender_resources_internal")
+load(":script_entry_points.bzl", "script_entry_points")
+load(":web_resources.bzl", "WebResourceInfo", "web_resources")
+
+visibility("public")
+
+def prerender_pages_unbundled(
+    name,
+    entry_point,
+    prerender,
+    scripts = None,
+    styles = None,
+    resources = None,
+    testonly = None,
+    visibility = None,
+    debug_target = None,
+):
+    """Renders a directory of resources at build time.
+
+    This invokes the default export function of the given `entry_point` and
+    generates a directory of files with the result.
+
+    The file listed in `entry_point` must compile to an ESM module with a
+    default export of the type:
+    
+    ```
+    () => Iterable<PrerenderResource> | Promise<Iterable<PrerenderResource>>
+        | AsyncIterable<PrerenderResource>
+    ```
+
+    Note: You may want to write this using the `Generator` or `AsyncGenerator`
+    types, as they are allowed subtypes and will enable TypeScript to catch some
+    foot-guns with `return` and `yield` that come with generators.
+
+    ```typescript
+    export default function*(): Generator<PrerenderResource, void, void> {
+        // ...
+    }
+
+    // OR
+
+    export default async function*():
+            AsyncGenerator<PrerenderResource, void, void> {
+        // ...
+    }
+    ```
+
+    Outputs:
+        %{name}: A `web_resources()` target containing all the generated files.
+        %{name}_scripts: A `js_library()` target containing all the client-side
+            scripts used by the page.
+        %{name}_scripts_entries: A `TreeArtifact` containing all the entry
+            points used for bundling laid out in the generated directory format.
+        %{name}_styles: A `css_library()` target re-exporting all the styles
+            used in any page.
+        %{name}_resources: A `web_resources()` target containing all the
+            transitively used resources.
+    
+    Args:
+        name: The name of this rule.
+        entry_point: The JavaScript file to invoke as the entry point of the
+            binary.
+        prerender: Passed through to `prerender_component()`.
+        scripts: Passed through to `prerender_component()`.
+        styles: Passed through to `prerender_component()`.
+        resources: Passed through to `prerender_component()`.
+        testonly: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+        visibility: See https://docs.bazel.build/versions/master/be/common-definitions.html.
+        debug_target: The label to check
+            `@rules_prerender//tools/flags:debug_prerender` for. If the flag is
+            set to this label, then the renderer binary with open a debugger for
+            local debugging. Defaults to this target's label. Useful for
+            providing intuitive flag behavior in macros.
+    """
+    # Generate a component of the user's code.
+    component = "%s_component" % name
+    prerender_component(
+        name = component,
+        prerender = prerender,
+        scripts = scripts,
+        styles = styles,
+        resources = resources,
+        testonly = testonly,
+    )
+    component_metadata = "%s_metadata" % component
+    component_prerender = "%s_prerender" % component
+
+    # Re-export transitive styles.
+    transitive_styles = "%s_styles" % name
+    _collect_transitive_styles(
+        name = transitive_styles,
+        metadata = component_metadata,
+        testonly = testonly,
+        visibility = visibility,
+    )
+
+    # Execute the runner to generate annotated resources.
+    annotated = "%s_annotated" % name
+    prerender_resources_internal(
+        name = annotated,
+        entry_point = entry_point,
+        styles = ":%s" % transitive_styles,
+        debug_target = debug_target or "//%s:%s" % (native.package_name(), name),
+        data = [":%s" % component_prerender],
+        testonly = testonly,
+    )
+
+    # Extract annotations and generate metadata from them.
+    metadata = "%s_metadata.json" % name
+    _multi_extract_annotations(
+        name = name,
+        annotated_dir = ":%s" % annotated,
+        output_metadata = ":%s" % metadata,
+        testonly = testonly,
+        visibility = visibility,
+    )
+
+    # Generate the entry points importing all included scripts for each page.
+    transitive_scripts = "%s_scripts" % name
+    script_entry_points(
+        name = "%s_entries" % transitive_scripts,
+        metadata = metadata,
+        testonly = testonly,
+        visibility = visibility,
+    )
+
+    # Reexport all included scripts at `%{name}_scripts`.
+    _collect_transitive_scripts(
+        name = transitive_scripts,
+        metadata = component_metadata,
+        testonly = testonly,
+        visibility = visibility,
+    )
+
+    # Reexport all transitive resources at `%{name}_resources`.
+    output_resources = "%s_resources" % name
+    _collect_transitive_resources(
+        name = output_resources,
+        metadata = component_metadata,
+        testonly = testonly,
+        visibility = visibility,
+    )
+
+_CollectedPrerenderMetadataInfo = provider(fields = {
+    "transitive_metadata": "`depset` of transitive `PrerenderMetadataInfo` providers.",
+})
+
+# Label attributes which may point at `PrerenderMetadataInfo` targets.
+_ASPECT_LABEL_ATTRS = [
+    # From `prerender_component()`.
+    "prerender",
+    "scripts",
+    "styles",
+    "resources",
+
+    # From `alias_with_metadata()`.
+    "actual",
+
+    # From `prerender_metadata()`.
+    "metadata",
+]
+
+# Label *list* attributes which may point at `PrerenderMetadataInfo` targets.
+_ASPECT_LABEL_LIST_ATTRS = ["deps"]
+
+def _collect_transitive_metadata_aspect_impl(target, ctx):
+    # Read `PrerenderMetadataInfo` off the current target if present.
+    metadata = target[PrerenderMetadataInfo] if PrerenderMetadataInfo in target else None
+
+    # Find all deps with known labels on the target.
+    label_attr_deps = [getattr(ctx.rule.attr, attr)
+                       for attr in _ASPECT_LABEL_ATTRS
+                       if getattr(ctx.rule.attr, attr, None) != None]
+    label_list_attr_deps = [dep
+                            for attr in _ASPECT_LABEL_LIST_ATTRS
+                            for dep in getattr(ctx.rule.attr, attr, [])]
+    deps = label_attr_deps + label_list_attr_deps
+
+    # Find all transitive `_CollectedPrerenderMetadataInfo`.
+    transitive_metadata = [dep[_CollectedPrerenderMetadataInfo].transitive_metadata
+                           for dep in deps
+                           if _CollectedPrerenderMetadataInfo in dep]
+
+    # Merge the metadata provided by this target with the
+    # `_CollectedPrerenderMetadataInfo` from all transitive dependencies.
+    return _CollectedPrerenderMetadataInfo(
+        transitive_metadata = depset(
+            direct = [metadata] if metadata else [],
+            transitive = transitive_metadata,
+        ),
+    )
+
+_collect_transitive_metadata_aspect = aspect(
+    implementation = _collect_transitive_metadata_aspect_impl,
+    attr_aspects = _ASPECT_LABEL_ATTRS + _ASPECT_LABEL_LIST_ATTRS,
+    doc = """
+        Collects all transitive `PrerenderMetadataInfo` providers which can be
+        reached and returns them in a `_CollectedPrerenderMetadataInfo`.
+    """,
+)
+
+def _collect_transitive_styles_impl(ctx):
+    transitive_metadata = ctx.attr.metadata[_CollectedPrerenderMetadataInfo].transitive_metadata.to_list()
+    transitive_styles = [metadata.styles.transitive_sources
+                         for metadata in transitive_metadata
+                         if metadata.styles]
+    transitive_import_maps = [metadata.styles_import_map
+                              for metadata in transitive_metadata
+                              if metadata.styles_import_map]
+
+    return [
+        DefaultInfo(files = depset(
+            direct = [],
+            transitive = transitive_styles,
+        )),
+        CssInfo(
+            direct_sources = [],
+            transitive_sources = depset(
+                direct = [],
+                transitive = transitive_styles,
+            ),
+        ),
+        CssImportMapInfo(
+            import_map = merge_import_maps(transitive_import_maps),
+        ),
+    ]
+
+_collect_transitive_styles = rule(
+    implementation = _collect_transitive_styles_impl,
+    attrs = {
+        "metadata": attr.label(
+            mandatory = True,
+            providers = [PrerenderMetadataInfo],
+            aspects = [_collect_transitive_metadata_aspect],
+        ),
+    },
+    doc = """
+        Collects all the styles used as transitive dependencies of this target.
+        Provides a `CssInfo` with all the CSS files and a `CssImportMapInfo`
+        with the full import map.
+    """,
+)
+
+def _collect_transitive_scripts_impl(ctx):
+    transitive_metadata = ctx.attr.metadata[_CollectedPrerenderMetadataInfo].transitive_metadata.to_list()
+    transitive_scripts = [metadata.scripts
+                         for metadata in transitive_metadata
+                         if metadata.scripts]
+
+    merged_js_info = js_info(
+        declarations = depset([],
+            transitive = [info.declarations
+                          for info in transitive_scripts],
+        ),
+        npm_linked_package_files = depset([],
+            transitive = [info.npm_linked_package_files
+                          for info in transitive_scripts],
+        ),
+        npm_linked_packages = depset([],
+            transitive = [info.npm_linked_packages
+                          for info in transitive_scripts],
+        ),
+        npm_package_store_deps = depset([],
+            transitive = [info.npm_package_store_deps
+                          for info in transitive_scripts],
+        ),
+        sources = depset([],
+            transitive = [info.sources
+                          for info in transitive_scripts],
+        ),
+        transitive_declarations = depset([],
+            transitive = [info.transitive_declarations
+                          for info in transitive_scripts],
+        ),
+        transitive_npm_linked_package_files = depset([],
+            transitive = [info.transitive_npm_linked_package_files
+                          for info in transitive_scripts],
+        ),
+        transitive_npm_linked_packages = depset([],
+            transitive = [info.transitive_npm_linked_packages
+                          for info in transitive_scripts],
+        ),
+        transitive_sources = depset([],
+            transitive = [info.transitive_sources
+                          for info in transitive_scripts],
+        ),
+    )
+
+    return merged_js_info
+
+_collect_transitive_scripts = rule(
+    implementation = _collect_transitive_scripts_impl,
+    attrs = {
+        "metadata": attr.label(
+            mandatory = True,
+            providers = [PrerenderMetadataInfo],
+            aspects = [_collect_transitive_metadata_aspect],
+        ),
+    },
+    doc = """
+        Collects all the scripts used as transitive dependencies of this target.
+        Provides a `JSInfo` with all the JS files.
+    """,
+)
+
+def _collect_transitive_resources_impl(ctx):
+    transitive_metadata = ctx.attr.metadata[_CollectedPrerenderMetadataInfo].transitive_metadata.to_list()
+    transitive_resources = [metadata.resources.transitive_entries
+                         for metadata in transitive_metadata
+                         if metadata.resources]
+
+    return WebResourceInfo(
+        transitive_entries = depset(
+            direct = [],
+            transitive = transitive_resources,
+        ),
+    )
+
+_collect_transitive_resources = rule(
+    implementation = _collect_transitive_resources_impl,
+    attrs = {
+        "metadata": attr.label(
+            mandatory = True,
+            providers = [PrerenderMetadataInfo],
+            aspects = [_collect_transitive_metadata_aspect],
+        ),
+    },
+    doc = """
+        Collects all the resources used as transitive dependencies of this
+        target. Provides a `WebResourceInfo` with all the resources.
+    """,
+)
+
+def _multi_extract_annotations_impl(ctx):
+    """Invokes the multi annotation extractor and returns the new directory.
+    
+    Returns a `DefaultInfo()` object containing a directory which holds all the
+    input files at their same relative location. Non-HTML files are copied over
+    unchanged, while HTML files have their annotations removed and extracted
+    into a separate metadata file.
+    """
+    output_dir = ctx.actions.declare_directory(ctx.attr.name)
+
+    args = ctx.actions.args()
+    args.add("--input-dir", ctx.file.annotated_dir.short_path)
+    args.add("--output-dir", output_dir.short_path)
+    args.add("--output-metadata", ctx.outputs.output_metadata.short_path)
+
+    ctx.actions.run(
+        mnemonic = "MultiAnnotationExtractor",
+        progress_message = "Extracting annotations from multiple pages",
+        executable = ctx.executable._extractor,
+        arguments = [args],
+        inputs = [ctx.file.annotated_dir],
+        outputs = [
+            output_dir,
+            ctx.outputs.output_metadata,
+        ],
+        env = {
+            "BAZEL_BINDIR": ctx.bin_dir.path,
+        },
+    )
+
+    return [
+        DefaultInfo(files = depset([output_dir])),
+        WebResourceInfo(transitive_entries = depset([output_dir])),
+    ]
+
+_multi_extract_annotations = rule(
+    implementation = _multi_extract_annotations_impl,
+    attrs = {
+        "annotated_dir": attr.label(
+            mandatory = True,
+            allow_single_file = True,
+            doc = """
+                A directory of annotated HTML pages to extract from. May also
+                contain non-HTML content which will be copied through to the
+                output.
+            """
+        ),
+        "output_metadata": attr.output(
+            mandatory = True,
+            doc = """
+                The file to write the output metadata JSON which is generated
+                from the annotations extracted from input HTML files.
+            """,
+        ),
+        "_extractor": attr.label(
+            default = "//tools/binaries/annotation_extractor",
+            executable = True,
+            cfg = "exec",
+        ),
+    },
+    doc = """Extracts annotations from HTML files in the provided directory.""",
+)