@starci/hfs 1.0.0

package/templates/be/skeleton/src/modules/platform/config/env-source.spec.ts

@@ -0,0 +1,36 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { EnvSource } from "./env-source"
+import { ConfigError } from "./errors/config.error"
+
+describe("EnvSource", () => {
+    it("reads a key and treats an empty value as unset", () => {
+        const env = EnvSource.of({ PORT: "8080", EMPTY: "" })
+        expect(env.optional("PORT")).toBe("8080")
+        expect(env.optional("EMPTY")).toBeUndefined()
+        expect(env.optional("ABSENT")).toBeUndefined()
+    })
+
+    it("refuses a missing required key by naming it", () => {
+        const failure = () => EnvSource.of({}).required("DATABASE_URL")
+        expect(failure).toThrow(ConfigError)
+        expect(failure).toThrow("Configuration key DATABASE_URL is required and has no default.")
+    })
+
+    it("resolves <KEY>_FILE to the trimmed content of the file", () => {
+        const dir = mkdtempSync(join(tmpdir(), "env-source-"))
+        try {
+            const path = join(dir, "token")
+            writeFileSync(path, "value-from-file\n")
+            expect(EnvSource.of({ API_TOKEN_FILE: path }).required("API_TOKEN")).toBe("value-from-file")
+        } finally {
+            rmSync(dir, { recursive: true, force: true })
+        }
+    })
+
+    it("names the _FILE key, not a path or a value, when the file cannot be read", () => {
+        const failure = () => EnvSource.of({ API_TOKEN_FILE: join(tmpdir(), "no-such-dir", "token") }).optional("API_TOKEN")
+        expect(failure).toThrow("Configuration key API_TOKEN_FILE points at a file that cannot be read.")
+    })
+})

package/templates/be/skeleton/src/modules/platform/config/env-source.ts

@@ -0,0 +1,40 @@
+import { readFileSync } from "node:fs"
+import { ConfigError } from "./errors/config.error"
+
+type Values = Readonly<Record<string, string | undefined>>
+
+/** The only reader of the process environment. Every key may instead be supplied as `<KEY>_FILE`, a path to its value. */
+export class EnvSource {
+    private constructor(private readonly values: Values) {}
+
+    /** The live process environment; called once, from `main.ts`. */
+    static fromProcess(): EnvSource {
+        return new EnvSource(process.env)
+    }
+
+    /** A fixed snapshot, for specs and tools. */
+    static of(values: Values): EnvSource {
+        return new EnvSource(values)
+    }
+
+    /** The value of `key`, or `undefined` when it is unset or empty. */
+    optional(key: string): string | undefined {
+        const path = this.values[`${key}_FILE`]
+        if (path !== undefined && path !== "") {
+            try {
+                return readFileSync(path, "utf8").trim()
+            } catch (cause) {
+                throw new ConfigError("CONFIG_FILE_UNREADABLE", `${key}_FILE`, { cause })
+            }
+        }
+        const value = this.values[key]
+        return value === undefined || value === "" ? undefined : value
+    }
+
+    /** The value of `key`; a missing key stops the boot with an error that names it. */
+    required(key: string): string {
+        const value = this.optional(key)
+        if (value === undefined) throw new ConfigError("CONFIG_KEY_MISSING", key)
+        return value
+    }
+}

package/templates/be/skeleton/src/modules/platform/config/errors/config.error.ts

