From b50ecb7e53727923ab9a9714b534aca93f68f70d Mon Sep 17 00:00:00 2001
From: Tobias Koppers <tobias.koppers@googlemail.com>
Date: Thu, 27 Apr 2023 07:54:53 +0200
Subject: [PATCH] add support for static implicit metadata in turbopack
 (#48823)

### What?

* support local static metadata files; opengraph-image, twitter-image,
favicon, manifest, icon, apple-icon
* support global static metadata files: robots.txt, sitemap.xml,
favicon.ico
* dynamic metadata is not yet implemented, but yields a warning

It's implemented a bit different compared to the webpack version.
All images will use the usual image machinery, so they are emitted to
output directory, content hashed and the url is shared with the same
import import in the app.

### Why?

Unsupported, and we want to have that.

### How?

see also https://github.com/vercel/turbo/pull/4692

fixes WEB-524
---
 .../next-swc/crates/napi/src/app_structure.rs | 139 +++++++----
 .../crates/next-core/src/app_source.rs        | 225 ++++++++++++++++--
 .../crates/next-core/src/app_structure.rs     | 198 +++++++++++++--
 .../crates/next-core/src/asset_helpers.rs     |  27 +++
 packages/next-swc/crates/next-core/src/lib.rs |   1 +
 .../crates/next-core/src/next_image/module.rs |  42 ++--
 .../next-swc/crates/next-core/src/router.rs   |  14 +-
 .../implicit-metadata/input/app/favicon.ico   | Bin 0 -> 15086 bytes
 .../implicit-metadata/input/app/icon1234.png  | Bin 880 -> 6230 bytes
 .../input/app/manifest.webmanifest            |   9 +
 .../input/app/opengraph-image.alt.txt         |   1 +
 .../input/app/opengraph-image.png             | Bin 0 -> 1661 bytes
 .../implicit-metadata/input/app/robots.txt    |   2 +
 .../implicit-metadata/input/app/sitemap.xml   |   7 +
 .../app/implicit-metadata/input/app/test.tsx  |  79 +++++-
 ...rom filesystem is currently not-9116b0.txt |  21 --
 16 files changed, 624 insertions(+), 141 deletions(-)
 create mode 100644 packages/next-swc/crates/next-core/src/asset_helpers.rs
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/favicon.ico
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/manifest.webmanifest
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.alt.txt
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.png
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/robots.txt
 create mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/sitemap.xml
 delete mode 100644 packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/issues/Implicit metadata from filesystem is currently not-9116b0.txt

diff --git a/packages/next-swc/crates/napi/src/app_structure.rs b/packages/next-swc/crates/napi/src/app_structure.rs
index 1a04522716f05..659f02288dd8b 100644
--- a/packages/next-swc/crates/napi/src/app_structure.rs
+++ b/packages/next-swc/crates/napi/src/app_structure.rs
@@ -8,7 +8,7 @@ use napi::{
 };
 use next_core::app_structure::{
     find_app_dir, get_entrypoints as get_entrypoints_impl, Components, ComponentsVc, Entrypoint,
-    EntrypointsVc, LoaderTree, LoaderTreeVc,
+    EntrypointsVc, LoaderTree, LoaderTreeVc, MetadataWithAltItem,
 };
 use serde::{Deserialize, Serialize};
 use turbo_binding::{
@@ -41,7 +41,8 @@ async fn project_fs(project_dir: &str, watching: bool) -> Result<FileSystemVc> {
 struct LoaderTreeForJs {
     segment: String,
     parallel_routes: HashMap<String, LoaderTreeForJsReadRef>,
-    components: serde_json::Value,
+    #[turbo_tasks(trace_ignore)]
+    components: ComponentsForJs,
 }
 
 #[derive(PartialEq, Eq, Serialize, Deserialize, ValueDebugFormat, TraceRawVcs)]
@@ -69,10 +70,57 @@ async fn fs_path_to_path(project_path: FileSystemPathVc, path: FileSystemPathVc)
     }
 }
 
+#[derive(Default, Deserialize, Serialize, PartialEq, Eq, ValueDebugFormat)]
+#[serde(rename_all = "camelCase")]
+struct ComponentsForJs {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    page: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    layout: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    loading: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    template: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    default: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    route: Option<String>,
+    metadata: MetadataForJs,
+}
+
+#[derive(Default, Deserialize, Serialize, PartialEq, Eq, ValueDebugFormat)]
+#[serde(rename_all = "camelCase")]
+struct MetadataForJs {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    icon: Vec<MetadataForJsItem>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    apple: Vec<MetadataForJsItem>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    twitter: Vec<MetadataForJsItem>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    open_graph: Vec<MetadataForJsItem>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    favicon: Vec<MetadataForJsItem>,
+}
+
+#[derive(Deserialize, Serialize, PartialEq, Eq, ValueDebugFormat)]
+#[serde(tag = "type", rename_all = "camelCase")]
+enum MetadataForJsItem {
+    Static {
+        path: String,
+        alt_path: Option<String>,
+    },
+    Dynamic {
+        path: String,
+    },
+}
+
 async fn prepare_components_for_js(
     project_path: FileSystemPathVc,
     components: ComponentsVc,
-) -> Result<serde_json::Value> {
+) -> Result<ComponentsForJs> {
     let Components {
         page,
         layout,
@@ -83,59 +131,66 @@ async fn prepare_components_for_js(
         route,
         metadata,
     } = &*components.await?;
-    let mut map = serde_json::value::Map::new();
+    let mut result = ComponentsForJs::default();
     async fn add(
-        map: &mut serde_json::value::Map<String, serde_json::Value>,
+        result: &mut Option<String>,
         project_path: FileSystemPathVc,
-        key: &str,
         value: &Option<FileSystemPathVc>,
     ) -> Result<()> {
         if let Some(value) = value {
-            map.insert(
-                key.to_string(),
-                fs_path_to_path(project_path, *value).await?.into(),
-            );
+            *result = Some(fs_path_to_path(project_path, *value).await?);
         }
         Ok::<_, anyhow::Error>(())
     }
-    add(&mut map, project_path, "page", page).await?;
-    add(&mut map, project_path, "layout", layout).await?;
-    add(&mut map, project_path, "error", error).await?;
-    add(&mut map, project_path, "loading", loading).await?;
-    add(&mut map, project_path, "template", template).await?;
-    add(&mut map, project_path, "default", default).await?;
-    add(&mut map, project_path, "route", route).await?;
-    let mut meta = serde_json::value::Map::new();
-    async fn add_meta(
-        meta: &mut serde_json::value::Map<String, serde_json::Value>,
+    add(&mut result.page, project_path, page).await?;
+    add(&mut result.layout, project_path, layout).await?;
+    add(&mut result.error, project_path, error).await?;
+    add(&mut result.loading, project_path, loading).await?;
+    add(&mut result.template, project_path, template).await?;
+    add(&mut result.default, project_path, default).await?;
+    add(&mut result.route, project_path, route).await?;
+    async fn add_meta<'a>(
+        meta: &mut Vec<MetadataForJsItem>,
         project_path: FileSystemPathVc,
-        key: &str,
-        value: &Vec<FileSystemPathVc>,
+        value: impl Iterator<Item = &'a MetadataWithAltItem>,
     ) -> Result<()> {
-        if !value.is_empty() {
-            meta.insert(
-                key.to_string(),
-                value
-                    .iter()
-                    .map(|value| async move {
-                        Ok(serde_json::Value::from(
-                            fs_path_to_path(project_path, *value).await?,
-                        ))
+        let mut value = value.peekable();
+        if value.peek().is_some() {
+            *meta = value
+                .map(|value| async move {
+                    Ok(match value {
+                        MetadataWithAltItem::Static { path, alt_path } => {
+                            let path = fs_path_to_path(project_path, *path).await?;
+                            let alt_path = if let Some(alt_path) = alt_path {
+                                Some(fs_path_to_path(project_path, *alt_path).await?)
+                            } else {
+                                None
+                            };
+                            MetadataForJsItem::Static { path, alt_path }
+                        }
+                        MetadataWithAltItem::Dynamic { path } => {
+                            let path = fs_path_to_path(project_path, *path).await?;
+                            MetadataForJsItem::Dynamic { path }
+                        }
                     })
-                    .try_join()
-                    .await?
-                    .into(),
-            );
+                })
+                .try_join()
+                .await?;
         }
         Ok::<_, anyhow::Error>(())
     }
-    add_meta(&mut meta, project_path, "icon", &metadata.icon).await?;
-    add_meta(&mut meta, project_path, "apple", &metadata.apple).await?;
-    add_meta(&mut meta, project_path, "twitter", &metadata.twitter).await?;
-    add_meta(&mut meta, project_path, "openGraph", &metadata.open_graph).await?;
-    add_meta(&mut meta, project_path, "favicon", &metadata.favicon).await?;
-    map.insert("metadata".to_string(), meta.into());
-    Ok(map.into())
+    let meta = &mut result.metadata;
+    add_meta(&mut meta.icon, project_path, metadata.icon.iter()).await?;
+    add_meta(&mut meta.apple, project_path, metadata.apple.iter()).await?;
+    add_meta(&mut meta.twitter, project_path, metadata.twitter.iter()).await?;
+    add_meta(
+        &mut meta.open_graph,
+        project_path,
+        metadata.open_graph.iter(),
+    )
+    .await?;
+    add_meta(&mut meta.favicon, project_path, metadata.favicon.iter()).await?;
+    Ok(result)
 }
 
 #[tasks::function]
diff --git a/packages/next-swc/crates/next-core/src/app_source.rs b/packages/next-swc/crates/next-core/src/app_source.rs
index 4eeb171f7d7b4..00c85d28c40ef 100644
--- a/packages/next-swc/crates/next-core/src/app_source.rs
+++ b/packages/next-swc/crates/next-core/src/app_source.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, io::Write};
+use std::{collections::HashMap, io::Write, iter::once};
 
 use anyhow::Result;
 use async_recursion::async_recursion;
@@ -30,6 +30,7 @@ use turbo_binding::{
         dev_server::{
             html::DevHtmlAssetVc,
             source::{
+                asset_graph::AssetGraphContentSourceVc,
                 combined::CombinedContentSource,
                 specificity::{Specificity, SpecificityElementType, SpecificityVc},
                 ContentSourceData, ContentSourceVc, NoContentSourceVc,
@@ -37,6 +38,7 @@ use turbo_binding::{
         },
         ecmascript::{
             magic_identifier,
+            text::TextContentSourceAssetVc,
             utils::{FormatIter, StringifyJs},
             EcmascriptInputTransformsVc, EcmascriptModuleAssetType, EcmascriptModuleAssetVc,
             InnerAssetsVc,
@@ -50,6 +52,7 @@ use turbo_binding::{
             },
             NodeEntry, NodeEntryVc, NodeRenderingEntry, NodeRenderingEntryVc,
         },
+        r#static::{fixed::FixedStaticAssetVc, StaticModuleAssetVc},
         turbopack::{
             ecmascript::EcmascriptInputTransform,
             transition::{TransitionVc, TransitionsByNameVc},
@@ -62,8 +65,10 @@ use turbo_tasks::{TryJoinIterExt, ValueToString};
 use crate::{
     app_render::next_layout_entry_transition::NextServerComponentTransition,
     app_structure::{
-        get_entrypoints, Components, Entrypoint, LoaderTree, LoaderTreeVc, Metadata, OptionAppDirVc,
+        get_entrypoints, get_global_metadata, Components, Entrypoint, GlobalMetadataVc, LoaderTree,
+        LoaderTreeVc, Metadata, MetadataItem, MetadataWithAltItem, OptionAppDirVc,
     },
+    asset_helpers::as_es_module_asset,
     embed_js::{next_js_file, next_js_file_path},
     env::env_for_js,
     fallback::get_fallback_page,
@@ -85,6 +90,7 @@ use crate::{
         context::{get_edge_compile_time_info, get_edge_resolve_options_context},
         transition::NextEdgeTransition,
     },
+    next_image::module::StructuredImageModuleType,
     next_route_matcher::NextParamsMatcherVc,
     next_server::context::{
         get_server_compile_time_info, get_server_module_options_context,
@@ -370,6 +376,7 @@ pub async fn create_app_source(
         return Ok(NoContentSourceVc::new().into());
     };
     let entrypoints = get_entrypoints(app_dir, next_config.page_extensions());
+    let metadata = get_global_metadata(app_dir, next_config.page_extensions());
 
     let client_compile_time_info = get_client_compile_time_info(browserslist_query);
 
@@ -444,11 +451,58 @@ pub async fn create_app_source(
                 output_path,
             ),
         })
+        .chain(once(create_global_metadata_source(
+            app_dir,
+            metadata,
+            server_root,
+        )))
         .collect();
 
     Ok(CombinedContentSource { sources }.cell().into())
 }
 
+#[turbo_tasks::function]
+async fn create_global_metadata_source(
+    app_dir: FileSystemPathVc,
+    metadata: GlobalMetadataVc,
+    server_root: FileSystemPathVc,
+) -> Result<ContentSourceVc> {
+    let metadata = metadata.await?;
+    let mut unsupported_metadata = Vec::new();
+    let mut sources = Vec::new();
+    for (server_path, item) in [
+        ("robots.txt", metadata.robots),
+        ("favicon.ico", metadata.favicon),
+        ("sitemap.xml", metadata.sitemap),
+    ] {
+        let Some(item) = item else {
+            continue;
+        };
+        match item {
+            MetadataItem::Static { path } => {
+                let asset = FixedStaticAssetVc::new(
+                    server_root.join(server_path),
+                    SourceAssetVc::new(path).into(),
+                );
+                sources.push(AssetGraphContentSourceVc::new_eager(server_root, asset.into()).into())
+            }
+            MetadataItem::Dynamic { path } => {
+                unsupported_metadata.push(path);
+            }
+        }
+    }
+    if !unsupported_metadata.is_empty() {
+        UnsupportedDynamicMetadataIssue {
+            app_dir,
+            files: unsupported_metadata,
+        }
+        .cell()
+        .as_issue()
+        .emit();
+    }
+    Ok(CombinedContentSource { sources }.cell().into())
+}
+
 #[allow(clippy::too_many_arguments)]
 #[turbo_tasks::function]
 async fn create_app_page_source_for_route(
@@ -576,6 +630,14 @@ impl AppRendererVc {
             unsupported_metadata: Vec<FileSystemPathVc>,
         }
 
+        impl State {
+            fn unique_number(&mut self) -> usize {
+                let i = self.counter;
+                self.counter += 1;
+                i
+            }
+        }
+
         let mut state = State {
             inner_assets: IndexMap::new(),
             counter: 0,
@@ -593,8 +655,7 @@ impl AppRendererVc {
             use std::fmt::Write;
 
             if let Some(component) = component {
-                let i = state.counter;
-                state.counter += 1;
+                let i = state.unique_number();
                 let identifier = magic_identifier::mangle(&format!("{name} #{i}"));
                 let chunks_identifier = magic_identifier::mangle(&format!("chunks of {name} #{i}"));
                 writeln!(
@@ -622,10 +683,136 @@ import {}, {{ chunks as {} }} from "COMPONENT_{}";
             Ok(())
         }
 
-        fn emit_metadata_warning(state: &mut State, files: &[FileSystemPathVc]) {
-            for file in files {
-                state.unsupported_metadata.push(*file);
+        fn write_metadata(state: &mut State, metadata: &Metadata) -> Result<()> {
+            if metadata.is_empty() {
+                return Ok(());
             }
+            let Metadata {
+                icon,
+                apple,
+                twitter,
+                open_graph,
+                favicon,
+                manifest,
+            } = metadata;
+            state.loader_tree_code += "  metadata: {";
+            write_metadata_items(state, "icon", favicon.iter().chain(icon.iter()))?;
+            write_metadata_items(state, "apple", apple.iter())?;
+            write_metadata_items(state, "twitter", twitter.iter())?;
+            write_metadata_items(state, "openGraph", open_graph.iter())?;
+            write_metadata_manifest(state, *manifest)?;
+            state.loader_tree_code += "  },";
+            Ok(())
+        }
+
+        fn write_metadata_manifest(
+            state: &mut State,
+            manifest: Option<MetadataItem>,
+        ) -> Result<()> {
+            let Some(manifest) = manifest else {
+                return Ok(());
+            };
+            match manifest {
+                MetadataItem::Static { path } => {
+                    use std::fmt::Write;
+                    let i = state.unique_number();
+                    let identifier = magic_identifier::mangle(&format!("manifest #{i}"));
+                    let inner_module_id = format!("METADATA_{i}");
+                    state
+                        .imports
+                        .push(format!("import {identifier} from \"{inner_module_id}\";"));
+                    state.inner_assets.insert(
+                        inner_module_id,
+                        StaticModuleAssetVc::new(SourceAssetVc::new(path).into(), state.context)
+                            .into(),
+                    );
+                    writeln!(state.loader_tree_code, "    manifest: {identifier},")?;
+                }
+                MetadataItem::Dynamic { path } => {
+                    state.unsupported_metadata.push(path);
+                }
+            }
+
+            Ok(())
+        }
+
+        fn write_metadata_items<'a>(
+            state: &mut State,
+            name: &str,
+            it: impl Iterator<Item = &'a MetadataWithAltItem>,
+        ) -> Result<()> {
+            use std::fmt::Write;
+            let mut it = it.peekable();
+            if it.peek().is_none() {
+                return Ok(());
+            }
+            writeln!(state.loader_tree_code, "    {name}: [")?;
+            for item in it {
+                write_metadata_item(state, name, item)?;
+            }
+            writeln!(state.loader_tree_code, "    ],")?;
+            Ok(())
+        }
+
+        fn write_metadata_item(
+            state: &mut State,
+            name: &str,
+            item: &MetadataWithAltItem,
+        ) -> Result<()> {
+            use std::fmt::Write;
+            let i = state.unique_number();
+            let identifier = magic_identifier::mangle(&format!("{name} #{i}"));
+            let inner_module_id = format!("METADATA_{i}");
+            state
+                .imports
+                .push(format!("import {identifier} from \"{inner_module_id}\";"));
+            let s = "      ";
+            match item {
+                MetadataWithAltItem::Static { path, alt_path } => {
+                    state.inner_assets.insert(
+                        inner_module_id,
+                        StructuredImageModuleType::create_module(
+                            SourceAssetVc::new(*path).into(),
+                            state.context,
+                        )
+                        .into(),
+                    );
+                    writeln!(state.loader_tree_code, "{s}(async (props) => [{{")?;
+                    writeln!(state.loader_tree_code, "{s}  url: {identifier}.src,")?;
+                    let numeric_sizes = name == "twitter" || name == "openGraph";
+                    if numeric_sizes {
+                        writeln!(state.loader_tree_code, "{s}  width: {identifier}.width,")?;
+                        writeln!(state.loader_tree_code, "{s}  height: {identifier}.height,")?;
+                    } else {
+                        writeln!(
+                            state.loader_tree_code,
+                            "{s}  sizes: `${{{identifier}.width}}x${{{identifier}.height}}`,"
+                        )?;
+                    }
+                    if let Some(alt_path) = alt_path {
+                        let identifier = magic_identifier::mangle(&format!("{name} alt text #{i}"));
+                        let inner_module_id = format!("METADATA_ALT_{i}");
+                        state
+                            .imports
+                            .push(format!("import {identifier} from \"{inner_module_id}\";"));
+                        state.inner_assets.insert(
+                            inner_module_id,
+                            as_es_module_asset(
+                                TextContentSourceAssetVc::new(SourceAssetVc::new(*alt_path).into())
+                                    .into(),
+                                state.context,
+                            )
+                            .into(),
+                        );
+                        writeln!(state.loader_tree_code, "{s}  alt: {identifier},")?;
+                    }
+                    writeln!(state.loader_tree_code, "{s}}}]),")?;
+                }
+                MetadataWithAltItem::Dynamic { path, .. } => {
+                    state.unsupported_metadata.push(*path);
+                }
+            }
+            Ok(())
         }
 
         #[async_recursion]
@@ -658,14 +845,7 @@ import {}, {{ chunks as {} }} from "COMPONENT_{}";
                 layout,
                 loading,
                 template,
-                metadata:
-                    Metadata {
-                        icon,
-                        apple,
-                        twitter,
-                        open_graph,
-                        favicon,
-                    },
+                metadata,
                 route: _,
             } = &*components.await?;
             write_component(state, "page", *page)?;
@@ -674,12 +854,7 @@ import {}, {{ chunks as {} }} from "COMPONENT_{}";
             write_component(state, "layout", *layout)?;
             write_component(state, "loading", *loading)?;
             write_component(state, "template", *template)?;
-            // TODO something useful for metadata
-            emit_metadata_warning(state, icon);
-            emit_metadata_warning(state, apple);
-            emit_metadata_warning(state, twitter);
-            emit_metadata_warning(state, open_graph);
-            emit_metadata_warning(state, favicon);
+            write_metadata(state, metadata)?;
             write!(state.loader_tree_code, "}}]")?;
             Ok(())
         }
@@ -695,7 +870,7 @@ import {}, {{ chunks as {} }} from "COMPONENT_{}";
         } = state;
 
         if !unsupported_metadata.is_empty() {
-            UnsupportedImplicitMetadataIssue {
+            UnsupportedDynamicMetadataIssue {
                 app_dir,
                 files: unsupported_metadata,
             }
@@ -877,13 +1052,13 @@ impl NodeEntry for AppRoute {
 }
 
 #[turbo_tasks::value]
-struct UnsupportedImplicitMetadataIssue {
+struct UnsupportedDynamicMetadataIssue {
     app_dir: FileSystemPathVc,
     files: Vec<FileSystemPathVc>,
 }
 
 #[turbo_tasks::value_impl]
-impl Issue for UnsupportedImplicitMetadataIssue {
+impl Issue for UnsupportedDynamicMetadataIssue {
     #[turbo_tasks::function]
     fn severity(&self) -> IssueSeverityVc {
         IssueSeverity::Warning.into()
@@ -902,7 +1077,7 @@ impl Issue for UnsupportedImplicitMetadataIssue {
     #[turbo_tasks::function]
     fn title(&self) -> StringVc {
         StringVc::cell(
-            "Implicit metadata from filesystem is currently not supported in Turbopack".to_string(),
+            "Dynamic metadata from filesystem is currently not supported in Turbopack".to_string(),
         )
     }
 
diff --git a/packages/next-swc/crates/next-core/src/app_structure.rs b/packages/next-swc/crates/next-core/src/app_structure.rs
index 5f59531b39507..bf3ed493ac860 100644
--- a/packages/next-swc/crates/next-core/src/app_structure.rs
+++ b/packages/next-swc/crates/next-core/src/app_structure.rs
@@ -82,18 +82,40 @@ impl ComponentsVc {
     }
 }
 
+/// A single metadata file plus an optional "alt" text file.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, TraceRawVcs)]
+pub enum MetadataWithAltItem {
+    Static {
+        path: FileSystemPathVc,
+        alt_path: Option<FileSystemPathVc>,
+    },
+    Dynamic {
+        path: FileSystemPathVc,
+    },
+}
+
+/// A single metadata file.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, TraceRawVcs)]
+pub enum MetadataItem {
+    Static { path: FileSystemPathVc },
+    Dynamic { path: FileSystemPathVc },
+}
+
+/// Metadata file that can be placed in any segment of the app directory.
 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, TraceRawVcs)]
 pub struct Metadata {
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub icon: Vec<FileSystemPathVc>,
+    pub icon: Vec<MetadataWithAltItem>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub apple: Vec<FileSystemPathVc>,
+    pub apple: Vec<MetadataWithAltItem>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub twitter: Vec<FileSystemPathVc>,
+    pub twitter: Vec<MetadataWithAltItem>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub open_graph: Vec<FileSystemPathVc>,
+    pub open_graph: Vec<MetadataWithAltItem>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub favicon: Vec<FileSystemPathVc>,
+    pub favicon: Vec<MetadataWithAltItem>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub manifest: Option<MetadataItem>,
 }
 
 impl Metadata {
@@ -104,12 +126,14 @@ impl Metadata {
             twitter,
             open_graph,
             favicon,
+            manifest,
         } = self;
         icon.is_empty()
             && apple.is_empty()
             && twitter.is_empty()
             && open_graph.is_empty()
             && favicon.is_empty()
+            && manifest.is_none()
     }
 
     fn merge(a: &Self, b: &Self) -> Self {
@@ -124,10 +148,34 @@ impl Metadata {
                 .copied()
                 .collect(),
             favicon: a.favicon.iter().chain(b.favicon.iter()).copied().collect(),
+            manifest: a.manifest.or(b.manifest),
         }
     }
 }
 
+/// Metadata files that can be placed in the root of the app directory.
+#[turbo_tasks::value]
+#[derive(Default, Clone, Debug)]
+pub struct GlobalMetadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub favicon: Option<MetadataItem>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub robots: Option<MetadataItem>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sitemap: Option<MetadataItem>,
+}
+
+impl GlobalMetadata {
+    pub fn is_empty(&self) -> bool {
+        let GlobalMetadata {
+            favicon,
+            robots,
+            sitemap,
+        } = self;
+        favicon.is_none() && robots.is_none() && sitemap.is_none()
+    }
+}
+
 #[turbo_tasks::value]
 #[derive(Debug)]
 pub struct DirectoryTree {
@@ -203,7 +251,7 @@ pub async fn find_app_dir_if_enabled(
     Ok(find_app_dir(project_path))
 }
 
-static STATIC_METADATA_IMAGES: Lazy<HashMap<&'static str, &'static [&'static str]>> =
+static STATIC_LOCAL_METADATA: Lazy<HashMap<&'static str, &'static [&'static str]>> =
     Lazy::new(|| {
         HashMap::from([
             (
@@ -211,18 +259,36 @@ static STATIC_METADATA_IMAGES: Lazy<HashMap<&'static str, &'static [&'static str
                 &["ico", "jpg", "jpeg", "png", "svg"] as &'static [&'static str],
             ),
             ("apple-icon", &["jpg", "jpeg", "png"]),
-            ("favicon", &["ico"]),
             ("opengraph-image", &["jpg", "jpeg", "png", "gif"]),
             ("twitter-image", &["jpg", "jpeg", "png", "gif"]),
+            ("favicon", &["ico"]),
+            ("manifest", &["webmanifest", "json"]),
         ])
     });
 
-fn match_metadata_file(basename: &str) -> Option<&'static str> {
+static STATIC_GLOBAL_METADATA: Lazy<HashMap<&'static str, &'static [&'static str]>> =
+    Lazy::new(|| {
+        HashMap::from([
+            ("favicon", &["ico"] as &'static [&'static str]),
+            ("robots", &["txt"]),
+            ("sitemap", &["xml"]),
+        ])
+    });
+
+fn match_metadata_file<'a>(
+    basename: &'a str,
+    page_extensions: &[String],
+) -> Option<(&'a str, i32, bool)> {
     let (stem, ext) = basename.split_once('.')?;
-    static REGEX: Lazy<Regex> = Lazy::new(|| Regex::new("\\d*$").unwrap());
-    let stem = REGEX.replace(stem, "");
-    let (key, exts) = STATIC_METADATA_IMAGES.get_key_value(stem.as_ref())?;
-    exts.contains(&ext).then_some(key)
+    static REGEX: Lazy<Regex> = Lazy::new(|| Regex::new("^(.*?)(\\d*)$").unwrap());
+    let captures = REGEX.captures(stem).expect("the regex will always match");
+    let stem = captures.get(1).unwrap().as_str();
+    let num: i32 = captures.get(2).unwrap().as_str().parse().unwrap_or(-1);
+    if page_extensions.iter().any(|e| e == ext) {
+        return Some((stem, num, true));
+    }
+    let exts = STATIC_LOCAL_METADATA.get(stem)?;
+    exts.contains(&ext).then_some((stem, num, false))
 }
 
 #[turbo_tasks::function]
@@ -233,14 +299,22 @@ async fn get_directory_tree(
     let DirectoryContent::Entries(entries) = &*app_dir.read_dir().await? else {
         bail!("app_dir must be a directory")
     };
+    let page_extensions_value = page_extensions.await?;
+
     let mut subdirectories = BTreeMap::new();
     let mut components = Components::default();
 
+    let mut metadata_icon = Vec::new();
+    let mut metadata_apple = Vec::new();
+    let mut metadata_open_graph = Vec::new();
+    let mut metadata_twitter = Vec::new();
+    let mut metadata_favicon = Vec::new();
+
     for (basename, entry) in entries {
         match *entry {
             DirectoryEntry::File(file) => {
                 if let Some((stem, ext)) = basename.split_once('.') {
-                    if page_extensions.await?.iter().any(|e| e == ext) {
+                    if page_extensions_value.iter().any(|e| e == ext) {
                         match stem {
                             "page" => components.page = Some(file),
                             "layout" => components.layout = Some(file),
@@ -249,24 +323,57 @@ async fn get_directory_tree(
                             "template" => components.template = Some(file),
                             "default" => components.default = Some(file),
                             "route" => components.route = Some(file),
+                            "manifest" => {
+                                components.metadata.manifest =
+                                    Some(MetadataItem::Dynamic { path: file });
+                                continue;
+                            }
                             _ => {}
                         }
                     }
                 }
-                if let Some(metadata_type) = match_metadata_file(basename.as_str()) {
-                    let metadata = &mut components.metadata;
+
+                if let Some((metadata_type, num, dynamic)) =
+                    match_metadata_file(basename.as_str(), &page_extensions_value)
+                {
+                    if metadata_type == "manifest" {
+                        if num == -1 {
+                            components.metadata.manifest =
+                                Some(MetadataItem::Static { path: file });
+                        }
+                        continue;
+                    }
 
                     let entry = match metadata_type {
-                        "icon" => Some(&mut metadata.icon),
-                        "apple-icon" => Some(&mut metadata.apple),
-                        "twitter-image" => Some(&mut metadata.twitter),
-                        "opengraph-image" => Some(&mut metadata.open_graph),
-                        "favicon" => Some(&mut metadata.favicon),
+                        "icon" => Some(&mut metadata_icon),
+                        "apple-icon" => Some(&mut metadata_apple),
+                        "twitter-image" => Some(&mut metadata_twitter),
+                        "opengraph-image" => Some(&mut metadata_open_graph),
+                        "favicon" => Some(&mut metadata_favicon),
                         _ => None,
                     };
 
                     if let Some(entry) = entry {
-                        entry.push(file)
+                        if dynamic {
+                            entry.push((num, MetadataWithAltItem::Dynamic { path: file }));
+                        } else {
+                            let file_value = file.await?;
+                            let file_name = file_value.file_name();
+                            let basename = file_name
+                                .rsplit_once('.')
+                                .map_or(file_name, |(basename, _)| basename);
+                            let alt_path = file.parent().join(&format!("{}.alt.txt", basename));
+                            let alt_path =
+                                matches!(&*alt_path.get_type().await?, FileSystemEntryType::File)
+                                    .then_some(alt_path);
+                            entry.push((
+                                num,
+                                MetadataWithAltItem::Static {
+                                    path: file,
+                                    alt_path,
+                                },
+                            ));
+                        }
                     }
                 }
             }
@@ -274,11 +381,22 @@ async fn get_directory_tree(
                 let result = get_directory_tree(dir, page_extensions);
                 subdirectories.insert(basename.to_string(), result);
             }
-            // TODO handle symlinks in app dir
+            // TODO(WEB-952) handle symlinks in app dir
             _ => {}
         }
     }
 
+    fn sort<T>(mut list: Vec<(i32, T)>) -> Vec<T> {
+        list.sort_by_key(|(num, _)| *num);
+        list.into_iter().map(|(_, item)| item).collect()
+    }
+
+    components.metadata.icon = sort(metadata_icon);
+    components.metadata.apple = sort(metadata_apple);
+    components.metadata.twitter = sort(metadata_twitter);
+    components.metadata.open_graph = sort(metadata_open_graph);
+    components.metadata.favicon = sort(metadata_favicon);
+
     Ok(DirectoryTree {
         subdirectories,
         components: components.cell(),
@@ -576,6 +694,42 @@ async fn directory_tree_to_entrypoints_internal(
     Ok(EntrypointsVc::cell(result))
 }
 
+/// Returns the global metadata for an app directory.
+#[turbo_tasks::function]
+pub async fn get_global_metadata(
+    app_dir: FileSystemPathVc,
+    page_extensions: StringsVc,
+) -> Result<GlobalMetadataVc> {
+    let DirectoryContent::Entries(entries) = &*app_dir.read_dir().await? else {
+        bail!("app_dir must be a directory")
+    };
+    let mut metadata = GlobalMetadata::default();
+
+    for (basename, entry) in entries {
+        if let DirectoryEntry::File(file) = *entry {
+            if let Some((stem, ext)) = basename.split_once('.') {
+                let list = match stem {
+                    "favicon" => Some(&mut metadata.favicon),
+                    "sitemap" => Some(&mut metadata.sitemap),
+                    "robots" => Some(&mut metadata.robots),
+                    _ => None,
+                };
+                if let Some(list) = list {
+                    if page_extensions.await?.iter().any(|e| e == ext) {
+                        *list = Some(MetadataItem::Dynamic { path: file });
+                    }
+                    if STATIC_GLOBAL_METADATA.get(stem).unwrap().contains(&ext) {
+                        *list = Some(MetadataItem::Static { path: file });
+                    }
+                }
+            }
+        }
+        // TODO(WEB-952) handle symlinks in app dir
+    }
+
+    Ok(metadata.cell())
+}
+
 #[turbo_tasks::value(shared)]
 struct DirectoryTreeIssue {
     pub severity: IssueSeverityVc,
diff --git a/packages/next-swc/crates/next-core/src/asset_helpers.rs b/packages/next-swc/crates/next-core/src/asset_helpers.rs
new file mode 100644
index 0000000000000..6dc253261d4f7
--- /dev/null
+++ b/packages/next-swc/crates/next-core/src/asset_helpers.rs
@@ -0,0 +1,27 @@
+use turbo_binding::turbopack::{
+    core::{
+        asset::AssetVc,
+        context::{AssetContext, AssetContextVc},
+    },
+    ecmascript::{
+        EcmascriptInputTransform, EcmascriptInputTransformsVc, EcmascriptModuleAssetType,
+        EcmascriptModuleAssetVc,
+    },
+};
+use turbo_tasks::Value;
+
+pub(crate) fn as_es_module_asset(
+    asset: AssetVc,
+    context: AssetContextVc,
+) -> EcmascriptModuleAssetVc {
+    EcmascriptModuleAssetVc::new(
+        asset,
+        context,
+        Value::new(EcmascriptModuleAssetType::Typescript),
+        EcmascriptInputTransformsVc::cell(vec![EcmascriptInputTransform::TypeScript {
+            use_define_for_class_fields: false,
+        }]),
+        Default::default(),
+        context.compile_time_info(),
+    )
+}
diff --git a/packages/next-swc/crates/next-core/src/lib.rs b/packages/next-swc/crates/next-core/src/lib.rs
index fa249e39fd220..b2f58717de922 100644
--- a/packages/next-swc/crates/next-core/src/lib.rs
+++ b/packages/next-swc/crates/next-core/src/lib.rs
@@ -5,6 +5,7 @@
 mod app_render;
 mod app_source;
 pub mod app_structure;
+mod asset_helpers;
 mod babel;
 mod embed_js;
 pub mod env;
diff --git a/packages/next-swc/crates/next-core/src/next_image/module.rs b/packages/next-swc/crates/next-core/src/next_image/module.rs
index 9c49905e52370..61a8672f5e197 100644
--- a/packages/next-swc/crates/next-core/src/next_image/module.rs
+++ b/packages/next-swc/crates/next-core/src/next_image/module.rs
@@ -24,25 +24,13 @@ use super::source_asset::StructuredImageSourceAsset;
 #[turbo_tasks::value]
 pub struct StructuredImageModuleType {}
 
-#[turbo_tasks::value_impl]
-impl StructuredImageModuleTypeVc {
-    #[turbo_tasks::function]
-    pub fn new() -> Self {
-        StructuredImageModuleTypeVc::cell(StructuredImageModuleType {})
-    }
-}
-
-#[turbo_tasks::value_impl]
-impl CustomModuleType for StructuredImageModuleType {
-    #[turbo_tasks::function]
-    async fn create_module(
-        &self,
+impl StructuredImageModuleType {
+    pub(crate) fn create_module(
         source: AssetVc,
         context: AssetContextVc,
-        _part: Option<ModulePartVc>,
-    ) -> Result<AssetVc> {
+    ) -> EcmascriptModuleAssetVc {
         let static_asset = StaticModuleAssetVc::new(source, context);
-        Ok(EcmascriptModuleAssetVc::new_with_inner_assets(
+        EcmascriptModuleAssetVc::new_with_inner_assets(
             StructuredImageSourceAsset { image: source }.cell().into(),
             context,
             Value::new(EcmascriptModuleAssetType::Ecmascript),
@@ -55,6 +43,26 @@ impl CustomModuleType for StructuredImageModuleType {
                 "IMAGE".to_string() => static_asset.into()
             )),
         )
-        .into())
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl StructuredImageModuleTypeVc {
+    #[turbo_tasks::function]
+    pub fn new() -> Self {
+        StructuredImageModuleTypeVc::cell(StructuredImageModuleType {})
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl CustomModuleType for StructuredImageModuleType {
+    #[turbo_tasks::function]
+    fn create_module(
+        &self,
+        source: AssetVc,
+        context: AssetContextVc,
+        _part: Option<ModulePartVc>,
+    ) -> AssetVc {
+        StructuredImageModuleType::create_module(source, context).into()
     }
 }
diff --git a/packages/next-swc/crates/next-core/src/router.rs b/packages/next-swc/crates/next-core/src/router.rs
index c24f18206afa9..f4c6e2b73dc62 100644
--- a/packages/next-swc/crates/next-core/src/router.rs
+++ b/packages/next-swc/crates/next-core/src/router.rs
@@ -45,6 +45,7 @@ use turbo_tasks::{
 use turbo_tasks_fs::json::parse_json_with_source_context;
 
 use crate::{
+    asset_helpers::as_es_module_asset,
     embed_js::{next_asset, next_js_file},
     next_config::NextConfigVc,
     next_edge::{
@@ -156,19 +157,6 @@ async fn get_config(
     Ok(OptionEcmascriptModuleAssetVc::cell(config_asset))
 }
 
-fn as_es_module_asset(asset: AssetVc, context: AssetContextVc) -> EcmascriptModuleAssetVc {
-    EcmascriptModuleAssetVc::new(
-        asset,
-        context,
-        Value::new(EcmascriptModuleAssetType::Typescript),
-        EcmascriptInputTransformsVc::cell(vec![EcmascriptInputTransform::TypeScript {
-            use_define_for_class_fields: false,
-        }]),
-        Default::default(),
-        context.compile_time_info(),
-    )
-}
-
 #[turbo_tasks::function]
 async fn next_config_changed(
     context: AssetContextVc,
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/favicon.ico b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..4965832f2c9b0605eaa189b7c7fb11124d24e48a
GIT binary patch
literal 15086
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
A761SM

literal 0
HcmV?d00001

diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/icon1234.png b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/icon1234.png
index e3b4277bf093d204f4088ba46590bc9e6f37bf67..c54f465b124a4a93588e30355af3a3097c07a352 100644
GIT binary patch
literal 6230
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
CmjnF(

delta 852
zcmca+@PVzqGr-TCmrII^fq{Y7)59eQNGpIa2MdtAS-hzpNU@|l`Z_W&Z0zU$lgJ8^
zO!f%!WnidMV_;}#VPN<L6l!?Ez))(y!0;-8fx&791A}<MoLzx7KnbQKZ+91l|Ly%}
z_5*qBC7!;n?2lNaIn>ps$QT@CsApgj^>lFz@i;zr>e=kzK!Kz6JN31;Ze7vactp=d
zU`f~t4?CBbB~BmmCpfu^2#UPA_sGdb=+3k>WvB8crFSk<Zs^5uUD69`;&n7!;<{@>
zgvr+9u2FA)`^|~GTRG=*+Pk@y!UuB${R$?^Ece_X|HHA__0*oFr_>bFCN6a8H7lyG
zm@TDh6yf+m#WgJU!rgsd6PL)_9A%1bEKuAQq41RT{6-nBdmmGa{3>R7T`y47TJm=5
z`R^>^N&oK0N^sd8Zq-PzVu_sf-}QnDH(R&oqusAN3py6ce#(_jY1*UgHpf#(Vqsc(
z-|MM%FPe0xT`J#uoiUxy)Q#sc&+Sfji=&e7>IFBOu5g{w@%e3=r1_JMs_jR4%@5d`
zS{`0uE%#7d`p&Z&3C12Np*R*^FCN3Q4-J}H7T(v^oA+Uo&Go|^zk17U4q1I)X?%32
z0Gsn^Yv#l5Tt{X+OAy$Xn(?E4?qkd8JJ@QH&;It6YExa$)Y2fvAMubcbJdv(-;^SZ
zrZku2O>D21d8pTH^K5JMSu@S*EuRW&uXgq2&HrVx{QfMVuFUoB+RaDT*w*;OhlD<Q
z|8t4fuQi+FK3m-OJY{&UcGn`#+xPWWFBN|mm^JBc<tYKjn~U9lt&HB+bg6a8(XVc$
zy+1vqN)%UVUj6FBY`2Ij_QbEywXc`0U*r5D>E?3D+DkLuC%vq{<N6@W`_<iBmz7Q~
z_$sj}=Ch=$xlHc+ZS$`EmhY_OUmkq-!5d)0Q7v(eC`m~yNwrEYN(E93Mh1o!x&|h?
zM&=;~7FNcVK%{M8WMyE`Tg%aeq9HdwB{QuOhXymCjz0<;?0`DLt3o15f)dLW3X1a6
zGILTDN-7Id6*3D-k{K8(<~;ty!%-Nfp>fLp^cl~mlf@WyL|%ytmV9zDoeI>;;OXk;
Jvd$@?2>_grTz&um

diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/manifest.webmanifest b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/manifest.webmanifest
new file mode 100644
index 0000000000000..f3e287945395b
--- /dev/null
+++ b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/manifest.webmanifest
@@ -0,0 +1,9 @@
+{
+  "name": "Next.js Static Manifest",
+  "short_name": "Next.js App",
+  "description": "Next.js App",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#fff",
+  "theme_color": "#fff"
+}
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.alt.txt b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.alt.txt
new file mode 100644
index 0000000000000..e07d9e8a67033
--- /dev/null
+++ b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.alt.txt
@@ -0,0 +1 @@
+This is an alt text.
\ No newline at end of file
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.png b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/opengraph-image.png
new file mode 100644
index 0000000000000000000000000000000000000000..7cbc1d26733614b83dcc25b9cfcd5e06dffb147c
GIT binary patch
literal 1661
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
Hu0mjfdKc_u

literal 0
HcmV?d00001

diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/robots.txt b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/robots.txt
new file mode 100644
index 0000000000000..0ad279c73692e
--- /dev/null
+++ b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/robots.txt
@@ -0,0 +1,2 @@
+User-Agent: *
+Disallow:
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/sitemap.xml b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/sitemap.xml
new file mode 100644
index 0000000000000..9d2b2deade0c4
--- /dev/null
+++ b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/sitemap.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://vercel.com/</loc>
+    <lastmod>2023-03-06T18:04:14.008Z</lastmod>
+  </url>
+</urlset>
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/test.tsx b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/test.tsx
index f4994b194885f..2633ad971ff98 100644
--- a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/test.tsx
+++ b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/test.tsx
@@ -5,7 +5,84 @@ import { useEffect } from 'react'
 export default function Test() {
   useEffect(() => {
     import('@turbo/pack-test-harness').then(() => {
-      it('should run', () => {})
+      it('should have the correct link tags', () => {
+        let links = Array.from(document.querySelectorAll('link'))
+        expect(
+          links.map((l) => ({
+            href: l.getAttribute('href'),
+            rel: l.getAttribute('rel'),
+            sizes: l.getAttribute('sizes'),
+          }))
+        ).toEqual([
+          expect.objectContaining({
+            rel: 'manifest',
+            href: expect.stringMatching(/^\/_next\/static\/.+\.webmanifest$/),
+            sizes: null,
+          }),
+          expect.objectContaining({
+            rel: 'icon',
+            href: expect.stringMatching(/^\/_next\/static\/.+\.ico$/),
+            sizes: '48x48',
+          }),
+          expect.objectContaining({
+            rel: 'icon',
+            href: expect.stringMatching(/^\/_next\/static\/.+\.png$/),
+            sizes: '32x32',
+          }),
+          expect.objectContaining({
+            rel: 'icon',
+            href: expect.stringMatching(/^\/_next\/static\/.+\.png$/),
+            sizes: '64x64',
+          }),
+          expect.objectContaining({
+            rel: 'apple-touch-icon',
+            href: expect.stringMatching(/^\/_next\/static\/.+\.png$/),
+            sizes: '114x114',
+          }),
+        ])
+      })
+
+      it('should have the correct meta tags', () => {
+        const meta = Array.from(document.querySelectorAll('meta'))
+        const metaObject = Object.fromEntries(
+          meta
+            .filter((l) => l.getAttribute('property'))
+            .map((l) => [l.getAttribute('property'), l.getAttribute('content')])
+        )
+        expect(metaObject).toEqual({
+          'og:image': expect.stringMatching(/^.+\/_next\/static\/.+\.png$/),
+          'og:image:width': '114',
+          'og:image:height': '114',
+          'og:image:alt': 'This is an alt text.',
+        })
+      })
+
+      it('should provide a robots.txt', async () => {
+        const res = await fetch('/robots.txt')
+        expect(res.status).toBe(200)
+        expect(await res.text()).toBe('User-Agent: *\nDisallow:\n')
+      })
+
+      it('should provide a sitemap.xml', async () => {
+        const res = await fetch('/sitemap.xml')
+        expect(res.status).toBe(200)
+        expect(await res.text()).toBe(
+          `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://vercel.com/</loc>
+    <lastmod>2023-03-06T18:04:14.008Z</lastmod>
+  </url>
+</urlset>
+`
+        )
+      })
+
+      it('should provide a favicon.ico', async () => {
+        const res = await fetch('/favicon.ico')
+        expect(res.status).toBe(200)
+        expect(res.headers.get('content-type')).toBe('image/x-icon')
+      })
     })
     return () => {}
   }, [])
diff --git a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/issues/Implicit metadata from filesystem is currently not-9116b0.txt b/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/issues/Implicit metadata from filesystem is currently not-9116b0.txt
deleted file mode 100644
index bc808b91de05f..0000000000000
--- a/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/issues/Implicit metadata from filesystem is currently not-9116b0.txt	
+++ /dev/null
@@ -1,21 +0,0 @@
-PlainIssue {
-    severity: Warning,
-    context: "[project]/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app",
-    category: "unsupported",
-    title: "Implicit metadata from filesystem is currently not supported in Turbopack",
-    description: "The following files were found in the app directory, but are not supported by Turbopack. They are ignored:\n\n- [project]/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/apple-icon.png\n- [project]/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/icon1234.png\n- [project]/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app/icon234.png",
-    detail: "",
-    documentation_link: "",
-    source: None,
-    sub_issues: [],
-    processing_path: Some(
-        [
-            PlainIssueProcessingPathItem {
-                context: Some(
-                    "[project]/packages/next-swc/crates/next-dev-tests/tests/integration/next/app/implicit-metadata/input/app",
-                ),
-                description: "Next.js App Page Route /",
-            },
-        ],
-    ),
-}
\ No newline at end of file