A reference that failed the bound module’s export set but resolved in
the GLOBAL class universe (tier two): rendered as the
globalClassFallthrough disclosure instead of a missing-selector
warning. Property accesses never produce one — they have no runtime
fall-through and stay strict.
A reverse-dependency memo refresh produced as a BYPRODUCT of an
off-loop selector build: the loop applies it from the completion
channel instead of ever building a selector itself.
Worker-side resolution of a dispatched query request. Mirrors the
synchronous handle_lsp_message arms exactly, including the feature gating
(evaluated against the snapshot, i.e. the settings in force at dispatch
time). Returns the complete JSON-RPC response; None only for messages that
were never dispatchable (defensive — the loop only dispatches
hover/definition requests).
Internal dispatch (no client-visible response): resolve one hover
against the snapshot purely to POPULATE the Arc-shared hover memos
(cascade-narrowing substrate, resolver identity index) right after a
republish tide settles — the user’s FIRST hover then lands warm instead
of paying the substrate build interactively.
Apply an off-loop reverse-dependency refresh (produced by a worker’s
selector build, delivered through the completion channel) to the loop
state’s memo. The straight-line build has no memo; the refresh is a
no-op there.
Loop-side apply for ONE item — the caller pumps a bounded chunk per tick
(I4) and must have verified the tide generation is still current.
Write-behind runs through the loop state’s real disk-cache session, then
the tiered publish emits in the same shape as every other arm.
Worker-side compute, streaming (rfcs#111 §8.5): ONE shared-graph parallel
wave — one memo-host sync, one substrate, one condensation — with a
per-item sink that emits each target the moment its pool task finishes.
Open documents were ordered first by prepare, so they converge first.
The generation watch aborts disowned tides at item boundaries; the final
event carries the uncovered remainder for the fallback arm.
The dispatched request class: hover/definition REQUESTS (an id is
required — without one there is nothing to respond to). Notifications named
like these methods fall through to the synchronous path unchanged.
JSON-RPC internal-error response for a dispatched query whose resolver
panicked on the worker: the request still gets exactly one response (a
silent drop would hang the client), and the worker survives to serve the
rest of its queue.
Lane routing for dispatched queries: HEAVY dispatches (codeLens, whose
occurrence-index rebuild is a whole-corpus scan, and the internal
substrate warmups) run on their own worker so an interactive hover /
definition / documentColor never queues behind a multi-second compute.
Head-of-line blocking on the single lane was measured live: a
documentColor answered 3ms of work 20 SECONDS after dispatch because a
codeLens rebuild held the worker.
Loop-side turn handler for the stdio server. Mirrors
handle_lsp_message_scheduled_outputs except that dispatchable query
requests are returned as jobs instead of being resolved inline.
The post-settle warmup dispatch: the first OPEN style document’s first
hover candidate. One document suffices — the substrate the build warms
is workspace-scoped, not per-document.
Gate evaluation + snapshot capture, on the loop. idle is the courtesy
input (no recent client message); aging overrides it after
[TIDE_REPUBLISH_LANE_CONFIG]’s bound, the frontier never.
The worker-side deferred compute, additionally returning the
reverse-dependency refresh its selector build produced — the loop
applies it from the completion channel, which is what keeps the
loop-side memo fresh WITHOUT the loop ever building a selector.
Evaluate the workspace-republish settle gate; on flush, run the follow-up
executor over the flushed demand’s targets. M2 keeps the per-file
deferred executor verbatim and completes the tide at flush time — the
executor swap to the off-loop generation-checked wave is exclusively M3
(rfcs#111 §12).
Compact workspace status for the client’s status surface. Change-driven:
the loop sends omena/status only when this tuple moves, so the wire
cost is bounded by real state transitions, not by tick rate.