Module runner 

The history-run seam — the async RUN machine behind a trait, mirroring the platform-seam shape of brep-app/src/store.rs’s ModelStore (a trait with impls behind it, async surfaced via a poll idiom).

A history run is split SUBMIT → POLL/APPLY: HistoryRunner::submit_run kicks off a run tagged with a monotonic generation, and the completed RunReply is drained later via HistoryRunner::poll_run. The runner OWNS the SceneRunner — so a future thread/worker impl owns the resident registry that execute_history populates — and holds the delta baseline across reruns.

This slice ships the DEFAULT InlineRunner: it runs on submit_run and stashes the reply for an immediate poll_run, so the run stays synchronous and byte-identical to the pre-seam in-process run. A native-thread impl (M2b) and a wasm-worker impl (M3) slot in behind the SAME trait — submit_run defers the work and poll_run surfaces it a frame (or many) later, so the EngineState::pump caller never changes.

Structs

InlineRunner

The default, SYNCHRONOUS runner: runs on submit, stashes the reply for an immediate poll. Behavior-identical to the pre-seam in-process run.

MeasureQuery

A per-object MEASUREMENT request routed to the runner (which owns the warm registry). The runner resolves owner to its resident handle and measures by kind; the reply is the object-info JSON fragment MINUS the main-injected name/creatingFeature fields. Tagged with a monotonic id so the main side can pair the reply with its pending request.

MeasureReply

A completed MeasureQuery: the object-info measurement fields as a JSON fragment (WITHOUT name/creatingFeature, which the main thread injects from its eager provenance), tagged with the request id.

MeshImportReply

Completed off-thread reconstruction. Success carries validated STEP and diagnostics for a preview or an ordinary IMPORT3D history insertion.

MeshImportRequest

A mesh reconstruction request. The byte payload moves to the native thread or is serialized to the browser worker; no parsing or fitting happens on UI.

RunProgress

A feature about to EXECUTE inside an in-flight run (cached replays are instant and are not reported): which one, of how many, under which generation. Posted by the runner before the kernel starts the feature, so the UI can name what it is waiting on — and, after a cancel, what it was waiting on.

RunReply

A completed history run, tagged with the generation it was submitted under so the applier can drop stale replies (a newer run that finished first). The output is the SceneRunner delta to apply to the display scene.

StepProbeReply

The probe’s answer: the parsed assembly (Some), no structure (None), or a parse failure. The assembly crosses back to the main side whole — its JSON is large (74 MB for the file above) but the trip costs a third of a second against the seconds the parse took.

StepProbeRequest

A STEP text to PROBE for product structure on the runner — the parse that brep_kernel::read_step_assembly performs, which builds every product’s bodies and takes seconds on a real assembly (8.3 s natively for a 5 MB, 140-product file), so it must not run on the browser’s main thread.

StlConversionOptions

Controls recognition and STEP topology construction.

StlConversionOutput

STEP text and its complete conversion report.

ThreadRunner

The persistent-thread runner. submit_*/reset push Commands down the channel; poll_* first DRAIN every ready Reply into the two demux buffers, then pop the matching one. The SceneRunner (and thus the kernel’s resident registry it warms) lives ENTIRELY on the thread — it is never shared — so the only cross-thread traffic is the Send command/reply payloads.

Enums

Command

A command sent main → runner (thread channel OR worker postMessage) over one ordered stream (so a Reset before a Run stays before it). Run carries the whole request; the driver coalesces consecutive Runs to shed a slider drag’s backlog (the thread in thread_main, the worker’s main side in WorkerRunner).

ConversionPolicy

Whether an unprovable analytic conversion may preserve the mesh as a repaired faceted STEP solid.

MeasureKind

Which exact measurement a MeasureQuery wants, mirroring the object-info kinds (crate::metadata): a whole solid, one named face, or one named edge.

MeshImportFormat

Mesh encoding accepted by the off-thread reconstruction channel.

Reply

A reply sent runner → main; the main side demuxes it into per-kind buffers.

Traits

HistoryRunner

The history-run seam: SUBMIT a run, POLL for its completed reply, RESET the delta baseline, plus a QUERY channel for per-object measurements (routed to the runner so the warm registry answers them, never the cold main-side one). The Inline impl runs everything synchronously; a later thread/worker impl defers the work and surfaces the replies through the same poll idiom.

Functions

process_command

Execute ONE Command against runner and return the Reply it produces, if any. The shared step both async drivers run: the native [thread_main] calls it for each (post-coalescing) command on the runner thread; the wasm WorkerRunner’s worker_entry calls it per postMessage on the worker. Run → a Reply::Run; Query → a Reply::Query; Reset drops the delta baseline AND the runner’s OWN kernel history cache (the resident registry lives with the runner — thread or worker — not on main) and yields no reply.