create-ailk 0.1.0

package/templates/apps/web/app/og/route.tsx

@@ -0,0 +1,135 @@
+/**
+ * Universal OG image route — /og?title=...&schemaType=...
+ *
+ * Design decisions (per spec § 3):
+ *  - next/og ImageResponse at 1200×630 (Open Graph standard)
+ *  - System sans-serif only — no .ttf fetches (the #1 source of OG bugs)
+ *  - force-static: Vercel caches generated images at the edge after first request
+ *  - Fallback strategy: on any ImageResponse throw, return a 302 redirect to
+ *    /og-default.png (the static PNG in apps/web/public/). The redirect is
+ *    edge-compatible (no fs access needed) and exposing the fallback URL is
+ *    acceptable per spec § 3 ("redirecting is simpler but exposes the fallback URL;
+ *    both acceptable"). Chosen over stream-bytes because edge runtime has no fs.
+ *
+ * Sanitization:
+ *  - Strip control characters \x00–\x1F and \x7F from title and schemaType
+ *  - Cap title at 200 chars, schemaType at 50 chars
+ *  - If sanitization yields an empty title, fall back to static PNG redirect
+ */
+import { clientError } from "@working-theory/page-renderer/edge";
+import { tokens } from "@working-theory/theme";
+import { ImageResponse } from "next/og";
+
+export const runtime = "edge";
+export const dynamic = "force-static";
+
+// Strips C0 control characters (U+0000–U+001F) and DEL (U+007F).
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHAR_RE = new RegExp("[\u0000-\u001F\u007F]", "g");
+
+const SYSTEM_FONT = "system-ui, -apple-system, sans-serif";
+
+function sanitize(raw: string, cap: number): string {
+  return raw.replace(CONTROL_CHAR_RE, "").slice(0, cap);
+}
+
+function serveFallback(): Response {
+  // 302 redirect to the static PNG served by Next.js from /public.
+  // Edge-compatible: no fs access required.
+  // Using new Response + Location header instead of Response.redirect() because
+  // Response.redirect() requires an absolute URL in the Fetch API spec, but
+  // relative redirects work correctly in Next.js edge middleware at runtime.
+  return new Response(null, {
+    status: 302,
+    headers: { Location: "/og-default.png" },
+  });
+}
+
+export async function GET(request: Request): Promise<Response> {
+  const { searchParams } = new URL(request.url);
+
+  const rawTitle = searchParams.get("title") ?? "";
+  const rawSchemaType = searchParams.get("schemaType") ?? "";
+
+  const siteName = process.env.NEXT_PUBLIC_SITE_NAME ?? "AI Launch Kit";
+  const wordmark = process.env.NEXT_PUBLIC_SITE_WORDMARK ?? "ailaunchkit.ai";
+
+  const title = sanitize(rawTitle || siteName, 200);
+  const schemaType = rawSchemaType ? sanitize(rawSchemaType, 50) : "";
+
+  // Post-sanitization empty title → fallback
+  if (!title) {
+    return serveFallback();
+  }
+
+  try {
+    return new ImageResponse(
+      <div
+        style={{
+          display: "flex",
+          flexDirection: "column",
+          justifyContent: "center",
+          alignItems: "flex-start",
+          width: "100%",
+          height: "100%",
+          backgroundColor: tokens.colors.light.brand,
+          padding: "80px",
+          fontFamily: SYSTEM_FONT,
+          position: "relative",
+        }}
+      >
+        {schemaType ? (
+          <div
+            style={{
+              position: "absolute",
+              top: "48px",
+              right: "48px",
+              backgroundColor: "rgba(0,0,0,0.25)",
+              color: tokens.colors.light.fg,
+              borderRadius: "9999px",
+              padding: "6px 18px",
+              fontSize: "18px",
+              fontFamily: SYSTEM_FONT,
+            }}
+          >
+            {schemaType}
+          </div>
+        ) : null}
+
+        <div
+          style={{
+            color: tokens.colors.light.fg,
+            fontSize: "56px",
+            fontWeight: 700,
+            lineHeight: 1.1,
+            maxWidth: "880px",
+            fontFamily: SYSTEM_FONT,
+          }}
+        >
+          {title}
+        </div>
+
+        <div
+          style={{
+            position: "absolute",
+            bottom: "48px",
+            right: "48px",
+            color: tokens.colors.light.fg,
+            fontSize: "24px",
+            opacity: 0.75,
+            fontFamily: SYSTEM_FONT,
+          }}
+        >
+          {wordmark}
+        </div>
+      </div>,
+      {
+        width: 1200,
+        height: 630,
+      },
+    );
+  } catch (err) {
+    clientError(err);
+    return serveFallback();
+  }
+}

