@turri-dev/cli 0.0.0-stage → 0.1.2-next.48dacfc

package/stdlib/backend/python-fastapi.plain

@@ -0,0 +1,23 @@
+---
+import:
+  - stdlib/lang/python
+  - stdlib/backend/common
+description: A backend in Python 3.12 with FastAPI, Pydantic v2, Uvicorn and structlog.
+---
+
+***implementation reqs***
+
+- :Implementation: uses FastAPI with Pydantic v2 and pydantic-settings, served by Uvicorn.
+- :Implementation: keeps its code in the package `app/`.
+  - `app/main.py` builds the application in `create_app(settings)` and exposes `app = create_app(Settings())`.
+  - `app/config.py` holds `Settings`, a pydantic-settings class.
+  - `app/api/` holds one `APIRouter` per resource, `app/services/` the services, `app/repositories/` the repositories, and `app/errors.py` the domain errors and their handlers.
+  - It starts with `uv run uvicorn app.main:app --host 0.0.0.0 --port $PORT`.
+- :Implementation: declares every request and response body as a Pydantic model, and reaches services and settings in a handler through `Depends`.
+- :Implementation: registers one exception handler for the domain errors' base class, one for `RequestValidationError` answering `validation_error` with its `details`, one for Starlette's `HTTPException`, and one for `Exception`.
+- :Implementation: logs as JSON with structlog, set up once in `app/logging.py`, with the standard `logging` module routed through it and Uvicorn's access log off.
+  - A middleware binds the request id with `structlog.contextvars` and logs the request line.
+- :UnitTests: use FastAPI's `TestClient` on an application of their own from `create_app(test_settings)`, never the module-level `app`, with its dependencies replaced through that application's `dependency_overrides`.
+  - They name it anything but `app`, which is the package: `application = create_app(test_settings)`.
+- :UnitTests: that use a database use SQLite in memory, one database a test, kept on one connection for the whole test - with SQLAlchemy, `poolclass=StaticPool` and `check_same_thread=False` - since every new connection to an in-memory SQLite database opens an empty one of its own.
+  - The tables are created on that engine before the first request, and the application under test is given that same engine through `dependency_overrides`.

package/stdlib/backend/python-flask.plain

@@ -0,0 +1,23 @@
+---
+import:
+  - stdlib/lang/python
+  - stdlib/backend/common
+description: A backend in Python 3.12 with Flask 3, Pydantic v2, Gunicorn and structlog.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Flask 3, with Pydantic v2 for request and response bodies, served by Gunicorn with 2 workers.
+- :Implementation: keeps its code in the package `app/`.
+  - `app/__init__.py` holds the application factory `create_app(settings=None)`, which reads `Settings` from the environment when none is given.
+  - `app/config.py` holds `Settings`, a frozen dataclass.
+  - `app/api/` holds one Blueprint per resource, `app/services/` the services, `app/repositories/` the repositories, and `app/errors.py` the domain errors and their handlers.
+  - It starts with `uv run gunicorn --bind 0.0.0.0:$PORT --workers 2 'app:create_app()'`.
+- :Implementation: validates every request body with a Pydantic model, and answers a `ValidationError` as `validation_error` with its `details`.
+- :Implementation: registers error handlers for the domain errors' base class, for Werkzeug's `HTTPException` - its status, and its name in snake case as the code - and for `Exception`.
+- :Implementation: logs as JSON with structlog, set up once in `app/logging.py`, with the standard `logging` module routed through it.
+  - A `before_request` hook binds the request id with `structlog.contextvars`, and an `after_request` hook logs the request line and sends back `X-Request-ID`.
+- :UnitTests: use an application from `create_app` with test settings, and its `test_client()`.
+  - They name it anything but `app`, which is the package: `application = create_app(test_settings)`.
+- :UnitTests: that use a database use SQLite in memory, one database a test, kept on one connection for the whole test - with SQLAlchemy, `poolclass=StaticPool` and `check_same_thread=False` - since every new connection to an in-memory SQLite database opens an empty one of its own.
+  - The tables are created on that engine before the first request, and the application under test is given that same engine through its settings.

package/stdlib/backend/rust-axum.plain

