the public API we deleted because the protocol had two sides

The library had a function that did the whole job. It drew its own seed, iterated until it found an answer, and returned the result. It was tested, documented, and the obvious thing for a caller to reach for.

It was also unusable, and it took a protocol to show it. The real interaction is not one party doing the whole job. One party issues a piece of work and sends it. A second party receives that work and solves it. The first party then checks the answer, and that check has to be cheap enough to run on every submission. Once the split is drawn, the all-in-one function cannot be called at all: it chooses its own seed, so it can never operate on a problem someone else set, and it hands back an opaque finished artifact rather than the separate pieces that have to travel.

We deleted it instead of writing a wrapper that pretended the two shapes were the same. The tests that exercised it were rewritten against the two-sided entry points rather than kept green around a dead function.

The replacement carried its own lesson. Two entry points, one serial and one multi-threaded, forced every caller to choose a threading function when what they wanted to choose was a budget. Those collapsed into a single configuration object, so the shape of the call follows the shape of the decision.

The cost is that the library lost a convenient one-liner and gained a caller obligation. What it proves is that this team will remove a working, tested interface when the real protocol says it cannot be called, and will move the tests rather than preserve them around the wrong model.