@@ -0,0 +1,21 @@
+import { DomainError } from "@modules/platform/errors"
+
+/** Why a configuration key was refused. */
+export type ConfigErrorCode = "CONFIG_KEY_MISSING" | "CONFIG_KEY_INVALID" | "CONFIG_FILE_UNREADABLE"
+
+const REASONS: Readonly<Record<ConfigErrorCode, string>> = {
+    CONFIG_KEY_MISSING: "is required and has no default",
+    CONFIG_KEY_INVALID: "does not hold a valid value",
+    CONFIG_FILE_UNREADABLE: "points at a file that cannot be read",
+}
+
+/** Startup configuration refusal: names the key and the rule it broke, never the value it was given. */
+export class ConfigError extends DomainError {
+    /** The environment key that was refused. */
+    readonly key: string
+
+    constructor(code: ConfigErrorCode, key: string, options?: { readonly cause?: unknown }) {
+        super(code, `Configuration key ${key} ${REASONS[code]}.`, options)
+        this.key = key
+    }
+}

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

@@ -0,0 +1,5 @@
+export { EnvSource } from "./env-source"
+export { ConfigError } from "./errors/config.error"
+export { parseServerConfig } from "./server.config"
+export { SERVER_OPTIONS } from "./server.options"
+export type { ServerOptions } from "./server.options"

package/templates/be/skeleton/src/modules/platform/config/server.config.spec.ts

@@ -0,0 +1,19 @@
+import { EnvSource } from "./env-source"
+import { ConfigError } from "./errors/config.error"
+import { parseServerConfig } from "./server.config"
+
+describe("parseServerConfig", () => {
+    it("falls back to port 3000 when PORT is unset", () => {
+        expect(parseServerConfig(EnvSource.of({}))).toEqual({ port: 3000 })
+    })
+
+    it("accepts an integer PORT inside the TCP range", () => {
+        expect(parseServerConfig(EnvSource.of({ PORT: "8080" }))).toEqual({ port: 8080 })
+    })
+
+    it.each(["80a", "0", "70000", "1.5"])("refuses PORT=%s by naming the key only", (port) => {
+        const failure = () => parseServerConfig(EnvSource.of({ PORT: port }))
+        expect(failure).toThrow(ConfigError)
+        expect(failure).toThrow("Configuration key PORT does not hold a valid value.")
+    })
+})

package/templates/be/skeleton/src/modules/platform/config/server.config.ts

@@ -0,0 +1,15 @@
+import type { EnvSource } from "./env-source"
+import { ConfigError } from "./errors/config.error"
+import type { ServerOptions } from "./server.options"
+
+const DEFAULT_PORT = 3000
+const MAX_PORT = 65535
+
+/** Parses the server keys of an environment; a malformed PORT stops the boot. */
+export const parseServerConfig = (env: EnvSource): ServerOptions => {
+    const raw = env.optional("PORT")
+    if (raw === undefined) return { port: DEFAULT_PORT }
+    const port = Number(raw)
+    if (!Number.isInteger(port) || port < 1 || port > MAX_PORT) throw new ConfigError("CONFIG_KEY_INVALID", "PORT")
+    return { port }
+}

package/templates/be/skeleton/src/modules/platform/config/server.options.ts

@@ -0,0 +1,8 @@
+/** The typed server configuration, validated once before the listener starts. */
+export interface ServerOptions {
+    /** TCP port the HTTP listener binds. */
+    readonly port: number
+}
+
+/** Injection token under which the app module provides its {@link ServerOptions}. */
+export const SERVER_OPTIONS = "SERVER_OPTIONS"

package/templates/be/skeleton/src/modules/platform/errors/domain-error.spec.ts

@@ -0,0 +1,15 @@
+import { DomainError } from "./domain-error"
+
+class SampleError extends DomainError {}
+
+describe("DomainError", () => {
+    it("carries the code, the message and the cause, and is named after its subclass", () => {
+        const cause = new SyntaxError("bad input")
+        const error = new SampleError("SAMPLE_FAILED", "The sample failed.", { cause })
+        expect(error.code).toBe("SAMPLE_FAILED")
+        expect(error.message).toBe("The sample failed.")
+        expect(error.cause).toBe(cause)
+        expect(error.name).toBe("SampleError")
+        expect(error).toBeInstanceOf(Error)
+    })
+})

package/templates/be/skeleton/src/modules/platform/errors/domain-error.ts