@@ -0,0 +1,17 @@
+---
+import:
+  - stdlib/lang/rust
+  - stdlib/backend/common
+description: A backend in Rust with axum 0.8 on tokio, serde, validator and tracing JSON logs.
+---
+
+***implementation reqs***
+
+- :Implementation: uses axum 0.8 on tokio, with serde for JSON and validator for request bodies.
+- :Implementation: keeps its code in one Cargo package: `src/main.rs` starts the server, `src/app.rs` builds the `Router` in `app(state)`, `src/config.rs` reads the environment, `src/routes/` holds one module per resource, `src/service/` the services, `src/store/` the repositories, and `src/error.rs` the error type.
+  - It builds with `cargo build --release`.
+- :Implementation: has handlers return `Result<_, AppError>`, where `AppError` is an enum of the domain errors that implements `IntoResponse` and writes the error body.
+- :Implementation: answers a body that does not parse or validate as `validation_error` with its `details`, through an extractor of its own.
+- :Implementation: logs with `tracing-subscriber`'s JSON formatter on standard output, with tower-http's `SetRequestIdLayer`, `PropagateRequestIdLayer` and `TraceLayer` putting the request id on every event and logging the request line.
+- :Implementation: stops through axum's `serve` with `with_graceful_shutdown`, on SIGTERM or Ctrl-C.
+- :UnitTests: call the `Router` with `oneshot` from tower's `ServiceExt`.

package/stdlib/backend/typescript-express.plain

@@ -0,0 +1,19 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/backend/common
+description: A backend in TypeScript on Node.js 24 with Express 5, zod and pino.
+---
+
+***implementation reqs***
+
+- :Implementation: runs on Node.js 24, with Express 5, zod for validation, and pino with pino-http for logs.
+- :Implementation: is an ES module package: `"type": "module"` in `package.json`, `module` and `moduleResolution` `NodeNext` in `tsconfig.json`, and every relative import ending in `.js` - `import { x } from "./x.js"` - as Node.js needs to run what `tsc` emits.
+- :Implementation: keeps its code in `src/`.
+  - `src/app.ts` builds the application in `createApp(deps)`, and `src/server.ts` starts it and stops it on a signal.
+  - `src/config.ts` parses the environment with a zod schema, `src/routes/` holds one `Router` per resource, `src/services/` the services, `src/repositories/` the repositories, and `src/errors.ts` the domain errors.
+  - It builds with `npm run build` - `tsc` into `dist/` - and starts with `npm start`, which runs `node dist/server.js`.
+- :Implementation: validates every request body, query and path parameter with a zod schema, and answers a `ZodError` as `validation_error` with its `details`.
+- :Implementation: turns errors into responses in one error-handling middleware, registered last, which every rejected handler reaches.
+- :Implementation: logs through one pino logger from `src/logger.ts`, with pino-http taking the request id from `X-Request-ID` and logging the request line.
+- :UnitTests: use Vitest and supertest against `createApp` with stand-in dependencies, next to the code as `<file>.test.ts`, and run with `npx vitest run`.

package/stdlib/backend/typescript-fastify.plain

@@ -0,0 +1,19 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/backend/common
+description: A backend in TypeScript on Node.js 24 with Fastify 5, TypeBox and its built-in pino logs.
+---
+
+***implementation reqs***
+
+- :Implementation: runs on Node.js 24, with Fastify 5, and TypeBox schemas through `@fastify/type-provider-typebox` for validation.
+- :Implementation: is an ES module package: `"type": "module"` in `package.json`, `module` and `moduleResolution` `NodeNext` in `tsconfig.json`, and every relative import ending in `.js` - `import { x } from "./x.js"` - as Node.js needs to run what `tsc` emits.
+- :Implementation: keeps its code in `src/`.
+  - `src/app.ts` builds the application in `buildApp(deps)`, and `src/server.ts` starts it and closes it on a signal.
+  - `src/config.ts` reads the environment against a TypeBox schema, `src/routes/` holds one plugin per resource, `src/services/` the services, `src/repositories/` the repositories, and `src/errors.ts` the domain errors.
+  - It builds with `npm run build` - `tsc` into `dist/` - and starts with `npm start`, which runs `node dist/server.js`.
+- :Implementation: declares a schema for every route's body, query, params and response.
+- :Implementation: turns errors into responses in one `setErrorHandler`, schema validation failures into `validation_error` with their `details`, and unknown routes in `setNotFoundHandler`.
+- :Implementation: logs with Fastify's own pino logger, with `requestIdHeader` set to `x-request-id`, a UUID v4 from `genReqId` when it is missing, and `requestIdLogLabel` set to `request_id`.
+- :UnitTests: use Vitest and `app.inject()` on `buildApp` with stand-in dependencies, next to the code as `<file>.test.ts`, and run with `npx vitest run`.

package/stdlib/backend/typescript-nestjs.plain

