@starci/hfs 4.0.7 → 4.0.9

package/templates/be/table/module.ts.tpl

@@ -0,0 +1,14 @@
+import { Module } from "@nestjs/common"
+import type { DynamicModule } from "@nestjs/common"
+import { ConfigurableModuleClass, OPTIONS_TYPE } from "./{{name}}.module-definition"
+import { {{Name}}Service } from "./{{name}}.service"
+
+@Module({})
+/** The {{name}} capability over the primary Supabase PostgreSQL connection. */
+export class {{Name}}Module extends ConfigurableModuleClass {
+    /** Registers the capability once in the API app. */
+    static register(options: typeof OPTIONS_TYPE): DynamicModule {
+        const base = super.register(options)
+        return { ...base, providers: [...(base.providers ?? []), {{Name}}Service], exports: [{{Name}}Service] }
+    }
+}

package/templates/be/table/options.ts.tpl

@@ -0,0 +1,2 @@
+/** The {{name}} capability takes no options; the app root decides whether it is global. */
+export type {{Name}}Options = Record<never, never>

package/templates/be/table/rows.ts.tpl

@@ -0,0 +1,4 @@
+import type { Database } from "../../../../../../supabase/types/database.types"
+
+/** One generated row of public.{{table}}. */
+export type {{Name}}Row = Database["public"]["Tables"]["{{table}}"]["Row"]

package/templates/be/table/service.ts.tpl

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common"
+import type { EntityManager } from "typeorm"
+import { InjectPrimaryEntityManager, requireOwnedRow } from "@modules/platform/database"
+import { {{Name}}Error, {{Name}}ErrorCode } from "./errors/{{name}}.error"
+import type { {{Name}}Row } from "./persistence/{{name}}.rows"
+import { FIND_{{upper}} } from "./persistence/{{name}}.sql"
+
+interface {{Name}}Result {
+    readonly id: string
+}
+
+@Injectable()
+/** The {{name}} rows reached only through the shared primary EntityManager. */
+export class {{Name}}Service {
+    constructor(@InjectPrimaryEntityManager() private readonly entityManager: EntityManager) {}
+
+    /** Answers one row owned by the authenticated principal; absent and denied rows share one typed not-found result. */
+    {{nameCamel}}(principalId: string, id: string): Promise<{{Name}}Result> {
+        return requireOwnedRow<Pick<{{Name}}Row, "id">>(this.entityManager, FIND_{{upper}}, id, principalId, () => {
+            throw new {{Name}}Error({ code: {{Name}}ErrorCode.NotFound, params: { id } })
+        })
+    }
+}

package/templates/be/table/sql.ts.tpl

@@ -0,0 +1,4 @@
+import { sql } from "@modules/platform/database"
+
+/** Reads one public.{{table}} row by id and owner through a branded SQL statement. */
+export const FIND_{{upper}} = sql`SELECT id FROM public.{{tableSql}} WHERE id = $1 AND owner_id = $2 LIMIT 1`

package/templates/be/tool-config/jest.config.js

@@ -1 +1,3 @@
-module.exports = require("@starci/jest-preset").starciJestConfig()
+module.exports = require("@starci/jest-preset").starciJestConfig({
+    coverage: {{jestCoverage}},
+})

package/templates/be/upgrade-full/apps/cli/src/app.module.ts

@@ -0,0 +1,14 @@
+import { Module } from "@nestjs/common";
+import { CliModule } from "@features/cli";
+import { ClockModule } from "@modules/platform/clock";
+import { LoggingModule } from "@modules/platform/logging";
+
+@Module({
+  imports: [
+    ClockModule.register({ isGlobal: true }),
+    LoggingModule.register({ isGlobal: true }),
+    CliModule,
+  ],
+})
+/** The cli composition root; database schema changes remain delegated to the Supabase CLI. */
+export class AppModule {}

