@litfamily/litopencode 1.0.0

package/skills/lit-code/references/go/tooling.md

@@ -0,0 +1,35 @@
+# Go — tooling
+
+## Linting
+
+`golangci-lint` with a small strict set beats a large permissive one. A useful baseline beyond the
+defaults:
+
+```yaml
+linters:
+  enable:
+    - errcheck        # unchecked errors
+    - govet
+    - staticcheck
+    - errorlint       # %v where %w belongs; comparison instead of errors.Is
+    - bodyclose       # unclosed HTTP response bodies
+    - rowserrcheck
+    - contextcheck    # dropped or wrong context
+    - nilerr          # returning nil after checking err != nil
+```
+
+`errorlint` and `nilerr` catch real defects rather than style; enable them before anything cosmetic.
+
+## Modules
+
+- Commit `go.sum`. It is the integrity record, not a lockfile artifact.
+- `go mod tidy` before every commit that changed imports; a stale `go.mod` fails other people's
+  builds and not yours.
+- Pin the toolchain in `go.mod` (`go 1.23.0`) so behavior differences between contributors are
+  visible rather than mysterious.
+
+## Formatting
+
+`gofmt` is not negotiable and needs no discussion. `gofumpt` adds a stricter superset — adopt it per
+project, not per file, and never mix the two in one repository.
+

package/skills/lit-code/references/go/type-patterns.md

@@ -0,0 +1,50 @@
+# Go — modelling with types
+
+Go's type system is deliberately small. The productive stance is to use it for the two things it does
+well — distinguishing values that must not be confused, and making zero values usable — and to accept
+that the rest is enforced by tests and review.
+
+## Named types for units and identifiers
+
+```go
+type UserID string
+type Cents  int64
+```
+
+The cost is a conversion at the boundary; the benefit is that passing an `OrderID` where a `UserID`
+belongs stops compiling. Do this wherever two values of the same underlying type mean different
+things. It is the highest-value type-level guard the language offers.
+
+## Make the zero value useful
+
+A struct whose zero value works needs no constructor and cannot be half-initialised:
+
+```go
+type Buffer struct { buf []byte }   // ready to use
+```
+
+When the zero value cannot be valid, do not export the struct — export a constructor returning an
+interface or an opaque type, so an uninitialised instance is unconstructable rather than a runtime
+surprise.
+
+## Accept interfaces, return structs
+
+Define the interface where it is *consumed*, listing only the methods that caller needs. A one- or
+two-method interface declared next to its use is composable; a large interface declared next to its
+implementation is a maintenance liability and forces fake-heavy tests.
+
+```go
+type userStore interface { ByID(context.Context, UserID) (User, error) }
+```
+
+## Avoid
+
+- **`interface{}` / `any` in a domain signature.** It moves an error from compile time to run time
+  and erases the documentation the signature was carrying.
+- **Generics for a single concrete type.** Write the concrete version. Generalise on the second real
+  caller, not in anticipation of one.
+- **Embedding to fake inheritance.** Embedding promotes methods, including ones you did not intend to
+  expose, and the promoted set changes when the embedded type changes.
+- **Pointer receivers chosen at random.** Pick one form per type. Mixing them makes the method set
+  differ between `T` and `*T`, which produces interface-satisfaction errors that read as nonsense.
+

package/skills/lit-code/references/python/README.md

@@ -0,0 +1,12 @@
+# Python
+
+| File | Covers |
+|---|---|
+| [type-patterns.md](type-patterns.md) | Annotations that carry weight, and where they stop helping |
+| [error-handling.md](error-handling.md) | Exception design and the boundary rule |
+| [async.md](async.md) | Structured concurrency, cancellation, and blocking the loop |
+| [testing.md](testing.md) | pytest structure, fixtures, and what to parametrise |
+| [tooling.md](tooling.md) | Strict project configuration |
+
+Defaults for new code. An existing codebase's conventions win.
+

package/skills/lit-code/references/python/async.md

