In a library's published output you find `const registry = /*#__PURE__*/ createRegistry();`. What does that comment assert, what reads it, and what is the risk of adding one?

## What the annotation says A bundler will not delete `createRegistry()` on its own, even when nothing reads the result, because it cannot see whether the call touches shared state. The annotation supplies the missing fact: ```js const registry = /*#__PURE__*/ createRegistry(); ``` Read it as: *if you decide the result of this expression is unused, deleting the expression is safe.* Two conditions must both hold for removal — the result must be unreachable, and the annotation must be present. An annotated call whose result is used stays exactly where it is. The `/*@__PURE__*/` spelling is equivalent, and both `f()` and `new C()` forms are supported. Placement is strict: the comment must sit immediately before the callee expression. Put it on the previous line, before the `const`, or before an assignment rather than the call, and it is simply ignored — a silent no-op that people misread as "the annotation didn't help". ## Who writes them and who reads them Mostly you do not write them by hand in application code. They show up in *compiled* output: Babel emits them around helper calls and downlevelled class constructs it knows are pure, Rollup preserves and propagates them, and library build pipelines add them to factory calls so consumers can drop unused APIs. On the reading side, Terser was the original consumer, and Rollup, esbuild and webpack (via its minifier) all honour them. The reason libraries care disproportionately: a UI or utility library often exports dozens of objects built by factory calls at module scope. Without annotations, each of those calls is opaque, so importing one export keeps them all. With annotations, a consumer using one export drops the rest. ## Why the transitive part matters Deleting a call can unlock a cascade. If `createRegistry` was the only reference to an imported module, that import becomes unused and may go too, and so on up the graph. This is where the real size wins come from — a single annotated factory call can be holding an entire dependency subtree alive. ## The risk, concretely The annotation is a promise the toolchain trusts and never checks. Consider: ```js // This call is NOT pure — the annotation is a lie const plugin = /*#__PURE__*/ registerPlugin('analytics'); ``` If `plugin` is unused, optimised builds delete the registration. Development builds usually skip minification, so it works locally. Unit tests that assert on the return value keep the call reachable, so they pass. What ships is missing a plugin, and the runtime symptom appears far from the deleted line. A second, subtler risk: purity can regress. A call that was genuinely pure when annotated acquires a `console.warn`, a cache write or a metrics counter three releases later, and the stale annotation now licenses deleting real behaviour. Annotations are assertions about code that keeps changing, and nothing re-checks them. ## Related, coarser tools For whole functions rather than single call sites, Rollup and esbuild also understand a `/*#__NO_SIDE_EFFECTS__*/` annotation placed before a function declaration, which asserts that *every* call to that function is pure — so call sites need no individual annotation. It carries the same trust model and the same risk, scaled up. And at the file and package level, `sideEffects` in `package.json` is the coarsest instrument of the three. Pick the narrowest one that expresses what you actually know. ## How to use them responsibly - Prefer restructuring over annotating. A factory the consumer calls explicitly needs no promise about purity. - Annotate only calls whose implementation you own and can keep pure. - Verify by building a consumer that uses nothing from the annotated module and checking that the code is actually gone, then that the app still works. - Treat an annotation as documentation with teeth: a comment near the callee stating that it must stay pure, so the next person editing it knows the constraint exists.