package/templates/apps/web/app/robots.txt/route.ts

@@ -0,0 +1,36 @@
+/**
+ * GET /robots.txt
+ *
+ * Returns a robots.txt with sensible defaults for an AX-first product:
+ *   - All crawlers allowed by default
+ *   - Sitemap location declared
+ *   - Optional path disallow via AILK_ROBOTS_DISALLOW env var
+ *     (comma-separated paths, e.g. "/admin/,/private/")
+ */
+
+import { resolveBaseUrl } from "../../src/lib/routes";
+
+export function GET(): Response {
+  const baseUrl = resolveBaseUrl();
+  const disallowEnv = process.env["AILK_ROBOTS_DISALLOW"] ?? "";
+
+  const disallowPaths = disallowEnv
+    .split(",")
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+
+  const lines = [
+    "User-agent: *",
+    ...disallowPaths.map((p) => `Disallow: ${p}`),
+    "",
+    `Sitemap: ${baseUrl}/sitemap.xml`,
+  ];
+
+  return new Response(lines.join("\n"), {
+    status: 200,
+    headers: {
+      "content-type": "text/plain; charset=utf-8",
+      "cache-control": "public, max-age=86400",
+    },
+  });
+}

package/templates/apps/web/app/sitemap.xml/route.ts

@@ -0,0 +1,146 @@
+/**
+ * GET /sitemap.xml
+ *
+ * Returns a standard XML sitemap covering all content seeds in content/.
+ * Crawlers (Google, Bing) and AI agents use this to discover pages.
+ *
+ * Includes per-locale <xhtml:link rel="alternate"> entries per Google's
+ * sitemap protocol for international content. Locale list is read from
+ * NEXT_PUBLIC_ENABLED_LOCALES (baked by next.config.mjs from project.yaml
+ * at build time) — same pattern as middleware.ts. This avoids importing
+ * node:fs-dependent lib/locales into the prerender context where cwd is
+ * apps/web/ but project.yaml lives at the repo root.
+ *
+ * Phase 3 S3: pages are listed per enabled locale via the adapter's
+ * locale-scoped `listPages(type, locale)`. Lists are scoped — see the
+ * adapter contract in @working-theory/content-adapters/src/mdx/adapter.ts — so a
+ * page must exist in each locale's content directory to be enumerated for
+ * that locale. The default-locale list still picks up legacy non-prefixed
+ * content via the adapter's legacy fallback.
+ *
+ * URL composition:
+ * - Default locale: bare path /<path> (matches next-intl as-needed serving)
+ * - Non-default locales: /<locale>/<path>
+ *
+ * lastmod uses the page's publishedAt frontmatter field when present;
+ * falls back to the current date so the sitemap is always valid.
+ *
+ * DI note: `createSitemapHandler` accepts an optional `getContentAdapter` dep
+ * for testing — tests inject a stub adapter to avoid mocking the internal module.
+ * The exported `GET` uses the real implementation.
+ */
+
+import { SCHEMA_ORG_TYPES } from "@working-theory/content-adapters";
+import type { ContentAdapter, SchemaOrgType } from "@working-theory/content-adapters";
+import { getContentAdapter as defaultGetContentAdapter } from "@working-theory/page-renderer";
+
+import { resolveBaseUrl, slugToPath } from "../../src/lib/routes";
+
+export interface SitemapHandlerDeps {
+  /**
+   * Content adapter factory. Defaults to the real implementation.
+   * Override in tests to inject a stub adapter without mocking the internal module.
+   */
+  getContentAdapter?: () => ContentAdapter;
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+/**
+ * Builds the locale-prefixed URL for a given locale and path.
+ * Default locale uses bare path; non-default uses /<locale>/<path>.
+ */
+function buildLocaleUrl(
+  baseUrl: string,
+  locale: string,
+  defaultLocale: string,
+  path: string,
+): string {
+  if (locale === defaultLocale) {
+    return `${baseUrl}${path}`;
+  }
+  // Avoid double-slash: path starts with "/", locale prefix ends without one.
+  return `${baseUrl}/${locale}${path}`;
+}
+
+/**
+ * Build a sitemap GET handler parameterised by deps.
+ * Tests inject a stub `getContentAdapter` to avoid mocking the internal module.
+ */
+export function createSitemapHandler(deps: SitemapHandlerDeps = {}) {
+  const resolveAdapter = deps.getContentAdapter ?? defaultGetContentAdapter;
+  return async function sitemapGET(): Promise<Response> {
+    const adapter = resolveAdapter();
+    const baseUrl = resolveBaseUrl();
+    const today = new Date().toISOString().slice(0, 10);
+    // Locale list and default locale are baked at build time by next.config.mjs
+    // from project.yaml. Reading env vars here mirrors middleware.ts exactly —
+    // avoids node:fs in prerender context where cwd != repo root.
+    const locales = (process.env.NEXT_PUBLIC_ENABLED_LOCALES ?? "en").split(",");
+    const defaultLocale = process.env.NEXT_PUBLIC_DEFAULT_LOCALE ?? "en";
+
+    const urlEntries: string[] = [];
+
+    const types = SCHEMA_ORG_TYPES as readonly SchemaOrgType[];
+
+    // Build (locale, type) tuples and fetch all lists in parallel. Adapter
+    // list calls are locale-scoped (no cross-locale fallback), so each locale
+    // gets its own enumeration — a page that exists only in `en/` is NOT
+    // auto-emitted for `es/` URLs. This honors AC-i18n-08 (lists scoped).
+    const tuples = locales.flatMap((locale) =>
+      types.map((type) => ({ locale, type })),
+    );
+    const lists = await Promise.all(
+      tuples.map(({ type, locale }) => adapter.listPages(type, locale)),
+    );
+
+    for (let i = 0; i < tuples.length; i++) {
+      const { locale } = tuples[i]!;
+      for (const page of lists[i]!) {
+        const path = slugToPath(page.type, page.slug);
+        const lastmod = page.publishedAt ?? today;
+
+        const defaultUrl = `${baseUrl}${path}`;
+        const localeUrl = buildLocaleUrl(baseUrl, locale, defaultLocale, path);
+        const loc = escapeXml(localeUrl);
+
+        const alternates = locales
+          .map(
+            (alt) =>
+              `    <xhtml:link rel="alternate" hreflang="${escapeXml(alt)}" href="${escapeXml(buildLocaleUrl(baseUrl, alt, defaultLocale, path))}"/>`,
+          )
+          .join("\n");
+
+        const xDefault = `    <xhtml:link rel="alternate" hreflang="x-default" href="${escapeXml(defaultUrl)}"/>`;
+
+        urlEntries.push(
+          `  <url>\n    <loc>${loc}</loc>\n    <lastmod>${lastmod}</lastmod>\n${alternates}\n${xDefault}\n  </url>`,
+        );
+      }
+    }
+
+    const xml = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">',
+      ...urlEntries,
+      "</urlset>",
+    ].join("\n");
+
+    return new Response(xml, {
+      status: 200,
+      headers: {
+        "content-type": "application/xml; charset=utf-8",
+        "cache-control": "public, max-age=3600",
+      },
+    });
+  };
+}
+
+export const GET = createSitemapHandler();

