fix(landing-page): stop download function 404-shadowing localized catalog pages (#5770)

* fix(landing-page): emit localized plugins/templates/[kind] pages in production

The `[locale]/plugins/templates/[kind]` route imported `getStaticPaths`
from the sibling English `[kind]` page and re-invoked it. That cross-page
`getStaticPaths` re-export resolved to zero paths in the CI (Linux)
production build, so every `/<locale>/plugins/templates/<kind>/` URL
(deck, prototype, image, video, audio, live-artifact, hyperframes) 404'd
in production for all non-English locales — while the English routes and
the localized category index built fine. The language switcher on the
English category pages links straight into these 404s.

Derive the locale x category paths directly from PLUGIN_CATEGORIES (the
same source the English page's own getStaticPaths uses), mirroring the
self-contained `[locale]/plugins/[slug]` wrapper, so the route no longer
depends on the fragile cross-page getStaticPaths import.

* fix(landing-page): stop download function shadowing localized catalog pages

The attributed-download function `functions/[os]/[arch]/[token]/[asset].ts`
has a file-path route (`/[os]/[arch]/[token]/[asset]`) that structurally
matches ANY four-segment path. Pages Functions run before static-asset
serving, so it was intercepting the localized plugin catalog pages — e.g.
`/zh/plugins/templates/deck/` bound os=zh, arch=plugins, token=templates,
asset=deck — and returning `{"error":"download_not_found"}` (404) instead
of the real page. Every `/<locale>/plugins/templates/<kind>/` URL (the only
four-segment paths on the site) 404'd for all non-English locales, and the
language switcher on the English category pages links straight into them.

Real download URLs are minted only as `/{windows|macos|linux}/{arch}/{token}
/{asset}` (see `functions/api/attribution/mint.ts`), so gate the function on
the platform segment: anything whose first segment isn't a download platform
falls through to the static asset via `context.next()`. Download requests
are unaffected. Adds `next` to the local `PagesFunctionContext` type.

Paired with the localized `templates/[kind]` getStaticPaths fix in the same
branch, which makes those static pages exist in the first place.

---------

Co-authored-by: Joey <236967869+joeylee12629-star@users.noreply.github.com>

Author: joeylee12629-star

apps/landing-page/app/pages/[locale]/plugins/templates/[kind]/index.astro

@@ -1,17 +1,33 @@
 ---
-import KindPage, {
-  getStaticPaths as getKindStaticPaths,
-} from '../../../../plugins/templates/[kind]/index.astro';
+/*
+ * /<locale>/plugins/templates/<kind>/ — localized artifact-category grids.
+ *
+ * Re-uses the canonical English `[kind]` page for rendering and forwards
+ * the same `categorySlug` prop. We compute the locale × category paths
+ * HERE from `PLUGIN_CATEGORIES` directly, rather than importing the
+ * English page's `getStaticPaths` and re-mapping it.
+ *
+ * Importing a sibling `.astro` PAGE's `getStaticPaths` and re-invoking it
+ * is a fragile Astro pattern: `getStaticPaths` is hoisted/extracted by the
+ * compiler, so the cross-page re-export resolved to zero paths in the CI
+ * (Linux) production build even though it worked in local dev — leaving
+ * every `/<locale>/plugins/templates/<kind>/` URL 404 in production while
+ * the English routes were fine. Deriving the paths from the shared facet
+ * const (the same source the English page's own `getStaticPaths` uses)
+ * makes this route self-contained, mirroring the sibling `[locale]/plugins/
+ * [slug]` wrapper. See PLUGIN_CATEGORIES in `_lib/plugin-facets`.
+ */
+import KindPage from '../../../../plugins/templates/[kind]/index.astro';
+import { PLUGIN_CATEGORIES } from '../../../../../_lib/plugin-facets';
 import { DEFAULT_LOCALE, LANDING_LOCALES } from '../../../../../i18n';
 
-export async function getStaticPaths() {
-  const basePaths = await getKindStaticPaths();
-  return LANDING_LOCALES.filter((locale) => locale.code !== DEFAULT_LOCALE).flatMap(
-    (locale) =>
-      basePaths.map((p) => ({
-        params: { ...p.params, locale: locale.code },
-        props: p.props,
-      })),
+export function getStaticPaths() {
+  const locales = LANDING_LOCALES.filter((locale) => locale.code !== DEFAULT_LOCALE);
+  return locales.flatMap((locale) =>
+    PLUGIN_CATEGORIES.map((cat) => ({
+      params: { locale: locale.code, kind: cat.slug },
+      props: { categorySlug: cat.slug },
+    })),
   );
 }
 ---

apps/landing-page/functions/[os]/[arch]/[token]/[asset].ts

@@ -9,12 +9,24 @@ import {
   type PagesFunction,
 } from '../../../_lib/attribution';
 
+// Download URLs are minted only as `/{windows|macos|linux}/{arch}/{token}/{asset}`
+// (see `functions/api/attribution/mint.ts`). This function's file-path route
+// `/[os]/[arch]/[token]/[asset]` structurally matches ANY four-segment path,
+// though — including localized static pages such as
+// `/zh/plugins/templates/deck/` (os=`zh`, arch=`plugins`, token=`templates`,
+// asset=`deck`). Because Pages Functions run before static-asset serving, an
+// unguarded function would shadow every four-segment page with a JSON 404
+// (`download_not_found`). Gate on the platform segment so anything that isn't a
+// real download request falls through to the static asset instead.
+const DOWNLOAD_PLATFORMS = new Set(['windows', 'macos', 'linux']);
+
 export const onRequest: PagesFunction<AttributionEnv, {
   os: string;
   arch: string;
   token: string;
   asset: string;
-}> = async ({ request, env, params }) => {
+}> = async ({ request, env, params, next }) => {
+  if (!DOWNLOAD_PLATFORMS.has(params.os)) return next();
   if (request.method !== 'GET' && request.method !== 'HEAD') {
     return json(405, { error: 'method_not_allowed' });
   }

apps/landing-page/functions/_lib/attribution.ts

@@ -2,6 +2,10 @@ export interface PagesFunctionContext<Env, Params = Record<string, string>> {
   request: Request;
   env: Env;
   params: Params;
+  // Serves the next matching handler — for a Pages Function that owns a broad
+  // route, this falls through to the static asset (or the 404 page) instead of
+  // the function generating a response itself.
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 }
 
 export type PagesFunction<Env, Params = Record<string, string>> = (