package/templates/be/upgrade-full/apps/cli/src/main.ts

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import { CommandFactory } from "nest-commander";
+import { SystemClockService } from "@modules/platform/clock";
+import { createJsonLogger, LoggingLogEvent } from "@modules/platform/logging";
+import { AppModule } from "./app.module";
+
+/** The one-off command app. Its migrate command delegates schema authority to the Supabase CLI. */
+async function bootstrap(): Promise<void> {
+  const logger = createJsonLogger(new SystemClockService());
+  await CommandFactory.run(AppModule, {
+    logger: false,
+    errorHandler: (error: Error) => {
+      logger.error(LoggingLogEvent.StartupFailed, error, { service: "cli" });
+      process.exit(1);
+    },
+  });
+}
+
+bootstrap().catch((error: unknown) => {
+  createJsonLogger(new SystemClockService()).error(
+    LoggingLogEvent.StartupFailed,
+    error,
+    { service: "cli" },
+  );
+  process.exit(1);
+});

package/templates/be/upgrade-full/src/features/cli/cli.module.ts

@@ -0,0 +1,6 @@
+import { Module } from "@nestjs/common";
+import { MigrateModule } from "./migrate/migrate.module";
+
+@Module({ imports: [MigrateModule] })
+/** The cli feature root of the upgraded app. */
+export class CliModule {}

package/templates/be/upgrade-full/src/features/cli/migrate/subs/run.cli.ts