package/templates/apps/web/auth.ts

@@ -0,0 +1,141 @@
+/**
+ * Better Auth initialisation — Node.js runtime only.
+ *
+ * Wires Better Auth's Prisma adapter (DB session strategy) against the
+ * `prismaForAuth` singleton in `./lib/prisma-for-auth.ts`. The adapter mediates
+ * all DB access so apps/web never imports @working-theory/database elsewhere.
+ *
+ * Exports:
+ *   createAuth — factory that accepts optional `prisma` dep for testing.
+ *   auth — lazy-proxy singleton using the real `prismaForAuth` client.
+ *          `auth.handler` is the Web Fetch handler consumed by
+ *          app/api/auth/[...all]/route.ts (via toNextJsHandler).
+ *          `auth.api.getSession({ headers })` reads the active session
+ *          server-side.
+ *
+ * Provider activation follows env-var presence (see lib/auth-env.ts) so the
+ * OSS standalone default — no env vars set — boots cleanly with zero providers.
+ *
+ * DI note: `createAuth` accepts an optional `prisma` client for testing —
+ * tests can pass a lightweight stub to avoid a real DB connection. The
+ * exported `auth` singleton uses the real `prismaForAuth` client.
+ * Pattern mirrors `apps-paid/dashboard-web/auth.ts`.
+ *
+ * Replaces the NextAuth v5-beta wiring per spec
+ * docs/internal/specs/ailk-pre-oss-security-phase-0.5-s0.5-better-auth-migration-spec.md.
+ */
+ 
+import type { PrismaClient } from "@working-theory/database";
+import { betterAuth } from "better-auth";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { nextCookies } from "better-auth/next-js";
+
+import { getActiveProviderIds } from "./lib/auth-env";
+
+// Lazy-load prisma-for-auth: import is deferred until createAuth() is called
+// without an explicit `prisma` dep. This prevents the PrismaClient singleton
+// from initialising (and calling @working-theory/database) at module-load time, which
+// lets tests import `createAuth` without triggering a DB connection.
+function getDefaultPrisma(): PrismaClient {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { prismaForAuth } = require("./lib/prisma-for-auth") as {
+    prismaForAuth: PrismaClient;
+  };
+  return prismaForAuth;
+}
+
+type SocialProviders = {
+  google?: { clientId: string; clientSecret: string };
+  github?: { clientId: string; clientSecret: string };
+};
+
+function buildSocialProviders(): SocialProviders {
+  const activeIds = getActiveProviderIds();
+  const providers: SocialProviders = {};
+
+  if (activeIds.includes("google")) {
+    providers.google = {
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    };
+  }
+
+  if (activeIds.includes("github")) {
+    providers.github = {
+      clientId: process.env.GITHUB_CLIENT_ID!,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+    };
+  }
+
+  // "email" is reported by getActiveProviderIds when AUTH_EMAIL_SERVER +
+  // AUTH_EMAIL_FROM are set, but Better Auth core does not ship a built-in
+  // magic-link provider — that wiring is deferred to a follow-up
+  // (see spec §7 "Out of Scope").
+
+  return providers;
+}
+
+/**
+ * Resolve the secret used to sign session cookies. Better Auth requires a
+ * secret in production. In dev / test the bare default keeps the app bootable
+ * without configuration; production deployments MUST set BETTER_AUTH_SECRET.
+ */
+function resolveSecret(): string {
+  return (
+    process.env.BETTER_AUTH_SECRET ??
+    "ailk-dev-secret-do-not-use-in-production"
+  );
+}
+
+export interface CreateAuthDeps {
+  /**
+   * Prisma client for the Better Auth adapter.
+   * Defaults to the singleton from `lib/prisma-for-auth.ts`.
+   * Override in tests to pass a lightweight stub and avoid a real DB
+   * connection at module-load time.
+   */
+  prisma?: PrismaClient;
+}
+
+/**
+ * Build a Better Auth instance parameterised by deps.
+ *
+ * Convention mirrors `apps-paid/marketing-api/src/routes/v1/account/license.ts`:
+ * the factory accepts optional deps with defaults to real implementations so
+ * existing callers (`import { auth }`) are unchanged.
+ */
+export function createAuth(deps: CreateAuthDeps = {}) {
+  const prisma = deps.prisma ?? getDefaultPrisma();
+  return betterAuth({
+    database: prismaAdapter(prisma, {
+      provider: "postgresql",
+    }),
+    secret: resolveSecret(),
+    baseURL: process.env.BETTER_AUTH_URL,
+    socialProviders: buildSocialProviders(),
+    // Persist sessions in the database so admin revocation by row delete remains
+    // the model the dual-mode preHandler relies on.
+    session: {
+      expiresIn: 60 * 60 * 24 * 7, // 7 days
+      updateAge: 60 * 60 * 24, // refresh in DB once per day
+    },
+    plugins: [nextCookies()],
+  });
+}
+
+// Lazy singleton: resolved on first access, not at module-load time.
+// Defers the `require("./lib/prisma-for-auth")` call until auth is actually
+// used, so tests can `import { createAuth }` without triggering a DB connection.
+let _auth: ReturnType<typeof createAuth> | undefined;
+
+export const auth: ReturnType<typeof createAuth> = new Proxy(
+  {} as ReturnType<typeof createAuth>,
+  {
+    get(_, prop: string | symbol) {
+      if (!_auth) _auth = createAuth();
+      return _auth[prop as keyof ReturnType<typeof createAuth>];
+    },
+  },
+);
+
+export type Auth = typeof auth;

