@escape-game-over/atlas 0.1.69 → 0.1.71

package/README.md

@@ -61,7 +61,7 @@ Linking to a page the active deployment switched off is a compile error, not a
 One file per deployment, saying only what differs:
 
 ```ts
-export default atlas.project(defaultMessages, defaultRoutes, {
+export const { project, redirects } = atlas.project(defaultMessages, defaultRoutes, {
   url: "https://acme.example",
   siteName: "Acme Rome",
   icon,
@@ -98,8 +98,8 @@ export const atlas = defineSite({ locales: {...}, defaultRouting: {...} })
 export const baseMessages = atlas.messages({...})
 export const baseRoutes   = atlas.routes({...})
 
-// 3. one deployment
-export default atlas.project(baseMessages, baseRoutes, {...})
+// 3. one deployment, and its redirects, typed against what it builds
+export const { project, redirects } = atlas.project(baseMessages, baseRoutes, {...})
 
 // 4. the API the pages use
 export const site = atlas.site(baseMessages, baseRoutes, project)
@@ -107,8 +107,21 @@ export const site = atlas.site(baseMessages, baseRoutes, project)
 
 Step 4 returns `t()`, `rich()`, `plain()`, `pathFor()`, `urlFor()`, `fileUrl()`,
 `localeLinksFor()`, `metaFor()`, `breadcrumbFor()`,
-`getStaticPaths()`, `routes`, `sitemap()`, `robots()`, `llms()` and
-`redirects()` already wired.
+`getStaticPaths()`, `routes`, `sitemap()`, `robots()` and `llms()` already
+wired.
+
+Step 3's `redirects` is the one way to write a redirect: it types one
+deployment's old URLs against *that* deployment's pages and languages,
+whichever project the site is currently built from. `siteRoutes()` takes what
+it returns and nothing else, resolves it, and writes `_redirects`:
+
+```ts
+// projects/rome/redirects.ts
+export default redirects([
+  { from: "/jobs", to: { route: "careers" }, kind: "permanent" }, // ✗ if Rome has no careers page
+  { from: "/en/*", to: { route: "home", locale: "en-US", splat: true }, kind: "permanent" }, // /en/faq → /en-US/faq
+])
+```
 
 `t()` is bound to a locale and knows each message's `{placeholders}` from its
 text:
@@ -177,7 +190,7 @@ than printing the brackets. See [`docs/rich-text.md`](docs/rich-text.md).
 | `sitemap.xml`            | `siteRoutes()`, from the routes  | nothing                                 |
 | `robots.txt`             | `siteRoutes()`                   | nothing                                 |
 | `llms.txt`               | `siteRoutes()`                   | words, via `site.llms({...})`           |
-| `_redirects`             | `siteRoutes()`                   | rules, via `site.redirects()`           |
+| `_redirects`             | `siteRoutes()`                   | rules, via the project's `redirects()`  |
 | `BreadcrumbList` JSON-LD | `breadcrumbFor()`, from the slug | a name per step, in a layout            |
 | `LocalBusiness` JSON-LD  | `localBusiness()`                | address, phone, hours                   |
 | `Organization` JSON-LD   | `organization()`                 | name, URL, logo                         |

package/docs/NOT-BUILT.md

@@ -384,7 +384,7 @@ repo, which is why this entry exists — reading that file is what prompts the
 question.
 
 Nothing is served by Apache any more. Worth knowing the seam is already there if
-that ever changes: `site.redirects()` returns resolved rules as *data*, and
+that ever changes: the site resolves rules to plain *data*, and
 `buildCloudflareRedirects` is one renderer over them rather than the only
 possible one, so another host is a new function and no redesign. The two
 non-redirect halves of that `.htaccess` — extension resolution and slash

package/docs/toolchain.md

@@ -82,7 +82,7 @@ The practical consequence: `/about-us` is `about-us.html`, not
 `about-us/index.html`. `dist/` is plain files — any static host works, and no
 server rules are required.
 
-## The URLs `site.redirects()` claims on its own
+## The URLs `_redirects` claims on its own
 
 Two of this toolchain's decisions leave a URL unpublished that people still ask
 for. Each is answered with a real **301** written into `_redirects` alongside

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@escape-game-over/atlas",
-    "version": "0.1.69",
+    "version": "0.1.71",
     "type": "module",
     "description": "Typed, data-driven machinery for static multi-locale, multi-deployment Astro sites.",
     "private": false,

package/src/astro/site-routes.ts

@@ -5,7 +5,10 @@ import type { AstroIntegration } from "astro";
 import type { GeneratedFile } from "../file.ts";
 import {
     buildCloudflareRedirects,
+    type ProjectRedirects,
+    type RedirectRule,
     type ResolvedRedirect,
+    resolveRedirects,
 } from "../redirects.ts";
 import type { Sitemap } from "../sitemap.ts";
 import type { HttpsUrl } from "../url.ts";
@@ -20,7 +23,7 @@ import { noClientRouter } from "./no-client-router.ts";
  * without having to name its three type arguments here — and so this states
  * exactly which parts are used.
  */
-export interface SiteFiles {
+export interface SiteFiles<Id extends string, L extends string> {
     readonly url: HttpsUrl;
     /** Segments with pages under them but none at them; see `orphanSegments`. */
     readonly orphanSegments: readonly string[];
@@ -29,6 +32,10 @@ export interface SiteFiles {
     sitemap(): Sitemap;
     robots(): GeneratedFile;
     llms(): GeneratedFile;
+    /** Where `Id` and `L` are read from, so the rules below must match them. */
+    readonly [resolveRedirects]: (
+        rules: readonly RedirectRule<Id, L>[]
+    ) => readonly ResolvedRedirect[];
 }
 
 /**
@@ -53,16 +60,23 @@ function size(body: string): string {
     return bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(1)} kB`;
 }
 
