@starci/hfs 3.0.0 → 4.0.1

package/templates/be/skeleton/src/modules/platform/i18n/i18n.module.ts

@@ -0,0 +1,24 @@
+import { Module } from "@nestjs/common"
+import type { DynamicModule } from "@nestjs/common"
+import { BundleMessageCatalog } from "./bundle-message-catalog.service"
+import { MESSAGE_CATALOG, REQUEST_LOCALE } from "./i18n.decorators"
+import { ConfigurableModuleClass, OPTIONS_TYPE } from "./i18n.module-definition"
+import { AcceptLanguageRequestLocale } from "./request-locale.service"
+
+@Module({})
+/** Provides the MessageCatalog and RequestLocale ports. */
+export class I18nModule extends ConfigurableModuleClass {
+    /** Registers the capability once per app with the bundles of every owner it composes. */
+    static register(options: typeof OPTIONS_TYPE): DynamicModule {
+        const base = super.register(options)
+        return {
+            ...base,
+            providers: [
+                ...(base.providers ?? []),
+                { provide: MESSAGE_CATALOG, useClass: BundleMessageCatalog },
+                { provide: REQUEST_LOCALE, useClass: AcceptLanguageRequestLocale },
+            ],
+            exports: [MESSAGE_CATALOG, REQUEST_LOCALE],
+        }
+    }
+}

package/templates/be/skeleton/src/modules/platform/i18n/i18n.options.ts

@@ -0,0 +1,7 @@
+import type { MessageBundle } from "./i18n.contracts"
+
+/** Options of the i18n capability: every owner catalog the app composes. */
+export interface I18nOptions {
+    /** The bundles to merge; each key belongs to exactly one bundle. */
+    readonly bundles: ReadonlyArray<MessageBundle>
+}

package/templates/be/skeleton/src/modules/platform/i18n/i18n.port.ts

@@ -0,0 +1,13 @@
+import type { AcceptLanguage, Locale, MessageParams } from "./i18n.contracts"
+
+/** The message catalog port: a keyed lookup with named interpolation over the bundles the app composes. */
+export interface MessageCatalog {
+    /** The text of `key` in `locale` with `{{name}}` placeholders filled from `params`; an unknown key answers the key itself. */
+    get(key: string, params: MessageParams, locale: Locale): string
+}
+
+/** Picks the locale of one request. */
+export interface RequestLocale {
+    /** The locale of an `Accept-Language` header value: Vietnamese or English, Vietnamese when it names neither. */
+    of(acceptLanguage: AcceptLanguage): Locale
+}

package/templates/be/skeleton/src/modules/platform/i18n/index.ts

@@ -0,0 +1,4 @@
+export type { Locale, MessageBundle } from "./i18n.contracts"
+export { InjectMessageCatalog, InjectRequestLocale, MESSAGE_CATALOG } from "./i18n.decorators"
+export { I18nModule } from "./i18n.module"
+export type { MessageCatalog, RequestLocale } from "./i18n.port"

package/templates/be/skeleton/src/modules/platform/i18n/request-locale.service.spec.ts

@@ -0,0 +1,45 @@
+import { Test } from "@nestjs/testing"
+import { AcceptLanguageRequestLocale } from "./request-locale.service"
+
+const build = async () => {
+    const moduleRef = await Test.createTestingModule({ providers: [AcceptLanguageRequestLocale] }).compile()
+    return moduleRef.get(AcceptLanguageRequestLocale)
+}
+
+describe("AcceptLanguageRequestLocale", () => {
+    describe("of", () => {
+        it.each([
+            ["en-US,en;q=0.9,vi;q=0.8", "en"],
+            ["vi-VN,vi;q=0.9", "vi"],
+            ["EN", "en"],
+        ])("picks the first supported language of %s", async (header, expected) => {
+            const locale = await build()
+
+            expect(locale.of(header)).toBe(expected)
+        })
+
+        it("skips unsupported languages until a supported one", async () => {
+            const locale = await build()
+
+            expect(locale.of("fr-FR, de;q=0.8, en;q=0.5")).toBe("en")
+        })
+
+        it("joins a header sent as several lines", async () => {
+            const locale = await build()
+
+            expect(locale.of(["fr", "en-GB"])).toBe("en")
+        })
+
+        it("defaults to Vietnamese when nothing supported is listed", async () => {
+            const locale = await build()
+
+            expect(locale.of("fr, de")).toBe("vi")
+        })
+
+        it("defaults to Vietnamese when the header is absent", async () => {
+            const locale = await build()
+
+            expect(locale.of(undefined)).toBe("vi")
+        })
+    })
+})