package/templates/apps/web/components/ThemeToggle.tsx

@@ -0,0 +1,60 @@
+"use client";
+
+// ThemeToggle — narrow client component for theme switching (#1322)
+//
+// OSS template mirror of apps-paid/marketing-web/components/ThemeToggle.tsx.
+// Reads current theme from document.documentElement.dataset.theme, toggles
+// between "light" and "dark", persists to the ailk-theme cookie, and updates
+// the DOM attribute synchronously.
+//
+// This is the ONLY "use client" component added to the layout tree.
+
+import type { ReactElement } from "react";
+import { useCallback, useEffect, useState } from "react";
+
+const COOKIE_NAME = process.env.NEXT_PUBLIC_THEME_COOKIE_NAME ?? "ailk-theme";
+
+function readCurrentTheme(): "light" | "dark" {
+  const attr = document.documentElement.getAttribute("data-theme");
+  return attr === "dark" ? "dark" : "light";
+}
+
+function setCookieTheme(theme: "light" | "dark"): void {
+  document.cookie = `${COOKIE_NAME}=${theme}; path=/; max-age=31536000; SameSite=Lax`;
+}
+
+interface Props {
+  "data-testid"?: string;
+}
+
+export default function ThemeToggle({
+  "data-testid": testId,
+}: Props): ReactElement {
+  const [theme, setTheme] = useState<"light" | "dark">("light");
+
+  useEffect(() => {
+    const current = readCurrentTheme();
+    setTheme(current);
+  }, []);
+
+  const toggle = useCallback(() => {
+    const next = theme === "light" ? "dark" : "light";
+    document.documentElement.setAttribute("data-theme", next);
+    setCookieTheme(next);
+    setTheme(next);
+  }, [theme]);
+
+  const isDark = theme === "dark";
+
+  return (
+    <button
+      type="button"
+      aria-pressed={isDark}
+      aria-label={isDark ? "Switch to light mode" : "Switch to dark mode"}
+      data-testid={testId}
+      onClick={toggle}
+    >
+      {isDark ? "Light" : "Dark"}
+    </button>
+  );
+}