@@ -0,0 +1,50 @@
+# Python — async
+
+## Structured concurrency by default
+
+```python
+async with asyncio.TaskGroup() as tg:      # 3.11+
+    tg.create_task(fetch(a))
+    tg.create_task(fetch(b))
+```
+
+The group waits for every child and cancels the rest when one fails. A bare `create_task` whose
+handle is discarded is a leak: it can be garbage-collected mid-flight, and its exception surfaces as
+a warning rather than an error. `anyio` provides the same guarantee across asyncio and trio.
+
+## Never block the loop
+
+A synchronous call inside a coroutine stops every other task. The commonest offenders are `requests`,
+`time.sleep`, file reads, and CPU-bound work.
+
+```python
+await asyncio.to_thread(blocking_call, arg)          # I/O-bound
+await loop.run_in_executor(process_pool, cpu_bound)  # CPU-bound
+```
+
+A "slow async service" is usually one blocking call away from being fast.
+
+## Cancellation is an exception
+
+`asyncio.CancelledError` propagates through your code. Two consequences:
+
+- `except Exception` does not catch it in 3.8+ — that is deliberate, do not "fix" it.
+- Cleanup in `finally` runs during cancellation, and an `await` there can be cancelled too. Use
+  `asyncio.shield` only when the cleanup genuinely must complete.
+
+## Timeouts at every external boundary
+
+```python
+async with asyncio.timeout(5):     # 3.11+
+    result = await client.get(url)
+```
+
+No network call should be able to hang forever. A missing timeout is not visible in testing and is
+the usual cause of a production stall.
+
+## Avoid
+
+- **Mixing sync and async versions of the same client** in one code path.
+- **`asyncio.run` called more than once** in a process, or called from inside a running loop.
+- **Sharing a connection pool across event loops.**
+

package/skills/lit-code/references/python/error-handling.md

@@ -0,0 +1,44 @@
+# Python — exceptions
+
+## Define a base exception per package
+
+```python
+class StorageError(Exception): ...
+class RecordNotFound(StorageError): ...
+class RecordConflict(StorageError): ...
+```
+
+One base lets a caller opt into "anything from this subsystem" without catching `Exception`. The
+subclasses let it react to the specific case. Carry structured data as attributes rather than
+formatting it into the message — callers should not parse strings.
+
+## Chain, do not swallow
+
+```python
+try:
+    payload = json.loads(raw)
+except json.JSONDecodeError as exc:
+    raise ConfigInvalid(f"config at {path} is not valid JSON") from exc
+```
+
+`raise ... from exc` keeps the original traceback. `raise ...` alone inside an `except` block also
+chains implicitly, but stating it is clearer. Never `except: pass` — if a failure is genuinely
+ignorable, catch the specific type and say why in a comment.
+
+## Catch narrowly, near the cause
+
+`except Exception` at a low level is the single biggest reason a Python traceback points somewhere
+unrelated to the fault. Catch the exception you can actually handle, at the place where you can
+handle it, and let everything else travel.
+
+## The boundary rule
+
+Libraries raise. Applications decide. Only the top-level entry point — `main`, a request handler, a
+task runner — converts an exception into an exit code, an HTTP status, or a log line. Logging and
+re-raising at every layer produces the same fault reported five times.
+
+## Cleanup
+
+`with` for anything with a lifetime; `contextlib.contextmanager` to write one in a few lines;
+`try/finally` only when neither fits. `ExitStack` when the number of resources is dynamic.
+

package/skills/lit-code/references/python/testing.md

@@ -0,0 +1,50 @@
+# Python — testing
+
+## Structure
+
+```python
+@pytest.mark.parametrize(
+    ("raw", "expected"),
+    [("", None), ("a", 1)],
+    ids=["empty", "single"],
+)
+def test_parse(raw, expected):
+    assert parse(raw) == expected
+```
+
+`ids` gives each case a readable failure name. Parametrise over inputs; do not parametrise over
+behavior — two genuinely different behaviors are two tests, and squeezing them into one parametrised
+case with an `if` inside is how a test stops being readable.
+
+## Fixtures
+
+Prefer function scope. A `session`-scoped fixture holding mutable state creates order dependence,
+which appears as a test that passes alone and fails in the suite. `tmp_path` and `monkeypatch` cover
+most needs without custom teardown.
+
+## Assert on behavior
+
+Check the return value, the raised exception type, or the observable side effect. Reaching into
+private attributes couples the test to the implementation and guarantees churn.
+
+```python
+with pytest.raises(RecordNotFound):
+    store.get("missing")
+```
+
+Assert the exception *type*, not its message.
+
+## Mock at the boundary only
+
+Patch the external service, not your own function. `unittest.mock.patch` targets where a name is
+looked up, not where it is defined — patching `mypkg.module.requests` rather than `requests` is the
+correction for the commonest "the mock did nothing" symptom.
+
+## Run
+
+```bash
+pytest -x -q                    # stop at first failure
+pytest --lf                     # rerun last failures
+pytest -p no:randomly           # rule out ordering when a failure looks flaky
+```
+

