@ecopages/core 0.2.0-beta.28 → 0.2.0-beta.29

package/src/route-renderer/orchestration/route-pipeline/route-html-finalization.service.js

@@ -1,9 +1,12 @@
+import { buildRobotsMetaContribution } from "./robots-meta.contribution.js";
 function buildRouteHtmlFinalization(context) {
   const { renderOptions } = context;
   const documentAttributes = context.getDocumentAttributes(renderOptions);
-  const htmlContributions = context.getHtmlDocumentContributions({ renderOptions, partial: false });
+  const integrationContributions = context.getHtmlDocumentContributions({ renderOptions, partial: false }) ?? [];
+  const robotsContribution = buildRobotsMetaContribution(renderOptions.metadata ?? {});
+  const htmlContributions = robotsContribution ? [robotsContribution, ...integrationContributions] : integrationContributions;
   const hasStructuralFinalization = documentAttributes && Object.keys(documentAttributes).length > 0;
-  if (!hasStructuralFinalization && (!htmlContributions || htmlContributions.length === 0)) {
+  if (!hasStructuralFinalization && htmlContributions.length === 0) {
     return {};
   }
   return {

package/src/route-renderer/orchestration/route-pipeline/route-prepared-options.builder.js

@@ -6,8 +6,12 @@ function buildPreparedRenderOptions(input) {
   const { Page, HtmlTemplate, Layouts, Layout, layoutEntries, props, metadata, integrationSpecificProps } = resolvedInputs;
   const dedupedDependencies = dedupeProcessedAssets(allDependencies);
   const pagePackage = createPagePackage(dedupedDependencies, { pageBrowserGraph });
-  const pageProps = {
+  const resolvedProps = {
     ...props,
+    ...routeOptions.props ?? {}
+  };
+  const pageProps = {
+    ...resolvedProps,
     params: routeOptions.params || {},
     query: routeOptions.query || {}
   };
@@ -25,7 +29,7 @@ function buildPreparedRenderOptions(input) {
     Layouts,
     Layout,
     layoutEntries,
-    props,
+    props: resolvedProps,
     Page,
     metadata,
     params: routeOptions.params || {},

package/src/static-site-generator/README.md

@@ -29,8 +29,10 @@ It should not invent a parallel rendering stack just for build mode.
 
 | File                           | Role                                                                         |
 | ------------------------------ | ---------------------------------------------------------------------------- |
-| `static-site-generator.ts`     | Route enumeration, HTML artifact writes, integration export hooks            |
+| `static-site-generator.ts`     | Route enumeration, HTML artifact writes, integration export hooks, sitemap   |
 | `static-export-context.ts`     | Hook context type for `beforeStaticExport` / `afterStaticExport`             |
+| `sitemap.ts`                   | Pure sitemap.xml renderer                                                    |
+| `sitemap-routes.ts`            | Sitemap location assembly (`exclude`, `extraUrls`, dedupe)                   |
 | `static-build-invalidation.ts` | `dist/` reset policy, production cache clearing, static-render cache context |
 
 Build-input fingerprinting (`hashAppConfigFile`, `createBuildInputsFingerprint`) lives in `packages/core/src/build/cache/build-input-fingerprint.ts` and is shared with server-entry and unified-graph caches.
@@ -56,4 +58,10 @@ Integrations may implement:
 - `beforeStaticExport(context)` — runs after unified-graph prebuild, before page rendering
 - `afterStaticExport(context)` — runs in a `finally` block after generation completes
 
+When `appConfig.sitemap.enabled` is true, `sitemap.xml` is written **after** `afterStaticExport` so integration-generated URLs can be listed via `extraUrls`.
+
+Sitemap eligibility is decided during successful page export (`activeStaticPathnames` plus `robots.index !== false`, fail-closed on metadata errors). `resolveSitemapLocations` then applies `exclude` and appends `extraUrls`.
+
+`StaticExportContext.routes` is the unfiltered static-generation route list. Sitemap filtering is applied separately.
+
 See `StaticExportContext` in `static-export-context.ts`.

package/src/static-site-generator/sitemap-routes.d.ts

@@ -0,0 +1,14 @@
+import type { SitemapConfig } from '../types/public-types.js';
+/**
+ * Builds the ordered absolute locations for sitemap.xml.
+ *
+ * @remarks
+ * `eligiblePathnames` must already be successfully exported and robots-indexable.
+ * Filtering here is only `sitemap.exclude`, then `extraUrls` are appended.
+ * `extraUrls` always include (deduped) and are not subject to `exclude` or page robots.
+ */
+export declare function resolveSitemapLocations(input: {
+    eligiblePathnames: readonly string[];
+    sitemap: SitemapConfig;
+    baseUrl: string;
+}): string[];

package/src/static-site-generator/sitemap-routes.js

@@ -0,0 +1,31 @@
+import { matchesAnyPathPattern, normalizePathname } from "../utils/path-pattern.js";
+import { buildSitemapLocation } from "./sitemap.js";
+function resolveSitemapLocations(input) {
+  const exclude = input.sitemap.exclude ?? [];
+  const locations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pathname of input.eligiblePathnames) {
+    const normalized = normalizePathname(pathname);
+    if (matchesAnyPathPattern(normalized, exclude)) {
+      continue;
+    }
+    const location = buildSitemapLocation(input.baseUrl, normalized);
+    if (seen.has(location)) {
+      continue;
+    }
+    seen.add(location);
+    locations.push(location);
+  }
+  for (const extraUrl of input.sitemap.extraUrls ?? []) {
+    const location = buildSitemapLocation(input.baseUrl, extraUrl);
+    if (seen.has(location)) {
+      continue;
+    }
+    seen.add(location);
+    locations.push(location);
+  }
+  return locations;
+}
+export {
+  resolveSitemapLocations
+};

package/src/static-site-generator/sitemap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Joins a base origin with a pathname or absolute URL into a sitemap `<loc>` value.
+ *
+ * @remarks
+ * Trailing slashes are stripped except for the site root (`/`). Absolute `http(s)`
+ * URLs in `extraUrls` are returned as-is (still slash-normalized).
+ */
+export declare function buildSitemapLocation(baseUrl: string, pathnameOrUrl: string): string;
+/**
+ * Renders a sitemap.org 0.9 urlset document from absolute location URLs.
+ *
+ * @remarks
+ * Callers are responsible for deduplication; this serializer preserves input order.
+ */
+export declare function renderSitemap(locations: readonly string[]): string;

package/src/static-site-generator/sitemap.js

@@ -0,0 +1,33 @@
+import { escapeXmlText } from "../utils/html-escaping.js";
+import { normalizePathname } from "../utils/path-pattern.js";
+function buildSitemapLocation(baseUrl, pathnameOrUrl) {
+  const trimmed = pathnameOrUrl.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    return normalizeLocation(trimmed);
+  }
+  const origin = baseUrl.replace(/\/+$/, "");
+  const pathname = normalizePathname(trimmed);
+  return pathname === "/" ? `${origin}/` : `${origin}${pathname}`;
+}
+function renderSitemap(locations) {
+  const urls = locations.map((loc) => `  <url>
+    <loc>${escapeXmlText(normalizeLocation(loc))}</loc>
+  </url>`).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    urls,
+    "</urlset>",
+    ""
+  ].join("\n");
+}
+function normalizeLocation(location) {
+  if (/^https?:\/\/[^/]+\/?$/i.test(location)) {
+    return `${location.replace(/\/+$/, "")}/`;
+  }
+  return location.replace(/\/+$/, "");
+}
+export {
+  buildSitemapLocation,
+  renderSitemap
+};

package/src/static-site-generator/static-export-context.d.ts

@@ -1,5 +1,5 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import type { StaticRoute } from '../types/public-types.js';
+import type { EcopagesRouteInfo, StaticRoute } from '../types/public-types.js';
 import type { StaticGenerationRendererResolver } from '../route-renderer/route-renderer.js';
 import type { StaticGenerationRoute } from '../router/server/route-registry.js';
 type StaticGenerationRouteSource = {
@@ -18,5 +18,13 @@ export interface StaticExportContext {
     staticRoutes?: StaticRoute[];
     force: boolean;
     preserveExportDirectory: boolean;
+    /**
+     * Unfiltered static-generation routes (exact + expanded dynamic).
+     *
+     * @remarks
+     * Sitemap filtering is applied separately; integrations that build custom
+     * artifacts should start from this full list.
+     */
+    routes: EcopagesRouteInfo[];
 }
 export {};

package/src/static-site-generator/static-site-generator.d.ts

@@ -1,5 +1,5 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import type { StaticRoute } from '../types/public-types.js';
+import type { SitemapConfig, StaticRoute } from '../types/public-types.js';
 import type { PageRendererResolver, StaticGenerationRendererResolver } from '../route-renderer/route-renderer.js';
 import type { StaticGenerationRoute } from '../router/server/route-registry.js';
 import type { RouteModuleBuildCache } from '../services/module-loading/route-module-build-cache.store.js';
@@ -31,6 +31,7 @@ export declare class StaticSiteGenerator {
     private readonly routeModuleBuildCacheOverride?;
     private staticRenderCacheContext;
     private forceFullStaticGeneration;
+    private pageModuleLoader?;
     /**
      * Creates the static-site generator for one app config.
      */
@@ -46,6 +47,10 @@ export declare class StaticSiteGenerator {
      * Writes the robots.txt file declared by the app config.
      */
     generateRobotsTxt(): void;
+    /**
+     * Writes the configured sitemap file to the export directory.
+     */
+    generateSitemap(locations: readonly string[], sitemap: SitemapConfig): void;
     /**
      * Returns whether the input path points at the root directory.
      */
@@ -56,6 +61,18 @@ export declare class StaticSiteGenerator {
     getDirectories(routes: string[]): string[];
     private writeStaticOutput;
     private writeStaticPageArtifact;
+    /**
+     * Marks a successfully exported pathname as sitemap-eligible when robots allow indexing.
+     *
+     * @remarks
+     * Fail-closed: metadata resolution errors omit the URL. `robots.index === false`
+     * also omits it. Eligibility is decided during generation, not by reloading modules
+     * after `afterStaticExport`.
+     */
+    private considerSitemapEligibility;
+    private getPageModuleLoader;
+    private resolveFilesystemPageMetadata;
+    private resolveExplicitViewMetadata;
     private pruneStaleStaticOutputs;
     private createFilesystemStaticContents;
     /**
@@ -64,7 +81,15 @@ export declare class StaticSiteGenerator {
      * @remarks
      * Routes are rendered through the normal route renderer directly.
      */
-    generateStaticPages(router: StaticGenerationRouteSource, baseUrl: string, routeRendererFactory?: StaticPageRouteRendererFactory, skipped?: string[], activeStaticPathnames?: Set<string>, preloadedRoutes?: readonly StaticGenerationRoute[]): Promise<void>;
+    generateStaticPages(input: {
+        router: StaticGenerationRouteSource;
+        baseUrl: string;
+        routeRendererFactory?: StaticPageRouteRendererFactory;
+        skipped?: string[];
+        activeStaticPathnames?: Set<string>;
+        preloadedRoutes?: readonly StaticGenerationRoute[];
+        sitemapEligiblePathnames?: Set<string>;
+    }): Promise<void>;
     private createStaticExportContext;
     private invokeStaticExportHook;
     /**
@@ -78,10 +103,6 @@ export declare class StaticSiteGenerator {
         force?: boolean;
         preserveExportDirectory?: boolean;
     }): Promise<void>;
-    /**
-     * Generates static pages from explicit static routes registered via app.static().
-     * These routes use eco.page views via loader functions for HMR support.
-     */
     private generateExplicitStaticPages;
     private resolveExplicitViewSourceFile;
     private generateExplicitStaticRoute;

package/src/static-site-generator/static-site-generator.js

@@ -17,6 +17,11 @@ import {
   prebuildProductionPageBrowserGraphs,
   shouldPrebuildProductionPageBrowserGraphs
 } from "./production-page-browser-graph-prebuild.js";
+import { PageModuleLoaderService } from "../route-renderer/page-loading/page-module-loader.js";
+import { renderSitemap } from "./sitemap.js";
+import { resolveSitemapLocations } from "./sitemap-routes.js";
+import { toEcopagesRouteInfo } from "../utils/ecopages-route-info.js";
+import { normalizePathname } from "../utils/path-pattern.js";
 const STATIC_SITE_GENERATOR_ERRORS = {
   ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy",
   unsupportedBodyType: (bodyType) => `Unsupported body type for static generation: ${bodyType}`,
@@ -46,6 +51,7 @@ class StaticSiteGenerator {
   routeModuleBuildCacheOverride;
   staticRenderCacheContext;
   forceFullStaticGeneration = false;
+  pageModuleLoader;
   /**
    * Creates the static-site generator for one app config.
    */
@@ -64,8 +70,9 @@ class StaticSiteGenerator {
     return this.appConfig.absolutePaths?.distDir ?? path.join(this.appConfig.rootDir, this.appConfig.distDir);
   }
   async shouldSkipStaticPageFile(filePath, routeRendererFactory) {
-    const module = await routeRendererFactory.getPageRenderer(filePath).loadPageModule(filePath);
-    return module.default?.cache === "dynamic";
+    const pageModule = await routeRendererFactory.getPageRenderer(filePath).loadPageModule(filePath);
+    const Page = pageModule.default;
+    return Page.cache === "dynamic";
   }
   shouldSkipStaticView(_routePath, view) {
     return view.cache === "dynamic";
@@ -88,6 +95,14 @@ class StaticSiteGenerator {
     fileSystem.ensureDir(this.getExportDir());
     fileSystem.write(path.join(this.getExportDir(), "robots.txt"), data);
   }
+  /**
+   * Writes the configured sitemap file to the export directory.
+   */
+  generateSitemap(locations, sitemap) {
+    const fileName = sitemap.fileName ?? "sitemap.xml";
+    fileSystem.ensureDir(this.getExportDir());
+    fileSystem.write(path.join(this.getExportDir(), fileName), renderSitemap(locations));
+  }
   /**
    * Returns whether the input path points at the root directory.
    */
@@ -116,7 +131,6 @@ class StaticSiteGenerator {
     return outputPath;
   }
   async writeStaticPageArtifact(options) {
-    options.activeStaticPathnames?.add(options.pathname);
     const directories = options.directories ?? this.getDirectories([options.pathname]);
     const renderedOutputPath = this.getOutputPath(options.pathname, directories);
     const routeModuleBuildCache = this.getRouteModuleBuildCache();
@@ -127,6 +141,8 @@ class StaticSiteGenerator {
       context: this.staticRenderCacheContext,
       force: this.forceFullStaticGeneration
     })) {
+      options.activeStaticPathnames?.add(options.pathname);
+      await options.onSuccessfulExport?.();
       appLogger.debug(`Skipped unchanged static page: ${options.debugLabel ?? options.pathname}`);
       return;
     }
@@ -135,15 +151,80 @@ class StaticSiteGenerator {
       return;
     }
     const outputPath = this.writeStaticOutput(options.pathname, contents, directories);
+    options.activeStaticPathnames?.add(options.pathname);
     if (options.sourceFile) {
-      routeModuleBuildCache.recordStaticRender({
-        filePath: options.sourceFile,
-        pathname: options.pathname,
-        sourceHash: fileSystem.hash(options.sourceFile),
-        renderedOutputPath: outputPath,
-        context: this.staticRenderCacheContext
-      });
+      try {
+        routeModuleBuildCache.recordStaticRender({
+          filePath: options.sourceFile,
+          pathname: options.pathname,
+          sourceHash: fileSystem.hash(options.sourceFile),
+          renderedOutputPath: outputPath,
+          context: this.staticRenderCacheContext
+        });
+      } catch (error) {
+        appLogger.debug(
+          `Failed to record static render cache for ${options.pathname}`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
     }
+    await options.onSuccessfulExport?.();
+  }
+  /**
+   * Marks a successfully exported pathname as sitemap-eligible when robots allow indexing.
+   *
+   * @remarks
+   * Fail-closed: metadata resolution errors omit the URL. `robots.index === false`
+   * also omits it. Eligibility is decided during generation, not by reloading modules
+   * after `afterStaticExport`.
+   */
+  async considerSitemapEligibility(input) {
+    if (!input.sitemapEligiblePathnames || !this.appConfig.sitemap?.enabled) {
+      return;
+    }
+    try {
+      const metadata = await input.resolveMetadata();
+      if (metadata.robots?.index === false) {
+        return;
+      }
+      input.sitemapEligiblePathnames.add(normalizePathname(input.pathname));
+    } catch (error) {
+      appLogger.debug(
+        `Sitemap eligibility skipped for ${input.pathname}; metadata resolution failed`,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  getPageModuleLoader(baseUrl) {
+    this.pageModuleLoader ??= new PageModuleLoaderService(this.appConfig, baseUrl);
+    return this.pageModuleLoader;
+  }
+  async resolveFilesystemPageMetadata(input) {
+    const loader = this.getPageModuleLoader(input.baseUrl);
+    const pageModule = await loader.resolvePageModule({
+      file: input.filePath,
+      importPageFileFn: (file) => input.routeRendererFactory.getPageRenderer(file).loadPageModule(file)
+    });
+    const { metadata } = await loader.resolvePageData({
+      pageModule,
+      routeOptions: {
+        file: input.filePath,
+        params: input.params
+      }
+    });
+    return metadata;
+  }
+  async resolveExplicitViewMetadata(input) {
+    if (!input.view.metadata) {
+      return this.appConfig.defaultMetadata;
+    }
+    const dynamicMetadata = await input.view.metadata({
+      params: input.params,
+      query: {},
+      props: input.props,
+      appConfig: this.appConfig
+    });
+    return { ...this.appConfig.defaultMetadata, ...dynamicMetadata };
   }
   pruneStaleStaticOutputs(activeStaticPathnames) {
     const removedOutputPaths = this.getRouteModuleBuildCache().pruneStaleRenderedOutputs(activeStaticPathnames);
@@ -155,11 +236,15 @@ class StaticSiteGenerator {
       }
     }
   }
-  async createFilesystemStaticContents(route, _baseUrl, routeRendererFactory, skipped) {
+  async createFilesystemStaticContents(input) {
     const {
-      templateRoute: { filePath },
-      params
-    } = route;
+      route: {
+        templateRoute: { filePath },
+        params
+      },
+      routeRendererFactory,
+      skipped
+    } = input;
     if (!routeRendererFactory) {
       throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
     }
@@ -187,8 +272,9 @@ class StaticSiteGenerator {
    * @remarks
    * Routes are rendered through the normal route renderer directly.
    */
-  async generateStaticPages(router, baseUrl, routeRendererFactory, skipped, activeStaticPathnames, preloadedRoutes) {
-    const routes = preloadedRoutes ?? await router.listStaticGenerationRoutes({ runtimeOrigin: baseUrl });
+  async generateStaticPages(input) {
+    const { router, baseUrl, routeRendererFactory, skipped, activeStaticPathnames, sitemapEligiblePathnames } = input;
+    const routes = input.preloadedRoutes ?? await router.listStaticGenerationRoutes({ runtimeOrigin: baseUrl });
     appLogger.debug(
       "Static Pages",
       routes.map((route) => route.requestUrl)
@@ -202,7 +288,27 @@ class StaticSiteGenerator {
           directories,
           debugLabel: route.requestUrl,
           activeStaticPathnames,
-          createContents: () => this.createFilesystemStaticContents(route, baseUrl, routeRendererFactory, skipped)
+          onSuccessfulExport: () => this.considerSitemapEligibility({
+            pathname: route.pathname,
+            sitemapEligiblePathnames,
+            resolveMetadata: () => {
+              if (!routeRendererFactory) {
+                throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+              }
+              return this.resolveFilesystemPageMetadata({
+                filePath: route.templateRoute.filePath,
+                params: route.params,
+                baseUrl,
+                routeRendererFactory
+              });
+            }
+          }),
+          createContents: () => this.createFilesystemStaticContents({
+            route,
+            baseUrl,
+            routeRendererFactory,
+            skipped
+          })
         });
       } catch (error) {
         appLogger.error(
@@ -220,7 +326,8 @@ class StaticSiteGenerator {
       routeRendererFactory: input.routeRendererFactory,
       staticRoutes: input.staticRoutes,
       force: input.force,
-      preserveExportDirectory: input.preserveExportDirectory
+      preserveExportDirectory: input.preserveExportDirectory,
+      routes: input.routes
     };
   }
   async invokeStaticExportHook(hook, context) {
@@ -244,8 +351,10 @@ class StaticSiteGenerator {
   }) {
     const skippedDynamicPages = [];
     const activeStaticPathnames = /* @__PURE__ */ new Set();
+    const sitemapEligiblePathnames = this.appConfig.sitemap?.enabled ? /* @__PURE__ */ new Set() : void 0;
     this.forceFullStaticGeneration = force;
     this.staticRenderCacheContext = createRouteModuleStaticRenderCacheContext(this.appConfig);
+    this.pageModuleLoader = void 0;
     if (!force) {
       this.getRouteModuleBuildCache().ensureIncrementalStaticGenerationContext(this.staticRenderCacheContext);
     }
@@ -253,6 +362,7 @@ class StaticSiteGenerator {
       clearProductionPageBrowserGraphSession(this.appConfig);
     }
     const routes = await router.listStaticGenerationRoutes({ runtimeOrigin: baseUrl });
+    const exportRoutes = routes.map((route) => toEcopagesRouteInfo(route));
     if (shouldBuildPagesUnifiedGraph()) {
       await ensurePagesUnifiedGraphBuilt({
         appConfig: this.appConfig,
@@ -267,7 +377,8 @@ class StaticSiteGenerator {
       routeRendererFactory,
       staticRoutes,
       force,
-      preserveExportDirectory
+      preserveExportDirectory,
+      routes: exportRoutes
     });
     await this.invokeStaticExportHook("beforeStaticExport", staticExportContext);
     try {
@@ -278,21 +389,23 @@ class StaticSiteGenerator {
         );
       }
       this.generateRobotsTxt();
-      await this.generateStaticPages(
+      await this.generateStaticPages({
         router,
         baseUrl,
         routeRendererFactory,
-        skippedDynamicPages,
+        skipped: skippedDynamicPages,
         activeStaticPathnames,
-        routes
-      );
+        preloadedRoutes: routes,
+        sitemapEligiblePathnames
+      });
       if (staticRoutes && staticRoutes.length > 0 && routeRendererFactory) {
-        await this.generateExplicitStaticPages(
+        await this.generateExplicitStaticPages({
           staticRoutes,
           routeRendererFactory,
-          skippedDynamicPages,
-          activeStaticPathnames
-        );
+          skipped: skippedDynamicPages,
+          activeStaticPathnames,
+          sitemapEligiblePathnames
+        });
       }
       if (preserveExportDirectory) {
         this.pruneStaleStaticOutputs(activeStaticPathnames);
@@ -305,6 +418,14 @@ class StaticSiteGenerator {
     } finally {
       await this.invokeStaticExportHook("afterStaticExport", staticExportContext);
     }
+    if (this.appConfig.sitemap?.enabled && sitemapEligiblePathnames) {
+      const locations = resolveSitemapLocations({
+        eligiblePathnames: [...sitemapEligiblePathnames],
+        sitemap: this.appConfig.sitemap,
+        baseUrl
+      });
+      this.generateSitemap(locations, this.appConfig.sitemap);
+    }
     if (skippedDynamicPages.length > 0) {
       appLogger.debug(
         `Skipped ${skippedDynamicPages.length} page(s) with cache: 'dynamic' (not supported in static generation)`,
@@ -312,24 +433,26 @@ class StaticSiteGenerator {
       );
     }
   }
-  /**
-   * Generates static pages from explicit static routes registered via app.static().
-   * These routes use eco.page views via loader functions for HMR support.
-   */
-  async generateExplicitStaticPages(staticRoutes, routeRendererFactory, skipped, activeStaticPathnames) {
+  async generateExplicitStaticPages(input) {
     appLogger.debug(
       "Generating explicit static routes",
-      staticRoutes.map((r) => r.path)
+      input.staticRoutes.map((r) => r.path)
     );
-    for (const route of staticRoutes) {
+    for (const route of input.staticRoutes) {
       try {
         const mod = await route.loader();
         const view = mod.default;
         if (this.shouldSkipStaticView(route.path, view)) {
-          skipped?.push(route.path);
+          input.skipped?.push(route.path);
           continue;
         }
-        await this.generateExplicitStaticRoute(route.path, view, routeRendererFactory, activeStaticPathnames);
+        await this.generateExplicitStaticRoute({
+          routePath: route.path,
+          view,
+          routeRendererFactory: input.routeRendererFactory,
+          activeStaticPathnames: input.activeStaticPathnames,
+          sitemapEligiblePathnames: input.sitemapEligiblePathnames
+        });
       } catch (error) {
         appLogger.error(
           `Error generating explicit static page for ${route.path}:`,
@@ -345,8 +468,13 @@ class StaticSiteGenerator {
     }
     return path.isAbsolute(sourceFile) ? sourceFile : path.join(this.appConfig.rootDir, sourceFile);
   }
-  async generateExplicitStaticRoute(routePath, view, routeRendererFactory, activeStaticPathnames) {
-    const { renderer, routeEntries } = await this.planExplicitStaticRoute(routePath, view, routeRendererFactory);
+  async generateExplicitStaticRoute(input) {
+    const { routePath, view, routeRendererFactory, activeStaticPathnames, sitemapEligiblePathnames } = input;
+    const { renderer, routeEntries } = await this.planExplicitStaticRoute({
+      routePath,
+      view,
+      routeRendererFactory
+    });
     const sourceFile = this.resolveExplicitViewSourceFile(view);
     for (const { pathname, params } of routeEntries) {
       await this.writeStaticPageArtifact({
@@ -354,37 +482,59 @@ class StaticSiteGenerator {
         sourceFile,
         debugLabel: pathname,
         activeStaticPathnames,
-        createContents: () => this.createExplicitStaticContents(routePath, view, params, routeRendererFactory, renderer)
+        onSuccessfulExport: () => this.considerSitemapEligibility({
+          pathname,
+          sitemapEligiblePathnames,
+          resolveMetadata: async () => {
+            const { props } = await prepareExplicitStaticRender({
+              routePath,
+              view,
+              params,
+              appConfig: this.appConfig,
+              runtimeOrigin: this.appConfig.baseUrl,
+              routeRendererFactory,
+              errors: STATIC_SITE_GENERATOR_ERRORS
+            });
+            return this.resolveExplicitViewMetadata({ view, params, props });
+          }
+        }),
+        createContents: () => this.createExplicitStaticContents({
+          routePath,
+          view,
+          params,
+          routeRendererFactory,
+          renderer
+        })
       });
       appLogger.debug(`Generated static page: ${pathname}`);
     }
   }
-  async planExplicitStaticRoute(routePath, view, routeRendererFactory) {
+  async planExplicitStaticRoute(input) {
     const { renderer } = await prepareExplicitStaticRender({
-      routePath,
-      view,
+      routePath: input.routePath,
+      view: input.view,
       params: {},
       appConfig: this.appConfig,
       runtimeOrigin: this.appConfig.baseUrl,
-      routeRendererFactory,
+      routeRendererFactory: input.routeRendererFactory,
       errors: STATIC_SITE_GENERATOR_ERRORS
     });
     return {
       renderer,
-      routeEntries: await this.listExplicitStaticRouteEntries(routePath, view)
+      routeEntries: await this.listExplicitStaticRouteEntries(input.routePath, input.view)
     };
   }
-  async createExplicitStaticContents(routePath, view, params, routeRendererFactory, renderer) {
+  async createExplicitStaticContents(input) {
     const { props, view: renderableView } = await prepareExplicitStaticRender({
-      routePath,
-      view,
-      params,
+      routePath: input.routePath,
+      view: input.view,
+      params: input.params,
       appConfig: this.appConfig,
       runtimeOrigin: this.appConfig.baseUrl,
-      routeRendererFactory,
+      routeRendererFactory: input.routeRendererFactory,
       errors: STATIC_SITE_GENERATOR_ERRORS
     });
-    const response = await renderer.renderToResponse(renderableView, props, {});
+    const response = await input.renderer.renderToResponse(renderableView, props, {});
     return response.text();
   }
   async listExplicitStaticRouteEntries(routePath, view) {