package/templates/apps/web/components/google-analytics.tsx

@@ -0,0 +1,34 @@
+// Google Analytics gtag wiring (#886). When NEXT_PUBLIC_GOOGLE_TAG_ID is set,
+// every page emits the canonical gtag.js loader script + inline init script in
+// <head>. When unset, renders null — no GA traffic at all.
+//
+// Sam's call (#886): fires whenever NEXT_PUBLIC_GOOGLE_TAG_ID is set, regardless
+// of STEALTH. Pre-launch internal traffic will hit GA; filter in GA if needed.
+//
+// Mirrored by sibling components in apps-paid/marketing-web/ and
+// apps-paid/dashboard-web/. Three-way duplication is deliberate — keeps each
+// app self-contained for the OSS fork model (apps/web ships in the public
+// template).
+import Script from "next/script";
+import type { ReactElement } from "react";
+
+export function GoogleAnalytics(): ReactElement | null {
+  const tagId = process.env.NEXT_PUBLIC_GOOGLE_TAG_ID;
+  if (!tagId) {
+    return null;
+  }
+  return (
+    <>
+      <Script
+        src={`https://www.googletagmanager.com/gtag/js?id=${tagId}`}
+        strategy="afterInteractive"
+      />
+      <Script id="ga-init" strategy="afterInteractive">
+        {`window.dataLayer = window.dataLayer || [];
+function gtag(){dataLayer.push(arguments);}
+gtag('js', new Date());
+gtag('config', '${tagId}');`}
+      </Script>
+    </>
+  );
+}