@@ -0,0 +1,19 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/backend/common
+description: A backend in TypeScript on Node.js 24 with NestJS 11, class-validator and nestjs-pino.
+---
+
+***implementation reqs***
+
+- :Implementation: runs on Node.js 24, with NestJS 11 on its Express platform.
+- :Implementation: compiles to CommonJS, as the Nest CLI sets a project up - the one stdlib TypeScript stack that is not ES modules - so Nest's decorators and Jest with ts-jest work without further setup.
+- :Implementation: keeps one Nest module per resource in `src/<resource>/`, with its controller, its service, and its repository as a provider.
+  - `src/main.ts` starts the application with `enableShutdownHooks()`, and `src/app.module.ts` imports the modules.
+  - It builds with `npm run build` - `nest build` into `dist/` - and starts with `npm start`, which runs `node dist/main.js`.
+- :Implementation: reads its configuration with `@nestjs/config`, validated at start by a schema.
+- :Implementation: validates every request body, query and path parameter as a DTO class with class-validator, through a global `ValidationPipe` with `whitelist` and `transform` on, whose failures are `validation_error` with their `details`.
+- :Implementation: turns errors into responses in one global exception filter, for the domain errors, Nest's `HttpException` and anything else.
+- :Implementation: logs with nestjs-pino, with the request id from `X-Request-ID` as `request_id`.
+- :UnitTests: use Jest with ts-jest and `@nestjs/testing`, controllers through supertest, next to the code as `<file>.spec.ts`, and run with `npx jest`.

package/stdlib/cli/common.plain

@@ -0,0 +1,17 @@
+---
+description: What every stdlib command-line tool shares - arguments in, results out, its errors, exit codes and logs.
+---
+
+***implementation reqs***
+
+- :Implementation: is a command-line tool: it reads its arguments, standard input and environment variables, and writes its results to standard output.
+- :Implementation: takes each setting from its flag, else from the environment variable `<TOOL>_<SETTING>`, else from its default.
+- :Implementation: keeps parsing the command line apart from the work: a command parses its arguments, calls the work, and prints what it returns.
+- :Implementation: reports a failure of the work by raising one of its own errors, which the command layer turns, in one place, into its message and exit code.
+  - It writes the message to standard error as one line, `Error: <message>`.
+  - It exits 0 on success, 1 on a failure of the work, 2 on a usage error, and 130 when interrupted with Ctrl-C.
+  - It shows a stack trace only with `--debug`.
+- :Implementation: logs to standard error only, never standard output: warnings by default, `INFO` with `--verbose`, `DEBUG` with `--debug`.
+- :Implementation: prints its usage with `--help` and its version with `--version`.
+- :UnitTests: call the work directly, and each command through its framework's in-process runner.
+- :UnitTests: replace the network with stand-ins, and use a temporary directory for files.

package/stdlib/cli/conformance/common.plain

@@ -0,0 +1,11 @@
+---
+description: How every stdlib command-line tool's conformance tests run - the built tool as a separate process.
+---
+
+***test reqs***
+
+- :ConformanceTests: run the built tool as a separate process, and check its standard output, standard error and exit code.
+- :ConformanceTests: run each case in a temporary directory of its own, with only the environment variables the case sets.
+  - The tool is run by its absolute path in the built code - the built binary, jar or script - never a path relative to the working directory, which is the case's temporary directory.
+- :ConformanceTests: check a failure by its exit code and that its message starts with `Error: `, never by the rest of the message.
+- :ConformanceTests: pass the formatter, the linter and the type checker of their language as the conformance testing script runs them, and are typed throughout where their language allows it.

package/stdlib/cli/conformance/go-cobra.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/go-cobra as a Go module with os/exec.
+---
+
+***test reqs***
+
+- :ConformanceTests: are a Go module of their own, using the `testing` package and `os/exec`, run with `go test ./...`.

package/stdlib/cli/conformance/go-flag.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/go-flag as a Go module with os/exec.
+---
+
+***test reqs***
+
+- :ConformanceTests: are a Go module of their own, using the `testing` package and `os/exec`, run with `go test ./...`.

package/stdlib/cli/conformance/java-picocli.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/java-picocli as a Maven project running the jar.
+---
+
+***test reqs***
+
+- :ConformanceTests: are a Maven project of their own, using JUnit 5 and `ProcessBuilder` to run the built jar, run with `mvn test`.

package/stdlib/cli/conformance/python-argparse.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/python-argparse in pytest with subprocess.
+---
+
+***test reqs***
+
+- :ConformanceTests: use pytest and `subprocess`, run the tool as `uv run --project <the built code> <tool>` - `--project`, because the working directory is the case's temporary directory - and run with `pytest`.

package/stdlib/cli/conformance/python-click.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/python-click in pytest with subprocess.
+---
+
+***test reqs***
+
+- :ConformanceTests: use pytest and `subprocess`, run the tool as `uv run --project <the built code> <tool>` - `--project`, because the working directory is the case's temporary directory - and run with `pytest`.

