@hellraisercenobit/ai-engineering-gate 0.8.0

package/skills/engineering/transpose-design-patterns/references/transpose-quarkus.md

@@ -0,0 +1,283 @@
+# Quarkus Transposition — Design Patterns (Java 21+, 2026)
+
+Generic, portable Quarkus wiring for the patterns in [`pattern-catalog.md`](pattern-catalog.md).
+Framework-specific only — keep business logic framework-agnostic in the catalog. Examples use
+throwaway domains (user, cart, payment, order); substitute your own types. This guide states **common**
+Quarkus practice (Quarkus 3.x, Java 21+), not any single project's house rules.
+
+## Quarkus building blocks
+
+The transpositions below lean on a few modern-Quarkus defaults:
+
+- **Build-time CDI (ArC)** — wiring is resolved at build time (no runtime classpath scanning, no Portable
+  Extensions). Prefer **constructor injection** (final fields, testable; `@Inject` is optional for a
+  single constructor) over field injection.
+- **`@ApplicationScoped`** for almost every bean — a _normal_ scope: a client proxy is injected and the
+  instance is created lazily. `@Singleton` is a _pseudo-scope_ (no proxy, eager, can't break cycles);
+  reach for it only to shave proxy indirection.
+- **Quarkus REST** (`quarkus-rest` + `quarkus-rest-jackson`) — Jakarta REST annotations (`@Path`, `@GET`).
+  It is the current name for RESTEasy Reactive; RESTEasy Classic (`quarkus-resteasy`) is legacy. A method
+  runs on the Vert.x event loop unless it returns a plain value / is `@Blocking` / `@Transactional` /
+  `@RunOnVirtualThread` (then a worker or virtual thread).
+- **Records** for immutable DTOs and value types; **sealed interfaces + pattern-matching `switch`** for
+  closed discriminated unions (compiler-checked exhaustiveness, no `default`).
+- **`@ConfigMapping`** interface for typed, grouped, validated config (over scattered `@ConfigProperty`).
+- **Native-image aware** — build-time wiring; payloads reached only by reflection need
+  `@RegisterForReflection`, beans resolved only by programmatic lookup need `@Unremovable`.
+
+```java
+@ApplicationScoped
+public class CheckoutService {             // proxied, lazy, one shared instance
+  private final OrderRepository orders;    // constructor injection, final field
+  CheckoutService(OrderRepository orders) { this.orders = orders; } // no @Inject needed
+}
+```
+
+## Pattern → Quarkus wiring
+
+### Strategy → many beans of one interface, selected via CDI (no `switch`)
+
+Each strategy is an `@ApplicationScoped` bean implementing the interface with a `supports()` / `key()`
+method. Inject **`@All List<T>`** (immutable, `@Priority`-sorted) and pick by predicate — DI replaces the
+`switch`. For a _closed_ variant set known at compile time, a sealed interface + pattern-matching `switch`
+is the typed alternative.
+
+```java
+interface PaymentStrategy { boolean supports(String method); void pay(long amount); }
+
+@ApplicationScoped
+class PaymentService {
+  private final List<PaymentStrategy> strategies;
+  PaymentService(@All List<PaymentStrategy> strategies) { this.strategies = strategies; }
+  void pay(String method, long amount) {
+    strategies.stream().filter(s -> s.supports(method)).findFirst()
+        .orElseThrow(() -> new IllegalArgumentException(method)).pay(amount);
+  }
+}
+```
+
+Disambiguate a one-of lookup with `@Identifier("…")` + `Instance<T>.select(…)` — **not** `@Named`
+(`@Named` also implies `@Default`, causing ambiguity).
+
+### Registry → typed map built from the injected implementations
+
+DI _is_ the registry: inject `@All List<T>` and index by the key each bean exposes. New implementations
+are discovered automatically — no central `switch`, no hand-maintained provider map. Duplicate keys fail
+fast when the registry is first used (it is `@ApplicationScoped`, so the constructor runs lazily; make it
+`@Singleton`/`@Startup` if you want the check at boot).
+
+```java
+interface Exporter { String format(); byte[] export(Report r); }
+
+@ApplicationScoped
+class ExporterRegistry {
+  private final Map<String, Exporter> byFormat;
+  ExporterRegistry(@All List<Exporter> exporters) {
+    this.byFormat = exporters.stream().collect(toUnmodifiableMap(Exporter::format, identity()));
+  }
+  Exporter forFormat(String f) {
+    return Optional.ofNullable(byFormat.get(f)).orElseThrow(() -> new NoSuchElementException(f));
+  }
+}
+```
+
+Gate a bean by config with `@LookupIfProperty` / `@LookupUnlessProperty` (then obtain it via `Instance<T>`).
+
+### Factory → CDI `@Produces` producer method
+
+Isolate creation logic in a `@Produces` method when it is non-trivial, config-driven, or builds a
+third-party type you can't annotate; return an abstraction. A `@Disposes` method cleans it up.
+
+```java
+@ApplicationScoped
+class GatewayFactory {
+  @Produces @ApplicationScoped @Identifier("primary")
+  PaymentGateway primary(GatewayConfig cfg) {
+    return new HttpPaymentGateway(cfg.url(), cfg.token());   // returns the abstraction
+  }
+}
+```
+
+Caveat: **interceptors are not woven on produced instances** — `@Transactional` / custom bindings on a
+producer-returned object do nothing. If you need interception, make it an annotated bean class instead.
+
+### Command → distinct `@ApplicationScoped` use-case the resource delegates to
+
+Encapsulate one action in a focused application-service bean; the Quarkus REST resource stays thin and
+delegates. Put `@Transactional` on the use-case method (the unit of work), never on the resource or the
+domain.
+
+```java
+@ApplicationScoped
+class PlaceOrder {                         // the use-case / Command
+  private final OrderRepository orders;
+  PlaceOrder(OrderRepository orders) { this.orders = orders; }
+  @Transactional
+  OrderId handle(PlaceOrderCommand cmd) { /* domain logic */ return orders.save(cmd.toOrder()); }
+}
+
+@Path("/orders")
+class OrderResource {
+  private final PlaceOrder placeOrder;
+  OrderResource(PlaceOrder placeOrder) { this.placeOrder = placeOrder; }
+  @POST OrderId create(@Valid PlaceOrderCommand cmd) { return placeOrder.handle(cmd); }
+}
+```
+
+A Panache repository method or a resource method is **not automatically** the Command — when the action
+must be reusable, composable, or unit-testable in isolation, keep it a distinct `@ApplicationScoped`
+use-case bean the resource/repository **delegates** to. Full rule + layering: catalog → _Command_.
+
+### Adapter / DTO Mapping → records + pure `from`/`to` at the boundary
+
+Map DTO ↔ domain/entity at the resource boundary; **never serialize JPA entities** (leaks internals,
+breaks on lazy relations, bloats the native reflection surface). The catalog's canonical mapper is
+TypeScript; the Java equivalent is a record with a static `from` (or, for large surfaces, MapStruct):
+
+```java
+public record UserDto(String id, Instant createdAt) {
+  static UserDto from(User u) { return new UserDto(u.id(), u.createdAt()); }
+}
+
+// larger surfaces: MapStruct, CDI-injectable and reflection-free (native-safe).
+// Use "jakarta-cdi" on Quarkus 3.x — plain "cdi" can emit javax.inject.@Inject, which ArC won't resolve.
+@Mapper(componentModel = "jakarta-cdi")
+interface UserMapper { UserDto toDto(User u); }
+```
+
+Keep mappers and DTOs in the application/web layer — the domain must not depend on them.
+
+### Composition → CDI injection + interceptors + events (not inheritance)
+
+Compose behavior through injected collaborators, **CDI interceptors** for cross-cutting concerns
+(`@InterceptorBinding` + `@AroundInvoke`, ordered by `@Priority`; `@Transactional` is the built-in
+example), and **CDI events** to decouple producers from consumers (`Event<T>` + `@Observes` /
+`@ObservesAsync`). Model variants with sealed records, not class hierarchies.
+
+```java
+@ApplicationScoped
+class OrderService {
+  private final Event<OrderPlaced> placed;
+  OrderService(Event<OrderPlaced> placed) { this.placed = placed; }
+  void place(Order o) { /* … */ placed.fireAsync(new OrderPlaced(o.id())); }
+}
+
+@ApplicationScoped
+class EmailNotifier {
+  void onOrder(@ObservesAsync OrderPlaced e) { /* offloaded to a worker pool */ }
+}
+```
+
+### Singleton / shared state → `@ApplicationScoped` bean exposing read-only state
+
+The common case for app-wide state: a single `@ApplicationScoped` instance with private state and a
+read-only surface. Because that one instance is hit by **all request threads**, mutable fields are a data
+race — guard them with container-managed `@Lock` (write-exclusive by default, `@Lock(READ)` for
+concurrent reads) or `java.util.concurrent` / atomics.
+
+```java
+@Lock
+@ApplicationScoped
+class FeatureFlags {
+  private final Map<String, Boolean> flags = new HashMap<>();
+  void set(String key, boolean on) { flags.put(key, on); }                  // exclusive
+  @Lock(value = Lock.Type.READ) boolean isEnabled(String key) {             // concurrent reads
+    return flags.getOrDefault(key, false);
+  }
+}
+```
+
+## Cross-cutting Quarkus practice
+
+### Keep resources thin
+
+Quarkus REST resources orchestrate HTTP, bind/validate input, and delegate. Push logic and mapping into
+`@ApplicationScoped` services and pure functions. (Resource classes are `@Singleton` by default — never
+store per-request mutable state in their fields.)
+
+### Never block the event loop
+
+Endpoint methods run on the Vert.x event loop. Blocking work (JDBC, blocking clients, filesystem) must
+either return a Mutiny `Uni` / `Multi`, or be annotated `@Blocking` (worker thread) or
+`@RunOnVirtualThread` (Java 21 virtual thread — the 2026 default for blocking I/O endpoints). Blocking the
+loop stalls every concurrent request.
+
+```java
+@GET @Path("/{id}") @RunOnVirtualThread            // imperative blocking on a virtual thread
+UserDto get(@RestPath String id) { return UserDto.from(users.findById(id)); }
+```
+
+### Reactive only at the async boundary
+
+Keep Mutiny `Uni` / `Multi` at the edges (REST signatures, reactive clients/messaging); map DTO→domain in
+the chain and convert to plain values inside imperative code. Never call `.await()` on the event-loop
+thread.
+
+### Transactions at the service boundary
+
+`@Transactional` (JTA) wraps the use-case method, making it atomic — not the domain, not the resource. On
+the _reactive_ stack use `@WithTransaction` / `Panache.withTransaction(...)` (returns `Uni`); JTA does not
+apply there.
+
+### Validate at the boundary
+
+Annotate DTO fields with `jakarta.validation.constraints.*` and REST params with `@Valid` — Quarkus
+auto-returns HTTP 400 with a violation report. Keep the rules as constraints / pure functions; inject
+`Validator` for programmatic checks in services.
+
+### Persistence behind a repository
+
+Prefer a `PanacheRepository<T>` (`@ApplicationScoped`) over the active-record entity for layered, mockable
+code — it keeps query logic off the entity and behind a seam.
+
+### Stay native-image-friendly
+
+Wire through build-time CDI, not `Class.forName` / classpath scanning. Add `@RegisterForReflection` to
+payloads reached only by reflection, and `@Unremovable` to beans resolved only via programmatic lookup
+(else `quarkus.arc.remove-unused-beans` drops them). Use the tracing agent in integration tests to find gaps.
+
+### Testing
+
+`@QuarkusTest` + REST Assured for app / endpoint tests; `@QuarkusComponentTest` to test one bean in
+isolation; `@InjectMock` / `@InjectSpy` (`quarkus-junit5-mockito`) to replace collaborators;
+`@TestHTTPEndpoint` to resolve paths from the resource; `@QuarkusIntegrationTest` to exercise the packaged
+jar / native image.
+
+## Quarkus Decision Matrix
+
+| Problem                                | Recommended Solution                                                       |
+| -------------------------------------- | -------------------------------------------------------------------------- |
+| Shared app state / service             | `@ApplicationScoped` bean (read-only surface; `@Lock` if mutable)          |
+| Singleton without proxy / lazy needs   | `@Singleton` (pseudo-scope, eager)                                         |
+| Depend on an abstraction               | inject the interface via the constructor                                   |
+| Interchangeable behaviors              | Strategy (`@All List<T>` + `supports()`, no switch)                        |
+| Closed, finite variant set             | sealed interface + pattern-matching `switch`                               |
+| Plugin / extension system              | Registry (map built from `@All List<T>`)                                   |
+| Object creation with logic             | Factory (`@Produces` producer method)                                      |
+| Reusable action                        | Command (distinct `@ApplicationScoped` use-case the resource delegates to) |
+| API ↔ domain shape mismatch           | record DTO + static `from` / MapStruct (`componentModel="jakarta-cdi"`)    |
+| Cross-cutting behavior                 | Composition (CDI interceptor / events; no inheritance)                     |
+| Disambiguate multiple beans            | `@Identifier` + `Instance.select` (not `@Named`)                           |
+| Config-gated bean                      | `@LookupIfProperty` / `@LookupUnlessProperty`                              |
+| Typed config                           | `@ConfigMapping` interface                                                 |
+| Runtime validation                     | Bean Validation (`@Valid` + `jakarta.validation.constraints.*`)            |
+| Unit of work / atomicity               | `@Transactional` on the service method (reactive: `@WithTransaction`)      |
+| Blocking I/O endpoint                  | `@RunOnVirtualThread` (or `@Blocking`)                                      |
+| Async / streaming boundary             | Mutiny `Uni` / `Multi`                                                     |
+| Persistence access                     | `PanacheRepository<T>` (repository over active-record)                     |
+| Reflectively-reached payload (native)  | `@RegisterForReflection`                                                   |
+| Bean kept only via programmatic lookup | `@Unremovable`                                                             |
+
+## Anti-Patterns to Avoid
+
+- field injection instead of constructor injection (loses final fields, testability)
+- business logic in Quarkus REST / JAX-RS resources — delegate to an `@ApplicationScoped` service
+- blocking the IO / event-loop thread without `@Blocking` / `@RunOnVirtualThread` — stalls all requests
+- mutable shared state in an `@ApplicationScoped` bean without `@Lock` / atomics — a data race across threads
+- serializing JPA entities over HTTP / entities leaking across layers — map to record DTOs at the boundary
+- `switch` on a type tag instead of CDI selection (open sets) or an exhaustive sealed `switch` (closed sets)
+- `@Named` for internal bean disambiguation (implicit `@Default` clash) — use `@Identifier`
+- `@Transactional` on a domain entity or a producer-returned instance (not woven) — put it on the service
+- runtime reflection / `Class.forName` / classpath scanning that breaks native image — wire at build time
+- deep inheritance hierarchies — prefer composition + CDI + sealed records
+- a Command merged into a resource/repository method when it must be reusable — keep it a distinct use-case the resource delegates to

package/skills/engineering/transpose-design-patterns/references/transpose-react.md

@@ -0,0 +1,256 @@
+# React Transposition — Design Patterns (TypeScript 2026)
+
+Generic, portable React wiring for the patterns in [`pattern-catalog.md`](pattern-catalog.md).
+Framework-specific only — keep business logic framework-agnostic in the catalog. Examples use
+throwaway domains (user, cart, payment, order); substitute your own types. This guide states **common**
+React practice, not any single project's house rules.
+
+## React building blocks
+
+The transpositions below lean on a few modern-React defaults (React 19+):
+
+- **Function components + hooks** only — no class components, no `forwardRef` (in React 19 `ref` is a
+  normal prop).
+- **`<Context>` as its own provider** — `<ThemeContext value={…}>`, not `<ThemeContext.Provider>`.
+  Consume with a typed custom hook (`useTheme()`), never raw `useContext` scattered in views.
+- **The React Compiler does the memoization.** With it enabled, drop hand-written `useMemo` /
+  `useCallback` / `React.memo` — keep them only where the compiler is off or you have a measured need.
+- **Derive during render**, hold only source-of-truth state in `useState` / `useReducer`. Effects are
+  for synchronizing with _external_ systems, not for computing values from props/state.
+- **External shared state lives in a store** (Zustand), not in a high-frequency Context. Context is for
+  dependency injection of stable services.
+- **Strong typing**: typed props, discriminated unions for variants, `as const satisfies` for lookup
+  maps, branded ids.
+
+```tsx
+const ThemeContext = createContext<Theme | null>(null);
+
+export function useTheme(): Theme {
+  const theme = use(ThemeContext); // React 19 reader — callable conditionally, unlike useContext
+  if (!theme) throw new Error('useTheme must be used inside <ThemeContext>');
+  return theme;
+}
+```
+
+## Pattern → React wiring
+
+### Strategy → typed lookup map, resolved by key
+
+Stateless strategies in an `as const satisfies` record; pick by key — no `switch`.
+
+```ts
+export interface PaymentStrategy {
+  pay(amount: number): Promise<void>;
+}
+
+export const paymentStrategies = {
+  stripe: stripeStrategy,
+  paypal: paypalStrategy,
+} as const satisfies Record<string, PaymentStrategy>;
+
+export type PaymentMethod = keyof typeof paymentStrategies;
+
+const strategy = paymentStrategies[method]; // typed, exhaustive, no switch
+```
+
+### Registry → self-registering map (validated when dynamic)
+
+Plugins self-register into a module-level map; no central switch. Validate runtime/external plugins.
+
+```ts
+const registry = new Map<string, Plugin>();
+export const registerPlugin = (p: Plugin): void => void registry.set(p.key, p);
+export const getPlugin = (key: string): Plugin | undefined => registry.get(key);
+// dynamic plugins: validate the shape with zod/valibot before registering
+```
+
+To expose a registry to the tree, provide it once via Context and read it through a custom hook —
+never reach into module singletons from components when the registry is request/tenant-scoped.
+
+### Factory → factory function returning an abstraction
+
+Isolate creation logic; return an interface, not a concrete class. A custom hook can be a factory of
+React-bound values.
+
+```ts
+export const createLogger = (env: Env): Logger => (env.production ? new RemoteLogger() : new ConsoleLogger());
+```
+
+### Command → framework-agnostic use-case, optionally wrapped by an Action
+
+Encapsulate one action as a plain (async) function in a framework-agnostic module. Invoke it from an
+event handler, a store action, or — for form submission — a React 19 **Action**.
+
+```ts
+// application/use-case — no React imports
+export const checkoutCart = (cart: Cart): Promise<Order> => orderApi.place(cart);
+```
+
+```tsx
+// component: wrap the use-case in an Action for pending/optimistic state
+const [order, submit, isPending] = useActionState<Order | null, FormData>(
+  (_prev, formData) => checkoutCart(cartFromForm(formData)),
+  null,
+);
+```
+
+A Zustand action is **not automatically** the Command — keep the action a distinct framework-agnostic use-case (function) the store action **delegates** to. Full rule + layering: catalog → _Command_.
+
+### Adapter / DTO Mapping → pure `from`/`to` at the data boundary
+
+Map DTO ↔ domain inside the api client / query function; never leak DTOs into components or JSX.
+
+```ts
+// UserDto / User / userFromDto: see catalog -> Adapter / DTO Mapping
+export const getUser = async (id: string): Promise<User> =>
+  userFromDto(await api.get<UserDto>(`/api/users/${id}`));
+```
+
+### Composition → custom hooks + children/slots
+
+Compose behavior through custom hooks and component composition (children, slot props) — not
+inheritance, not mixins, not deep HOC stacks.
+
+```tsx
+function useTooltip(ref: RefObject<HTMLElement | null>) {
+  /* attach/detach behavior, returns state */
+}
+
+function Card({ media, children }: { media?: ReactNode; children: ReactNode }) {
+  return (
+    <section>
+      {media}
+      {children}
+    </section>
+  ); // behavior composed via hooks + slots, no base class
+}
+```
+
+### Singleton / shared state → a Zustand store exposing state + actions
+
+The common case for app-wide state. Keep the shape minimal; mutate only through actions; **select
+narrowly** so components re-render on the slices they read. Use `useShallow` for object/array selections
+and derive in selectors (or in actions) rather than duplicating derived state.
+
+```ts
+import { create } from 'zustand';
+import { useShallow } from 'zustand/react/shallow';
+
+interface CartState {
+  items: readonly CartItem[];
+  add: (item: CartItem) => void;
+}
+
+export const useCartStore = create<CartState>((set) => ({
+  items: [],
+  add: (item) => set((s) => ({ items: [...s.items, item] })),
+}));
+
+// consume — narrow selector; derived value computed in the selector
+const total = useCartStore((s) => s.items.reduce((sum, i) => sum + i.price, 0));
+const { items, add } = useCartStore(useShallow((s) => ({ items: s.items, add: s.add })));
+```
+
+For app-wide _services_ (not reactive state), inject via Context + a typed hook. Reserve Context for
+stable dependencies; route high-frequency state through the store to avoid re-rendering the subtree.
+
+## Cross-cutting React practice
+
+### Derive during render, not in effects
+
+Compute values from props/state inline (the compiler memoizes). Do **not** mirror props into state with
+`useEffect` + `setState`.
+
+```tsx
+// Bad: const [full, setFull] = useState(''); useEffect(() => setFull(`${first} ${last}`), [first, last]);
+// Good:
+const fullName = `${first} ${last}`;
+```
+
+### Effects only at external boundaries
+
+`useEffect` is for synchronizing with systems outside React (subscriptions, timers, non-React widgets,
+manual DOM). Always return a cleanup. Event-response logic belongs in the event handler, not an effect.
+
+```tsx
+useEffect(() => {
+  const sub = socket.subscribe(onMessage);
+  return () => sub.unsubscribe();
+}, [socket]);
+```
+
+### Data fetching at the edge
+
+Read promises with `use()` under `<Suspense>`, or use a cache (TanStack Query) for client data; fetch
+on the server with Server Components / server functions where the framework supports them. Map DTO→domain
+in the fetcher. Don't fetch in `useEffect` for primary data in new code.
+
+### Let the compiler memoize
+
+With the React Compiler enabled, do not hand-roll `useMemo` / `useCallback` / `memo`. Add them back only
+when the compiler is disabled for a file or profiling proves a hot path.
+
+### Keep components thin
+
+Components render UI, bind state, dispatch actions. Push logic and mapping into hooks, the store, and
+pure framework-agnostic functions.
+
+### Forms via Actions
+
+Prefer React 19 form **Actions** — `useActionState` for submit + result, `useFormStatus` for pending
+UI, `useOptimistic` for optimistic updates. Keep validation rules in pure functions (zod/valibot) the
+Action just calls. Controlled inputs remain fine for small, interactive forms.
+
+### `ref` is a prop
+
+Pass `ref` directly to function components (React 19) — do **not** write `forwardRef` in new code.
+
+```tsx
+function TextField({ ref, ...props }: { ref?: Ref<HTMLInputElement> } & InputProps) {
+  return <input ref={ref} {...props} />;
+}
+```
+
+### JSX SRP
+
+No business logic in JSX. Move ternaries, multi-condition branches, and data-transforming calls into
+derived consts (or selectors).
+
+```tsx
+// Bad: {user.isActive ? 'Active' : 'Inactive'}
+const statusLabel = user.isActive ? 'Active' : 'Inactive';
+// JSX: {statusLabel}
+```
+
+## React Decision Matrix
+
+| Problem                       | Recommended Solution                                          |
+| ----------------------------- | ------------------------------------------------------------ |
+| Local component state         | useState / useReducer                                        |
+| Derived value                 | compute during render (compiler memoizes)                    |
+| Shared app state              | Zustand store + narrow selectors / useShallow                |
+| Dependency injection          | Context + a typed custom hook (`<Context value>`)            |
+| Interchangeable behaviors     | Strategy (`as const satisfies` lookup map)                   |
+| Plugin / extension system     | Registry (self-registering Map, zod for dynamic)             |
+| Object creation with logic    | Factory (factory function / hook returning an abstraction)   |
+| Reusable action               | Command (framework-agnostic use-case, store/Action delegates) |
+| API ↔ domain shape mismatch  | Adapter — fromDto / toDto in the fetcher                      |
+| Cross-cutting behavior        | Composition (custom hooks + children/slots)                  |
+| Data fetching                 | use() + Suspense / TanStack Query / Server Components         |
+| Form                          | React 19 Actions (useActionState / useFormStatus / useOptimistic) |
+| External system sync          | useEffect with cleanup                                        |
+| Forwarding a ref              | `ref` as a normal prop (no forwardRef)                       |
+| Memoization                   | React Compiler (no manual useMemo/useCallback)               |
+
+## Anti-Patterns to Avoid
+
+- class components; `forwardRef` in new code
+- deriving state with `useEffect` + `setState`; storing derived data in `useState`
+- fetching primary data in `useEffect` (use `use()` + Suspense / a query cache / the server)
+- business logic in components; DTOs leaking into JSX; god hooks/components; string magic / `switch` on a type tag instead of an `as const satisfies` lookup map
+- high-frequency global state in Context (re-renders the subtree) — use a Zustand store; reserve Context for DI
+- selecting the whole store object without `useShallow` (re-renders on every change)
+- hand-rolled `useMemo` / `useCallback` / `memo` noise when the React Compiler is enabled
+- prop-drilling shared state deep instead of composition / a store
+- a Command merged into a store action when it must be reusable — keep it a distinct use-case the action delegates to
+- inheritance / mixins; `any`; magic strings; mutating props or store state outside actions