package/skills/lit-code/references/python/tooling.md

@@ -0,0 +1,38 @@
+# Python — project configuration
+
+Everything in `pyproject.toml`, so contributors, CI, and the editor read one source.
+
+## Type checking
+
+```toml
+[tool.basedpyright]
+typeCheckingMode = "strict"
+venvPath = "."
+venv = ".venv"
+```
+
+`venvPath`/`venv` matter more than the strictness setting: without them the checker resolves the
+wrong interpreter and reports import errors for packages that are installed.
+
+Adopting strict mode on an existing codebase works file by file. A repo-wide flip that produces
+hundreds of errors gets suppressed wholesale, which is worse than not enabling it.
+
+## Lint and format
+
+```toml
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "ASYNC"]
+```
+
+`B` (bugbear) and `ASYNC` catch real defects — mutable defaults, blocking calls in async code. `I`
+replaces isort. `ruff format` replaces black; do not run both.
+
+## Dependencies
+
+Pin with a lockfile (`uv.lock`, `poetry.lock`) and commit it. Declare ranges in `pyproject.toml`,
+resolve exact versions in the lock. Separate dev dependencies from runtime ones so the deployed
+image does not carry the test suite.
+

package/skills/lit-code/references/python/type-patterns.md

@@ -0,0 +1,46 @@
+# Python — types that carry weight
+
+Annotations are checked by a separate tool, never at run time. That makes some patterns genuinely
+valuable and others decorative.
+
+## Worth doing
+
+**Annotate every public signature.** Parameters and return type. Internal helpers can stay bare when
+the types are obvious from two lines of context; a module boundary should not.
+
+**`NewType` for identifiers.** Free at run time, and it stops the argument-order mistake that unit
+tests rarely catch:
+
+```python
+from typing import NewType
+UserId = NewType("UserId", str)
+OrderId = NewType("OrderId", str)
+```
+
+**Narrow the container types.** `Sequence[str]` in a parameter accepts more callers than `list[str]`
+and promises less; `list[str]` in a return type promises more than `Iterable[str]` and lets the
+caller index. Pick per direction, not per habit.
+
+**Model absent and invalid separately.** `str | None` says "may be missing". A `Result`-style union
+or a raised exception says "may be wrong". Collapsing the two into `None` is how a validation failure
+becomes a `NoneType` error three frames away.
+
+**`Literal` and `Enum` for closed sets.** `Literal["read", "write"]` costs nothing and turns a typo
+into a type error.
+
+## Where it stops helping
+
+- **`Any` anywhere in a domain signature** disables checking for everything downstream of it, silently.
+- **`cast()` as a way to quiet the checker.** It asserts something the checker could not verify. Each
+  use should be justified in a comment or replaced with a runtime check.
+- **Deep generic gymnastics.** If the annotation is harder to read than the function, the function is
+  probably doing two things.
+- **`# type: ignore` without a code.** Use `# type: ignore[arg-type]` so the suppression stops
+  applying when the reason changes.
+
+## Dataclasses
+
+`@dataclass(frozen=True, slots=True)` for value objects: immutability prevents a whole class of
+aliasing bug, and `slots` removes the per-instance dict. Use `field(default_factory=list)` — a bare
+mutable default is shared across every instance, which is the oldest trap in the language.
+

package/skills/lit-code/references/rust/README.md

@@ -0,0 +1,12 @@
+# Rust
+
+| File | Covers |
+|---|---|
+| [type-patterns.md](type-patterns.md) | Making invalid states unrepresentable |
+| [error-handling.md](error-handling.md) | `thiserror` in libraries, `anyhow` in binaries |
+| [concurrency.md](concurrency.md) | Send/Sync, async, and what the compiler does not check |
+| [unsafe.md](unsafe.md) | The discipline, and the tools that actually verify it |
+| [tooling.md](tooling.md) | Strict lints and test tooling |
+
+Defaults for new code. An existing codebase's conventions win.
+