@@ -0,0 +1,23 @@
+import { spawnSync } from "node:child_process";
+import { CommandRunner, SubCommand } from "nest-commander";
+
+@SubCommand({
+  name: "run",
+  description: "Apply the Supabase migrations",
+})
+/** `cli migrate run`: delegates the schema authority under supabase/migrations to the Supabase CLI. */
+export class RunCli extends CommandRunner {
+  /** Runs the installed Supabase CLI in the app root and preserves its exit result. */
+  async run(): Promise<void> {
+    const command = process.platform === "win32" ? "supabase.cmd" : "supabase";
+    const result = spawnSync(command, ["db", "push"], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+    if (result.error !== undefined) throw result.error;
+    if (result.status !== 0)
+      throw new Error(
+        `supabase db push exited ${result.status ?? "without a status"}`,
+      );
+  }
+}

package/templates/common/gitignore.base

@@ -24,10 +24,9 @@ lf.json
 lt.json
 %*%
 nul
-.qwen*/
 .artifacts/
 .tmp-*
-# Worktrees live under D:/starci-lanes, never inside the repository.
+# Worktrees live outside the repository, never inside it.
 .worktrees/
 # StarCi runtime state of the repository (ledger), never tracked.
 .starci/

package/templates/fe/app/package.json.tpl

@@ -0,0 +1 @@
+{{packageJson}}

package/templates/fe/app/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "plugins": [{ "name": "next" }],
+    "incremental": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "src/**/*.ts", "src/**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/templates/fe/common/app-layout.tsx.partial

@@ -0,0 +1,8 @@
+export const AppLayout = async (props: AppLayoutProps) => {
+    const t = await getTranslations("app.shell")
+    return (
+        <SiteShell brand={t("brand")} homeHref={APP_ROUTES.home}>
+            {props.content}
+        </SiteShell>
+    )
+}

package/templates/fe/common/site-shell.tsx.partial

@@ -0,0 +1,9 @@
+export const SiteShell = (props: SiteShellProps) => (
+    <GrammarRoot className={siteShellClassNames.frame}>
+        <WorkspaceShell
+            primaryLabel={props.brand}
+            header={<TopBar brand={<TextAction href={props.homeHref}>{props.brand}</TextAction>} />}
+            primary={<PageContainer measure="reading">{props.children}</PageContainer>}
+        />
+    </GrammarRoot>
+)

package/templates/fe/image/next/Dockerfile

@@ -0,0 +1,42 @@
+# {{project}}/{{app}} - the {{app}} Next app (standalone output). The build context is the APP ROOT (the folder holding the one
+# package.json and package-lock.json), not this folder:
+#
+#   docker build -f fe/apps/{{app}}/Dockerfile -t {{project}}/{{app}}:<tag> .
+#
+# NEXT_PUBLIC_* values are published to every browser by design, so they are the one kind of build argument:
+# add `ARG NEXT_PUBLIC_<NAME>` here and pass it with `--build-arg`. It follows the image canon (knowledge/hfs/docker.md) and
+# diverges from it nowhere. No secret is built in: credentials are mounted at run time and .dockerignore keeps them out of the
+# build context.
+
+FROM {{nodeImage}} AS manifests
+WORKDIR /app
+COPY package.json package-lock.json ./
+COPY fe fe
+RUN find fe -type f ! -name package.json -delete
+
+FROM {{nodeImage}} AS build
+WORKDIR /app
+COPY --from=manifests /app ./
+RUN npm ci --ignore-scripts
+
+COPY turbo.json ./
+COPY scripts scripts
+COPY fe/tsconfig.json fe/tsconfig.json
+{{copyInputs}}COPY fe/apps/{{app}} fe/apps/{{app}}
+RUN npm run codegen --silent
+RUN npx turbo run build --filter=@{{project}}/{{app}}
+
+FROM {{nodeImage}} AS runtime
+WORKDIR /app
+ENV NODE_ENV=production
+ENV PORT={{port}}
+ENV HOSTNAME=0.0.0.0
+
+COPY --from=build --chown=node:node /app/fe/apps/{{app}}/.next/standalone ./
+COPY --from=build --chown=node:node /app/fe/apps/{{app}}/.next/static ./fe/apps/{{app}}/.next/static
+COPY --from=build --chown=node:node /app/fe/apps/{{app}}/public ./fe/apps/{{app}}/public
+
+USER node
+EXPOSE {{port}}
+HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 CMD node -e "fetch('http://127.0.0.1:'+process.env.PORT+'/').then(r=>process.exit(r.status<500?0:1)).catch(()=>process.exit(1))"
+CMD ["node", "fe/apps/{{app}}/server.js"]

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

@@ -0,0 +1,23 @@
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import type { NextConfig } from "next"
+import createNextIntlPlugin from "next-intl/plugin"
+
+/** The request config lives in this app's i18n module; next-intl resolves it from the directory the build runs in. */
+const withNextIntl = createNextIntlPlugin("./src/modules/i18n/request.ts")
+
+/** The npm workspace root (three levels above this app): Turbopack resolves the built workspace packages from it, and output tracing is pinned to it. */
+const WORKSPACE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..")
+
+/** Next config of the product app: the standalone output its image ships, next-intl wired to the request config, root params on (the locale is read from the route). */
+const nextConfig: NextConfig = {
+    output: "standalone",
+    reactStrictMode: true,
+    experimental: { rootParams: true },
+    outputFileTracingRoot: WORKSPACE_ROOT,
+    turbopack: { root: WORKSPACE_ROOT },
+    // The product app is the authenticated one: it does not advertise the framework that serves it.
+    poweredByHeader: false,
+}
+
+export default withNextIntl(nextConfig)

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__ → app}/src/app/[locale]/error.tsx

@@ -1,10 +1,10 @@
 "use client"
 
-import { ErrorPage } from "@/features/pages/ErrorPage"
+import { AppErrorPage } from "@/features/pages/AppErrorPage"
 
 type ErrorProps = { readonly reset: () => void }
 
 /** 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} />
+const ErrorBoundary = (props: ErrorProps) => <AppErrorPage onRetry={props.reset} />
 
-export default Error
+export default ErrorBoundary

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

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react"
+import { LocaleShell } from "@{{project}}/ui"
+import { AppLayout, appLayoutMetadata } from "@/features/layouts/AppLayout"
+import { appI18n } from "@/modules/i18n"
+import "../globals.css"
+
+type LayoutProps = {
+    readonly children: ReactNode
+    readonly params: Promise<{ readonly locale: string }>
+}
+
+/** The localized document title of this route segment. */
+export const generateMetadata = async (props: LayoutProps) => appLayoutMetadata((await props.params).locale)
+
+/** The locale segment's layout slot: the document of the address's language around the product app's chrome. */
+const Layout = async (props: LayoutProps) => (
+    <LocaleShell {...await appI18n.readLocaleSegment(props.params)}>
+        <AppLayout content={props.children} />
+    </LocaleShell>
+)
+
+export default Layout

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { AppHomePage, appHomeMetadata } from "@/features/pages/AppHomePage"
+
+/** The document title of this page, from the catalog of the requested locale. */
+export const generateMetadata = appHomeMetadata
+
+/** The locale root's page slot: it mounts the product app's home page and nothing else. */
+const Page = () => <AppHomePage />
+
+export default Page

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