package/stdlib/cli/conformance/python-typer.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/python-typer in pytest with subprocess.
+---
+
+***test reqs***
+
+- :ConformanceTests: use pytest and `subprocess`, run the tool as `uv run --project <the built code> <tool>` - `--project`, because the working directory is the case's temporary directory - and run with `pytest`.

package/stdlib/cli/conformance/rust-clap.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/rust-clap as a Cargo package with assert_cmd.
+---
+
+***test reqs***
+
+- :ConformanceTests: are a Cargo package of their own, using `assert_cmd` and `predicates`, run with `cargo test`.

package/stdlib/cli/conformance/typescript-commander.plain

@@ -0,0 +1,9 @@
+---
+import:
+  - stdlib/cli/conformance/common
+description: Conformance tests for stdlib/cli/typescript-commander in Vitest with child_process.
+---
+
+***test reqs***
+
+- :ConformanceTests: use Vitest and `node:child_process`, run the tool as `node dist/cli.js`, and run with `npx vitest run`.

package/stdlib/cli/go-cobra.plain

@@ -0,0 +1,14 @@
+---
+import:
+  - stdlib/lang/go
+  - stdlib/cli/common
+description: A command-line tool in Go 1.25 with Cobra.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Cobra, with `main` in `cmd/<tool>/`, one file per command in `internal/cli/`, the work in packages under `internal/`, and the tool's errors under `internal/errs`.
+  - Every command uses `RunE`, and the root command sets `SilenceUsage` and `SilenceErrors`, so `main` alone writes the error and chooses the exit code.
+  - It builds with `go build -o bin/<tool> ./cmd/<tool>`.
+- :Implementation: logs with a `slog.TextHandler` on standard error, at the level `--verbose` or `--debug` gives.
+- :UnitTests: run commands through the root command with `SetArgs`, `SetOut` and `SetErr`.

package/stdlib/cli/go-flag.plain

@@ -0,0 +1,14 @@
+---
+import:
+  - stdlib/lang/go
+  - stdlib/cli/common
+description: A command-line tool in Go 1.25 with the standard library's flag package and no dependencies.
+---
+
+***implementation reqs***
+
+- :Implementation: uses the standard library only: `flag`, with one `flag.FlagSet` per command, and no third-party dependency.
+- :Implementation: keeps `main` in `cmd/<tool>/`, which calls `run(args, stdout, stderr) int` and exits with what it returns, the commands in `internal/cli/`, the work in packages under `internal/`, and the tool's errors under `internal/errs`.
+  - It builds with `go build -o bin/<tool> ./cmd/<tool>`.
+- :Implementation: logs with a `slog.TextHandler` on standard error, at the level `--verbose` or `--debug` gives.
+- :UnitTests: call `run` with arguments and buffers for its output.

package/stdlib/cli/java-picocli.plain

@@ -0,0 +1,15 @@
+---
+import:
+  - stdlib/lang/java
+  - stdlib/cli/common
+description: A command-line tool in Java 21 with picocli 4 and Maven.
+---
+
+***implementation reqs***
+
+- :Implementation: uses picocli 4, built with Maven through the Maven wrapper into one executable jar with its dependencies, run with `java -jar target/<tool>.jar`.
+  - The jar is made by maven-shade-plugin, with a `ManifestResourceTransformer` naming the main class, and `<finalName><tool></finalName>`, so it is `target/<tool>.jar` and runs on its own.
+- :Implementation: keeps the main class with the top command in the base package, one `@Command` class per subcommand in `cli`, the work in `core`, and the tool's exceptions in `error`.
+  - An `IExecutionExceptionHandler` turns the tool's exceptions into the message and exit code, and an `IParameterExceptionHandler` usage errors.
+- :Implementation: logs through SLF4J with slf4j-simple on standard error, at the level `--verbose` or `--debug` gives.
+- :UnitTests: run commands through `CommandLine.execute` with captured output, run with `./mvnw test`.

package/stdlib/cli/python-argparse.plain

@@ -0,0 +1,18 @@
+---
+import:
+  - stdlib/lang/python
+  - stdlib/cli/common
+description: A command-line tool in Python 3.12 with the standard library's argparse and no dependencies.
+---
+
+***implementation reqs***
+
+- :Implementation: uses the standard library only: `argparse`, with one subparser per command, and no third-party dependency at run time.
+- :Implementation: keeps its code in the package `app/`.
+  - `app/cli.py` holds `main(argv=None) -> int`, which builds the parser, runs the command, and turns a `ToolError` into its message and exit code.
+  - One module per command in `app/commands/`, each with `add_parser(subparsers)` and `run(args) -> int`.
+  - The work lives in `app/core/`, and the tool's errors in `app/errors.py`, under one base class `ToolError`.
+  - `[project.scripts]` names the tool, `<tool> = "app.cli:main"`.
+  - `pyproject.toml` declares a build system - hatchling, with `[tool.hatch.build.targets.wheel]` `packages = ["app"]` - so `uv sync` installs the package and the `<tool>` command: without one, uv installs no `[project.scripts]` at all.
+- :Implementation: sets up the standard `logging` module to write to standard error with the level `--verbose` or `--debug` gives.
+- :UnitTests: call `main` with a list of arguments, and read what it printed with `capsys`.