package/skills/lit-code/references/rust/concurrency.md

@@ -0,0 +1,45 @@
+# Rust — concurrency
+
+The compiler proves the absence of data races. It does not prove the absence of deadlocks, lost
+wakeups, or logic that is simply wrong under interleaving.
+
+## Send and Sync
+
+`Send` means it can move to another thread; `Sync` means `&T` can be shared. Both are inferred. When
+a type is not `Send`, the error names the offending field — usually an `Rc` or a raw pointer, and the
+fix is usually `Arc`, not `unsafe impl Send`.
+
+**Never write `unsafe impl Send`/`Sync` to make an error go away.** That assertion is the one the
+compiler was making for you.
+
+## Shared state
+
+```rust
+let counter = Arc::new(Mutex::new(0));
+```
+
+`Arc<Mutex<T>>` is the default and is usually right. `RwLock` only when reads genuinely dominate —
+its bookkeeping costs more than a `Mutex` under contention. `parking_lot` is faster and has no
+poisoning, at the cost of a dependency.
+
+A `MutexGuard` held across an `.await` blocks the executor thread. Use `tokio::sync::Mutex` in async
+code, or restructure so the lock is released before awaiting — the second is almost always better.
+
+## Async
+
+```rust
+let (a, b) = tokio::try_join!(fetch(x), fetch(y))?;
+tokio::select! { res = work() => ..., _ = shutdown.recv() => ... }
+```
+
+Spawned tasks need a `JoinHandle` that someone awaits, or they are fire-and-forget. `select!` drops
+the losing futures at the branch point — a future cancelled mid-operation may leave state
+half-written, so make each branch cancellation-safe or use `tokio::spawn` instead.
+
+Never call blocking code in an async task: `spawn_blocking` for I/O, `rayon` for CPU work.
+
+## Verify
+
+`cargo test -- --test-threads=1` to expose order dependence, and `loom` for lock-free code — it
+exhaustively explores interleavings that testing will never hit.
+

package/skills/lit-code/references/rust/error-handling.md

@@ -0,0 +1,43 @@
+# Rust — errors
+
+## Libraries: typed errors
+
+```rust
+#[derive(Debug, thiserror::Error)]
+pub enum StoreError {
+    #[error("record {0} not found")]
+    NotFound(UserId),
+    #[error("database unavailable")]
+    Unavailable(#[from] sqlx::Error),
+}
+```
+
+A caller can match on the variant and react. `#[from]` gives `?` conversion without boilerplate.
+Never expose `anyhow::Error` from a library API — it erases exactly the information the caller needs.
+
+## Binaries: contextual errors
+
+```rust
+use anyhow::{Context, Result};
+
+let config = fs::read_to_string(&path)
+    .with_context(|| format!("read config at {}", path.display()))?;
+```
+
+At the top level nobody matches on the error; they read it. `with_context` builds the chain that
+makes the message useful, and the closure form avoids formatting on the success path.
+
+## `unwrap` and `expect`
+
+`unwrap()` in production code is a panic with no explanation. When a value genuinely cannot be
+absent, `expect("...")` documents why — and the message should state the invariant, not the symptom:
+`expect("config was validated at startup")`, not `expect("should exist")`.
+
+In tests, `unwrap()` is fine.
+
+## Panics are for broken invariants
+
+A panic says "this program is wrong". Anything the caller could reasonably encounter — bad input, a
+missing file, a network failure — is a `Result`. Panicking across an FFI boundary is undefined
+behavior; catch it with `catch_unwind` there.
+

package/skills/lit-code/references/rust/tooling.md

