@escape-game-over/atlas 0.1.24 → 0.1.26

package/src/project.ts

@@ -8,16 +8,15 @@ import type {
 } from "./config.ts";
 import type {
     BaseCatalog,
-    MessageOverlayKeys,
     OverrideCatalog,
     ValidateOverrideCatalog,
 } from "./i18n/define.ts";
-import type { SiteIcon, SiteVerification, ThemeColor } from "./meta/index.ts";
+import type { ImageAsset } from "./image.ts";
+import type { SiteVerification, ThemeColor } from "./meta/index.ts";
 import type {
-    RouteOverlayKeys,
-    RouteOverlayShape,
-    RouteOverrideMap,
+    RouteOverrides,
     RouteRegistry,
+    ValidateOverrideSlugDepth,
 } from "./routes/define.ts";
 import type { NoExcessKeys, StringKeys } from "./types.ts";
 import type { HttpsUrl, ValidSiteUrl } from "./url.ts";
@@ -60,7 +59,7 @@ export interface ProjectInput<L extends string, Routes> {
      * from the home page, so a per-page icon would change the browser tab and
      * nothing else.
      */
-    readonly icon: SiteIcon;
+    readonly icon: ImageAsset;
     /**
      * Ownership tokens from Search Console, Bing Webmaster Tools and the like.
      *
@@ -131,7 +130,7 @@ export interface ProjectInput<L extends string, Routes> {
      */
     readonly overrideMessages: OverrideCatalog<L>;
     /** Slug retranslations and page on/off switches. See `overrideMessages`. */
-    readonly overrideRoutes: RouteOverrideMap<L, Routes>;
+    readonly overrideRoutes: RouteOverrides<Routes, L>;
 }
 
 /**
@@ -148,67 +147,88 @@ export interface ProjectInput<L extends string, Routes> {
  *  - unknown top-level fields are rejected, so a typo cannot sit there unread;
  *  - locales named anywhere must be ones the site ships and this project enabled.
  */
+/** Everything a project file must satisfy; see `defineSite`. */
+export type ProjectChecks<
+    L extends string,
+    Catalog,
+    Routes,
+    T extends ProjectInput<L, Routes>,
+> = NoExcessKeys<T, keyof ProjectInput<L, Routes>> & {
+    readonly url: ValidSiteUrl<T["url"]>;
+    readonly overrideRouting?: {
+        readonly defaultLocale?: T["enabledLocales"][number];
+        // Against `enabledLocales` rather than the site's list: a
+        // segment spelled for a language this deployment does not
+        // publish is a word that appears in no URL it builds. Mapped
+        // over the keys written, for the reason `overrideLocaleMeta`
+        // below is.
+        readonly pageSegmentByLocale?: {
+            readonly [K in StringKeys<
+                NonNullable<T["overrideRouting"]>["pageSegmentByLocale"]
+            >]: K extends T["enabledLocales"][number]
+                ? string
+                : LocaleNotEnabled<K>;
+        };
+    };
+    // Two separate checks on the same field: the keys must be messages
+    // the default catalog declares, and the locales inside each must be
+    // ones this project publishes. Copy written for a locale left out of
+    // `enabledLocales` is never built, so it is always a mistake — a
+    // locale removed from the list, or a project copied from another.
+    readonly overrideMessages: NoExcessKeys<
+        T["overrideMessages"],
+        StringKeys<Catalog>
+    > & {
+        readonly [K in StringKeys<T["overrideMessages"]>]: {
+            readonly [L in StringKeys<
+                T["overrideMessages"][K]
+            >]: L extends T["enabledLocales"][number]
+                ? T["overrideMessages"][K][L]
+                : LocaleNotEnabled<L>;
+        };
+    };
+    readonly overrideRoutes: NoExcessKeys<
+        T["overrideRoutes"],
+        StringKeys<Routes>
+    >;
+    // Nested, so that `dir` is rejected inside each locale's entry.
+    // Declaring the field as `Pick<LocaleMeta, "label">` is not enough:
+    // `T` is *inferred* from the literal, so a stray `dir` just becomes
+    // part of `T` and there is no fresh object for excess-property
+    // checking to fire on.
+    readonly overrideLocaleMeta?: {
+        readonly [K in StringKeys<
+            T["overrideLocaleMeta"]
+        >]: K extends T["enabledLocales"][number]
+            ? NoExcessKeys<T["overrideLocaleMeta"][K], keyof LocaleMetaOverride>
+            : LocaleNotEnabled<K>;
+    };
+};
+
+/** The same checks that map the whole override objects, in parameter position. */
+export type ProjectOverrideChecks<
+    L extends string,
+    Catalog,
+    Routes,
+    T extends ProjectInput<L, Routes>,
+> = {
+    readonly overrideMessages: ValidateOverrideCatalog<
+        T["overrideMessages"],
+        Catalog,
+        L
+    >;
+    readonly overrideRoutes: ValidateOverrideSlugDepth<
+        Routes,
+        T["overrideRoutes"]
+    >;
+};
+
 export function defineProject<
     const C extends SiteConfigShape,
     const Catalog extends BaseCatalog<LocalesOf<C>>,
     const Routes extends RouteRegistry<LocalesOf<C>>,
     const T extends ProjectInput<LocalesOf<C>, Routes> &