package/stdlib/cli/python-click.plain

@@ -0,0 +1,16 @@
+---
+import:
+  - stdlib/lang/python
+  - stdlib/cli/common
+description: A command-line tool in Python 3.12 with Click 8.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Click 8, in the package `app/`.
+  - `app/cli.py` holds the `@click.group()` with `--verbose`, `--debug` and `--version`, which sets up logging, and one module per command in `app/commands/`.
+  - The work lives in `app/core/`, and the tool's errors in `app/errors.py`, under one base class `ToolError`, a subclass of `click.ClickException` whose `exit_code` is 1.
+  - `[project.scripts]` names the tool, `<tool> = "app.cli:cli"`.
+  - `pyproject.toml` declares a build system - hatchling, with `[tool.hatch.build.targets.wheel]` `packages = ["app"]` - so `uv sync` installs the package and the `<tool>` command: without one, uv installs no `[project.scripts]` at all.
+- :Implementation: sets up the standard `logging` module to write to standard error with the level `--verbose` or `--debug` gives.
+- :UnitTests: run commands with Click's `CliRunner`.

package/stdlib/cli/python-typer.plain

@@ -0,0 +1,16 @@
+---
+import:
+  - stdlib/lang/python
+  - stdlib/cli/common
+description: A command-line tool in Python 3.12 with Typer.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Typer, with its pretty exceptions off, in the package `app/`.
+  - `app/cli.py` holds the Typer app, with a callback for `--verbose`, `--debug` and `--version` that sets up logging, and one module per command in `app/commands/`.
+  - The work lives in `app/core/`, and the tool's errors in `app/errors.py`, under one base class `ToolError`.
+  - `[project.scripts]` names the tool, `<tool> = "app.cli:main"`, where `main()` runs the Typer app and turns a `ToolError` into its message and exit code.
+  - `pyproject.toml` declares a build system - hatchling, with `[tool.hatch.build.targets.wheel]` `packages = ["app"]` - so `uv sync` installs the package and the `<tool>` command: without one, uv installs no `[project.scripts]` at all.
+- :Implementation: sets up the standard `logging` module to write to standard error with the level `--verbose` or `--debug` gives.
+- :UnitTests: run commands with Typer's `CliRunner`.

package/stdlib/cli/rust-clap.plain

@@ -0,0 +1,14 @@
+---
+import:
+  - stdlib/lang/rust
+  - stdlib/cli/common
+description: A command-line tool in Rust with clap 4.
+---
+
+***implementation reqs***
+
+- :Implementation: uses clap 4's derive API, as one Cargo package: `src/main.rs` parses the arguments and runs the command, one module per command in `src/commands/`, the work in `src/lib.rs` and its modules, and the tool's error type in `src/error.rs`.
+  - `main` returns an `ExitCode`, writing the error and choosing the code itself.
+  - It builds with `cargo build --release`.
+- :Implementation: logs with `tracing-subscriber` on standard error, at the level `--verbose` or `--debug` gives.
+- :UnitTests: call the work directly, and parse arguments with `Cli::try_parse_from`.

package/stdlib/cli/typescript-commander.plain

@@ -0,0 +1,17 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/cli/common
+description: A command-line tool in TypeScript on Node.js 24 with Commander.
+---
+
+***implementation reqs***
+
+- :Implementation: runs on Node.js 24, with Commander.
+- :Implementation: is an ES module package: `"type": "module"` in `package.json`, `module` and `moduleResolution` `NodeNext` in `tsconfig.json`, and every relative import ending in `.js` - `import { x } from "./x.js"` - as Node.js needs to run what `tsc` emits.
+- :Implementation: keeps its code in `src/`: `src/cli.ts` builds the program with `exitOverride()` and runs it, one module per command in `src/commands/`, the work in `src/core/`, and the tool's errors in `src/errors.ts` under one base class `ToolError`.
+  - `bin` in `package.json` names the tool, pointing at `dist/cli.js`.
+  - It builds with `npm run build` - `tsc` into `dist/` - and runs with `node dist/cli.js`.
+- :Implementation: turns a `ToolError` or a Commander error into its message and exit code in `src/cli.ts`, around `program.parseAsync`.
+- :Implementation: logs through a small logger in `src/logger.ts` that writes to standard error, with the level `--verbose` or `--debug` gives.
+- :UnitTests: use Vitest, running commands through `program.parseAsync` with `exitOverride()` and captured output, next to the code as `<file>.test.ts`, and run with `npx vitest run`.