@@ -0,0 +1,36 @@
+# Rust — tooling
+
+## Lints
+
+```toml
+# Cargo.toml
+[lints.rust]
+unsafe_code = "deny"          # remove per-crate where unsafe is genuinely needed
+missing_debug_implementations = "warn"
+
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "allow"
+```
+
+Declaring lints in `Cargo.toml` beats `#![deny(...)]` in `lib.rs`: it applies to the whole crate, is
+visible where dependencies are, and does not need editing in a source file.
+
+`clippy::pedantic` as a warning is productive. As `deny` it fights you over style during unrelated
+work.
+
+## Tests
+
+- `insta` for snapshot tests — `cargo insta review` makes accepting a change deliberate.
+- `proptest` where the input space is large and the invariant is simple. One property often replaces
+  a dozen examples and finds the case nobody thought of.
+- `criterion` for benchmarks. Do not infer performance from a `#[test]` with a timer.
+
+## Build hygiene
+
+- Commit `Cargo.lock` for binaries; for libraries it is advisory.
+- `cargo deny check` for licence and advisory auditing in anything shipped.
+- Pin the toolchain in `rust-toolchain.toml` so a nightly-only feature does not silently become a
+  requirement for every contributor.
+

package/skills/lit-code/references/rust/type-patterns.md

@@ -0,0 +1,46 @@
+# Rust — making invalid states unrepresentable
+
+Rust's type system is strong enough that most invariants can be structural rather than checked. That
+is where the language pays for its difficulty; use it.
+
+## Newtypes at every boundary
+
+```rust
+pub struct UserId(String);
+pub struct Email(String);
+
+impl Email {
+    pub fn parse(raw: &str) -> Result<Self, InvalidEmail> { ... }
+}
+```
+
+Validate once, in the constructor, and the rest of the program can stop re-checking. A function
+taking `Email` cannot receive an unvalidated string, so the check cannot be forgotten.
+
+## Enums instead of flag combinations
+
+```rust
+enum Connection {
+    Disconnected,
+    Connecting { started: Instant },
+    Ready { session: SessionId },
+}
+```
+
+Three booleans allow eight states, of which perhaps three are legal. An enum allows exactly the legal
+ones, and the compiler enumerates them at every `match`.
+
+## Typestate for ordering rules
+
+When operations must happen in an order, encode the order in types: `Builder<Unvalidated>` →
+`Builder<Validated>` → `build()`. A misordered call fails to compile instead of failing at run time.
+Use this where the ordering is genuinely load-bearing; it costs readability, so it is not a default.
+
+## Borrow rather than clone — but not religiously
+
+Take `&str` and `&[T]` in parameters. Return owned values. Reach for `Cow<'_, str>` only when
+profiling shows the clone matters. A `.clone()` that makes a lifetime problem disappear in
+non-hot-path code is a reasonable trade, and fighting the borrow checker for a nanosecond is not.
+
+`Rc`/`Arc` in a data model usually signals that ownership was never decided. Decide it.
+

package/skills/lit-code/references/rust/unsafe.md

@@ -0,0 +1,47 @@
+# Rust — `unsafe`
+
+`unsafe` does not disable the borrow checker. It permits five specific operations: dereferencing a
+raw pointer, calling an `unsafe` function, implementing an `unsafe` trait, mutating a `static mut`,
+and accessing a union field. Everything else is checked as usual.
+
+## The discipline
+
+**Every `unsafe` block gets a `// SAFETY:` comment** stating the invariant that makes it sound, in
+terms a reviewer can check:
+
+```rust
+// SAFETY: `idx < self.len` was checked above, and `self.ptr` is valid for
+// `self.len` initialised elements for the lifetime of `&self`.
+unsafe { &*self.ptr.add(idx) }
+```
+
+A block without one is not reviewable, and "it works" is not the invariant.
+
+**Keep the block minimal.** Wrap the single operation, not the surrounding logic. A large `unsafe`
+block hides which line carries the risk.
+
+**Encapsulate behind a safe API.** The module exposing `unsafe` internals owns the proof. If a caller
+can break the invariant through the safe interface, the interface is wrong — that is a soundness bug,
+and it is a defect even when no current caller triggers it.
+
+## The undefined behavior that actually bites
+
+- **Aliasing `&mut`.** Two mutable references to the same location, even briefly, even unused.
+- **Reading uninitialised memory.** Use `MaybeUninit`; a zeroed `bool` or reference is UB.
+- **Invalid values.** A `bool` that is not 0 or 1, a `char` outside the Unicode range, a null
+  reference — constructing one is UB immediately, before it is read.
+- **Pointer provenance.** A pointer derived from one allocation cannot address another, even at a
+  numerically correct address.
+- **Unwinding across FFI.** Wrap in `catch_unwind`.
+
+## Verify, do not assert
+
+```bash
+cargo +nightly miri test
+RUSTFLAGS="-Zsanitizer=address" cargo +nightly test --target <host-triple>
+```
+
+Miri catches aliasing and provenance violations that run correctly in debug and corrupt memory in
+release. For anything with `unsafe`, run it before believing the tests. A clean release run proves
+very little on its own.
+