-        NoExcessKeys<T, keyof ProjectInput<LocalesOf<C>, Routes>> & {
-            readonly url: ValidSiteUrl<T["url"]>;
-            readonly overrideRouting?: {
-                readonly defaultLocale?: T["enabledLocales"][number];
-                // Against `enabledLocales` rather than the site's list: a
-                // segment spelled for a language this deployment does not
-                // publish is a word that appears in no URL it builds. Mapped
-                // over the keys written, for the reason `overrideLocaleMeta`
-                // below is.
-                readonly pageSegmentByLocale?: {
-                    readonly [K in StringKeys<
-                        NonNullable<T["overrideRouting"]>["pageSegmentByLocale"]
-                    >]: K extends T["enabledLocales"][number]
-                        ? string
-                        : LocaleNotEnabled<K>;
-                };
-            };
-            // Two separate checks on the same field: the keys must be messages
-            // the default catalog declares, and the locales inside each must be
-            // ones this project publishes. Copy written for a locale left out of
-            // `enabledLocales` is never built, so it is always a mistake — a
-            // locale removed from the list, or a project copied from another.
-            readonly overrideMessages: MessageOverlayKeys<
-                Catalog,
-                T["overrideMessages"]
-            > & {
-                readonly [K in StringKeys<T["overrideMessages"]>]: {
-                    readonly [L in StringKeys<
-                        T["overrideMessages"][K]
-                    >]: L extends T["enabledLocales"][number]
-                        ? T["overrideMessages"][K][L]
-                        : LocaleNotEnabled<L>;
-                };
-            };
-            // Shared with `defineRouteOverrides` rather than restated — see
-            // `RouteOverlayKeys` for why the two must not drift.
-            readonly overrideRoutes: RouteOverlayKeys<
-                Routes,
-                T["overrideRoutes"]
-            >;
-            // Nested, so that `dir` is rejected inside each locale's entry.
-            // Declaring the field as `Pick<LocaleMeta, "label">` is not enough:
-            // `T` is *inferred* from the literal, so a stray `dir` just becomes
-            // part of `T` and there is no fresh object for excess-property
-            // checking to fire on.
-            readonly overrideLocaleMeta?: {
-                readonly [K in StringKeys<
-                    T["overrideLocaleMeta"]
-                >]: K extends T["enabledLocales"][number]
-                    ? NoExcessKeys<
-                          T["overrideLocaleMeta"][K],
-                          keyof LocaleMetaOverride
-                      >
-                    : LocaleNotEnabled<K>;
-            };
-        },
+        ProjectChecks<LocalesOf<C>, Catalog, Routes, T>,
 >(
     // The first three are read for their types: they are how the locale union,
     // the message keys and the route ids are inferred without type arguments.
@@ -220,16 +240,7 @@ export function defineProject<
     // type in a constraint makes one unrelated mistake fail the argument
     // outright — TypeScript then reports at this call instead of on the line
     // that is wrong.
-    project: T & {
-        readonly overrideMessages: ValidateOverrideCatalog<
-            T["overrideMessages"],
-            Catalog,
-            LocalesOf<C>
-        >;
-        // The same alias `defineRouteOverrides` uses, so writing the overlay
-        // inline is never the weaker option.
-        readonly overrideRoutes: RouteOverlayShape<Routes, T["overrideRoutes"]>;
-    }
+    project: T & ProjectOverrideChecks<LocalesOf<C>, Catalog, Routes, T>
 ): T {
     // Checked at runtime as well as in the type, because the type is not always
     // what fails first. An Astro config is *evaluated* before `astro check`

package/src/routes/define.ts

@@ -1,5 +1,5 @@
 import type { LocalesOf, SiteConfigShape } from "../config.ts";
-import type { IsNever, IsoDate, NoExcessKeys, StringKeys } from "../types.ts";
+import type { IsNever, IsoDate, StringKeys } from "../types.ts";
 
 export type ChangeFreq =
     | "always"
@@ -92,7 +92,7 @@ interface SlugDepthMismatch<Id extends string, L extends string> {
  * here: in parameter position one bad slug widens `T` and every *other* route
  * then reports as malformed.
  */
-type ValidateSlugDepth<T> = {
+export type ValidateSlugDepth<T> = {
     readonly [K in StringKeys<T>]: {
         // Every key of the route is carried through unchanged, and only
         // `slugByLocale` is rewritten. Mapping the whole shape rather than
@@ -149,8 +149,12 @@ export interface RouteOverride<L extends string> {
     readonly sitemap?: RouteSitemap;
 }
 
-export type RouteOverrideMap<L extends string, Base> = Readonly<
-    Partial<Record<StringKeys<Base>, RouteOverride<L>>>
+/**
+ * One project's route overrides, for an overlay kept in its own file:
+ * `{ … } as const satisfies RouteOverrides<typeof defaultRoutes, EnabledLocale>`.
+ */
+export type RouteOverrides<Routes, L extends string> = Readonly<
+    Partial<Record<StringKeys<Routes>, RouteOverride<L>>>
 >;
 
 /** The slug a registry declares for route `K`, if it declares one. */
@@ -253,46 +257,6 @@ export type ValidateOverrideSlugDepth<Base, T> = {
     };
 };
 
-/**
- * Everything a route overlay must satisfy — and the only place it is stated.
- *
- * Two entry points accept an overlay: `defineRouteOverrides`, for one written in
- * its own file, and `defineProject`, for one written inline. They must check it
- * identically, or whichever has the extra check quietly becomes the safer place
- * to write overrides. That is not hypothetical: the depth rule below lived in
- * `defineRouteOverrides` alone for a while, and the inline form was weaker for
- * it with nothing to say so.
- *
- * **Add new overlay checks here, never at a call site.** Both entry points name
- * these two aliases, so anything added reaches both.
- *
- * Split in two because the positions are not interchangeable. Excess keys belong
- * in the *constraint*, where a wrong id reports on that key. The depth rule
- * belongs in the *parameter*: it maps the whole object, and a whole-object
- * mapped type in constraint position makes one unrelated mistake fail the
- * argument outright, moving the error off the offending line.
- */
-export type RouteOverlayKeys<Base, T> = NoExcessKeys<T, StringKeys<Base>>;
-
-/** @see {@link RouteOverlayKeys} — the parameter-position half. */
-export type RouteOverlayShape<Base, T> = ValidateOverrideSlugDepth<Base, T>;
-
-/**
- * Declares a project's route overlay: retranslated slugs and on/off switches.
- *
- * Enforced at compile time: unknown route ids are rejected, a slug override
- * cannot invent a locale the site does not ship, and no override may leave a
- * route sitting at different depths in different languages.
- */
-export function defineRouteOverrides<
-    const C extends SiteConfigShape,
-    const Base extends RouteRegistry<LocalesOf<C>>,
-    const T extends RouteOverrideMap<LocalesOf<C>, Base> &
-        RouteOverlayKeys<Base, T>,
->(_config: C, _base: Base, overrides: T & RouteOverlayShape<Base, T>): T {
-    return overrides;
-}
-
 /** The minimum `EnabledRouteIdFor` needs to know about a registry. */
 export type EnabledFlagSource = Readonly<
     Record<string, { readonly enabled: boolean }>

package/src/routes/resolve.ts

@@ -238,7 +238,7 @@ export function listRouteEntries<L extends string, Id extends string>(
         // until the day someone turns the page on.
         //
         // A backstop rather than the main check: `defineRoutes` and
-        // `defineRouteOverrides` both reject this at compile time. What survives
+        // `defineProject` both reject this at compile time. What survives
         // to here is a slug that was typed as plain `string` — computed, or read
         // from an env var — where the literal comparison passed vacuously.
         const depth = segmentCount(route.slug);

package/src/site/api.ts

@@ -11,11 +11,9 @@ import type {
     ValidateRedirectTargets,
 } from "../redirects.ts";
 import type { RobotsGroup } from "../robots.ts";
-import type { RouteEntry } from "../routes/resolve.ts";
 import type { Sitemap } from "../sitemap.ts";
 import type { HttpsUrl, UrlPath } from "../url.ts";
 import type {
-    Alternate,
     Crumb,
     LinkOptions,
     LocaleLink,
@@ -209,11 +207,8 @@ export interface Site<
      */
     fileUrl(path: PublicFilePath): HttpsUrl;
 
-    /** One entry per published locale, for `hreflang` tags. */
-    alternatesFor(id: RouteId, options?: LinkOptions): readonly Alternate<L>[];
-
     /**
-     * The same, ready to render as a language switcher: each locale's own label
+     * One link per published locale, ready to render as a language switcher: each locale's own label
      * and writing direction, and which one the reader is on.
      *
      * Switching language keeps the page — `about` stays `about`, so `/about-us`
@@ -257,15 +252,10 @@ export interface Site<
      */
     readonly orphanSegments: readonly string[];
 
-    /** Every (route, locale) pair this build emits. Throws on colliding URLs. */
-    readonly entries: readonly RouteEntry<L, RouteId>[];
-
     /**
-     * Every page to generate, as `{ params, props }` for a catch-all route.
-     *
-     * `param` is the name of the rest parameter in the router's filename, e.g.
-     * `"route"` for `[...route].astro`. The root path is emitted as `undefined`,
-     * which is what such routers expect.
+     * Every page to generate, for `src/pages/[...route].astro`:
+     * `export const getStaticPaths = site.getStaticPaths`. The root path is
+     * emitted as `undefined`, which is what a rest parameter expects.
      *
      * When every locale is prefixed nothing owns `/`, and no page is generated
      * for it: `redirects()` claims it with a 301 to the default locale's root
@@ -275,7 +265,7 @@ export interface Site<
      *
      * Returns a fresh mutable array, because SSG routers typically demand one.
      */
-    staticPaths(param: string): StaticPath<L, RouteId>[];
+    getStaticPaths(): StaticPath<L, RouteId>[];
 
     /**
      * The rendered sitemap: `entry` is the file to submit, `files` is everything
@@ -291,14 +281,7 @@ export interface Site<
      */
     robots(groups?: readonly RobotsGroup[]): GeneratedFile;
 
-    /**
-     * Where this site's `llms.txt` is published, or `undefined` if the config
-     * turned it off.
-     *
-     * Public because it is a promise made in two places at once: every page's
-     * head links to this URL, and something has to write a file there. It is
-     * what `siteRoutes` checks so the two cannot disagree.
-     */
+    /** Where this site's `llms.txt` is published, or `undefined` when the config turned it off. */
     readonly llmsUrl: HttpsUrl | undefined;
 
     /**
@@ -364,18 +347,9 @@ export interface Site<
 }
 
 /** The routes a given site builds, read back off the site's own type. */
-export type RouteIdOf<S> =
+type RouteIdOf<S> =
     S extends Site<infer _L, infer _Catalog, infer Id> ? Id : never;
 
-/**
- * `T` when this site builds route `Id`, `never` when it does not.
- *
- * For a value that only makes sense alongside an optional page — a field that
- * should vanish rather than sit there unread once the page is switched off.
- */
-export type WhenEnabled<S, Id extends string, T> =
-    Id extends RouteIdOf<S> ? T : never;
-
 /**
  * A `T` for every route this site builds — and only those.
  *

package/src/site/create.ts

@@ -13,12 +13,12 @@ import type { GeneratedFile } from "../file.ts";
 import type { PublicFilePath } from "../files.ts";
 import { type BaseCatalog, mergeCatalog } from "../i18n/define.ts";
 import { createTranslateFactory } from "../i18n/translate.ts";
+import type { ImageAsset } from "../image.ts";
 import { buildLlms, type LlmsItem, type LlmsSection } from "../llms.ts";
 import {
     buildMeta,
     buildNotFoundMeta,
     resolveShareImage,
-    type SiteIcon,
 } from "../meta/index.ts";
 import type { ProjectInput } from "../project.ts";
 import {
@@ -171,9 +171,6 @@ export function createSite<
             | undefined,
     };
 
-    // Declared config, not a call to `llms()`: the head is built page by page
-    // and cannot know whether some other module generated the file, whereas
-    // stating `llms` in the site config is a promise that one is published.
     const llmsName =
         (config_.llms === false ? undefined : config_.llms?.name) ?? "llms.txt";
     // Annotated, not inferred: a template expression widens to `string` unless
@@ -291,15 +288,16 @@ export function createSite<
         entries.map((entry) => entry.path)
     );
 
-    function staticPaths(param: string): StaticPath<L, RouteId>[] {
+    function getStaticPaths(): StaticPath<L, RouteId>[] {
         const paths: StaticPath<L, RouteId>[] = entries.map((entry) => ({
             params: {
-                [param]: entry.path === "/" ? undefined : entry.path.slice(1),
+                route: entry.path === "/" ? undefined : entry.path.slice(1),
             },
             props: {
                 routeId: entry.routeId,
                 locale: entry.locale,
                 page: entry.page,
+                pages: resolved[entry.routeId]?.pages ?? 1,
             },
         }));
 
@@ -362,7 +360,7 @@ export function createSite<
      * a bad icon still fails the build, at the first page that renders.
      */
     let iconChecked = false;
-    function checkedIcon(): SiteIcon {
+    function checkedIcon(): ImageAsset {
         if (iconChecked) return project.icon;
         if (project.icon.width !== project.icon.height) {
             throw new Error(
@@ -795,10 +793,8 @@ export function createSite<
         fileUrl,
         breadcrumbFor,
         orphanSegments,
-        alternatesFor,
         localeLinksFor,
-        entries,
-        staticPaths,
+        getStaticPaths,
         sitemap,
         robots,
         llms,

package/src/site/define.ts

@@ -0,0 +1,120 @@
+import {
+    defineSiteConfig,
+    type LocalesOf,
+    type SiteConfigChecks,
+    type SiteConfigShape,
+} from "../config.ts";
+import {
+    type BaseCatalog,
+    defineMessages,
+    type NoExtraLocales,
+    type ValidateBase,
+} from "../i18n/define.ts";
+import {
+    defineProject,
+    type ProjectChecks,
+    type ProjectInput,
+    type ProjectOverrideChecks,
+} from "../project.ts";
+import {
+    defineRoutes,
+    type RouteRegistry,
+    type ValidateSlugDepth,
+} from "../routes/define.ts";
+import {
+    type FamilyMemberInput,
+    type FamilyOptions,
+    routeFamily,
+} from "../routes/family.ts";
+import { createSite } from "./create.ts";
+
+/**
+ * A site: which languages exist and how URLs are shaped, and everything built
+ * on that, as methods — so no other file restates the config.
+ *
+ * ```ts
+ * // config/site.config.ts
+ * export const atlas = defineSite({ locales: {…}, defaultRouting: {…} });
+ *
+ * // config/routes.ts, messages.ts, projects/<name>/project.ts, site.ts
+ * const rooms = atlas.family("rooms", ROOMS, { enabled: true });
+ * export const defaultRoutes = atlas.routes({ ...rooms, home: {…} });
+ * export const defaultMessages = atlas.messages({…});
+ * export default atlas.project(defaultMessages, defaultRoutes, {…});
+ * export const site = atlas.site(defaultMessages, defaultRoutes, project);
+ * ```
+ *
+ * Every check each step makes is the same one it makes as a function: a typo'd
+ * key, a dropped placeholder or a slug at the wrong depth is an error on the
+ * line that is wrong.
+ */
+export function defineSite<
+    const C extends SiteConfigShape & SiteConfigChecks<C>,
+>(input: C) {
+    const config = defineSiteConfig(input as never) as C;
+    type L = LocalesOf<C>;
+
+    return {
+        config,
+
+        /** A route per member, under one prefix: `rooms/red-room` for `rooms`. */
+        family<
+            const Prefix extends string,
+            const Members extends readonly FamilyMemberInput<L>[],
+            const Options extends FamilyOptions<L> = Record<string, never>,
+        >(
+            prefix: Prefix,
+            members: Members,
+            options?: Options
+        ): ReturnType<typeof routeFamily<C, Prefix, Members, Options>> {
+            return routeFamily(config, prefix, members, options);
+        },
+
+        /** The route table every project starts from. */
+        routes<const T extends RouteRegistry<L>>(
+            routes: T & ValidateSlugDepth<T>
+        ): T {
+            return defineRoutes(config, routes as never) as T;
+        },
+
+        /** The copy every project starts from, in every locale. */
+        messages<const T extends BaseCatalog<L>>(
+            catalog: T & ValidateBase<T> & NoExtraLocales<T, L>
+        ): T {
+            return defineMessages(config, catalog as never) as T;
+        },
+
+        /** One deployment: what differs from the defaults. */
+        project<
+            const Catalog extends BaseCatalog<L>,
+            const Routes extends RouteRegistry<L>,
+            const T extends ProjectInput<L, Routes> &
+                ProjectChecks<L, Catalog, Routes, T>,
+        >(
+            messages: Catalog,
+            routes: Routes,
+            project: T & ProjectOverrideChecks<L, Catalog, Routes, T>
+        ): T {
+            return defineProject(
+                config,
+                messages,
+                routes,
+                project as never
+            ) as T;
+        },
+
+        /** The API every page reads, wired for one project. */
+        site<
+            const Catalog extends BaseCatalog<L>,
+            const Routes extends RouteRegistry<L>,
+            const Published extends L,
+            const P extends ProjectInput<L, Routes>,
+        >(
+            messages: Catalog,
+            routes: Routes,
+            project: P & { readonly enabledLocales: readonly Published[] }
+        ): ReturnType<typeof createSite<C, Catalog, Routes, Published, P>> {
+            return createSite(config, messages, routes, project);
+        },
+    };
+}

package/src/site/index.ts

@@ -3,8 +3,8 @@
  *
  * Three files, along the seam between what the API *is* and what builds it:
  *
- * - `api.ts` — the `Site` interface, and the types read back off it
- *   (`RouteIdOf`, `PerRoute`, `WhenEnabled`). The half worth reading.
+ * - `api.ts` — the `Site` interface, and `PerRoute`, read back off it. The
+ *   half worth reading.
  * - `page.ts` — one page's vocabulary: what a view is handed and what it
  *   returns. Nothing here mentions a route registry.
  * - `create.ts` — `createSite`, the closure that satisfies the interface. Its
@@ -15,11 +15,8 @@
 export type {
     LlmsOptions,
     PerRoute,
-    RouteIdOf,
     Site,
-    WhenEnabled,
 } from "./api.ts";
-export { createSite } from "./create.ts";
 export type {
     Alternate,
     Crumb,

package/src/site/page.ts

@@ -40,11 +40,13 @@ export type PageProps<L extends string, Id extends string> = {
      * it needs no guard.
      */
     readonly page: number;
+    /** How many pages this route's list runs to; `1` for a route that does not paginate. */
+    readonly pages: number;
 };
 
-/** One `{ params, props }` pair, shaped for a static-site router. */
+/** One `{ params, props }` pair for `[...route].astro`. */
 export type StaticPath<L extends string, Id extends string> = {
-    readonly params: Readonly<Record<string, string | undefined>>;
+    readonly params: { readonly route: string | undefined };
     readonly props: PageProps<L, Id>;
 };
 

package/src/sitemap.ts

@@ -38,12 +38,6 @@ export interface SitemapConfig {
     readonly entryLimit?: number;
 }
 
-/** One `{ params, props }` pair for a sitemap file, shaped for a static router. */
-export type SitemapStaticPath = {
-    readonly params: Readonly<Record<string, string>>;
-    readonly props: { readonly file: GeneratedFile };
-};
-
 export interface Sitemap {
     /**
      * The file to submit and to reference from `robots.txt`.
@@ -55,33 +49,6 @@ export interface Sitemap {
     readonly entry: GeneratedFile;
     /** Every file that must be served, `entry` included. */
     readonly files: readonly GeneratedFile[];
-
-    /**
-     * Every file to generate, as `{ params, props }` for a dynamic route.
-     *
-     * `param` is the name of the parameter in the router's filename, e.g.
-     * `"sitemap"` for `[sitemap].ts`. One route therefore serves the single
-     * sitemap or the index plus its parts, without the caller knowing which
-     * case it is in.
-     *
-     * Returns a fresh mutable array, because SSG routers typically demand one.
-     */
-    staticPaths(param: string): SitemapStaticPath[];
-}
-
-function toSitemap(
-    entry: GeneratedFile,
-    files: readonly GeneratedFile[]
-): Sitemap {
-    return {
-        entry,
-        files,
-        staticPaths: (param) =>
-            files.map((file) => ({
-                params: { [param]: file.name },
-                props: { file },
-            })),
-    };
 }
 
 export interface SitemapInput<L extends string, Id extends string> {
@@ -235,7 +202,7 @@ export function buildSitemap<L extends string, Id extends string>(
 
     if (chunks.length <= 1) {
         const only = file(input.siteUrl, input.name, urlset(included));
-        return toSitemap(only, [only]);
+        return { entry: only, files: [only] };
     }
 
     const parts = chunks.map((entries, index) =>
@@ -253,5 +220,5 @@ export function buildSitemap<L extends string, Id extends string>(
         )
     );
 
-    return toSitemap(index, [index, ...parts]);
+    return { entry: index, files: [index, ...parts] };
 }