@@ -1,10 +1,10 @@
 "use client"
 
-import { GlobalErrorPage } from "@/features/pages/GlobalErrorPage"
+import { AppGlobalErrorPage } from "@/features/pages/AppGlobalErrorPage"
 
 type GlobalErrorProps = { readonly reset: () => void }
 
 /** 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} />
+const GlobalError = (props: GlobalErrorProps) => <AppGlobalErrorPage onRetry={props.reset} />
 
 export default GlobalError

package/templates/fe/skeleton/apps/app/src/app/globals.css

@@ -0,0 +1,10 @@
+@import "tailwindcss";
+@import "@heroui/styles/css";
+@import "@starci/grammar/common.css";
+
+/*
+ * The grammar's renderers spell their layout in Tailwind utilities inside node_modules, which Tailwind never scans by default;
+ * the ui package's own utilities are scanned the same way.
+ */
+@source "../../../../../node_modules/@starci/grammar/dist";
+@source "../../../../packages/{{project}}-ui/src";

package/templates/fe/skeleton/apps/app/src/features/layouts/AppLayout/index.tsx

@@ -0,0 +1,18 @@
+import type { Metadata } from "next"
+import { getTranslations } from "next-intl/server"
+import type { ReactNode } from "react"
+import { SiteShell } from "@{{project}}/ui"
+import { siteUrl } from "@/modules/config"
+import { APP_ROUTES } from "@/modules/routes"
+
+/** Framework-layout boundary input: the routed page body and nothing else. */
+type AppLayoutProps = { readonly content: ReactNode }
+
+/** The document title and the absolute base of every metadata URL, for the language in the address. */
+export const appLayoutMetadata = async (locale: string): Promise<Metadata> => {
+    const t = await getTranslations({ locale, namespace: "app" })
+    return { title: t("title"), metadataBase: new URL(siteUrl()) }
+}
+
+/** The product app's chrome, resolved on the server: the shared brand shell with the wordmark linking home, around the routed body. */
+{{> fe/common/app-layout.tsx.partial}}

package/templates/fe/skeleton/apps/app/src/features/pages/AppErrorPage/component.tsx

@@ -0,0 +1,19 @@
+import { ErrorNotice } from "@{{project}}/ui"
+
+/** Props for {@link AppErrorPageBase}. */
+export type AppErrorPageBaseProps = {
+    /** The words the failure shows, already resolved. */
+    readonly props: {
+        readonly title: string
+        readonly retryLabel: string
+    }
+    /** What the surface reports upward. */
+    readonly on: {
+        readonly retry: () => void
+    }
+}
+
+/** Draw the failure of the product app's locale segment with its one recovery action. */
+export const AppErrorPageBase = (props: AppErrorPageBaseProps) => (
+    <ErrorNotice title={props.props.title} retryLabel={props.props.retryLabel} onRetry={props.on.retry} />
+)

package/templates/fe/skeleton/apps/app/src/features/pages/AppErrorPage/index.tsx

@@ -0,0 +1,11 @@
+import { useTranslations } from "next-intl"
+import { AppErrorPageBase } from "./component"
+
+/** The public props of the locale error page: the boundary hands it the retry. */
+type AppErrorPageProps = { readonly onRetry: () => void }
+
+/** A render failure in the product app shows this instead of a blank page; retry re-renders the segment. */
+export const AppErrorPage = (props: AppErrorPageProps) => {
+    const t = useTranslations("app.errors.page")
+    return <AppErrorPageBase props={{ title: t("title"), retryLabel: t("retry") }} on={{ retry: props.onRetry }} />
+}

