Models and levels, in full.Modelsandlevels,infull.

An in-process cache service evicts the wrong entry under a specific access pattern. Somewhere in the cache layer, recency bookkeeping is broken — locate the eviction-order bug among the service's modules and fix it at its single site so the least-recently-used key is the one removed on overflow.

Implement a mutex-backed bounded FIFO queue from empty signatures: blocking Push/Pop with a fixed capacity, safe under concurrent producers and consumers. The interface and tests are given; you write the implementation.

Implement sliding-window rate-limit middleware for an existing Express app: allow N requests per window per client key, return 429 with the right headers when exceeded. Time is driven by an injectable clock so grading is deterministic — never real wall-clock sleep.

An async crawler has a data race on its shared visited-set, dropping or double-visiting URLs. Fix the synchronization so the visited set is consistent. Grading uses a seeded scheduler — public test #1 carries an evil seed that reproduces the race immediately, so the defect fails on the first run rather than flaking.

One endpoint of a small orders service scales its query count with result size and is missing an index its access path needs. Find the offending query pattern among several efficient neighbors and make the request issue a bounded number of queries. A query counter in the harness enforces the bound.

A Raft-style cluster elects two leaders in the same term under a specific message ordering. Somewhere in the per-node ballot logic a safety rule is broken — find it and fix it so at most one leader is elected per term. The cluster, network simulation, and role machinery are provided; the defect has one site.

Implement a vector clock from scratch against a fixed, closed API: Tick, Merge, and Compare (returning before/after/concurrent/equal). A bounded distributed primitive with unambiguous semantics — the signatures and tests are given.

An RGA text CRDT fails to converge: two replicas applying the same operations in different orders reach different documents. Fix the merge so replicas converge regardless of delivery order. Grading replays fixed operation sets, so convergence is checked deterministically.

A task orchestrator deadlocks when tasks contend for shared resources in a particular shape. Audit the codebase's concurrency discipline, find the defect, and make every submitted task complete. A seeded scheduler with an evil seed in public test #1 reproduces the hang deterministically.

Under context cancellation, a service leaks goroutines and idle connections. Fix the lifecycle so both are released on cancel. The harness counts live goroutines and open connections before and after, asserting they return to baseline.

A secure-envelope library sometimes accepts messages it must reject: its tag verification mishandles certain attacker-shaped inputs and leaks information through timing. Locate the offending compare among the crate's crypto plumbing and make verification strict and constant-time. The cipher, MAC derivation, and framing are provided.

Implement swap and a mulDiv helper for a constant-product (x·y=k) AMM against a narrow, fixed API: compute the output amount with fees, preserve the invariant, and stay overflow-safe with integer fixed-point math. Hidden tests cover rounding, fee edges, and large reserves.

Implement schnorr_verify and merkle_verify from scratch. The elliptic-curve module is provided as a primitive; you author both verification functions against a serialization convention pinned in the kit, with a worked vector shipped alongside. Validated against published test vectors so correctness is unambiguous.

An Express API has a blind SQL injection in a search route and a prototype-pollution bug in a deep-merge helper. Patch both without breaking the legitimate request paths. The harness boots the app and fires both benign and adversarial requests, asserting safe behavior and unpolluted Object.prototype.

One function in a bit-packed analytics toolkit returns wrong counts for some inputs. Every module is written in the same dense, branchless bit-trick style — decode the one that's broken, find the defect, and fix it so the function honors its inclusive-range contract for all inputs.

Implement one tiled online-softmax attention block from scratch: the streaming block update that keeps softmax numerically stable across tiles. The tensor views, tiling helpers, and attention driver are provided — you write the single block-update function. Checked against a dense reference with tight tolerances, including tiles whose scores overflow a naive implementation.

Implement the constant-folding pass over a small bytecode IR: evaluate constant subexpressions at compile time while preserving program semantics and side effects. The IR, parser, and evaluator are provided; you write the pass. Dead-code elimination is an optional, separately-scored bonus.

Implement the broad-phase collision stage of a small 2D physics engine using sweep-and-prune over AABBs: report every genuinely overlapping pair, normalized and sorted, fast enough to beat brute force on mostly-separated workloads. The body, world, and narrow-phase machinery are provided; you write the broad phase.

A seeded 2-layer MLP training run explodes to NaN within a few steps. Several distinct numerical-stability defects hide in the model and training loop — diagnose them from the divergence and fix each one so the network trains to the target loss with every intermediate loss finite.

A cooperative task runtime stops making progress under a specific arrival order of wakes and schedules. The codebase documents its lock discipline — audit the scheduler paths that take multiple locks, find where the discipline is violated, and restore liveness. A deterministic yield scheduler with an evil seed reproduces the hang.