@starci/hfs 5.1.0 → 5.3.0

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/be/test-world/e2e/serves-once-migrated.e2e-spec.ts.tpl

@@ -10,23 +10,23 @@ describe("system-health: the {{app}} app serves once its database is migrated (e
     const world = useTestWorld({ apps: ["{{app}}"] })
 
     it("answers liveness and readiness over the migrated {{connection}} database", async () => {
-        const live = await world.apps{{appAccess}}.api.get("/health/live")
-        const ready = await world.apps{{appAccess}}.api.get("/health/ready")
+        const live = await world.apps{{appAccess}}?.api.get("/health/live")
+        const ready = await world.apps{{appAccess}}?.api.get("/health/ready")
         const applied = await appliedMigrations(world.db{{connectionAccess}}, {{migrationsConst}})
 
-        expect(live.status).toBe(200)
-        expect(ready.status).toBe(200)
-        expect(ready.body).toEqual({ ok: true })
+        expect(live?.status).toBe(200)
+        expect(ready?.status).toBe(200)
+        expect(ready?.body).toEqual({ ok: true })
         expect(applied.length).toBeGreaterThan(0)
     })
 
     it("answers 503 on readiness while the database is cut, and liveness stays up", async () => {
         await world.interruptDatabase(async () => {
-            const ready = await world.apps{{appAccess}}.api.get("/health/ready")
-            const live = await world.apps{{appAccess}}.api.get("/health/live")
+            const ready = await world.apps{{appAccess}}?.api.get("/health/ready")
+            const live = await world.apps{{appAccess}}?.api.get("/health/live")
 
-            expect(ready.status).toBe(503)
-            expect(live.status).toBe(200)
+            expect(ready?.status).toBe(503)
+            expect(live?.status).toBe(200)
         })
     })
 })

package/templates/be/test-world/fixtures/migrations.sql.ts.tpl

@@ -1,6 +1,5 @@
 import type { EntityManager } from "typeorm"
 import { sql } from "@modules/platform/database"
-import type { SqlText } from "@modules/platform/database"
 
 /** One row of a connection's migration ledger: the name of a migration the cli migrate step applied. */
 export interface AppliedMigrationRow {
@@ -8,8 +7,9 @@ export interface AppliedMigrationRow {
     readonly name: string
 }
 {{migrationQueries}}
-/** Reads the ledger of one connection with one of the queries above. */
+/** Reads the ledger of one connection with one of the queries above; a connection the world did not wire fails the spec. */
 export const appliedMigrations = (
-    manager: EntityManager,
+    manager: EntityManager | undefined,
     query: ReturnType<typeof sql>,
-): Promise<ReadonlyArray<AppliedMigrationRow>> => manager.query(query)
+): Promise<ReadonlyArray<AppliedMigrationRow>> =>
+    manager === undefined ? Promise.reject(new Error("The test world wired no such connection")) : manager.query(query)

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

@@ -0,0 +1,26 @@
+// 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 { AuthClient, AuthFailure, AuthSession } from "./contracts"
+
+/** The one instance of the front end: the doors of the app's own back end, the access token in its memory, one shared refresh. */
+const auth = createAuthClient({ apiOrigin: () => apiUrl() })
+
+const sessionOf = (user: { readonly id: string; readonly email: string } | null): AuthSession | undefined =>
+    user === null ? undefined : { userId: user.id, ...(user.email === "" ? {} : { email: user.email }) }
+
+/** The lite session issuer's client: `@starci/auth/client` behind the interface every edition shares. */
+export const authClient: AuthClient = {
+    session: async () => sessionOf(await auth.user()),
+    accessToken: () => auth.accessToken(),
+    refreshAccessToken: () => auth.renew(),
+    signInWithPassword: async (email, password): Promise<AuthFailure | undefined> => {
+        const outcome = await auth.signIn({ email, password })
+        return outcome.success ? undefined : { code: outcome.error, kind: outcome.message, message: "" }
+    },
+    signOut: async () => {
+        await auth.signOut()
+        return undefined
+    },
+    onChange: (listener) => auth.subscribe(() => listener(sessionOf(auth.getSnapshot().user))),
+}

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/common/site-shell.tsx.partial

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

package/templates/fe/skeleton/apps/__app__/src/components/providers/AppProviders/index.tsx

@@ -1,11 +1,15 @@
 "use client"
 
 import { ToastProvider } from "@heroui/react"
