Stop the slicer before freeing what it is still reading

Loading an undo snapshot deletes every PartPlate, and the slicing thread keeps dereferencing its current plate and the status callback that captured it on every progress tick. Nothing stopped the process first, and Ctrl+Z does not go through can_undo() at all. undo_redo_to() now stops it, which is what the cancel button and the project reset already do. The cost is that undo during a slice waits for the next cancellation checkpoint, exactly like pressing Cancel. priv::reset() deleted the plates, and with them the Print and the GCodeResult, five lines before stopping the process, so the stop then ran on a freed Print. can_delete_plate() was missing the slicing guard its neighbour can_add_plate() has, and delete_plate() destroys the Print the worker is slicing. The grabber in the 3D scene does not go through the menu check, so the stop is in delete_plate() as well. OnEditingDone runs from ~wxDataViewCtrl while ~Plater is already running, where the Plater pointer is not null but the object behind it is gone, so a null check cannot catch it. It uses the shutdown flag the file already checks elsewhere. PrintBase::m_status_callback was a bare std::function reassigned by the UI thread while the worker invoked it, on the common path rather than a rare one: the callback is reinstalled on the running Print on every background process update. It is now assigned under a mutex and invoked as a copy with the lock released, so a callback that blocks cannot deadlock against the assignment. The shared timestamp counter is incremented under a different mutex per Print, and Orca keeps one Print per plate, which is what the FIXME above it anticipated. The plate drops its status callback where both it and the Print are still alive. The destructor cannot do it: delete_plate() destroys the Print first.
2026-10-03 05:41:10 +00:00 · 2026-10-01 09:15:48 +02:00
38 changed files with 344 additions and 1541 deletions
@@ -151,12 +151,6 @@ elseif(APPLE)
    # the post-install -add_rpath below.
    set(_python_ldflags "${_python_arch_flags} -Wl,-headerpad_max_install_names")

-    # The macOS 27 SDK declares pipe2() and dup3() as available from macOS 27, so
-    # configure finds them and CPython 3.12 calls them without a runtime check.
-    # Below a macOS 27 deployment target they are weak-linked and resolve to NULL
-    # on older systems, where os.pipe() then segfaults -- in `make install`
-    # (compileall, ensurepip) and in the shipped app alike. Every configure below
-    # keeps the pipe()/dup2() fallbacks (python/cpython#153711).
    if(IS_CROSS_COMPILE)
        set(_python_build_tgt --build=${_python_build_arch}-apple-darwin --host=${_python_host_arch}-apple-darwin)
        set(_python_build_arch_flags "-arch ${_python_build_arch_flag} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
@@ -180,8 +174,7 @@ elseif(APPLE)
                 --enable-shared \
                 --without-static-libpython \
                 --disable-test-modules \
-                 --build=${_python_build_arch}-apple-darwin \
-                 ac_cv_func_pipe2=no ac_cv_func_dup3=no && \
+                 --build=${_python_build_arch}-apple-darwin && \
             make -j${NPROC} python && \
             cd '<SOURCE_DIR>' && \
             env \
@@ -198,7 +191,6 @@ elseif(APPLE)
                 --without-static-libpython \
                 --with-openssl='${DESTDIR}' \
                 --disable-test-modules \
-                 ac_cv_func_pipe2=no ac_cv_func_dup3=no \
                 ${_python_build_tgt} \
                 --with-build-python='${_python_build_python}' \
                 py_cv_module__tkinter=n/a"
@@ -221,8 +213,6 @@ elseif(APPLE)
            --with-openssl=${DESTDIR}
            --disable-test-modules
            ${_python_build_tgt}
-            ac_cv_func_pipe2=no
-            ac_cv_func_dup3=no
            # Tcl/Tk 9.0 (e.g. from Homebrew) is incompatible with CPython 3.12's
            # _tkinter; OrcaSlicer's embedded Python does not need tkinter anyway.
            py_cv_module__tkinter=n/a
@@ -5,7 +5,6 @@
 //BBS
 #include "Preset.hpp"
 #include "Exception.hpp"
-#include "InstanceLock.hpp"
 #include "LocalesUtils.hpp"
 #include "Thread.hpp"
 #include "format.hpp"
@@ -744,13 +743,10 @@ static bool verify_config_file_checksum(boost::nowide::ifstream &ifs)


 #ifdef USE_JSON_CONFIG
-std::string AppConfig::load(bool read_only)
+std::string AppConfig::load()
 {
    json j;

-    // Keep another instance from replacing or restoring the file mid-read.
-    InstanceLock instance_lock(read_only ? std::string() : lock_path());
-
    // 1) Read the complete config file into a boost::property_tree.
    namespace pt = boost::property_tree;
    pt::ptree tree;
@@ -1000,6 +996,7 @@ void AppConfig::save()
    // The config is first written to a file with a PID suffix and then moved
    // to avoid race conditions with multiple instances of Slic3r
    const auto path = config_path();
+    std::string path_pid = (boost::format("%1%.%2%") % path % get_current_pid()).str();

    json j;

@@ -1129,18 +1126,43 @@ void AppConfig::save()

        j["local_machines"][local_machine.first] = m_json;
    }
-    const std::string config_str = j.dump(1, '\t');
-    if (write_config_file(path, config_str + "\n", config_str))
-        m_dirty = false;
+    boost::nowide::ofstream c;
+    c.open(path_pid, std::ios::out | std::ios::trunc);
+    c << j.dump(1, '\t') << std::endl;
+
+#ifdef WIN32
+    // WIN32 specific: The final "rename_file()" call is not safe in case of an application crash, there is no atomic "rename file" API
+    // provided by Windows (sic!). Therefore we save a MD5 checksum to be able to verify file corruption. In addition,
+    // we save the config file into a backup first before moving it to the final destination.
+    c << appconfig_md5_hash_line(j.dump(1, '\t'));
+#endif
+
+    c.close();
+    if (c.fail()) {
+      BOOST_LOG_TRIVIAL(error) << "Failed to write new configuration to " << path_pid << "; aborting attempt to overwrite original configuration";
+      return;
+    }
+
+#ifdef WIN32
+    // Make a backup of the configuration file before copying it to the final destination.
+    std::string error_message;
+    std::string backup_path = (boost::format("%1%.bak") % path).str();
+    // Copy configuration file with PID suffix into the configuration file with "bak" suffix.
+    if (copy_file(path_pid, backup_path, error_message, false) != SUCCESS)
+        BOOST_LOG_TRIVIAL(error) << "Copying from " << path_pid << " to " << backup_path << " failed. Failed to create a backup configuration.";
+#endif
+
+    // Rename the config atomically.
+    // On Windows, the rename is likely NOT atomic, thus it may fail if PrusaSlicer crashes on another thread in the meanwhile.
+    // To cope with that, we already made a backup of the config on Windows.
+    rename_file(path_pid, path);
+    m_dirty = false;
 }

 #else

-std::string AppConfig::load(bool read_only)
+std::string AppConfig::load()
 {
-    // Keep another instance from replacing or restoring the file mid-read.
-    InstanceLock instance_lock(read_only ? std::string() : lock_path());
-
    // 1) Read the complete config file into a boost::property_tree.
    namespace pt = boost::property_tree;
    pt::ptree tree;
@@ -1278,6 +1300,7 @@ void AppConfig::save()
    // The config is first written to a file with a PID suffix and then moved
    // to avoid race conditions with multiple instances of Slic3r
    const auto path = config_path();
+    std::string path_pid = (boost::format("%1%.%2%") % path % get_current_pid()).str();

    std::stringstream config_ss;
    if (m_mode == EAppMode::Editor)
@@ -1313,38 +1336,38 @@ void AppConfig::save()
    // One empty line before the MD5 sum.
    config_ss << std::endl;

-    const std::string config_str = config_ss.str();
-    if (write_config_file(path, config_str, config_str))
-        m_dirty = false;
-}
-#endif
-
-bool AppConfig::write_config_file(const std::string &path, std::string body, const std::string &checksum_source)
-{
-    // Everything before this is assembly; only the writes need the other instances kept out.
-    InstanceLock instance_lock(lock_path());
+    std::string config_str = config_ss.str();
+    boost::nowide::ofstream c;
+    c.open(path_pid, std::ios::out | std::ios::trunc);
+    c << config_str;
 #ifdef WIN32
-    // WIN32 specific: the final replace is not safe in case of an application crash, there is no atomic "rename file" API
+    // WIN32 specific: The final "rename_file()" call is not safe in case of an application crash, there is no atomic "rename file" API
    // provided by Windows (sic!). Therefore we save a MD5 checksum to be able to verify file corruption. In addition,
    // we save the config file into a backup first before moving it to the final destination.
-    body += appconfig_md5_hash_line(checksum_source);
+    c << appconfig_md5_hash_line(config_str);
 #endif
-    // Not flushed to the device: the idle handler saves on the GUI thread after
-    // any change, and the rename already gives a complete old or new file.
-    if (const std::error_code ec = write_file_atomically(path, body)) {
-        BOOST_LOG_TRIVIAL(error) << "Failed to write the configuration " << path << ": " << ec.message() << "; trying again in 10 s";
-        m_retry_save_at = std::chrono::steady_clock::now() + std::chrono::seconds(10);
-        return false;
+    c.close();
+    if (c.fail()) {
+      BOOST_LOG_TRIVIAL(error) << "Failed to write new configuration to " << path_pid << "; aborting attempt to overwrite original configuration";
+      return;
    }
-    m_retry_save_at = {};
+
 #ifdef WIN32
-    // Written after the config, so the backup never holds a state that was not confirmed written.
-    const std::string backup_path = (boost::format("%1%.bak") % path).str();
-    if (const std::error_code ec = write_file_atomically(backup_path, body))
-        BOOST_LOG_TRIVIAL(error) << "Failed to write the backup configuration " << backup_path << ": " << ec.message();
+    // Make a backup of the configuration file before copying it to the final destination.
+    std::string error_message;
+    std::string backup_path = (boost::format("%1%.bak") % path).str();
+    // Copy configuration file with PID suffix into the configuration file with "bak" suffix.
+    if (copy_file(path_pid, backup_path, error_message, false) != SUCCESS)
+        BOOST_LOG_TRIVIAL(error) << "Copying from " << path_pid << " to " << backup_path << " failed. Failed to create a backup configuration.";
 #endif
-    return true;
+
+    // Rename the config atomically.
+    // On Windows, the rename is likely NOT atomic, thus it may fail if PrusaSlicer crashes on another thread in the meanwhile.
+    // To cope with that, we already made a backup of the config on Windows.
+    rename_file(path_pid, path);
+    m_dirty = false;
 }
+#endif

 bool AppConfig::get_variant(const std::string &vendor, const std::string &model, const std::string &variant) const
 {
@@ -1834,11 +1857,6 @@ void AppConfig::reset_selections()
    }
 }

-std::string AppConfig::lock_path()
-{
-    return Slic3r::data_dir().empty() ? std::string() : config_path() + ".lock";
-}
-
 std::string AppConfig::config_path()
 {
 #ifdef USE_JSON_CONFIG
@@ -1875,7 +1893,7 @@ bool AppConfig::exists()

 std::string AppConfig::load_if_exists()
 {
-    return boost::filesystem::exists(loading_path()) ? load(/*read_only=*/true) : std::string();
+    return boost::filesystem::exists(loading_path()) ? load() : std::string();
 }

 }; // namespace Slic3r
@@ -2,7 +2,6 @@
 #define slic3r_AppConfig_hpp_

 #include <set>
-#include <chrono>
 #include <map>
 #include <string>
 #include "nlohmann/json.hpp"
@@ -123,18 +122,14 @@ public:

 	// Load the slic3r.ini from a user profile directory (or a datadir, if configured).
 	// Return an error string, or an empty string on success.
-	std::string         load(bool read_only = false);
+	std::string         load();
 	// Treat a missing config as default state; otherwise load it normally.
-	// The CLI's load: it never saves, so it takes no lock and creates no lock file.
 	std::string         load_if_exists();
 	// Store the slic3r.ini into a user profile directory (or a datadir, if configured).
 	void 			   	save();

 	// Does this config need to be saved?
 	bool 				dirty() const { return m_dirty; }
-	// False for ten seconds after a failed write, so the idle handler does not
-	// repeat a hopeless attempt on every event; an explicit save() always tries.
-	bool 				save_due() const { return std::chrono::steady_clock::now() >= m_retry_save_at; }


 	void				set_dirty() { m_dirty = true; }
@@ -344,8 +339,6 @@ public:

 	// Get the default config path from Slic3r::data_dir().
 	std::string			config_path();
-	// Lock file guarding config_path() against other running instances; empty without a data dir.
-	std::string			lock_path();

 	// Returns true if the user's data directory comes from before Slic3r 1.40.0 (no updating)
 	bool 				legacy_datadir() const { return m_legacy_datadir; }
@@ -456,16 +449,8 @@ private:

 	// Preset for each machine
 	MachineSettingMap											m_printer_settings;
-	// Writes the assembled config text, and on Windows its checksum and a backup copy; false when the
-	// config itself could not be written, in which case the caller stays dirty and retries. `checksum_source`
-	// is the text load() will verify, which for the JSON config ends before the trailing newline.
-	bool												write_config_file(const std::string &path, std::string body, const std::string &checksum_source);
-
 	// Has any value been modified since the config.ini has been last saved or loaded?
 	bool														m_dirty;
-	// After a failed write, save_due() is false for the next ten seconds, so the
-	// idle handler does not repeat a hopeless write on every event.
-	std::chrono::steady_clock::time_point						m_retry_save_at{};
 	// Original version found in the ini file before it was overwritten
 	Semver                                                      m_orig_version;
 	// Whether the existing version is before system profiles & configuration updating
