@starci/hfs 5.0.8 → 5.1.0

package/templates/be/skeleton/src/modules/platform/http-security/http-security.module-definition.ts

@@ -1,9 +1,15 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { HTTP_SECURITY_OPTIONS } from "./http-security.decorators"
 import type { HttpSecurityOptions } from "./http-security.options"
 
-/** The configurable-module base of the http-security capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<HttpSecurityOptions>({ optionsInjectionToken: HTTP_SECURITY_OPTIONS })
+const built = new ConfigurableModuleBuilder<HttpSecurityOptions>({ optionsInjectionToken: HTTP_SECURITY_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<HttpSecurityOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the http-security capability; `isGlobal` is decided by the app root. */
+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

package/templates/be/skeleton/src/modules/platform/http-security/persistence/connection.ts

@@ -1,8 +1,9 @@
+import type { DatabaseConnectionOptions } from "@modules/platform/database"
 import { RateWindowEntity } from "./entities/rate-window.entity"
 import { CreateRateWindows1789900000000 } from "./migrations/1789900000000-create-rate-windows"
 
 /** The entities of the http-security capability, for the primary connection its rate limit counts in. */
-export const httpSecurityEntities = [RateWindowEntity]
+export const httpSecurityEntities: DatabaseConnectionOptions["entities"] = [RateWindowEntity]
 
 /** The migrations of the http-security capability, in the order they run. */
-export const httpSecurityMigrations = [CreateRateWindows1789900000000]
+export const httpSecurityMigrations: DatabaseConnectionOptions["migrations"] = [CreateRateWindows1789900000000]

package/templates/be/skeleton/src/modules/platform/http-security/persistence/rate-limit.sql.ts

@@ -1,10 +1,11 @@
 import { sql } from "@modules/platform/database"
+import type { SqlText } from "@modules/platform/database"
 
 /**
  * Counts one hit in the caller's window and answers the hits of that window: a missing or expired window opens afresh at one
  * hit and ends at $3 ($1 tier and address key, $2 instant, $3 end of a fresh window).
  */
-export const HIT_RATE_WINDOW = sql`INSERT INTO http_security_rate_windows (key, hits, reset_at)
+export const HIT_RATE_WINDOW: SqlText = sql`INSERT INTO http_security_rate_windows (key, hits, reset_at)
     VALUES ($1::varchar, 1, $3::timestamptz)
     ON CONFLICT (key) DO UPDATE SET
         hits = CASE WHEN http_security_rate_windows.reset_at <= $2::timestamptz THEN 1
@@ -14,7 +15,7 @@ export const HIT_RATE_WINDOW = sql`INSERT INTO http_security_rate_windows (key,
     RETURNING hits`
 
 /** Deletes a bounded batch of the windows that ended by $1; a second replica skips the rows this one holds. */