package/stdlib/frontend/angular.plain

@@ -0,0 +1,17 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/frontend/common
+description: A frontend in Angular 20 and TypeScript with standalone components, signals and HttpClient.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Angular 20 with standalone components, signals for state, and the Angular CLI, building into `dist/`, with `npm run preview` serving the build.
+- :Implementation: takes the backend's base URL from `src/environments/environment.ts`, set at build time.
+- :Implementation: keeps pages in `src/app/pages/`, shared components in `src/app/components/`, services in `src/app/services/`, the API layer in `src/app/api/`, and the logger in `src/app/logger.ts`.
+- :Implementation: makes backend calls with `HttpClient`, with one interceptor that turns an error into an `ApiError`.
+- :Implementation: routes with the Angular Router, one lazy-loaded route per page in `src/app/app.routes.ts`.
+- :Implementation: catches any other failure in its own `ErrorHandler`, and shows the page that says something went wrong.
+- :Implementation: styles each component in its own stylesheet.
+- :UnitTests: use `TestBed` and `HttpTestingController`, with Vitest through the Angular CLI's unit-test builder, next to the code as `<file>.spec.ts`, and run with `npx ng test --watch=false`.

package/stdlib/frontend/common.plain

@@ -0,0 +1,17 @@
+---
+description: What every stdlib frontend shares - a single-page app, its API layer, errors, logs and test ids.
+---
+
+***implementation reqs***
+
+- :Implementation: is a single-page web app, built by `npm run build` into `dist/`, whose build `npm run preview -- --port $PORT` serves.
+- :Implementation: calls its backend at the base URL it is built with, `/api` when none is given.
+- :Implementation: makes every backend call through its API layer: one typed function per call, and no call to `fetch` anywhere else.
+  - A response that is not 2xx becomes an `ApiError` with its `status`, and the `code` and `message` of the backend's error body `{"error": {"code", "message"}}`.
+  - A request that gets no response becomes an `ApiError` with the code `network_error`.
+- :Implementation: shows an `ApiError` from a page's own calls on that page, in place of what failed, with its message.
+- :Implementation: catches any other failure at the root of the app, and shows a page saying something went wrong, with a button that reloads it.
+- :Implementation: logs through its own logger module only, with `debug`, `info`, `warn` and `error`, which writes to the browser console, `debug` only in a development build; no `console` call is anywhere else.
+- :Implementation: gives every element a person acts on an accessible role and name, or a `data-testid` when it has none.
+- :UnitTests: use Vitest with jsdom, next to the code as `<file>.test.ts` or `<file>.test.tsx`, and run with `npx vitest run`.
+- :UnitTests: replace the API layer with a stand-in, never the network.

package/stdlib/frontend/conformance/angular.plain

@@ -0,0 +1,5 @@
+---
+import:
+  - stdlib/frontend/conformance/common
+description: Conformance tests for stdlib/frontend/angular in Playwright, as for every stdlib frontend.
+---

package/stdlib/frontend/conformance/common.plain

@@ -0,0 +1,11 @@
+---
+description: How every stdlib frontend's conformance tests run - in Chromium through Playwright, against the served build, with the backend stood in.
+---
+
+***test reqs***
+
+- :ConformanceTests: use Playwright with Chromium, and run with `npx playwright test`.
+- :ConformanceTests: build the app, serve the build on a free port given in `PORT`, and drive it through the browser only.
+- :ConformanceTests: answer every backend call with Playwright's `page.route`, never a real backend, and answer an error with the body `{"error": {"code", "message"}}`.
+- :ConformanceTests: find elements by role, label or text, else by `data-testid`, and never by a CSS class.
+- :ConformanceTests: pass the formatter, the linter and the type checker of their language as the conformance testing script runs them, and are typed throughout where their language allows it.

package/stdlib/frontend/conformance/react-vite.plain

@@ -0,0 +1,5 @@
+---
+import:
+  - stdlib/frontend/conformance/common
+description: Conformance tests for stdlib/frontend/react-vite in Playwright, as for every stdlib frontend.
+---

package/stdlib/frontend/conformance/sveltekit-spa.plain

@@ -0,0 +1,5 @@
+---
+import:
+  - stdlib/frontend/conformance/common
+description: Conformance tests for stdlib/frontend/sveltekit-spa in Playwright, as for every stdlib frontend.
+---