@@ -306,8 +306,6 @@ set(lisbslic3r_sources
    Geometry/VoronoiUtils.cpp
    Geometry/VoronoiUtils.hpp
    Geometry/VoronoiVisualUtils.hpp
-    InstanceLock.cpp
-    InstanceLock.hpp
    Int128.hpp
    KDTreeIndirect.hpp
    Layer.cpp
@@ -1538,10 +1538,12 @@ void ConfigBase::save_to_json(const std::string &file, const std::string &name,
    // Serialize first: if that throws (invalid UTF-8), the existing file stays untouched.
    std::ostringstream ss;
    this->save_to_json(ss, name, from, version);
-    if (const std::error_code ec = write_file_atomically(file, ss.str()))
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to save config to %1%: %2%") % file % ec.message();
-    else
-        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
+    boost::nowide::ofstream c;
+    c.open(file, std::ios::out | std::ios::trunc);
+    c << ss.str();
+    c.close();
+
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
 }

 void ConfigBase::save_to_json(std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8) const
@@ -1,165 +0,0 @@
-#include "InstanceLock.hpp"
-
-#include <map>
-#include <memory>
-#include <system_error>
-#include <thread>
-
-#include <boost/filesystem.hpp>
-#include <boost/log/trivial.hpp>
-#include <boost/nowide/fstream.hpp>
-#ifdef _WIN32
-#include <boost/interprocess/sync/file_lock.hpp>
-#include <boost/nowide/convert.hpp>
-#else
-#include <cerrno>
-#include <fcntl.h>
-#include <sys/file.h>
-#include <unistd.h>
-#endif
-
-namespace Slic3r {
-
-#ifdef _WIN32
-// LockFileEx, held by this handle alone.
-using NativeFileLock = boost::interprocess::file_lock;
-#else
-// flock(2) rather than an fcntl lock: it belongs to this open file description,
-// so any other code in the process that opens and closes the lock file, as a
-// backup or an export walking the data dir might, cannot drop it. An fcntl
-// lock would go with the first such close.
-class NativeFileLock
-{
-public:
-    explicit NativeFileLock(const char *path) : m_fd(::open(path, O_RDWR | O_CREAT | O_CLOEXEC, 0644))
-    {
-        if (m_fd < 0)
-            throw std::system_error(errno, std::generic_category(), path);
-    }
-    ~NativeFileLock() { ::close(m_fd); }
-    bool try_lock()
-    {
-        if (::flock(m_fd, LOCK_EX | LOCK_NB) == 0)
-            return true;
-        // A signal (a child exiting, for one) interrupts the call like any other; the caller polls again.
-        if (errno == EWOULDBLOCK || errno == EINTR)
-            return false;
-        throw std::system_error(errno, std::generic_category(), "flock");
-    }
-    void unlock() { ::flock(m_fd, LOCK_UN); }
-private:
-    int m_fd;
-};
-#endif
-
-// One slot per lock file, shared by every guard in the process: one lock
-// object per path behind a mutex is what makes the guard re-entrant and safe
-// to use from the preset sync thread and the GUI thread at once. The lock
-// file is opened by the outermost guard and closed when it goes, so the file
-// is never held open between guards: whatever is at the path is what gets
-// locked, and a data dir can be removed once nothing is saving into it. The
-// file is kept rather than deleted on release because the lock state lives in
-// the kernel on the open file, and deleting it would let a third instance
-// lock a fresh file while the second still holds the old one.
-struct InstanceLock::Slot
-{
-    std::recursive_mutex mutex;
-    // Non-null exactly while this process holds the file lock.
-    std::unique_ptr<NativeFileLock> file_lock;
-    int  depth{0};
-    // Until this point, after a guard could not open, lock or wait out the
-    // file, guards do not touch it.
-    std::chrono::steady_clock::time_point cooldown_until{};
-};
-
-InstanceLock::Slot &InstanceLock::slot_for(const std::string &lock_file_path)
-{
-    // Never freed: a save during static destruction still needs its slot.
-    static auto *registry_mutex = new std::mutex();
-    static auto *registry       = new std::map<std::string, std::unique_ptr<Slot>>();
-
-    std::lock_guard<std::mutex> guard(*registry_mutex);
-    std::unique_ptr<Slot> &slot = (*registry)[lock_file_path];
-    if (! slot)
-        slot = std::make_unique<Slot>();
-    return *slot;
-}
-
-// Starts the cool-down. Called with the slot mutex held.
-void InstanceLock::defer(Slot &slot, const std::string &reason)
-{
-    slot.cooldown_until = std::chrono::steady_clock::now() + cooldown;
-    BOOST_LOG_TRIVIAL(warning) << reason << "; proceeding without the lock for the next " << cooldown.count() << " ms";
-}
-
-// Creates the lock file if needed and opens it, or starts the cool-down.
-// Called with the slot mutex held.
-bool InstanceLock::open_lock_file(Slot &slot, const std::string &lock_file_path)
-{
-    try {
-#ifdef _WIN32
-        // The lock opens an existing file; created once, on the first miss.
-        const std::wstring wide_path = boost::nowide::widen(lock_file_path);
-        try {
-            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
-        } catch (const std::exception &) {
-            boost::nowide::ofstream(lock_file_path, std::ios::app).close();
-            slot.file_lock = std::make_unique<NativeFileLock>(wide_path.c_str());
-        }
-#else
-        slot.file_lock = std::make_unique<NativeFileLock>(lock_file_path.c_str());
-#endif
-        return true;
-    } catch (const std::exception &e) {
-        defer(slot, "Cannot open lock file " + lock_file_path + ": " + e.what() + " (check its owner and permissions)");
-        return false;
-    }
-}
-
-InstanceLock::InstanceLock(const std::string &lock_file_path, std::chrono::milliseconds timeout)
-{
-    if (lock_file_path.empty())
-        return;
-    m_slot       = &slot_for(lock_file_path);
-    m_slot_guard = std::unique_lock<std::recursive_mutex>(m_slot->mutex);
-    const auto now = std::chrono::steady_clock::now();
-    if (m_slot->depth == 0 && now >= m_slot->cooldown_until && open_lock_file(*m_slot, lock_file_path)) {
-        const auto deadline = now + timeout;
-        bool       taken    = false;
-        for (;;) {
-            try {
-                if ((taken = m_slot->file_lock->try_lock()))
-                    break;
-            } catch (const std::exception &e) {
-                defer(*m_slot, "Cannot lock " + lock_file_path + ": " + e.what());
-                break;
-            }
-            if (std::chrono::steady_clock::now() >= deadline) {
-                defer(*m_slot, "Another instance has held " + lock_file_path + " for over " + std::to_string(timeout.count()) + " ms");
-                break;
-            }
-            std::this_thread::sleep_for(std::chrono::milliseconds(5));
-        }
-        if (! taken)
-            m_slot->file_lock.reset();
-    }
-    // Counted last, so a throw above leaves the slot exactly as it was found.
-    ++ m_slot->depth;
-    m_locked = m_slot->file_lock != nullptr;
-}
-
-InstanceLock::~InstanceLock()
-{
-    if (m_slot == nullptr)
-        return;
-    if (-- m_slot->depth == 0 && m_slot->file_lock) {
-        try {
-            m_slot->file_lock->unlock();
-        } catch (const std::exception &e) {
-            BOOST_LOG_TRIVIAL(warning) << "Cannot unlock instance lock: " << e.what();
-        }
-        m_slot->file_lock.reset();
-    }
-}
-
-} // namespace Slic3r
@@ -1,60 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <mutex>
-#include <string>
-
-namespace Slic3r {
-
-// Scoped write lock on a file shared by every running instance of the
-// application, such as the app config or the user preset directory: threads
-// of this process are serialised through a recursive mutex, other processes
-// through an advisory OS file lock on `lock_file_path`. The lock file is
-// created on first use and kept; the OS releases the lock when its holder
-// exits, so a crashed instance never leaves a stale lock behind.
-//
-// Best effort: when the lock file cannot be opened or locked, or another
-// instance still holds it after `timeout`, the guard keeps only the in-process
-// mutex, locked() reports false and the write proceeds, since a hung instance
-// must never block another one from saving. For `cooldown` afterwards guards
-// leave the file alone. The wait for the in-process mutex is bounded only by
-// the longest critical section, so a guard covers a few file operations and
-// nothing slower.
-//
-// Lock order: the preset collection mutex may be held when a guard is taken
-// (set_sync_info_and_save() calls save_info() under it), never the reverse;
-// that is why the guards sit at the leaf readers and writers and why a guard
-// must not be added around save_user_presets(), which takes the collection
-// mutex through delete_preset().
-class InstanceLock
-{
-public:
-    // Long against a critical section of milliseconds, short against the GUI
-    // thread, which is where most guards are taken.
-    static constexpr std::chrono::milliseconds default_timeout{1000};
-    // Long enough that a holder stuck in a debugger does not cost a stall per
-    // save; mutable so tests can shorten it.
-    static inline std::chrono::milliseconds cooldown{10000};
-
-    // An empty path makes the guard a no-op.
-    explicit InstanceLock(const std::string &lock_file_path, std::chrono::milliseconds timeout = default_timeout);
-    ~InstanceLock();
-
-    InstanceLock(const InstanceLock &) = delete;
-    InstanceLock &operator=(const InstanceLock &) = delete;
-
-    // True while this process holds the cross-process file lock.
-    bool locked() const { return m_locked; }
-
-private:
-    struct Slot;
-    static Slot &slot_for(const std::string &lock_file_path);
-    static bool  open_lock_file(Slot &slot, const std::string &lock_file_path);
-    static void  defer(Slot &slot, const std::string &reason);
-
-    Slot *m_slot{nullptr};
-    std::unique_lock<std::recursive_mutex> m_slot_guard;
-    bool  m_locked{false};
-};
-
-} // namespace Slic3r
@@ -51,9 +51,6 @@
 #include "libslic3r.h"
 #include "LifecycleEvents.hpp"
 #include "Utils.hpp"
-#include "InstanceLock.hpp"
-
-#include <sstream>
 #include "Time.hpp"
 #include "PlaceholderParser.hpp"
 #include "libslic3r/GCode/Thumbnails.hpp"
@@ -110,32 +107,6 @@ std::string get_preset_canonical_name(const std::string &preset_bare_name, const
    }
 }

-std::string user_presets_lock_path(bool read_only)
-{
-    return read_only || data_dir().empty() ? std::string() : (fs::path(data_dir()) / (PRESET_USER_DIR ".lock")).string();
-}
-
-// Removes a preset file the scan could not load, and its .info, under the lock.
-// The scan passes read_only when it could not take the lock, since the file may
-// then be another instance's fresh write that it merely raced.
-static void remove_preset_files(const std::string &preset_file, bool read_only)
-{
-    if (read_only)
-        return;
-    InstanceLock instance_lock(user_presets_lock_path());
-    // A symlink whose target is missing stays, since the target may come back; one
-    // that cannot even be followed is removed like any other unreadable file.
-    auto remove = [](const fs::path &file) {
-        boost::system::error_code ec;
-        if (fs::status(file, ec).type() != fs::file_not_found)
-            fs::remove(file, ec);
-    };
-    fs::path file_path(preset_file);
-    remove(file_path);
-    file_path.replace_extension(".info");
-    remove(file_path);
-}
-
 std::string get_preset_bare_name(const std::string &canonical_name)
 {
    const auto pos = canonical_name.find_last_of('/');
@@ -678,20 +649,18 @@ void Preset::save_info(std::string file)
        file = idx_file.string();
    }

+    boost::nowide::ofstream c;
+    c.open(file, std::ios::out | std::ios::trunc);
    std::string sync_info_to_save;
    //BBS: hold is used for stop requesting to server this time
    if (this->sync_info.compare("hold") != 0)
        sync_info_to_save = this->sync_info;
-    std::ostringstream c;
    c << "sync_info" << " = " << sync_info_to_save << std::endl;
    c << "user_id" << " = " << this->user_id << std::endl;
    c << "setting_id" << " = " << this->setting_id << std::endl;
    c << "base_id" << " = " << this->base_id << std::endl;
    c << "updated_time" << " = " << std::to_string(this->updated_time) << std::endl;
-
-    InstanceLock instance_lock(user_presets_lock_path());
-    if (const std::error_code ec = write_file_atomically(file, c.str()))
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to save " << file << ": " << ec.message();
+    c.close();
 }

 void Preset::remove_files(bool cloud_already_deleted)
@@ -700,7 +669,6 @@ void Preset::remove_files(bool cloud_already_deleted)
    if (this->is_project_embedded) {
        return;
    }
-    InstanceLock instance_lock(user_presets_lock_path());
    // Erase the preset file.
    boost::nowide::remove(this->file.c_str());
    fs::path idx_path(this->file);
@@ -718,11 +686,11 @@ void Preset::remove_files(bool cloud_already_deleted)
 }

 //BBS: add logic for only difference save
-bool Preset::save(DynamicPrintConfig* parent_config)
+void Preset::save(DynamicPrintConfig* parent_config)
 {
    //BBS: add project embedded preset logic
    if (this->is_project_embedded)
-        return true;
+        return;
    //BBS: change to json format
    //this->config.save(this->file);
    std::string from_str;
@@ -737,16 +705,12 @@ bool Preset::save(DynamicPrintConfig* parent_config)
    else
        from_str = std::string("Default");

+    boost::filesystem::create_directories(fs::path(this->file).parent_path());
    const std::string bare_name = get_preset_bare_name(this->name);

-    // What gets written: the diff against the parent, the config plus its
-    // filament id, or the config as is. Built before the lock is taken so the
-    // exclusive window covers only the file writes.
-    DynamicPrintConfig        temp_config;
-    const DynamicPrintConfig *to_save = &this->config;
-
    //BBS: only save difference if it has parent
    if (parent_config) {
+        DynamicPrintConfig temp_config;
        std::vector<std::string> dirty_options = config.diff(*parent_config);

        std::string extruder_id_name, extruder_variant_name;
@@ -782,22 +746,13 @@ bool Preset::save(DynamicPrintConfig* parent_config)
                    opt_dst->set(opt_src);
            }
        }
-        to_save = &temp_config;
+        temp_config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
    } else if (!filament_id.empty() && inherits().empty()) {
-        temp_config = config;
+        DynamicPrintConfig temp_config = config;
        temp_config.set_key_value(BBL_JSON_KEY_FILAMENT_ID, new ConfigOptionString(filament_id));
-        to_save = &temp_config;
-    }
-
-    std::ostringstream json;
-    to_save->save_to_json(json, bare_name, from_str, this->version.to_string());
-
-    InstanceLock instance_lock(user_presets_lock_path());
-    boost::filesystem::create_directories(fs::path(this->file).parent_path());
-    if (const std::error_code ec = write_file_atomically(this->file, json.str())) {
-        // No .info either: one without its preset reads as a cloud deletion request.
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to save " << this->file << ": " << ec.message();
-        return false;
+        temp_config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
+    } else {
+        this->config.save_to_json(this->file, bare_name, from_str, this->version.to_string());
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " save config for: " << this->name << " and filament_id: " << filament_id << " and base_id: " << this->base_id;

@@ -807,7 +762,6 @@ bool Preset::save(DynamicPrintConfig* parent_config)
        idx_file.replace_extension(".info");
        this->save_info(idx_file.string());
    }
-    return true;
 }

 void Preset::reload(Preset const &parent)