-export const PRUNE_RATE_WINDOWS = sql`DELETE FROM http_security_rate_windows WHERE key IN (
+export const PRUNE_RATE_WINDOWS: SqlText = sql`DELETE FROM http_security_rate_windows WHERE key IN (
     SELECT key FROM http_security_rate_windows WHERE reset_at <= $1::timestamptz
     LIMIT 100 FOR UPDATE SKIP LOCKED
 )`

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

@@ -1,9 +1,15 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import { I18N_OPTIONS } from "./i18n.decorators"
 import type { I18nOptions } from "./i18n.options"
 
-/** The configurable-module base of the i18n capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<I18nOptions>({ optionsInjectionToken: I18N_OPTIONS })
+const built = new ConfigurableModuleBuilder<I18nOptions>({ optionsInjectionToken: I18N_OPTIONS })
         .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
         .build()
+type Host = ConfigurableModuleHost<I18nOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the i18n capability; `isGlobal` is decided by the app root. */
+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

package/templates/be/skeleton/src/modules/platform/ids/ids.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { IdsOptions } from "./ids.options"
 
-/** The configurable-module base of the ids capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<IdsOptions>()
+const built = new ConfigurableModuleBuilder<IdsOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<IdsOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the ids capability; `isGlobal` is decided by the app root. */
+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

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

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { LoggingOptions } from "./logging.options"
 
-/** The configurable-module base of the logging capability; `isGlobal` is decided by the app root. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<LoggingOptions>()
+const built = new ConfigurableModuleBuilder<LoggingOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<LoggingOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the logging capability; `isGlobal` is decided by the app root. */
+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

package/templates/be/skeleton/src/modules/platform/retry/retry.module-definition.ts

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { RetryOptions } from "./retry.options"
 
-/** The configurable-module base of the retry capability; the app root decides its global scope. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<RetryOptions>()
+const built = new ConfigurableModuleBuilder<RetryOptions>()
     .setExtras({ isGlobal: false }, (definition, extras) => ({ ...definition, global: extras.isGlobal }))
     .build()
+type Host = ConfigurableModuleHost<RetryOptions, "register", "create", { isGlobal: boolean }>
+
+/** The configurable-module base of the retry capability; the app root decides its global scope. */
+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

package/templates/be/skeleton-lite/src/modules/domain/identity/identity.decorators.ts

@@ -47,7 +47,7 @@ export const Credential = (metadata: CredentialMetadata): DoorDecorator =>
     applyDecorators(SetMetadata(CREDENTIAL_KEY, metadata), ServerToServer())
 
 /** The authenticated caller established by the default-deny guard. */
-export const CurrentPrincipal = createParamDecorator((_data: unknown, context: ExecutionContext): Principal => {
+export const CurrentPrincipal: ReturnType<typeof createParamDecorator> = createParamDecorator((_data: unknown, context: ExecutionContext): Principal => {
     const principal = requestOf(context).principal
     if (!principal) throw new IdentityError({ code: IdentityErrorCode.Unauthenticated })
     return principal

package/templates/be/skeleton-lite/src/modules/integrations/passport/strategies/google.strategy.ts

@@ -1,4 +1,5 @@
 import { Injectable } from "@nestjs/common"
+import type { Type } from "@nestjs/common"
 import { PassportStrategy } from "@nestjs/passport"
 import { Strategy } from "passport-google-oauth20"
 import type { Profile } from "passport-google-oauth20"
@@ -14,9 +15,12 @@ export interface GoogleIdentity {
     readonly email?: string
 }
 
+/** The Passport strategy base of the google scheme, typed as the class the strategy extends. */
+const GoogleStrategyBase: Type<object> = PassportStrategy(Strategy, "google")
+
 @Injectable()
 /** Google OAuth 2.0 (authorization code with state and PKCE): it proves the Google identity and never signs the user in itself. */
-export class GoogleStrategy extends PassportStrategy(Strategy, "google") {
+export class GoogleStrategy extends GoogleStrategyBase {
     constructor(@InjectPassportOptions() options: PassportOptions) {
         super({
             clientID: options.google.clientId,

package/templates/be/skeleton-lite/src/modules/integrations/passport/strategies/local.strategy.ts

@@ -1,4 +1,5 @@
 import { Injectable } from "@nestjs/common"
+import type { Type } from "@nestjs/common"
 import { PassportStrategy } from "@nestjs/passport"
 import { Strategy } from "passport-local"
 import { PassportError, PassportErrorCode } from "../errors/passport.error"
@@ -18,9 +19,12 @@ export interface PasswordAccount {
 /** The lookup the identity domain provides: the account of one email, or undefined. */
 export type FindPasswordAccount = (email: string) => Promise<PasswordAccount | undefined>
 
+/** The Passport strategy base of the local scheme, typed as the class the strategy extends. */
+const LocalStrategyBase: Type<object> = PassportStrategy(Strategy, "local")
+
 @Injectable()
 /** Email and password sign-in: bcrypt against the stored hash; a miss and a wrong password fail alike. */
-export class LocalStrategy extends PassportStrategy(Strategy, "local") {
+export class LocalStrategy extends LocalStrategyBase {
     constructor(@InjectPasswordAccounts() private readonly findAccount: FindPasswordAccount) {
         super({ usernameField: "email", passwordField: "password" })
     }

package/templates/be/skeleton-lite/src/modules/platform/database/database.port.ts

@@ -5,7 +5,7 @@ import type { DatabaseOptions } from "./database.options"
 import { PRIMARY_CONNECTION } from "./primary.connection"
 
 /** The primary pool's override token for infrastructure fixtures; TypeORM tokens stay owned by this capability. */
-export const PRIMARY_DATA_SOURCE = getDataSourceToken(PRIMARY_CONNECTION)
+export const PRIMARY_DATA_SOURCE: ReturnType<typeof getDataSourceToken> = getDataSourceToken(PRIMARY_CONNECTION)
 
 /** Token of the options of the database capability. */
 export const DATABASE_OPTIONS: unique symbol = Symbol("platform.database.options")

package/templates/be/skeleton-lite/src/modules/platform/http-security/persistence/entities/index.ts

@@ -1,4 +1,4 @@
 import { RateWindowEntity } from "./rate-window.entity"
 
 /** The entities of the http-security capability, named in PRIMARY_ENTITIES of platform/database/entities.ts. */
-export const httpSecurityEntities = [RateWindowEntity]
+export const httpSecurityEntities: ReadonlyArray<typeof RateWindowEntity> = [RateWindowEntity]

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

@@ -4,8 +4,14 @@ import { ACCESS_TOKEN_VERIFIER } from "@modules/domain/identity"
 import { OWN_TOKEN_VERIFIER } from "@modules/integrations/passport"
 import { OBJECT_STORAGE } from "@modules/integrations/object-storage"
 
+/** What a wiring proof hands the compiled root: public options and the infrastructure doubles. */
+export interface WiringProof {
+    readonly options: Readonly<Record<string, unknown>>
+    readonly overrides: ReadonlyArray<{ readonly token: unknown; readonly value: unknown }>
+}
+
 /** Compiles the real API root with public configuration and explicit infrastructure doubles. */
-export const buildWiringProof = () => ({
+export const buildWiringProof = (): WiringProof => ({
     options: {
         server: { port: 3000 },
         httpSecurity: {

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

@@ -2,8 +2,14 @@ import { getDataSourceToken } from "@nestjs/typeorm"
 import { Secret } from "@modules/platform/config"
 import { PRIMARY_CONNECTION } from "@modules/platform/database"
 
+/** What a wiring proof hands the compiled root: public options and the infrastructure doubles. */
+export interface WiringProof {
+    readonly options: Readonly<Record<string, unknown>>
+    readonly overrides: ReadonlyArray<{ readonly token: unknown; readonly value: unknown }>
+}
+
 /** Public fixture options and the database double for compiling the real CLI AppModule without network access. */
-export const buildWiringProof = () => ({
+export const buildWiringProof = (): WiringProof => ({
     options: {
         connections: [{
             name: PRIMARY_CONNECTION,

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

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 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, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<{{Name}}ApiOptions>().setClassMethodName("register").build()
+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

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

@@ -1,6 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 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, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } =
-    new ConfigurableModuleBuilder<{{Name}}GraphqlOptions>().setClassMethodName("register").build()
+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

package/templates/be/table/entities.index.ts.tpl

@@ -1,4 +1,4 @@
 import { {{Singular}}Entity } from "./{{name}}.entity"
 
 /** The entities of the {{name}} capability, named in PRIMARY_ENTITIES of platform/database/entities.ts. */
-export const {{nameCamel}}Entities = [{{Singular}}Entity]
+export const {{nameCamel}}Entities: ReadonlyArray<typeof {{Singular}}Entity> = [{{Singular}}Entity]

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

@@ -1,7 +1,12 @@
-import { ConfigurableModuleBuilder } from "@nestjs/common"
+import { ConfigurableModuleBuilder, type ConfigurableModuleHost } from "@nestjs/common"
 import type { {{Name}}Options } from "./{{name}}.options"
 
-/** The configurable-module base of the {{name}} capability. */
-export const { ConfigurableModuleClass, OPTIONS_TYPE } = new ConfigurableModuleBuilder<{{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

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

@@ -1,5 +1,6 @@
 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 {

package/templates/be/test-world/world/test-world.config.ts.tpl

@@ -5,10 +5,11 @@
  */
 import { applyCorrelation } from "@modules/platform/logging"
 import { defineTestWorld } from "@starci/test-world"
+import type { TestWorldApi } from "@starci/test-world"
 {{appModuleImports}}
 import { {{optionsImports}} } from "./test-apps.options"
 
-export const { useTestWorld, useSandbox } = defineTestWorld({
+const world: TestWorldApi = defineTestWorld({
     stack: ".starcistacks/dev",
     stacks: {
         postgresql: { connections: [{{connectionDeclarations}}] },
@@ -19,3 +20,9 @@ export const { useTestWorld, useSandbox } = defineTestWorld({
     migrate: { module: migrateCli, options: cliOptionsOf },
     modules: { base: platformBase },
 })
+
+/** Registers the hooks that boot and close the world around a spec and answers its handle; call it inside `describe`. */
+export const useTestWorld: TestWorldApi["useTestWorld"] = world.useTestWorld
+
+/** The contract layer: the real integration client against a provider sandbox, in a `contract-spec`. */
+export const useSandbox: TestWorldApi["useSandbox"] = world.useSandbox

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

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

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

@@ -2,9 +2,10 @@
 
 import { useDebugValue } from "react"
 import { useAppSelector } from "@/redux"
+import type { SessionState } from "@/redux"
 
 /** The reader's session as the app shares it (redux, kept by the auth session effect): unknown, signed in or signed out. */
-export const useSession = () => {
+export const useSession = (): SessionState => {
     const session = useAppSelector((state) => state.session)
     useDebugValue(session.status)
     return session

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

@@ -12,18 +12,26 @@ const FAILURES: readonly SignInFailure[] = ["refused", "invalid", "unavailable"]
 /** The failure of a sign-in's failure kind. */
 const failureOf = (kind: string): SignInFailure => FAILURES.find((each) => each === kind) ?? "unavailable"
 
+/** What the sign-in hook answers: whether a request runs, why the last one failed, the sign-in itself and `reject`. */
+export interface SignIn {
+    readonly failure: SignInFailure | undefined
+    readonly pending: boolean
+    readonly signIn: (email: string, password: string) => void
+    readonly reject: () => void
+}
+
 /**
  * Signs the reader in with an email and a password through modules/auth: whether a request runs, why the last one failed,
  * the sign-in itself and `reject` for input the form could not read. A success needs no state here: the session effect
  * moves the reader to signed in.
  */
-export const useSignIn = () => {
+export const useSignIn = (): SignIn => {
     const [failure, setFailure] = useState<SignInFailure>()
     const [pending, startTransition] = useTransition()
-    const signIn = (email: string, password: string) =>
+    const signIn = (email: string, password: string): void =>
         startTransition(async () => {
             const failed = await authClient.signInWithPassword(email, password)
             setFailure(failed === undefined ? undefined : failureOf(failed.kind))
         })
-    return { failure, pending, signIn, reject: () => setFailure("invalid") }
+    return { failure, pending, signIn, reject: (): void => setFailure("invalid") }
 }

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

@@ -11,14 +11,20 @@ const responseOf = (failure: AuthFailure | undefined) =>
         ? { success: true as const, data: null }
         : { success: false as const, error: failure.code, kind: failure.kind, message: failure.message }
 
+/** What the sign-out hook answers: whether the request runs and the sign-out itself. */
+export interface SignOut {
+    readonly pending: boolean
+    readonly signOut: () => void
+}
+
 /**
  * Ends the reader's session through modules/auth: whether the request runs and the sign-out itself. A failure is reported by
  * modules/toast; a success needs no toast, the session effect moves the reader to signed out.
  */
-export const useSignOut = () => {
+export const useSignOut = (): SignOut => {
     const withToast = useGraphQLWithToast()
     const [pending, startTransition] = useTransition()
-    const signOut = () =>
+    const signOut = (): void =>
         startTransition(async () => {
             await withToast(async () => responseOf(await authClient.signOut()), { showSuccessToast: false })
         })

package/templates/fe/skeleton/apps/__app__/src/hooks/zustand/appGuide/store.ts

@@ -1,6 +1,7 @@
 "use client"
 
 import { create } from "zustand"
+import type { StoreApi, UseBoundStore } from "zustand"
 
 /** The home guide's local UI state; it carries no session or server data. */
 type AppGuideState = {
@@ -9,7 +10,7 @@ type AppGuideState = {
 }
 
 /** One feature-local store, shared by the guide trigger and its controlled dialog. */
-export const useAppGuideStore = create<AppGuideState>()((set) => ({
+export const useAppGuideStore: UseBoundStore<StoreApi<AppGuideState>> = create<AppGuideState>()((set) => ({
     isOpen: false,
     setOpen: (isOpen) => set({ isOpen }),
 }))

package/templates/fe/skeleton/apps/__app__/src/modules/toast/hooks.ts

@@ -23,7 +23,7 @@ const useToastMessages = (): ToastMessages => {
 }
 
 /** A localized runGraphQLWithToast: every GraphQL write reports its outcome through it. */
-export const useGraphQLWithToast = () => {
+export const useGraphQLWithToast = (): (<T>(action: () => Promise<GraphQLResponse<T>>, options?: RunWithToastOptions) => Promise<GraphQLResponse<T>>) => {
     const messages = useToastMessages()
     return useCallback(
         <T>(action: () => Promise<GraphQLResponse<T>>, options?: RunWithToastOptions) =>

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

@@ -18,8 +18,11 @@ const INDICATOR: Record<"success" | "danger" | "warning" | "info", ReactNode> =
     info: <InformationCircleIcon className="size-6" />,
 }
 
+/** 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 = {
+export const toast: AppToast = {
     ...heroToast,
     success: (message: ReactNode, options?: StatusToastOptions) =>
         heroToast.success(message, { indicator: INDICATOR.success, ...options }),

package/templates/fe/skeleton/apps/__app__/src/redux/hooks.ts

@@ -1,8 +1,9 @@
 import { useDispatch, useSelector } from "react-redux"
+import type { UseDispatch, UseSelector } from "react-redux"
 import type { AppDispatch, RootState } from "./store"
 
 /** The typed dispatch of the app's store. */
-export const useAppDispatch = useDispatch.withTypes<AppDispatch>()
+export const useAppDispatch: UseDispatch<AppDispatch> = useDispatch.withTypes<AppDispatch>()
 
 /** The typed selector of the app's store. */
-export const useAppSelector = useSelector.withTypes<RootState>()
+export const useAppSelector: UseSelector<RootState> = useSelector.withTypes<RootState>()

package/templates/fe/skeleton/apps/__app__/src/redux/index.ts

@@ -1,3 +1,4 @@
 export { useAppDispatch, useAppSelector } from "./hooks"
 export { ReduxProvider } from "./ReduxProvider"
 export { sessionChanged } from "./slices/session"
+export type { SessionState } from "./slices/session"

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

@@ -1,5 +1,5 @@
 import { createSlice } from "@reduxjs/toolkit"
-import type { PayloadAction } from "@reduxjs/toolkit"
+import type { CaseReducer, PayloadAction, Reducer, Slice } from "@reduxjs/toolkit"
 import type { AuthSession } from "@/modules/auth"
 
 /** The reader's session as the app shares it: unknown until modules/auth answers, then signed in or signed out. */
@@ -8,10 +8,18 @@ export interface SessionState {
     readonly session?: AuthSession
 }
 
+/** The reducers of the session slice. */
+interface SessionReducers {
+    sessionChanged: CaseReducer<SessionState, PayloadAction<AuthSession | undefined>>
+}
+
+/** The session slice as the store and the effects see it. */
+type SessionSlice = Slice<SessionState, SessionReducers, "session">
+
 const initialState: SessionState = { status: "unknown" }
 
 /** The session slice: written only by the auth session effect (hooks/effects), read by any component through useAppSelector. */
-export const sessionSlice = createSlice({
+export const sessionSlice: SessionSlice = createSlice({
     name: "session",
     initialState,
     reducers: {
@@ -21,6 +29,6 @@ export const sessionSlice = createSlice({
 })
 
 /** The one action of the session slice: modules/auth reported a session (or none). */
-export const { sessionChanged } = sessionSlice.actions
+export const sessionChanged: SessionSlice["actions"]["sessionChanged"] = sessionSlice.actions.sessionChanged
 /** The reducer the store mounts under `session`. */
-export const sessionReducer = sessionSlice.reducer
+export const sessionReducer: Reducer<SessionState> = sessionSlice.reducer

package/templates/fe/skeleton/apps/__app__/src/redux/store.ts

@@ -1,14 +1,19 @@
 import { configureStore } from "@reduxjs/toolkit"
+import type { EnhancedStore } from "@reduxjs/toolkit"
 import { sessionReducer } from "./slices/session"
+import type { SessionState } from "./slices/session"
+
+/** The state of the store, for useAppSelector: one slice per key of the root reducer. */
+export interface RootState {
+    readonly session: SessionState
+}
 
 /** The one store of the app: app-wide shared state only (feature-local state lives in hooks/zustand). */
-export const store = configureStore({
+export const store: EnhancedStore<RootState> = configureStore({
     reducer: {
         session: sessionReducer,
     },
 })
 
-/** The state of the store, for useAppSelector. */
-export type RootState = ReturnType<typeof store.getState>
 /** The dispatch of the store, for useAppDispatch. */
 export type AppDispatch = typeof store.dispatch

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

@@ -1,4 +1,5 @@
-import type { ReactNode } from "react"
+import type { Metadata } from "next"
+import type { ReactElement, ReactNode } from "react"
 import { LocaleShell } from "@{{project}}/ui"
 import { AppProviders } from "@/components/providers/AppProviders"
 import { AppLayout, appLayoutMetadata } from "@/features/layouts/AppLayout"
@@ -11,10 +12,10 @@ type LayoutProps = {
 }
 
 /** The localized document title of this route segment. */
-export const generateMetadata = async (props: LayoutProps) => appLayoutMetadata((await props.params).locale)
+export const generateMetadata = async (props: LayoutProps): Promise<Metadata> => appLayoutMetadata((await props.params).locale)
 
 /** The locale segment's layout slot: the document of the address's language, the app's client providers and its chrome. */
-const Layout = async (props: LayoutProps) => (
+const Layout = async (props: LayoutProps): Promise<ReactElement> => (
     <LocaleShell
         {...await appI18n.readLocaleSegment(props.params)}
         content={

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

@@ -1,6 +1,6 @@
 import type { Metadata } from "next"
 import { getTranslations } from "next-intl/server"
-import type { ReactNode } from "react"
+import type { ReactElement, ReactNode } from "react"
 import { SiteShell } from "@{{project}}/ui"
 import { siteUrl } from "@/modules/config"
 import { APP_ROUTES } from "@/modules/routes"

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

@@ -1,3 +1,4 @@
+import type { ReactElement } from "react"
 import type { Metadata } from "next"
 import { getTranslations } from "next-intl/server"
 import { AppGuideOverlay } from "@/features/overlays/AppGuideOverlay"
@@ -10,7 +11,7 @@ export const appHomeMetadata = async (): Promise<Metadata> => {
 }
 
 /** The first page of the product app: a server component; the session surface it draws runs on the client. */
-export const AppHomePage = async () => {
+export const AppHomePage = async (): Promise<ReactElement> => {
     const t = await getTranslations("app.home")
     return (
         <>

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

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

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

@@ -1,9 +1,10 @@
+import type { ReactElement } from "react"
 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 () => {
+export const AppNotFoundPage = async (): Promise<ReactElement> => {
     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

@@ -1,4 +1,5 @@
 import { createAppI18n } from "@{{project}}/i18n"
+import type { AppI18n } 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", (locale) => import(`./messages/${locale}.json`))
+export const appI18n: AppI18n = createAppI18n("app", (locale) => import(`./messages/${locale}.json`))

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

@@ -1,4 +1,7 @@
 import { appI18n } from "./index"
+import type { AppI18n } from "@{{project}}/i18n"
 
 /** The request config next-intl's plugin loads (next.config.ts): the product stack over this app's catalogs. */
-export default appI18n.requestConfig
+const requestConfig: AppI18n["requestConfig"] = appI18n.requestConfig
+
+export default requestConfig