feat(S9/S8): bank-generation change-detection + instrument-side assignment reader

Extension stamps a monotonic bank_generation counter, bumped at content
mutations; the VST3 instrument polls it off-thread on an editor timer and
consumes assignment requests, refreshing playback hands-free.

src/vst/reasampler_processor.cpp

@@ -17,8 +17,10 @@
 
 #include "public.sdk/source/vst/vstbus.h"  // Vst::AudioBus::setArrangement (S7 output arr)
 
+#include "assignment_request.h"  // decodeAssignmentRequest (S8 request wire parse)
+#include "bank_sync.h"       // S9/S8 pure decisions: parseBankGeneration, consumeDecision
 #include "capture_paths.h"   // resolveBankFile (shared M4 path resolution)
-#include "ext_keys.h"        // kProjExtBanksKey (shared wire contract)
+#include "ext_keys.h"        // kProjExtBanksKey / kProjExtBankGenKey / kProjExtAssignKey (shared wire contract)
 #include "reasampler_editor.h"
 #include "reasampler_embed.h"  // S6 embed shell + IReaperUIEmbedInterface (its iid DEF'd there)
 #include "sample_map.h"       // selectSample, resolvePerformance, buildZonedKeymap, state (de)ser
@@ -184,6 +186,12 @@ tresult PLUGIN_API ReaSamplerProcessor::setState(IBStream* state) {
     const ComponentState cs = deserializeComponentState(bytes);
     setSelectedSampleId(cs.selectionId);
     setPerformanceMap(cs.map);
+    // S8: restore the last-consumed assignment generation so a re-open does not re-apply a
+    // stale assign_request (the user may have manually changed the selection after the assign).
+    {
+        std::lock_guard<std::mutex> lock(assignMarkerMutex_);
+        lastConsumedAssignGeneration_ = cs.lastConsumedAssignGeneration;
+    }
     // Restore the S7 channel mode and point the output bus at its arrangement so a reopened
     // project comes back in the saved mode. setState runs before the host queries bus info, so
     // seeding the arrangement here (rather than re-negotiating) is enough — no restartComponent.
@@ -208,6 +216,10 @@ tresult PLUGIN_API ReaSamplerProcessor::getState(IBStream* state) {
     state_out.selectionId = selectedSampleId();
     state_out.map = performanceMap();
     state_out.channelMode = channelMode();  // S7: persist the per-instance mono/stereo mode
+    {
+        std::lock_guard<std::mutex> lock(assignMarkerMutex_);
+        state_out.lastConsumedAssignGeneration = lastConsumedAssignGeneration_;  // S8 reader marker
+    }
     const std::vector<std::uint8_t> bytes = serializeComponentState(state_out);
     if (!bytes.empty()) {
         const tresult wr = state->write(const_cast<std::uint8_t*>(bytes.data()),
@@ -392,6 +404,79 @@ std::string ReaSamplerProcessor::reloadFromBank() {
     return resolvedId;
 }
 
+ReaSamplerProcessor::BankSyncResult
+ReaSamplerProcessor::pollBankSync(bool isFocusedTarget) {
+    // OFF THE AUDIO THREAD (the editor's UI timer calls this). Both reads allocate and call
+    // REAPER via the bridge — never invoked from process(). A disconnected bridge (non-REAPER
+    // host, or before connect) yields nullopt for both reads, so this no-ops cleanly.
+    BankSyncResult result;
+
+    // --- S8: assignment-request consume FIRST -------------------------------------
+    // Decode the pending assignment request (nullopt when absent/malformed). Resolve its
+    // (bankId, sampleId) against the live bank blob: selectSample returns non-nullopt only when
+    // the sampleId names an existing sample (the reader requirement — an unresolvable pair is
+    // dropped). Then run the pure consume decision against this instance's persisted marker.
+    std::optional<AssignmentRequest> request;
+    if (auto raw = bridge_.readReasamplerExtState(kProjExtAssignKey)) {
+        request = decodeAssignmentRequest(*raw);
+    }
+
+    bool resolves = false;
+    if (request) {
+        // Resolve the assigned sample against the CURRENT bank blob (a fresh read, so a request
+        // whose sample was rolled back by an extension undo resolves to nullopt -> dropped).
+        if (auto banksJson = bridge_.readReasamplerExtState(kProjExtBanksKey)) {
+            resolves = selectSample(*banksJson, request->sampleId).has_value();
+        }
+    }
+
+    std::int64_t lastConsumed = 0;
+    {
+        std::lock_guard<std::mutex> lock(assignMarkerMutex_);
+        lastConsumed = lastConsumedAssignGeneration_;
+    }
+    const AssignConsumeDecision decision =
+        consumeDecision(request, lastConsumed, resolves, isFocusedTarget);
+
+    // Advance the persisted consumed marker whenever the decision consumed the request
+    // (applied OR dropped-as-seen). getState will persist it on the next project save so a
+    // re-open does not re-apply. A non-target instance leaves the marker (decision returns it
+    // unchanged) so it stays eligible if focus later lands here.
+    if (decision.consumedGeneration != lastConsumed) {
+        std::lock_guard<std::mutex> lock(assignMarkerMutex_);
+        lastConsumedAssignGeneration_ = decision.consumedGeneration;
+    }
+
+    if (decision.apply) {
+        // Apply the assignment as this instance's own selection (the same path a user card-pick
+        // takes) — the instrument updates its OWN state, never the bank. reloadFromBank below
+        // rebuilds against the new selection, so skip a redundant reload here.
+        setSelectedSampleId(decision.sampleId);
+        result.applied = true;
+    }
+
+    // --- S9: bank-generation change-detection -------------------------------------
+    // Read the generation stamp; parse (absent/malformed -> 0, the pre-S9 default). FIRST poll
+    // (lastSeenBankGeneration_ == -1 sentinel): BASELINE the seen value without a reload — setState
+    // already loaded the current bank, so a redundant reload on open would only churn. A later
+    // generation CHANGE (a recapture/ingest/remove, or an undo that lowers it) then drives the
+    // reload. An assignment we just applied also needs a reload; fold both into ONE (coalesced).
+    std::int64_t currentGen = kBankGenerationAbsent;
+    if (auto rawGen = bridge_.readReasamplerExtState(kProjExtBankGenKey)) {
+        currentGen = parseBankGeneration(*rawGen);
+    }
+    const bool firstPoll = (lastSeenBankGeneration_ < 0);
+    const bool genChanged =
+        !firstPoll && bankGenerationChanged(lastSeenBankGeneration_, currentGen);
+    lastSeenBankGeneration_ = currentGen;
+
+    if (genChanged || result.applied) {
+        reloadFromBank();  // atomic pointer-swap handoff — glitch-free mid-play (S4 graveyard)
+        result.reloaded = genChanged;  // report S9 vs S8 distinctly for the editor's reaction
+    }
+    return result;
+}
+
 tresult PLUGIN_API ReaSamplerProcessor::process(ProcessData& data) {
     // REAL-TIME: no allocation, no IO, no locks. Load the live instrument once for the
     // whole block (a single atomic acquire), then publish inst->installedAt so the off-