@@ -819,7 +773,6 @@ void Preset::reload(Preset const &parent)
    std::string                        reason;
    ForwardCompatibilitySubstitutionRule substitution_rule    = ForwardCompatibilitySubstitutionRule::Disable;
    try {
-        InstanceLock instance_lock(user_presets_lock_path());
        ConfigSubstitutions                config_substitutions = config.load_from_json(file, substitution_rule, key_values, reason);
        this->config = parent.config;
        this->config.apply(std::move(config));
@@ -1749,22 +1702,6 @@ std::string PresetCollection::canonical_preset_name(const std::string &name, con
    return get_preset_canonical_name(parsed.bare, origin);
 }

-PresetCollection::PresetFilesOnDisk PresetCollection::PresetFilesOnDisk::read(const boost::filesystem::path &file)
-{
-    auto read_if_present = [](const fs::path &path) -> std::optional<std::string> {
-        std::string bytes;
-        try {
-            load_string_file(path, bytes);
-        } catch (const std::exception &) {
-            return std::nullopt;
-        }
-        return bytes;
-    };
-    fs::path info_path(file);
-    info_path.replace_extension(".info");
-    return { read_if_present(file), read_if_present(info_path) };
-}
-
 PresetCollection::UserPresetLoad PresetCollection::resolve_user_preset(
    const boost::filesystem::path &file, const std::string &canonical_name,
    const PresetOrigin &load_origin, ForwardCompatibilitySubstitutionRule substitution_rule,
@@ -1776,9 +1713,6 @@ PresetCollection::UserPresetLoad PresetCollection::resolve_user_preset(
    Preset &preset = out.preset;
    preset.bundle_id = load_origin.bundle_id;
    preset.file = file.string();
-    // Before either file is parsed, so a save that lands during the parse still shows
-    // up as a difference when commit compares.
-    out.on_disk = PresetFilesOnDisk::read(file);
    // Load the preset file, apply preset values on top of defaults.
    try {
        fs::path idx_path(preset.file);
@@ -1891,8 +1825,14 @@ void PresetCollection::commit_user_preset(UserPresetLoad &&loaded, std::deque<Pr
        ++m_errors;
        BOOST_LOG_TRIVIAL(error) << error;
    }
-    if (loaded.discard_file)
-        remove_preset_files(loaded.preset.file, read_only);
+    if (loaded.discard_file && !read_only) {
+        fs::path file_path(loaded.preset.file);
+        if (fs::exists(file_path))
+            fs::remove(file_path);
+        file_path.replace_extension(".info");
+        if (fs::exists(file_path))
+            fs::remove(file_path);
+    }
    if (!loaded.install)
        return;

@@ -1900,12 +1840,9 @@ void PresetCollection::commit_user_preset(UserPresetLoad &&loaded, std::deque<Pr
        if (loaded.save_compatible_printers) {
            // A filesystem error from the rewrite is counted, and the preset still loads.
            try {
-                if (read_only)
-                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name << " (not written back)";
-                else if (preset.save(nullptr))
-                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name;
-                else
-                    ++m_errors; // save() logged why
+                if (!read_only)
+                    preset.save(nullptr);
+                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name;
            } catch (const std::runtime_error &err) {
                ++m_errors;
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " can not write compatible_printers back to " << preset.file << ": " << err.what();
@@ -1991,32 +1928,11 @@ void PresetCollection::load_presets(
            return this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
                                             extruder_id_name, extruder_variant_name, key_set1, key_set2);
        },
-        [&](size_t i, UserPresetLoad &&loaded) {
-            // Resolve read the files without the lock, so another instance may have saved
-            // over them since. A file that changed is resolved again under the lock before
-            // commit removes or rewrites it, which also keeps its .json and .info from two
-            // different saves apart. Without the lock nothing is checked, so commit leaves
-            // the files alone.
-            const std::string lock_path = user_presets_lock_path(read_only);
-            InstanceLock      instance_lock(lock_path);
-            if (instance_lock.locked()) {
-                const PresetFilesOnDisk   on_disk = PresetFilesOnDisk::read(files[i].path);
-                boost::system::error_code ec;
-                // The link itself, and a stat error counts as present, so a file that is
-                // there but cannot be read is still counted and removed by commit.
-                if (! on_disk.json && fs::symlink_status(files[i].path, ec).type() == fs::file_not_found)
-                    return; // removed by another instance since it was read
-                if (! (on_disk == loaded.on_disk)) {
-                    CNumericLocalesSetter locales_setter;
-                    loaded = this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
-                                                       extruder_id_name, extruder_variant_name, key_set1, key_set2);
-                }
-            }
-            const bool leave_files = read_only || (! lock_path.empty() && ! instance_lock.locked());
+        [&](size_t, UserPresetLoad &&loaded) {
            // Committing can remove an unreadable preset's file, and a filesystem error
            // there is reported without stopping the rest of the directory.
            try {
-                this->commit_user_preset(std::move(loaded), presets_loaded, substitutions, preset_loaded_fn, leave_files);
+                this->commit_user_preset(std::move(loaded), presets_loaded, substitutions, preset_loaded_fn, read_only);
            } catch (const std::runtime_error &err) {
                errors_cummulative += err.what();
                errors_cummulative += "\n";
@@ -2326,10 +2242,7 @@ void PresetCollection::set_sync_info_and_save(std::string name, std::string sett
            preset->setting_id = setting_id;
            if (update_time > 0)
                preset->updated_time = update_time;
-            if (preset->sync_info == "update")
-                preset->save(nullptr);
-            else
-                preset->save_info();
+            preset->sync_info == "update" ? preset->save(nullptr) : preset->save_info();
            break;
        }
    }
@@ -4398,15 +4311,8 @@ void PhysicalPrinter::update_preset_names_in_config()
    }
 }

-void PhysicalPrinter::save(DynamicPrintConfig* /* parent_config */)
-{
-    InstanceLock instance_lock(user_presets_lock_path());
-    this->config.save_to_json(this->file, std::string("Physical_Printer"), std::string("User"), std::string(SLIC3R_VERSION));
-}
-
 void PhysicalPrinter::save(const std::string& file_name_from, const std::string& file_name_to)
 {
-    InstanceLock instance_lock(user_presets_lock_path());
    // rename the file
    boost::nowide::rename(file_name_from.data(), file_name_to.data());
    this->file = file_name_to;
@@ -4538,7 +4444,6 @@ void PhysicalPrinterCollection::load_printers(
                continue;
            }
            try {
-                InstanceLock instance_lock(user_presets_lock_path());
                PhysicalPrinter printer(name, this->default_config());
                printer.file = dir_entry.path().string();
                // Load the preset file, apply preset values on top of defaults.
@@ -4731,10 +4636,7 @@ bool PhysicalPrinterCollection::delete_printer(const std::string& name)

    const PhysicalPrinter& printer = *it;
    // Erase the preset file.
-    {
-        InstanceLock instance_lock(user_presets_lock_path());
-        boost::nowide::remove(printer.file.c_str());
-    }
+    boost::nowide::remove(printer.file.c_str());
    m_printers.erase(it);
    return true;
 }
@@ -4746,10 +4648,7 @@ bool PhysicalPrinterCollection::delete_selected_printer()
    const PhysicalPrinter& printer = this->get_selected_printer();

    // Erase the preset file.
-    {
-        InstanceLock instance_lock(user_presets_lock_path());
-        boost::nowide::remove(printer.file.c_str());
-    }
+    boost::nowide::remove(printer.file.c_str());
    // Remove the preset from the list.
    m_printers.erase(m_printers.begin() + m_idx_selected);
    // unselect all printers
@@ -8,7 +8,6 @@
 #include <unordered_set>
 #include <functional>
 #include <mutex>
-#include <optional>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/property_tree/ptree_fwd.hpp>
@@ -331,8 +330,7 @@ public:

    //BBS: add logic for only difference save
    //if parent_config is null, save all keys, otherwise, only save difference
-    // Returns false when the preset file could not be written.
-    bool                save(DynamicPrintConfig* parent_config);
+    void                save(DynamicPrintConfig* parent_config);
    void                reload(Preset const & parent);

    // Return a label of this preset, consisting of a name and a "(modified)" suffix, if this preset is dirty.
@@ -499,12 +497,6 @@ std::string get_preset_canonical_name(const std::string &preset_bare_name, const
 // Tail segment of a canonical name — what's written to the bundle's .json filename and JSON "name" field.
 std::string get_preset_bare_name(const std::string &canonical_name);

-// Lock file guarding every user preset file under data_dir() against other
-// running instances and the preset sync thread. Empty without a data dir, and
-// for a read-only load (the CLI), which never rewrites or deletes and may run
-// many jobs on one data dir.
-std::string user_presets_lock_path(bool read_only = false);
-
 // Resolve an origin from a directory path when the caller passes Kind::Auto.
 PresetOrigin detect_origin_from_path(const boost::filesystem::path &path, const PresetOrigin &explicit_origin = PresetOrigin());

@@ -914,16 +906,6 @@ protected:
    void            set_custom_preset_alias(Preset &preset);

 private:
-    // A preset file and its .info as read from disk, std::nullopt for one that is missing.
-    struct PresetFilesOnDisk
-    {
-        std::optional<std::string> json;
-        std::optional<std::string> info;
-
-        static PresetFilesOnDisk read(const boost::filesystem::path &file);
-        bool operator==(const PresetFilesOnDisk &rhs) const { return json == rhs.json && info == rhs.info; }
-    };
-
    // One preset file read and flattened against the presets already in this
    // collection, before anything the collection shares has been touched.
    struct UserPresetLoad
@@ -941,9 +923,6 @@ private:
        bool        discard_file { false };
        // The .info file read beside the preset, which commit logs.
        std::string info_file;
-        // Both files as they were before the preset was read from them. Resolve runs
-        // without the instance lock, so commit compares this with the disk under it.
-        PresetFilesOnDisk on_disk;
        // Counted and logged by commit, in the order the directory listed the files.
        std::vector<std::string>   errors;
        PresetsConfigSubstitutions substitutions;
@@ -1132,7 +1111,7 @@ public:

    //BBS: change to json format
    //void                save() { this->config.save(this->file); }
-    void                save(DynamicPrintConfig* parent_config);
+    void                save(DynamicPrintConfig* parent_config) { this->config.save_to_json(this->file, std::string("Physical_Printer"), std::string("User"), std::string(SLIC3R_VERSION)); }
    void                save(const std::string& file_name_from, const std::string& file_name_to);

    void                update_from_preset(const Preset& preset);
@@ -1,4 +1,3 @@
-#include <atomic>
 #include <cassert>
 #include <chrono>
 #include <ctime>
@@ -14,7 +13,6 @@
 #include "libslic3r.h"
 #include "I18N.hpp"
 #include "Utils.hpp"
-#include "InstanceLock.hpp"
 #include "LocalesUtils.hpp"
 #include "Model.hpp"
 #include "TriangleSelector.hpp"
@@ -1274,13 +1272,6 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For

    const auto user_load_t0 = std::chrono::steady_clock::now();

-    // Reads one bundle's metadata under the lock, per file, so the lock is never
-    // held when bundles.WriteLock() is taken afterwards.
-    auto load_bundle_metadata = [read_only](const fs::path &metadata_file, BundleMetadata &metadata) {
-        InstanceLock instance_lock(user_presets_lock_path(read_only));
-        return metadata.load_from_json(metadata_file.string());
-    };
-
    // Load bundle metadata from _local directory first
    fs::path local_dir(folder / PRESET_LOCAL_DIR);
    if (fs::exists(local_dir)) {
@@ -1294,7 +1285,7 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
            if (!fs::exists(metadata_file)) continue;

            BundleMetadata metadata;
-            if (!load_bundle_metadata(metadata_file, metadata)) continue;
+            if (!metadata.load_from_json(metadata_file.string())) continue;
            metadata.print_presets.clear();
            metadata.filament_presets.clear();
            metadata.printer_presets.clear();
@@ -1329,7 +1320,7 @@ PresetsConfigSubstitutions PresetBundle::load_user_presets(std::string user, For
            if (!fs::exists(metadata_file)) continue;

            BundleMetadata metadata;
-            if (!load_bundle_metadata(metadata_file, metadata)) continue;
+            if (!metadata.load_from_json(metadata_file.string())) continue;
            metadata.print_presets.clear();
            metadata.filament_presets.clear();
            metadata.printer_presets.clear();
@@ -1663,12 +1654,10 @@ PresetsConfigSubstitutions PresetBundle::import_presets(std::vector<std::string>
            if (ec) BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << ec.message();
            //create temp folder
            //std::string user_default_temp_dir = data_dir() + "/" + PRESET_USER_DIR + "/" + DEFAULT_USER_FOLDER_NAME + "/" + "temp";
-            // Under cache/, per process and per import, so two instances importing
-            // at once do not clear each other's extraction and no preset scan reads it.
-            static std::atomic<unsigned> import_counter{0};
-            fs::path temp_folder(fs::path(data_dir()) / "cache" / ("import." + std::to_string(get_current_pid()) + "." + std::to_string(import_counter++)));
+            fs::path temp_folder(configs_folder / "temp");
            std::string user_default_temp_dir = temp_folder.make_preferred().string();
-            fs::create_directories(temp_folder, ec);
+            if (fs::exists(temp_folder)) fs::remove_all(temp_folder);
+            fs::create_directory(temp_folder, ec);
            if (ec) BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << ec.message();

            file = boost::filesystem::path(file).make_preferred().string();
@@ -1680,9 +1669,6 @@ PresetsConfigSubstitutions PresetBundle::import_presets(std::vector<std::string>
            status        = mz_zip_reader_init_cfile(&zip_archive, zipFile, 0, MZ_ZIP_FLAG_CASE_SENSITIVE | MZ_ZIP_FLAG_IGNORE_PATH);
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Failed to initialize reader ZIP archive";
-                if (zipFile != nullptr)
-                    std::fclose(zipFile);
-                fs::remove_all(temp_folder, ec);
                return substitutions;
            } else {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Success to initialize reader ZIP archive";
@@ -2290,9 +2276,10 @@ void PresetBundle::remove_user_presets_directory(const std::string preset_folder
        return;
    }
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, delete directory : %1%") % dir_user_presets;
-    boost::system::error_code ec;
-    InstanceLock instance_lock(user_presets_lock_path());
-    fs::remove_all(fs::path(dir_user_presets), ec);
+    fs::path folder(dir_user_presets);
+    if (fs::exists(folder)) {
+        fs::remove_all(folder);
+    }
 }

 void PresetBundle::update_system_preset_setting_ids(std::map<std::string, std::map<std::string, std::string>>& system_presets)
@@ -8226,13 +8213,9 @@ bool BundleMetadata::save_to_json(const std::string& path) const
        j["filament_presets"] = strip_prefix(this->filament_presets);                                                                                                                                                                                                                       
        j["printer_presets"] = strip_prefix(this->printer_presets);

-        const std::string content = j.dump(4);
-        InstanceLock instance_lock(user_presets_lock_path());
-        if (const std::error_code ec = write_file_atomically(path, content)) {
-            BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << ec.message();
-            return false;
-        }
-        return true;
+        boost::nowide::ofstream ofs(path);
+        ofs << j.dump(4);
+        return ofs.good();
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "Failed to save bundle metadata to " << path << ": " << e.what();
        return false;
@@ -400,24 +400,46 @@ bool write_cache_blob(const std::string& path, const std::string& blob)
 {
    boost::crc_32_type crc;
    crc.process_bytes(blob.data(), blob.size());
-    // Written beside the target and moved into place: a cache is truncated and
-    // rewritten in full, so a write that dies partway would otherwise leave a
-    // header claiming more body than the file holds.
+    // Written beside the target and moved into place, as AppConfig::save does:
+    // a cache is truncated and rewritten in full, so a write that dies partway
+    // would otherwise leave a header claiming more body than the file holds.
+    // The PID suffix also keeps two instances writing the same vendor from
+    // interleaving.
+    const std::string tmp_path = path + "." + std::to_string(get_current_pid()) + ".tmp";
    try {
        boost::filesystem::create_directories(boost::filesystem::path(path).parent_path());
-        CacheFileHeader fhdr;
-        fhdr.magic     = CACHE_MAGIC;
-        fhdr.version   = CACHE_VERSION;
-        fhdr.data_size = static_cast<uint64_t>(blob.size());
-        fhdr.crc32     = crc.checksum();
-        const std::string_view header(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
-        if (const std::error_code ec = write_file_atomically(path, { header, std::string_view(blob) }, /*binary=*/true)) {
-            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << ec.message();
+        {
+            boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
+            if (!ofs.is_open()) {
+                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: cannot open for writing: " << tmp_path;
+                return false;
+            }
+            CacheFileHeader fhdr;
+            fhdr.magic     = CACHE_MAGIC;
+            fhdr.version   = CACHE_VERSION;
+            fhdr.data_size = static_cast<uint64_t>(blob.size());
+            fhdr.crc32     = crc.checksum();
+            ofs.write(reinterpret_cast<const char*>(&fhdr), sizeof(fhdr));
+            ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
+            ofs.close();   // flush; close() raises failbit on error
+            if (! ofs.good()) {
+                BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << tmp_path << ")";
+                boost::system::error_code ec;
+                boost::filesystem::remove(tmp_path, ec);
+                return false;
+            }
+        }
+        if (const std::error_code ec = rename_file(tmp_path, path)) {
+            BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: could not move " << tmp_path << " into place: " << ec.message();
+            boost::system::error_code rm;
+            boost::filesystem::remove(tmp_path, rm);
            return false;
        }
        return true;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(warning) << "VendorCacheFile: write failed (" << path << "): " << e.what();
+        boost::system::error_code ec;
+        boost::filesystem::remove(tmp_path, ec);
        return false;
    }
 }
@@ -19,7 +19,7 @@ void PrintTryCancel::operator()()
    m_print->throw_if_canceled();
 }

-size_t PrintStateBase::g_last_timestamp = 0;
+std::atomic<size_t> PrintStateBase::g_last_timestamp{0};

 // Update "scale", "input_filename", "input_filename_base", "first_object_name" placeholders from the current m_objects.
 void PrintBase::update_object_placeholders(DynamicConfig &config, const std::string &default_ext) const
@@ -107,11 +107,26 @@ std::string PrintBase::output_filepath(const std::string &path, const std::strin
    return path;
 }

+void PrintBase::set_status_callback(status_callback_type cb)
+{
+    std::scoped_lock<std::mutex> lock(m_status_callback_mutex);
+    m_status_callback = std::move(cb);
+}
+
+// Returns a copy, so that the callback is invoked with m_status_callback_mutex released: the callback
+// may block on the UI thread, which in turn may be assigning a new callback.
+PrintBase::status_callback_type PrintBase::status_callback() const
+{
+    std::scoped_lock<std::mutex> lock(m_status_callback_mutex);
+    return m_status_callback;
+}
+
 //BBS: move set_status from hpp to cpp
 void  PrintBase::set_status(int percent, const std::string &message, unsigned int flags, int warning_step) const
 {
-	if (m_status_callback)
-        m_status_callback(SlicingStatus(percent, message, flags, warning_step));
+    status_callback_type status_callback = this->status_callback();
+    if (status_callback)
+        status_callback(SlicingStatus(percent, message, flags, warning_step));
    else
        BOOST_LOG_TRIVIAL(debug) <<boost::format("Percent %1%: %2%\n")%percent %message.c_str();
 }
@@ -119,9 +134,10 @@ void  PrintBase::set_status(int percent, const std::string &message, unsigned in
 void PrintBase::status_update_warnings(int step, PrintStateBase::WarningLevel  warning_level,
    const std::string &message, const PrintObjectBase* print_object, PrintStateBase::SlicingNotificationType message_id)
 {
-    if (this->m_status_callback) {
+    status_callback_type status_callback = this->status_callback();
+    if (status_callback) {
        auto status = print_object ? SlicingStatus(*print_object, step, message, message_id, warning_level) : SlicingStatus(*this, step, message, message_id, warning_level);
-        m_status_callback(status);
+        status_callback(status);
    }
    else if (! message.empty())
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Print warning: %1%\n")% message.c_str();
@@ -132,8 +148,9 @@ void PrintBase::status_update_warnings(int step, PrintStateBase::WarningLevel wa
    const std::string& message, PrintObjectBase &object, PrintStateBase::SlicingNotificationType message_id)
 {
    //BBS: add object it into slicing status
-    if (this->m_status_callback) {
-        m_status_callback(SlicingStatus(object, step, message, message_id, warning_level));
+    status_callback_type status_callback = this->status_callback();
+    if (status_callback) {
+        status_callback(SlicingStatus(object, step, message, message_id, warning_level));
    }
    else if (!message.empty())
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", PrintObject warning: %1%\n")% message.c_str();
@@ -99,10 +99,9 @@ public:
    };

 protected:
-    //FIXME last timestamp is shared between Print & SLAPrint,
-    // and if multiple Print or SLAPrint instances are executed in parallel, modification of g_last_timestamp
-    // is not synchronized!
-    static size_t g_last_timestamp;
+    // The last timestamp is shared between all the Print & SLAPrint instances, and Orca keeps one Print
+    // per PartPlate, so it is incremented under different state mutexes: it has to be atomic.
+    static std::atomic<size_t> g_last_timestamp;
 };

 // To be instantiated over PrintStep or PrintObjectStep enums.
@@ -473,11 +472,12 @@ public:
    };
    typedef std::function<void(const SlicingStatus&)>  status_callback_type;
    // Default status console print out in the form of percent => message.
-    void                    set_status_default() { m_status_callback = nullptr; }
+    void                    set_status_default() { this->set_status_callback(nullptr); }
    // No status output or callback whatsoever, useful mostly for automatic tests.
-    void                    set_status_silent() { m_status_callback = [](const SlicingStatus&){}; }
-    // Register a custom status callback.
-    void                    set_status_callback(status_callback_type cb) { m_status_callback = cb; }
+    void                    set_status_silent() { this->set_status_callback([](const SlicingStatus&){}); }
+    // Register a custom status callback. Called from the UI thread while the worker thread may be
+    // invoking the previous callback, therefore guarded by m_status_callback_mutex.
+    void                    set_status_callback(status_callback_type cb);
    // Calls a registered callback to update the status, or print out the default message.
    void                    set_status(int percent, const std::string &message, unsigned int flags = SlicingStatus::DEFAULT, int warning_step = -1) const;

@@ -563,7 +563,10 @@ protected:
    std::string m_plate_name;

    // Callback to be evoked regularly to update state of the UI thread.
+    // Guarded by m_status_callback_mutex, always invoke the copy returned by status_callback().
    status_callback_type                    m_status_callback;
+    mutable std::mutex                      m_status_callback_mutex;
+    status_callback_type                    status_callback() const;

 private:
    std::atomic<CancelStatus>               m_cancel_status;
@@ -8,8 +8,6 @@
 #include <functional>
 #include <type_traits>
 #include <system_error>
-#include <initializer_list>
-#include <string_view>
 #include <regex>

 #include <boost/system/error_code.hpp>
@@ -226,21 +224,6 @@ extern std::vector<std::string> split_string(const std::string &str, char delimi
 // On Windows, the file explorer (or anti-virus or whatever else) often locks the file
 // for a short while, so the file may not be movable. Retry while we see recoverable errors.
 extern std::error_code rename_file(const std::string &from, const std::string &to);
-// Write `chunks`, in order, to `path` through a temporary file beside it that is
-// then renamed over the target, so a concurrent reader sees the old or the new
-// file, never a partial one. The temporary is removed on failure and an existing
-// target keeps its permissions. Text mode unless `binary`, so Windows writes CRLF
-// as the streams this replaces did. A target that is not a regular file (a
-// device or pipe) is written in place, since replacing it would change what it
-// is, and so is an existing target beside which no temporary can be created or
-// whose replace the filesystem refuses; a symlink is followed and the file it
-// names is replaced. On Windows a reader holding the
-// target open without sharing its deletion, which the C runtime does not, makes
-// the replace fall back to the in-place write too, so an unlocked reader there
-// can still see a partial file.
-extern std::error_code write_file_atomically(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary = false);
-inline std::error_code write_file_atomically(const std::string &path, const std::string &content, bool binary = false)
-	{ return write_file_atomically(path, { std::string_view(content) }, binary); }

 enum CopyFileResult {
 	SUCCESS = 0,
@@ -9,8 +9,6 @@
 #include <stdio.h>
 #include <filesystem>
 #include <sstream>
-#include <cerrno>
-#include <mutex>
 #include <iomanip>
 #include <algorithm>
 #include <cmath>
@@ -705,99 +703,13 @@ namespace WindowsSupport
 std::error_code rename_file(const std::string &from, const std::string &to)
 {
 #ifdef _WIN32
-	// Retries and moves an open destination aside itself.
 	return WindowsSupport::rename(from, to);
 #else
-	// rename(2) replaces an existing target atomically; removing it first would
-	// leave a window in which the file does not exist at all.
-	if (boost::nowide::rename(from.c_str(), to.c_str()) == 0)
-		return {};
-	const int err = errno;
-	// Some mounts (sshfs, gvfs, MTP and a few SMB setups) refuse to replace an
-	// existing target in one step, each with the error it sees fit; every error
-	// is worth the remove-then-rename this always did, except the ones no retry
-	// can help: nothing at the source, a different device, or a directory where
-	// a file was expected and the reverse.
-	const bool worth_retrying = err != ENOENT && err != EXDEV && err != ENOTDIR && err != EISDIR;
-	if (worth_retrying && boost::nowide::remove(to.c_str()) == 0 && boost::nowide::rename(from.c_str(), to.c_str()) == 0)
-		return {};
-	return std::make_error_code(static_cast<std::errc>(err));
+	boost::nowide::remove(to.c_str());
+	return std::make_error_code(static_cast<std::errc>(boost::nowide::rename(from.c_str(), to.c_str())));
 #endif
 }

-static std::error_code write_whole_file(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
-{
-	errno = 0;
-	FILE *file = boost::nowide::fopen(path.c_str(), binary ? "wb" : "w");
-	if (file == nullptr)
-		return std::make_error_code(errno != 0 ? static_cast<std::errc>(errno) : std::errc::io_error);
-	bool ok = true;
-	for (const std::string_view chunk : chunks)
-		ok = ok && std::fwrite(chunk.data(), 1, chunk.size(), file) == chunk.size();
-	ok = ok && std::fflush(file) == 0;
-	const int err = ok ? 0 : errno;
-	ok = std::fclose(file) == 0 && ok;
-	if (ok)
-		return {};
-	return std::make_error_code(err != 0 ? static_cast<std::errc>(err) : std::errc::io_error);
-}
-
-// The in-place fallback truncates the target, so two threads of this process
-// on the same file must not both be in it. One mutex for all such writes: they
-// are the rare case. Never freed, like the InstanceLock registry, so a save
-// during static destruction still finds it.
-static std::error_code write_in_place(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
-{
-	static auto *mutex = new std::mutex();
-	std::lock_guard<std::mutex> guard(*mutex);
-	return write_whole_file(path, chunks, binary);
-}
-
-std::error_code write_file_atomically(const std::string &path, std::initializer_list<std::string_view> chunks, bool binary)
-{
-	boost::system::error_code bec;
-	const boost::filesystem::file_status target = boost::filesystem::symlink_status(path, bec);
-	const bool target_exists = ! bec && boost::filesystem::exists(target);
-	if (target_exists && boost::filesystem::is_symlink(target)) {
-		// A config or preset kept in a dotfiles repository: the link stays,
-		// the file it points to is replaced like any other.
-		const boost::filesystem::path resolved = boost::filesystem::canonical(path, bec);
-		if (! bec && boost::filesystem::is_regular_file(resolved, bec))
-			return write_file_atomically(resolved.string(), chunks, binary);
-	}
-	if (target_exists && ! boost::filesystem::is_regular_file(target))
-		return write_in_place(path, chunks, binary);
-
-	// Unique per process and per call, so two threads writing one target
-	// without a lock never share a temporary.
-	static std::atomic<unsigned> counter{0};
-	const std::string tmp_path = path + "." + std::to_string(get_current_pid()) + "." + std::to_string(counter++) + ".tmp";
-	if (const std::error_code ec = write_whole_file(tmp_path, chunks, binary)) {
-		boost::nowide::remove(tmp_path.c_str());
-		if (! target_exists)
-			return ec;
-		// A directory that lets this process write its files but not create
-		// one: losing the save is worse than a reader seeing a partial file.
-		BOOST_LOG_TRIVIAL(warning) << "Cannot create a temporary beside " << path << " (" << ec.message() << "); writing in place";
-		return write_in_place(path, chunks, binary);
-	}
-#ifndef _WIN32
-	// Not on Windows, where a read-only bit on the temporary would stop the rename itself.
-	if (target_exists)
-		boost::filesystem::permissions(tmp_path, target.permissions(), bec);
-#endif
-	if (const std::error_code ec = rename_file(tmp_path, path)) {
-		boost::nowide::remove(tmp_path.c_str());
-		// A reader on Windows holding the target open without FILE_SHARE_DELETE,
-		// or a mount that cannot replace a file at all. Losing the save is worse
-		// than a reader seeing a partial file, so write in place the way this
-		// used to work before the atomic path existed.
-		BOOST_LOG_TRIVIAL(warning) << "Cannot replace " << path << " (" << ec.message() << "); writing in place";
-		return write_in_place(path, chunks, binary);
-	}
-	return {};
-}
-
 #ifdef __linux__
 // Copied from boost::filesystem.
 // Called by copy_file_linux() in case linux sendfile() API is not supported.
@@ -87,7 +87,6 @@
 #include "libslic3r/Model.hpp"
 #include "libslic3r/I18N.hpp"
 #include "libslic3r/PresetBundle.hpp"
-#include "libslic3r/InstanceLock.hpp"
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/miniz_extension.hpp"
 #include "libslic3r/Utils.hpp"
@@ -3557,7 +3556,7 @@ bool GUI_App::on_init_inner()
            update_publish_status();
        }

-        if (m_post_initialized && app_config->dirty() && app_config->save_due())
+        if (m_post_initialized && app_config->dirty())
            app_config->save();

    });
@@ -7652,11 +7651,8 @@ void GUI_App::start_sync_user_preset(bool with_progress_dlg)

                            // Delete the bundle folder and bundle
                            fs::path bundle_folder = fs::path(bundle.path.c_str()).parent_path();
-                            {
-                                boost::system::error_code ec;
-                                InstanceLock instance_lock(user_presets_lock_path());
-                                boost::filesystem::remove_all(bundle_folder, ec);
-                            }
+                            boost::system::error_code ec;
+                            boost::filesystem::remove_all(bundle_folder, ec);

                            preset_bundle->bundles.WriteLock();
                            preset_bundle->bundles.m_bundles.erase(bundle.id);
@@ -8948,7 +8944,6 @@ void GUI_App::preset_deleted_from_cloud(std::string setting_id)

    // Delete the .info file after cloud deletion is confirmed
    if (!preset_file_path.empty() && fs::exists(fs::path(preset_file_path))) {
-        InstanceLock instance_lock(user_presets_lock_path());
        boost::nowide::remove(preset_file_path.c_str());
        BOOST_LOG_TRIVIAL(info) << "Deleted .info file after cloud confirmation: " << preset_file_path;
    }
@@ -9011,19 +9006,15 @@ void GUI_App::scan_orphaned_info_files()
            fs::path preset_file = info_file;
            preset_file.replace_extension(".json");

-            // If .json doesn't exist, .info is orphaned. Read under the lock, so a
-            // remove_files() in another instance is seen whole or not at all; the
-            // delete queue's own mutex is taken after the lock is released.
-            std::string setting_id;
-            {
-                InstanceLock instance_lock(user_presets_lock_path());
-                if (!fs::exists(preset_file))
-                    setting_id = extract_setting_id_from_info(info_file.string());
-            }
-            if (!setting_id.empty()) {
-                // Add to need_delete_presets
-                delete_preset_from_cloud(setting_id, info_file.string());
-                BOOST_LOG_TRIVIAL(info) << "Found orphaned .info file on startup: " << info_file.string();
+            // If .json doesn't exist, .info is orphaned
+            if (!fs::exists(preset_file)) {
+                // Extract setting_id from .info file
+                std::string setting_id = extract_setting_id_from_info(info_file.string());
+                if (!setting_id.empty()) {
+                    // Add to need_delete_presets
+                    delete_preset_from_cloud(setting_id, info_file.string());
+                    BOOST_LOG_TRIVIAL(info) << "Found orphaned .info file on startup: " << info_file.string();
+                }
            }
        }
        if (ec)
@@ -6693,6 +6693,11 @@ void ObjectList::OnEditingStarted(wxDataViewEvent &event)

 void ObjectList::OnEditingDone(wxDataViewEvent &event)
 {
+    // ~wxDataViewCtrl ends the in-place editing, so this handler runs while ~Plater is already tearing
+    // the Plater down. Nothing below may touch the Plater or the plates any more.
+    if (wxGetApp().is_closing())
+        return;
+
    if (event.GetColumn() != colName)
        return;

@@ -3572,6 +3572,8 @@ void PartPlate::update_slice_result_valid_state(bool valid)
 //update current slice context into backgroud slicing process
 void PartPlate::update_slice_context(BackgroundSlicingProcess & process)
 {
+	//this callback outlives the call, so it is dropped again in PartPlateList::clear() and
+	//PartPlateList::delete_plate() before the plate is destroyed
 	auto statuscb = [this](const Slic3r::PrintBase::SlicingStatus& status) {
 		Slic3r::SlicingStatusEvent *event = new Slic3r::SlicingStatusEvent(EVT_SLICING_UPDATE, 0, status);
 		//BBS: GUI refactor: add plate info befor message
@@ -4543,7 +4545,14 @@ void PartPlateList::clear(bool delete_plates, bool release_print_list, bool exce
 		else
 			plate->clear();
 		if (delete_plates)
+		{
+			//the slicing status callback installed by update_slice_context() captures the plate, so drop it
+			//while the Print is still alive: the prints are only released below, after this loop, and are
+			//not released at all when release_print_list is false.
+			if (Print* print = plate->fff_print())
+				print->set_status_default();
 			delete plate;
+		}
 	}

 	if (delete_plates)
@@ -4886,6 +4895,10 @@ int PartPlateList::delete_plate(int index)
 	//destroy the print object
 	int print_index;
 	plate->get_print(nullptr, nullptr, &print_index);
+	//the slicing status callback installed by update_slice_context() captures the plate, and destroy_print()
+	//frees the Print, so drop the callback here, the last point where both are still alive.
+	if (Print* print = plate->fff_print())
+		print->set_status_default();
 	destroy_print(print_index);

 	delete plate;
@@ -103,7 +103,6 @@
 #include "Selection.hpp"
 #include "GLToolbar.hpp"
 #include "GUI_Preview.hpp"
-#include "UVEditorCanvas.hpp"
 #include "3DBed.hpp"
 #include "PartPlate.hpp"
 #include "Camera.hpp"
@@ -1798,14 +1797,11 @@ bool Sidebar::priv::switch_diameter_to(const wxString &diameter)
    Preset& printer_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
    // The combo lists printer variants, and the variant of a mixed-nozzle machine ("0.4+0.6") is no
    // single extruder's diameter, so the preset's own variant answers first.
-    const std::string &printer_variant = printer_preset.config.opt_string("printer_variant");
-    if (printer_variant == diameter.ToStdString()) {
+    if (printer_preset.config.opt_string("printer_variant") == diameter.ToStdString()) {
        return true;
    }
-    // A named variant ("0.4 High Flow") shares its diameter with the standard profile, which selecting
-    // the plain diameter switches back to, so only a preset naming no variant is kept by its diameter.
    auto* nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(printer_preset.config.option("nozzle_diameter"));
-    if (printer_variant.empty() && nozzle_diameter && nozzle_diameter->size() > 0) {
+    if (nozzle_diameter && nozzle_diameter->size() > 0) {
        auto current_nozzle_dia = get_diameter_string(nozzle_diameter->values[0]);
        // If the selected diameter is the same as current nozzle, don't switch profiles
        if (current_nozzle_dia == diameter.ToStdString()) {
@@ -2240,14 +2236,12 @@ bool Sidebar::priv::sync_extruder_list(bool &only_external_material, bool is_man
    std::string machine_print_name = obj->get_show_printer_type();
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    std::string target_model_id  = preset_bundle->printers.get_selected_preset().get_printer_type(preset_bundle);
-    const bool optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type);
-    const bool optional_target_model  = DevPrinterConfigUtil::is_optional_printer_model_id(target_model_id);
-    Preset* machine_preset = optional_printer_model ? nullptr : get_printer_preset(obj);
-    if (!optional_printer_model && !optional_target_model && !machine_preset) {
+    Preset* machine_preset = get_printer_preset(obj);
+    if (!machine_preset) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "check error: machine_preset empty";
        return false;
    }
-    if (!optional_printer_model && !optional_target_model && machine_print_name != target_model_id) {
+    if (machine_print_name != target_model_id) {
        MessageDialog dlg(this->plater, _L("The currently selected machine preset is inconsistent with the connected printer type.\n"
                                            "Are you sure to continue syncing?"), _L("Sync printer information"), wxICON_WARNING | wxYES | wxNO);
        if (dlg.ShowModal() == wxID_NO) {
@@ -2439,11 +2433,6 @@ void Sidebar::priv::update_sync_status(const MachineObject *obj)
        return;
    }

-    if (DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type)) {
-        clear_all_sync_status();
-        return;
-    }
-
    bool printer_synced = false;
    // 1. update printer status
    const Preset &cur_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
@@ -3937,18 +3926,13 @@ void Sidebar::update_presets(Preset::Type preset_type)
            combo_flow->Show(combo_flow->GetCount() > 0);
        };

-        auto update_extruder_diameter = [&diameters, &nozzle_diameter, &diameter](int extruder_index,ExtruderGroup & extruder) {
+        auto update_extruder_diameter = [&diameters, &nozzle_diameter](int extruder_index,ExtruderGroup & extruder) {
            extruder.combo_diameter->Clear();
            if (extruder_index >= int(nozzle_diameter->values.size()))
                return;
            int select = -1;
            // ORCA get the actual nozzle diameter from printer config
            auto nozzle_dia = get_diameter_string(nozzle_diameter->values[extruder_index]);
-            // Named variants such as "0.4HS" and "0.4 High Flow" share a physical diameter.
-            // Retain the variant selection unless the diameter was customized.
-            const bool keep_variant = diameter.substr(0, diameter.find_first_not_of("0123456789.")) == nozzle_dia &&
-                                      std::find(diameters.begin(), diameters.end(), diameter) != diameters.end();
-            const std::string &selected_variant = keep_variant ? diameter : nozzle_dia;
            // ORCA try to add nozzle diameter from config if list is empty. fixes blank nozzle combo box when preset has no alias
            if(!diameters.empty() && diameters[0].empty() && !nozzle_dia.empty()){
                diameters[0] = nozzle_dia;
@@ -3958,7 +3942,7 @@ void Sidebar::update_presets(Preset::Type preset_type)
                diameters.push_back(nozzle_dia);
            }
            for (size_t i = 0; i < diameters.size(); ++i) {
-                if (diameters[i] == selected_variant)
+                if (diameters[i] == nozzle_dia)
                    select = extruder.combo_diameter->GetCount();
                extruder.combo_diameter->Append(diameters[i], {});
            }
@@ -6082,30 +6066,11 @@ void Sidebar::load_ams_list(MachineObject* obj)
        filament_ams_list = build_filament_ams_list(obj);
    }

+    bool device_change     = false;
    const std::string& device = obj ? obj->get_dev_id() : "";
-    const bool same_device = p->ams_list_device == device;
-
-    // Keep sync metadata out of the device payload, but preserve it across a
-    // subscription refresh when the physical filament in a slot is unchanged.
-    // Otherwise the refreshed configs differ only by the missing
-    // filament_changed key, causing combo boxes to rebuild and lose their
-    // transient post-sync badges.
-    auto &previous_filament_ams_list = wxGetApp().preset_bundle->filament_ams_list;
-    for (auto &entry : filament_ams_list) {
-        auto previous = previous_filament_ams_list.find(entry.first);
-        const auto *previous_changed = previous == previous_filament_ams_list.end() ? nullptr :
-                                       dynamic_cast<const ConfigOptionBool *>(previous->second.option("filament_changed"));
-        if (!same_device || previous_changed == nullptr ||
-            previous->second.opt_string("filament_id", 0u) != entry.second.opt_string("filament_id", 0u)) {
-            continue;
-        }
-        entry.second.set_key_value("filament_changed",
-                                   new ConfigOptionBool{previous_changed->value});
-    }
-
-    bool device_change     = !same_device;
-    if (device_change) {
+    if (p->ams_list_device != device) {
        p->ams_list_device = device;
+        device_change      = true;
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% items") % filament_ams_list.size();
    if (wxGetApp().preset_bundle->filament_ams_list == filament_ams_list && !device_change)
@@ -6115,27 +6080,9 @@ void Sidebar::load_ams_list(MachineObject* obj)
    wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;

    for (auto c : p->combos_filament){
-        c->set_sync_badge(false);
        c->update();
-    }
-
-    if (!device_change) {
-        size_t combo_index = 0;
-        for (const auto &entry : filament_ams_list) {
-            const auto &tray = entry.second;
-            const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
-            const bool is_placeholder = tray.has("filament_slot_placeholder") &&
-                                         tray.opt_bool("filament_slot_placeholder", 0u);
-            if (!has_filament && !is_placeholder) {
-                continue;
-            }
-            if (combo_index >= p->combos_filament.size()) {
-                break;
-            }
-            const auto *filament_changed = dynamic_cast<const ConfigOptionBool *>(tray.option("filament_changed"));
-            p->combos_filament[combo_index]->set_sync_badge(
-                has_filament && !is_placeholder && filament_changed != nullptr && filament_changed->value);
-            ++combo_index;
+        if (device_change) {
+            c->ShowBadge(false);//change printer,then clear badge
        }
    }

@@ -6309,32 +6256,18 @@ void Sidebar::sync_ams_list(bool is_from_big_sync_btn)
        auto tip     = sync_color_only ? _L("Only filament color information has been synchronized from printer.") :
                                         _L("Filament type and color information have been synchronized, but slot information is not included.");
        c->SetToolTip(tip);
-        c->set_sync_badge(true);
+        c->ShowBadge(true);
    };
    { // badge ams filament
        clear_combos_filament_badge();
        if (sync_result.direct_sync) {
-            // A placeholder contributes a preserved project filament to the
-            // overwrite result, but it is not AMS-sourced and must not get a
-            // sync badge. Non-placeholder empty trays are omitted entirely.
-            size_t combo_index = 0;
-            for (const auto &entry : wxGetApp().preset_bundle->filament_ams_list) {
-                const auto &tray = entry.second;
-                const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
-                const bool is_placeholder = tray.has("filament_slot_placeholder") &&
-                                             tray.opt_bool("filament_slot_placeholder", 0u);
-                if (!has_filament && !is_placeholder) {
-                    continue;
-                }
-                if (combo_index >= p->combos_filament.size()) {
-                    break;
-                }
-                if (is_placeholder) {
-                    p->combos_filament[combo_index]->set_sync_badge(false);
-                } else {
-                    badge_combox_filament(p->combos_filament[combo_index]);
-                }
-                ++combo_index;
+            // Orca: PresetBundle::sync_ams_list rebuilds combos_filament
+            // 1:1 from the AMS trays that produce a combo (loaded trays + placeholders; non-placeholder
+            // empty trays are skipped), so every resulting combo is AMS-sourced and gets a badge. The
+            // previous per-tray index walked the full filament_ams_list (including the skipped empties),
+            // so an empty slot before a loaded one dropped the badge for the trailing filaments.
+            for (auto &c : p->combos_filament) {
+                badge_combox_filament(c);
            }
        }
    }
@@ -6602,11 +6535,6 @@ template<typename T> void setup_dialog_position(T& info)

 void Sidebar::pop_sync_nozzle_and_ams_dialog() {
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " begin pop_sync_nozzle_and_ams_dialog";
-    auto agent = wxGetApp().getAgent();
-    if (!agent || agent->get_filament_sync_mode() == FilamentSyncMode::none) {
-        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament synchronization is not supported; skipping dialog";
-        return;
-    }
    wxTheApp->CallAfter([this]() {
        SyncNozzleAndAmsDialog::InputInfo temp_na_info;
        wxPoint                           big_btn_pt;
@@ -6738,14 +6666,17 @@ void Sidebar::clear_combos_filament_badge()
 {
    auto &combos_filament = p->combos_filament;
    for (auto &c : combos_filament) { // clear flag
-        c->set_sync_badge(false);
+        c->ShowBadge(false);
    }
 }

 void Sidebar::udpate_combos_filament_badge() {
    auto &combos_filament = p->combos_filament;
    for (auto &c : combos_filament) {
-        c->update_badge_according_flag();
+        auto selection   = c->GetSelection();
+        auto select_flag = c->GetFlag(selection);
+        auto ok          = select_flag == (int) PresetComboBox::FilamentAMSType::FROM_AMS;
+        c->ShowBadge(ok);
    }

 }
@@ -7117,13 +7048,6 @@ struct Plater::priv
    GLToolbar collapse_toolbar;
    Preview *preview;
    AssembleView* assemble_view { nullptr };
-    // Docked/resizable 2D pane showing GLGizmoTextureDisplacement's LSCM unwrap of a painted
-    // patch; a sibling AUI pane alongside "sidebar"/"main", not part of the view3D/preview/
-    // assemble_view sizer - see its registration below and Plater::get_uv_editor_canvas(). The
-    // pane hosts the panel (toolbar + canvas + status line); uv_editor_canvas is its inner canvas,
-    // cached so the gizmo can reach it directly.
-    UVEditorPanel*  uv_editor_panel { nullptr };
-    UVEditorCanvas* uv_editor_canvas { nullptr };
    bool first_enter_assemble{ true };
    std::unique_ptr<NotificationManager> notification_manager;

@@ -7373,8 +7297,6 @@ struct Plater::priv

    void undo();
    void redo();
-    // True, and tells the user, while a background job is working on the model - see the definition.
-    bool undo_redo_blocked_by_job();
    void undo_redo_to(size_t time_to_load);

    // BBS: backup
@@ -7828,26 +7750,6 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
                                   .BottomDockable(false)
                                   .BestSize(wxSize(39 * wxGetApp().em_unit(), 90 * wxGetApp().em_unit())));

-    // UV editor pane for GLGizmoTextureDisplacement's LSCM unwrap preview - a resizable/dockable
-    // sibling of "sidebar"/"main" like everything else registered on this same AUI manager, not a
-    // change to the view3D/preview/assemble_view sizer above. Hidden by default: only relevant
-    // while that gizmo is active with a layer using the "Unwrap (LSCM)" projection method (see
-    // Plater::show_uv_editor()), so it stays out of the way of everyone else's window layout.
-    uv_editor_panel  = new UVEditorPanel(q);
-    uv_editor_canvas = uv_editor_panel->canvas();
-    m_aui_mgr.AddPane(uv_editor_panel, wxAuiPaneInfo()
-                                            .Name("uv_editor")
-                                            .Caption(_L("UV Editor"))
-                                            .Right()
-                                            .Hide()
-                                            .BestSize(wxSize(40 * wxGetApp().em_unit(), 40 * wxGetApp().em_unit())));
-    // Closing the pane with its own X has to reach the gizmo, or its next update would simply show the pane again.
-    q->Bind(wxEVT_AUI_PANE_CLOSE, [this](wxAuiManagerEvent &evt) {
-        evt.Skip();
-        if (evt.GetPane() != nullptr && evt.GetPane()->window == uv_editor_panel && uv_editor_canvas != nullptr)
-            uv_editor_canvas->run_command(UVEditorCanvas::Command::PaneClosed);
-    });
-
    auto* panel_sizer = new wxBoxSizer(wxHORIZONTAL);
    panel_sizer->Add(view3D, 1, wxEXPAND | wxALL, 0);
    panel_sizer->Add(preview, 1, wxEXPAND | wxALL, 0);
@@ -7889,13 +7791,6 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
                BOOST_LOG_TRIVIAL(info) << "Removed floating AUI state from saved window layout for Wayland";
            }

-            // The UV editor is a transient, gizmo-driven pane (see show_uv_editor()); a saved layout
-            // from a session that happened to close with it open would otherwise restore it visible on
-            // startup, with nothing painted in it. Force it hidden here so it only ever appears when the
-            // texture-displacement gizmo asks for it.
-            if (wxAuiPaneInfo &uv_pane = m_aui_mgr.GetPane("uv_editor"); uv_pane.IsOk())
-                uv_pane.Hide();
-
            sidebar_layout.is_collapsed = !sidebar.IsShown();
        }

@@ -10744,13 +10639,15 @@ void Plater::priv::reset(bool apply_presets_change, bool reload_presets)

    m_worker.cancel_all();

+    // Stop and reset the Print content. m_worker.cancel_all() only stops the UI jobs, so this has to
+    // happen before reinit() deletes the plates together with the Print the slicing thread may still
+    // be working on.
+    this->background_process.reset();
+
    //BBS: clear the partplate list's object before object cleared
    partplate_list.reinit();
    partplate_list.update_slice_context_to_current_plate(background_process);
    preview->update_gcode_result(partplate_list.get_current_slice_result());
-
-    // Stop and reset the Print content.
-    this->background_process.reset();
    model.clear_objects();
    // clear_objects() only drops the ModelObjects; the CAD recipe is Model-level state and would
    // otherwise be written into every project saved for the rest of the session.
@@ -12766,7 +12663,7 @@ void Plater::priv::on_select_preset(wxCommandEvent &evt)
            sidebar->auto_calc_flushing_volumes(idx);
        }
        auto select_flag = combo->GetFlag(selection);
-        combo->set_sync_badge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
+        combo->ShowBadge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
        q->on_filament_change(idx);
    }
    bool select_preset = !combo->selection_is_changed_according_to_physical_printers();
@@ -15038,25 +14935,8 @@ void Plater::priv::take_snapshot(const std::string& snapshot_name, const UndoRed
    BOOST_LOG_TRIVIAL(info) << "Undo / Redo snapshot taken: " << snapshot_name << ", Undo / Redo stack memory: " << Slic3r::format_memsize_MB(this->undo_redo_stack().memsize()) << log_memory_info();
 }

-// A background job holds the model it is working on: the texture displacement bake, for one, hands its
-// result to the volume when it finishes, and it was queued against the geometry as it was at the time.
-// Undoing while it runs restores an older state under it - a different transform, a different mesh -
-// and the result then lands on geometry it was never computed for. Undo and redo therefore wait for
-// the job, and say so rather than doing nothing.
-bool Plater::priv::undo_redo_blocked_by_job()
-{
-    if (m_worker.is_idle())
-        return false;
-    notification_manager->push_notification(NotificationType::CustomNotification,
-                                            NotificationManager::NotificationLevel::RegularNotificationLevel,
-                                            _u8L("Cannot undo or redo while an operation is running. Stop it first."));
-    return true;
-}
-
 void Plater::priv::undo()
 {
-    if (this->undo_redo_blocked_by_job())
-        return;
    const std::vector<UndoRedo::Snapshot> &snapshots = this->undo_redo_stack().snapshots();
    auto it_current = std::lower_bound(snapshots.begin(), snapshots.end(), UndoRedo::Snapshot(this->undo_redo_stack().active_snapshot_time()));
    // BBS: undo-redo until modify record
@@ -15074,8 +14954,6 @@ void Plater::priv::undo()

 void Plater::priv::redo()
 {
-    if (this->undo_redo_blocked_by_job())
-        return;
    const std::vector<UndoRedo::Snapshot> &snapshots = this->undo_redo_stack().snapshots();
    auto it_current = std::lower_bound(snapshots.begin(), snapshots.end(), UndoRedo::Snapshot(this->undo_redo_stack().active_snapshot_time()));
    // BBS: undo-redo until modify record
@@ -15114,6 +14992,11 @@ void Plater::priv::undo_redo_to(std::vector<UndoRedo::Snapshot>::const_iterator
    // Make sure that no updating function calls take_snapshot until we are done.
    SuppressSnapshots snapshot_supressor(q);

+    // Loading a snapshot deletes every PartPlate, which the slicing thread keeps dereferencing (its
+    // current plate and the status callback). Cancel it and wait for it to finish before the jump,
+    // update_after_undo_redo() re-applies the background process to the rebuilt plates afterwards.
+    this->background_process.stop();
+
    bool 				temp_snapshot_was_taken 	= this->undo_redo_stack().temp_snapshot_active();
    PrinterTechnology 	new_printer_technology 		= it_snapshot->snapshot_data.printer_technology;
    bool 				printer_technology_changed 	= this->printer_technology != new_printer_technology;
@@ -16721,7 +16604,7 @@ void adjust_settings_for_flowrate_calib(ModelObjectPtrs& objects, bool linear, i
    auto printer_config  = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    auto filament_config = &wxGetApp().preset_bundle->filaments.get_edited_preset().config;

-    /// -- scale --
+    /// --- scale ---
    // model is created for a 0.4 nozzle, scale z with nozzle size.
    const ConfigOptionFloats* nozzle_diameter_config = printer_config->option<ConfigOptionFloats>("nozzle_diameter");
    std::vector<int> extruder_types         = printer_config->option<ConfigOptionEnumsGeneric>("extruder_type")->values;
@@ -21198,33 +21081,6 @@ GLCanvas3D* Plater::get_assmeble_canvas3D()
    return nullptr;
 }

-UVEditorCanvas* Plater::get_uv_editor_canvas()
-{
-    return p->uv_editor_canvas;
-}
-
-void Plater::show_uv_editor(bool show)
-{
-    if (p->uv_editor_panel == nullptr)
-        return;
-    const wxAuiPaneInfo &pane = p->m_aui_mgr.GetPane(p->uv_editor_panel);
-    if (!pane.IsOk() || pane.IsShown() == show)
-        return;
-
-    // Deferred, because GLGizmoTextureDisplacement calls this from its ImGui panel - that is, from
-    // the middle of the 3D canvas's GL frame. Showing an AUI pane re-lays out the window and
-    // delivers the resulting size/paint events synchronously, and the UV canvas painting itself
-    // makes its own surface current in the app's *shared* GL context, which mid-frame is the one
-    // the 3D canvas is drawing into. Doing the layout once the frame is over avoids that entirely.
-    CallAfter([this, show]() {
-        wxAuiPaneInfo &deferred_pane = p->m_aui_mgr.GetPane(p->uv_editor_panel);
-        if (!deferred_pane.IsOk() || deferred_pane.IsShown() == show)
-            return;
-        deferred_pane.Show(show);
-        p->m_aui_mgr.Update();
-    });
-}
-
 GLCanvas3D* Plater::get_current_canvas3D(bool exclude_preview)
 {
    return p->get_current_canvas3D(exclude_preview);
@@ -21486,14 +21342,9 @@ bool Plater::is_same_printer_for_connected_and_selected(bool popup_warning)
    }
    if (!check_printer_initialized(obj, true, popup_warning))
        return false;
-    const std::string machine_model = obj->printer_type;
-    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
-    const std::string selected_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
-    if (!DevPrinterConfigUtil::is_optional_printer_model_id(machine_model) &&
-        !DevPrinterConfigUtil::is_optional_printer_model_id(selected_model) &&
-        !get_printer_preset(obj)) {
+    Preset *      machine_preset     = get_printer_preset(obj);
+    if (!machine_preset)
        return false;
-    }

    if (wxGetApp().is_blocking_printing()) {
        if (popup_warning) {
@@ -22578,6 +22429,11 @@ int Plater::delete_plate(int plate_index)
    if (plate_index == -1)
        index = p->partplate_list.get_curr_plate_index();

+    // Orca: delete_plate() destroys the plate's Print and GCodeResult, which the slicing thread is
+    // still working on, so it has to be stopped first. can_delete_plate() also refuses while slicing,
+    // but the plate grabber in the 3D scene does not go through it.
+    p->background_process.stop();
+
    take_snapshot("delete partplate");
    ret = p->partplate_list.delete_plate(index);

@@ -22907,7 +22763,7 @@ bool Plater::can_delete() const { return p->can_delete(); }
 bool Plater::can_delete_all() const { return p->can_delete_all(); }
 bool Plater::can_add_model() const { return !is_background_process_slicing(); }
 bool Plater::can_add_plate() const { return !is_background_process_slicing() && p->can_add_plate(); }
-bool Plater::can_delete_plate() const { return p->can_delete_plate(); }
+bool Plater::can_delete_plate() const { return !is_background_process_slicing() && p->can_delete_plate(); }
 bool Plater::can_increase_instances() const { return p->can_increase_instances(); }
 bool Plater::can_decrease_instances() const { return p->can_decrease_instances(); }
 bool Plater::can_set_instance_to_object() const { return p->can_set_instance_to_object(); }
@@ -22964,9 +22820,8 @@ bool Plater::can_copy_to_clipboard() const
    return true;
 }

-// The job check keeps the buttons in step with priv::undo()/redo(), which refuse while one runs.
-bool Plater::can_undo() const { return IsShown() && p->is_view3D_shown() && p->m_worker.is_idle() && p->undo_redo_stack().has_undo_snapshot(); }
-bool Plater::can_redo() const { return IsShown() && p->is_view3D_shown() && p->m_worker.is_idle() && p->undo_redo_stack().has_redo_snapshot(); }
+bool Plater::can_undo() const { return IsShown() && p->is_view3D_shown() && p->undo_redo_stack().has_undo_snapshot(); }
+bool Plater::can_redo() const { return IsShown() && p->is_view3D_shown() && p->undo_redo_stack().has_redo_snapshot(); }
 bool Plater::can_reload_from_disk() const { return p->can_reload_from_disk(); }
 //BBS
 bool Plater::can_fillcolor() const { return p->can_fillcolor(); }
@@ -1478,7 +1478,9 @@ bool GuideFrame::BuildProfileDataFromVendors()
            return false;

        // Written through a temp file and moved into place, as the preset caches
-        // are: half a cache must never be readable.
+        // are: half a cache must never be readable, and the PID suffix keeps two
+        // instances from interleaving on one temp file.
+        const std::string tmp_path = cache_file.string() + "." + std::to_string(get_current_pid()) + ".tmp";
        try {
            json out;
            out["format"]  = 1;
@@ -1487,9 +1489,18 @@ bool GuideFrame::BuildProfileDataFromVendors()
            for (const char* key : { "model", "machine", "filament", "process" })
                profile[key] = m_ProfileJson[key];
            boost::filesystem::create_directories(cache_file.parent_path());
-            if (const std::error_code ec = write_file_atomically(cache_file.string(), out.dump(-1, ' ', false, json::error_handler_t::ignore), /*binary=*/true))
+            {
+                boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
+                ofs << out.dump(-1, ' ', false, json::error_handler_t::ignore);
+                ofs.close();
+                if (! ofs.good())
+                    throw std::runtime_error("write failed");
+            }
+            if (const std::error_code ec = rename_file(tmp_path, cache_file.string()))
                throw std::runtime_error(ec.message());
        } catch (const std::exception& e) {
+            boost::system::error_code rm;
+            boost::filesystem::remove(tmp_path, rm);
            BOOST_LOG_TRIVIAL(warning) << "GuideFrame: could not write the profile data cache: " << e.what();
        }
        return true;
@@ -2,7 +2,6 @@

 #include <algorithm>
 #include <sstream>
-#include <system_error>
 #include <exception>
 #include <boost/format.hpp>
 #include <boost/log/trivial.hpp>
@@ -581,10 +580,9 @@ bool C3DPrinterOS::save_api_session(const std::string &session, const std::strin
    j.put("session", session);
    j.put("email", email);
    try {
-        std::ostringstream json;
-        pt::write_json(json, j);
-        if (const std::error_code ec = write_file_atomically(m_api_session_file_path, json.str()))
-            throw std::system_error(ec);
+        auto temp_path = m_api_session_file_path + ".tmp";
+        pt::write_json(temp_path, j);
+        boost::filesystem::rename(temp_path, m_api_session_file_path);
    } catch (const std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to write json to file. Path = "
                                 << m_api_session_file_path
@@ -819,9 +819,7 @@ int OrcaCloudServiceAgent::user_logout(bool request)
        }
    }

-    // An explicit logout also wipes the backend the token storage option is not using, so a token
-    // stranded by switching that option cannot sign the account back in later.
-    clear_session(/*all_backends=*/request);
+    clear_session();
    return BAMBU_NETWORK_SUCCESS;
 }

@@ -1478,8 +1476,15 @@ void OrcaCloudServiceAgent::save_sync_state()
    if (sync_state_path.empty())
        return;

-    if (const std::error_code ec = write_file_atomically(sync_state_path, std::to_string(sync_state.last_sync_timestamp)))
-        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to save the sync state: " << ec.message();
+    try {
+        std::string tmp_path = sync_state_path + ".tmp";
+        std::ofstream ofs(tmp_path, std::ios::out | std::ios::trunc);
+        if (ofs.good()) {
+            ofs << std::to_string(sync_state.last_sync_timestamp);
+            ofs.close();
+            boost::filesystem::rename(tmp_path, sync_state_path);
+        }
+    } catch (...) {}
 }

 void OrcaCloudServiceAgent::clear_sync_state()
@@ -1568,10 +1573,22 @@ void OrcaCloudServiceAgent::persist_user_secret(const std::string& secret)
            wxFileName::Mkdir(path.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
        }

-        if (const std::error_code ec = write_file_atomically(secret_fallback_path, signed_payload, /*binary=*/true))
-            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot write user secret file " << secret_fallback_path << ": " << ec.message();
-        else
-            stored = true;
+        const std::string tmp_path = secret_fallback_path + ".tmp";
+        std::ofstream ofs(tmp_path, std::ios::out | std::ios::trunc | std::ios::binary);
+        if (ofs.good()) {
+            ofs << signed_payload;
+            ofs.flush();
+            ofs.close();
+
+            if (wxRenameFile(wxString::FromUTF8(tmp_path.c_str()), wxString::FromUTF8(secret_fallback_path.c_str()), true)) {
+                stored = true;
+            } else {
+                wxRemoveFile(wxString::FromUTF8(tmp_path.c_str()));
+                BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: failed to atomically replace user secret file";
+            }
+        } else {
+            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: cannot open user secret file for write - " << secret_fallback_path;
+        }
    } else {
        // Use wxSecretStore only
        wxSecretStore store = wxSecretStore::GetDefault();
@@ -1587,9 +1604,7 @@ void OrcaCloudServiceAgent::persist_user_secret(const std::string& secret)
        }
    }

-    if (stored) {
-        secret_stored = true;
-    }
+    (void) stored;
 }

 bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
@@ -1629,7 +1644,6 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
                }

                if (integrity_ok && aes256gcm_decrypt(encoded_payload, key, plain) && !plain.empty()) {
-                    secret_stored = true;
                    out_secret = plain;
                    // Upgrade legacy payloads to signed format
                    if (payload.rfind("v2:", 0) != 0) {
@@ -1647,7 +1661,6 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
            if (store.Load(SECRET_STORE_SERVICE, username, secret) && secret.IsOk()) {
                out_secret.assign(static_cast<const char*>(secret.GetData()), secret.GetSize());
                if (!out_secret.empty()) {
-                    secret_stored = true;
                    return true;
                }
            }
@@ -1657,20 +1670,11 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
    return false;
 }

-void OrcaCloudServiceAgent::clear_user_secret(bool all_backends)
+void OrcaCloudServiceAgent::clear_user_secret()
 {
-    // Nothing this process loaded or saved: leave the store alone. Deleting would only cost a
-    // keychain round trip (or a hang while the keychain is unresponsive) and could remove a
-    // login another instance just saved.
-    if (!secret_stored.exchange(false) && !all_backends) {
-        return;
-    }
-
-    if (all_backends || !m_use_encrypted_token_file) {
-        wxSecretStore store = wxSecretStore::GetDefault();
-        if (store.IsOk()) {
-            store.Delete(SECRET_STORE_SERVICE);
-        }
+    wxSecretStore store = wxSecretStore::GetDefault();
+    if (store.IsOk()) {
+        store.Delete(SECRET_STORE_SERVICE);
    }

    compute_fallback_path();
@@ -2019,13 +2023,13 @@ bool OrcaCloudServiceAgent::set_user_session(const json& session_json, bool noti
    return success;
 }

-void OrcaCloudServiceAgent::clear_session(bool all_backends)
+void OrcaCloudServiceAgent::clear_session()
 {
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        session = SessionInfo{};
    }
-    clear_user_secret(all_backends);
+    clear_user_secret();
 }

 // ============================================================================
@@ -326,7 +326,7 @@ public:

    void persist_user_secret(const std::string& secret);
    bool load_user_secret(std::string& out_secret);
-    void clear_user_secret(bool all_backends = false);
+    void clear_user_secret();

    // Token refresh helpers
    bool          refresh_if_expiring(std::chrono::seconds skew, const std::string& reason);
@@ -344,7 +344,7 @@ public:
                          bool persist = true);
    // Accepts either nested Orca cloud / GoTrue session JSON or flat WebView token JSON.
    bool set_user_session(const nlohmann::json& session_json, bool notify_login = true);
-    void clear_session(bool all_backends = false);
+    void clear_session();

    static std::string generate_uuid_for_setting_id(const std::string& name, const std::string& user_id = "");

@@ -413,11 +413,6 @@ private:
    // Member variables - auth state
    PkceBundle pkce_bundle;
    std::string secret_fallback_path;
-    // Set once this process has read a secret from the store or written one. Unless the user logs
-    // out explicitly, clear_user_secret() only touches the store while it is set, so a logged-out
-    // instance (the GUI polls the login status every 2 s) makes no keychain calls and cannot wipe
-    // a login another instance saved.
-    std::atomic_bool secret_stored{false};
    SessionHandler session_handler;
    OnLoginCompleteHandler on_login_complete_handler;
    SessionInfo session;
@@ -1025,6 +1025,8 @@ void StackImpl::load_snapshot(size_t timestamp, Slic3r::Model& model, Slic3r::GU
 		std::vector<std::string> previous_gcode_paths;
 		plate_list.get_sliced_result(previous_slice_result, previous_gcode_paths);

+		// The plates are dereferenced by the slicing thread, which the caller
+		// (Plater::priv::undo_redo_to) has stopped before loading the snapshot.
 		plate_list.reset(false);
 		this->load_mutable_object<Slic3r::GUI::PartPlateList>(plate_list.id(), plate_list);
 		plate_list.rebuild_plates_after_deserialize(previous_slice_result, previous_gcode_paths);
@@ -249,10 +249,21 @@ bool PluginConfig::save()
        return false;
    }

-    // Written beside the target and moved into place, so a crash mid-write cannot truncate an
-    // existing config.
-    if (const std::error_code ec = write_file_atomically(path, root.dump(1, '\t') + "\n")) {
-        BOOST_LOG_TRIVIAL(error) << "PluginConfig: failed to write " << path << ": " << ec.message() << "; keeping the existing config";
+    // Write to a PID-suffixed file and rename it into place, so a crash mid-write cannot truncate an
+    // existing config. Same approach as AppConfig::save().
+    const std::string path_pid = (boost::format("%1%.%2%") % path % get_current_pid()).str();
+
+    boost::nowide::ofstream file;
+    file.open(path_pid, std::ios::out | std::ios::trunc);
+    file << root.dump(1, '\t') << std::endl;
+    file.close();
+    if (file.fail()) {
+        BOOST_LOG_TRIVIAL(error) << "PluginConfig: failed to write " << path_pid << "; keeping the existing config";
+        return false;
+    }
+
+    if (const std::error_code rename_ec = rename_file(path_pid, path)) {
+        BOOST_LOG_TRIVIAL(error) << "PluginConfig: failed to move " << path_pid << " onto " << path << ": " << rename_ec.message();
        return false;
    }

@@ -57,7 +57,6 @@ add_executable(${_TEST_NAME}_tests
    # test_png_io.cpp
    test_indexed_triangle_set.cpp
    test_texture_displacement.cpp
-    test_instance_lock.cpp
    ../libnest2d/printer_parts.cpp
    )

@@ -1,228 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <atomic>
-#include <chrono>
-#include <thread>
-
-#include <boost/filesystem.hpp>
-
-#include "libslic3r/InstanceLock.hpp"
-#include "test_utils.hpp"
-
-#ifdef _WIN32
-#include <boost/interprocess/sync/file_lock.hpp>
-#include <boost/nowide/convert.hpp>
-#include <boost/nowide/fstream.hpp>
-#else
-#include <fcntl.h>
-#include <sys/file.h>
-#include <unistd.h>
-#endif
-
-using namespace Slic3r;
-using namespace std::chrono_literals;
-
-// Sets a process-wide knob for one test and restores it however the test ends.
-template<typename T> struct ScopedStaticValue
-{
-    T &ref;
-    T  saved;
-    ScopedStaticValue(T &ref, T value) : ref(ref), saved(ref) { ref = value; }
-    ~ScopedStaticValue() { ref = saved; }
-};
-
-TEST_CASE("InstanceLock creates its lock file and holds it for the guard's scope", "[InstanceLock]")
-{
-    ScopedTemporaryFile lock_file(".lock");
-    const std::string   path = lock_file.string();
-
-    {
-        InstanceLock lock(path);
-        REQUIRE(lock.locked());
-        REQUIRE(boost::filesystem::exists(path));
-    }
-    // Released: a fresh guard gets the lock at once instead of waiting out a timeout.
-    const auto   started = std::chrono::steady_clock::now();
-    InstanceLock again(path, 5000ms);
-    REQUIRE(again.locked());
-    // Well inside the timeout it would otherwise have waited out; loose enough for a loaded runner.
-    REQUIRE(std::chrono::steady_clock::now() - started < 4000ms);
-}
-
-TEST_CASE("InstanceLock nests within one thread", "[InstanceLock]")
-{
-    ScopedTemporaryFile lock_file(".lock");
-    const std::string   path = lock_file.string();
-
-    InstanceLock outer(path);
-    {
-        InstanceLock inner(path, 100ms);
-        REQUIRE(inner.locked());
-    }
-    // The inner guard leaving does not release the outer one.
-    REQUIRE(outer.locked());
-}
-
-TEST_CASE("InstanceLock is a no-op for an empty path and survives an unwritable one", "[InstanceLock]")
-{
-    ScopedTemporaryDir dir;
-
-    InstanceLock none("");
-    REQUIRE_FALSE(none.locked());
-
-    // The directory does not exist, so the lock file cannot be created; the
-    // guard still constructs and the write it guards can go ahead.
-    InstanceLock unwritable((dir.path() / "missing" / "shared.lock").string(), 100ms);
-    REQUIRE_FALSE(unwritable.locked());
-}
-
-TEST_CASE("InstanceLock retries a lock file it could not open once the cool-down passes", "[InstanceLock]")
-{
-    ScopedTemporaryDir dir;
-    const std::string  path = (dir.path() / "later" / "shared.lock").string();
-    ScopedStaticValue  cooldown(InstanceLock::cooldown, 300ms);
-
-    bool before_dir, during_cooldown, after_cooldown;
-    const auto started = std::chrono::steady_clock::now();
-    {
-        InstanceLock lock(path, 100ms);
-        before_dir = lock.locked();
-    }
-    boost::filesystem::create_directories(dir.path() / "later");
-    {
-        InstanceLock lock(path, 100ms);
-        during_cooldown = lock.locked();
-    }
-    const bool second_guard_inside_cooldown = std::chrono::steady_clock::now() - started < InstanceLock::cooldown;
-    std::this_thread::sleep_for(400ms);
-    {
-        InstanceLock lock(path, 100ms);
-        after_cooldown = lock.locked();
-    }
-
-    REQUIRE_FALSE(before_dir);
-    // A loaded runner may take longer than the cool-down to get here; then the
-    // second guard legitimately retried, so only assert when the timing held.
-    if (second_guard_inside_cooldown)
-        REQUIRE_FALSE(during_cooldown);
-    REQUIRE(after_cooldown);
-}
-
-TEST_CASE("InstanceLock reopens a lock file that was replaced on disk", "[InstanceLock]")
-{
-    ScopedTemporaryFile lock_file(".lock");
-    const std::string   path = lock_file.string();
-    {
-        InstanceLock lock(path);
-        REQUIRE(lock.locked());
-    }
-
-    boost::filesystem::remove(path);
-    InstanceLock lock(path);
-    REQUIRE(lock.locked());
-    // Each outermost guard opens the file afresh, so the deleted path is back.
-    REQUIRE(boost::filesystem::exists(path));
-}
-
-TEST_CASE("InstanceLock serialises the threads of one process", "[InstanceLock]")
-{
-    ScopedTemporaryFile lock_file(".lock");
-    const std::string   path = lock_file.string();
-
-    std::atomic<bool> holder_ready{false};
-    std::atomic<bool> holder_released{false};
-    std::thread holder([&] {
-        InstanceLock lock(path);
-        holder_ready = true;
-        std::this_thread::sleep_for(150ms);
-        holder_released = true;
-    });
-    while (! holder_ready)
-        std::this_thread::yield();
-
-    bool released_before_acquire = false;
-    {
-        InstanceLock lock(path);
-        released_before_acquire = holder_released;
-    }
-    holder.join();
-    REQUIRE(released_before_acquire);
-}
-
-// Holds the OS lock on a file through a handle of its own, as another instance would. The lock
-// belongs to the handle on Windows and to the open file description elsewhere, so the guard's
-// handle is refused while this one holds it.
-class OtherHolder
-{
-public:
-    explicit OtherHolder(const std::string &path)
-    {
-#ifdef _WIN32
-        boost::nowide::ofstream(path, std::ios::app).close();
-        m_lock = boost::interprocess::file_lock(boost::nowide::widen(path).c_str());
-        m_held = m_lock.try_lock();
-#else
-        m_fd   = ::open(path.c_str(), O_RDWR | O_CREAT, 0644);
-        m_held = m_fd >= 0 && ::flock(m_fd, LOCK_EX | LOCK_NB) == 0;
-#endif
-    }
-    ~OtherHolder() { release(); }
-    OtherHolder(const OtherHolder &) = delete;
-    OtherHolder &operator=(const OtherHolder &) = delete;
-
-    bool held() const { return m_held; }
-    void release()
-    {
-#ifdef _WIN32
-        if (m_held)
-            m_lock.unlock();
-        m_lock = boost::interprocess::file_lock();
-#else
-        if (m_fd >= 0)
-            ::close(m_fd);
-        m_fd = -1;
-#endif
-        m_held = false;
-    }
-
-private:
-#ifdef _WIN32
-    boost::interprocess::file_lock m_lock;
-#else
-    int m_fd{-1};
-#endif
-    bool m_held{false};
-};
-
-TEST_CASE("InstanceLock yields to a lock held through another handle and reports it", "[InstanceLock]")
-{
-    ScopedTemporaryFile lock_file(".lock");
-    const std::string   path = lock_file.string();
-    ScopedStaticValue   cooldown(InstanceLock::cooldown, 300ms);
-
-    OtherHolder other(path);
-    REQUIRE(other.held());
-
-    bool locked_while_other_holds;
-    {
-        InstanceLock lock(path, 100ms);
-        locked_while_other_holds = lock.locked();
-    }
-    // The timed-out wait starts a cool-down: the next guard does not touch the file.
-    const auto started = std::chrono::steady_clock::now();
-    bool       locked_during_cooldown;
-    {
-        InstanceLock lock(path, 5000ms);
-        locked_during_cooldown = lock.locked();
-    }
-    const auto cooldown_wait = std::chrono::steady_clock::now() - started;
-    other.release();
-
-    REQUIRE_FALSE(locked_while_other_holds);
-    REQUIRE_FALSE(locked_during_cooldown);
-    REQUIRE(cooldown_wait < 4000ms);
-    // Once the cool-down passes, the lock the other holder released is taken again.
-    std::this_thread::sleep_for(400ms);
-    InstanceLock lock(path);
-    REQUIRE(lock.locked());
-}
@@ -5,7 +5,6 @@
 #include <fstream>

 #include "libslic3r/PresetBundle.hpp"
-#include "libslic3r/ParallelResolve.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/TriangleMesh.hpp"
@@ -18,10 +17,6 @@
 #include <iostream>
 #include <initializer_list>

-#ifndef _WIN32
-#include <unistd.h> // geteuid
-#endif
-
 using namespace Slic3r;

 namespace {
@@ -5961,214 +5956,3 @@ TEST_CASE("A filament's variant index follows the extruder type and nozzle volum
    // the filament defines no Bowden High Flow variant
    CHECK(PresetBundle::get_filament_variant_index(filament, printer, 1, nvtHighFlow) == 0);
 }
-
-TEST_CASE("A user preset saved over by another instance while its directory loads is read again under the lock", "[Preset][Bundle][InstanceLock]")
-{
-    ScopedTemporaryDir   temp_dir;
-    ScopedDataDir        data_dir_scope(temp_dir.path());
-    RenameTestCollection coll;
-
-    Preset &parent = add_inmemory_preset(coll, "Parent Process");
-    parent.config.option<ConfigOptionFloat>("layer_height", true)->value = 0.24;
-    parent.is_system = true;
-
-    // Fewer than one batch, so every file is read before the first one is committed.
-    constexpr int  children = 8;
-    static_assert(children <= int(resolve_batch_size));
-    const fs::path dir      = temp_dir.path() / PRESET_PRINT_NAME;
-    for (int i = 0; i < children; ++ i)
-        write_minimal_child(dir / ("Child " + std::to_string(i) + ".json"), "Child " + std::to_string(i), "Parent Process");
-
-    // The first commit stands in for another instance saving every other preset after
-    // they were read and before they are committed.
-    std::string first;
-    auto save_the_others = [&](Preset &preset) {
-        if (! first.empty())
-            return;
-        first = preset.name;
-        for (int i = 0; i < children; ++ i) {
-            const std::string name = "Child " + std::to_string(i);
-            if (name != first)
-                std::ofstream((dir / (name + ".json")).string())
-                    << R"({"type":"process","name":")" << name
-                    << R"(","from":"User","version":"1.0.0","inherits":"Parent Process","layer_height":"0.3"})";
-        }
-    };
-    PresetsConfigSubstitutions substitutions;
-    coll.load_presets(temp_dir.path().string(), PRESET_PRINT_NAME, substitutions,
-                      ForwardCompatibilitySubstitutionRule::Disable, save_the_others);
-
-    REQUIRE_FALSE(first.empty());
-    CHECK(coll.error_count() == 0);
-    for (int i = 0; i < children; ++ i) {
-        const std::string name  = "Child " + std::to_string(i);
-        const Preset     *child = coll.find_preset(name);
-        REQUIRE(child != nullptr);
-        CHECK_THAT(child->config.opt_float("layer_height"), Catch::Matchers::WithinAbs(name == first ? 0.24 : 0.3, 1e-9));
-    }
-}
-
-TEST_CASE("A user preset removed by another instance while its directory loads is not installed", "[Preset][Bundle][InstanceLock]")
-{
-    ScopedTemporaryDir   temp_dir;
-    ScopedDataDir        data_dir_scope(temp_dir.path());
-    RenameTestCollection coll;
-
-    Preset &parent = add_inmemory_preset(coll, "Parent Process");
-    parent.is_system = true;
-
-    // Fewer than one batch, so every file is read before the first one is committed.
-    constexpr int  children = 8;
-    static_assert(children <= int(resolve_batch_size));
-    const fs::path dir      = temp_dir.path() / PRESET_PRINT_NAME;
-    for (int i = 0; i < children; ++ i)
-        write_minimal_child(dir / ("Child " + std::to_string(i) + ".json"), "Child " + std::to_string(i), "Parent Process");
-
-    std::string first;
-    auto remove_the_others = [&](Preset &preset) {
-        if (! first.empty())
-            return;
-        first = preset.name;
-        for (int i = 0; i < children; ++ i)
-            if (const std::string name = "Child " + std::to_string(i); name != first)
-                fs::remove(dir / (name + ".json"));
-    };
-    PresetsConfigSubstitutions substitutions;
-    coll.load_presets(temp_dir.path().string(), PRESET_PRINT_NAME, substitutions,
-                      ForwardCompatibilitySubstitutionRule::Disable, remove_the_others);
-
-    REQUIRE_FALSE(first.empty());
-    CHECK(coll.error_count() == 0);
-    CHECK(coll.size() == 3); // the default preset, the parent and the first child
-    CHECK(coll.find_preset(first) != nullptr);
-}
-
-TEST_CASE("Without the instance lock a user preset loads but its file is not written back", "[Preset][Bundle][InstanceLock]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data_dir_scope(temp_dir.path());
-    // A directory where the lock file belongs, so the lock cannot be taken.
-    fs::create_directories(fs::path(user_presets_lock_path()));
-    PresetBundle       bundle;
-    const fs::path     file = temp_dir.path() / PRESET_FILAMENT_NAME / "My PLA @Test Printer.json";
-    write_preset_with_inherits(bundle.filaments.default_preset().config, file, "My PLA @Test Printer", std::string());
-    const std::string before = read_file(file);
-
-    PresetsConfigSubstitutions substitutions;
-    bundle.filaments.load_presets(temp_dir.path().string(), PRESET_FILAMENT_NAME, substitutions,
-                                  ForwardCompatibilitySubstitutionRule::EnableSilent);
-
-    const Preset *preset = bundle.filaments.find_preset("My PLA @Test Printer");
-    REQUIRE(preset != nullptr);
-    CHECK(preset->config.option<ConfigOptionStrings>("compatible_printers")->values == std::vector<std::string>{ "Test Printer" });
-    CHECK(read_file(file) == before);
-}
-
-#ifndef _WIN32
-// File permissions stop reading only on POSIX.
-TEST_CASE("A user preset that cannot be read under the instance lock is counted and removed", "[Preset][Bundle][InstanceLock]")
-{
-    if (::geteuid() == 0)
-        SKIP("file permissions do not stop root");
-    ScopedTemporaryDir   temp_dir;
-    ScopedDataDir        data_dir_scope(temp_dir.path());
-    RenameTestCollection coll;
-
-    Preset &parent = add_inmemory_preset(coll, "Parent Process");
-    parent.is_system = true;
-    const fs::path file = temp_dir.path() / PRESET_PRINT_NAME / "Unreadable.json";
-    write_minimal_child(file, "Unreadable", "Parent Process");
-    fs::permissions(file, fs::no_perms);
-
-    PresetsConfigSubstitutions substitutions;
-    coll.load_presets(temp_dir.path().string(), PRESET_PRINT_NAME, substitutions,
-                      ForwardCompatibilitySubstitutionRule::Disable);
-
-    CHECK(coll.error_count() == 1);
-    CHECK(coll.find_preset("Unreadable") == nullptr);
-    CHECK_FALSE(fs::exists(file));
-}
-#endif
-
-#ifndef _WIN32
-// Creating a symlink needs no privilege only on POSIX.
-TEST_CASE("A user preset that is a symlink to itself is counted and removed while the rest still load", "[Preset][Bundle][InstanceLock]")
-{
-    ScopedTemporaryDir   temp_dir;
-    ScopedDataDir        data_dir_scope(temp_dir.path());
-    RenameTestCollection coll;
-
-    Preset &parent = add_inmemory_preset(coll, "Parent Process");
-    parent.is_system = true;
-    const fs::path dir = temp_dir.path() / PRESET_PRINT_NAME;
-    write_minimal_child(dir / "Good A.json", "Good A", "Parent Process");
-    write_minimal_child(dir / "Good B.json", "Good B", "Parent Process");
-    const fs::path loop = dir / "Loop.json";
-    fs::create_symlink(loop.filename(), loop);
-
-    PresetsConfigSubstitutions substitutions;
-    REQUIRE_NOTHROW(coll.load_presets(temp_dir.path().string(), PRESET_PRINT_NAME, substitutions,
-                                      ForwardCompatibilitySubstitutionRule::Disable));
-
-    CHECK(coll.error_count() == 1);
-    CHECK(coll.find_preset("Good A") != nullptr);
-    CHECK(coll.find_preset("Good B") != nullptr);
-    CHECK(coll.find_preset("Loop") == nullptr);
-    boost::system::error_code ec;
-    CHECK(fs::symlink_status(loop, ec).type() == fs::file_not_found);
-}
-#endif
-
-#ifndef _WIN32
-// Creating a symlink needs no privilege only on POSIX.
-TEST_CASE("A user preset symlinked to a missing target is counted but the link is kept", "[Preset][Bundle][InstanceLock]")
-{
-    ScopedTemporaryDir   temp_dir;
-    ScopedDataDir        data_dir_scope(temp_dir.path());
-    RenameTestCollection coll;
-
-    const fs::path dir  = temp_dir.path() / PRESET_PRINT_NAME;
-    const fs::path link = dir / "Linked.json";
-    fs::create_directories(dir);
-    fs::create_symlink(temp_dir.path() / "unmounted" / "Linked.json", link);
-
-    PresetsConfigSubstitutions substitutions;
-    coll.load_presets(temp_dir.path().string(), PRESET_PRINT_NAME, substitutions,
-                      ForwardCompatibilitySubstitutionRule::Disable);
-
-    CHECK(coll.error_count() == 1);
-    CHECK(coll.find_preset("Linked") == nullptr);
-    boost::system::error_code ec;
-    CHECK(fs::symlink_status(link, ec).type() == fs::symlink_file);
-}
-#endif
-
-#ifndef _WIN32
-// The read-only bit on a directory stops file creation only on POSIX.
-TEST_CASE("A user filament whose derived compatible printer cannot be written back still loads with the failure counted", "[Preset][Bundle]")
-{
-    if (::geteuid() == 0)
-        SKIP("a read-only directory does not stop root");
-    ScopedTemporaryDir temp_dir;
-    PresetBundle       bundle;
-    const fs::path     dir  = temp_dir.path() / PRESET_FILAMENT_NAME;
-    const fs::path     file = dir / "My PLA @Test Printer.json";
-    write_preset_with_inherits(bundle.filaments.default_preset().config, file, "My PLA @Test Printer", std::string());
-    const std::string before = read_file(file);
-
-    fs::permissions(file, fs::owner_read);
-    fs::permissions(dir, fs::owner_read | fs::owner_exe);
-    PresetsConfigSubstitutions substitutions;
-    bundle.filaments.load_presets(temp_dir.path().string(), PRESET_FILAMENT_NAME, substitutions,
-                                  ForwardCompatibilitySubstitutionRule::EnableSilent);
-    // Restored before any assertion, so a failure never leaves an unremovable directory behind.
-    fs::permissions(dir, fs::owner_all);
-    fs::permissions(file, fs::owner_read | fs::owner_write);
-
-    const Preset *preset = bundle.filaments.find_preset("My PLA @Test Printer");
-    REQUIRE(preset != nullptr);
-    CHECK(preset->config.option<ConfigOptionStrings>("compatible_printers")->values == std::vector<std::string>{ "Test Printer" });
-    CHECK(bundle.filaments.error_count() == 1);
-    CHECK(read_file(file) == before);
-}
-#endif
@@ -10,8 +10,6 @@
 #include <cctype>
 #include <fstream>
 #include <string>
-#include <thread>
-#include <system_error>

 #ifndef _WIN32
 #include <unistd.h>     // getuid
@@ -64,113 +62,6 @@ TEST_CASE("per-user temp root is unchanged on Windows, isolated elsewhere", "[ut
 #endif
 }

-TEST_CASE("write_file_atomically replaces the target and leaves no temporary file", "[utils]") {
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path target = dir.path() / "preset.json";
-
-    REQUIRE_FALSE(write_file_atomically(target.string(), "first"));
-    REQUIRE_FALSE(write_file_atomically(target.string(), "second"));
-
-    std::string content;
-    load_string_file(target, content);
-    REQUIRE(content == "second");
-    size_t entries = 0;
-    for (auto &entry : boost::filesystem::directory_iterator(dir.path())) {
-        (void) entry;
-        ++entries;
-    }
-    REQUIRE(entries == 1);
-}
-
-TEST_CASE("write_file_atomically reports a missing directory and writes nothing", "[utils]") {
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path target = dir.path() / "missing" / "preset.json";
-
-    const std::error_code ec = write_file_atomically(target.string(), "x");
-    REQUIRE(ec == std::errc::no_such_file_or_directory);
-    REQUIRE_FALSE(boost::filesystem::exists(target));
-}
-
-#ifndef _WIN32
-// The read-only bit on a directory stops file creation only on POSIX.
-TEST_CASE("write_file_atomically writes in place when no temporary can be created beside an existing target", "[utils]") {
-    if (::geteuid() == 0)
-        SKIP("a read-only directory does not stop root");
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path target = dir.path() / "preset.json";
-    REQUIRE_FALSE(write_file_atomically(target.string(), "first"));
-    boost::filesystem::permissions(dir.path(), boost::filesystem::owner_read | boost::filesystem::owner_exe);
-
-    const std::error_code replaced = write_file_atomically(target.string(), "second");
-    const std::error_code created  = write_file_atomically((dir.path() / "new.json").string(), "x");
-    // Restored before any assertion, so a failure never leaves an unremovable directory behind.
-    boost::filesystem::permissions(dir.path(), boost::filesystem::owner_all);
-
-    REQUIRE_FALSE(replaced);
-    REQUIRE(created == std::errc::permission_denied);
-    std::string content;
-    load_string_file(target, content);
-    REQUIRE(content == "second");
-}
-#endif
-
-TEST_CASE("write_file_atomically keeps bytes intact in binary mode", "[utils]") {
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path target = dir.path() / "blob.bin";
-    const std::string bytes("a\r\nb\0c", 6);
-
-    REQUIRE_FALSE(write_file_atomically(target.string(), bytes, /*binary=*/true));
-    REQUIRE(boost::filesystem::file_size(target) == bytes.size());
-}
-
-#ifndef _WIN32
-TEST_CASE("write_file_atomically writes through a symlink and keeps the target's permissions", "[utils]") {
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path real = dir.path() / "real.json";
-    const boost::filesystem::path link = dir.path() / "link.json";
-    REQUIRE_FALSE(write_file_atomically(real.string(), "first"));
-    boost::filesystem::permissions(real, boost::filesystem::owner_read | boost::filesystem::owner_write);
-    boost::filesystem::create_symlink(real, link);
-
-    REQUIRE_FALSE(write_file_atomically(link.string(), "second"));
-
-    REQUIRE(boost::filesystem::is_symlink(boost::filesystem::symlink_status(link)));
-    std::string content;
-    load_string_file(real, content);
-    REQUIRE(content == "second");
-
-    REQUIRE_FALSE(write_file_atomically(real.string(), "third"));
-    const auto perms = boost::filesystem::status(real).permissions() & boost::filesystem::all_all;
-    REQUIRE(perms == (boost::filesystem::owner_read | boost::filesystem::owner_write));
-}
-#endif
-
-TEST_CASE("write_file_atomically survives two threads writing one target", "[utils]") {
-    ScopedTemporaryDir dir;
-    const boost::filesystem::path target = dir.path() / "shared.json";
-    const std::string a(20000, 'a'), b(20000, 'b');
-
-    std::thread other([&] {
-        for (int i = 0; i < 50; ++i)
-            write_file_atomically(target.string(), a);
-    });
-    for (int i = 0; i < 50; ++i)
-        write_file_atomically(target.string(), b);
-    other.join();
-
-    std::string content;
-    load_string_file(target, content);
-    const bool whole = content == a || content == b;
-    REQUIRE(whole);
-    // No temporary may be left; a scanner on Windows may briefly hold the old
-    // file under another name, so only the temporaries are counted.
-    size_t temporaries = 0;
-    for (auto &entry : boost::filesystem::directory_iterator(dir.path()))
-        if (entry.path().extension() == ".tmp")
-            ++temporaries;
-    REQUIRE(temporaries == 0);
-}
-
 TEST_CASE("copy_file reports the OS error when the destination cannot be written", "[utils]") {
    ScopedTemporaryFile source(".txt");
    {
@@ -1804,6 +1804,24 @@ TEST_CASE("a header claiming more body than the file holds is rejected", "[Vendo
    REQUIRE_FALSE(bundle.load_vendor_cache(cache, "Bounded", Semver(1, 0, 0)));
 }

+TEST_CASE("a failed write leaves the previous cache in place", "[VendorCache]")
+{
+    TempDir tmp;
+    const std::string cache = (tmp.path / "Durable.opc").string();
+    REQUIRE(save_one_vendor(cache, one_vendor("Durable"), "Durable", "1.0.0"));
+    const std::string before = slurp(cache);
+
+    // A directory where the temp file wants to go: the write cannot complete,
+    // and must not have destroyed what was already there to find that out.
+    const fs::path blocker = fs::path(cache + "." + std::to_string(get_current_pid()) + ".tmp");
+    fs::create_directories(blocker);
+
+    REQUIRE_FALSE(save_one_vendor(cache, one_vendor("Durable"), "Durable", "2.0.0"));
+    CHECK(slurp(cache) == before);
+
+    fs::remove_all(blocker);
+}
+
 TEST_CASE("a cache written by another build's option ordering still loads", "[VendorCache]")
 {
    // The regression the fingerprint used to prevent by refusing the file
@@ -13,7 +13,6 @@ add_executable(${_TEST_NAME}_tests
    test_prebuild_queue.cpp
    test_staged_build.cpp
    test_network_versions.cpp
-    test_orca_cloud_agent.cpp
    test_action_source.cpp
    test_plugin_host_api.cpp
    # Exercise seam enums and predicates through the embedded Python host API.
@@ -6,7 +6,6 @@
 #include <boost/filesystem.hpp>
 #include <memory.h>
 #include <stdexcept>
-#include <string>
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>

@@ -26,15 +25,8 @@ void ensure_python_initialized()
    config.parse_argv = 0;

    const auto python_home = boost::dll::program_location().parent_path() / "python";
-#ifdef _WIN32
-    const auto stdlib = python_home / "Lib";
-#else
-    const auto stdlib = python_home / "lib" /
-                        ("python" + std::to_string(PY_MAJOR_VERSION) + "." + std::to_string(PY_MINOR_VERSION));
-#endif

-    // Only a real runtime: a stray python/ folder (packages a test left behind) is not a home.
-    if (boost::filesystem::exists(stdlib / "encodings")) {
+    if (boost::filesystem::exists(python_home)) {
        const std::string home = python_home.string();
        const PyStatus status  = PyConfig_SetBytesString(&config, &config.home, home.c_str());

@@ -1,86 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-
-#include <memory>
-#include <string>
-
-#include "slic3r/Utils/OrcaCloudServiceAgent.hpp"
-#include "test_utils.hpp"
-
-using namespace Slic3r;
-namespace fs = boost::filesystem;
-
-namespace {
-
-// The encrypted token file is the one secret backend a test can observe without a system
-// keychain. Every agent pointed at the same directory shares it, like separate app instances
-// share the keychain entry.
-std::unique_ptr<OrcaCloudServiceAgent> make_file_backed_agent(const fs::path& dir)
-{
-    auto agent = std::make_unique<OrcaCloudServiceAgent>(dir.string());
-    agent->set_use_encrypted_token_file(true);
-    agent->set_config_dir(dir.string());
-    return agent;
-}
-
-fs::path secret_file(const fs::path& dir) { return dir / secret_constants::USER_SECRET_FILENAME; }
-
-} // namespace
-
-TEST_CASE("Logging out removes the secret this instance saved", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    auto agent = make_file_backed_agent(dir.path());
-
-    agent->persist_user_secret("refresh-token");
-    REQUIRE(fs::exists(secret_file(dir.path())));
-
-    agent->user_logout(false);
-    CHECK_FALSE(fs::exists(secret_file(dir.path())));
-}
-
-TEST_CASE("Logging out removes a secret this instance loaded from the store", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
-
-    auto        agent = make_file_backed_agent(dir.path());
-    std::string secret;
-    REQUIRE(agent->load_user_secret(secret));
-    CHECK(secret == "refresh-token");
-
-    agent->user_logout(false);
-    CHECK_FALSE(fs::exists(secret_file(dir.path())));
-}
-
-TEST_CASE("Logging out leaves a secret this instance never loaded or saved alone", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
-
-    // A logged-out instance is asked to log out on every login-status poll.
-    auto other = make_file_backed_agent(dir.path());
-    other->user_logout(false);
-    other->user_logout(false);
-    CHECK(fs::exists(secret_file(dir.path())));
-
-    std::string secret;
-    REQUIRE(make_file_backed_agent(dir.path())->load_user_secret(secret));
-    CHECK(secret == "refresh-token");
-}
-
-TEST_CASE("Logging out leaves a secret this instance could not read alone", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    // Written under another encryption key, e.g. by another OS user sharing the data directory.
-    fs::ofstream(secret_file(dir.path())) << "v2:0000:not-a-payload-this-user-can-decrypt";
-
-    auto        agent = make_file_backed_agent(dir.path());
-    std::string secret;
-    REQUIRE_FALSE(agent->load_user_secret(secret));
-
-    agent->user_logout(false);
-    CHECK(fs::exists(secret_file(dir.path())));
-}
@@ -38,9 +38,6 @@ namespace {
 // before this destructor's shutdown() runs.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedPluginManager()
@@ -31,9 +31,6 @@ namespace {
 // same as any other plugin.
 struct ScopedManagerShutdown
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedManagerShutdown()
@@ -42,9 +42,6 @@ namespace {
 // Declare this FIRST in a test so it is destroyed last.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = false;

    ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }
@@ -12,8 +12,6 @@
 #include <memory>
 #include <string>

-#include "plugin_test_utils.hpp"
-
 namespace py = pybind11;
 using namespace Slic3r;

@@ -23,9 +21,6 @@ namespace {
 // into Python unless PythonInterpreter::instance() reports initialized.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedPluginManager()
@@ -35,9 +35,6 @@ namespace {

 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = false;

    ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }