@escape-game-over/atlas 0.1.1

package/src/site/create.ts

@@ -0,0 +1,660 @@
+import {
+    type LocaleMeta,
+    type LocalesOf,
+    mergeLocaleMeta,
+    type SiteConfigShape,
+} from "../config.ts";
+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 { 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 {
+    buildRedirects,
+    type RedirectRule,
+    type ResolvedRedirect,
+    statusFor,
+} from "../redirects.ts";
+import { buildRobots, type RobotsGroup } from "../robots.ts";
+import type {
+    EnabledRouteIdFor,
+    OrphanSectionPrefixOf,
+    RouteRegistry,
+    SectionPrefixOf,
+} from "../routes/define.ts";
+import {
+    buildPath,
+    listRouteEntries,
+    mergeRoutes,
+    type PathContext,
+    pagePath,
+    type RouteEntry,
+    slugFor,
+} from "../routes/resolve.ts";
+import { buildSitemap, type Sitemap } from "../sitemap.ts";
+import type { StringKeys } from "../types.ts";
+import {
+    absoluteUrl,
+    type HttpsUrl,
+    isHttpsUrl,
+    joinUrl,
+    type UrlPath,
+} from "../url.ts";
+import type { LlmsOptions, Site } from "./api.ts";
+import type {
+    Alternate,
+    Crumb,
+    LinkOptions,
+    LocaleLink,
+    PageContent,
+    PageMeta,
+    StaticPath,
+} from "./page.ts";
+
+function decorate(path: UrlPath, options: LinkOptions | undefined): UrlPath {
+    if (options === undefined) return path;
+    const query = options.query
+        ? new URLSearchParams(options.query).toString()
+        : "";
+    const hash = options.hash === undefined ? "" : `#${options.hash}`;
+    return `${path}${query === "" ? "" : `?${query}`}${hash}`;
+}
+
+/**
+ * Turns a site config, its base data and one project overlay into the API the
+ * pages use.
+ *
+ * This is the only wiring a consuming project writes: the merging, slug
+ * fallbacks, URL building, translation and sitemap all come back ready to use.
+ */
+export function createSite<
+    const C extends SiteConfigShape,
+    const Catalog extends BaseCatalog<LocalesOf<C>>,
+    const Routes extends RouteRegistry<LocalesOf<C>>,
+    // Inferred from `project.enabledLocales` as its own parameter rather than
+    // read back as `P["enabledLocales"][number]`: that indexed access resolves
+    // through the constraint's `readonly L[]` and collapses to `string`, which
+    // silently un-types every locale the API accepts.
+    const Published extends LocalesOf<C>,
+    const P extends ProjectInput<LocalesOf<C>, Routes>,
+>(
+    config_: C,
+    messages: Catalog,
+    routes: Routes,
+    // `Published` is named in the *parameter*, not only in `P`'s constraint:
+    // a type parameter mentioned nowhere an argument reaches has nothing to
+    // infer from and silently falls back to its constraint — here the whole
+    // locale universe, which is the bug this was meant to fix.
+    project: P & { readonly enabledLocales: readonly Published[] }
+): Site<
+    Published,
+    Catalog,
+    EnabledRouteIdFor<Routes, P["overrideRoutes"]> & StringKeys<Routes>,
+    SectionPrefixOf<Routes, P["overrideRoutes"]>,
+    OrphanSectionPrefixOf<Routes, P["overrideRoutes"]>
+> {
+    // The locales this *project* publishes, not the universe the site config
+    // declares. The runtime has always used the narrow set — `locales` below is
+    // `project.enabledLocales` — but the type used to be the wide one, so
+    // `pathFor("home", "el-GR")` type-checked on a build with no Greek pages and
+    // returned a URL that was never generated.
+    type L = Published;
+    type RouteId = EnabledRouteIdFor<Routes, P["overrideRoutes"]> &
+        StringKeys<Routes>;
+
+    const locales = project.enabledLocales as readonly L[];
+    const defaultLocale = (project.overrideRouting?.defaultLocale ??
+        config_.defaultRouting.defaultLocale) as L;
+    const prefixDefaultLocale =
+        project.overrideRouting?.prefixDefaultLocale ??
+        config_.defaultRouting.prefixDefaultLocale;
+
+    // Checks that types cannot express, run once at build time.
+    if (locales.length === 0) {
+        throw new Error("A project must publish at least one locale.");
+    }
+    if (new Set(locales).size !== locales.length) {
+        throw new Error("A project lists a locale twice.");
+    }
+    // Backstop for a URL typed as plain `string` — an env var, say — where the
+    // compile-time checks in `defineProject` pass vacuously.
+    if (project.url.endsWith("/")) {
+        throw new Error(
+            `Project "url" must not end with a slash: ${project.url}`
+        );
+    }
+    if (!isHttpsUrl(project.url)) {
+        throw new Error(
+            `Project "url" must start with https://: ${project.url}`
+        );
+    }
+    if (!locales.includes(defaultLocale)) {
+        throw new Error(
+            `defaultLocale "${defaultLocale}" is not among this project's locales.`
+        );
+    }
+
+    // Captured once, after the guard above has narrowed it. Everything absolute
+    // this file builds is a template on this value, so they all inherit
+    // `https://` without a check of their own — and a local const keeps the
+    // narrowing inside the closures below, which a property access would not.
+    const siteUrl = project.url;
+
+    const localeMeta = mergeLocaleMeta<L>(
+        config_.locales as Readonly<Record<L, LocaleMeta>>,
+        project.overrideLocaleMeta,
+        locales
+    );
+    const pathContext: PathContext<L> = {
+        defaultLocale,
+        prefixDefaultLocale,
+        pageSegment:
+            project.overrideRouting?.pageSegment ??
+            config_.defaultRouting.pageSegment ??
+            "page",
+        pageSegmentByLocale: (project.overrideRouting?.pageSegmentByLocale ??
+            config_.defaultRouting.pageSegmentByLocale) as
+            | Readonly<Partial<Record<L, string>>>
+            | 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
+    // something contextually asks for the narrower type.
+    const llmsUrl: HttpsUrl | undefined =
+        config_.llms === false ? undefined : joinUrl(siteUrl, `/${llmsName}`);
+
+    const catalog = mergeCatalog<L>(messages, project.overrideMessages);
+    const translateFactory = createTranslateFactory<Catalog, L>();
+
+    const resolved = mergeRoutes<L, Routes>(routes, project.overrideRoutes);
+
+    function pathFor(id: RouteId, locale: L, options?: LinkOptions): UrlPath {
+        const route = resolved[id];
+        if (route === undefined) {
+            throw new Error(`Unknown route id "${id}".`);
+        }
+        if (!route.enabled) {
+            throw new Error(
+                `Route "${id}" is disabled for this project and has no URL.`
+            );
+        }
+        const base = buildPath(slugFor(route, locale), locale, pathContext);
+        const page = options?.page ?? 1;
+
+        // Asking for a page the route does not have would produce a URL nothing
+        // built, and a link to it is a 404 that no test would catch. The count
+        // is right here, so the mistake is worth refusing rather than serving.
+        if (page > route.pages) {
+            throw new Error(
+                `Route "${id}" has ${route.pages} page${route.pages === 1 ? "" : "s"}, so there is no page ${page}.`
+            );
+        }
+        return decorate(pagePath(base, page, locale, pathContext), options);
+    }
+
+    function urlFor(id: RouteId, locale: L, options?: LinkOptions): HttpsUrl {
+        return joinUrl(siteUrl, pathFor(id, locale, options));
+    }
+
+    function alternatesFor(
+        id: RouteId,
+        options?: LinkOptions
+    ): readonly Alternate<L>[] {
+        return locales.map((locale) => {
+            const path = pathFor(id, locale, options);
+            return { locale, path, url: joinUrl(siteUrl, path) };
+        });
+    }
+
+    function sitemap(): Sitemap {
+        return buildSitemap<L, RouteId>({
+            siteUrl,
+            name: config_.sitemap?.name ?? "sitemap.xml",
+            entryLimit: config_.sitemap?.entryLimit,
+            entries,
+            localeMeta,
+            alternatesFor,
+        });
+    }
+
+    // Registry declaration order, filtered to what this project builds.
+    const enabledRouteIds: readonly RouteId[] = Object.values(resolved)
+        .filter((route) => route.enabled)
+        // Narrowing to the enabled subset, which the filter above guarantees.
+        .map((route) => route.id as RouteId);
+
+    // Only enabled routes are listed, so the ids are exactly the enabled set.
+    const entries = listRouteEntries(
+        resolved,
+        locales,
+        pathContext
+    ) as readonly RouteEntry<L, RouteId>[];
+
+    // In prefix-everything mode no route owns `/`; the locale root stands in for
+    // it, provided some route actually claims that path.
+    const localeRootPath = buildPath("", defaultLocale, pathContext);
+    const rootEntry = prefixDefaultLocale
+        ? entries.find((entry) => entry.path === localeRootPath)
+        : undefined;
+
+    function staticPaths(param: string): StaticPath<L, RouteId>[] {
+        const paths: StaticPath<L, RouteId>[] = entries.map((entry) => ({
+            params: {
+                [param]: entry.path === "/" ? undefined : entry.path.slice(1),
+            },
+            props: {
+                routeId: entry.routeId,
+                locale: entry.locale,
+                page: entry.page,
+            },
+        }));
+
+        return paths;
+    }
+
+    function localeLinksFor(
+        id: RouteId,
+        current: L,
+        options?: LinkOptions
+    ): readonly LocaleLink<L>[] {
+        return alternatesFor(id, options).map((alternate) => ({
+            ...alternate,
+            label: localeMeta[alternate.locale].label,
+            htmlLang: localeMeta[alternate.locale].htmlLang,
+            dir: localeMeta[alternate.locale].dir,
+            isCurrent: alternate.locale === current,
+        }));
+    }
+
+    function notFoundMetaFor(locale: L, title: string): PageMeta {
+        return {
+            lang: localeMeta[locale].htmlLang,
+            dir: localeMeta[locale].dir,
+            // Umami only, tagged so the misses read on their own — the point
+            // of measuring this page is finding a redirect somebody forgot,
+            // not counting the people who mistype. See `notFoundAnalytics`.
+            tags: buildNotFoundMeta(title, project.analytics),
+            // Nothing. The body channel exists for Tag Manager's `<noscript>`,
+            // and no Google tag reaches this page.
+            bodyTags: [],
+        };
+    }
+
+    /**
+     * Icon rules, checked on first use rather than at construction, and checked
+     * once.
+     *
+     * They are facts about the file — square and a multiple of 48 are what
+     * search engines ask for, and PNG is forced by this design reusing one asset
+     * for `apple-touch-icon`, which needs a raster image — so they can only be
+     * read from an image the asset pipeline has processed. Checking eagerly
+     * would make a `Site` impossible to build anywhere the pipeline has not run,
+     * an Astro config being the case that matters: everything else here is
+     * derived from plain data, and holding the whole object hostage to the one
+     * field that is not made every deploy artifact unreachable from there.
+     *
+     * Nothing is skipped by waiting: every page's `<head>` goes through here, so
+     * a bad icon still fails the build, at the first page that renders.
+     */
+    let iconChecked = false;
+    function checkedIcon(): SiteIcon {
+        if (iconChecked) return project.icon;
+        if (project.icon.width !== project.icon.height) {
+            throw new Error(
+                `The site icon must be square: got ${project.icon.width}x${project.icon.height}.`
+            );
+        }
+        if (project.icon.width % 48 !== 0) {
+            throw new Error(
+                `The site icon must be a multiple of 48px (48, 96, 144, 192, …): got ${project.icon.width}.`
+            );
+        }
+        if (project.icon.format?.toLowerCase() !== "png") {
+            throw new Error(
+                `The site icon must be a PNG: got ${project.icon.format ?? "an unknown format"}. It is reused for apple-touch-icon, which needs a raster image.`
+            );
+        }
+        iconChecked = true;
+        return project.icon;
+    }
+
+    function metaFor(id: RouteId, locale: L, content: PageContent): PageMeta {
+        const { page, breadcrumb, ...meta } = content;
+        const link = page === undefined ? undefined : { page };
+        const document = buildMeta<L>({
+            ...meta,
+            locale,
+            // Named rather than left to the spread above. It reaches
+            // `buildMeta` either way, but a reader of this function should
+            // be able to see that a page's trail is part of its head.
+            breadcrumb,
+            canonical: urlFor(id, locale, link),
+            alternates: alternatesFor(id, link),
+            localeMeta,
+            defaultLocale,
+            image: resolveShareImage(siteUrl, content.image),
+            // Resolved here rather than in `buildMeta`, which is handed a
+            // canonical and no origin — and an origin is what a root-relative
+            // asset path has to be joined to.
+            articleImages: content.article?.images?.map((crop) =>
+                absoluteUrl(siteUrl, crop.src, "article image")
+            ),
+            siteName: project.siteName,
+            twitterSite: project.twitterSite,
+            icon: checkedIcon(),
+            verification: project.verification,
+            analytics: project.analytics,
+            llmsUrl,
+            themeColor: project.themeColor,
+            colorScheme: project.colorScheme,
+        });
+        return {
+            lang: localeMeta[locale].htmlLang,
+            dir: localeMeta[locale].dir,
+            tags: document.head,
+            bodyTags: document.body,
+        };
+    }
+
+    /** The enabled route whose own slug is exactly this, if any. */
+    function routeWithSlug(slug: string): RouteId | undefined {
+        return enabledRouteIds.find((candidate) => {
+            const route = resolved[candidate];
+            return route !== undefined && route.slug === slug;
+        });
+    }
+
+    /**
+     * URL segments that no page occupies — `/rooms` when `/rooms/alpha` is
+     * built and nothing sits at `/rooms` itself.
+     *
+     * Derived once from the route table, because that is what it is a fact
+     * about. A breadcrumb through such a segment is left with a gap, and
+     * structured data will not accept an intermediate step without a URL.
+     */
+    const orphanSegments: readonly string[] = [
+        ...new Set(
+            enabledRouteIds.flatMap((routeId) => {
+                const segments = (resolved[routeId]?.slug ?? "")
+                    .split("/")
+                    .filter((segment) => segment !== "");
+                // Every prefix except the whole slug, which is the page itself.
+                return segments
+                    .slice(0, -1)
+                    .map((_, depth) => segments.slice(0, depth + 1).join("/"));
+            })
+        ),
+    ]
+        .filter((prefix) => routeWithSlug(prefix) === undefined)
+        .sort();
+
+    function breadcrumbFor(
+        id: RouteId,
+        locale: L,
+        name: (id: RouteId) => string
+    ): readonly Crumb[] {
+        const crumb = (routeId: RouteId): Crumb => ({
+            name: name(routeId),
+            path: pathFor(routeId, locale),
+            url: urlFor(routeId, locale),
+        });
+
+        // The untranslated slug, as everywhere else that identifies a route:
+        // the trail's *URLs* are localised, but which routes are its ancestors
+        // is a fact about the site, not about the language it is read in.
+        const segments = (resolved[id]?.slug ?? "")
+            .split("/")
+            .filter((segment) => segment !== "");
+
+        const root = routeWithSlug("");
+        const trail: Crumb[] =
+            root === undefined || root === id ? [] : [crumb(root)];
+
+        // Every prefix except the whole slug, which is the page itself.
+        for (let depth = 1; depth < segments.length; depth++) {
+            const prefix = segments.slice(0, depth).join("/");
+            const ancestor = routeWithSlug(prefix);
+            // A gap, not an error to raise from here: which segments have no
+            // page is a fact about the route table, reported once by
+            // `orphanSegments` rather than by whichever page happens to render.
+            if (ancestor === undefined) continue;
+
+            trail.push(crumb(ancestor));
+        }
+
+        trail.push(crumb(id));
+
+        // One step is the page itself, which is not a trail: it says nothing a
+        // reader does not already know, and `BreadcrumbList` renders nothing
+        // for it. Dropped here, at the only place a trail is built, rather than
+        // by each reader — the markup and the rendered list both used to test
+        // the length themselves, each with a comment promising it matched the
+        // other, which is two enforcements of one rule and one of them free to
+        // drift. Downstream now only asks whether it was given a trail.
+        return trail.length > 1 ? trail : [];
+    }
+
+    function fileUrl(path: PublicFilePath): HttpsUrl {
+        return joinUrl(siteUrl, path);
+    }
+
+    function redirects(
+        rules: readonly RedirectRule<RouteId, L>[]
+    ): readonly ResolvedRedirect[] {
+        // When every locale is prefixed, nothing owns `/` — so lib claims it,
+        // with a real 301 to the default locale's root.
+        //
+        // A redirect rather than a page: a meta-refresh stub at `/` is a soft
+        // redirect, which search engines follow slowly and weigh less, and it
+        // costs a render before the reader goes anywhere. The two cannot both
+        // exist, since a static host serves the file and the rule never fires —
+        // which is what `builtPaths` below rejects.
+        // Named by route id like any other rule, so the target is derived from
+        // the route table and follows a retranslated slug.
+        const root: readonly RedirectRule<RouteId, L>[] =
+            rootEntry === undefined
+                ? []
+                : [
+                      {
+                          from: "/",
+                          to: {
+                              route: rootEntry.routeId,
+                              locale: rootEntry.locale,
+                          },
+                          // The root will never own a page again while every
+                          // locale is prefixed, which is what permanent means.
+                          kind: "permanent",
+                      },
+                  ];
+
+        return buildRedirects({
+            // Every path this build serves, so a rule that shadows a real page
+            // is rejected rather than sitting dead in the file.
+            builtPaths: new Set(entries.map((entry) => entry.path)),
+            rules: [...root, ...rules].map((rule) => ({
+                from: rule.from,
+                // Three kinds of target, told apart by shape: a string is
+                // external and passes through, `file` is served verbatim from
+                // `public/`, and a route is resolved to whatever URL it has in
+                // the locale asked for.
+                to: ((): string => {
+                    if (typeof rule.to === "string") return rule.to;
+                    if ("file" in rule.to) return rule.to.file;
+                    return pathFor(
+                        rule.to.route,
+                        rule.to.locale ?? defaultLocale
+                    );
+                })(),
+                status: statusFor(rule.kind),
+            })),
+        });
+    }
+
+    function llms(options: LlmsOptions<RouteId, L> = {}): GeneratedFile {
+        const locale = options.locale ?? defaultLocale;
+
+        // A page listed by route id beats a page not listed at all: the file is
+        // still a complete, correct map of what this site publishes and where.
+        const describe: NonNullable<LlmsOptions<RouteId, L>["describe"]> =
+            options.describe ?? ((id) => ({ name: id }));
+
+        // Grouped by the first segment of the slug, which is what a nested route
+        // has and a top-level one does not. Derived rather than declared: a
+        // family of generated routes already shares a prefix, so the grouping is
+        // a fact about the URLs and cannot fall out of step with them.
+        //
+        // The *untranslated* slug, though the URLs below are localised. The
+        // prefix is an identifier — it is what `sectionHeading` matches on, and
+        // what `SectionPrefixOf` types — so it has to be the same string in
+        // every language's file. Grouping by the translated slug would also
+        // silently regroup a family the day someone translated its prefix.
+        const baseSlugOf = (id: RouteId): string => resolved[id]?.slug ?? "";
+
+        const grouped = new Map<string, RouteId[]>();
+        const topLevel: RouteId[] = [];
+        for (const id of enabledRouteIds) {
+            const segments = baseSlugOf(id)
+                .split("/")
+                .filter((part) => part !== "");
+            const parent = segments.length > 1 ? segments[0] : undefined;
+            if (parent === undefined) {
+                topLevel.push(id);
+                continue;
+            }
+            const members = grouped.get(parent);
+            if (members === undefined) {
+                grouped.set(parent, [id]);
+            } else {
+                members.push(id);
+            }
+        }
+
+        // A group headed by the index page its children sit under: that page
+        // titles the section instead of being listed twice.
+        const owners = new Map<string, RouteId>();
+        for (const parent of grouped.keys()) {
+            const owner = topLevel.find((id) => baseSlugOf(id) === parent);
+            if (owner !== undefined) {
+                owners.set(parent, owner);
+            }
+        }
+        const ungrouped = topLevel.filter((id) => !owners.has(baseSlugOf(id)));
+
+        const item = (id: RouteId): LlmsItem => {
+            const described = describe(id, locale);
+            return {
+                name: described.name,
+                url: urlFor(id, locale),
+                ...(described.description === undefined
+                    ? {}
+                    : { description: described.description }),
+            };
+        };
+
+        const sections: LlmsSection[] = [
+            {
+                heading: options.pagesHeading ?? "Pages",
+                items: ungrouped.map(item),
+            },
+        ];
+        for (const [parent, members] of grouped) {
+            const owner = owners.get(parent);
+
+            // An explicit heading first, then the owning page's own words — a
+            // second name for the same page would only drift from it. Failing
+            // both, the URL segment: lib will not fabricate a heading out of
+            // copy it does not have.
+            const heading =
+                options.sectionHeading?.(parent, locale) ??
+                (owner === undefined ? parent : describe(owner, locale).name);
+
+            // The owning page, or the one nominated for a section that has
+            // none. Both may be absent — a family with no index page listed
+            // nowhere else — and the heading is then left unlinked rather than
+            // pointed at a URL this build never wrote.
+            const target = owner ?? options.sectionLink?.(parent, locale);
+
+            sections.push({
+                heading,
+                ...(target === undefined
+                    ? {}
+                    : { url: urlFor(target, locale) }),
+                items: members.map(item),
+            });
+        }
+        sections.push(...(options.sections ?? []));
+
+        const others = locales.filter((other) => other !== locale);
+        return buildLlms({
+            name: llmsName,
+            siteUrl,
+            title: project.siteName,
+            ...(options.summary === undefined
+                ? {}
+                : { summary: options.summary }),
+            sitemap: sitemap().entry.url,
+            language: {
+                tag: localeMeta[locale].htmlLang,
+                url: joinUrl(siteUrl, buildPath("", locale, pathContext)),
+            },
+            otherLanguages: others.map((other) => ({
+                tag: localeMeta[other].htmlLang,
+                url: joinUrl(siteUrl, buildPath("", other, pathContext)),
+            })),
+            sections,
+        });
+    }
+
+    function robots(groups?: readonly RobotsGroup[]): GeneratedFile {
+        return buildRobots({
+            name: config_.robots?.name ?? "robots.txt",
+            siteUrl,
+            // Derived, so a renamed or newly split sitemap cannot fall out of
+            // sync with what robots.txt advertises.
+            sitemap: sitemap().entry.url,
+            groups: groups ?? config_.robots?.groups,
+        });
+    }
+
+    return {
+        locales,
+        defaultLocale,
+        prefixDefaultLocale,
+        url: siteUrl,
+        siteName: project.siteName,
+        themeColor: project.themeColor,
+        localeMeta,
+        routes: enabledRouteIds,
+
+        translate: (locale) => translateFactory(catalog, locale),
+
+        pathFor,
+        urlFor,
+        fileUrl,
+        breadcrumbFor,
+        orphanSegments,
+        alternatesFor,
+        localeLinksFor,
+        entries,
+        staticPaths,
+        sitemap,
+        robots,
+        llms,
+        llmsUrl,
+        redirects,
+        metaFor,
+        notFoundMetaFor,
+    };
+}

package/src/site/index.ts

@@ -0,0 +1,32 @@
+/**
+ * The site object: what a project builds once, and every page then reads.
+ *
+ * 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.
+ * - `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
+ *   methods share captured state — the merged locales, the resolved routes, the
+ *   catalog — which is why it is one function and not a folder of them.
+ */
+
+export type {
+    LlmsOptions,
+    PerRoute,
+    RouteIdOf,
+    Site,
+    WhenEnabled,
+} from "./api.ts";
+export { createSite } from "./create.ts";
+export type {
+    Alternate,
+    Crumb,
+    LinkOptions,
+    LocaleLink,
+    PageContent,
+    PageMeta,
+    PageProps,
+    StaticPath,
+} from "./page.ts";