+import { viewerCacheKey, viewerSwrConfig } from "@starci/next-data"
+import type { ViewerId } from "@starci/next-data"
 import { ThemeProvider } from "next-themes"
 import type { ReactNode } from "react"
-import { SWRConfig } from "swr"
+import { SWRConfig, useSWRConfig } from "swr"
+import { useViewerId } from "@/hooks/auth"
 import { useAuthSessionEffect } from "@/hooks/effects"
 import { SwrSideEffects } from "@/hooks/swr"
+import { viewerCache } from "@/modules/viewer-cache"
 import { ReduxProvider } from "@/redux"
 
 /** What the app providers wrap: the routed tree. */
@@ -25,25 +29,44 @@ const SWR_DEFAULTS = {
 } as const
 
 /** The app-wide session effect: modules/auth's session kept in redux. Renders nothing. */
-const AuthSessionEffect = () => {
+const AuthSessionEffect = (): null => {
     useAuthSessionEffect()
     return null
 }
 
+/** Points the writes of viewerCache at the SWR cache around it. Renders nothing. */
+const ViewerCacheBinding = (): null => {
+    viewerCache.bind(useSWRConfig().mutate)
+    return null
+}
+
+/**
+ * Each viewer gets their own SWR cache (FE-BOUNDARY-3): a change of person remounts the config on a fresh Map, and
+ * `viewerSwrConfig` lists pollingRestart so a read whose refreshInterval stopped at 0 polls again for newer data.
+ */
+const renderViewerScope = (viewerId: ViewerId, children: ReactNode): ReactNode => (
+    <SWRConfig key={viewerCacheKey(viewerId)} value={viewerSwrConfig(SWR_DEFAULTS)}>
+        <ViewerCacheBinding />
+        <SwrSideEffects />
+        {children}
+        <ToastProvider />
+    </SWRConfig>
+)
+
+/** The SWR config of the viewer on screen around the routed tree. */
+const ViewerSwrScope = (props: AppProvidersProps): ReactNode => renderViewerScope(useViewerId(), props.children)
+
 /**
  * The one client provider stack the locale layout mounts, outer to inner: the theme (light and dark through the `.light` /
- * `.dark` class the grammar and the brand layer read, the system theme by default), the redux store, the SWR defaults, the
- * app-wide effects and the HeroUI toast region modules/toast writes to. Each part is composed here, in its one owner.
+ * `.dark` class the grammar and the brand layer read, the system theme by default), the redux store, the session effect, the
+ * SWR config keyed by the viewer, the app-wide effects and the HeroUI toast region modules/toast writes to. Each part is
+ * composed here, in its one owner.
  */
 export const AppProviders = (props: AppProvidersProps) => (
     <ThemeProvider attribute="class" defaultTheme="system" enableSystem disableTransitionOnChange>
         <ReduxProvider>
-            <SWRConfig value={SWR_DEFAULTS}>
-                <AuthSessionEffect />
-                <SwrSideEffects />
-                {props.children}
-                <ToastProvider />
-            </SWRConfig>
+            <AuthSessionEffect />
+            <ViewerSwrScope>{props.children}</ViewerSwrScope>
         </ReduxProvider>
     </ThemeProvider>
 )

package/templates/fe/skeleton/apps/__app__/src/hooks/auth/index.ts

@@ -2,3 +2,4 @@ export { useSession } from "./useSession"
 export { useSignIn } from "./useSignIn"
 export type { SignInFailure } from "./useSignIn"
 export { useSignOut } from "./useSignOut"
+export { useViewerId } from "./useViewerId"

package/templates/fe/skeleton/apps/__app__/src/hooks/auth/useViewerId.ts

@@ -0,0 +1,11 @@
+"use client"
+
+import type { ViewerId } from "@starci/next-data"
+import { useAppSelector } from "@/redux"
+
+/** The person the session belongs to: undefined until modules/auth answers, null when signed out (the viewer of @starci/next-data). */
+export const useViewerId = (): ViewerId => {
+    const session = useAppSelector((state) => state.session)
+    if (session.status === "unknown") return undefined
+    return session.session?.userId ?? null
+}

package/templates/fe/skeleton/apps/__app__/src/modules/toast/toast.tsx

@@ -21,15 +21,18 @@ const INDICATOR: Record<"success" | "danger" | "warning" | "info", ReactNode> =
 /** The app's toast: HeroUI's, with the four status methods wrapped. */
 type AppToast = typeof heroToast
 
-/** The app's toast: HeroUI's imperative toast with the status indicator injected; the region is mounted by the providers. */
-export const toast: AppToast = {
-    ...heroToast,
-    success: (message: ReactNode, options?: StatusToastOptions) =>
-        heroToast.success(message, { indicator: INDICATOR.success, ...options }),
-    danger: (message: ReactNode, options?: StatusToastOptions) =>
-        heroToast.danger(message, { indicator: INDICATOR.danger, ...options }),
-    warning: (message: ReactNode, options?: StatusToastOptions) =>
-        heroToast.warning(message, { indicator: INDICATOR.warning, ...options }),
-    info: (message: ReactNode, options?: StatusToastOptions) =>
-        heroToast.info(message, { indicator: INDICATOR.info, ...options }),
-}
+/** The app's toast: HeroUI's imperative toast, callable as it is, with the four status methods wrapped to inject the status indicator; the region is mounted by the providers. */
+export const toast: AppToast = Object.assign(
+    (message: ReactNode, options?: Parameters<typeof heroToast>[1]) => heroToast(message, options),
+    heroToast,
+    {
+        success: (message: ReactNode, options?: StatusToastOptions) =>
+            heroToast.success(message, { indicator: INDICATOR.success, ...options }),
+        danger: (message: ReactNode, options?: StatusToastOptions) =>
+            heroToast.danger(message, { indicator: INDICATOR.danger, ...options }),
+        warning: (message: ReactNode, options?: StatusToastOptions) =>
+            heroToast.warning(message, { indicator: INDICATOR.warning, ...options }),
+        info: (message: ReactNode, options?: StatusToastOptions) =>
+            heroToast.info(message, { indicator: INDICATOR.info, ...options }),
+    },
+)

package/templates/fe/skeleton/apps/__app__/src/modules/viewer-cache/index.ts

@@ -0,0 +1,5 @@
+import { createViewerCache } from "@starci/next-data"
+import type { ViewerCache } from "@starci/next-data"
+
+/** The writes to the cache of the viewer on screen: the one instance of the app, bound by the client providers. */
+export const viewerCache: ViewerCache = createViewerCache()

package/templates/fe/skeleton/apps/__app__/src/redux/slices/session.ts

@@ -9,7 +9,7 @@ export interface SessionState {
 }
 
 /** The reducers of the session slice. */
-interface SessionReducers {
+type SessionReducers = {
     sessionChanged: CaseReducer<SessionState, PayloadAction<AuthSession | undefined>>
 }
 

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(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/packages/__project__-ui/src/composites/NotFoundNotice/index.tsx

@@ -1,4 +1,4 @@
-import { Heading, TextAction } from "@starci/grammar/common"
+import { Link, Page } from "@starci/grammar/common"
 
 /** The words of a page that does not exist and the way back. */
 type NotFoundNoticeProps = {
@@ -10,10 +10,7 @@ type NotFoundNoticeProps = {
 
 /** A missing page: the message and the way back to the app's front door. */
 export const NotFoundNotice = (props: NotFoundNoticeProps) => (
-    <>
-        <Heading level={1}>{props.title}</Heading>
-        <TextAction appearance="inline" href={props.homeHref}>
-            {props.homeLabel}
-        </TextAction>
-    </>
+    <Page header={{ title: props.title }} measure="reading">
+        <Link href={props.homeHref}>{props.homeLabel}</Link>
+    </Page>
 )

package/templates/fe/skeleton/packages/__project__-ui/src/frames/SiteShell/index.tsx

@@ -1,6 +1,5 @@
 import type { ReactNode } from "react"
-import { GrammarRoot, PageContainer, TextAction, TopBar, WorkspaceShell } from "@starci/grammar/common"
-import { siteShellClassNames } from "./classNames"
+import { GrammarRoot, Link, TopBar, WorkspaceShell } from "@starci/grammar/common"
 
 /** What an app's chrome hands the shell: the brand, its home link and the routed body. */
 type SiteShellProps = {
@@ -14,6 +13,6 @@ type SiteShellProps = {
 
 /**
  * The document chrome both apps share: Grammar's Common boundary, the brand header (the top bar carrying the wordmark that links
- * home), then the routed body in the shell's main landmark at reading measure.
+ * home), then the routed body in the shell's main landmark (each page draws its own measure).
  */
 {{> fe/common/site-shell.tsx.partial}}

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>
             }