package/templates/be/skeleton/src/modules/platform/i18n/request-locale.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@nestjs/common"
+import type { AcceptLanguage, Locale } from "./i18n.contracts"
+import type { RequestLocale } from "./i18n.port"
+
+const DEFAULT_LOCALE: Locale = "vi"
+
+@Injectable()
+/** Picks Vietnamese or English from Accept-Language, Vietnamese by default (this example stores no user preference). */
+export class AcceptLanguageRequestLocale implements RequestLocale {
+    /** The first listed language that is Vietnamese or English, Vietnamese when none is. */
+    of(acceptLanguage: AcceptLanguage): Locale {
+        const header = typeof acceptLanguage === "string" ? acceptLanguage : (acceptLanguage ?? []).join(",")
+        for (const part of header.split(",")) {
+            const language = part.trim().slice(0, 2).toLowerCase()
+            if (language === "vi" || language === "en") return language
+        }
+        return DEFAULT_LOCALE
+    }
+}

package/templates/be/skeleton/src/modules/platform/logging/index.ts

@@ -1,5 +1,5 @@
 export { createJsonLogger } from "./json-logger.service"
-export { InjectLogger } from "./logging.decorators"
+export { InjectLogger, LOGGER } from "./logging.decorators"
 export { LoggingLogEvent } from "./logging.log-events"
 export { LoggingModule } from "./logging.module"
 export type { Logger } from "./logging.port"

package/templates/be/skeleton/src/modules/platform/logging/json-logger.service.spec.ts

@@ -1,99 +1,116 @@
-import { Test } from "@nestjs/testing"
-import { FakeClock } from "@starci/jest-preset"
+import type { Writable } from "node:stream"
+import { FakeClock, mock } from "@starci/jest-preset"
 import { CLOCK } from "@modules/platform/clock"
-import { JsonLoggerService, createJsonLogger } from "./json-logger.service"
-
-const TIME = "2026-01-01T00:00:00.000Z"
+import { Test } from "@nestjs/testing"
+import { createJsonLogger, JsonLoggerService } from "./json-logger.service"
+import { LOG_ERR, LOG_OUT } from "./logging.decorators"
+import { LoggingLogEvent } from "./logging.log-events"
 
 const build = async () => {
-    const clock = new FakeClock(TIME)
+    const clock = new FakeClock("2026-05-06T07:08:09.000Z")
+    const written: Array<{ stream: "out" | "err"; line: string }> = []
+    const out = mock<Writable>({
+        write: (chunk: string) => {
+            written.push({ stream: "out", line: chunk })
+            return true
+        },
+    })
+    const err = mock<Writable>({
+        write: (chunk: string) => {
+            written.push({ stream: "err", line: chunk })
+            return true
+        },
+    })
     const moduleRef = await Test.createTestingModule({
-        providers: [JsonLoggerService, { provide: CLOCK, useValue: clock }],
+        providers: [
+            JsonLoggerService,
+            { provide: CLOCK, useValue: clock },
+            { provide: LOG_OUT, useValue: out },
+            { provide: LOG_ERR, useValue: err },
+        ],
     }).compile()
-    return { service: moduleRef.get(JsonLoggerService), clock }
+    return { logger: moduleRef.get(JsonLoggerService), clock, written }
 }
 