package/templates/fe/skeleton/apps/app/src/features/pages/AppGlobalErrorPage/index.tsx

@@ -0,0 +1,16 @@
+import { DEFAULT_LOCALE } from "@{{project}}/i18n/routing"
+import { GlobalErrorNotice } from "@{{project}}/ui"
+import messages from "@/modules/i18n/messages/vi.json"
+
+/** The public props of the last-resort error page: the boundary hands it the retry. */
+type AppGlobalErrorPageProps = { readonly onRetry: () => void }
+
+/** The last-resort boundary above the locale layout of the product app: it has no provider, so it reads the default catalog directly. */
+export const AppGlobalErrorPage = (props: AppGlobalErrorPageProps) => (
+    <GlobalErrorNotice
+        lang={DEFAULT_LOCALE}
+        title={messages.app.errors.global.title}
+        retryLabel={messages.app.errors.global.retry}
+        onRetry={props.onRetry}
+    />
+)

package/templates/fe/skeleton/apps/app/src/features/pages/AppHomePage/component.tsx

@@ -0,0 +1,10 @@
+import { Heading } from "@starci/grammar/common"
+
+/** Props for {@link AppHomePageBase}. */
+export type AppHomePageBaseProps = {
+    /** The words the page shows. */
+    readonly props: { readonly title: string }
+}
+
+/** Draw the front door of the product app. */
+export const AppHomePageBase = (props: AppHomePageBaseProps) => <Heading level={1}>{props.props.title}</Heading>

package/templates/fe/skeleton/apps/app/src/features/pages/AppHomePage/index.tsx

@@ -0,0 +1,15 @@
+import type { Metadata } from "next"
+import { getTranslations } from "next-intl/server"
+import { AppHomePageBase } from "./component"
+
+/** The document title of the home page, from the catalog of the requested locale. */
+export const appHomeMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("app.home")
+    return { title: t("title") }
+}
+
+/** The first page of the product app: a server component, so no catalog is shipped for it. */
+export const AppHomePage = async () => {
+    const t = await getTranslations("app.home")
+    return <AppHomePageBase props={{ title: t("title") }} />
+}

package/templates/fe/skeleton/apps/app/src/features/pages/AppLoadingPage/index.tsx

@@ -0,0 +1,8 @@
+import { getTranslations } from "next-intl/server"
+import { LoadingNotice } from "@{{project}}/ui"
+
+/** Shown while a route of the product app resolves. */
+export const AppLoadingPage = async () => {
+    const t = await getTranslations("app.loading")
+    return <LoadingNotice label={t("message")} />
+}

package/templates/fe/skeleton/apps/app/src/features/pages/AppNotFoundPage/index.tsx

@@ -0,0 +1,9 @@
+import { getTranslations } from "next-intl/server"
+import { NotFoundNotice } from "@{{project}}/ui"
+import { APP_ROUTES } from "@/modules/routes"
+
+/** Shown when a route of the product app calls `notFound()`. */
+export const AppNotFoundPage = async () => {
+    const t = await getTranslations("app.notFound")
+    return <NotFoundNotice title={t("title")} homeLabel={t("home")} homeHref={APP_ROUTES.home} />
+}

package/templates/fe/skeleton/apps/app/src/modules/i18n/index.ts

@@ -0,0 +1,4 @@
+import { createAppI18n } from "@{{project}}/i18n"
+
+/** The product app's i18n: the product's one next-intl stack (the i18n package), with this app's own catalogs under `messages/`. */
+export const appI18n = createAppI18n("app", async (locale) => (await import(`./messages/${locale}.json`)).default)

package/templates/fe/skeleton/apps/app/src/modules/i18n/messages/vi.json

@@ -0,0 +1,28 @@
+{
+  "app": {
+    "title": "{{project}}",
+    "shell": {
+      "brand": "{{project}}"
+    },
+    "home": {
+      "title": "Trang chủ"
+    },
+    "loading": {
+      "message": "Đang tải"
+    },
+    "notFound": {
+      "title": "Không tìm thấy trang",
+      "home": "Về trang chủ"
+    },
+    "errors": {
+      "page": {
+        "title": "Đã xảy ra lỗi",
+        "retry": "Thử lại"
+      },
+      "global": {
+        "title": "Đã xảy ra lỗi nghiêm trọng",
+        "retry": "Thử lại"
+      }
+    }
+  }
+}