@@ -0,0 +1,11 @@
+/** The base of every error a capability declares: a stable machine code, a sentence for people, and the cause. */
+export abstract class DomainError extends Error {
+    /** Stable machine code that transports map to a status and logs group by. */
+    readonly code: string
+
+    constructor(code: string, message: string, options?: { readonly cause?: unknown }) {
+        super(message, options)
+        this.name = new.target.name
+        this.code = code
+    }
+}

package/templates/be/skeleton/src/modules/platform/errors/error.filter.spec.ts

@@ -0,0 +1,38 @@
+import { ArgumentsHost, HttpException, HttpStatus } from "@nestjs/common"
+import { HttpArgumentsHost } from "@nestjs/common/interfaces"
+import { mock } from "@starci/jest-preset/mock"
+import type { Response } from "express"
+import { Logger, LogId } from "@modules/platform/logging"
+import { ErrorFilter } from "./error.filter"
+
+const arrange = () => {
+    const response = mock<Response>()
+    response.status.mockReturnValue(response)
+    const http = mock<HttpArgumentsHost>()
+    http.getResponse.mockReturnValue(response)
+    const host = mock<ArgumentsHost>()
+    host.switchToHttp.mockReturnValue(http)
+    const logger = mock<Logger>()
+    return { response, host, logger, filter: new ErrorFilter(logger) }
+}
+
+describe("ErrorFilter", () => {
+    it("answers an unknown failure with a 500 that names no detail, and logs it once", () => {
+        const { response, host, logger, filter } = arrange()
+        filter.catch(new TypeError("secret detail"), host)
+        expect(response.status).toHaveBeenCalledWith(HttpStatus.INTERNAL_SERVER_ERROR)
+        expect(response.json).toHaveBeenCalledWith({ code: "internal_error" })
+        expect(logger.error).toHaveBeenCalledTimes(1)
+        expect(logger.error).toHaveBeenCalledWith(LogId.RequestFailed, {
+            status: HttpStatus.INTERNAL_SERVER_ERROR,
+            failure: { name: "TypeError" },
+        })
+    })
+
+    it("keeps the status of a framework exception and answers with its status code only", () => {
+        const { response, host, filter } = arrange()
+        filter.catch(new HttpException("Not Found", HttpStatus.NOT_FOUND), host)
+        expect(response.status).toHaveBeenCalledWith(HttpStatus.NOT_FOUND)
+        expect(response.json).toHaveBeenCalledWith({ code: "http_404" })
+    })
+})

package/templates/be/skeleton/src/modules/platform/errors/error.filter.ts

@@ -0,0 +1,24 @@
+import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from "@nestjs/common"
+import type { Response } from "express"
+import { Logger, LogId } from "@modules/platform/logging"
+import { DomainError } from "./domain-error"
+
+/** What a log line says about a failure: its name and code, never the stack or the request. */
+const describeFailure = (exception: unknown): Readonly<Record<string, unknown>> =>
+    exception instanceof DomainError
+        ? { name: exception.name, code: exception.code }
+        : { name: exception instanceof Error ? exception.name : typeof exception }
+
+/** The one filter of an app: logs every failure once and answers with a status and a code that reveal nothing else. */
+@Catch()
+export class ErrorFilter implements ExceptionFilter {
+    constructor(private readonly logger: Logger) {}
+
+    /** Answers the request; an unknown failure is a 500 whose body names no detail. */
+    catch(exception: unknown, host: ArgumentsHost): void {
+        const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR
+        this.logger.error(LogId.RequestFailed, { status, failure: describeFailure(exception) })
+        const code = status === HttpStatus.INTERNAL_SERVER_ERROR ? "internal_error" : `http_${status}`
+        host.switchToHttp().getResponse<Response>().status(status).json({ code })
+    }
+}

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

@@ -0,0 +1,2 @@
+export { DomainError } from "./domain-error"
+export { ErrorFilter } from "./error.filter"

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