-/** One JSON line, the way the logger writes it. */
-const line = (fields: Record<string, unknown>): string => `${JSON.stringify(fields)}\n`
-
 describe("JsonLoggerService", () => {
-    const stdout: Array<string> = []
-    const stderr: Array<string> = []
-
-    beforeEach(() => {
-        stdout.length = 0
-        stderr.length = 0
-        jest.spyOn(process.stdout, "write").mockImplementation((chunk) => {
-            stdout.push(String(chunk))
-            return true
-        })
-        jest.spyOn(process.stderr, "write").mockImplementation((chunk) => {
-            stderr.push(String(chunk))
-            return true
-        })
-    })
+    it("writes an info line to the out stream stamped by the clock", async () => {
+        const { logger, written } = await build()
 
-    afterEach(() => {
-        jest.restoreAllMocks()
-    })
+        logger.info("cart.opened", { personId: "p-1" })
 
-    describe("info", () => {
-        it("stamps the line with the clock and writes it to stdout", async () => {
-            const { service } = await build()
-
-            service.info("thing.happened", { id: 1 })
-
-            expect(stdout).toEqual([line({ level: "info", event: "thing.happened", time: TIME, id: 1 })])
-            expect(stderr).toEqual([])
-        })
+        expect(written).toEqual([
+            {
+                stream: "out",
+                line: `${JSON.stringify({ level: "info", event: "cart.opened", time: "2026-05-06T07:08:09.000Z", personId: "p-1" })}\n`,
+            },
+        ])
     })
 
-    describe("warn", () => {
-        it("writes the line to stderr, stamped with the moment of the call", async () => {
-            const { service, clock } = await build()
-            clock.advance(5_000)
+    it("writes a warn line without fields to the err stream", async () => {
+        const { logger, clock, written } = await build()
+        clock.advance(1000)
 
-            service.warn("thing.slow")
+        logger.warn(LoggingLogEvent.StartupFailed)
 
-            expect(stderr).toEqual([line({ level: "warn", event: "thing.slow", time: "2026-01-01T00:00:05.000Z" })])
-            expect(stdout).toEqual([])
-        })
+        expect(written).toEqual([
+            {
+                stream: "err",
+                line: `${JSON.stringify({ level: "warn", event: LoggingLogEvent.StartupFailed, time: "2026-05-06T07:08:10.000Z" })}\n`,
+            },
+        ])
     })
 
-    describe("error", () => {
-        it("serializes an Error cause by name and message", async () => {
-            const { service } = await build()
+    it("writes an error line with the name and message of an Error cause", async () => {
+        const { logger, written } = await build()
 
-            service.error("thing.failed", new TypeError("boom"), { id: 2 })
+        logger.error("db.failed", new TypeError("boom"), { operation: "PlaceOrderHandler" })
 
-            expect(stderr).toEqual([
-                line({
+        expect(written).toEqual([
+            {
+                stream: "err",
+                line: `${JSON.stringify({
                     level: "error",
-                    event: "thing.failed",
-                    time: TIME,
+                    event: "db.failed",
+                    time: "2026-05-06T07:08:09.000Z",
                     errorName: "TypeError",
                     errorMessage: "boom",
-                    id: 2,
-                }),
-            ])
-        })
+                    operation: "PlaceOrderHandler",
+                })}\n`,
+            },
+        ])
+    })
 
-        it("serializes a cause that is not an Error to its text", async () => {
-            const { service } = await build()
+    it("writes an error line with the text of a cause that is not an Error", async () => {
+        const { logger, written } = await build()
 
-            service.error("thing.failed", "plain text")
+        logger.error("db.failed", "plain failure")
 
-            expect(stderr).toEqual([
-                line({ level: "error", event: "thing.failed", time: TIME, errorMessage: "plain text" }),
-            ])
-        })
+        expect(written).toEqual([
+            {
+                stream: "err",
+                line: `${JSON.stringify({ level: "error", event: "db.failed", time: "2026-05-06T07:08:09.000Z", errorMessage: "plain failure" })}\n`,
+            },
+        ])
     })
 
     describe("createJsonLogger", () => {
-        it("builds a logger stamped by the given clock", () => {
-            createJsonLogger(new FakeClock(TIME)).info("thing.started")
+        afterEach(() => {
+            jest.restoreAllMocks()
+        })
 
-            expect(stdout).toEqual([line({ level: "info", event: "thing.started", time: TIME })])
+        it("builds a logger that writes info to stdout and errors to stderr, stamped by the clock", () => {
+            const lines: Array<string> = []
+            jest.spyOn(process.stdout, "write").mockImplementation((chunk) => lines.push(`out:${String(chunk)}`) > 0)
+            jest.spyOn(process.stderr, "write").mockImplementation((chunk) => lines.push(`err:${String(chunk)}`) > 0)
+            const logger = createJsonLogger(new FakeClock("2026-05-06T07:08:09.000Z"))
+
+            logger.info(LoggingLogEvent.ServerStarted)
+            logger.warn(LoggingLogEvent.StartupFailed)
+
+            expect(lines).toEqual([
+                `out:${JSON.stringify({ level: "info", event: LoggingLogEvent.ServerStarted, time: "2026-05-06T07:08:09.000Z" })}\n`,
+                `err:${JSON.stringify({ level: "warn", event: LoggingLogEvent.StartupFailed, time: "2026-05-06T07:08:09.000Z" })}\n`,
+            ])
         })
     })
 })

package/templates/be/skeleton/src/modules/platform/logging/json-logger.service.ts

@@ -1,23 +1,27 @@
-import { Injectable } from "@nestjs/common"
+import type { Writable } from "node:stream"
 import { InjectClock } from "@modules/platform/clock"
 import type { Clock } from "@modules/platform/clock"
+import { InjectLogErr, InjectLogOut } from "./logging.decorators"
 import type { LogFields, Logger } from "./logging.port"
 
 type Level = "info" | "warn" | "error"
 
-@Injectable()
-/** The default adapter: one JSON object per line, stamped by the Clock; info goes to stdout, warn and error to stderr. */
+/** The default adapter: one JSON object per line, stamped by the Clock; info goes to `out`, warn and error to `err`. */
 export class JsonLoggerService implements Logger {
-    constructor(@InjectClock() private readonly clock: Clock) {}
+    constructor(
+        @InjectClock() private readonly clock: Clock,
+        @InjectLogOut() private readonly out: Writable,
+        @InjectLogErr() private readonly err: Writable,
+    ) {}
 
     /** Writes an info line. */
     info(event: string, fields?: LogFields): void {
-        this.write("info", process.stdout, event, fields)
+        this.write("info", this.out, event, fields)
     }
 
     /** Writes a warn line. */
     warn(event: string, fields?: LogFields): void {
-        this.write("warn", process.stderr, event, fields)
+        this.write("warn", this.err, event, fields)
     }
 
     /** Writes an error line with the cause serialized by name and message. */
@@ -26,13 +30,13 @@ export class JsonLoggerService implements Logger {
             cause instanceof Error
                 ? { errorName: cause.name, errorMessage: cause.message }
                 : { errorMessage: String(cause) }
-        this.write("error", process.stderr, event, { ...detail, ...fields })
+        this.write("error", this.err, event, { ...detail, ...fields })
     }
 
-    private write(level: Level, sink: NodeJS.WriteStream, event: string, fields?: LogFields): void {
+    private write(level: Level, sink: Writable, event: string, fields?: LogFields): void {
         sink.write(`${JSON.stringify({ level, event, time: this.clock.now().toISOString(), ...fields })}\n`)
     }
 }
 
-/** Builds the JSON logger stamping lines with `clock`; main.ts uses it before the DI container exists. */
-export const createJsonLogger = (clock: Clock): Logger => new JsonLoggerService(clock)
+/** Builds the JSON logger stamping lines with `clock` on stdout and stderr; main.ts uses it before the DI container exists. */
+export const createJsonLogger = (clock: Clock): Logger => new JsonLoggerService(clock, process.stdout, process.stderr)

package/templates/be/skeleton/src/modules/platform/logging/logging.decorators.ts

@@ -1,3 +1,4 @@
+import type { Writable } from "node:stream"
 import { injector } from "@modules/platform/composition"
 import type { TypedParameterDecorator } from "@modules/platform/composition"
 import type { Logger } from "./logging.port"
@@ -7,3 +8,15 @@ export const LOGGER: unique symbol = Symbol("platform.logging.logger")
 
 /** Injects the Logger port. Parameter type: Logger. */
 export const InjectLogger = (): TypedParameterDecorator<Logger> => injector<Logger>(LOGGER)
+
+/** Token of the stream info lines go to. */
+export const LOG_OUT: unique symbol = Symbol("platform.logging.out")
+
+/** Token of the stream warn and error lines go to. */
+export const LOG_ERR: unique symbol = Symbol("platform.logging.err")
+
+/** Injects the stream info lines go to. Parameter type: Writable. */
+export const InjectLogOut = (): TypedParameterDecorator<Writable> => injector<Writable>(LOG_OUT)
+
+/** Injects the stream warn and error lines go to. Parameter type: Writable. */
+export const InjectLogErr = (): TypedParameterDecorator<Writable> => injector<Writable>(LOG_ERR)

package/templates/be/skeleton/src/modules/platform/logging/logging.log-events.ts

@@ -4,4 +4,8 @@ export enum LoggingLogEvent {
     ServerStarted = "server.started",
     /** The service failed before it could serve; the process exits non-zero. */
     StartupFailed = "server.startup_failed",
+    /** The worker started: its jobs are ticking and its consumers are polling. */
+    WorkerStarted = "worker.started",
+    /** The migrate app finished; the names of the applied migrations ride in the fields. */
+    MigrationsApplied = "migrations.applied",
 }

package/templates/be/skeleton/src/modules/platform/logging/logging.port.ts

@@ -1,6 +1,5 @@
 /** The structured data of one log line; values are plain data, never a request, a token or a secret. */
 export interface LogFields {
-    /** The value logged under `name`. */
     readonly [name: string]: unknown
 }
 

package/templates/be/skeleton/src/modules/platform/primitives/index.ts

@@ -0,0 +1,2 @@
+export type { Outcome } from "./outcome.contracts"
+export { ok, refused, unwrapOutcome } from "./outcome.mapper"

package/templates/be/skeleton/src/modules/platform/primitives/outcome.contracts.ts

@@ -0,0 +1,25 @@
+import type { DomainError, DomainErrorInit, ErrorParams } from "@modules/platform/errors"
+
+/** The success half of an outcome: the value the operation produced. */
+export interface OutcomeOk<V> {
+    /** Discriminant of the success half. */
+    readonly kind: "ok"
+    /** The value the operation produced. */
+    readonly value: V
+}
+
+/** The expected-refusal half of an outcome: a capability code and the parameters of its display text. */
+export interface OutcomeRefused<C extends string> {
+    /** Discriminant of the refusal half. */
+    readonly kind: "refused"
+    /** The capability code of the refusal, a member of its code enum. */
+    readonly code: C
+    /** Values for the placeholders of the display text. */
+    readonly params?: ErrorParams
+}
+
+/** The result of an operation that can be refused for an expected business reason: returned, never thrown. */
+export type Outcome<V, C extends string> = OutcomeOk<V> | OutcomeRefused<C>
+
+/** The class of a capability error family, as `unwrapOutcome` constructs it from a refusal. */
+export type OutcomeErrorClass<K extends string> = new (init: DomainErrorInit<K>) => DomainError<K>

package/templates/be/skeleton/src/modules/platform/primitives/outcome.mapper.ts

@@ -0,0 +1,24 @@
+import type { ErrorParams } from "@modules/platform/errors"
+import type { Outcome, OutcomeErrorClass, OutcomeOk, OutcomeRefused } from "./outcome.contracts"
+
+/** Wraps a produced value as a successful outcome. */
+export const ok = <V>(value: V): OutcomeOk<V> => ({ kind: "ok", value })
+
+/** Builds a refusal with a capability code and the parameters of its display text. */
+export const refused = <C extends string>(code: C, params?: ErrorParams): OutcomeRefused<C> => ({
+    kind: "refused",
+    code,
+    params,
+})
+
+/**
+ * Returns the value of a successful outcome; a refusal becomes the capability error of `ErrorClass`. This is the only
+ * place a refusal turns into a throw, and it runs in the transport.
+ */
+export const unwrapOutcome = <V, C extends K, K extends string>(
+    outcome: Outcome<V, C>,
+    ErrorClass: OutcomeErrorClass<K>,
+): V => {
+    if (outcome.kind === "ok") return outcome.value
+    throw new ErrorClass({ code: outcome.code, params: outcome.params })
+}

package/templates/fe/skeleton/apps/__app__/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+    plugins: {
+        "@tailwindcss/postcss": {},
+    },
+}
+
+export default config

package/templates/fe/skeleton/apps/__app__/src/app/[locale]/error.tsx

@@ -1,22 +1,10 @@
 "use client"
 
-import { useTranslations } from "next-intl"
+import { ErrorPage } from "@/features/pages/ErrorPage"
 
-interface ErrorPageProps {
-    readonly reset: () => void
-}
+type ErrorProps = { readonly reset: () => void }
 
-/** Boundary of the locale segment: a render failure shows this instead of a blank page, and retry re-renders the segment. */
-const ErrorPage = ({ reset }: ErrorPageProps) => {
-    const t = useTranslations("errors.page")
-    return (
-        <main role="alert">
-            <h1>{t("title")}</h1>
-            <button type="button" onClick={reset}>
-                {t("retry")}
-            </button>
-        </main>
-    )
-}
+/** The locale segment's error boundary slot: it mounts the error page and hands it the segment's retry. */
+const Error = (props: ErrorProps) => <ErrorPage onRetry={props.reset} />
 
-export default ErrorPage
+export default Error

package/templates/fe/skeleton/apps/__app__/src/app/[locale]/layout.tsx

@@ -1,31 +1,20 @@
-import { hasLocale, NextIntlClientProvider } from "next-intl"
-import { getMessages, setRequestLocale } from "next-intl/server"
-import { notFound } from "next/navigation"
+import type { Metadata } from "next"
 import type { ReactNode } from "react"
-import { routing } from "../../modules/i18n"
+import { LocaleShell, localeMetadata } from "@/features/layouts/LocaleShell"
 import "../globals.css"
 
-interface LocaleLayoutProps {
+type LayoutProps = {
     readonly children: ReactNode
     readonly params: Promise<{ readonly locale: string }>
 }
 
-/** One static shell per served locale. */
-export const generateStaticParams = () => routing.locales.map((locale) => ({ locale }))
+/** The localized document title of this route segment. */
+export const generateMetadata = async (props: LayoutProps): Promise<Metadata> =>
+    localeMetadata((await props.params).locale)
 
-/** Root layout: sets `<html lang>` from the route segment and gives client components only the `errors` namespace. */
-const LocaleLayout = async ({ children, params }: LocaleLayoutProps) => {
-    const { locale } = await params
-    if (!hasLocale(routing.locales, locale)) notFound()
-    setRequestLocale(locale)
-    const messages = await getMessages()
-    return (
-        <html lang={locale}>
-            <body className="min-h-dvh">
-                <NextIntlClientProvider messages={{ errors: messages.errors }}>{children}</NextIntlClientProvider>
-            </body>
-        </html>
-    )
-}
+/** The locale segment's layout slot: it mounts the locale shell around the segment. */
+const Layout = async (props: LayoutProps) => (
+    <LocaleShell lang={(await props.params).locale}>{props.children}</LocaleShell>
+)
 
-export default LocaleLayout
+export default Layout

package/templates/fe/skeleton/apps/__app__/src/app/[locale]/loading.tsx

@@ -0,0 +1,6 @@
+import { LoadingPage } from "@/features/pages/LoadingPage"
+
+/** The locale segment's loading slot: it mounts the loading page and nothing else. */
+const Loading = () => <LoadingPage />
+
+export default Loading

package/templates/fe/skeleton/apps/__app__/src/app/[locale]/not-found.tsx

@@ -1,15 +1,6 @@
-import { getTranslations } from "next-intl/server"
-import { Link } from "../../modules/i18n"
+import { NotFoundPage } from "@/features/pages/NotFoundPage"
 
-/** Shown when a route calls `notFound()`. */
-const NotFound = async () => {
-    const t = await getTranslations("notFound")
-    return (
-        <main>
-            <h1>{t("title")}</h1>
-            <Link href="/">{t("home")}</Link>
-        </main>
-    )
-}
+/** The locale segment's not-found slot: it mounts the not-found page and nothing else. */
+const NotFound = () => <NotFoundPage />
 
 export default NotFound

package/templates/fe/skeleton/apps/__app__/src/app/[locale]/page.tsx

@@ -1,27 +1,9 @@
-import type { Metadata } from "next"
-import { getTranslations, setRequestLocale } from "next-intl/server"
+import { HomePage, homeMetadata } from "@/features/pages/HomePage"
 
-interface HomePageProps {
-    readonly params: Promise<{ readonly locale: string }>
-}
+/** The document title of this page, from the catalog of the requested locale. */
+export const generateMetadata = homeMetadata
 
-/** The document title comes from the catalog of the requested locale. */
-export const generateMetadata = async ({ params }: HomePageProps): Promise<Metadata> => {
-    const { locale } = await params
-    const t = await getTranslations({ locale, namespace: "home" })
-    return { title: t("title") }
-}
+/** The locale root's page slot: it mounts the home page and nothing else. */
+const Page = () => <HomePage />
 
-/** The first page of the app; a server component, so no catalog is shipped for it. */
-const HomePage = async ({ params }: HomePageProps) => {
-    const { locale } = await params
-    setRequestLocale(locale)
-    const t = await getTranslations("home")
-    return (
-        <main>
-            <h1>{t("title")}</h1>
-        </main>
-    )
-}
-
-export default HomePage
+export default Page

package/templates/fe/skeleton/apps/__app__/src/app/global-error.tsx

@@ -1,24 +1,10 @@
 "use client"
 
-import { DEFAULT_LOCALE } from "../modules/i18n"
-import messages from "../modules/i18n/messages/vi.json"
+import { GlobalErrorPage } from "@/features/pages/GlobalErrorPage"
 
-interface GlobalErrorProps {
-    readonly reset: () => void
-}
+type GlobalErrorProps = { readonly reset: () => void }
 
-/** Last-resort boundary above the locale layout: it has no provider, so it reads the default catalog directly. */
-const GlobalError = ({ reset }: GlobalErrorProps) => (
-    <html lang={DEFAULT_LOCALE}>
-        <body>
-            <main role="alert">
-                <h1>{messages.errors.global.title}</h1>
-                <button type="button" onClick={reset}>
-                    {messages.errors.global.retry}
-                </button>
-            </main>
-        </body>
-    </html>
-)
+/** The last-resort error boundary slot: it mounts the global error page and hands it the retry. */
+const GlobalError = (props: GlobalErrorProps) => <GlobalErrorPage onRetry={props.reset} />
 
 export default GlobalError