Every package in the workspace, what it owns, and what it deliberately doesn't.

Owns the app widget, flavors, and all composition in bootstrap/. Three files carry // <generated:...> anchor comments that modular new feature writes above — never remove them.

Startup, in order: WidgetsFlutterBinding.ensureInitialized() → DependencyInjectionConfiguration.initialize() → RouterConfiguration.initialize(container) → runApp wrapping DependencyScope → RouterScope → AppThemeScopeWrapper → AppLocaleScopeWrapper → RootApp. Full detail on the architecture page.

Two screens, one counter. This is the shape every generated feature starts from — deliberately kept small so the wiring is what stands out, not the feature.

Cross-feature link: counter_impl depends on posts_api (never posts_impl) to push a NavigateToPosts effect through PostsApi.launcher — the worked example of leaving one feature for another. See it on the architecture page.

A list screen and a details screen backed by JSONPlaceholder — GET /posts and GET /posts/{id}. This is the template's one worked example of a data layer, laid out to copy when a feature needs to talk to a backend.

Three rules hold it together:

Registration lives in the module, under types declared in lib/src/ — shared container, private contracts:

container
  ..registerLazySingleton<PostsRemoteDataSource>(...)
  ..registerLazySingleton<PostsRepository>(...)
  ..registerLazySingleton<PostsApi>((_) => const PostsApiImpl());

ARB-based translations with a locale scope in the widget tree and a notifier in the container — so code without a BuildContext (a network interceptor, for instance) can still read the selected language.

Adding a language means two edits that must agree: a new app_<code>.arb with every key from app_en.arb, and a value on the AppLocale enum — supportedLocales derives from that enum. A test fails if the two ever drift apart.

This application's own success/error envelope, built on top of the transport-agnostic network_api. It's the single seam between a generic REST client and your backend's response shape — see it worked through in detail below.

Registered once, at composition time: NetworkModule<AppResponse>(responseParser: AppResponseParser()). Everything below it — network_api, network_impl, every feature — stays free of any envelope knowledge.

A from-scratch State/Event/Effect implementation — no bloc, no riverpod, no provider. AppStateController<S, E, F> is the whole engine; see the loop diagram on the architecture page.

router_api defines routes, requests and the navigation service purely in domain terms; router_impl maps them onto go_router. No feature imports go_router — everything goes through AppRouteRequest, AppModuleRouter and context.navigation.

The abstraction every module registers through, independent of any DI library — swapping get_it for something else is one new _impl package.

A REST client generic over the success model, so it carries zero knowledge of any backend envelope — that knowledge lives entirely in a NetworkResponseParser<TSuccess>, supplied once at composition time by base/app_network_contract.

The token system in full — colour, spacing, radius, size, typography — but deliberately only six components. Build your own on the tokens rather than extending a component library that wasn't designed for your product.

Two key/value contracts — StandardStorageApi for plain preferences (theme, locale) and a secure counterpart for anything sensitive — behind one StorageModule.

A talker-backed logger with an in-app log screen. The network module's HTTP logging interceptor is built on the same LoggerApi, so requests and app logs land in one place.

A small, two-method contract for device biometrics — availability and a single authenticate call — kept deliberately minimal so it's easy to see everywhere it's used.

An analysis_options.yaml only — every other package includes it with include: package:app_linter/analysis_options.yaml. Lint rules change here and nowhere else, so the ruleset can never quietly diverge between packages. Notably strict: strict-casts, strict-inference, strict-raw-types, require_trailing_commas, prefer_relative_imports, implementation_imports: error.