package/skills/lit-code/references/typescript/README.md

@@ -0,0 +1,11 @@
+# TypeScript
+
+| File | Covers |
+|---|---|
+| [type-patterns.md](type-patterns.md) | Types that prevent defects rather than describe code |
+| [error-handling.md](error-handling.md) | Typed failure at the boundary |
+| [tsconfig-strict.md](tsconfig-strict.md) | The settings that change what compiles |
+| [testing.md](testing.md) | Structure and the mocking boundary |
+
+Defaults for new code. An existing codebase's conventions win.
+

package/skills/lit-code/references/typescript/error-handling.md

@@ -0,0 +1,56 @@
+# TypeScript — failure at the boundary
+
+`throw` accepts any value, and a caught value is `unknown`. Both facts shape how errors should be
+handled.
+
+## Narrow what you catch
+
+```ts
+try {
+  await run();
+} catch (err: unknown) {
+  if (err instanceof ApiError) { ...; return; }
+  throw err;
+}
+```
+
+`catch (err)` gives `unknown` under `useUnknownInCatchVariables` (included in `strict`). Treat that
+as a feature: it forces the narrowing that `err.message` would otherwise skip.
+
+## Typed errors carry data
+
+```ts
+export class ApiError extends Error {
+  constructor(readonly status: number, readonly code: string, message: string) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+```
+
+Setting `name` explicitly matters — subclass names are lost through some transpilation targets, and a
+caller matching on it silently stops matching.
+
+Use `cause` to chain: `new ConfigError("load failed", { cause: err })`.
+
+## Result types where failure is expected
+
+For an operation whose failure is ordinary — validation, parsing, a lookup that may miss — returning
+a discriminated union puts the failure in the signature rather than out of band:
+
+```ts
+type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
+```
+
+Use exceptions for the unexpected. Using them for control flow makes every call site a potential
+non-local exit, which is what makes async cleanup hard to reason about.
+
+## Async
+
+Every `Promise` needs an owner. A floating promise swallows its rejection and, in Node, can terminate
+the process. Enable `@typescript-eslint/no-floating-promises` — it is the single highest-value lint
+rule in this language. Use `void promise` to mark a deliberate fire-and-forget.
+
+`Promise.allSettled` when partial failure is acceptable; `Promise.all` when it is not. Choosing
+`all` by default turns one slow failure into a total one.
+

package/skills/lit-code/references/typescript/testing.md

@@ -0,0 +1,42 @@
+# TypeScript — testing
+
+## Structure
+
+```ts
+describe("parseConfig", () => {
+  it.each([
+    ["empty input", "", null],
+    ["valid port", '{"port":8080}', 8080],
+  ])("%s", (_name, raw, expected) => {
+    expect(parseConfig(raw)?.port ?? null).toBe(expected);
+  });
+});
+```
+
+Name the case, not the index. A failure that reads `parseConfig > case 3` costs a lookup every time.
+
+## Assert on behavior
+
+Check the returned value, the thrown error type, or the observable effect. Testing that a private
+method was called couples the test to the implementation and produces churn on every refactor.
+
+```ts
+await expect(store.get("missing")).rejects.toThrow(RecordNotFound);
+```
+
+Assert the error type, not the message.
+
+## Mock at the boundary
+
+Mock the HTTP client, the clock, the filesystem — the things you do not own. Mocking your own modules
+means the test verifies the mock. For HTTP specifically, an interceptor such as `msw` or `nock`
+exercises the real client code path, which a stubbed module does not.
+
+Fake timers for anything time-dependent; a test with a real `setTimeout` is a slow test and
+eventually a flaky one.
+
+## Types are not tests
+
+A passing type check proves the shapes line up, not that the logic is right. Conversely, a test that
+only asserts a type (`expectTypeOf`) belongs in a type-level test file, separate from behavior tests.
+