ReplHost

Per-eval unique id → unique source name → unique script class, and the label a spilled dump is filed under. Minted here so the compiler and the failure report can never disagree about which eval it was.

The compile classpath the last buildCompiler ran with, so warm can drive a full compile+remap warmup without the gate having to pass it again. Stable across evals (same enumerated game classpath). Real compiles take their own compile argument — this is not an input to them.

This class's own loader — in dev too: ReplBridge puts the repl classes dir on the masking urls so repl.impl.* resolves child-first. Null only when repl.impl was not masking-loaded (dev without mcp.repl.classes, unit tests), where the regime machinery is inert. See MaskingClassLoader.Regime.

Build the warm K2 compiler (overlay + createCompilationState). Assumes preload already ran (eager path: the preload thread; lazy path: the idempotent call below).

Compile code. Off-tick; PlainEngine serializes compilation.

Run a handle from compile, writing the snippet's println into out, and return captured out + => value. On-tick (may yield). The script body IS the class constructor, so constructing it runs it, and PlainEngine.Compiled.Ok.resultType already carries its own ? — nothing here re-adds one.

Wrap the snippet's cross-tick iterator so a throw mid-drive doesn't discard what it already printed: the (mojmap-remapped) stack is appended to out and the iterator ends cleanly, so the lane returns the partial output together with the error. Without this, a throw in next() would propagate to the lane pump, which completes the future with just the exception text and loses the buffered output. The throw goes through stack() so it's mojmap-remapped like every other throw.

True for a cross-tick builder — ours, or the stdlib's when a snippet fully-qualified past the shadow — and false for listOf(...).iterator() and friends, whose value would otherwise be driven away as a generator and returned as "(no output)".

Enum identity comparison is safe here: mustDelegateToParent routes MaskingClassLoader — and its nested Regime — to the game loader, so exactly one Regime class can ever exist.

Profile-guided preload of the compiler working set. Returns true on a TRAINING launch — preload skipped entirely, so the compiler build loads exactly the true working set for recordWorkingSet to capture; preloading first would make the working set indistinguishable from dead classes. Training is every launch with nothing to replay: no recorded list, a list stamped with another kotlin version, or mcp.preload=false — the only lever that retrains a list the stamp still calls current, for a classpath change the kotlin version cannot see. False only where a list really was preloaded. Idempotent.

Training-launch capture: write every kotlin / kotlin-compiler class the masking loader has defined (= the true compiler working set, since a training launch runs with preload off) to path, plus the kotlin version stamp doPreload gates on. The set comes from MaskingClassLoader.definedClassNames.

Warm the eval path — compile AND run — so the first real eval pays none of it on the tick thread. iterator { yield(1) } is the widest single shape: it compiles a suspend state machine (a superset of a scalar snippet) and is the only one that reaches the snippet loader and the cross-tick path. Running it, not just compiling it, is also what puts those classes in front of recordWorkingSet — what never runs here never enters the preload classlist, and is never preloaded on any later launch either.