@starci/hfs 5.2.0 → 5.4.0

package/templates/be/skeleton-lite/src/tests/fixtures/builders/api.builder.ts

@@ -46,6 +46,17 @@ export const buildWiringProof = (): WiringProof => ({
             secretAccessKey: new Secret("fixture-only"),
             defaultExpiresIn: 300,
         },
+        mail: {
+            host: "127.0.0.1",
+            port: 2525,
+            security: "none",
+            from: { name: "Fixture", address: "no-reply@fixture.example" },
+            webOrigin: "https://app.fixture.example",
+            brandName: "Fixture",
+            defaultLanguage: "en",
+            confirmTtlSeconds: 86400,
+            resetTtlSeconds: 3600,
+        },
     },
     overrides: [
         { token: PRIMARY_DATA_SOURCE, value: { manager: {} } },

package/templates/be/table/api/feature.module-definition.ts.tpl

@@ -1,12 +1,6 @@
-import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
+import { defineConfigurableModule } from "@starci/nest-kit"
 import type { {{Name}}ApiOptions } from "./{{name}}.options"
 
-const built = new ConfigurableModuleBuilder<{{Name}}ApiOptions>().setClassMethodName("register").build()
-type Host = ConfigurableModuleHost<{{Name}}ApiOptions, "register", "create", {}>
-
 /** The configurable-module base of the {{name}} module. */
-export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
-/** The injection token of the registered options. */
-export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
-/** The options of a synchronous registration, for the register signature. */
-export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE
+export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
+    defineConfigurableModule<{{Name}}ApiOptions>()

package/templates/be/table/api/graphql.module-definition.ts.tpl

@@ -1,12 +1,6 @@
-import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
+import { defineConfigurableModule } from "@starci/nest-kit"
 import type { {{Name}}GraphqlOptions } from "./{{name}}-graphql.options"
 
-const built = new ConfigurableModuleBuilder<{{Name}}GraphqlOptions>().setClassMethodName("register").build()
-type Host = ConfigurableModuleHost<{{Name}}GraphqlOptions, "register", "create", {}>
-
 /** The configurable-module base of the {{name}}-graphql module. */
-export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
-/** The injection token of the registered options. */
-export const MODULE_OPTIONS_TOKEN: Host["MODULE_OPTIONS_TOKEN"] = built.MODULE_OPTIONS_TOKEN
-/** The options of a synchronous registration, for the register signature. */
-export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE
+export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
+    defineConfigurableModule<{{Name}}GraphqlOptions>()

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

@@ -1,12 +1,5 @@
-import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
+import { defineCapabilityModule } from "@starci/nest-kit"
 import type { {{Name}}Options } from "./{{name}}.options"
 
-const built = new ConfigurableModuleBuilder<{{Name}}Options>()
-    .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
-    .build()
-type Host = ConfigurableModuleHost<{{Name}}Options, "register", "create", { isGlobal: boolean }>
-
 /** The configurable-module base of the {{name}} capability. */
-export const ConfigurableModuleClass: Host["ConfigurableModuleClass"] = built.ConfigurableModuleClass
-/** The options of a synchronous registration, for the register signature. */
-export const OPTIONS_TYPE: Host["OPTIONS_TYPE"] = built.OPTIONS_TYPE
+export const { ConfigurableModuleClass, OPTIONS_TYPE } = defineCapabilityModule<{{Name}}Options>()

package/templates/fe/auth-lite/apps/web/src/modules/auth/email-doors.ts

@@ -0,0 +1,16 @@
+// Managed by starci app sync (slot fe.modules.auth.client); do not edit: run "npx starci app sync --execute".
+import { createAuthClient } from "@starci/auth/client"
+import { apiUrl } from "@/modules/config"
+import type { AuthFailure } from "./contracts"
+
+/** The email doors of the lite back end; the full edition's identity provider owns its own sign-up and recovery flows. */
+export type EmailDoorName = "signup" | "resend" | "confirm" | "forgot" | "reset"
+
+/** The anonymous doors need no session, so they use a client of their own over the same back-end origin. */
+const doors = createAuthClient({ apiOrigin: () => apiUrl() })
+
+/** Calls one email door with its posted fields; answers its failure (the wire code and its kind), or undefined when the back end accepted it. */
+export const sendEmailDoor = async (door: EmailDoorName, body: Readonly<Record<string, string | undefined>>): Promise<AuthFailure | undefined> => {
+    const outcome = await doors.send(door, body)
+    return outcome.success ? undefined : { code: outcome.error, kind: outcome.message, message: "" }
+}

package/templates/fe/auth-lite/apps/web/src/modules/auth/index.ts

@@ -0,0 +1,5 @@
+// Managed by starci app sync (slot fe.modules.auth.client); do not edit: run "npx starci app sync --execute".
+export { authClient } from "./client"
+export { sendEmailDoor } from "./email-doors"
+export type { EmailDoorName } from "./email-doors"
+export type { AuthFailure, AuthSession } from "./contracts"

package/templates/fe/skeleton/packages/__project__-i18n/src/index.ts

@@ -1,81 +1,44 @@
 import "server-only"
-import { hasLocale } from "next-intl"
-import type { AbstractIntlMessages } from "next-intl"
-import { createNavigation } from "next-intl/navigation"
-import { getMessages, getRequestConfig } from "next-intl/server"
-import { notFound } from "next/navigation"
+import { createReadLocaleSegment } from "@starci/next-i18n/layout"
+import type { ReadLocaleSegment } from "@starci/next-i18n/layout"
+import { createI18nNavigation } from "@starci/next-i18n/navigation"
+import type { I18nNavigation } from "@starci/next-i18n/navigation"
+import { createRequestConfig } from "@starci/next-i18n/request"
+import type { I18nRequestConfig } from "@starci/next-i18n/request"
+import type { LoadCatalog } from "@starci/next-i18n"
 import { locale as routeLocale } from "next/root-params"
-import { PRODUCT_TIME_ZONE, routing } from "./routing"
-import type { ProductRouting } from "./routing"
+import { i18n } from "./routing"
+import type { ProductI18n } from "./routing"
 
-/** Loads one app's own catalog for a served locale. */
-type LoadMessages = (locale: string) => Promise<unknown>
+/** The locales the product serves, as the catalog loader of an app receives them. */
+type ProductLocale = ProductI18n["locales"][number]
 
-/** The missing message next-intl asks a fallback for. */
-type MissingMessage = { readonly namespace?: string; readonly key: string }
-
-/** The message tree a catalog module exports as its default: the module is read as `unknown` and checked, never trusted as `any`. */
-const isMessages = (value: unknown): value is AbstractIntlMessages => typeof value === "object" && value !== null
-
-const messagesOf = (loaded: unknown): AbstractIntlMessages => {
-    const messages = typeof loaded === "object" && loaded !== null && "default" in loaded ? loaded.default : undefined
-    if (!isMessages(messages)) throw new TypeError("A message catalog module must export its messages as default")
-    return messages
+/** What one app of the product reads of its next-intl stack. */
+export interface AppI18n {
+    readonly navigation: I18nNavigation<ProductI18n["locales"], ProductI18n["localePrefix"]>
+    readonly requestConfig: I18nRequestConfig
+    readonly readLocaleSegment: ReadLocaleSegment<ProductLocale>
 }
 
 /** `next/root-params` is typed only after Next generates its types, so the reader is checked before it is called. */
 const isLocaleReader = (value: unknown): value is () => Promise<unknown> => typeof value === "function"
 
+/**
+ * The `[locale]` route param, read through `next/root-params` (`experimental.rootParams` in the app's next.config.ts), never the
+ * deprecated `requestLocale`. `next/root-params` is importable only where Next bundles it, which is why this workspace package, not
+ * `@starci/next-i18n`, reads it.
+ */
 const readRouteLocale = async (): Promise<unknown> => (isLocaleReader(routeLocale) ? routeLocale() : undefined)
 
-/** The language the address states, its catalog and the product time zone. */
-interface LocaleSegment {
-    readonly locale: string
-    readonly messages: AbstractIntlMessages
-    readonly timeZone: string
-}
-
-/** The navigation helpers of the product's routing (links, redirects, the locale-aware router). */
-type ProductNavigation = ReturnType<typeof createNavigation<ProductRouting["locales"], "as-needed">>
-
-/** What one app of the product reads of its next-intl stack. */
-export interface AppI18n {
-    readonly navigation: ProductNavigation
-    readonly requestConfig: ReturnType<typeof getRequestConfig>
-    readonly readLocaleSegment: (params: Promise<{ readonly locale: string }>) => Promise<LocaleSegment>
-}
-
 /**
- * The next-intl stack of one app of the product, written once here and called once by each app's `modules/i18n` (R59): the
- * product's one routing with its locale-aware navigation, the request config next-intl's plugin loads (the app's
- * `modules/i18n/request.ts` default-exports it) and what the app's `[locale]` layout resolves before it mounts the shell. `app` names
- * the app in the text of a message its catalog lacks (`<app>:<namespace>.<key>`); `loadMessages` loads its own catalogs. A server
- * module: a client component reads the default locale from `./routing`.
+ * What one app of the product calls from its `modules/i18n` (R59): the locale-aware navigation, the request config next-intl's
+ * plugin loads (the app's `modules/i18n/request.ts` default-exports it) and what the app's `[locale]` layout resolves before it
+ * mounts the shell, all built by `@starci/next-i18n` over the product's one description of its languages. `app` names the app in the
+ * text of a message its catalog lacks (`<app>:<namespace>.<key>`); `loadMessages` loads its own catalogs. A server module: a client
+ * component reads the default locale from `./routing`.
  */
-export const createAppI18n = (app: string, loadMessages: LoadMessages): AppI18n => ({
-    navigation: createNavigation<ProductRouting["locales"], "as-needed">(routing),
-    /**
-     * The locale is the `[locale]` route param read through `next/root-params` (`experimental.rootParams` in the app's next.config.ts,
-     * FE-I18N-1), never the deprecated `requestLocale`. An unrecognised locale resolves to the default before the loader runs, so a
-     * missing catalog file is never imported.
-     */
-    requestConfig: getRequestConfig(async () => {
-        const requested = await readRouteLocale()
-        const locale = hasLocale(routing.locales, requested) ? requested : routing.defaultLocale
-        return {
-            locale,
-            timeZone: PRODUCT_TIME_ZONE,
-            messages: messagesOf(await loadMessages(locale)),
-            getMessageFallback: ({ namespace, key }: MissingMessage) => `${app}:${namespace ?? ""}.${key}`,
-        }
-    }),
-    /**
-     * The language the address states, its catalog and the product time zone. An unknown segment is a route that does not exist,
-     * not a request to fall back silently.
-     */
-    readLocaleSegment: async (params: Promise<{ readonly locale: string }>) => {
-        const { locale } = await params
-        if (!hasLocale(routing.locales, locale)) notFound()
-        return { locale, messages: await getMessages(), timeZone: PRODUCT_TIME_ZONE }
-    },
+export const createAppI18n = (app: string, loadMessages: LoadCatalog<ProductLocale>): AppI18n => ({
+    navigation: createI18nNavigation(i18n),
+    requestConfig: createRequestConfig(i18n, { app, loadMessages, readRouteLocale }),
+    readLocaleSegment: createReadLocaleSegment(i18n),
 })

package/templates/fe/skeleton/packages/__project__-i18n/src/proxy.ts

@@ -1,24 +1,9 @@
-import "server-only"
-import createMiddleware from "next-intl/middleware"
-import { NextResponse, type NextRequest } from "next/server"
-import { routing } from "./routing"
-
-/** The first path segments of the API, the health probe and the framework: never locale-negotiated. */
-const UNNEGOTIATED_ROOTS: ReadonlySet<string> = new Set(["api", "health", "_next", "_vercel"])
-
-/** Whether the path belongs to the API, the health probe, the framework or a file with an extension. */
-const isUnnegotiated = (pathname: string): boolean => {
-    const segments = pathname.split("/")
-    const last = segments.at(-1) ?? ""
-    return UNNEGOTIATED_ROOTS.has(segments[1] ?? "") || (last.includes(".") && !last.endsWith("."))
-}
-
-const negotiate = createMiddleware(routing)
+import { createProxy } from "@starci/next-i18n/proxy"
+import type { LocaleProxy } from "@starci/next-i18n/proxy"
+import { i18n } from "./routing"
 
 /**
- * The one thing that runs before a route exists: which language it is in. next-intl's middleware reads the cookie, falls back to
- * the default and serves the default locale (vi) without a prefix. One routing table for every app; each app's `src/proxy.ts`
- * re-exports this.
+ * The one thing that runs before a route exists: which language it is in. The product's one description of its languages, read by
+ * the package's proxy; each app's `src/proxy.ts` re-exports this.
  */
-export const proxy = (request: NextRequest): NextResponse =>
-    isUnnegotiated(request.nextUrl.pathname) ? NextResponse.next() : negotiate(request)
+export const proxy: LocaleProxy = createProxy(i18n)

package/templates/fe/skeleton/packages/__project__-i18n/src/routing.ts

@@ -1,24 +1,18 @@
-import { defineRouting } from "next-intl/routing"
-import type { RoutingConfig } from "next-intl/routing"
+import { defineI18n } from "@starci/next-i18n"
+import type { I18n } from "@starci/next-i18n"
 
 /** The locales every app of the product serves; every catalog of an app has the same keys in each. */
 const LOCALES = ["vi", "en"] as const
 
-/** The locale served at the unprefixed path, and the language of a document no locale reached (the global error boundary). */
-export const DEFAULT_LOCALE = "vi"
-
-/** The product's time zone: fixed, not inferred, so the server and the hydrated client format the same instant the same way. */
-export const PRODUCT_TIME_ZONE = "Asia/Ho_Chi_Minh"
+/** The description of the product's languages: the locales and the `as-needed` prefix mode that `defineI18n` types. */
+export type ProductI18n = I18n<typeof LOCALES, "as-needed">
 
-/** The type of the product's routing table: the served locales, no locale prefix for the default one, no localized pathnames or domains. */
-export type ProductRouting = RoutingConfig<typeof LOCALES, "as-needed", never, never>
+/** The locale served at the unprefixed path, and the language of a document no locale reached (the global error boundary). */
+export const DEFAULT_LOCALE: ProductI18n["defaultLocale"] = "vi"
 
 /**
- * The one routing table of the product, for the proxy, the navigation and the request config of every app: vi default, a prefix
- * only when the locale is not the default, so `/vi` means the same thing on every app.
+ * The one description of the product's languages, for the proxy, the navigation and the request config of every app: vi default,
+ * a prefix only when the locale is not the default, and a fixed time zone so the server and the hydrated client format the same
+ * instant the same way. The stack that reads it is `@starci/next-i18n`'s; this package only states the languages (FE-I18N-1).
  */
-export const routing: ProductRouting = defineRouting({
-    locales: LOCALES,
-    defaultLocale: DEFAULT_LOCALE,
-    localePrefix: "as-needed",
-})
+export const i18n: ProductI18n = defineI18n({ locales: LOCALES, defaultLocale: DEFAULT_LOCALE, timeZone: "Asia/Ho_Chi_Minh" })

package/templates/fe/skeleton-lite/apps/web/src/app/[locale]/auth/confirm/page.tsx

@@ -0,0 +1,9 @@
+import { AppConfirmPage } from "@/features/pages/AppConfirmPage"
+
+/** The document title of this page. */
+export { appConfirmMetadata as generateMetadata } from "@/features/pages/AppConfirmPage"
+
+/** The confirm page slot: Next hands the query over as a promise, which the page reads for the token of the mail link. */
+const Page = (props: Parameters<typeof AppConfirmPage>[0]) => <AppConfirmPage {...props} />
+
+export default Page

package/templates/fe/skeleton-lite/apps/web/src/app/[locale]/auth/forgot/page.tsx

@@ -0,0 +1,9 @@
+import { AppForgotPage } from "@/features/pages/AppForgotPage"
+
+/** The document title of this page. */
+export { appForgotMetadata as generateMetadata } from "@/features/pages/AppForgotPage"
+
+/** The forgot page slot. */
+const Page = () => <AppForgotPage />
+
+export default Page

package/templates/fe/skeleton-lite/apps/web/src/app/[locale]/auth/resend/page.tsx

@@ -0,0 +1,9 @@
+import { AppResendPage } from "@/features/pages/AppResendPage"
+
+/** The document title of this page. */
+export { appResendMetadata as generateMetadata } from "@/features/pages/AppResendPage"
+
+/** The resend page slot. */
+const Page = () => <AppResendPage />
+
+export default Page

package/templates/fe/skeleton-lite/apps/web/src/app/[locale]/auth/reset/page.tsx

@@ -0,0 +1,9 @@
+import { AppResetPage } from "@/features/pages/AppResetPage"
+
+/** The document title of this page. */
+export { appResetMetadata as generateMetadata } from "@/features/pages/AppResetPage"
+
+/** The reset page slot: Next hands the query over as a promise, which the page reads for the token of the mail link. */
+const Page = (props: Parameters<typeof AppResetPage>[0]) => <AppResetPage {...props} />
+
+export default Page

package/templates/fe/skeleton-lite/apps/web/src/app/[locale]/auth/signup/page.tsx

@@ -0,0 +1,9 @@
+import { AppSignupPage } from "@/features/pages/AppSignupPage"
+
+/** The document title of this page. */
+export { appSignupMetadata as generateMetadata } from "@/features/pages/AppSignupPage"
+
+/** The signup page slot. */
+const Page = () => <AppSignupPage />
+
+export default Page

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

@@ -1,10 +1,8 @@
-import { hasLocale } from "next-intl"
-import { getMessages } from "next-intl/server"
-import { notFound } from "next/navigation"
+import { createReadLocaleSegment } from "@starci/next-i18n/layout"
 import type { Metadata } from "next"
 import type { ReactElement, ReactNode } from "react"
 import { AppLayout, appLayoutMetadata } from "@/features/layouts/AppLayout"
-import { PRODUCT_TIME_ZONE, routing } from "@/modules/i18n"
+import { i18n } from "@/modules/i18n"
 import { Providers } from "./providers"
 import "../globals.css"
 import "@/modules/brand"
@@ -17,16 +15,14 @@ type LayoutProps = {
 /** The localized document title of this route segment. */
 export const generateMetadata = async (props: LayoutProps): Promise<Metadata> => appLayoutMetadata((await props.params).locale)
 
-/** The locale segment's document, providers and app chrome. */
+/** The locale segment's document, providers and app chrome; an unknown locale is a 404. */
 const Layout = async (props: LayoutProps): Promise<ReactElement> => {
-    const { locale } = await props.params
-    if (!hasLocale(routing.locales, locale)) notFound()
-    const messages = await getMessages()
+    const { locale, messages, timeZone } = await createReadLocaleSegment(i18n)(props.params)
     return (
         <AppLayout
             locale={locale}
             content={
-                <Providers locale={locale} messages={messages} timeZone={PRODUCT_TIME_ZONE}>
+                <Providers locale={locale} messages={messages} timeZone={timeZone}>
                     {props.children}
                 </Providers>
             }

package/templates/fe/skeleton-lite/apps/web/src/components/blocks/EmailDoorForm/component.tsx

@@ -0,0 +1,51 @@
+import { Button, Form, Input, Link, Text } from "@starci/grammar/common"
+
+/** One destination under the form: a sibling door or the sign-in page. */
+export interface EmailDoorLink {
+    readonly href: string
+    readonly label: string
+}
+
+/** Copy, fields, state and action supplied by the connected email-door block. */
+export interface EmailDoorFormBaseProps {
+    readonly props: {
+        readonly title: string
+        readonly description: string
+        /** The label of the email field, or undefined when the door takes none. */
+        readonly emailLabel: string | undefined
+        /** The label of the password field, or undefined when the door takes none. */
+        readonly passwordLabel: string | undefined
+        readonly submitLabel: string
+        readonly pending: boolean
+        /** The resolved message of the last refusal, or undefined. */
+        readonly errorMessage: string | undefined
+        /** The message shown once the back end accepted the request, or undefined while it has not. */
+        readonly doneMessage: string | undefined
+        readonly links: readonly EmailDoorLink[]
+    }
+    readonly on: { readonly submit: (input: FormData) => void }
+}
+
+/** Draws one email door (sign up, resend, forgot, reset) without reading navigation, copy or request state. */
+export const EmailDoorFormBase = (props: EmailDoorFormBaseProps) => (
+    <>
+        {props.props.doneMessage === undefined ? (
+            <Form label={props.props.title} isPending={props.props.pending} onSubmit={props.on.submit}>
+                <Text>{props.props.description}</Text>
+                {props.props.emailLabel === undefined ? null : <Input id="email-door-email" name="email" label={props.props.emailLabel} kind="email" isRequired />}
+                {props.props.passwordLabel === undefined ? null : <Input id="email-door-password" name="password" label={props.props.passwordLabel} kind="password" isRequired />}
+                {props.props.errorMessage === undefined ? null : <Text live="assertive">{props.props.errorMessage}</Text>}
+                <Button type="submit" intent="commit" isPending={props.props.pending}>
+                    {props.props.submitLabel}
+                </Button>
+            </Form>
+        ) : (
+            <Text live="polite">{props.props.doneMessage}</Text>
+        )}
+        {props.props.links.map((link) => (
+            <Link key={link.href} href={link.href}>
+                {link.label}
+            </Link>
+        ))}
+    </>
+)

package/templates/fe/skeleton-lite/apps/web/src/components/blocks/EmailDoorForm/index.tsx

@@ -0,0 +1,84 @@
+"use client"
+
+import { useLocale, useTranslations } from "next-intl"
+import { useEmailDoor } from "@/hooks/emailAuth"
+import type { EmailDoorFailure } from "@/hooks/emailAuth"
+import { APP_ROUTES } from "@/modules/routes"
+import { EmailDoorFormBase } from "./component"
+import type { EmailDoorLink } from "./component"
+
+/** The doors the block draws; the confirmation is a button, so the mailbox is confirmed by a person and not by a mail scanner opening the link. */
+type FormDoor = "signup" | "resend" | "forgot" | "reset" | "confirm"
+
+/** The door the block draws and, for the two link doors, the token of the link. */
+type EmailDoorFormProps = { readonly door: FormDoor; readonly token?: string | undefined }
+
+/** The words of one door. */
+interface DoorCopy {
+    readonly title: string
+    readonly description: string
+    readonly submit: string
+    readonly done: string
+    readonly email: string | undefined
+    readonly password: string | undefined
+}
+
+/** The value of a field of the submitted form, or undefined when it is missing. */
+const fieldOf = (input: FormData, name: string): string | undefined => {
+    const value = input.get(name)
+    return typeof value === "string" ? value : undefined
+}
+
+/** The language a mail is written in: the page's, when the back end writes mail in it. */
+const languageOf = (locale: string): "vi" | "en" | undefined => (locale === "vi" || locale === "en" ? locale : undefined)
+
+/** One email door of the lite sign-in as a form: sign up, resend the confirmation, forgot the password, or choose a new one from a link. */
+export const EmailDoorForm = (props: EmailDoorFormProps) => {
+    const t = useTranslations("app.emailAuth")
+    const locale = useLocale()
+    const { failure, done, pending, submit, reject } = useEmailDoor(props.door)
+    const copy = {
+        signup: { title: t("signup.title"), description: t("signup.description"), submit: t("signup.submit"), done: t("signup.done"), email: t("email"), password: t("password") },
+        resend: { title: t("resend.title"), description: t("resend.description"), submit: t("resend.submit"), done: t("resend.done"), email: t("email"), password: undefined },
+        forgot: { title: t("forgot.title"), description: t("forgot.description"), submit: t("forgot.submit"), done: t("forgot.done"), email: t("email"), password: undefined },
+        confirm: { title: t("confirm.title"), description: t("confirm.description"), submit: t("confirm.submit"), done: t("confirm.done"), email: undefined, password: undefined },
+        reset: { title: t("reset.title"), description: t("reset.description"), submit: t("reset.submit"), done: t("reset.done"), email: undefined, password: t("newPassword") },
+    } satisfies Record<FormDoor, DoorCopy>
+    const links = {
+        signup: [{ href: APP_ROUTES.home, label: t("toSignIn") }, { href: APP_ROUTES.resend, label: t("toResend") }],
+        resend: [{ href: APP_ROUTES.home, label: t("toSignIn") }],
+        forgot: [{ href: APP_ROUTES.home, label: t("toSignIn") }],
+        reset: [{ href: APP_ROUTES.home, label: t("toSignIn") }, { href: APP_ROUTES.forgot, label: t("toForgot") }],
+        confirm: [{ href: APP_ROUTES.home, label: t("toSignIn") }, { href: APP_ROUTES.resend, label: t("toResend") }],
+    } satisfies Record<FormDoor, readonly EmailDoorLink[]>
+    const failures = {
+        invalid: t("errors.invalid"),
+        password: t("errors.password"),
+        link: t("errors.link"),
+        tooMany: t("errors.tooMany"),
+        unavailable: t("errors.unavailable"),
+    } satisfies Record<EmailDoorFailure, string>
+    const chosen = copy[props.door]
+    const onSubmit = (input: FormData) => {
+        const email = fieldOf(input, "email")
+        const password = fieldOf(input, "password")
+        if ((chosen.email !== undefined && email === undefined) || (chosen.password !== undefined && password === undefined)) reject()
+        else submit({ email, password, token: props.token, language: languageOf(locale) })
+    }
+    return (
+        <EmailDoorFormBase
+            props={{
+                title: chosen.title,
+                description: chosen.description,
+                emailLabel: chosen.email,
+                passwordLabel: chosen.password,
+                submitLabel: chosen.submit,
+                pending,
+                errorMessage: failure === undefined ? undefined : failures[failure],
+                doneMessage: done ? chosen.done : undefined,
+                links: links[props.door],
+            }}
+            on={{ submit: onSubmit }}
+        />
+    )
+}

package/templates/fe/skeleton-lite/apps/web/src/features/pages/AppConfirmPage/index.tsx

@@ -0,0 +1,25 @@
+import type { ReactElement } from "react"
+import type { Metadata } from "next"
+import { Page } from "@starci/grammar/common"
+import { getTranslations } from "next-intl/server"
+import { EmailDoorForm } from "@/components/blocks/EmailDoorForm"
+
+/** The document title of the confirm page. */
+export const appConfirmMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("app.emailAuth.confirm")
+    return { title: t("title") }
+}
+
+/** The query of the page: the link of the mail carries its token there. */
+type AppConfirmPageProps = { readonly searchParams: Promise<{ readonly token?: string | readonly string[] }> }
+
+/** The confirm door of the lite sign-in, drawn as one Grammar Page (R325). */
+export const AppConfirmPage = async (props: AppConfirmPageProps): Promise<ReactElement> => {
+    const { token } = await props.searchParams
+    const t = await getTranslations("app.emailAuth.confirm")
+    return (
+        <Page header={{ title: t("title") }} measure="reading">
+            <EmailDoorForm door="confirm" token={typeof token === "string" ? token : token?.[0]} />
+        </Page>
+    )
+}

package/templates/fe/skeleton-lite/apps/web/src/features/pages/AppForgotPage/index.tsx

@@ -0,0 +1,21 @@
+import type { ReactElement } from "react"
+import type { Metadata } from "next"
+import { Page } from "@starci/grammar/common"
+import { getTranslations } from "next-intl/server"
+import { EmailDoorForm } from "@/components/blocks/EmailDoorForm"
+
+/** The document title of the forgot page. */
+export const appForgotMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("app.emailAuth.forgot")
+    return { title: t("title") }
+}
+
+/** The forgot door of the lite sign-in, drawn as one Grammar Page (R325). */
+export const AppForgotPage = async (_props: Record<string, never>): Promise<ReactElement> => {
+    const t = await getTranslations("app.emailAuth.forgot")
+    return (
+        <Page header={{ title: t("title") }} measure="reading">
+            <EmailDoorForm door="forgot" />
+        </Page>
+    )
+}

package/templates/fe/skeleton-lite/apps/web/src/features/pages/AppHomePage/component.tsx

@@ -1,16 +1,24 @@
-import { Page } from "@starci/grammar/common"
+import { Link, Page } from "@starci/grammar/common"
 import { SignInForm } from "@/components/blocks/SignInForm"
 import { SignOutButton } from "@/components/blocks/SignOutButton"
 
-/** Props for the home page: its title. */
+/** Props for the home page: its title and the two doors beside the sign-in form. */
 export type AppHomePageBaseProps = {
-    readonly props: { readonly title: string }
+    readonly props: {
+        readonly title: string
+        readonly signupLabel: string
+        readonly signupHref: string
+        readonly forgotLabel: string
+        readonly forgotHref: string
+    }
 }
 
 /** Draws the front door as one Grammar Page (R325): the title heads the band, the body the sign-in form or the reader and sign-out. */
 export const AppHomePageBase = (props: AppHomePageBaseProps) => (
     <Page header={{ title: props.props.title }}>
         <SignInForm />
+        <Link href={props.props.signupHref}>{props.props.signupLabel}</Link>
+        <Link href={props.props.forgotHref}>{props.props.forgotLabel}</Link>
         <SignOutButton />
     </Page>
 )

package/templates/fe/skeleton-lite/apps/web/src/features/pages/AppHomePage/index.tsx

@@ -2,6 +2,7 @@ import type { ReactElement } from "react"
 import type { Metadata } from "next"
 import { getTranslations } from "next-intl/server"
 import { AppGuideOverlay } from "@/features/overlays/AppGuideOverlay"
+import { APP_ROUTES } from "@/modules/routes"
 import { AppHomePageBase } from "./component"
 
 /** The document title of the home page. */
@@ -15,7 +16,9 @@ export const AppHomePage = async (): Promise<ReactElement> => {
     const t = await getTranslations("app.home")
     return (
         <>
-            <AppHomePageBase props={{ title: t("title") }} />
+            <AppHomePageBase
+                props={{ title: t("title"), signupLabel: t("signup"), signupHref: APP_ROUTES.signup, forgotLabel: t("forgot"), forgotHref: APP_ROUTES.forgot }}
+            />
             <AppGuideOverlay />
         </>
     )

package/templates/fe/skeleton-lite/apps/web/src/features/pages/AppResendPage/index.tsx

@@ -0,0 +1,21 @@
+import type { ReactElement } from "react"
+import type { Metadata } from "next"
+import { Page } from "@starci/grammar/common"
+import { getTranslations } from "next-intl/server"
+import { EmailDoorForm } from "@/components/blocks/EmailDoorForm"
+
+/** The document title of the resend page. */
+export const appResendMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("app.emailAuth.resend")
+    return { title: t("title") }
+}
+
+/** The resend door of the lite sign-in, drawn as one Grammar Page (R325). */
+export const AppResendPage = async (_props: Record<string, never>): Promise<ReactElement> => {
+    const t = await getTranslations("app.emailAuth.resend")
+    return (
+        <Page header={{ title: t("title") }} measure="reading">
+            <EmailDoorForm door="resend" />
+        </Page>
+    )
+}