package/templates/fe/skeleton/apps/app/src/modules/i18n/request.ts

@@ -0,0 +1,4 @@
+import { appI18n } from "./index"
+
+/** The request config next-intl's plugin loads (next.config.ts): the product stack over this app's catalogs. */
+export default appI18n.requestConfig

package/templates/fe/skeleton/apps/app/src/modules/routes/index.ts

@@ -0,0 +1,4 @@
+/** Every internal destination the product app's screens link to, named once. */
+export const APP_ROUTES = {
+    home: "/",
+} as const

package/templates/fe/skeleton/apps/app/src/proxy.ts

@@ -0,0 +1 @@
+export { proxy } from "@{{project}}/i18n/proxy"

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

@@ -0,0 +1,21 @@
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import type { NextConfig } from "next"
+import createNextIntlPlugin from "next-intl/plugin"
+
+/** The request config lives in this app's i18n module; next-intl resolves it from the directory the build runs in. */
+const withNextIntl = createNextIntlPlugin("./src/modules/i18n/request.ts")
+
+/** The npm workspace root (three levels above this app): Turbopack resolves the built workspace packages from it, and output tracing is pinned to it. */
+const WORKSPACE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..")
+
+/** Next config of the landing: the standalone output its image ships, next-intl wired to the request config, root params on (the locale is read from the route). */
+const nextConfig: NextConfig = {
+    output: "standalone",
+    reactStrictMode: true,
+    experimental: { rootParams: true },
+    outputFileTracingRoot: WORKSPACE_ROOT,
+    turbopack: { root: WORKSPACE_ROOT },
+}
+
+export default withNextIntl(nextConfig)

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

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

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

@@ -0,0 +1,10 @@
+"use client"
+
+import { LandingErrorPage } from "@/features/pages/LandingErrorPage"
+
+type ErrorProps = { readonly reset: () => void }
+
+/** The locale segment's error boundary slot: it mounts the error page and hands it the segment's retry. */
+const ErrorBoundary = (props: ErrorProps) => <LandingErrorPage onRetry={props.reset} />
+
+export default ErrorBoundary

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

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react"
+import { LocaleShell } from "@{{project}}/ui"
+import { LandingLayout, landingLayoutMetadata } from "@/features/layouts/LandingLayout"
+import { landingI18n } from "@/modules/i18n"
+import "../globals.css"
+
+type LayoutProps = {
+    readonly children: ReactNode
+    readonly params: Promise<{ readonly locale: string }>
+}
+
+/** The localized document title and description of the landing. */
+export const generateMetadata = async (props: LayoutProps) => landingLayoutMetadata((await props.params).locale)
+
+/** The locale segment's layout slot: the document of the address's language around the landing's chrome. */
+const Layout = async (props: LayoutProps) => (
+    <LocaleShell {...await landingI18n.readLocaleSegment(props.params)}>
+        <LandingLayout content={props.children} />
+    </LocaleShell>
+)
+
+export default Layout

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { LandingPage, landingMetadata } from "@/features/pages/LandingPage"
+
+/** The document title of this page, from the catalog of the requested locale. */
+export const generateMetadata = landingMetadata
+
+/** The locale root's page slot: it mounts the landing page and nothing else. */
+const Page = () => <LandingPage />
+
+export default Page

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

@@ -0,0 +1,10 @@
+"use client"
+
+import { LandingGlobalErrorPage } from "@/features/pages/LandingGlobalErrorPage"
+
+type GlobalErrorProps = { readonly reset: () => void }
+
+/** The last-resort error boundary slot: it mounts the global error page and hands it the retry. */
+const GlobalError = (props: GlobalErrorProps) => <LandingGlobalErrorPage onRetry={props.reset} />
+
+export default GlobalError