package/templates/apps/web/content/en/blog/index.mdx

@@ -0,0 +1,15 @@
+---
+title: Blog
+description: Writing on AEO, answer-engine citation readiness, and what it means to ship software with three peers — UX, API, and MCP.
+author:
+  name: The AI Launch Kit Team
+tags:
+  - AEO
+  - AX
+---
+
+# Blog
+
+This is where we think out loud. The topics stay close to the work: schema.org implementation details, how LLMs decide what to cite, and what AX-first looks like in practice.
+
+The posts are opinionated because vague advice isn't useful. If something here turns out to be wrong, we'll update it and say so.

package/templates/apps/web/content/en/blog/launching-ailk.mdx

@@ -0,0 +1,20 @@
+---
+title: Launching AI Launch Kit
+description: A short note on why we built an AX-first OSS template and what ships in v1.
+date: "2026-05-06"
+author:
+  name: The AI Launch Kit Team
+tags:
+  - Announcements
+  - AX
+---
+
+# Launching AI Launch Kit
+
+We're shipping the first public version today. The template gives you three
+peer apps (web, api, mcp), a content-adapter contract with MDX as the default
+backend, and a JSON-LD pipeline for SEO that doesn't require manual schema.org
+authoring.
+
+The goal is clone-to-shipping in under an hour. If you hit friction, the
+README's standalone test should catch it before you do.

package/templates/apps/web/content/en/docs/getting-started.mdx

@@ -0,0 +1,30 @@
+---
+title: Getting Started
+description: Everything you need to know to get your AI Launch Kit project running.
+---
+
+# Getting Started
+
+Welcome to AI Launch Kit. This guide walks you through the first steps after cloning the template.
+
+## Prerequisites
+
+- Node.js 20+
+- pnpm 9+
+
+## Quick start
+
+```bash
+pnpm install
+pnpm dev
+```
+
+The dev server starts three apps in parallel:
+
+- **web** (`localhost:3000`) — the Next.js UX surface
+- **api** (`localhost:3001`) — the Fastify REST API
+- **mcp** — the MCP server (stdio transport)
+
+## Next steps
+
+Replace the seed content in `apps/web/content/en/` with your own pages, blog posts, and docs. Each MDX file maps to a route automatically via Fumadocs.

package/templates/apps/web/i18n/request.ts

@@ -0,0 +1,36 @@
+// i18n S2 — next-intl getRequestConfig entry point (#949)
+//
+// Reads the message catalog for the requested locale and falls back to
+// English when no catalog exists (e.g. a locale is enabled in project.yaml
+// but its messages/<locale>.json has not been translated yet).
+//
+// Spec: docs/internal/specs/i18n-phase1-s2-next-intl-foundation-spec.md
+
+import type { AbstractIntlMessages } from "next-intl";
+import { getRequestConfig } from "next-intl/server";
+
+const DEFAULT_LOCALE = "en";
+
+export default getRequestConfig(async ({ requestLocale }) => {
+  // requestLocale is the modern API (next-intl >= 3.22). It resolves the
+  // active locale from the request, validated by middleware.
+  const locale = (await requestLocale) ?? DEFAULT_LOCALE;
+
+  // Attempt to load the locale catalog; fall back to English on any error.
+  let messages: AbstractIntlMessages;
+  try {
+    // Dynamic import — bundler can tree-shake per-locale at build time.
+    const mod = await import(`../messages/${locale}.json`).catch(() => null);
+    if (mod) {
+      messages = (mod.default ?? mod) as AbstractIntlMessages;
+    } else {
+      const fallback = await import(`../messages/${DEFAULT_LOCALE}.json`);
+      messages = (fallback.default ?? fallback) as AbstractIntlMessages;
+    }
+  } catch {
+    const fallback = await import(`../messages/${DEFAULT_LOCALE}.json`);
+    messages = (fallback.default ?? fallback) as AbstractIntlMessages;
+  }
+
+  return { locale, messages };
+});