@@ -0,0 +1,5 @@
+export { createJsonLogger } from "./json-logger"
+export { LogId } from "./log-id"
+export { Logger } from "./logger.port"
+export type { LogPayload } from "./logger.port"
+export { LoggingModule } from "./logging.module"

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

@@ -0,0 +1,33 @@
+import { Writable } from "node:stream"
+import { createJsonLogger } from "./json-logger"
+import { LogId } from "./log-id"
+
+const capture = () => {
+    const lines: string[] = []
+    const sink = new Writable({
+        write(chunk: Buffer, _encoding, done) {
+            lines.push(chunk.toString())
+            done()
+        },
+    })
+    return { lines, logger: createJsonLogger(sink) }
+}
+
+describe("createJsonLogger", () => {
+    it("writes one JSON line carrying the level, the enum identity, a timestamp and the payload", () => {
+        const { lines, logger } = capture()
+        logger.error(LogId.StartupFailed, { code: "CONFIG_KEY_MISSING" })
+        expect(lines).toHaveLength(1)
+        expect(lines[0].endsWith("\n")).toBe(true)
+        expect(JSON.parse(lines[0])).toMatchObject({ level: "error", id: "server.startup_failed", code: "CONFIG_KEY_MISSING" })
+        expect(JSON.parse(lines[0]).time).toEqual(expect.any(String))
+    })
+
+    it("maps every level to its own name", () => {
+        const { lines, logger } = capture()
+        logger.debug(LogId.ServerStarted)
+        logger.info(LogId.ServerStarted)
+        logger.warn(LogId.ServerStarted)
+        expect(lines.map((line) => JSON.parse(line).level)).toEqual(["debug", "info", "warn"])
+    })
+})

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

@@ -0,0 +1,35 @@
+import type { Writable } from "node:stream"
+import type { LogId } from "./log-id"
+import { Logger, LogPayload } from "./logger.port"
+
+type Level = "debug" | "info" | "warn" | "error"
+
+/** The default adapter: one JSON object per line on a stream, so a collector reads it without parsing prose. */
+class JsonLogger extends Logger {
+    constructor(private readonly sink: Writable) {
+        super()
+    }
+
+    debug(id: LogId, payload?: LogPayload): void {
+        this.write("debug", id, payload)
+    }
+
+    info(id: LogId, payload?: LogPayload): void {
+        this.write("info", id, payload)
+    }
+
+    warn(id: LogId, payload?: LogPayload): void {
+        this.write("warn", id, payload)
+    }
+
+    error(id: LogId, payload?: LogPayload): void {
+        this.write("error", id, payload)
+    }
+
+    private write(level: Level, id: LogId, payload?: LogPayload): void {
+        this.sink.write(`${JSON.stringify({ level, id, time: new Date().toISOString(), ...payload })}\n`)
+    }
+}
+
+/** Builds the JSON logger; `sink` is stdout unless a caller (a spec, a process manager) supplies its own stream. */
+export const createJsonLogger = (sink: Writable = process.stdout): Logger => new JsonLogger(sink)

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

@@ -0,0 +1,9 @@
+/** Every log line is named by a member of this enum, so a line can be found from the code that wrote it. */
+export enum LogId {
+    /** The HTTP listener is bound and the app serves requests. */
+    ServerStarted = "server.started",
+    /** The app failed before it could serve; the process exits non-zero. */
+    StartupFailed = "server.startup_failed",
+    /** A request ended in a failure the app's filter answered. */
+    RequestFailed = "http.request_failed",
+}

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