package/stdlib/frontend/conformance/vue-vite.plain

@@ -0,0 +1,5 @@
+---
+import:
+  - stdlib/frontend/conformance/common
+description: Conformance tests for stdlib/frontend/vue-vite in Playwright, as for every stdlib frontend.
+---

package/stdlib/frontend/react-vite.plain

@@ -0,0 +1,16 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/frontend/common
+description: A frontend in React 19 and TypeScript with Vite, React Router, TanStack Query and react-hook-form.
+---
+
+***implementation reqs***
+
+- :Implementation: uses React 19 with function components and hooks only, built with Vite, and takes the backend's base URL from `VITE_API_URL`.
+- :Implementation: routes with React Router 7, with one route per page in `src/routes.tsx`, and the root route's `errorElement` as the page that catches any other failure.
+- :Implementation: keeps pages in `src/pages/`, shared components in `src/components/`, one component per `.tsx` file, hooks in `src/hooks/`, the API layer in `src/api/`, and the logger in `src/lib/logger.ts`.
+- :Implementation: loads and changes backend data with TanStack Query, one hook per call in `src/hooks/`, and holds no copy of it in component state.
+- :Implementation: builds forms with react-hook-form and a zod schema per form, showing each field's error beside it.
+- :Implementation: styles components with CSS Modules, one `<Component>.module.css` beside each component.
+- :UnitTests: render components with React Testing Library, drive them with `@testing-library/user-event`, and wrap them in a fresh `QueryClient` per test.

package/stdlib/frontend/sveltekit-spa.plain

@@ -0,0 +1,16 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/frontend/common
+description: A frontend in Svelte 5 and TypeScript with SvelteKit as a single-page app on adapter-static.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Svelte 5 with runes, in SvelteKit with `adapter-static` writing to `dist/` with the fallback `index.html`, and `ssr` off in the root layout, and takes the backend's base URL from `PUBLIC_API_URL`.
+- :Implementation: keeps pages in `src/routes/`, shared components in `src/lib/components/`, the API layer in `src/lib/api/`, and the logger in `src/lib/logger.ts`.
+- :Implementation: loads a page's data in its `+page.ts` `load` function, and holds state that several pages share in `.svelte.ts` modules with `$state`.
+- :Implementation: shows the page that says something went wrong from `src/routes/+error.svelte`, and catches any other failure in `handleError` in `src/hooks.client.ts`.
+- :Implementation: styles components in their own `<style>` block.
+- :UnitTests: render components with `@testing-library/svelte`.
+  - Vitest's config sets `resolve.conditions` to `["browser"]` for the tests, so Svelte 5 mounts components as in the browser rather than as on a server.

package/stdlib/frontend/vue-vite.plain

@@ -0,0 +1,16 @@
+---
+import:
+  - stdlib/lang/typescript
+  - stdlib/frontend/common
+description: A frontend in Vue 3 and TypeScript with Vite, Vue Router and Pinia.
+---
+
+***implementation reqs***
+
+- :Implementation: uses Vue 3 with single-file components and `<script setup lang="ts">`, built with Vite, and takes the backend's base URL from `VITE_API_URL`.
+- :Implementation: routes with Vue Router 4, one route per page in `src/router.ts`.
+- :Implementation: keeps pages in `src/views/`, shared components in `src/components/`, composables in `src/composables/`, stores in `src/stores/`, the API layer in `src/api/`, and the logger in `src/lib/logger.ts`.
+- :Implementation: holds state that several pages share in Pinia setup stores, and loads a page's own data in a composable that returns its data, its loading flag and its error.
+- :Implementation: catches any other failure in `app.config.errorHandler` and the router's `onError`, and shows the page that says something went wrong.
+- :Implementation: styles components in their own `<style scoped>` block.
+- :UnitTests: mount components with Vue Test Utils, with a fresh Pinia per test from `createTestingPinia`.

package/stdlib/lang/go.plain

@@ -0,0 +1,13 @@
+---
+description: Go 1.25 with slog and go test - what every stdlib Go stack shares.
+---
+
+***implementation reqs***
+
+- :Implementation: is written in Go 1.25, as one Go module with `go.mod` and `go.sum` committed.
+- :Implementation: returns an error as the last result for every failure, and never panics on one it can expect.
+  - It wraps an error with `fmt.Errorf("<what failed>: %w", err)`.
+  - It declares the errors a caller checks as sentinel values or error types, which callers compare with `errors.Is` and `errors.As`.
+- :Implementation: logs with `log/slog`, and never with `fmt.Print` or the `log` package.
+- :Implementation: is formatted with gofmt and passes `go vet`.
+- :UnitTests: use the `testing` package, table-driven where a function has several cases, next to the code as `<file>_test.go`, and run with `go test ./...`.