-export interface SiteRoutesOptions {
+export interface SiteRoutesOptions<Id extends string, L extends string> {
     /**
      * The site, imported. Not a module path: everything below is derived from
      * plain data — URLs, route ids, locales — so it can be built where an Astro
      * config is evaluated, and a real import is checked where a specifier would
      * not be.
      */
-    readonly site: SiteFiles;
-    /** From `site.redirects([…])`. Omit to write no `_redirects`. */
-    readonly redirects?: readonly ResolvedRedirect[];
+    readonly site: SiteFiles<Id, L>;
+    /**
+     * From the `redirects` that `atlas.project()` returns — the only form taken,
+     * so every rule here was checked against the project it belongs to.
+     *
+     * Resolved against `site`, which adds the rules its route table implies;
+     * omitted, `_redirects` holds only those. Not inferred from: a list typed
+     * for another project is an error here, not a widening of `Id`.
+     */
+    readonly redirects?: ProjectRedirects<NoInfer<Id>, NoInfer<L>>;
     /**
      * From `site.llms({…})`.
      *
@@ -92,8 +106,13 @@ export interface SiteRoutesOptions {
  * That was built and served, in dev and in a build, before being taken out
  * again for the reason above.
  */
-export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
-    const { site, redirects, llms } = options;
+export function siteRoutes<Id extends string, L extends string>(
+    options: SiteRoutesOptions<Id, L>
+): AstroIntegration {
+    const { site, llms } = options;
+    // Resolved here, once, so a rule that cannot be served throws while the
+    // config is evaluated rather than at the end of a build.
+    const redirects = site[resolveRedirects](options.redirects ?? []);
 
     /** `llms.txt (4.2 kB)` — the name and what it actually weighs. */
     const describe = (file: GeneratedFile): string =>
@@ -116,7 +135,7 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
         if (site.llmsUrl !== undefined) files.push(llms ?? site.llms());
         // Length rather than presence: a site with no rules gets no file, not an
         // empty one.
-        if (redirects?.length) {
+        if (redirects.length > 0) {
             files.push(
                 buildCloudflareRedirects(redirects, { siteUrl: site.url })
             );
@@ -381,7 +400,7 @@ export function siteRoutes(options: SiteRoutesOptions): AstroIntegration {
                         path.length > 1 && path.endsWith("/")
                             ? path.slice(0, -1)
                             : path;
-                    const rule = redirects?.find((it) => it.from === canonical);
+                    const rule = redirects.find((it) => it.from === canonical);
                     if (rule !== undefined) {
                         logger.info(
                             `redirect: ${path} → ${rule.to} (${rule.status})`

package/src/index.ts

@@ -7,7 +7,7 @@
  * export const atlas = defineSite({ locales: {...}, defaultRouting: {...} })  // site.config.ts
  * export const defaultMessages = atlas.messages({...})                        // messages.ts
  * export const defaultRoutes = atlas.routes({...})                            // routes.ts
- * export default atlas.project(defaultMessages, defaultRoutes, {...})         // projects/<name>/project.ts
+ * export const { project, redirects } = atlas.project(defaultMessages, defaultRoutes, {...}) // projects/<name>/project.ts
  * export const site = atlas.site(defaultMessages, defaultRoutes, project)     // site.ts
  * ```
  */
@@ -206,12 +206,17 @@ export {
     type TieredPrice,
     tierRange,
 } from "./money.ts";
-export type { ProjectInput } from "./project.ts";
+export type {
+    DefinedProject,
+    ProjectInput,
+    ProjectRouteId,
+} from "./project.ts";
 export {
     buildCloudflareRedirects,
     buildRedirects,
     type CloudflareRedirectsOptions,
     type ExternalUrl,
+    type ProjectRedirects,
     type RedirectKind,
     type RedirectRule,
     type RedirectStatus,

package/src/project.ts

@@ -15,6 +15,13 @@ import type {
 import type { ImageAsset } from "./image.ts";
 import type { SiteVerification, ThemeColor } from "./meta/index.ts";
 import type {
+    ProjectRedirects,
+    RedirectRule,
+    ValidateRedirectTargets,
+} from "./redirects.ts";
+import type {
+    EnabledFlagSource,
+    EnabledRouteIdFor,
     RouteOverrides,
     RouteRegistry,
     ValidateOverrideSlugDepth,
@@ -136,6 +143,64 @@ export interface ProjectInput<L extends string, Routes> {
     readonly overrideRoutes: RouteOverrides<Routes, L>;
 }
 
+/**
+ * The route ids one project builds: the registry's, minus what it switched off.
+ *
+ * The single definition, read by `site` and by a project's own `redirects` —
+ * so a rule typed against the project fits the site built from it, and the two
+ * cannot drift apart. A near-miss spelling of this type is not harmless: an
+ * intersection with the registry's constraint was enough to let switched-off
+ * routes back in, silently.
+ */
+export type ProjectRouteId<
+    Routes extends EnabledFlagSource,
+    P extends { readonly overrideRoutes: unknown },
+> = EnabledRouteIdFor<Routes, P["overrideRoutes"]> & StringKeys<Routes>;
+
+/**
+ * What `atlas.project()` hands back: the project, and its redirects.
+ *
+ * `redirects` is bound to *this* project, because the rules belong to it: an
+ * old URL is a fact about one deployment's past, and a target can only be a
+ * page that deployment builds, in a language it publishes. Typed here rather
+ * than through `site`, which is built from whichever project is linked — so a
+ * project that is not the linked one has its rules checked all the same.
+ *
+ * The one way to type a rule. What it returns is what `siteRoutes()` takes,
+ * resolves, and writes to `_redirects` with the rules the route table implies.
+ */
+export interface DefinedProject<
+    Routes extends EnabledFlagSource,
+    T extends ProjectInput<string, Routes>,
+> {
+    readonly project: T;
+    /** Rules for this project's old URLs, checked against what it builds. */
+    readonly redirects: <
+        const Rules extends readonly RedirectRule<
+            ProjectRouteId<Routes, T>,
+            T["enabledLocales"][number]
+        >[],
+    >(
+        rules: Rules & ValidateRedirectTargets<Rules>
+    ) => ProjectRedirects<
+        ProjectRouteId<Routes, T>,
+        T["enabledLocales"][number]
+    >;
+}
+
+/**
+ * A project's `redirects`. The one place a rule list is branded as checked.
+ *
+ * Takes the routes and the project only for their types; the rules come back
+ * as they went in.
+ */
+export function bindRedirects<
+    Routes extends EnabledFlagSource,
+    T extends ProjectInput<string, Routes>,
+>(_routes: Routes, _project: T): DefinedProject<Routes, T>["redirects"] {
+    return (rules) => rules as never;
+}
+
 /**
  * Declares one deployment, validated against the site config and base data.
  *

package/src/redirects.ts

@@ -6,10 +6,9 @@
  * target is either another page of this site, named by route id so it is checked
  * and its URL derived, or an absolute `https://` URL somewhere else.
  *
- * `site.redirects()` returns the resolved rules *and* a rendered file, the way
- * `sitemap()` returns entries and files. A consumer that only wants the data —
- * to feed a host with its own format — reads `rules`; one deploying to a static
- * host writes `file` and is done.
+ * There is one way in: the `redirects` that `atlas.project()` returns types a
+ * project's rules against what that project builds, and `siteRoutes()` takes
+ * them, resolves them against the site and writes `_redirects`.
  */
 
 import type { GeneratedFile } from "./file.ts";
@@ -72,13 +71,19 @@ export type SitePath = UrlPath;
  */
 export type ExternalUrl = HttpsUrl;
 
+/** A `splat` target whose source has no `*` to carry: there is no rest to keep. */
+export interface SplatNeedsWildcard<From extends string> {
+    readonly __SPLAT_WITHOUT_WILDCARD__: `"${From}" has no "/*" to carry over: a rule with \`splat: true\` needs a source ending in "/*"`;
+}
+
 /**
- * Rejects an external target that is not `https://`, naming it.
+ * Rejects an external target that is not `https://`, and a `splat` target
+ * whose source has no wildcard, naming each.
  *
- * Applied to the rules array in parameter position, so a bad URL reports on its
- * own line rather than as the whole array failing to match. The check itself is
- * `ValidHttpsUrl`, shared with the site origin — one idea of an acceptable URL,
- * stated once.
+ * Applied to the rules array in parameter position, so a bad rule reports on
+ * its own line rather than as the whole array failing to match. The URL check
+ * itself is `ValidHttpsUrl`, shared with the site origin — one idea of an
+ * acceptable URL, stated once.
  */
 export type ValidateRedirectTargets<Rules> = {
     readonly [K in keyof Rules]: Rules[K] extends {
@@ -91,7 +96,18 @@ export type ValidateRedirectTargets<Rules> = {
                   ? ValidHttpsUrl<To>
                   : Rules[K][P];
           }
-        : Rules[K];
+        : Rules[K] extends {
+                readonly from: infer From extends string;
+                readonly to: { readonly splat: true };
+            }
+          ? From extends `${string}/*`
+              ? Rules[K]
+              : {
+                    readonly [P in keyof Rules[K]]: P extends "from"
+                        ? SplatNeedsWildcard<From>
+                        : Rules[K][P];
+                }
+          : Rules[K];
 };
 
 /**
@@ -106,7 +122,28 @@ export type ValidateRedirectTargets<Rules> = {
  */
 export type RedirectTarget<Id extends string, L extends string> =
     | ExternalUrl
-    | { readonly route: Id; readonly locale?: L; readonly page?: number }
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly page?: number;
+          readonly splat?: never;
+      }
+    /**
+     * A page, with whatever the source's `*` matched kept after its path:
+     * `/en/*` to `{ route: "home", locale: "en-US", splat: true }` sends
+     * `/en/faq` to `/en-US/faq`.
+     *
+     * For an old prefix whose pages kept their slugs, so one rule answers every
+     * URL under it. The target stays a route, so the prefix it lands on is
+     * derived like every other link rather than spelled out by hand. Not with
+     * `page`: the rest of a path cannot follow a page number.
+     */
+    | {
+          readonly route: Id;
+          readonly locale?: L;
+          readonly splat: true;
+          readonly page?: never;
+      }
     /**
      * A file served verbatim from `public/` — a PDF, a spreadsheet.
      *
@@ -133,6 +170,31 @@ export interface RedirectRule<Id extends string, L extends string> {
     readonly kind: RedirectKind;
 }
 
+declare const checkedByProject: unique symbol;
+
+/**
+ * Rules a project's own `redirects` checked — the only form `siteRoutes()`
+ * takes.
+ *
+ * Branded so that a list cannot reach the integration any other way. Written
+ * inline at `siteRoutes()`, rules could only be checked against the site, and
+ * the site is built from whichever project is linked: every other project's
+ * rules would go unchecked until it was the one being built.
+ */
+export type ProjectRedirects<
+    Id extends string,
+    L extends string,
+> = readonly RedirectRule<Id, L>[] & { readonly [checkedByProject]: true };
+
+/**
+ * The key a site resolves rules under, for `siteRoutes()`.
+ *
+ * A symbol the package does not export, so the integration is the only caller:
+ * a site method anyone could reach would be a second way to turn rules into
+ * `_redirects`, and one that takes rules no project checked.
+ */
+export const resolveRedirects: unique symbol = Symbol("atlas.resolveRedirects");
+
 /** One rule with its target resolved to a URL or path, ready to serve. */
 export interface ResolvedRedirect {
     readonly from: string;

package/src/routes/define.ts

@@ -49,7 +49,7 @@ export interface RouteData<L extends string> {
      * `1` or omitted is an ordinary route. Above that, lib emits
      * `/news/page/2` … `/news/page/n` alongside `/news` — page one is always
      * the bare slug, never `page/1`, so there is no duplicate to canonicalise
-     * away. `site.redirects()` then claims `/news/page/1` with a 301 onto the
+     * away. A redirect then claims `/news/page/1` with a 301 onto the
      * bare slug, since a URL nothing publishes is still one a reader edits
      * their way to.
      *

package/src/site/api.ts

@@ -9,7 +9,7 @@ import type { ThemeColor } from "../meta/index.ts";
 import type {
     RedirectRule,
     ResolvedRedirect,
-    ValidateRedirectTargets,
+    resolveRedirects,
 } from "../redirects.ts";
 import type { RobotsGroup } from "../robots.ts";
 import type { Sitemap } from "../sitemap.ts";
@@ -261,7 +261,7 @@ export interface Site<
      * 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
+     * for it: a redirect claims it with a 301 to the default locale's root
      * instead, which is a real redirect rather than a rendered stub. The target
      * is whichever route has an empty slug — lib has no notion of a "home"
      * page, so the caller does not have to name one.
@@ -302,13 +302,16 @@ export interface Site<
     ): GeneratedFile;
 
     /**
-     * Old URLs that must keep working, resolved and rendered.
+     * Old URLs that must keep working, resolved — for `siteRoutes()` only.
      *
      * A rule's target names a *route*, not a path, so the URL is derived the way
      * every other link is: a redirect cannot outlive the page it points at, and
      * a retranslated slug moves it too. External targets are `https://` URLs and
      * pass through untouched.
      *
+     * Rules are typed by the `redirects` that `atlas.project()` returns, not
+     * here: see `ProjectRedirects`.
+     *
      * **What comes back is more than what went in.** lib adds the rules the
      * route table implies, for the URLs its own design leaves unpublished but
      * reachable: whichever site root the routing mode does not serve — `/` when
@@ -316,15 +319,11 @@ export interface Site<
      * pages under that unused `/en-US/`, as one `/en-US/* /:splat` wildcard
      * written last, and `/news/page/1` for a list whose page one is the bare
      * path. A rule you state for one of those paths replaces the inferred one,
-     * so pass `[]` and you still get a file worth writing.
-     *
-     * Returns the rules as data. Rendering is a separate step —
-     * `buildCloudflareRedirects` writes the `_redirects` that Cloudflare and
-     * Netlify read, and a host with its own syntax takes these and writes its own.
+     * so a project with no rules of its own still gets a file worth writing.
      */
-    redirects<const Rules extends readonly RedirectRule<RouteId, L>[]>(
-        rules: Rules & ValidateRedirectTargets<Rules>
-    ): readonly ResolvedRedirect[];
+    readonly [resolveRedirects]: (
+        rules: readonly RedirectRule<RouteId, L>[]
+    ) => readonly ResolvedRedirect[];
 
     /**
      * Everything the document head needs for one page: the `<html>` attributes,

package/src/site/create.ts

@@ -22,16 +22,16 @@ import {
     buildNotFoundMeta,
     resolveShareImage,
 } from "../meta/index.ts";
-import type { ProjectInput } from "../project.ts";
+import type { ProjectInput, ProjectRouteId } from "../project.ts";
 import {
     buildRedirects,
     type RedirectRule,
     type ResolvedRedirect,
+    resolveRedirects,
     statusFor,
 } from "../redirects.ts";
 import { buildRobots, type RobotsGroup } from "../robots.ts";
 import type {
-    EnabledRouteIdFor,
     OrphanSectionPrefixOf,
     RouteRegistry,
     SectionPrefixOf,
@@ -47,7 +47,6 @@ import {
     slugFor,
 } from "../routes/resolve.ts";
 import { buildSitemap, type Sitemap } from "../sitemap.ts";
-import type { StringKeys } from "../types.ts";
 import {
     absoluteUrl,
     type HttpsUrl,
@@ -104,7 +103,7 @@ export function createSite<
 ): Site<
     Published,
     Catalog,
-    EnabledRouteIdFor<Routes, P["overrideRoutes"]> & StringKeys<Routes>,
+    ProjectRouteId<Routes, P>,
     SectionPrefixOf<Routes, P["overrideRoutes"]>,
     OrphanSectionPrefixOf<Routes, P["overrideRoutes"]>
 > {
@@ -114,8 +113,7 @@ export function createSite<
     // `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>;
+    type RouteId = ProjectRouteId<Routes, P>;
 
     const locales = project.enabledLocales as readonly L[];
     const defaultLocale = (project.overrideRouting?.defaultLocale ??
@@ -284,7 +282,7 @@ export function createSite<
     /**
      * Every path this build serves.
      *
-     * Read by `redirects()` twice over: to reject a stated rule that shadows a
+     * Read by `resolve()` twice over: to reject a stated rule that shadows a
      * real page, and to keep an inferred one from doing the same.
      */
     const builtPaths: ReadonlySet<string> = new Set(
@@ -600,7 +598,7 @@ export function createSite<
         ];
     }
 
-    function redirects(
+    function resolve(
         rules: readonly RedirectRule<RouteId, L>[]
     ): readonly ResolvedRedirect[] {
         const stated: readonly ResolvedRedirect[] = rules.map((rule) => ({
@@ -612,6 +610,20 @@ export function createSite<
             to: ((): string => {
                 if (typeof rule.to === "string") return rule.to;
                 if ("file" in rule.to) return rule.to.file;
+                if (rule.to.splat === true) {
+                    // Checked here too, for a rule the types could not see:
+                    // without a `*`, the host has nothing to put in `:splat`.
+                    if (!rule.from.endsWith("/*")) {
+                        throw new Error(
+                            `Redirect "${rule.from}" keeps the rest of the path (\`splat: true\`) but has no "/*" to take it from.`
+                        );
+                    }
+                    const path = pathFor(
+                        rule.to.route,
+                        rule.to.locale ?? defaultLocale
+                    );
+                    return path === "/" ? "/:splat" : `${path}/:splat`;
+                }
                 return pathFor(rule.to.route, rule.to.locale ?? defaultLocale, {
                     page: rule.to.page,
                 });
@@ -833,7 +845,7 @@ export function createSite<
         robots,
         llms,
         llmsUrl,
-        redirects,
+        [resolveRedirects]: resolve,
         metaFor,
         notFoundMetaFor,
     };

package/src/site/define.ts

@@ -11,6 +11,8 @@ import {
     type ValidateBase,
 } from "../i18n/define.ts";
 import {
+    bindRedirects,
+    type DefinedProject,
     defineProject,
     type ProjectChecks,
     type ProjectInput,
@@ -40,7 +42,7 @@ import { createSite } from "./create.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 { project, redirects } = atlas.project(defaultMessages, defaultRoutes, {…});
  * export const site = atlas.site(defaultMessages, defaultRoutes, project);
  * ```
  *
@@ -94,13 +96,17 @@ export function defineSite<
             messages: Catalog,
             routes: Routes,
             project: T & ProjectOverrideChecks<L, Catalog, Routes, T>
-        ): T {
-            return defineProject(
+        ): DefinedProject<Routes, T> {
+            const defined = defineProject(
                 config,
                 messages,
                 routes,
                 project as never
             ) as T;
+            return {
+                project: defined,
+                redirects: bindRedirects(routes, defined),
+            };
         },
 
         /** The API every page reads, wired for one project. */