@@ -0,0 +1,19 @@
+import type { LogId } from "./log-id"
+
+/** The structured data of one log line; values are plain data, never a request, a token or a secret. */
+export type LogPayload = Readonly<Record<string, unknown>>
+
+/** The logging port: capabilities log through it with an enum identity and a structured payload, never `console`. */
+export abstract class Logger {
+    /** Detail for people debugging one environment. */
+    abstract debug(id: LogId, payload?: LogPayload): void
+
+    /** A normal event worth keeping. */
+    abstract info(id: LogId, payload?: LogPayload): void
+
+    /** Something unexpected the app recovered from. */
+    abstract warn(id: LogId, payload?: LogPayload): void
+
+    /** A failure the app could not recover from in place. */
+    abstract error(id: LogId, payload?: LogPayload): void
+}

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

@@ -0,0 +1,11 @@
+import { Global, Module } from "@nestjs/common"
+import { createJsonLogger } from "./json-logger"
+import { Logger } from "./logger.port"
+
+/** Provides the logging port to every capability; one of the three platform modules that may be global. */
+@Global()
+@Module({
+    providers: [{ provide: Logger, useFactory: (): Logger => createJsonLogger() }],
+    exports: [Logger],
+})
+export class LoggingModule {}

package/templates/be/sonar-project.properties

@@ -0,0 +1,10 @@
+sonar.projectKey={{sonarKey}}
+sonar.host.url=https://sonar.starci.org
+sonar.sourceEncoding=UTF-8
+sonar.sources=apps,src
+sonar.tests=apps,src
+sonar.exclusions={{sonarExclusions}}
+sonar.test.inclusions=**/*.spec.ts
+sonar.coverage.exclusions={{sonarCoverageExclusions}}
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+sonar.nodejs.maxspace=8192

package/templates/be/starciwork.gitignore

@@ -0,0 +1,39 @@
+# StarCi .starciwork: product content only (ARCHITECTURE-DB §5.1, work-layout.yaml shape.productPaths).
+# Agent output (reports, checks, captures, draw rounds, UAT runs, logs, ledgers, worktrees) lives in
+# runtime.sqlite rows and blobs outside the repository.
+/*
+!/.gitignore
+!/.gitattributes
+!/workspace.yaml
+!/index.yaml
+!/brand/
+!/shell/
+!/_resources/
+!/_derived/
+!/features/
+/brand/*
+!/brand/index.yaml
+!/brand/evidence.yaml
+!/brand/assets/
+/shell/*
+!/shell/index.yaml
+!/shell/evidence.yaml
+/_resources/*
+!/_resources/environments/
+!/_resources/identities/
+!/_resources/fixtures/
+!/_resources/runtimes/
+!/_resources/grammar-captures/
+/_derived/*
+!/_derived/index.yaml
+!/_derived/frontier.md
+!/_derived/critique.yaml
+!/_derived/critique.md
+evidence/
+runs/
+draw-loop/
+operations/
+report*.json
+*.tmp.json
+/features/**/impl/**/assets/
+/shell/assets/

package/templates/common/ci.yml

@@ -0,0 +1,50 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    env:
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: {{nodeMajor}}
+          cache: npm
+      - run: npm ci
+      - name: hfs sync
+        run: npx hfs sync --check
+      - name: hfs check
+        run: npx hfs check
+      - name: lint
+        run: npm run lint:check
+      - name: typecheck
+        run: npm run typecheck
+      - name: unit
+        run: npm run test:ci
+      - name: build
+        run: npm run build
+      - uses: codecov/codecov-action@v5
+        with:
+          files: coverage/lcov.info
+          disable_search: true
+          fail_ci_if_error: true
+          use_oidc: true
+      - uses: SonarSource/sonarqube-scan-action@v7
+        if: env.SONAR_TOKEN != ''
+        env:
+          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}
+      - uses: SonarSource/sonarqube-quality-gate-action@v1
+        if: env.SONAR_TOKEN != ''
+        timeout-minutes: 10
+        env:
+          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}

package/templates/common/codecov.yml

@@ -0,0 +1,13 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 80%
+        informational: false
+    patch:
+      default:
+        target: 90%
+        informational: false
+comment: false
+ignore:
+  - {{codecovIgnore}}