package/stdlib/lang/java.plain

@@ -0,0 +1,12 @@
+---
+description: Java 21 with SLF4J, JUnit 5 and AssertJ - what every stdlib Java stack shares.
+---
+
+***implementation reqs***
+
+- :Implementation: is written in Java 21, with records for data carriers and `Optional` only as a return type.
+- :Implementation: reports a failure by throwing an unchecked exception of its own, all of them subclasses of one base exception.
+  - It catches `Exception` only at its outermost boundary, and wraps a caught exception with it as the cause.
+- :Implementation: logs through SLF4J, with one `private static final Logger` per class, and never with `System.out` or `System.err`.
+- :Implementation: uses constructor injection only, with every field it can make `final` made so.
+- :UnitTests: use JUnit 5 and AssertJ, with Mockito for stand-ins, in `src/test/java` mirroring the main packages, named `<Class>Test`.

package/stdlib/lang/python.plain

@@ -0,0 +1,18 @@
+---
+description: Python 3.12 with uv, ruff and pytest - what every stdlib Python stack shares.
+---
+
+***implementation reqs***
+
+- :Implementation: is written in Python 3.12, with type hints on every function signature.
+- :Implementation: manages dependencies with uv in `pyproject.toml`, with `uv.lock` committed, and keeps development dependencies in the `dev` dependency group.
+- :Implementation: is formatted and linted with ruff, configured in `pyproject.toml` with a line length of 100.
+- :Implementation: is type checked with mypy, configured in `pyproject.toml` under `[tool.mypy]` with `disallow_untyped_defs = true` and `files` naming the package and its tests.
+  - A library that ships no type information gets its stubs package (`types-...`) in the `dev` group; only one with none is listed under `ignore_missing_imports`, by its module.
+- :Implementation: keeps ruff and mypy in the `dev` dependency group.
+- :Implementation: reports a failure by raising an exception, never by returning `None` or an error code.
+  - It catches an exception only where it handles it, or to raise one of its own with `raise ... from`, keeping the cause.
+- :Implementation: logs through the standard `logging` module, with one logger per module from `logging.getLogger(__name__)`, and never with `print`.
+- :UnitTests: use pytest, in `tests/` mirroring the package layout, named `test_<module>.py`, and run with `uv run pytest`.
+  - `pyproject.toml` sets `[tool.pytest.ini_options]` with `testpaths = ["tests"]` and `pythonpath` naming the folder the package is in - `["."]` for a package at the project root, `["src"]` for one under `src/` - so `uv run pytest` imports it whether or not uv installs the project: without a build system it never does.
+- :UnitTests: use fixtures and `monkeypatch` for stand-ins, and `tmp_path` for files.

package/stdlib/lang/rust.plain

@@ -0,0 +1,12 @@
+---
+description: Stable Rust with Cargo, thiserror and tracing - what every stdlib Rust stack shares.
+---
+
+***implementation reqs***
+
+- :Implementation: is written in stable Rust, edition 2021, as Cargo packages.
+- :Implementation: returns a `Result` for every failure, with error types of its own defined with `thiserror`.
+  - It never calls `unwrap` or `expect` outside tests.
+- :Implementation: logs with the `tracing` crate.
+- :Implementation: is formatted with rustfmt and passes `cargo clippy` with no warnings.
+- :UnitTests: are `#[cfg(test)] mod tests` modules next to the code, run with `cargo test`.

package/stdlib/lang/typescript.plain

@@ -0,0 +1,13 @@
+---
+description: TypeScript 5 in strict mode with npm - what every stdlib TypeScript stack shares.
+---
+
+***implementation reqs***
+
+- :Implementation: is written in TypeScript 5 with `strict` and `noUncheckedIndexedAccess` on, as ES modules.
+- :Implementation: manages dependencies with npm, with `package-lock.json` committed.
+- :Implementation: is formatted with Prettier and linted with ESLint's recommended TypeScript rules.
+- :Implementation: type checks with no errors under `tsc --noEmit` - `vue-tsc --noEmit` where it has Vue components, `tsc --build` where its `tsconfig.json` is made of project references.
+- :Implementation: keeps `typescript`, `prettier`, `eslint` and `typescript-eslint` in `devDependencies`, and `package.json` has the scripts `typecheck`, `lint` and `format` that run them.
+- :Implementation: never uses `any`: data from outside - a request, a response, a file, the environment - is `unknown` until it is validated.
+- :Implementation: reports a failure by throwing an `Error` subclass of its own, with `cause` set when it wraps another error, and never throws a string or a plain object.