package/templates/common/gitignore.base

@@ -0,0 +1,33 @@
+# Build output and tool output the tools need in place.
+node_modules/
+dist/
+coverage/
+test-results/
+playwright-report/
+*.tsbuildinfo
+.scannerwork/
+.turbo/
+.tools/
+# Generated code is rebuilt by prebuild / pretypecheck, never tracked.
+__generated__/
+# Plaintext secrets never enter the tree; the sealed form is .starcistacks/<env>/secrets/<slug>.enc.
+.env
+.env.*
+!.env.example
+.secrets/
+*.pem
+# Agent output lives in the scratchpad and the blob store, never in the repository.
+report*.json
+*.tmp.json
+*-lint.json
+lf.json
+lt.json
+%*%
+nul
+.qwen*/
+.artifacts/
+.tmp-*
+# Worktrees live under D:/starci-lanes, never inside the repository.
+.worktrees/
+# StarCi runtime state of the repository (ledger), never tracked.
+.starci/

package/templates/common/pre-push

@@ -0,0 +1,5 @@
+# Push gate: types, lint, the architecture check on the owners this push touches, unit specs affected since main. Never e2e.
+npm run typecheck
+npm run lint:check
+npx hfs check --fast
+npm run test:affected

package/templates/fe/e2e.yml

@@ -0,0 +1,22 @@
+# End-to-end runs are manual: nothing triggers this workflow but a person dispatching it.
+name: e2e
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: {{nodeMajor}}
+          cache: npm
+      - run: npm ci
+      - run: npx playwright install --with-deps chromium
+      - name: e2e
+        run: npm run test:e2e

package/templates/fe/gitignore

@@ -0,0 +1,3 @@
+{{> common/gitignore.base}}
+.next/
+next-env.d.ts

package/templates/fe/pre-commit

@@ -0,0 +1,7 @@
+# Commit gate: staged lint, types, the unit specs the staged files touch. Never e2e.
+npx lint-staged
+npm run typecheck
+staged=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' '*.tsx' | grep -v -E '(^|/)e2e/|\.e2e-spec\.ts$' || true)
+if [ -n "$staged" ]; then
+  npx vitest related --run --passWithNoTests $staged
+fi

package/templates/fe/skeleton/apps/__app__/next.config.ts

@@ -0,0 +1,11 @@
+import type { NextConfig } from "next"
+import createNextIntlPlugin from "next-intl/plugin"
+
+const withNextIntl = createNextIntlPlugin("./src/modules/i18n/request.ts")
+
+/** Next config of the {{app}} app: next-intl wired to the request config, Turbopack rooted at the repository. */
+const nextConfig: NextConfig = {
+    turbopack: { root: process.cwd() },
+}
+
+export default withNextIntl(nextConfig)

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

@@ -0,0 +1,22 @@
+"use client"
+
+import { useTranslations } from "next-intl"
+
+interface ErrorPageProps {
+    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>
+    )
+}
+
+export default ErrorPage

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

@@ -0,0 +1,31 @@
+import { hasLocale, NextIntlClientProvider } from "next-intl"
+import { getMessages, setRequestLocale } from "next-intl/server"
+import { notFound } from "next/navigation"
+import type { ReactNode } from "react"
+import { routing } from "../../modules/i18n/routing"
+import "../globals.css"
+
+interface LocaleLayoutProps {
+    readonly children: ReactNode
+    readonly params: Promise<{ readonly locale: string }>
+}
+
+/** One static shell per served locale. */
+export const generateStaticParams = () => routing.locales.map((locale) => ({ 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>
+    )
+}
+
+export default LocaleLayout

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

@@ -0,0 +1,15 @@
+import { getTranslations } from "next-intl/server"
+import { Link } from "../../modules/i18n/navigation"
+
+/** 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>
+    )
+}
+
+export default NotFound