chore: shift files

CMakeLists.txt

@@ -123,6 +123,7 @@ option(SLIC3R_ASAN              "Enable ASan on Clang and GCC" 0)
 
 # Python stubgen module
 option(ORCA_BUILD_PYTHON_STUBGEN_MODULE "Build importable Python module for pybind11-stubgen" ON)
+option(ORCA_BUILD_PLUGIN_PERMISSION_PROBE "Build the headless Python plugin permission probe (developer tool)" OFF)
 set(ORCA_BUNDLED_UV_EXECUTABLE "" CACHE FILEPATH "Path to a uv executable to bundle for Python package installation. Leave empty to auto-download.")
 
 # Auto-download uv if not provided by the user.

deps/GMP/GMP.cmake

@@ -59,13 +59,9 @@ else ()
         set(_cross_compile_arg --host=${TOOLCHAIN_PREFIX})
     endif ()
 
-    # 6.3.0 is the first release whose arm64 assembly avoids x18, which macOS
-    # reserves and zeroes on every return to user space; 6.2.1 crashes on Apple
-    # silicon whenever CGAL falls back to exact arithmetic.
     ExternalProject_Add(dep_GMP
-        URL https://ftp.gnu.org/gnu/gmp/gmp-6.3.0.tar.xz
-            https://github.com/SoftFever/OrcaSlicer_deps/releases/download/gmp-6.3.0/gmp-6.3.0.tar.xz
-        URL_HASH SHA256=a3c2b80201b89e68616f4ad30bc66aee4927c3ce50e33929ca819d5c43538898
+        URL https://github.com/SoftFever/OrcaSlicer_deps/releases/download/gmp-6.2.1/gmp-6.2.1.tar.bz2
+        URL_HASH SHA256=eae9326beb4158c386e39a356818031bd28f3124cf915f8c5b1dc4c7a36b4d7c
         DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/GMP
         PATCH_COMMAND git apply ${GMP_DIRECTORY_FLAG} --verbose ${CMAKE_CURRENT_LIST_DIR}/0001-GMP_GCC15.patch
         BUILD_IN_SOURCE ON

docs/HLSD/polygon-clipping.md

@@ -62,23 +62,6 @@ Clipper2 behaves differently by default, the wrapper adjusts it.
   clip do not leave slivers.
 - Open polylines are clipped with the non-zero rule and keep their direction.
 
-### Tiled booleans
-
-The sweep slows down with the number of edges crossing a scan line, so a layer
-cut into thousands of pieces makes every whole-layer boolean expensive.
-`diff_ex_by_piece()` and `intersection_ex_by_piece()` take a subject of
-non-overlapping `ExPolygons`, group them into tiles with
-`ClipperUtils::tile_expolygons()`, and run each tile in parallel against only
-the clip polygons near it, cut to the tile's box. Below 128 pieces there is a
-single tile, and they are the plain `diff_ex()` / `intersection_ex()`.
-
-The result covers the same area as the plain call. Without the safety offset
-the rings are the same. With it, each tile unites only the clip polygons near
-it, so a clip edge that the whole-layer union splits where it crosses a distant
-clip polygon stays whole, and a crossing with the subject can round 1 unit
-differently. The tiles' results are concatenated in tile order, so the order of
-the output `ExPolygons` differs from the plain call.
-
 ### Offsets
 
 - Before offsetting, input vertices closer than

localization/i18n/list.txt

@@ -366,6 +366,7 @@ src/slic3r/Utils/MoonrakerPrinterAgent.cpp
 src/slic3r/Utils/BBLNetworkPlugin.cpp
 src/slic3r/Utils/OrcaCloudServiceAgent.cpp
 src/slic3r/plugin/PluginAuditManager.cpp
+src/slic3r/plugin/PluginAuditManagerGui.cpp
 src/slic3r/plugin/PluginConfig.cpp
 src/slic3r/plugin/PluginResolver.cpp
 src/slic3r/plugin/CloudPluginService.cpp

resources/profiles/Flashforge.json

@@ -1,7 +1,7 @@
 {
 	"name": "Flashforge",
 	"url": "",
-	"version": "02.04.00.12",
+	"version": "02.04.00.11",
 	"force_update": "0",
 	"description": "Flashforge configurations",
 	"machine_model_list": [

resources/profiles/Flashforge/process/0.20mm Standard @Flashforge AD5M 0.4 Nozzle.json

@@ -8,7 +8,6 @@
 	"compatible_printers": [
 		"Flashforge Adventurer 5M 0.4 Nozzle"
 	],
-	"exclude_object_tolerance": "0.2",
 	"filename_format": "{input_filename_base}_{filament_type[initial_tool]}_{print_time}.gcode",
 	"post_process": "",
 	"only_one_wall_top": "0",

resources/profiles/Flashforge/process/0.20mm Standard @Flashforge AD5M Pro 0.4 Nozzle.json

@@ -8,7 +8,6 @@
 	"compatible_printers": [
 		"Flashforge Adventurer 5M Pro 0.4 Nozzle"
 	],
-	"exclude_object_tolerance": "0.2",
 	"filename_format": "{input_filename_base}_{filament_type[0]}_{print_time}.gcode",
 	"post_process": "",
 	"only_one_wall_top": "0",

resources/profiles/Flashforge/process/0.30mm Standard @Flashforge AD5M 0.6 Nozzle.json

@@ -8,7 +8,6 @@
 	"compatible_printers": [
 		"Flashforge Adventurer 5M 0.6 Nozzle"
 	],
-	"exclude_object_tolerance": "0.2",
 	"filename_format": "{input_filename_base}_{filament_type[initial_tool]}_{print_time}.gcode",
 	"post_process": "",
 	"only_one_wall_top": "0",

resources/profiles/Flashforge/process/0.30mm Standard @Flashforge AD5M Pro 0.6 Nozzle.json

@@ -8,7 +8,6 @@
 	"compatible_printers": [
 		"Flashforge Adventurer 5M Pro 0.6 Nozzle"
 	],
-	"exclude_object_tolerance": "0.2",
 	"filename_format": "{input_filename_base}_{filament_type[initial_tool]}_{print_time}.gcode",
 	"post_process": "",
 	"only_one_wall_top": "0",

scripts/flatpak/com.orcaslicer.OrcaSlicer.yml

@@ -226,10 +226,10 @@ modules:
         sha256: f353e7b99bd0cbfc27ac9082de51acf32a8bc0b3e21ff9661ecca6f205ec1d81
         dest: external-packages/OpenVDB
 
-      # GMP 6.3.0
+      # GMP 6.2.1
       - type: file
-        url: https://ftp.gnu.org/gnu/gmp/gmp-6.3.0.tar.xz
-        sha256: a3c2b80201b89e68616f4ad30bc66aee4927c3ce50e33929ca819d5c43538898
+        url: https://github.com/SoftFever/OrcaSlicer_deps/releases/download/gmp-6.2.1/gmp-6.2.1.tar.bz2
+        sha256: eae9326beb4158c386e39a356818031bd28f3124cf915f8c5b1dc4c7a36b4d7c
         dest: external-packages/GMP
 
       # MPFR 4.2.2

scripts/run_gettext.bat

@@ -23,7 +23,7 @@ if %FULL_MODE%==1 (
     call :prepareGettextList "%list_file%" "%filtered_list%" "%missing_list%"
     if "!has_sources!"=="1" (
         if not exist "%generated_i18n%" mkdir "%generated_i18n%"
-        .\tools\xgettext.exe --keyword=L --keyword=_L --keyword=_u8L --keyword=L_CONTEXT:1,2c --keyword=_L_CONTEXT:1,2c --keyword=_u8L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost --no-wrap -f "%filtered_list%" -o "%generated_pot%"
+        .\tools\xgettext.exe --keyword=L --keyword=_L --keyword=_u8L --keyword=PLUGIN_U8L --keyword=L_CONTEXT:1,2c --keyword=_L_CONTEXT:1,2c --keyword=_u8L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost --no-wrap -f "%filtered_list%" -o "%generated_pot%"
         if errorlevel 1 (
             set "script_exit_code=1"
         ) else (

scripts/run_gettext.sh

@@ -85,7 +85,7 @@ if $FULL_MODE; then
         generated_pot_file="${generated_i18n_dir}/OrcaSlicer.pot"
 
         mkdir -p "$generated_i18n_dir"
-        xgettext --keyword=L --keyword=_L --keyword=_u8L --keyword=L_CONTEXT:1,2c --keyword=_L_CONTEXT:1,2c --keyword=_u8L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost --no-wrap -f "$filtered_list" -o "$generated_pot_file"
+        xgettext --keyword=L --keyword=_L --keyword=_u8L --keyword=PLUGIN_U8L --keyword=L_CONTEXT:1,2c --keyword=_L_CONTEXT:1,2c --keyword=_u8L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost --no-wrap -f "$filtered_list" -o "$generated_pot_file"
         python3 scripts/HintsToPot.py ./resources "$generated_i18n_dir"
 
         if [ -f "$pot_file" ] && files_equal_ignoring_pot_date "$pot_file" "$generated_pot_file"; then

src/libslic3r/ClipperUtils.cpp

@@ -7,13 +7,9 @@
 #include <cmath>
 #include <limits>
 #include <numeric>
-#include <optional>
 #include <unordered_map>
 
-#include <tbb/parallel_for.h>
-
 #include "ClipperUtils.hpp"
-#include "AABBTreeIndirect.hpp"
 #include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
 #include "Point.hpp"
@@ -280,7 +276,6 @@ Polylines c2_to_polylines(const C2::Paths64 &paths)
     return out;
 }
 
-// Only sizes the reserve of c2_to_expolygons(): for a tree Clipper2 misnested (see below) the count is approximate.
 size_t c2_count_expolygons(const C2::PolyPath64 &outer)
 {
     size_t cnt = 1;
@@ -290,90 +285,17 @@ size_t c2_count_expolygons(const C2::PolyPath64 &outer)
     return cnt;
 }
 
-// Clipper2 sometimes puts a path at the wrong level of its PolyTree: a hole beside the outer path around it instead of
-// under it, or an island at the level of holes. Taken as they are, a misplaced hole becomes a clockwise contour and its
-// outer an expolygon that covers it; whole-layer booleans cancel the two, but anything handling expolygons one at a time
-// sees the hole filled. So the orientation of a path decides its role: a clockwise path where a contour belongs is
-// collected in stray_holes, for c2_attach_stray_holes() to give to the contour around it.
-void c2_append_expolygons(const C2::PolyPath64 &outer, ExPolygons &out, std::vector<const C2::Path64*> &stray_holes)
+void c2_append_expolygons(const C2::PolyPath64 &outer, ExPolygons &out)
 {
-    if (C2::Area(outer.Polygon()) < 0.) {
-        stray_holes.emplace_back(&outer.Polygon());
-        for (const auto &island : outer)
-            c2_append_expolygons(*island, out, stray_holes);
-        return;
-    }
-    // Indexed, as the recursion below may reallocate out.
-    const size_t idx = out.size();
-    out.emplace_back().contour.points = c2_to_points(outer.Polygon());
-    out[idx].holes.reserve(outer.Count());
-    for (const auto &child : outer)
-        if (C2::Area(child->Polygon()) > 0.)
-            c2_append_expolygons(*child, out, stray_holes);
-        else {
-            out[idx].holes.emplace_back().points = c2_to_points(child->Polygon());
-            // Islands inside the hole.
-            for (const auto &island : *child)
-                c2_append_expolygons(*island, out, stray_holes);
-        }
-}
-
-// Whether outer encloses inner, two paths of one Clipper2 result. Such paths don't cross, they only touch, and rounding
-// both to the grid leaves a touching vertex up to about 1.5 units across the other path. So a vertex of inner that close
-// to outer doesn't count, the first vertex clear of it decides, and a path touching at every vertex goes by a point
-// strictly inside it: either lies on the same side of outer as the whole path. A sliver too thin to hold such a point is
-// taken as not enclosed. A hole closely hugging an island inside it would pass, so callers skip any outer no larger than
-// inner: a path inside another is always the smaller.
-bool path_encloses(const Polygon &outer, const Polygon &inner)
-{
-    // The rounding of the two paths, and of the projection Polygon::on_boundary() measures to.
-    static constexpr double touching = 3.;
-    for (const Point &pt : inner.points)
-        if (! outer.on_boundary(pt, touching))
-            return contains(outer, pt, true);
-    const std::optional<Point> pt = ClipperUtils::interior_point(inner);
-    return pt && contains(outer, *pt, true);
-}
-
-// Gives each stray hole to the innermost of the contours out[first..] around it. Contours of a Clipper2 result don't
-// cross, so those around a hole are nested and the innermost one is the smallest: candidates are tried smallest first,
-// from the first one larger than the hole.
-void c2_attach_stray_holes(ExPolygons &out, size_t first, const std::vector<const C2::Path64*> &stray_holes)
-{
-    if (stray_holes.empty())
-        return;
-    using Tree = AABBTreeIndirect::Tree<2, coord_t>;
-    std::vector<AABBTreeIndirect::BoundingBoxWrapper> bboxes;
-    bboxes.reserve(out.size() - first);
-    for (size_t i = first; i < out.size(); ++ i)
-        bboxes.emplace_back(i, get_extents(out[i].contour));
-    Tree tree;
-    tree.build_modify_input(bboxes);
-    // Contour areas, computed when a contour first becomes a candidate.
-    std::vector<double> areas(out.size(), 0.);
-    std::vector<size_t> candidates;
-    for (const C2::Path64 *path : stray_holes) {
-        Polygon hole;
-        hole.points = c2_to_points(*path);
-        const double            hole_area = - C2::Area(*path);
-        const BoundingBox       bbox      = get_extents(hole);
-        const Tree::BoundingBox hole_bbox(bbox.min, bbox.max);
-        candidates.clear();
-        AABBTreeIndirect::traverse(tree,
-            [&hole_bbox](const Tree::Node &node) { return node.bbox.contains(hole_bbox); },
-            [&candidates](const Tree::Node &node) { candidates.emplace_back(node.idx); return true; });
-        for (size_t idx : candidates)
-            if (areas[idx] == 0.)
-                areas[idx] = out[idx].contour.area();
-        std::sort(candidates.begin(), candidates.end(), [&areas](size_t a, size_t b) { return areas[a] < areas[b]; });
-        auto larger = std::upper_bound(candidates.begin(), candidates.end(), hole_area, [&areas](double area, size_t idx) { return area < areas[idx]; });
-        if (auto it = std::find_if(larger, candidates.end(), [&out, &hole](size_t idx) { return path_encloses(out[idx].contour, hole); });
-            it == candidates.end())
-            // Nothing around it: keep the path as Clipper2 returned it.
-            out.emplace_back().contour = std::move(hole);
-        else
-            out[*it].holes.emplace_back(std::move(hole));
-    }
+    ExPolygon &expoly = out.emplace_back();
+    expoly.contour.points = c2_to_points(outer.Polygon());
+    expoly.holes.reserve(outer.Count());
+    for (const auto &hole : outer)
+        expoly.holes.emplace_back().points = c2_to_points(hole->Polygon());
+    // Islands inside the holes.
+    for (const auto &hole : outer)
+        for (const auto &island : *hole)
+            c2_append_expolygons(*island, out);
 }
 
 ExPolygons c2_to_expolygons(const C2::PolyTree64 &tree)
@@ -383,10 +305,8 @@ ExPolygons c2_to_expolygons(const C2::PolyTree64 &tree)
         cnt += c2_count_expolygons(*outer);
     ExPolygons out;
     out.reserve(cnt);
-    std::vector<const C2::Path64*> stray_holes;
     for (const auto &outer : tree)
-        c2_append_expolygons(*outer, out, stray_holes);
-    c2_attach_stray_holes(out, 0, stray_holes);
+        c2_append_expolygons(*outer, out);
     return out;
 }
 
@@ -880,114 +800,6 @@ Slic3r::ExPolygons intersection_ex(const Slic3r::Surfaces &subject, const Slic3r
     { return _clipper_ex(ctIntersection, ClipperUtils::SurfacesProvider(subject), ClipperUtils::SurfacesProvider(clip), do_safety_offset); }
 Slic3r::ExPolygons intersection_ex(const Slic3r::SurfacesPtr &subject, const Slic3r::ExPolygons &clip, ApplySafetyOffset do_safety_offset)
     { return _clipper_ex(ctIntersection, ClipperUtils::SurfacesPtrProvider(subject), ClipperUtils::ExPolygonsProvider(clip), do_safety_offset); }
-
-namespace ClipperUtils {
-    std::vector<ExPolygonsTile> tile_expolygons(const ExPolygons &expolygons, size_t per_tile)
-    {
-        BoundingBox              extent;
-        std::vector<BoundingBox> bboxes;
-        bboxes.reserve(expolygons.size());
-        for (const ExPolygon &expoly : expolygons) {
-            bboxes.emplace_back(get_extents(expoly));
-            extent.merge(bboxes.back());
-        }
-        if (! extent.defined)
-            return {};
-        const int     tiles  = std::clamp(int(std::sqrt(double(expolygons.size()) / double(std::max<size_t>(per_tile, 1)))), 1, 32);
-        const Point   size   = extent.size();
-        const coord_t tile_w = std::max<coord_t>(1, size.x() / tiles + 1), tile_h = std::max<coord_t>(1, size.y() / tiles + 1);
-        std::vector<ExPolygonsTile> out(size_t(tiles * tiles));
-        for (size_t i = 0; i < expolygons.size(); ++ i) {
-            const Point c = bboxes[i].center();
-            ExPolygonsTile &tile = out[size_t(std::clamp(int((c.y() - extent.min.y()) / tile_h), 0, tiles - 1) * tiles +
-                                              std::clamp(int((c.x() - extent.min.x()) / tile_w), 0, tiles - 1))];
-            tile.members.emplace_back(i);
-            tile.bbox.merge(bboxes[i]);
-        }
-        out.erase(std::remove_if(out.begin(), out.end(), [](const ExPolygonsTile &tile) { return tile.members.empty(); }), out.end());
-        return out;
-    }
-
-    // Between two consecutive heights of its vertices the polygon is a set of trapezoids, and the line through the middle
-    // of that band meets no vertex and no horizontal edge: its crossings with the edges alternate into and out of the
-    // polygon, and there each trapezoid is at least half as wide as at its widest. So the bands are tried widest first,
-    // until the middle of the widest span on that line rounds to a point strictly inside. A band under two units has no
-    // grid line inside it.
-    std::optional<Point> interior_point(const Polygon &polygon)
-    {
-        std::vector<coord_t> heights;
-        heights.reserve(polygon.size());
-        for (const Point &pt : polygon.points)
-            heights.emplace_back(pt.y());
-        std::sort(heights.begin(), heights.end());
-        heights.erase(std::unique(heights.begin(), heights.end()), heights.end());
-        std::vector<std::pair<coord_t, coord_t>> bands;
-        for (size_t i = 1; i < heights.size(); ++ i)
-            if (heights[i] - heights[i - 1] >= 2)
-                bands.emplace_back(heights[i - 1], heights[i]);
-        std::sort(bands.begin(), bands.end(), [](const auto &a, const auto &b) { return a.second - a.first > b.second - b.first; });
-        std::vector<double> crossings;
-        for (const auto &[low, high] : bands) {
-            const coord_t y = low + (high - low) / 2;
-            crossings.clear();
-            for (size_t i = 0, j = polygon.size() - 1; i < polygon.size(); j = i ++) {
-                const Point &a = polygon.points[j];
-                const Point &b = polygon.points[i];
-                if ((a.y() > y) != (b.y() > y))
-                    crossings.emplace_back(double(a.x()) + double(y - a.y()) * double(b.x() - a.x()) / double(b.y() - a.y()));
-            }
-            std::sort(crossings.begin(), crossings.end());
-            // Inside from the first crossing to the second, from the third to the fourth...
-            double left = 0., right = 0.;
-            for (size_t i = 1; i < crossings.size(); i += 2)
-                if (crossings[i] - crossings[i - 1] > right - left) {
-                    left  = crossings[i - 1];
-                    right = crossings[i];
-                }
-            if (const Point pt(coord_t(std::round(0.5 * (left + right))), y); right > left && contains(polygon, pt, false))
-                return pt;
-        }
-        return std::nullopt;
-    }
-}
-
-static Slic3r::ExPolygons clipper_ex_by_piece(ClipType clipType, const Slic3r::ExPolygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset)
-{
-    // A few dozen subject ExPolygons to a tile, each tile one Clipper call with the clip cut to the tile's box.
-    const std::vector<ClipperUtils::ExPolygonsTile> tiles = ClipperUtils::tile_expolygons(subject, 32);
-    // One tile is the plain call: cutting the clip would only cost time.
-    if (tiles.size() <= 1)
-        return _clipper_ex(clipType, ClipperUtils::ExPolygonsProvider(subject), ClipperUtils::PolygonsProvider(clip), do_safety_offset);
-    std::vector<BoundingBox> clip_bboxes;
-    clip_bboxes.reserve(clip.size());
-    for (const Polygon &polygon : clip)
-        clip_bboxes.emplace_back(get_extents(polygon));
-
-    std::vector<Slic3r::ExPolygons> out_tiles(tiles.size());
-    tbb::parallel_for(size_t(0), tiles.size(), [&](size_t tile_idx) {
-        const ClipperUtils::ExPolygonsTile &tile = tiles[tile_idx];
-        Slic3r::ExPolygons local_subject;
-        local_subject.reserve(tile.members.size());
-        for (size_t i : tile.members)
-            local_subject.emplace_back(subject[i]);
-        // Grown so that the cut edges of the clip stay clear of the subject, also after the safety offset.
-        const BoundingBox bbox = tile.bbox.inflated(SCALED_EPSILON);
-        Polygons local_clip;
-        for (size_t i = 0; i < clip.size(); ++i)
-            if (clip_bboxes[i].overlap(bbox))
-                if (Polygon clipped = ClipperUtils::clip_clipper_polygon_with_subject_bbox(clip[i], bbox); ! clipped.empty())
-                    local_clip.emplace_back(std::move(clipped));
-        out_tiles[tile_idx] = _clipper_ex(clipType, ClipperUtils::ExPolygonsProvider(local_subject), ClipperUtils::PolygonsProvider(local_clip), do_safety_offset);
-    });
-    Slic3r::ExPolygons out;
-    for (Slic3r::ExPolygons &out_tile : out_tiles)
-        append(out, std::move(out_tile));
-    return out;
-}
-Slic3r::ExPolygons diff_ex_by_piece(const Slic3r::ExPolygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset)
-    { return clipper_ex_by_piece(ctDifference, subject, clip, do_safety_offset); }
-Slic3r::ExPolygons intersection_ex_by_piece(const Slic3r::ExPolygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset)
-    { return clipper_ex_by_piece(ctIntersection, subject, clip, do_safety_offset); }
 // May be used to "heal" unusual models (3DLabPrints etc.) by providing fill_type (pftEvenOdd, pftNonZero, pftPositive, pftNegative).
 Slic3r::ExPolygons union_ex(const Slic3r::Polygons &subject, PolyFillType fill_type)
     { return _clipper_ex(ctUnion, ClipperUtils::PolygonsProvider(subject), ClipperUtils::EmptyPathsProvider(), ApplySafetyOffset::No, fill_type); }
@@ -1195,75 +1007,24 @@ Lines _clipper_ln(ClipType clipType, const Lines &subject, const Polygons &clip)
     return retval;
 }
 
-// Chains the loops of one level of the tree, each followed by the loops under it, depth first. Clipper2 may put a loop
-// beside the loop around it instead of under it (see c2_append_expolygons()), out of the nesting order the callers rely
-// on: the spiral of FillSpiralInset continues only into a loop inside the last one. So a loop whose orientation doesn't
-// fit its level (CCW under the top or a CW loop, CW under a CCW loop) goes under the smallest loop of the level around
-// it, the one Clipper2 failed to put it under, and stays where it is if none is.
-static void traverse_pt_outside_in(const std::vector<const C2::PolyPath64*> &nodes, bool holes, Polygons *retval)
+static void traverse_pt_outside_in(const C2::PolyPath64 &parent, Polygons *retval)
 {
-    struct Loop
-    {
-        const C2::PolyPath64              *node;
-        double                             area;
-        // The loops to traverse under this one: its children, then the misplaced loops it takes in.
-        std::vector<const C2::PolyPath64*> next;
-        bool                               moved = false;
-    };
-    std::vector<Loop>   loops;
-    std::vector<size_t> fitting, misfits;
-    loops.reserve(nodes.size());
-    for (const C2::PolyPath64 *node : nodes) {
-        Loop &loop = loops.emplace_back(Loop{ node, C2::Area(node->Polygon()), {} });
-        loop.next.reserve(node->Count());
-        for (const auto &child : *node)
-            loop.next.emplace_back(child.get());
-        ((loop.area < 0.) == holes ? fitting : misfits).emplace_back(loops.size() - 1);
-    }
-    if (! misfits.empty()) {
-        // Candidates are tried smallest first, from the first one larger than the misplaced loop (see path_encloses()).
-        std::sort(fitting.begin(), fitting.end(), [&loops](size_t a, size_t b) { return std::abs(loops[a].area) < std::abs(loops[b].area); });
-        std::vector<C2::Rect64> bounds(loops.size());
-        for (size_t i = 0; i < loops.size(); ++ i)
-            bounds[i] = C2::GetBounds(loops[i].node->Polygon());
-        for (size_t misfit : misfits) {
-            Loop             &loop = loops[misfit];
-            const C2::Rect64 &box  = bounds[misfit];
-            Polygon           inner;
-            inner.points = c2_to_points(loop.node->Polygon());
-            for (size_t idx : fitting) {
-                // The slack of a vertex rounded across the candidate, as in c2_attach_stray_holes().
-                const C2::Rect64 &around = bounds[idx];
-                if (std::abs(loops[idx].area) <= std::abs(loop.area) || around.left - SCALED_EPSILON > box.left ||
-                    around.right + SCALED_EPSILON < box.right || around.top - SCALED_EPSILON > box.top || around.bottom + SCALED_EPSILON < box.bottom)
-                    continue;
-                Polygon outer;
-                outer.points = c2_to_points(loops[idx].node->Polygon());
-                if (path_encloses(outer, inner)) {
-                    loops[idx].next.emplace_back(loop.node);
-                    loop.moved = true;
-                    break;
-                }
-            }
-        }
-    }
+    // collect ordering points
+    Points ordering_points;
+    ordering_points.reserve(parent.Count());
+    for (const auto &node : parent)
+        ordering_points.emplace_back(node->Polygon().front().x, node->Polygon().front().y);
 
-    // Chain the loops staying on this level, push results recursively.
-    std::vector<size_t> staying;
-    Points              ordering_points;
-    for (size_t i = 0; i < loops.size(); ++ i)
-        if (! loops[i].moved) {
-            staying.emplace_back(i);
-            ordering_points.emplace_back(loops[i].node->Polygon().front().x, loops[i].node->Polygon().front().y);
-        }
+    // Perform the ordering, push results recursively.
     //FIXME pass the last point to chain_points?
     for (size_t idx : chain_points(ordering_points)) {
-        const Loop &loop = loops[staying[idx]];
-        retval->emplace_back().points = c2_to_points(loop.node->Polygon());
-        if (loop.area < 0.)
+        const C2::PolyPath64 &node = *parent.Child(idx);
+        retval->emplace_back().points = c2_to_points(node.Polygon());
+        if (node.IsHole())
             // Orient a hole, which is clockwise oriented, to CCW.
             retval->back().reverse();
-        traverse_pt_outside_in(loop.next, loop.area > 0., retval);
+        // traverse the next depth
+        traverse_pt_outside_in(node, retval);
     }
 }
 
@@ -1271,12 +1032,8 @@ Polygons union_pt_chained_outside_in(const Polygons &subject)
 {
     C2::PolyTree64 tree;
     c2_clip(C2::ClipType::Union, to_paths64(ClipperUtils::PolygonsProvider(subject)), {}, C2::FillRule::EvenOdd, tree);
-    std::vector<const C2::PolyPath64*> top_level;
-    top_level.reserve(tree.Count());
-    for (const auto &node : tree)
-        top_level.emplace_back(node.get());
     Polygons retval;
-    traverse_pt_outside_in(top_level, false, &retval);
+    traverse_pt_outside_in(tree, &retval);
     return retval;
 }
 
@@ -1313,8 +1070,6 @@ ExPolygons top_level_expolygons(const ExPolygons &expolygons, ExPolygons *nested
     c2_clip(C2::ClipType::Union, to_paths64(ClipperUtils::ExPolygonsProvider(expolygons)), {}, C2::FillRule::EvenOdd, tree);
     ExPolygons out;
     out.reserve(tree.Count());
-    const size_t                   first_nested = nested ? nested->size() : 0;
-    std::vector<const C2::Path64*> stray_holes;
     for (const auto &outer : tree) {
         ExPolygon &expoly = out.emplace_back();
         expoly.contour.points = c2_to_points(outer->Polygon());
@@ -1322,11 +1077,9 @@ ExPolygons top_level_expolygons(const ExPolygons &expolygons, ExPolygons *nested
             expoly.holes.emplace_back().points = c2_to_points(hole->Polygon());
             if (nested)
                 for (const auto &island : *hole)
-                    c2_append_expolygons(*island, *nested, stray_holes);
+                    c2_append_expolygons(*island, *nested);
         }
     }
-    if (nested)
-        c2_attach_stray_holes(*nested, first_nested, stray_holes);
     return out;
 }
 

src/libslic3r/ClipperUtils.hpp

@@ -5,14 +5,12 @@
 #include "Polyline.hpp"
 #include "Line.hpp"
 #include "libslic3r.h"
-#include "BoundingBox.hpp"
 #include "ExPolygon.hpp"
 #include "Polygon.hpp"
 #include "Surface.hpp"
 #include <cstddef>
 #include <iterator>
 #include <cassert>
-#include <optional>
 #include <vector>
 
 namespace Slic3r {
@@ -334,19 +332,6 @@ namespace ClipperUtils {
     [[nodiscard]] Polygons clip_clipper_polygons_with_subject_bbox(const ExPolygon &src, const BoundingBox &bbox, const bool get_entire_polygons = false);
     [[nodiscard]] Polygons clip_clipper_polygons_with_subject_bbox(const ExPolygons &src, const BoundingBox &bbox, const bool get_entire_polygons = false);
 
-    // Splits ExPolygons into tiles by the centres of their boxes, about `per_tile` of them to a tile, to run Clipper on a
-    // layer of many pieces tile by tile. Returns the non-empty tiles, each with the indices of its ExPolygons and their box.
-    struct ExPolygonsTile
-    {
-        BoundingBox         bbox;
-        std::vector<size_t> members;
-    };
-    [[nodiscard]] std::vector<ExPolygonsTile> tile_expolygons(const ExPolygons &expolygons, size_t per_tile);
-
-    // A grid point strictly inside the polygon, or none if the polygon is at most a few units thick everywhere.
-    // Decides on which side of another path a path lies when every one of its vertices touches that path.
-    [[nodiscard]] std::optional<Point> interior_point(const Polygon &polygon);
-
     }
 
 // offset Polygons
@@ -542,11 +527,6 @@ Slic3r::ExPolygons intersection_ex(const Slic3r::Surfaces &subject, const Slic3r
 Slic3r::ExPolygons intersection_ex(const Slic3r::Surfaces &subject, const Slic3r::ExPolygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::ExPolygons intersection_ex(const Slic3r::Surfaces &subject, const Slic3r::Surfaces &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::ExPolygons intersection_ex(const Slic3r::SurfacesPtr &subject, const Slic3r::ExPolygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
-// diff_ex() / intersection_ex() of the subject split into tiles, each against only the part of the clip near it, the tiles in
-// parallel. The same area as the operation on the whole subject when its ExPolygons do not overlap, and much faster for a
-// subject of thousands of pieces spread over a layer: Clipper slows down with the number of edges crossing a scan line.
-Slic3r::ExPolygons diff_ex_by_piece(const Slic3r::ExPolygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
-Slic3r::ExPolygons intersection_ex_by_piece(const Slic3r::ExPolygons &subject, const Slic3r::Polygons &clip, ApplySafetyOffset do_safety_offset = ApplySafetyOffset::No);
 Slic3r::Polylines  intersection_pl(const Slic3r::Polylines &subject, const Slic3r::Polygon &clip);
 Slic3r::Polylines  intersection_pl(const Slic3r::Polyline &subject, const Slic3r::ExPolygon &clip);
 Slic3r::Polylines  intersection_pl(const Slic3r::Polylines &subject, const Slic3r::ExPolygon &clip);

src/libslic3r/Fill/Fill.cpp

@@ -22,8 +22,6 @@
 #include "../PrintConfig.hpp"
 #include "../Surface.hpp"
 
-#include <tbb/parallel_for.h>
-
 #include "AABBTreeLines.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/ExPolygon.hpp"
@@ -677,28 +675,24 @@ void split_solid_surface(size_t layer_id, const SurfaceFill &fill, ExPolygons &n
     if (!line_based_pattern) {
         const coord_t scaled_spacing = scaled<coord_t>(fill.params.spacing);
 
-        // Each expolygon is split on its own, so they run in parallel and are collected in their original order.
-        std::vector<std::pair<ExPolygons, ExPolygons>> split_parts(fill.expolygons.size()); // normal, narrow
-        tbb::parallel_for(size_t(0), fill.expolygons.size(), [&](size_t idx) {
-            const ExPolygon &expolygon = fill.expolygons[idx];
+        for (const ExPolygon &expolygon : fill.expolygons) {
             Polygons filled_area = to_polygons(expolygon);
 
             // "Core" area: open (erode+dilate) to drop thin features, then clamp back to the original polygon.
             Polygons inner_area  = intersection(filled_area, opening(filled_area, scaled_spacing, scaled_spacing));
 
             if (inner_area.empty()) {
-                split_parts[idx].second.emplace_back(expolygon);
-                return;
+                narrow_infill.emplace_back(expolygon);
+                continue;
             }
 
             ExPolygons inner_ex = union_ex(inner_area);
             ExPolygons expolys{expolygon};
-            split_parts[idx].second = diff_ex(expolys, inner_ex);         // narrow infill area
-            split_parts[idx].first  = intersection_ex(expolys, inner_ex); // normal infill area
-        });
-        for (auto &[normal_ex, narrow_ex] : split_parts) {
-            append(normal_infill, std::move(normal_ex));
-            append(narrow_infill, std::move(narrow_ex));
+            ExPolygons narrow_ex = diff_ex(expolys, inner_ex);
+            ExPolygons normal_ex = intersection_ex(expolys, inner_ex);
+
+            append(normal_infill, normal_ex); // normal infill area
+            append(narrow_infill, narrow_ex); // narrow infill area
         }
 
         return;
@@ -720,10 +714,7 @@ void split_solid_surface(size_t layer_id, const SurfaceFill &fill, ExPolygons &n
     }
     const double aligning_angle = -base_angle + PI;
 
-    // Each expolygon is reconstructed on its own, so they run in parallel and are collected in their original order.
-    std::vector<Polygons> split_reconstructed(fill.expolygons.size());
-    tbb::parallel_for(size_t(0), fill.expolygons.size(), [&](size_t expolygon_idx) {
-        const ExPolygon &expolygon = fill.expolygons[expolygon_idx];
+	for (const ExPolygon &expolygon : fill.expolygons) {
         Polygons filled_area = to_polygons(expolygon);
         polygons_rotate(filled_area, aligning_angle);
         BoundingBox bb = get_extents(filled_area);
@@ -854,10 +845,8 @@ void split_solid_surface(size_t layer_id, const SurfaceFill &fill, ExPolygons &n
             }
         }
 
-        split_reconstructed[expolygon_idx] = std::move(reconstructed_area);
-    });
-    for (Polygons &reconstructed_area : split_reconstructed)
-        polygons_append(normal_fill_areas, std::move(reconstructed_area));
+        polygons_append(normal_fill_areas, reconstructed_area);
+    }
 
     polygons_rotate(normal_fill_areas, -aligning_angle);
 
@@ -1484,15 +1473,7 @@ void Layer::make_fills(const FillAdaptive::RegionOctrees* fill_octrees, FillLigh
             f->set_bounding_box(body >= 0 ? this->object()->separated_body_bboxes()[body] : bbox);
             f->adapt_fill_octree = octrees ? octrees->get(body) : nullptr;
 
-            // Only the part of the layer-wide no-overlap area under this expolygon matters, so clip it to the
-            // expolygon's box first (padded past the safety offset, which grows the clip side). The result is
-            // identical; the cost is not: a layer split into many small fills, e.g. by colour painting,
-            // otherwise intersects every one of them with the whole layer.
-            BoundingBox no_overlap_bbox = get_extents(expoly);
-            no_overlap_bbox.offset(SCALED_EPSILON);
-            f->no_overlap_expolygons = intersection_ex(
-                ClipperUtils::clip_clipper_polygons_with_subject_bbox(surface_fill.no_overlap_expolygons, no_overlap_bbox),
-                ExPolygons() = {expoly}, ApplySafetyOffset::Yes);
+            f->no_overlap_expolygons = intersection_ex(surface_fill.no_overlap_expolygons, ExPolygons() = {expoly}, ApplySafetyOffset::Yes);
             if (params.symmetric_infill_y_axis) {
                 params.symmetric_y_axis = f->extended_object_bounding_box().center().x();
                 expoly.symmetric_y(params.symmetric_y_axis);

src/libslic3r/Fill/FillBase.cpp

@@ -2914,7 +2914,7 @@ void multiline_fill(Polylines& polylines, const FillParams& params, float spacin
 
         const float delta = float(scale_(t));
         // Arc tolerance of 1/500 of the offset, Clipper2's default.
-        for (const Polygon &ring : offset(polylines, delta, jtMiter, 0.002 * delta, etOpenRound))
+        for (const Polygon &ring : offset(polylines, delta, jtRound, 0.002 * delta, etOpenRound))
             if (ring.size() >= 3)
                 all_polylines.emplace_back(ring.split_at_first_point());
     }

src/libslic3r/GCode.cpp

@@ -3979,22 +3979,22 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
         this->placeholder_parser().set("hold_chamber_temp_for_flat_print", new ConfigOptionBool(hold_chamber_temp_for_flat_print));
     }
 
-    this->placeholder_parser().set_deferred("print_time_total_sec", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Total_Sec_Placeholder));
-    this->placeholder_parser().set_deferred("print_time_day", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Day_Placeholder));
-    this->placeholder_parser().set_deferred("print_time_hour", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Hour_Placeholder));
-    this->placeholder_parser().set_deferred("print_time_minute", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Minute_Placeholder));
-    this->placeholder_parser().set_deferred("print_time_sec", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Sec_Placeholder));
-    this->placeholder_parser().set_deferred("used_filament_length", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder));
+    this->placeholder_parser().set("print_time_total_sec", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Total_Sec_Placeholder)));
+    this->placeholder_parser().set("print_time_day", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Day_Placeholder)));
+    this->placeholder_parser().set("print_time_hour", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Hour_Placeholder)));
+    this->placeholder_parser().set("print_time_minute", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Minute_Placeholder)));
+    this->placeholder_parser().set("print_time_sec", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Sec_Placeholder)));
+    this->placeholder_parser().set("used_filament_length", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
     // The final print statistics are known only after the whole G-code is generated, so they are filled in during post-processing too.
     // The running extruded_* totals are left alone; profiles use them as numbers.
-    this->placeholder_parser().set_deferred("used_filament", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder));
-    this->placeholder_parser().set_deferred("print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder));
-    this->placeholder_parser().set_deferred("normal_print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder));
-    this->placeholder_parser().set_deferred("silent_print_time", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Silent_Print_Time_Placeholder));
-    this->placeholder_parser().set_deferred("total_weight", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Weight_Placeholder));
-    this->placeholder_parser().set_deferred("total_cost", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Cost_Placeholder));
-    this->placeholder_parser().set_deferred("total_wipe_tower_cost", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Cost_Placeholder));
-    this->placeholder_parser().set_deferred("total_wipe_tower_filament", GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Filament_Placeholder));
+    this->placeholder_parser().set("used_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
+    this->placeholder_parser().set("print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
+    this->placeholder_parser().set("normal_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
+    this->placeholder_parser().set("silent_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Silent_Print_Time_Placeholder)));
+    this->placeholder_parser().set("total_weight", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Weight_Placeholder)));
+    this->placeholder_parser().set("total_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Cost_Placeholder)));
+    this->placeholder_parser().set("total_wipe_tower_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Cost_Placeholder)));
+    this->placeholder_parser().set("total_wipe_tower_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Filament_Placeholder)));
 
     // Sync variant-mapped params into placeholder_parser before processing start gcode
     update_placeholder_parser_with_variant_params();
@@ -9214,9 +9214,10 @@ std::string GCode::_extrude(const ExtrusionPath &path, const std::string &path_d
         effective_height = static_cast<float>(m_sub_layer_height);
     }
 
-    // _mm3_per_mm already includes the filament flow ratio, so convert it with the bare cross-section
-    // rather than e_per_mm3(), which would apply the ratio a second time.
-    double e_per_mm = _mm3_per_mm / m_writer.filament()->filament_crossection();
+    // Effective extrusion length per distance unit = (filament_flow_ratio/cross_section) * mm3_per_mm / print flow ratio
+    // m_writer.extruder()->e_per_mm3() below is (filament flow ratio / cross-sectional area)
+    double e_per_mm = m_writer.filament()->e_per_mm3() * _mm3_per_mm;
+    e_per_mm /= filament_flow_ratio;
 
     // set speed
     if (speed == -1) {

src/libslic3r/GCode/OrderingStrategies.cpp

@@ -6,7 +6,6 @@
 #include "../ShortestPath.hpp"
 #include "libslic3r/Point.hpp"
 #include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/libslic3r.h"
 
 #include <algorithm>
 #include <cassert>
@@ -142,87 +141,15 @@ bool tsp_remove_crossings(std::vector<size_t>& path, const Points& centers)
         return {std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max()};
     };
 
-    // For many islands, the same scan with the edges binned in a uniform grid over their boxes, so each edge is only tested against the edges sharing a
-    // cell with it - two edges whose boxes overlap always do. It returns the same crossing as the all-pairs scan
-    // (smallest i, then smallest j), so the result is unchanged. The all-pairs scan is quadratic in the edge count and
-    // runs again after every reversal; rebuilding the grid costs more than it saves below the threshold.
-    constexpr size_t grid_min_size = 500;
-    BoundingBox extent;
-    for (size_t idx : path)
-        extent.merge(centers[idx]);
-    const int     grid_n = std::clamp(int(std::sqrt(double(pn))), 1, 256);
-    const coord_t cell_w = std::max<coord_t>(1, (extent.max.x() - extent.min.x()) / grid_n + 1);
-    const coord_t cell_h = std::max<coord_t>(1, (extent.max.y() - extent.min.y()) / grid_n + 1);
-    const auto    for_cells = [&](const Point& a, const Point& b, auto&& fn) {
-        const int x0 = int((std::min(a.x(), b.x()) - extent.min.x()) / cell_w), x1 = int((std::max(a.x(), b.x()) - extent.min.x()) / cell_w);
-        const int y0 = int((std::min(a.y(), b.y()) - extent.min.y()) / cell_h), y1 = int((std::max(a.y(), b.y()) - extent.min.y()) / cell_h);
-        for (int y = y0; y <= y1; ++y)
-            for (int x = x0; x <= x1; ++x)
-                fn(y * grid_n + x);
-    };
-    std::vector<std::vector<size_t>> edge_cells(size_t(grid_n) * grid_n);
-
-    auto find_crossing_grid = [&]() -> std::pair<size_t, size_t> {
-        for (std::vector<size_t>& cell : edge_cells)
-            cell.clear();
-        for (size_t j = 0; j < n_edges; ++j)
-            for_cells(centers[path[j]], centers[path[(j + 1) % pn]], [&](int cell) { edge_cells[cell].emplace_back(j); });
-
-        for (size_t i = 0; i < n_edges; ++i) {
-            const Point& ai = centers[path[i]];
-            const Point& bi = centers[path[(i + 1) % pn]];
-
-            size_t first_j = std::numeric_limits<size_t>::max();
-            for_cells(ai, bi, [&](int cell) {
-                for (size_t j : edge_cells[cell]) {
-                    if (j < i + 2 || j >= first_j) continue;
-                    // Skip the (0, pn-1) pair: edges (0,1) and (pn-1,0) share node 0.
-                    if (i == 0 && j == pn - 1) continue;
-
-                    const Point& aj = centers[path[j]];
-                    const Point& bj = centers[path[(j + 1) % pn]];
-
-                    if (!bboxes_overlap(ai, bi, aj, bj)) continue;
-                    if (Geometry::segments_intersect(ai, bi, aj, bj))
-                        first_j = j;
-                }
-            });
-            if (first_j != std::numeric_limits<size_t>::max())
-                return {i, first_j};
-        }
-        return {std::numeric_limits<size_t>::max(), std::numeric_limits<size_t>::max()};
-    };
-
     // Process crossings one at a time: find first, reverse it, restart scan.
     // Cap iterations to prevent infinite loops on collinear/overlapping segments.
-    const int max_iters = static_cast<int>(pn * pn);
+    int max_iters = static_cast<int>(pn * pn);
     bool improved = false;
-    // Reversing between two segments that only touch or overlap along a line need not remove the intersection, so on
-    // islands laid out on a regular grid (a tiled texture, an array of parts) the loop can cycle through the same
-    // orderings until the pn * pn cap. Once an ordering repeats the rest of the loop is periodic, so only the steps
-    // to the ordering the capped loop would have stopped on are taken.
-    std::unordered_map<uint64_t, int> seen_paths; // path hash -> reversals done when it was reached
-    const auto path_hash = [&path]() {
-        uint64_t h = 1469598103934665603ull; // FNV-1a
-        for (size_t idx : path)
-            h = (h ^ uint64_t(idx)) * 1099511628211ull;
-        return h;
-    };
-    const auto reverse_first_crossing = [&]() {
-        auto [ci, cj] = pn >= grid_min_size ? find_crossing_grid() : find_crossing();
-        if (ci == std::numeric_limits<size_t>::max())
-            return false;
-        std::reverse(path.begin() + ci + 1, path.begin() + cj + 1);
-        return true;
-    };
-    seen_paths.emplace(path_hash(), 0);
-    for (int iter = 1; iter <= max_iters && reverse_first_crossing(); ++iter) {
+    while (max_iters-- > 0) {
+        auto [ci, cj] = find_crossing();
+        if (ci == std::numeric_limits<size_t>::max()) break;
         improved = true;
-        if (auto [it, inserted] = seen_paths.emplace(path_hash(), iter); !inserted) {
-            for (int steps = (max_iters - iter) % (iter - it->second); steps > 0; --steps)
-                reverse_first_crossing();
-            break;
-        }
+        std::reverse(path.begin() + ci + 1, path.begin() + cj + 1);
     }
     return improved;
 }

src/libslic3r/GCode/SeamPlacer.cpp

@@ -29,7 +29,6 @@
 #include <memory>
 #include <random>
 #include <algorithm>
-#include <limits>
 #include <queue>
 #include <string>
 #include <unordered_map>
@@ -1208,21 +1207,21 @@ std::optional<std::pair<size_t, size_t>> SeamPlacer::find_next_seam_in_layer(
     const size_t layer_idx, const float max_distance,
     const SeamPlacerImpl::SeamComparator &comparator) const {
   using namespace SeamPlacerImpl;
-  // Find the best nearby point and the nearest one. A layer of a fine relief has tens of thousands of candidates within
-  // the radius, so they are looked at as the search finds them rather than collected into a vector first.
-  constexpr size_t none = std::numeric_limits<size_t>::max();
-  size_t best_nearby_point_index = none;
-  size_t nearest_point_index = none;
-  visit_nearby_points(*layers[layer_idx].points_tree, projected_position, max_distance,
-                      [&layers, &comparator, &projected_position, layer_idx, &best_nearby_point_index, &nearest_point_index]
-                      (size_t nearby_point_index) {
-    if (best_nearby_point_index == none) {
-      // The first point found starts both, as the first of the collected ones did.
-      best_nearby_point_index = nearest_point_index = nearby_point_index;
-    }
+  std::vector<size_t> nearby_points_indices = find_nearby_points(*layers[layer_idx].points_tree, projected_position,
+                                                                 max_distance);
+
+  if (nearby_points_indices.empty()) {
+    return {};
+  }
+
+  size_t best_nearby_point_index = nearby_points_indices[0];
+  size_t nearest_point_index = nearby_points_indices[0];
+
+  // Now find best nearby point, nearest point, and corresponding indices
+  for (const size_t &nearby_point_index : nearby_points_indices) {
     const SeamCandidate &point = layers[layer_idx].points[nearby_point_index];
     if (point.perimeter.finalized) {
-      return; // skip over finalized perimeters, try to find some that is not finalized
+      continue; // skip over finalized perimeters, try to find some that is not finalized
     }
     if (comparator.is_first_better(point, layers[layer_idx].points[best_nearby_point_index],
                                    projected_position.head<2>())
@@ -1234,10 +1233,6 @@ std::optional<std::pair<size_t, size_t>> SeamPlacer::find_next_seam_in_layer(
         || layers[layer_idx].points[nearest_point_index].perimeter.finalized) {
       nearest_point_index = nearby_point_index;
     }
-  });
-
-  if (best_nearby_point_index == none) {
-    return {};
   }
 
   const SeamCandidate &best_nearby_point = layers[layer_idx].points[best_nearby_point_index];

src/libslic3r/KDTreeIndirect.hpp

@@ -318,36 +318,6 @@ std::vector<size_t> find_nearby_points(const KDTreeIndirectType &kdtree, const P
     return visitor.result;
 }
 
-// Visits the points within max_distance of center, in the order find_nearby_points() would collect them, and hands
-// each of them to `visitor_fn` instead of returning them all: a search over a dense set spends more on collecting the
-// points into a vector than on the search itself, and its caller usually keeps only a few of them.
-template<typename KDTreeIndirectType, typename PointType, typename VisitorFn>
-void visit_nearby_points(const KDTreeIndirectType &kdtree, const PointType &center,
-                         const typename KDTreeIndirectType::CoordType &max_distance, VisitorFn visitor_fn)
-{
-    using CoordType = typename KDTreeIndirectType::CoordType;
-
-    struct Visitor {
-        const KDTreeIndirectType &kdtree;
-        const PointType           center;
-        const CoordType           max_distance_squared;
-        VisitorFn                 visitor_fn;
-
-        unsigned int operator()(size_t idx, size_t dimension) {
-            auto dist = CoordType(0);
-            for (size_t i = 0; i < KDTreeIndirectType::NumDimensions; ++i) {
-                CoordType d = center[i] - kdtree.coordinate(idx, i);
-                dist += d * d;
-            }
-            if (dist < max_distance_squared)
-                visitor_fn(idx);
-            return kdtree.descent_mask(center[dimension], max_distance_squared, idx, dimension);
-        }
-    } visitor { kdtree, center, max_distance * max_distance, visitor_fn };
-
-    kdtree.visit(visitor);
-}
-
 template<typename KDTreeIndirectType, typename PointType>
 std::vector<size_t> find_nearby_points(const KDTreeIndirectType &kdtree, const PointType &center,
                                        const typename KDTreeIndirectType::CoordType& max_distance)

src/libslic3r/LayerRegion.cpp

@@ -99,11 +99,10 @@ void LayerRegion::slices_to_fill_surfaces_clipped()
         by_surface[size_t(surface.surface_type)].emplace_back(&surface);
     // Trim surfaces by the fill_boundaries.
     this->fill_surfaces.surfaces.clear();
-    const Polygons fill_boundaries = to_polygons(this->fill_expolygons);
     for (size_t surface_type = 0; surface_type < size_t(stCount); ++ surface_type) {
         const SurfacesPtr &this_surfaces = by_surface[surface_type];
         if (! this_surfaces.empty())
-            this->fill_surfaces.append(intersection_ex_by_piece(to_expolygons(this_surfaces), fill_boundaries), SurfaceType(surface_type));
+            this->fill_surfaces.append(intersection_ex(this_surfaces, this->fill_expolygons), SurfaceType(surface_type));
     }
 }
 

src/libslic3r/MultiMaterialSegmentation.cpp

@@ -22,7 +22,6 @@
 #include "Surface.hpp"
 #include "libslic3r.h"
 
-#include <numeric>
 #include <cmath>
 #include <cstddef>
 #include <list>
@@ -1362,15 +1361,10 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
     }
 #endif // MM_SEGMENTATION_DEBUG_TOP_BOTTOM
 
-    // When the upper surface of an object is occluded, it should no longer be considered the upper surface.
-    // Every (colour, layer) pair is trimmed on its own, so they all run at once: the painted faces of a finely
-    // textured part project hundreds of thousands of triangles onto one layer, which used to be trimmed serially.
+    // When the upper surface of an object is occluded, it should no longer be considered the upper surface
     {
-        const size_t occluded_pairs = num_facets_states * layers.size();
-        tbb::parallel_for(tbb::blocked_range<size_t>(0, occluded_pairs), [&](const tbb::blocked_range<size_t> &range) {
-            for (size_t pair_idx = range.begin(); pair_idx < range.end(); ++pair_idx) {
-                const size_t extruder_idx = pair_idx / layers.size();
-                const size_t layer_idx    = pair_idx % layers.size();
+        for (size_t extruder_idx = 0; extruder_idx < num_facets_states; ++extruder_idx) {
+            for (size_t layer_idx = 0; layer_idx < layers.size(); ++layer_idx) {
                 if (!top_raw[extruder_idx].empty() && !top_raw[extruder_idx][layer_idx].empty() && layer_idx + 1 < layers.size()) {
                     top_raw[extruder_idx][layer_idx] = diff(top_raw[extruder_idx][layer_idx], input_expolygons[layer_idx + 1]);
                 }
@@ -1378,7 +1372,7 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
                     bottom_raw[extruder_idx][layer_idx] = diff(bottom_raw[extruder_idx][layer_idx], input_expolygons[layer_idx - 1]);
                 }
             }
-        });
+        }
     }
 
     std::vector<std::vector<ExPolygons>> triangles_by_color_bottom(num_facets_states);
@@ -1436,58 +1430,11 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
         return out;
     };
 
-    // Projects a painted top or bottom face `ex` of layer `layer_idx` onto the shell layers below or above it (in
-    // `shell_layers`, nearest first), one more perimeter in on each, stopping at the first layer where nothing is left.
-    // Only the slices within the deepest offset of `ex` (three times that with the miter joins) decide the result, so the
-    // work is done per tile of `ex`'s ExPolygons on the slices cut to the tile's box grown by that much: the same result, but
-    // each Clipper call stays the size of a tile rather than of a layer cut through a fine relief, and the tiles run in
-    // parallel.
-    const auto project_to_shells = [&input_expolygons](const ExPolygons &ex, size_t layer_idx, const std::vector<size_t> &shell_layers,
-                                                       const LayerColorStat &stat, ShellProjections &dst) {
-        std::vector<float> offsets(shell_layers.size());
-        float              offset = 0.f;
-        for (size_t i = 0; i < shell_layers.size(); ++i) {
-            //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
-            offset -= (stat.extrusion_spacing + stat.extrusion_width);
-            offsets[i] = offset;
-        }
-        if (offsets.empty())
-            return;
-        const coord_t reach = coord_t(std::ceil(DefaultMiterLimit * std::abs(offsets.back()))) + 10 * SCALED_EPSILON;
-        const std::vector<ClipperUtils::ExPolygonsTile> tiles = ClipperUtils::tile_expolygons(ex, 16);
-        // [shell layer][tile]
-        std::vector<std::vector<ExPolygons>> shells(shell_layers.size(), std::vector<ExPolygons>(tiles.size()));
-        tbb::parallel_for(size_t(0), tiles.size(), [&](size_t tile_idx) {
-            const ClipperUtils::ExPolygonsTile &tile = tiles[tile_idx];
-            const BoundingBox                   bbox = tile.bbox.inflated(reach);
-            ExPolygons                          tile_ex;
-            tile_ex.reserve(tile.members.size());
-            for (size_t i : tile.members)
-                tile_ex.emplace_back(ex[i]);
-            Polygons layer_slices_trimmed = ClipperUtils::clip_clipper_polygons_with_subject_bbox(input_expolygons[layer_idx], bbox);
-            for (size_t i = 0; i < shell_layers.size() && ! layer_slices_trimmed.empty(); ++i) {
-                const ExPolygons trimmed = intersection_ex(layer_slices_trimmed, ClipperUtils::clip_clipper_polygons_with_subject_bbox(input_expolygons[shell_layers[i]], bbox));
-                shells[i][tile_idx]  = opening_ex(intersection_ex(tile_ex, offset_ex(trimmed, offsets[i])), stat.small_region_threshold);
-                layer_slices_trimmed = to_polygons(trimmed);
-            }
-        });
-        for (size_t i = 0; i < shell_layers.size(); ++i) {
-            ExPolygons shell;
-            for (ExPolygons &tile_shell : shells[i])
-                append(shell, std::move(tile_shell));
-            if (shell.empty())
-                break;
-            dst.emplace_back(shell_layers[i], std::move(shell));
-        }
-    };
-
     tbb::parallel_for(tbb::blocked_range<size_t>(0, num_layers), [&num_layers, &num_facets_states, &layer_color_stat, &top_raw, &triangles_by_color_top,
-                                                                  &throw_on_cancel_callback, &bottom_raw, &triangles_by_color_bottom, &project_to_shells,
+                                                                  &throw_on_cancel_callback, &input_expolygons, &bottom_raw, &triangles_by_color_bottom,
                                                                   &shell_triangles_by_color_top, &shell_triangles_by_color_bottom](const tbb::blocked_range<size_t> &range) {
         for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) {
-            // Each colour writes only its own vectors, so the colours run in parallel: a painted top or bottom face
-            // projects onto a single layer, which otherwise did all of its colours on one thread.
-            tbb::parallel_for(size_t(0), size_t(num_facets_states), [&](size_t color_idx) {
+            for (size_t color_idx = 0; color_idx < num_facets_states; ++color_idx) {
                 throw_on_cancel_callback();
                 LayerColorStat stat = layer_color_stat(layer_idx, color_idx);
                 if (std::vector<Polygons> &top = top_raw[color_idx]; ! top.empty() && ! top[layer_idx].empty())
@@ -1496,10 +1443,18 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
                         top_ex = opening_ex(top_ex, stat.small_region_threshold);
                         if (! top_ex.empty()) {
                             append(triangles_by_color_top[color_idx][layer_idx], top_ex);
-                            std::vector<size_t> shell_layers;
-                            for (int last_idx = int(layer_idx) - 1; last_idx > std::max(int(layer_idx - stat.top_shell_layers), int(0)); --last_idx)
-                                shell_layers.emplace_back(size_t(last_idx));
-                            project_to_shells(top_ex, layer_idx, shell_layers, stat, shell_triangles_by_color_top[color_idx][layer_idx]);
+                            float offset = 0.f;
+                            ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
+                            for (int last_idx = int(layer_idx) - 1; last_idx > std::max(int(layer_idx - stat.top_shell_layers), int(0)); --last_idx) {
+                                //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
+                                //offset -= stat.extrusion_width ;
+                                offset -= (stat.extrusion_spacing + stat.extrusion_width);
+                                layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
+                                ExPolygons last = opening_ex(intersection_ex(top_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
+                                if (last.empty())
+                                    break;
+                                shell_triangles_by_color_top[color_idx][layer_idx].emplace_back(size_t(last_idx), std::move(last));
+                            }
                         }
                     }
                 if (std::vector<Polygons> &bottom = bottom_raw[color_idx]; ! bottom.empty() && ! bottom[layer_idx].empty())
@@ -1508,13 +1463,21 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
                         bottom_ex = opening_ex(bottom_ex, stat.small_region_threshold);
                         if (! bottom_ex.empty()) {
                             append(triangles_by_color_bottom[color_idx][layer_idx], bottom_ex);
-                            std::vector<size_t> shell_layers;
-                            for (size_t last_idx = layer_idx + 1; last_idx < std::min(layer_idx + stat.bottom_shell_layers, num_layers); ++last_idx)
-                                shell_layers.emplace_back(last_idx);
-                            project_to_shells(bottom_ex, layer_idx, shell_layers, stat, shell_triangles_by_color_bottom[color_idx][layer_idx]);
+                            float offset = 0.f;
+                            ExPolygons layer_slices_trimmed = input_expolygons[layer_idx];
+                            for (size_t last_idx = layer_idx + 1; last_idx < std::min(layer_idx + stat.bottom_shell_layers, num_layers); ++last_idx) {
+                                //BBS: offset width should be 2*spacing to avoid too narrow area which has overlap of wall line
+                                //offset -= stat.extrusion_width;
+                                offset -= (stat.extrusion_spacing + stat.extrusion_width);
+                                layer_slices_trimmed = intersection_ex(layer_slices_trimmed, input_expolygons[last_idx]);
+                                ExPolygons last = opening_ex(intersection_ex(bottom_ex, offset_ex(layer_slices_trimmed, offset)), stat.small_region_threshold);
+                                if (last.empty())
+                                    break;
+                                shell_triangles_by_color_bottom[color_idx][layer_idx].emplace_back(last_idx, std::move(last));
+                            }
                         }
                     }
-            });
+            }
         }
     });
 
@@ -1535,23 +1498,20 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
                                                                   &shell_top_by_layer, &shell_bottom_by_layer](const tbb::blocked_range<size_t> &range) {
         for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) {
             throw_on_cancel_callback();
-            // The per-colour unions below are independent of each other, so they run in parallel (a painted top or
-            // bottom face puts all of its colours on one layer); whatever combines the colours stays in colour order.
-            const auto merge_colour_union = [&](size_t color_idx) {
+            ExPolygons painted_exploys;
+            for (size_t color_idx = 0; color_idx < triangles_by_color_merged.size(); ++color_idx) {
                 auto &self = triangles_by_color_merged[color_idx][layer_idx];
                 append(self, std::move(triangles_by_color_bottom[color_idx][layer_idx]));
                 append(self, std::move(triangles_by_color_top[color_idx][layer_idx]));
                 self = union_ex(self);
-            };
-            tbb::parallel_for(size_t(0), triangles_by_color_merged.size(), merge_colour_union);
 
-            ExPolygons painted_exploys;
-            for (size_t color_idx = 0; color_idx < triangles_by_color_merged.size(); ++color_idx)
-                append(painted_exploys, triangles_by_color_merged[color_idx][layer_idx]);
+                append(painted_exploys, self);
+            }
+
             painted_exploys = union_ex(painted_exploys);
 
             //BBS: merge the top and bottom shell layers
-            tbb::parallel_for(size_t(0), triangles_by_color_merged.size(), [&](size_t color_idx) {
+            for (size_t color_idx = 0; color_idx < triangles_by_color_merged.size(); ++color_idx) {
                 auto &self = triangles_by_color_merged[color_idx][layer_idx];
 
                 auto top_area    = diff_ex(union_ex(shell_top_by_layer[color_idx][layer_idx]), painted_exploys);
@@ -1560,7 +1520,7 @@ static inline std::vector<std::vector<ExPolygons>> segmentation_top_and_bottom_l
                 append(self, top_area);
                 append(self, bottom_area);
                 self = union_ex(self);
-            });
+            }
             // Trim one region by the other if some of the regions overlap.
             ExPolygons painted_regions;
             for (size_t color_idx = 1; color_idx < triangles_by_color_merged.size(); ++color_idx) {
@@ -1927,69 +1887,7 @@ static void remove_multiple_edges_in_vertices(MMU_Graph &graph, const std::vecto
     }
 }
 
-
-// Finds the islands (layer ExPolygons) a region piece overlaps. A top or bottom region is projected from the neighbouring
-// layers and may reach past the island it belongs to, or over several islands.
-class IslandLocator
-{
-public:
-    explicit IslandLocator(const ExPolygons &islands) : m_islands(islands)
-    {
-        m_bboxes.reserve(islands.size());
-        for (const ExPolygon &island : islands) {
-            m_bboxes.emplace_back(get_extents(island));
-            m_extent.merge(m_bboxes.back());
-        }
-        if (!m_extent.defined)
-            return;
-        const Point size = m_extent.size();
-        m_cell_w = std::max<coord_t>(1, size.x() / GRID + 1);
-        m_cell_h = std::max<coord_t>(1, size.y() / GRID + 1);
-        m_grid.assign(GRID * GRID, {});
-        for (size_t i = 0; i < m_bboxes.size(); ++i)
-            for_cells(m_bboxes[i], [&](int cell) { m_grid[cell].emplace_back(i); });
-    }
-
-    void find(const ExPolygon &piece, std::vector<size_t> &out) const
-    {
-        out.clear();
-        const BoundingBox bbox = get_extents(piece);
-        if (!m_extent.defined || !m_extent.overlap(bbox))
-            return;
-        for_cells(bbox, [&](int cell) {
-            for (size_t i : m_grid[cell])
-                if (m_bboxes[i].overlap(bbox))
-                    out.emplace_back(i);
-        });
-        sort_remove_duplicates(out);
-        if (out.size() > 1)
-            out.erase(std::remove_if(out.begin(), out.end(), [&](size_t i) {
-                const BoundingBox common(m_bboxes[i].min.cwiseMax(bbox.min), m_bboxes[i].max.cwiseMin(bbox.max));
-                return intersection(ClipperUtils::clip_clipper_polygons_with_subject_bbox(piece, common.inflated(SCALED_EPSILON)),
-                                    ClipperUtils::clip_clipper_polygons_with_subject_bbox(m_islands[i], common.inflated(SCALED_EPSILON))).empty();
-            }), out.end());
-    }
-
-private:
-    static constexpr int GRID = 64;
-    template<typename Fn> void for_cells(const BoundingBox &bb, Fn &&fn) const
-    {
-        const int x0 = std::clamp(int((bb.min.x() - m_extent.min.x()) / m_cell_w), 0, GRID - 1), x1 = std::clamp(int((bb.max.x() - m_extent.min.x()) / m_cell_w), 0, GRID - 1);
-        const int y0 = std::clamp(int((bb.min.y() - m_extent.min.y()) / m_cell_h), 0, GRID - 1), y1 = std::clamp(int((bb.max.y() - m_extent.min.y()) / m_cell_h), 0, GRID - 1);
-        for (int y = y0; y <= y1; ++y)
-            for (int x = x0; x <= x1; ++x)
-                fn(y * GRID + x);
-    }
-
-    const ExPolygons                &m_islands;
-    std::vector<BoundingBox>         m_bboxes;
-    BoundingBox                      m_extent;
-    coord_t                          m_cell_w = 1, m_cell_h = 1;
-    std::vector<std::vector<size_t>> m_grid;
-};
-
-static std::vector<std::vector<ExPolygons>> merge_segmented_layers(const std::vector<ExPolygons>              &input_expolygons,
-                                                                   const std::vector<std::vector<ExPolygons>> &segmented_regions,
+static std::vector<std::vector<ExPolygons>> merge_segmented_layers(const std::vector<std::vector<ExPolygons>> &segmented_regions,
                                                                    std::vector<std::vector<ExPolygons>>      &&top_and_bottom_layers,
                                                                    const size_t                                num_facets_states,
                                                                    const std::function<void()>                &throw_on_cancel_callback)
@@ -2000,91 +1898,33 @@ static std::vector<std::vector<ExPolygons>> merge_segmented_layers(const std::ve
     assert(!top_and_bottom_layers.size() || num_facets_states == top_and_bottom_layers.size());
 
     BOOST_LOG_TRIVIAL(debug) << "Print object segmentation - Merging segmented layers in parallel - Begin";
-    // Every region of a layer is merged together with the regions of the islands it overlaps, and the islands are further
-    // apart than the dimple removal below reaches, so this gives the same result as merging the layer at once. On a layer
-    // cut through a fine relief every region shares thousands of hole contours with every other, and Clipper, splitting
-    // and re-linking one huge polygon over and over, took anything up to half an hour for a layer; per island each operation
-    // stays the size of the island, and the islands run in parallel.
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, num_layers), [&](const tbb::blocked_range<size_t> &range) {
+    tbb::parallel_for(tbb::blocked_range<size_t>(0, num_layers), [&segmented_regions, &top_and_bottom_layers, &segmented_regions_merged, &num_facets_states, &throw_on_cancel_callback](const tbb::blocked_range<size_t> &range) {
         for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
             assert(segmented_regions[layer_idx].size() == num_facets_states);
-            throw_on_cancel_callback();
-            // Group the islands joined by a region overlapping several of them; the last group takes the regions lying
-            // outside every island.
-            const ExPolygons   &islands = input_expolygons[layer_idx];
-            const IslandLocator locator(islands);
-            std::vector<size_t> parent(islands.size() + 1);
-            std::iota(parent.begin(), parent.end(), 0);
-            const auto root = [&parent](size_t i) {
-                while (parent[i] != i)
-                    i = parent[i] = parent[parent[i]];
-                return i;
-            };
-            // Islands of every piece: side regions of colours 1.., then top/bottom regions of colours 0..
-            std::vector<const ExPolygon *> pieces;
-            for (size_t extruder_id = 1; extruder_id < num_facets_states; ++extruder_id)
-                for (const ExPolygon &piece : segmented_regions[layer_idx][extruder_id])
-                    pieces.emplace_back(&piece);
-            if (!top_and_bottom_layers.empty())
-                for (size_t color_idx = 0; color_idx < num_facets_states; ++color_idx)
-                    for (const ExPolygon &piece : top_and_bottom_layers[color_idx][layer_idx])
-                        pieces.emplace_back(&piece);
-            std::vector<std::vector<size_t>> overlapped(pieces.size());
-            tbb::parallel_for(size_t(0), pieces.size(), [&](size_t i) { locator.find(*pieces[i], overlapped[i]); });
-            std::vector<size_t> piece_island(pieces.size());
-            for (size_t i = 0; i < pieces.size(); ++i) {
-                piece_island[i] = overlapped[i].empty() ? islands.size() : overlapped[i].front();
-                for (size_t island : overlapped[i])
-                    parent[root(island)] = root(piece_island[i]);
-            }
-            std::vector<size_t> bucket_of(parent.size(), size_t(-1));
-            size_t              num_buckets = 0;
-            for (size_t i = 0; i < parent.size(); ++i)
-                if (size_t &b = bucket_of[root(i)]; b == size_t(-1))
-                    b = num_buckets++;
-
-            // [bucket][colour]
-            std::vector<std::vector<ExPolygons>> sides(num_buckets, std::vector<ExPolygons>(num_facets_states));
-            std::vector<std::vector<ExPolygons>> tops(num_buckets, std::vector<ExPolygons>(num_facets_states));
-            size_t                               piece_idx = 0;
-            for (size_t extruder_id = 1; extruder_id < num_facets_states; ++extruder_id)
-                for (const ExPolygon &piece : segmented_regions[layer_idx][extruder_id])
-                    sides[bucket_of[root(piece_island[piece_idx++])]][extruder_id].emplace_back(piece);
-            if (!top_and_bottom_layers.empty())
-                for (size_t color_idx = 0; color_idx < num_facets_states; ++color_idx)
-                    for (const ExPolygon &piece : top_and_bottom_layers[color_idx][layer_idx])
-                        tops[bucket_of[root(piece_island[piece_idx++])]][color_idx].emplace_back(piece);
-
-            // Side regions minus the top/bottom regions of every colour.
-            std::vector<std::vector<ExPolygons>> merged(num_buckets, std::vector<ExPolygons>(num_facets_states));
-            tbb::parallel_for(size_t(0), num_buckets, [&](size_t bucket) {
-                Polygons tops_all;
-                for (const ExPolygons &t : tops[bucket])
-                    polygons_append(tops_all, t);
-                for (size_t extruder_id = 1; extruder_id < num_facets_states; ++extruder_id)
-                    if (!sides[bucket][extruder_id].empty())
-                        merged[bucket][extruder_id] = tops_all.empty() ? std::move(sides[bucket][extruder_id]) :
-                                                                         diff_ex_by_piece(sides[bucket][extruder_id], tops_all);
-            });
-
-            // Then this colour's top/bottom regions, with the dimples removed (#7235) when the layer has side regions left.
+            // Zero is skipped because it is the default color of the volume
             for (size_t extruder_id = 1; extruder_id < num_facets_states; ++extruder_id) {
-                if (top_and_bottom_layers.empty() || top_and_bottom_layers[extruder_id][layer_idx].empty()) {
-                    for (size_t bucket = 0; bucket < num_buckets; ++bucket)
-                        append(segmented_regions_merged[layer_idx][extruder_id - 1], std::move(merged[bucket][extruder_id]));
-                    continue;
+                throw_on_cancel_callback();
+                if (!segmented_regions[layer_idx][extruder_id].empty()) {
+                    ExPolygons segmented_regions_trimmed = segmented_regions[layer_idx][extruder_id];
+                    if (!top_and_bottom_layers.empty()) {
+                        for (const std::vector<ExPolygons> &top_and_bottom_by_extruder : top_and_bottom_layers) {
+                            if (!top_and_bottom_by_extruder[layer_idx].empty() && !segmented_regions_trimmed.empty()) {
+                                segmented_regions_trimmed = diff_ex(segmented_regions_trimmed, top_and_bottom_by_extruder[layer_idx]);
+                            }
+                        }
+                    }
+
+                    segmented_regions_merged[layer_idx][extruder_id - 1] = std::move(segmented_regions_trimmed);
+                }
+
+                if (!top_and_bottom_layers.empty() && !top_and_bottom_layers[extruder_id][layer_idx].empty()) {
+                    bool was_top_and_bottom_empty = segmented_regions_merged[layer_idx][extruder_id - 1].empty();
+                    append(segmented_regions_merged[layer_idx][extruder_id - 1], top_and_bottom_layers[extruder_id][layer_idx]);
+
+                    // Remove dimples (#7235) appearing after merging side segmentation of the model with tops and bottoms painted layers.
+                    if (!was_top_and_bottom_empty)
+                        segmented_regions_merged[layer_idx][extruder_id - 1] = offset2_ex(union_ex(segmented_regions_merged[layer_idx][extruder_id - 1]), float(SCALED_EPSILON), -float(SCALED_EPSILON));
                 }
-                bool was_top_and_bottom_empty = true;
-                for (size_t bucket = 0; bucket < num_buckets && was_top_and_bottom_empty; ++bucket)
-                    was_top_and_bottom_empty = merged[bucket][extruder_id].empty();
-                tbb::parallel_for(size_t(0), num_buckets, [&](size_t bucket) {
-                    ExPolygons &region = merged[bucket][extruder_id];
-                    append(region, tops[bucket][extruder_id]);
-                    if (!was_top_and_bottom_empty && !region.empty())
-                        region = offset2_ex(union_ex(region), float(SCALED_EPSILON), -float(SCALED_EPSILON));
-                });
-                for (size_t bucket = 0; bucket < num_buckets; ++bucket)
-                    append(segmented_regions_merged[layer_idx][extruder_id - 1], std::move(merged[bucket][extruder_id]));
             }
         }
     }); // end of parallel_for
@@ -2372,56 +2212,16 @@ std::vector<std::vector<ExPolygons>> segmentation_by_painting(const PrintObject
 
                 assert(!color_poly.empty());
                 assert(!color_poly.front().empty());
-                // Each island (an ExPolygon with its holes) is segmented on its own. Any point of an island is closer to
-                // that island's contours than to any other island's - the way out crosses its own boundary first - so its
-                // Voronoi cells, and with them its colour regions, depend on nothing else. A layer cut through a fine relief
-                // has thousands of islands, and one Voronoi diagram over all of them degenerated into overlapping regions
-                // that every boolean afterwards had to untangle. Per island the diagrams stay small and the islands run in
-                // parallel; an island in a single colour needs no diagram at all.
-                const ExPolygons                      &islands = input_expolygons[layer_idx];
-                std::vector<std::pair<size_t, size_t>> island_contours(islands.size()); // [first, last) into color_poly
-                {
-                    // The same order EdgeGrid::Grid::create() lists the contours in, and so colorize_contours().
-                    size_t idx = 0;
-                    for (size_t island_idx = 0; island_idx < islands.size(); ++island_idx) {
-                        const size_t first = idx;
-                        if (!islands[island_idx].contour.empty())
-                            ++idx;
-                        for (const Polygon &hole : islands[island_idx].holes)
-                            if (!hole.empty())
-                                ++idx;
-                        island_contours[island_idx] = {first, idx};
-                    }
-                    assert(idx == color_poly.size());
+                if (has_layer_only_one_color(color_poly)) {
+                    // If the whole layer is painted using the same color, it is not needed to construct a Voronoi diagram for the segmentation of this layer.
+                    segmented_regions[layer_idx][size_t(color_poly.front().front().color)] = input_expolygons[layer_idx];
+                } else {
+                    MMU_Graph graph = build_graph(layer_idx, color_poly);
+                    remove_multiple_edges_in_vertices(graph, color_poly);
+                    graph.remove_nodes_with_one_arc();
+                    segmented_regions[layer_idx] = extract_colored_segments(graph, num_facets_states);
+                    //segmented_regions[layer_idx] = extract_colored_segments(color_poly, num_extruders, layer_idx);
                 }
-                std::vector<std::vector<ExPolygons>> island_regions(islands.size());
-                tbb::parallel_for(size_t(0), islands.size(), [&](size_t island_idx) {
-                    const auto [first, last] = island_contours[island_idx];
-                    if (first == last)
-                        return;
-                    const std::vector<ColoredLines> island_poly(color_poly.begin() + first, color_poly.begin() + last);
-                    std::vector<ExPolygons>        &regions = island_regions[island_idx];
-                    if (has_layer_only_one_color(island_poly)) {
-                        regions.assign(num_facets_states, ExPolygons());
-                        regions[size_t(island_poly.front().front().color)].emplace_back(islands[island_idx]);
-                    } else {
-                        MMU_Graph graph = build_graph(layer_idx, island_poly);
-                        remove_multiple_edges_in_vertices(graph, island_poly);
-                        graph.remove_nodes_with_one_arc();
-                        regions = extract_colored_segments(graph, num_facets_states);
-                        // The faces of one colour tile it without overlapping; merged here, where an island is small,
-                        // every later boolean gets a few regions instead of thousands of faces sharing their edges. An
-                        // island with many holes keeps its faces: merged, each colour would be one region with thousands
-                        // of holes, and subtracting from that is far slower than from the faces one at a time.
-                        if (island_poly.size() <= 64)
-                            for (ExPolygons &faces : regions)
-                                if (faces.size() > 1)
-                                    faces = union_ex(faces);
-                    }
-                });
-                for (std::vector<ExPolygons> &regions : island_regions)
-                    for (size_t color_idx = 0; color_idx < regions.size(); ++color_idx)
-                        append(segmented_regions[layer_idx][color_idx], std::move(regions[color_idx]));
 
 #ifdef MM_SEGMENTATION_DEBUG_REGIONS
                 export_regions_to_svg(debug_out_path("3-mm-regions-sides-%d-%d.svg", layer_idx, iRun), segmented_regions[layer_idx], input_expolygons[layer_idx]);
@@ -2444,7 +2244,7 @@ std::vector<std::vector<ExPolygons>> segmentation_by_painting(const PrintObject
         throw_on_cancel_callback();
     }
 
-    std::vector<std::vector<ExPolygons>> segmented_regions_merged = merge_segmented_layers(input_expolygons, segmented_regions, std::move(top_and_bottom_layers), num_facets_states, throw_on_cancel_callback);
+    std::vector<std::vector<ExPolygons>> segmented_regions_merged = merge_segmented_layers(segmented_regions, std::move(top_and_bottom_layers), num_facets_states, throw_on_cancel_callback);
     throw_on_cancel_callback();
 
 #ifdef MM_SEGMENTATION_DEBUG_REGIONS

src/libslic3r/MultiPoint.hpp

@@ -23,15 +23,11 @@ public:
     
     MultiPoint() {}
     MultiPoint(const MultiPoint &other) : points(other.points) {}
-    MultiPoint(MultiPoint &&other) noexcept : points(std::move(other.points)) {}
+    MultiPoint(MultiPoint &&other) : points(std::move(other.points)) {}
     MultiPoint(std::initializer_list<Point> list) : points(list) {}
     explicit MultiPoint(const Points &_points) : points(_points) {}
-    // Without it, the derived classes' move constructors passing std::move(points) here copied them, which
-    // also means a moved-from Polygon or Polyline is now really empty where it used to silently keep its
-    // points: a use-after-move anywhere in the tree that happened to work before now sees nothing.
-    explicit MultiPoint(Points &&_points) noexcept : points(std::move(_points)) {}
     MultiPoint& operator=(const MultiPoint &other) { points = other.points; return *this; }
-    MultiPoint& operator=(MultiPoint &&other) noexcept { points = std::move(other.points); return *this; }
+    MultiPoint& operator=(MultiPoint &&other) { points = std::move(other.points); return *this; }
     virtual ~MultiPoint() = default;
     void scale(double factor);
     void scale(double factor_x, double factor_y);

src/libslic3r/PerimeterGenerator.cpp

@@ -32,8 +32,6 @@
 #include <tuple>
 #include <unordered_set>
 #include <thread>
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
 #include <vector>
 #include "libslic3r.h"
 #include <utility>
@@ -2585,490 +2583,467 @@ void PerimeterGenerator::process_arachne()
     const bool only_one_wall_first_layer = this->config->only_one_wall_first_layer && has_bottom_shell_layers(*this->config);
     // we need to process each island separately because we might have different
     // extra perimeters for each one
-    // Each island is independent up to its outputs, so they are generated in parallel - a layer split into thousands
-    // of islands (e.g. by colour painting) otherwise ran on one thread - and the outputs are then committed in the
-    // original island order, which is what the extra overhang perimeters (applied to the last island's loops and to
-    // all fill surfaces so far) depend on.
-    struct ArachneSurfaceResult
-    {
-        ExtrusionEntityCollection loops;
-        bool                      has_loops = false;
-        ExPolygons                infill;
-        ExPolygons                no_overlap;
-    };
-    std::vector<ArachneSurfaceResult> results(all_surfaces.size());
-    tbb::parallel_for(tbb::blocked_range<size_t>(0, all_surfaces.size()), [&](const tbb::blocked_range<size_t> &range) {
-      for (size_t surface_idx = range.begin(); surface_idx < range.end(); ++surface_idx) {
-        const Surface        &surface = all_surfaces[surface_idx];
-        ArachneSurfaceResult &result  = results[surface_idx];
-            coord_t bead_width_0 = ext_perimeter_spacing;
-            // detect how many perimeters must be generated for this island
-            int loop_number = this->config->wall_loops + surface.extra_perimeters - 1; // 0-indexed loops
-            int sparse_infill_density = this->config->sparse_infill_density.value;
-            if (this->config->alternate_extra_wall && this->layer_id % 2 == 1 && !m_spiral_vase && sparse_infill_density > 0) // add alternating extra wall
-                loop_number++;
+    for (const Surface& surface : all_surfaces) {
+        coord_t bead_width_0 = ext_perimeter_spacing;
+        // detect how many perimeters must be generated for this island
+        int loop_number = this->config->wall_loops + surface.extra_perimeters - 1; // 0-indexed loops
+        int sparse_infill_density = this->config->sparse_infill_density.value;
+        if (this->config->alternate_extra_wall && this->layer_id % 2 == 1 && !m_spiral_vase && sparse_infill_density > 0) // add alternating extra wall
+            loop_number++;
 
-            // Set the bottommost layer to be one wall
-            const bool is_bottom_layer = (this->layer_id == object_config->raft_layers) ? true : false;
-            if (is_bottom_layer && only_one_wall_first_layer)
-                loop_number = 0;
+        // Set the bottommost layer to be one wall
+        const bool is_bottom_layer = (this->layer_id == object_config->raft_layers) ? true : false;
+        if (is_bottom_layer && only_one_wall_first_layer)
+            loop_number = 0;
 
-            // Orca: set the topmost layer to be one wall according to the config
-            const bool is_topmost_layer = (this->upper_slices == nullptr) ? true : false;
-            if (is_topmost_layer && loop_number > 0 && only_one_wall_top)
-                loop_number = 0;
+        // Orca: set the topmost layer to be one wall according to the config
+        const bool is_topmost_layer = (this->upper_slices == nullptr) ? true : false;
+        if (is_topmost_layer && loop_number > 0 && only_one_wall_top)
+            loop_number = 0;
         
-            auto apply_precise_outer_wall = config->precise_outer_wall && config->wall_sequence == WallSequence::InnerOuter;
-            // Orca: properly adjust offset for the outer wall if precise_outer_wall is enabled.
-            ExPolygons last = offset_ex(surface.expolygon.simplify_p(surface_simplify_resolution),
-                           apply_precise_outer_wall? -float(ext_perimeter_width - ext_perimeter_spacing )
-                                                     : -float(ext_perimeter_width / 2. - ext_perimeter_spacing / 2.));
+        auto apply_precise_outer_wall = config->precise_outer_wall && config->wall_sequence == WallSequence::InnerOuter;
+        // Orca: properly adjust offset for the outer wall if precise_outer_wall is enabled.
+        ExPolygons last = offset_ex(surface.expolygon.simplify_p(surface_simplify_resolution),
+                       apply_precise_outer_wall? -float(ext_perimeter_width - ext_perimeter_spacing )
+                                                 : -float(ext_perimeter_width / 2. - ext_perimeter_spacing / 2.));
         
-            Arachne::WallToolPathsParams input_params = Arachne::make_paths_params(this->layer_id, *object_config, *print_config);
-            // Set params is_top_or_bottom_layer for adjusting short-wall removal sensitivity.
-            input_params.is_top_or_bottom_layer = (is_bottom_layer || is_topmost_layer) ? true : false;
+        Arachne::WallToolPathsParams input_params = Arachne::make_paths_params(this->layer_id, *object_config, *print_config);
+        // Set params is_top_or_bottom_layer for adjusting short-wall removal sensitivity.
+        input_params.is_top_or_bottom_layer = (is_bottom_layer || is_topmost_layer) ? true : false;
 
-            coord_t wall_0_inset = 0;
-            if (apply_precise_outer_wall)
-               wall_0_inset = -coord_t(ext_perimeter_width / 2 - ext_perimeter_spacing / 2);
+        coord_t wall_0_inset = 0;
+        if (apply_precise_outer_wall)
+           wall_0_inset = -coord_t(ext_perimeter_width / 2 - ext_perimeter_spacing / 2);
 
-            //PS: One wall top surface for Arachne
-            ExPolygons top_expolygons;
-            // Calculate how many inner loops remain when TopSurfaces is selected.
-            const int inner_loop_number = (only_one_wall_top && upper_slices != nullptr) ? loop_number - 1 : -1;
+        //PS: One wall top surface for Arachne
+        ExPolygons top_expolygons;
+        // Calculate how many inner loops remain when TopSurfaces is selected.
+        const int inner_loop_number = (only_one_wall_top && upper_slices != nullptr) ? loop_number - 1 : -1;
 
-            // Set one perimeter when TopSurfaces is selected.
-            if (only_one_wall_top && loop_number > 0)
-                loop_number = 0;
+        // Set one perimeter when TopSurfaces is selected.
+        if (only_one_wall_top && loop_number > 0)
+            loop_number = 0;
 
-            Arachne::WallToolPathsParams input_params_tmp = input_params;
+        Arachne::WallToolPathsParams input_params_tmp = input_params;
         
-            Polygons   last_p = to_polygons(last);
-            Arachne::WallToolPaths wallToolPaths(last_p, bead_width_0, perimeter_spacing, coord_t(loop_number + 1),
-                                                   wall_0_inset, layer_height, input_params_tmp);
-            std::vector<Arachne::VariableWidthLines>   perimeters = wallToolPaths.getToolPaths();
-            ExPolygons  infill_contour = union_ex(wallToolPaths.getInnerContour());
+        Polygons   last_p = to_polygons(last);
+        Arachne::WallToolPaths wallToolPaths(last_p, bead_width_0, perimeter_spacing, coord_t(loop_number + 1),
+                                               wall_0_inset, layer_height, input_params_tmp);
+        std::vector<Arachne::VariableWidthLines>   perimeters = wallToolPaths.getToolPaths();
+        ExPolygons  infill_contour = union_ex(wallToolPaths.getInnerContour());
 
-            // Check if there are some remaining perimeters to generate (the number of perimeters
-            // is greater than one together with enabled the single perimeter on top surface feature).
-            if (inner_loop_number >= 0) {
-                assert(upper_slices != nullptr);
+        // Check if there are some remaining perimeters to generate (the number of perimeters
+        // is greater than one together with enabled the single perimeter on top surface feature).
+        if (inner_loop_number >= 0) {
+            assert(upper_slices != nullptr);
 
-                coord_t perimeter_width = this->perimeter_flow.scaled_width();
+            coord_t perimeter_width = this->perimeter_flow.scaled_width();
 
-                // Filter out areas that are too thin and expand top surface polygons a bit to hide the wall line.
-                // ORCA: skip if the top surface area is smaller than "min_width_top_surface"
-                const float top_surface_min_width = std::max<float>(float(ext_perimeter_spacing) / 4.f + scaled<float>(0.00001), float(scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width)))) / 4.f);
+            // Filter out areas that are too thin and expand top surface polygons a bit to hide the wall line.
+            // ORCA: skip if the top surface area is smaller than "min_width_top_surface"
+            const float top_surface_min_width = std::max<float>(float(ext_perimeter_spacing) / 4.f + scaled<float>(0.00001), float(scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width)))) / 4.f);
 
-                // Get top ExPolygons from the given contour. uncovered reports whether the upper layer leaves any of the
-                // contour uncovered, before bridges and too thin areas are filtered out.
-                auto get_top_expolygons = [&](const ExPolygons &contour, bool &uncovered) {
-                    // Contour bounding box.
-                    BoundingBox contour_bbox = get_extents(contour);
-                    contour_bbox.offset(SCALED_EPSILON);
+            // Get top ExPolygons from the given contour. uncovered reports whether the upper layer leaves any of the
+            // contour uncovered, before bridges and too thin areas are filtered out.
+            auto get_top_expolygons = [&](const ExPolygons &contour, bool &uncovered) {
+                // Contour bounding box.
+                BoundingBox contour_bbox = get_extents(contour);
+                contour_bbox.offset(SCALED_EPSILON);
 
-                    Polygons upper_slices_clipped;
-                    if (object_config->interface_shells) {
-                        auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
-                        upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, contour_bbox);
-                    } else
-                        upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, contour_bbox);
+                Polygons upper_slices_clipped;
+                if (object_config->interface_shells) {
+                    auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
+                    upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, contour_bbox);
+                } else
+                    upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, contour_bbox);
 
-                    ExPolygons top = diff_ex(contour, upper_slices_clipped);
-                    uncovered      = !top.empty();
-                    if (top.empty())
-                        return top;
+                ExPolygons top = diff_ex(contour, upper_slices_clipped);
+                uncovered      = !top.empty();
+                if (top.empty())
+                    return top;
 
-                    if (lower_slices != nullptr) {
-                        const float      bridge_offset          = float(std::max<coord_t>(ext_perimeter_spacing, perimeter_width));
-                        const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, contour_bbox);
-                        const ExPolygons current_slices_bridges = offset_ex(diff_ex(top, lower_slices_clipped), bridge_offset);
+                if (lower_slices != nullptr) {
+                    const float      bridge_offset          = float(std::max<coord_t>(ext_perimeter_spacing, perimeter_width));
+                    const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, contour_bbox);
+                    const ExPolygons current_slices_bridges = offset_ex(diff_ex(top, lower_slices_clipped), bridge_offset);
 
-                        // Remove bridges from top surface polygons.
-                        top = diff_ex(top, current_slices_bridges);
-                    }
-
-                    // Shrink the polygon to remove the small areas, then expand it back out plus a maragin to hide the wall line a little.
-                    // ORCA: Expand the polygon with half the perimeter width in addition to the contracted amount,
-                    // not the full perimeter width as PS does, to enable thin lettering to print on the top surface without nozzle collisions
-                    // due to thin lines being generated
-                    top = offset2_ex(top, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
-
-                    // Get final top ExPolygons (bridges were excluded above, so they stay walled).
-                    return intersection_ex(top, contour);
-                };
-
-                // Walls with the full count, as generated when the single perimeter feature is disabled. Generated on first use.
-                std::vector<Arachne::VariableWidthLines> full_perimeters;
-                Polygons                                 full_inner_contour;
-                bool                                     full_perimeters_generated = false;
-                auto generate_full_perimeters = [&]() {
-                    if (full_perimeters_generated)
-                        return;
-                    Arachne::WallToolPaths full_tool_paths(last_p, bead_width_0, perimeter_spacing, coord_t(inner_loop_number + 2), wall_0_inset, layer_height, input_params_tmp);
-                    full_perimeters           = full_tool_paths.getToolPaths();
-                    full_inner_contour        = full_tool_paths.getInnerContour();
-                    full_perimeters_generated = true;
-                };
-
-                // ORCA: the single wall pass allows Arachne 2 beads across a wall, so it fills a wall narrower than 3 outer wall
-                // widths by widening both, where the full pass adds a middle bead. Over the top surface that is the intent;
-                // anywhere else it leaves no room for the inner walls. When the single wall pass's outer walls run away from
-                // the full pass's outside the top surface, take the full pass's outer walls and the area inside them instead.
-                // Walls closer than outer_wall_tolerance count as the same wall: a widened bead's centerline moves by half
-                // the width added, and only beads widened by more than twice the tolerance are looked for.
-                const coord_t outer_wall_tolerance = bead_width_0 / 10;
-                if (widest_bead(perimeters) > bead_width_0 + 2 * outer_wall_tolerance) {
-                    // The single wall pass's inner contour where it widens no bead: inside nominal width outer walls.
-                    const ExPolygons nominal_infill_contour = offset_ex(last, -float(bead_width_0 + wall_0_inset));
-                    bool             nominal_uncovered      = false;
-                    // Grown by an outer wall width to take in the outer walls bordering the top surface.
-                    const ExPolygons top_zone = offset_ex(get_top_expolygons(nominal_infill_contour, nominal_uncovered), float(bead_width_0));
-                    if (nominal_uncovered) {
-                        generate_full_perimeters();
-                        if (! full_perimeters.empty() && ! full_perimeters.front().empty() &&
-                            length_off_reference(perimeters, full_perimeters.front(), top_zone, outer_wall_tolerance) > double(perimeter_width)) {
-                            perimeters     = { full_perimeters.front() };
-                            infill_contour = diff_ex(nominal_infill_contour, walls_footprint(full_perimeters.front()), ApplySafetyOffset::Yes);
-                        }
-                    }
+                    // Remove bridges from top surface polygons.
+                    top = diff_ex(top, current_slices_bridges);
                 }
 
-                bool uncovered = false;
-                top_expolygons = get_top_expolygons(infill_contour, uncovered);
+                // Shrink the polygon to remove the small areas, then expand it back out plus a maragin to hide the wall line a little.
+                // ORCA: Expand the polygon with half the perimeter width in addition to the contracted amount,
+                // not the full perimeter width as PS does, to enable thin lettering to print on the top surface without nozzle collisions
+                // due to thin lines being generated
+                top = offset2_ex(top, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
 
-                if (uncovered) {
-                    // ORCA: onion the real region (inside the outer wall) so the remaining walls follow the actual
-                    // geometry, then cut away the parts over the top surface. Re-onioning the non-top complement
-                    // instead - the fallback when there is no top fill - walls the top/non-top interface and rings
-                    // top-surface islands with inner walls that don't exist when the feature is disabled.
-                    const bool     clip_walls_over_top = top_fill_replaces_inner_walls(*this->config);
-                    const Polygons inner_region        = to_polygons(offset_ex(clip_walls_over_top ? infill_contour
-                                                                                                   : diff_ex(infill_contour, top_expolygons),
-                                                                              wall_0_inset));
-                    Arachne::WallToolPaths inner_wall_tool_paths(inner_region, perimeter_spacing, perimeter_spacing, coord_t(inner_loop_number + 1), 0, layer_height, input_params_tmp);
-                    std::vector<Arachne::VariableWidthLines> inner_perimeters = inner_wall_tool_paths.getToolPaths();
+                // Get final top ExPolygons (bridges were excluded above, so they stay walled).
+                return intersection_ex(top, contour);
+            };
 
-                    if (clip_walls_over_top) {
-                        Polygons kept_over_top;
-                        clip_inner_walls_over_top(inner_perimeters, top_expolygons, perimeter_width, kept_over_top);
-                        // Route the top fill around the walls kept despite grazing the top.
-                        if (! kept_over_top.empty())
-                            top_expolygons = diff_ex(top_expolygons, kept_over_top);
-                    }
+            // Walls with the full count, as generated when the single perimeter feature is disabled. Generated on first use.
+            std::vector<Arachne::VariableWidthLines> full_perimeters;
+            Polygons                                 full_inner_contour;
+            bool                                     full_perimeters_generated = false;
+            auto generate_full_perimeters = [&]() {
+                if (full_perimeters_generated)
+                    return;
+                Arachne::WallToolPaths full_tool_paths(last_p, bead_width_0, perimeter_spacing, coord_t(inner_loop_number + 2), wall_0_inset, layer_height, input_params_tmp);
+                full_perimeters           = full_tool_paths.getToolPaths();
+                full_inner_contour        = full_tool_paths.getInnerContour();
+                full_perimeters_generated = true;
+            };
 
-                    // Recalculate indexes of inner perimeters before merging them: they come after the single outer wall.
-                    if (!perimeters.empty())
-                        for (Arachne::VariableWidthLines &inner_perimeter : inner_perimeters)
-                            for (Arachne::ExtrusionLine &el : inner_perimeter)
-                                ++el.inset_idx;
-
-                    perimeters.insert(perimeters.end(), inner_perimeters.begin(), inner_perimeters.end());
-                    infill_contour = union_ex(top_expolygons, inner_wall_tool_paths.getInnerContour());
-                } else {
-                    // There is no top surface ExPolygon, so use the walls generated like when the single perimeter
-                    // feature is disabled.
+            // ORCA: the single wall pass allows Arachne 2 beads across a wall, so it fills a wall narrower than 3 outer wall
+            // widths by widening both, where the full pass adds a middle bead. Over the top surface that is the intent;
+            // anywhere else it leaves no room for the inner walls. When the single wall pass's outer walls run away from
+            // the full pass's outside the top surface, take the full pass's outer walls and the area inside them instead.
+            // Walls closer than outer_wall_tolerance count as the same wall: a widened bead's centerline moves by half
+            // the width added, and only beads widened by more than twice the tolerance are looked for.
+            const coord_t outer_wall_tolerance = bead_width_0 / 10;
+            if (widest_bead(perimeters) > bead_width_0 + 2 * outer_wall_tolerance) {
+                // The single wall pass's inner contour where it widens no bead: inside nominal width outer walls.
+                const ExPolygons nominal_infill_contour = offset_ex(last, -float(bead_width_0 + wall_0_inset));
+                bool             nominal_uncovered      = false;
+                // Grown by an outer wall width to take in the outer walls bordering the top surface.
+                const ExPolygons top_zone = offset_ex(get_top_expolygons(nominal_infill_contour, nominal_uncovered), float(bead_width_0));
+                if (nominal_uncovered) {
                     generate_full_perimeters();
-                    perimeters     = std::move(full_perimeters);
-                    infill_contour = union_ex(full_inner_contour);
+                    if (! full_perimeters.empty() && ! full_perimeters.front().empty() &&
+                        length_off_reference(perimeters, full_perimeters.front(), top_zone, outer_wall_tolerance) > double(perimeter_width)) {
+                        perimeters     = { full_perimeters.front() };
+                        infill_contour = diff_ex(nominal_infill_contour, walls_footprint(full_perimeters.front()), ApplySafetyOffset::Yes);
+                    }
                 }
             }
-            //PS
 
-            loop_number = int(perimeters.size()) - 1;
+            bool uncovered = false;
+            top_expolygons = get_top_expolygons(infill_contour, uncovered);
 
-            #ifdef ARACHNE_DEBUG
-            {
-                static int iRun = 0;
-                export_perimeters_to_svg(debug_out_path("arachne-perimeters-%d-%d.svg", layer_id, iRun++), to_polygons(last), perimeters, union_ex(wallToolPaths.getInnerContour()));
+            if (uncovered) {
+                // ORCA: onion the real region (inside the outer wall) so the remaining walls follow the actual
+                // geometry, then cut away the parts over the top surface. Re-onioning the non-top complement
+                // instead - the fallback when there is no top fill - walls the top/non-top interface and rings
+                // top-surface islands with inner walls that don't exist when the feature is disabled.
+                const bool     clip_walls_over_top = top_fill_replaces_inner_walls(*this->config);
+                const Polygons inner_region        = to_polygons(offset_ex(clip_walls_over_top ? infill_contour
+                                                                                               : diff_ex(infill_contour, top_expolygons),
+                                                                          wall_0_inset));
+                Arachne::WallToolPaths inner_wall_tool_paths(inner_region, perimeter_spacing, perimeter_spacing, coord_t(inner_loop_number + 1), 0, layer_height, input_params_tmp);
+                std::vector<Arachne::VariableWidthLines> inner_perimeters = inner_wall_tool_paths.getToolPaths();
+
+                if (clip_walls_over_top) {
+                    Polygons kept_over_top;
+                    clip_inner_walls_over_top(inner_perimeters, top_expolygons, perimeter_width, kept_over_top);
+                    // Route the top fill around the walls kept despite grazing the top.
+                    if (! kept_over_top.empty())
+                        top_expolygons = diff_ex(top_expolygons, kept_over_top);
+                }
+
+                // Recalculate indexes of inner perimeters before merging them: they come after the single outer wall.
+                if (!perimeters.empty())
+                    for (Arachne::VariableWidthLines &inner_perimeter : inner_perimeters)
+                        for (Arachne::ExtrusionLine &el : inner_perimeter)
+                            ++el.inset_idx;
+
+                perimeters.insert(perimeters.end(), inner_perimeters.begin(), inner_perimeters.end());
+                infill_contour = union_ex(top_expolygons, inner_wall_tool_paths.getInnerContour());
+            } else {
+                // There is no top surface ExPolygon, so use the walls generated like when the single perimeter
+                // feature is disabled.
+                generate_full_perimeters();
+                perimeters     = std::move(full_perimeters);
+                infill_contour = union_ex(full_inner_contour);
             }
-    #endif
+        }
+        //PS
 
-            // All closed ExtrusionLine should have the same the first and the last point.
-            // But in rare cases, Arachne produce ExtrusionLine marked as closed but without
-            // equal the first and the last point.
-            assert([&perimeters = std::as_const(perimeters)]() -> bool {
-                for (const Arachne::VariableWidthLines& perimeter : perimeters)
-                    for (const Arachne::ExtrusionLine& el : perimeter)
-                        if (el.is_closed && el.junctions.front().p != el.junctions.back().p)
-                            return false;
-                return true;
-            }());
+        loop_number = int(perimeters.size()) - 1;
 
-            int start_perimeter = int(perimeters.size()) - 1;
-            int end_perimeter = -1;
-            int direction = -1;
+        #ifdef ARACHNE_DEBUG
+        {
+            static int iRun = 0;
+            export_perimeters_to_svg(debug_out_path("arachne-perimeters-%d-%d.svg", layer_id, iRun++), to_polygons(last), perimeters, union_ex(wallToolPaths.getInnerContour()));
+        }
+#endif
 
-    		bool is_outer_wall_first =
-                	this->config->wall_sequence == WallSequence::OuterInner ||
-                	this->config->wall_sequence == WallSequence::InnerOuterInner;
+        // All closed ExtrusionLine should have the same the first and the last point.
+        // But in rare cases, Arachne produce ExtrusionLine marked as closed but without
+        // equal the first and the last point.
+        assert([&perimeters = std::as_const(perimeters)]() -> bool {
+            for (const Arachne::VariableWidthLines& perimeter : perimeters)
+                for (const Arachne::ExtrusionLine& el : perimeter)
+                    if (el.is_closed && el.junctions.front().p != el.junctions.back().p)
+                        return false;
+            return true;
+        }());
+
+        int start_perimeter = int(perimeters.size()) - 1;
+        int end_perimeter = -1;
+        int direction = -1;
+
+		bool is_outer_wall_first =
+            	this->config->wall_sequence == WallSequence::OuterInner ||
+            	this->config->wall_sequence == WallSequence::InnerOuterInner;
         
-            if (layer_id == 0){ // disable inner outer inner algorithm after the first layer
-            	is_outer_wall_first =
-                	this->config->wall_sequence == WallSequence::OuterInner || this->outer_walls_first_for_brim();
-            }
-            if (is_outer_wall_first) {
-                start_perimeter = 0;
-                end_perimeter = int(perimeters.size());
-                direction = 1;
+        if (layer_id == 0){ // disable inner outer inner algorithm after the first layer
+        	is_outer_wall_first =
+            	this->config->wall_sequence == WallSequence::OuterInner || this->outer_walls_first_for_brim();
+        }
+        if (is_outer_wall_first) {
+            start_perimeter = 0;
+            end_perimeter = int(perimeters.size());
+            direction = 1;
+        }
+
+        std::vector<Arachne::ExtrusionLine*> all_extrusions;
+        for (int perimeter_idx = start_perimeter; perimeter_idx != end_perimeter; perimeter_idx += direction) {
+            if (perimeters[perimeter_idx].empty())
+                continue;
+            for (Arachne::ExtrusionLine& wall : perimeters[perimeter_idx])
+                all_extrusions.emplace_back(&wall);
+        }
+
+        // Find topological order with constraints from extrusions_constrains.
+        std::vector<size_t>              blocked(all_extrusions.size(), 0); // Value indicating how many extrusions it is blocking (preceding extrusions) an extrusion.
+        std::vector<std::vector<size_t>> blocking(all_extrusions.size());   // Each extrusion contains a vector of extrusions that are blocked by this extrusion.
+        std::unordered_map<const Arachne::ExtrusionLine*, size_t> map_extrusion_to_idx;
+        for (size_t idx = 0; idx < all_extrusions.size(); idx++)
+            map_extrusion_to_idx.emplace(all_extrusions[idx], idx);
+
+        auto extrusions_constrains = Arachne::WallToolPaths::getRegionOrder(all_extrusions, is_outer_wall_first);
+        for (auto [before, after] : extrusions_constrains) {
+            auto after_it = map_extrusion_to_idx.find(after);
+            ++blocked[after_it->second];
+            blocking[map_extrusion_to_idx.find(before)->second].emplace_back(after_it->second);
+        }
+
+        std::vector<bool> processed(all_extrusions.size(), false);          // Indicate that the extrusion was already processed.
+        Point             current_position = all_extrusions.empty() ? Point::Zero() : all_extrusions.front()->junctions.front().p; // Some starting position.
+        std::vector<PerimeterGeneratorArachneExtrusion> ordered_extrusions;         // To store our result in. At the end we'll std::swap.
+        ordered_extrusions.reserve(all_extrusions.size());
+
+        while (ordered_extrusions.size() < all_extrusions.size()) {
+            size_t best_candidate = 0;
+            double best_distance_sqr = std::numeric_limits<double>::max();
+            bool   is_best_closed = false;
+
+            std::vector<size_t> available_candidates;
+            for (size_t candidate = 0; candidate < all_extrusions.size(); ++candidate) {
+                if (processed[candidate] || blocked[candidate])
+                    continue; // Not a valid candidate.
+                available_candidates.push_back(candidate);
             }
 
-            std::vector<Arachne::ExtrusionLine*> all_extrusions;
-            for (int perimeter_idx = start_perimeter; perimeter_idx != end_perimeter; perimeter_idx += direction) {
-                if (perimeters[perimeter_idx].empty())
+            std::sort(available_candidates.begin(), available_candidates.end(), [&all_extrusions](const size_t a_idx, const size_t b_idx) -> bool {
+                return all_extrusions[a_idx]->is_closed < all_extrusions[b_idx]->is_closed;
+                });
+
+            for (const size_t candidate_path_idx : available_candidates) {
+                auto& path = all_extrusions[candidate_path_idx];
+
+                if (path->junctions.empty()) { // No vertices in the path. Can't find the start position then or really plan it in. Put that at the end.
+                    if (best_distance_sqr == std::numeric_limits<double>::max()) {
+                        best_candidate = candidate_path_idx;
+                        is_best_closed = path->is_closed;
+                    }
                     continue;
-                for (Arachne::ExtrusionLine& wall : perimeters[perimeter_idx])
-                    all_extrusions.emplace_back(&wall);
-            }
-
-            // Find topological order with constraints from extrusions_constrains.
-            std::vector<size_t>              blocked(all_extrusions.size(), 0); // Value indicating how many extrusions it is blocking (preceding extrusions) an extrusion.
-            std::vector<std::vector<size_t>> blocking(all_extrusions.size());   // Each extrusion contains a vector of extrusions that are blocked by this extrusion.
-            std::unordered_map<const Arachne::ExtrusionLine*, size_t> map_extrusion_to_idx;
-            for (size_t idx = 0; idx < all_extrusions.size(); idx++)
-                map_extrusion_to_idx.emplace(all_extrusions[idx], idx);
-
-            auto extrusions_constrains = Arachne::WallToolPaths::getRegionOrder(all_extrusions, is_outer_wall_first);
-            for (auto [before, after] : extrusions_constrains) {
-                auto after_it = map_extrusion_to_idx.find(after);
-                ++blocked[after_it->second];
-                blocking[map_extrusion_to_idx.find(before)->second].emplace_back(after_it->second);
-            }
-
-            std::vector<bool> processed(all_extrusions.size(), false);          // Indicate that the extrusion was already processed.
-            Point             current_position = all_extrusions.empty() ? Point::Zero() : all_extrusions.front()->junctions.front().p; // Some starting position.
-            std::vector<PerimeterGeneratorArachneExtrusion> ordered_extrusions;         // To store our result in. At the end we'll std::swap.
-            ordered_extrusions.reserve(all_extrusions.size());
-
-            while (ordered_extrusions.size() < all_extrusions.size()) {
-                size_t best_candidate = 0;
-                double best_distance_sqr = std::numeric_limits<double>::max();
-                bool   is_best_closed = false;
-
-                std::vector<size_t> available_candidates;
-                for (size_t candidate = 0; candidate < all_extrusions.size(); ++candidate) {
-                    if (processed[candidate] || blocked[candidate])
-                        continue; // Not a valid candidate.
-                    available_candidates.push_back(candidate);
                 }
 
-                std::sort(available_candidates.begin(), available_candidates.end(), [&all_extrusions](const size_t a_idx, const size_t b_idx) -> bool {
-                    return all_extrusions[a_idx]->is_closed < all_extrusions[b_idx]->is_closed;
-                    });
-
-                for (const size_t candidate_path_idx : available_candidates) {
-                    auto& path = all_extrusions[candidate_path_idx];
-
-                    if (path->junctions.empty()) { // No vertices in the path. Can't find the start position then or really plan it in. Put that at the end.
-                        if (best_distance_sqr == std::numeric_limits<double>::max()) {
-                            best_candidate = candidate_path_idx;
-                            is_best_closed = path->is_closed;
-                        }
-                        continue;
-                    }
-
-                    const Point candidate_position = path->junctions.front().p;
-                    double      distance_sqr = (current_position - candidate_position).cast<double>().norm();
-                    if (distance_sqr < best_distance_sqr) { // Closer than the best candidate so far.
-                        if (path->is_closed || (!path->is_closed && best_distance_sqr != std::numeric_limits<double>::max()) || (!path->is_closed && !is_best_closed)) {
-                            best_candidate = candidate_path_idx;
-                            best_distance_sqr = distance_sqr;
-                            is_best_closed = path->is_closed;
-                        }
+                const Point candidate_position = path->junctions.front().p;
+                double      distance_sqr = (current_position - candidate_position).cast<double>().norm();
+                if (distance_sqr < best_distance_sqr) { // Closer than the best candidate so far.
+                    if (path->is_closed || (!path->is_closed && best_distance_sqr != std::numeric_limits<double>::max()) || (!path->is_closed && !is_best_closed)) {
+                        best_candidate = candidate_path_idx;
+                        best_distance_sqr = distance_sqr;
+                        is_best_closed = path->is_closed;
                     }
                 }
-
-                auto& best_path = all_extrusions[best_candidate];
-                ordered_extrusions.push_back({ best_path, best_path->is_contour() });
-                processed[best_candidate] = true;
-                for (size_t unlocked_idx : blocking[best_candidate])
-                    blocked[unlocked_idx]--;
-
-                if (!best_path->junctions.empty()) { //If all paths were empty, the best path is still empty. We don't upate the current position then.
-                    if (best_path->is_closed)
-                        current_position = best_path->junctions[0].p; //We end where we started.
-                    else
-                        current_position = best_path->junctions.back().p; //Pick the other end from where we started.
-                }
             }
 
-           // printf("New Layer: Layer ID %d\n",layer_id); //debug - new layer
-            if (this->config->wall_sequence == WallSequence::InnerOuterInner && layer_id > 0) { // only enable inner outer inner algorithm after first layer
-                if (ordered_extrusions.size() > 2) { // 3 walls minimum needed to do inner outer inner ordering
-                    int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
-                    int arr_i, arr_j = 0;    // indexes to run through the walls in the for loops
-                    int outer, first_internal, second_internal, max_internal, current_perimeter; // allocate index values
-                
-                    // To address any remaining scenarios where the outer perimeter contour is not first on the list as arachne sometimes reorders the perimeters when clustering
-                    // for OI mode that is used the basis for IOI
-                    bringContoursToFront(ordered_extrusions);
-                    std::vector<PerimeterGeneratorArachneExtrusion> reordered_extrusions;
-                
-                    // Debug statement to print spacing values:
-                    //printf("External threshold - Ext perimeter: %d Ext spacing: %d Int perimeter: %d Int spacing: %d\n", this->ext_perimeter_flow.scaled_width(),this->ext_perimeter_flow.scaled_spacing(),this->perimeter_flow.scaled_width(), this->perimeter_flow.scaled_spacing());
+            auto& best_path = all_extrusions[best_candidate];
+            ordered_extrusions.push_back({ best_path, best_path->is_contour() });
+            processed[best_candidate] = true;
+            for (size_t unlocked_idx : blocking[best_candidate])
+                blocked[unlocked_idx]--;
 
-                    // Get searching thresholds. For an external perimeter we take the external perimeter spacing/2 plus the internal perimeter spacing/2 and expand by the factor
-                    // rounding errors. When precise wall is enabled, the external perimeter full spacing is used.
-                    coord_t threshold_external = (apply_precise_outer_wall)
-                        // Precise outer wall: use the full external spacing
-                        ? ( this->ext_perimeter_flow.scaled_spacing()
-                            + this->perimeter_flow.scaled_spacing()/2.0 )
-                        // Normal: half ext spacing plus half int spacing
-                        : ( this->ext_perimeter_flow.scaled_spacing()/2.0
-                            + this->perimeter_flow.scaled_spacing()/2.0 );
+            if (!best_path->junctions.empty()) { //If all paths were empty, the best path is still empty. We don't upate the current position then.
+                if (best_path->is_closed)
+                    current_position = best_path->junctions[0].p; //We end where we started.
+                else
+                    current_position = best_path->junctions.back().p; //Pick the other end from where we started.
+            }
+        }
+
+       // printf("New Layer: Layer ID %d\n",layer_id); //debug - new layer
+        if (this->config->wall_sequence == WallSequence::InnerOuterInner && layer_id > 0) { // only enable inner outer inner algorithm after first layer
+            if (ordered_extrusions.size() > 2) { // 3 walls minimum needed to do inner outer inner ordering
+                int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
+                int arr_i, arr_j = 0;    // indexes to run through the walls in the for loops
+                int outer, first_internal, second_internal, max_internal, current_perimeter; // allocate index values
                 
-                    // For the intenal perimeter threshold, the distance is the internal perimeter spacing expanded by the factor to cover rounding errors.
-                    coord_t threshold_internal = this->perimeter_flow.scaled_spacing();
+                // To address any remaining scenarios where the outer perimeter contour is not first on the list as arachne sometimes reorders the perimeters when clustering
+                // for OI mode that is used the basis for IOI
+                bringContoursToFront(ordered_extrusions);
+                std::vector<PerimeterGeneratorArachneExtrusion> reordered_extrusions;
                 
-                    // Re-order extrusions based on distance
-                    // Alorithm will aggresively optimise for the appearance of the outermost perimeter
-                    ordered_extrusions = reorderPerimetersByProximity(ordered_extrusions,threshold_external,threshold_internal );
-                    reordered_extrusions = ordered_extrusions; // copy them into the reordered extrusions vector to allow for IOI operations to be performed below without altering the base ordered extrusions list.
+                // Debug statement to print spacing values:
+                //printf("External threshold - Ext perimeter: %d Ext spacing: %d Int perimeter: %d Int spacing: %d\n", this->ext_perimeter_flow.scaled_width(),this->ext_perimeter_flow.scaled_spacing(),this->perimeter_flow.scaled_width(), this->perimeter_flow.scaled_spacing());
+
+                // Get searching thresholds. For an external perimeter we take the external perimeter spacing/2 plus the internal perimeter spacing/2 and expand by the factor
+                // rounding errors. When precise wall is enabled, the external perimeter full spacing is used.
+                coord_t threshold_external = (apply_precise_outer_wall)
+                    // Precise outer wall ⇒ use “full external spacing”
+                    ? ( this->ext_perimeter_flow.scaled_spacing()
+                        + this->perimeter_flow.scaled_spacing()/2.0 )
+                    // Normal ⇒ half ext spacing + half int spacing
+                    : ( this->ext_perimeter_flow.scaled_spacing()/2.0
+                        + this->perimeter_flow.scaled_spacing()/2.0 );
                 
-                    // Now start the sandwich mode wall re-ordering using the reordered_extrusions as the basis
-                    // scan to find the external perimeter, first internal, second internal and last perimeter in the island.
-                    // We then advance the position index to move to the second island and continue until there are no more
-                    // perimeters left.
-                    while (position < reordered_extrusions.size()) {
-                        outer = first_internal = second_internal = current_perimeter = -1; // initialise all index values to -1
-                        max_internal = reordered_extrusions.size()-1; // initialise the maximum internal perimeter to the last perimeter on the extrusion list
-                        // run through the walls to get the index values that need re-ordering until the first one for each
-                        // is found. Start at "position" index to enable the for loop to iterate for multiple external
-                        // perimeters in a single island
-                        // printf("Reorder Loop. Position %d, extrusion list size: %d, Outer index %d, inner index %d, second inner index %d\n", position, reordered_extrusions.size(),outer,first_internal,second_internal);
-                        for (arr_i = position; arr_i < reordered_extrusions.size(); ++arr_i) {
-                            // printf("Perimeter: extrusion inset index %d, ordered extrusions array position %d\n",reordered_extrusions[arr_i].extrusion->inset_idx, arr_i);
-                            switch (reordered_extrusions[arr_i].extrusion->inset_idx) {
-                                case 0: // external perimeter
-                                    if (outer == -1)
-                                        outer = arr_i;
-                                    break;
-                                case 1: // first internal wall
-                                    if (first_internal==-1 && arr_i>outer && outer!=-1){
-                                        first_internal = arr_i;
-                                    }
-                                    break;
-                                case 2: // second internal wall
-                                    if (second_internal == -1 && arr_i > first_internal && outer!=-1){
-                                        second_internal = arr_i;
-                                    }
-                                    break;
-                            }
-                            if(outer >-1 && first_internal>-1 && reordered_extrusions[arr_i].extrusion->inset_idx == 0){  // found a new external perimeter after we've found at least a first internal perimeter to re-order.
-                                                                                                                          // This means we entered a new island.
-                                arr_i=arr_i-1; //step back one perimeter
-                                max_internal = arr_i; // new maximum internal perimeter is now this as we have found a new external perimeter, hence a new island.
-                                break; // exit the for loop
-                            }
-                        }
-                    
-                        // printf("Layer ID %d, Outer index %d, inner index %d, second inner index %d, maximum internal perimeter %d \n",layer_id,outer,first_internal,second_internal, max_internal);
-                        if (outer > -1 && first_internal > -1 && second_internal > -1) { // found all three perimeters to re-order? If not the perimeters will be processed outside in.
-                            std::vector<PerimeterGeneratorArachneExtrusion> inner_outer_extrusions; // temporary array to hold extrusions for reordering
-                            inner_outer_extrusions.resize(max_internal - position + 1); // reserve array containing the number of perimeters before a new island. Variables are array indexes hence need to add +1 to convert to position allocations
-                            // printf("Allocated array size %d, max_internal index %d, start position index %d \n",max_internal-position+1,max_internal,position);
-                        
-                            for (arr_j = max_internal; arr_j >=position; --arr_j){ // go inside out towards the external perimeter (perimeters in reverse order) and store all internal perimeters until the first one identified with inset index 2
-                                if(arr_j >= second_internal){
-                                    //printf("Inside out loop: Mapped perimeter index %d to array position %d\n", arr_j, max_internal-arr_j);
-                                    inner_outer_extrusions[max_internal-arr_j] = reordered_extrusions[arr_j];
-                                    current_perimeter++; 
+                // For the intenal perimeter threshold, the distance is the internal perimeter spacing expanded by the factor to cover rounding errors.
+                coord_t threshold_internal = this->perimeter_flow.scaled_spacing();
+                
+                // Re-order extrusions based on distance
+                // Alorithm will aggresively optimise for the appearance of the outermost perimeter
+                ordered_extrusions = reorderPerimetersByProximity(ordered_extrusions,threshold_external,threshold_internal );
+                reordered_extrusions = ordered_extrusions; // copy them into the reordered extrusions vector to allow for IOI operations to be performed below without altering the base ordered extrusions list.
+                
+                // Now start the sandwich mode wall re-ordering using the reordered_extrusions as the basis
+                // scan to find the external perimeter, first internal, second internal and last perimeter in the island.
+                // We then advance the position index to move to the second island and continue until there are no more
+                // perimeters left.
+                while (position < reordered_extrusions.size()) {
+                    outer = first_internal = second_internal = current_perimeter = -1; // initialise all index values to -1
+                    max_internal = reordered_extrusions.size()-1; // initialise the maximum internal perimeter to the last perimeter on the extrusion list
+                    // run through the walls to get the index values that need re-ordering until the first one for each
+                    // is found. Start at "position" index to enable the for loop to iterate for multiple external
+                    // perimeters in a single island
+                    // printf("Reorder Loop. Position %d, extrusion list size: %d, Outer index %d, inner index %d, second inner index %d\n", position, reordered_extrusions.size(),outer,first_internal,second_internal);
+                    for (arr_i = position; arr_i < reordered_extrusions.size(); ++arr_i) {
+                        // printf("Perimeter: extrusion inset index %d, ordered extrusions array position %d\n",reordered_extrusions[arr_i].extrusion->inset_idx, arr_i);
+                        switch (reordered_extrusions[arr_i].extrusion->inset_idx) {
+                            case 0: // external perimeter
+                                if (outer == -1)
+                                    outer = arr_i;
+                                break;
+                            case 1: // first internal wall
+                                if (first_internal==-1 && arr_i>outer && outer!=-1){
+                                    first_internal = arr_i;
                                 }
-                            }
-                        
-                            for (arr_j = position; arr_j < second_internal; ++arr_j){ // go outside in and map the remaining perimeters (external and first internal wall(s)) using the outside in wall order
-                                // printf("Outside in loop: Mapped perimeter index %d to array position %d\n", arr_j, current_perimeter+1);
-                                inner_outer_extrusions[++current_perimeter] = reordered_extrusions[arr_j];
-                            }
-                        
-                            for(arr_j = position; arr_j <= max_internal; ++arr_j) // replace perimeter array with the new re-ordered array
-                                ordered_extrusions[arr_j] = inner_outer_extrusions[arr_j-position];
+                                break;
+                            case 2: // second internal wall
+                                if (second_internal == -1 && arr_i > first_internal && outer!=-1){
+                                    second_internal = arr_i;
+                                }
+                                break;
+                        }
+                        if(outer >-1 && first_internal>-1 && reordered_extrusions[arr_i].extrusion->inset_idx == 0){  // found a new external perimeter after we've found at least a first internal perimeter to re-order.
+                                                                                                                      // This means we entered a new island.
+                            arr_i=arr_i-1; //step back one perimeter
+                            max_internal = arr_i; // new maximum internal perimeter is now this as we have found a new external perimeter, hence a new island.
+                            break; // exit the for loop
                         }
-                        // go to the next perimeter from the current position to continue scanning for external walls in the same island
-                        position = arr_i + 1;
                     }
+                    
+                    // printf("Layer ID %d, Outer index %d, inner index %d, second inner index %d, maximum internal perimeter %d \n",layer_id,outer,first_internal,second_internal, max_internal);
+                    if (outer > -1 && first_internal > -1 && second_internal > -1) { // found all three perimeters to re-order? If not the perimeters will be processed outside in.
+                        std::vector<PerimeterGeneratorArachneExtrusion> inner_outer_extrusions; // temporary array to hold extrusions for reordering
+                        inner_outer_extrusions.resize(max_internal - position + 1); // reserve array containing the number of perimeters before a new island. Variables are array indexes hence need to add +1 to convert to position allocations
+                        // printf("Allocated array size %d, max_internal index %d, start position index %d \n",max_internal-position+1,max_internal,position);
+                        
+                        for (arr_j = max_internal; arr_j >=position; --arr_j){ // go inside out towards the external perimeter (perimeters in reverse order) and store all internal perimeters until the first one identified with inset index 2
+                            if(arr_j >= second_internal){
+                                //printf("Inside out loop: Mapped perimeter index %d to array position %d\n", arr_j, max_internal-arr_j);
+                                inner_outer_extrusions[max_internal-arr_j] = reordered_extrusions[arr_j];
+                                current_perimeter++; 
+                            }
+                        }
+                        
+                        for (arr_j = position; arr_j < second_internal; ++arr_j){ // go outside in and map the remaining perimeters (external and first internal wall(s)) using the outside in wall order
+                            // printf("Outside in loop: Mapped perimeter index %d to array position %d\n", arr_j, current_perimeter+1);
+                            inner_outer_extrusions[++current_perimeter] = reordered_extrusions[arr_j];
+                        }
+                        
+                        for(arr_j = position; arr_j <= max_internal; ++arr_j) // replace perimeter array with the new re-ordered array
+                            ordered_extrusions[arr_j] = inner_outer_extrusions[arr_j-position];
+                    }
+                    // go to the next perimeter from the current position to continue scanning for external walls in the same island
+                    position = arr_i + 1;
                 }
             }
+        }
         
-            bool steep_overhang_contour = false;
-            bool steep_overhang_hole    = false;
-            if (!config->overhang_reverse) {
-                // Skip steep overhang detection no reverse is specified
-                steep_overhang_contour = true;
-                steep_overhang_hole    = true;
-            }
-            if (ExtrusionEntityCollection extrusion_coll = traverse_extrusions(*this, ordered_extrusions, steep_overhang_contour, steep_overhang_hole); !extrusion_coll.empty()) {
-                if (config->overhang_reverse) {
-                    reorient_perimeters(extrusion_coll, steep_overhang_contour, steep_overhang_hole,
-                                        this->config->overhang_reverse_internal_only);
-                }
-                defer_unsupported_loops(*this, extrusion_coll);
-                result.loops     = std::move(extrusion_coll);
-                result.has_loops = true;
+        bool steep_overhang_contour = false;
+        bool steep_overhang_hole    = false;
+        if (!config->overhang_reverse) {
+            // Skip steep overhang detection no reverse is specified
+            steep_overhang_contour = true;
+            steep_overhang_hole    = true;
+        }
+        if (ExtrusionEntityCollection extrusion_coll = traverse_extrusions(*this, ordered_extrusions, steep_overhang_contour, steep_overhang_hole); !extrusion_coll.empty()) {
+            if (config->overhang_reverse) {
+                reorient_perimeters(extrusion_coll, steep_overhang_contour, steep_overhang_hole,
+                                    this->config->overhang_reverse_internal_only);
             }
+            defer_unsupported_loops(*this, extrusion_coll);
+            this->loops->append(extrusion_coll);
+        }
 
-            const coord_t spacing = (perimeters.size() == 1) ? ext_perimeter_spacing2 : perimeter_spacing;
+        const coord_t spacing = (perimeters.size() == 1) ? ext_perimeter_spacing2 : perimeter_spacing;
 
-            if (offset_ex(infill_contour, -float(spacing / 2.)).empty())
-                infill_contour.clear(); // Infill region is too small, so let's filter it out.
+        if (offset_ex(infill_contour, -float(spacing / 2.)).empty())
+            infill_contour.clear(); // Infill region is too small, so let's filter it out.
 
-            // create one more offset to be used as boundary for fill
-            // we offset by half the perimeter spacing (to get to the actual infill boundary)
-            // and then we offset back and forth by half the infill spacing to only consider the
-            // non-collapsing regions
-            coord_t inset =
-                (loop_number < 0) ? 0 :
-                (loop_number == 0) ?
-                // one loop
-                ext_perimeter_spacing :
-                // two or more loops?
-                perimeter_spacing;
-            coord_t top_inset = inset;
+        // create one more offset to be used as boundary for fill
+        // we offset by half the perimeter spacing (to get to the actual infill boundary)
+        // and then we offset back and forth by half the infill spacing to only consider the
+        // non-collapsing regions
+        coord_t inset =
+            (loop_number < 0) ? 0 :
+            (loop_number == 0) ?
+            // one loop
+            ext_perimeter_spacing :
+            // two or more loops?
+            perimeter_spacing;
+        coord_t top_inset = inset;
         
-            top_inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
-            if(is_topmost_layer || is_bottom_layer)
-                inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
-            else
-                inset = coord_t(scale_(this->config->infill_wall_overlap.get_abs_value(unscale<double>(inset))));
+        top_inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
+        if(is_topmost_layer || is_bottom_layer)
+            inset = coord_t(scale_(this->config->top_bottom_infill_wall_overlap.get_abs_value(unscale<double>(inset))));
+        else
+            inset = coord_t(scale_(this->config->infill_wall_overlap.get_abs_value(unscale<double>(inset))));
         
-            // simplify infill contours according to resolution
-            Polygons pp;
-            for (ExPolygon& ex : infill_contour)
-                ex.simplify_p(m_scaled_resolution, &pp);
-            ExPolygons not_filled_exp = union_ex(pp);
-            // collapse too narrow infill areas
-            const auto    min_perimeter_infill_spacing = coord_t(solid_infill_spacing * (1. - INSET_OVERLAP_TOLERANCE));
+        // simplify infill contours according to resolution
+        Polygons pp;
+        for (ExPolygon& ex : infill_contour)
+            ex.simplify_p(m_scaled_resolution, &pp);
+        ExPolygons not_filled_exp = union_ex(pp);
+        // collapse too narrow infill areas
+        const auto    min_perimeter_infill_spacing = coord_t(solid_infill_spacing * (1. - INSET_OVERLAP_TOLERANCE));
 
-            ExPolygons infill_exp = offset2_ex(
+        ExPolygons infill_exp = offset2_ex(
+            not_filled_exp,
+            float(-min_perimeter_infill_spacing / 2.),
+            float(inset + min_perimeter_infill_spacing / 2.));
+        // append infill areas to fill_surfaces
+        if (!top_expolygons.empty()) {
+            infill_exp = union_ex(infill_exp, offset_ex(top_expolygons, double(top_inset)));
+        }
+        this->fill_surfaces->append(infill_exp, stInternal);
+
+        apply_extra_perimeters(infill_exp);
+
+        // BBS: get the no-overlap infill expolygons
+        {
+            ExPolygons polyWithoutOverlap;
+            polyWithoutOverlap = offset2_ex(
                 not_filled_exp,
                 float(-min_perimeter_infill_spacing / 2.),
-                float(inset + min_perimeter_infill_spacing / 2.));
-            // append infill areas to fill_surfaces
-            if (!top_expolygons.empty()) {
-                infill_exp = union_ex(infill_exp, offset_ex(top_expolygons, double(top_inset)));
-            }
-            result.infill = std::move(infill_exp);
-
-            // BBS: get the no-overlap infill expolygons
-            {
-                ExPolygons polyWithoutOverlap;
-                polyWithoutOverlap = offset2_ex(
-                    not_filled_exp,
-                    float(-min_perimeter_infill_spacing / 2.),
-                    float(+min_perimeter_infill_spacing / 2.));
-                if (!top_expolygons.empty())
-                    polyWithoutOverlap = union_ex(polyWithoutOverlap, top_expolygons);
-                result.no_overlap = std::move(polyWithoutOverlap);
-            }
-      }
-    });
-    for (ArachneSurfaceResult &result : results) {
-        if (result.has_loops)
-            // Moved, not copied: append(const ExtrusionEntity &) clones the whole wall tree of the island.
-            this->loops->append(std::move(result.loops));
-        this->fill_surfaces->append(result.infill, stInternal);
-        apply_extra_perimeters(result.infill);
-        append(*this->fill_no_overlap, std::move(result.no_overlap));
+                float(+min_perimeter_infill_spacing / 2.));
+            if (!top_expolygons.empty())
+                polyWithoutOverlap = union_ex(polyWithoutOverlap, top_expolygons);
+            this->fill_no_overlap->insert(this->fill_no_overlap->end(), polyWithoutOverlap.begin(), polyWithoutOverlap.end());
+        }
     }
 }
 

src/libslic3r/PlaceholderParser.cpp

@@ -243,7 +243,7 @@ namespace client
     struct expr
     {
                  expr() {}
-                 expr(const expr &rhs) : m_type(rhs.type()), it_range(rhs.it_range), m_deferred(rhs.m_deferred)
+                 expr(const expr &rhs) : m_type(rhs.type()), it_range(rhs.it_range)
                     { if (rhs.type() == TYPE_STRING) m_data.s = new std::string(*rhs.m_data.s); else m_data.set(rhs.m_data); }
                  expr(expr &&rhs) : expr(std::move(rhs), rhs.it_range.begin(), rhs.it_range.end()) {}
 
@@ -258,16 +258,13 @@ namespace client
         explicit expr(std::string &&s) : m_type(TYPE_STRING) { m_data.s = new std::string(std::move(s)); }
         explicit expr(const std::string &s, const Iterator &it_begin, const Iterator &it_end) :
             m_type(TYPE_STRING), it_range(it_begin, it_end) { m_data.s = new std::string(s); }
-        explicit expr(expr &&rhs, const Iterator &it_begin, const Iterator &it_end) : m_type(rhs.type()), it_range{ it_begin, it_end }, m_deferred(rhs.m_deferred)
+        explicit expr(expr &&rhs, const Iterator &it_begin, const Iterator &it_end) : m_type(rhs.type()), it_range{ it_begin, it_end }
         {
             m_data.set(rhs.m_data);
-            rhs.m_type     = TYPE_EMPTY;
-            rhs.m_deferred = Deferred::None;
+            rhs.m_type = TYPE_EMPTY;
         }
         expr &operator=(const expr &rhs)
         { 
-            // set_s() clears m_deferred, which is also rhs.m_deferred on a self-assignment.
-            const Deferred deferred = rhs.m_deferred;
             if (rhs.type() == TYPE_STRING) {
                 this->set_s(rhs.s());
             } else  {
@@ -275,7 +272,6 @@ namespace client
                 m_data.set(rhs.m_data);
             }
             this->it_range = rhs.it_range;
-            m_deferred     = deferred;
             return *this;
         }
 
@@ -285,10 +281,8 @@ namespace client
                 this->reset();
                 m_type          = rhs.type();
                 this->it_range  = rhs.it_range;
-                m_deferred      = rhs.m_deferred;
                 m_data.set(rhs.m_data);
                 rhs.m_type      = TYPE_EMPTY;
-                rhs.m_deferred  = Deferred::None;
             }
             return *this;
         }
@@ -297,8 +291,7 @@ namespace client
         { 
             if (this->type() == TYPE_STRING)
                 delete m_data.s;
-            m_type     = TYPE_EMPTY;
-            m_deferred = Deferred::None;
+            m_type = TYPE_EMPTY;
         }
         ~expr() { reset(); }
 
@@ -311,10 +304,6 @@ namespace client
         };
         Type                type() const { return m_type; }
         bool                numeric_type() const { return m_type == TYPE_INT || m_type == TYPE_DOUBLE; }
-        // A deferred string is either one deferred value or text that contains at least one.
-        enum class Deferred : unsigned char { None, Value, Text };
-        bool                deferred() const { return m_deferred != Deferred::None; }
-        void                set_deferred(Deferred deferred) { m_deferred = deferred; }
 
         bool&               b()       { return m_data.b; }
         bool                b() const { return m_data.b; }
@@ -334,21 +323,18 @@ namespace client
         std::string&        s()       { return *m_data.s; }
         const std::string&  s() const { return *m_data.s; }
         void                set_s(const std::string &s) {
-            m_deferred = Deferred::None;
             if (this->type() == TYPE_STRING)
                 *m_data.s = s;
             else 
                 this->set_s_take_ownership(new std::string(s));
         }
         void                set_s(std::string &&s) {
-            m_deferred = Deferred::None;
             if (this->type() == TYPE_STRING)
                 *m_data.s = std::move(s);
             else
                 this->set_s_take_ownership(new std::string(std::move(s)));
         }
         void                set_s(const char *s) {
-            m_deferred = Deferred::None;
             if (this->type() == TYPE_STRING)
                 *m_data.s = s;
             else
@@ -492,21 +478,12 @@ namespace client
         {
             if (this->type() == TYPE_EMPTY) {
                 // Inside an if / else block to be skipped.
-            } else if (m_deferred == Deferred::Value && (rhs.type() != TYPE_STRING || rhs.m_deferred == Deferred::Value)) {
-                // A deferred value added to a number or to another deferred value is meant as a sum.
-                this->throw_if_deferred();
-            } else if (rhs.m_deferred == Deferred::Value && this->type() != TYPE_STRING) {
-                rhs.throw_if_deferred();
             } else if (this->type() == TYPE_STRING) {
                 // Convert the right hand side to string and append.
                 *m_data.s += rhs.to_string();
-                if (this->deferred() || rhs.deferred())
-                    m_deferred = Deferred::Text;
             } else if (rhs.type() == TYPE_STRING) {
                 // Conver the left hand side to string, append rhs.
                 this->set_s(this->to_string() + rhs.s());
-                if (rhs.deferred())
-                    m_deferred = Deferred::Text;
             } else {
                 const char *err_msg = L("Cannot add non-numeric types.");
                 this->throw_if_not_numeric(err_msg);
@@ -625,8 +602,6 @@ namespace client
             if (lhs.type() == TYPE_EMPTY)
                 // Inside an if / else block to be skipped
                 return;
-            lhs.throw_if_deferred();
-            rhs.throw_if_deferred();
             bool value = false;
             if (lhs.numeric_type() && rhs.numeric_type()) {
                 // Both types are numeric.
@@ -756,7 +731,6 @@ namespace client
             if (lhs.type() == TYPE_EMPTY)
                 // Inside an if / else block to be skipped
                 return;
-            lhs.throw_if_deferred();
             const std::string *subject  = nullptr;
             if (lhs.type() == TYPE_STRING) {
                 // One type is string, the other could be converted to string.
@@ -787,7 +761,6 @@ namespace client
             if (subject.type() == TYPE_EMPTY)
                 // Inside an if / else block to be skipped
                 return;
-            subject.throw_if_deferred();
             if (subject.type() != TYPE_STRING)
                 subject.throw_exception(L("regex_replace() first parameter must be a string."));
             try {
@@ -812,8 +785,6 @@ namespace client
                 return;            
             }
             if (! out.b()) {
-                match.throw_if_deferred();
-                pattern.throw_if_deferred();
                 if (match.type() != TYPE_STRING)
                     match.throw_exception(L("one_of(): First parameter (the string to match against) has to be a string value"));
                 if (pattern.type() != TYPE_STRING)
@@ -847,8 +818,6 @@ namespace client
             if (lhs.type() == TYPE_EMPTY)
                 // Inside an if / else block to be skipped
                 return;            
-            lhs.throw_if_deferred();
-            rhs.throw_if_deferred();
             bool value = false;
             if (lhs.type() == TYPE_BOOL && rhs.type() == TYPE_BOOL) {
                 value = (op == '|') ? (lhs.b() || rhs.b()) : (lhs.b() && rhs.b());
@@ -861,16 +830,8 @@ namespace client
         static void logical_or (expr &lhs, expr &rhs) { logical_op(lhs, rhs, '|'); }
         static void logical_and(expr &lhs, expr &rhs) { logical_op(lhs, rhs, '&'); }
 
-        static const char* deferred_message()
-        {
-            return L("This value is known only after the G-code is generated. It can be printed, but not used in a calculation or a comparison.");
-        }
-
-        // Reports the deferred message for a type error on a deferred value, since it holds a tag in place of the value.
         void throw_exception(const char *message) const
         {
-            if (this->deferred())
-                message = deferred_message();
             boost::throw_exception(qi::expectation_failure<Iterator>(
                 this->it_range.begin(), this->it_range.end(), spirit::info(std::string("*") + message)));
         }
@@ -881,18 +842,11 @@ namespace client
                 this->throw_exception(message);
         }
 
-        void throw_if_deferred() const
-        {
-            if (this->deferred())
-                this->throw_exception(deferred_message());
-        }
-
     private:
         // This object will take ownership of the parameter string object "s".
         void        set_s_take_ownership(std::string* s) { assert(this->type() != TYPE_STRING); Data tmp; tmp.s = s; m_data.set(tmp); m_type = TYPE_STRING; }
 
         Type        m_type = TYPE_EMPTY;
-        Deferred    m_deferred = Deferred::None;
 
         union Data {
             bool         b;
@@ -941,8 +895,6 @@ namespace client
         std::string              error_message;
         // Local variables declared in {if} branches that were not taken, see PlaceholderParser::check_inactive_branches.
         mutable std::set<std::string> inactive_local_variables;
-        // Tags of PlaceholderParser::set_deferred(), matched by value so that a copy in a variable is deferred too.
-        const std::set<std::string> *deferred_tags = nullptr;
 
         // Table to translate symbol tag to a human readable error message.
         static std::map<std::string, std::string> tag_to_error_message;
@@ -1018,18 +970,6 @@ namespace client
             } else
                 this->config_local.set_key_value(opt_key, opt.release());
         }
-        void                    mark_deferred(expr &output) const {
-            if (output.type() != expr::TYPE_STRING)
-                return;
-            expr::Deferred deferred = expr::Deferred::None;
-            if (deferred_tags != nullptr && output.s().find('@') != std::string::npos)
-                for (const std::string &tag : *deferred_tags)
-                    if (output.s().find(tag) != std::string::npos) {
-                        deferred = output.s() == tag ? expr::Deferred::Value : expr::Deferred::Text;
-                        break;
-                    }
-            output.set_deferred(deferred);
-        }
 
         static void legacy_variable_expansion(const MyContext *ctx, IteratorRange &opt_key, std::string &output)
         {
@@ -1490,7 +1430,6 @@ namespace client
                     vector_element_to_expr(ctx, opt, output);
                 else
                     scalar_variable_to_expr(ctx, opt, output);
-                ctx->mark_deferred(output);
             }
             output.it_range = opt.it_range;
         }
@@ -1577,7 +1516,7 @@ namespace client
             if (ctx->skipping()) {
             } else if (lhs.opt) {
                 if (lhs.opt->is_vector())
-                    ctx->throw_exception(L("Cannot assign a scalar value to a vector variable."), rhs.it_range);
+                    rhs.throw_exception(L("Cannot assign a scalar value to a vector variable."));
                 OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                 scalar_variable_assign_scalar(ctx, lhs_opt, rhs);
             } else {
@@ -1603,7 +1542,7 @@ namespace client
             if (ctx->skipping()) {
             } else if (lhs.opt) {
                 if (lhs.opt->is_scalar())
-                    ctx->throw_exception(L("Cannot assign a vector value to a scalar variable."), rhs_value.it_range);
+                    rhs_value.throw_exception(L("Cannot assign a vector value to a scalar variable."));
                 OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                 vector_variable_assign_expr_with_count(ctx, lhs_opt, rhs_count, rhs_value);
             } else {
@@ -1629,7 +1568,7 @@ namespace client
             if (! ctx->skipping()) {
                 check_writable(ctx, lhs);
                 if (lhs.opt->is_scalar())
-                    ctx->throw_exception(L("Cannot assign a vector value to a scalar variable."), rhs_value.it_range);
+                    rhs_value.throw_exception(L("Cannot assign a vector value to a scalar variable."));
                 vector_variable_assign_expr_with_count(ctx, lhs, rhs_count, rhs_value);
             }
         }
@@ -1864,21 +1803,10 @@ namespace client
 
         static void filament_change(const MyContext* ctx, expr& param)
         {
-            if (param.type() == expr::TYPE_EMPTY)
-                // Inside an if / else block to be skipped
-                return;
             MyContext *context = const_cast<MyContext *>(ctx);
-            param.throw_if_deferred();
             context->current_extruder_id = param.as_i();
         }
 
-        // The replacement may put a deferred tag into the result.
-        static void regex_replace(const MyContext *ctx, expr &subject, IteratorRange &pattern, expr &replacement)
-        {
-            expr::regex_replace(subject, pattern, replacement);
-            ctx->mark_deferred(subject);
-        }
-
         static void throw_exception(const std::string &msg, const IteratorRange &it_range)
         {
             // An asterix is added to the start of the string to differentiate the boost::spirit::info::tag content
@@ -2481,7 +2409,7 @@ namespace client
                 |   (kw["zdigits"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > optional_parameter(_r1))
                                                                     [ px::bind(&expr::digits<true>, _val, _2, _3) ]
                 |   (kw["regex_replace"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > regular_expression > ',' > conditional_expression(_r1) > ')')
-                                                                    [ px::bind(&MyContext::regex_replace, _r1, _val, _2, _3) ]
+                                                                    [ px::bind(&expr::regex_replace, _val, _2, _3) ]
                 |   (kw["int"]   > '(' > conditional_expression(_r1) > ')') [ px::bind(&FactorActions::to_int,  _1, _val) ]
                 |   (kw["round"] > '(' > conditional_expression(_r1) > ')') [ px::bind(&FactorActions::round,   _1, _val) ]
                 |   (kw["ceil"]  > '(' > conditional_expression(_r1) > ')') [ px::bind(&FactorActions::ceil,    _1, _val) ]
@@ -2686,7 +2614,6 @@ std::string PlaceholderParser::process(const std::string &templ, unsigned int cu
     context.config              = &this->config();
     context.config_override     = config_override;
     context.config_outputs      = config_outputs;
-    context.deferred_tags       = &m_deferred_tags;
     context.current_extruder_id = current_extruder_id;
     context.context_data        = context_data;
     return process_macro(templ, context);

src/libslic3r/PlaceholderParser.hpp

@@ -60,9 +60,6 @@ public:
     void set(const std::string &key, double value)              { this->set(key, new ConfigOptionFloat(value)); }
     void set(const std::string &key, const std::vector<std::string> &values) { this->set(key, new ConfigOptionStrings(values)); }
     void set(const std::string &key, ConfigOption *opt)         { m_config.set_key_value(key, opt); }
-    // Orca: sets a value known only after the G-code is generated, as a tag that post-processing replaces.
-    // A template may print it or join it to text, and a calculation or a comparison on it throws.
-    void set_deferred(const std::string &key, const std::string &tag) { this->set(key, tag); m_deferred_tags.insert(tag); }
 	DynamicConfig&			config_writable()					{ return m_config; }
 	const DynamicConfig&    config() const                      { return m_config; }
     const ConfigOption*     option(const std::string &key) const { return m_config.option(key); }
@@ -91,7 +88,6 @@ private:
 	// config has a higher priority than external_config when looking up a symbol.
     DynamicConfig 			 m_config;
     const DynamicConfig 	*m_external_config;
-    std::set<std::string>    m_deferred_tags;
 };
 
 }

src/libslic3r/Polygon.hpp

@@ -34,7 +34,7 @@ public:
     explicit Polygon(const Points &points) : MultiPoint(points) {}
 	Polygon(std::initializer_list<Point> points) : MultiPoint(points) {}
     Polygon(const Polygon &other) : MultiPoint(other.points) {}
-    Polygon(Polygon &&other) noexcept : MultiPoint(std::move(other.points)) {}
+    Polygon(Polygon &&other) : MultiPoint(std::move(other.points)) {}
 	static Polygon new_scale(const std::vector<Vec2d> &points) { 
         Polygon pgn;
         pgn.points.reserve(points.size());
@@ -43,7 +43,7 @@ public:
 		return pgn;
 	}
     Polygon& operator=(const Polygon &other) { points = other.points; return *this; }
-    Polygon& operator=(Polygon &&other) noexcept { points = std::move(other.points); return *this; }
+    Polygon& operator=(Polygon &&other) { points = std::move(other.points); return *this; }
 
     Point& operator[](Points::size_type idx) { return this->points[idx]; }
     const Point& operator[](Points::size_type idx) const { return this->points[idx]; }

src/libslic3r/Polyline.hpp

@@ -26,7 +26,7 @@ class Polyline : public MultiPoint {
 public:
     Polyline() {};
     Polyline(const Polyline& other) : MultiPoint(other.points), fitting_result(other.fitting_result) {}
-    Polyline(Polyline &&other) noexcept : MultiPoint(std::move(other.points)), fitting_result(std::move(other.fitting_result))  {}
+    Polyline(Polyline &&other) : MultiPoint(std::move(other.points)), fitting_result(std::move(other.fitting_result))  {}
     Polyline(std::initializer_list<Point> list) : MultiPoint(list) { 
         fitting_result.clear();
     }
@@ -47,7 +47,7 @@ public:
         fitting_result = other.fitting_result;
         return *this;
     }
-    Polyline& operator=(Polyline&& other) noexcept {
+    Polyline& operator=(Polyline&& other) {
         points = std::move(other.points);
         fitting_result = std::move(other.fitting_result);
         return *this;

src/libslic3r/Print.cpp

@@ -1882,23 +1882,6 @@ StringObjectException Print::validate(std::vector<StringObjectException> *warnin
     if (extruders.empty())
         return { L("No extrusions under current settings.") };
 
-    // A flow ratio of 0 would extrude nothing, and a nil one would write NaN extrusion lengths.
-    {
-        const std::vector<double> &flow_ratios = m_config.filament_flow_ratio.values;
-        const std::vector<int>    &self_index  = m_config.filament_self_index.values;
-        for (size_t column = 0; column < flow_ratios.size(); ++column) {
-            // filament_self_index maps a column to its filament once the filament arrays hold one column per variant
-            const unsigned int filament_id = self_index.size() == flow_ratios.size() ? self_index[column] - 1 : column;
-            if (flow_ratios[column] > 0. || !std::binary_search(extruders.begin(), extruders.end(), filament_id))
-                continue;
-            StringObjectException err;
-            // TRN %1% is the filament number as shown in the filament list, starting from 1.
-            err.string  = Slic3r::format(L("The flow ratio of filament %1% must be greater than 0."), filament_id + 1);
-            err.opt_key = "filament_flow_ratio";
-            return err;
-        }
-    }
-
     // IDEX/IQEX: block multi-color in non-primary parallel modes when the active
     // configuration can't physically support it (no within-gantry toolchange path
     // or MMU lane sharing). See imex_multicolor_block_reason() for the full rule.

src/libslic3r/PrintConfig.cpp

@@ -6459,7 +6459,7 @@ void PrintConfigDef::init_fff_params()
     def->label = L("Seam gap");
     def->category = L("Quality");
     def->tooltip = L("In order to reduce the visibility of the seam in a closed loop extrusion, the loop is interrupted and shortened by a specified amount.\n"
-                     "This amount can be specified in millimeters or as a percentage of the nozzle diameter. The default value for this parameter is 10%.");
+                     "This amount can be specified in millimeters or as a percentage of the current extruder diameter. The default value for this parameter is 10%.");
     def->sidetext = L("mm or %");
     def->min = 0;
     def->mode = comAdvanced;

src/libslic3r/PrintObject.cpp

@@ -50,7 +50,6 @@
 #include <cstdlib>
 #include <cstdint>
 #include <float.h>
-#include <array>
 #include <functional>
 #include <ios>
 #include <iomanip>
@@ -77,7 +76,6 @@
 #include <Eigen/Core>
 
 #include <tbb/parallel_for.h>
-#include <tbb/parallel_invoke.h>
 #include <tbb/spin_mutex.h>
 #include <tbb/concurrent_unordered_set.h>
 
@@ -1932,9 +1930,7 @@ void PrintObject::detect_surfaces_type()
     bool interface_shells = ! spiral_mode && m_config.interface_shells.value;
     size_t num_layers     = spiral_mode ? std::min(size_t(this->printing_region(0).config().bottom_shell_layers), m_layers.size()) : m_layers.size();
 
-    // The regions of a layer do not see each other here, and a layer cut through a fine relief takes far longer than the
-    // others, so the regions run next to each other instead of one after another, each still over all layers.
-    tbb::parallel_for(size_t(0), this->num_printing_regions(), [&](size_t region_id) {
+    for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id) {
         BOOST_LOG_TRIVIAL(debug) << "Detecting solid surfaces for region " << region_id << " in parallel - start";
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
         for (Layer *layer : m_layers)
@@ -1992,7 +1988,7 @@ void PrintObject::detect_surfaces_type()
                     if (upper_layer) {
                         ExPolygons upper_slices = interface_shells ?
                             diff_ex(layerm_slices_surfaces, upper_layer->m_regions[region_id]->slices.surfaces, ApplySafetyOffset::Yes) :
-                            diff_ex_by_piece(layerm_slices_surfaces, to_polygons(upper_layer->lslices), ApplySafetyOffset::Yes);
+                            diff_ex(layerm_slices_surfaces, upper_layer->lslices, ApplySafetyOffset::Yes);
                         surfaces_append(top, opening_ex(upper_slices, offset), stTop);
                     } else {
                         // if no upper layer, all surfaces of this one are solid
@@ -2018,7 +2014,7 @@ void PrintObject::detect_surfaces_type()
                         surfaces_append(
                             bottom,
                             opening_ex(
-                                diff_ex_by_piece(layerm_slices_surfaces, to_polygons(lower_layer->lslices), ApplySafetyOffset::Yes),
+                                diff_ex(layerm_slices_surfaces, lower_layer->lslices, ApplySafetyOffset::Yes),
                                 offset),
                             surface_type_bottom_other);
                         // if user requested internal shells, we need to identify surfaces
@@ -2049,44 +2045,34 @@ void PrintObject::detect_surfaces_type()
                     // and top surfaces; let's do an intersection to discover them and consider them
                     // as bottom surfaces (to allow for bridge detection)
                     if (! top.empty() && ! bottom.empty()) {
-                        const auto cracks = intersection_ex_by_piece(to_expolygons(top), to_polygons(bottom));
+                        const auto cracks = intersection_ex(top, bottom);
                         if (!cracks.empty()) {
                             if (lower_layer) { // Only detect small cracks for non-first layer, because first layer should always be bottom
                                 const float small_crack_threshold = -layerm->flow(frExternalPerimeter).scaled_width() * 1.5;
                                 
-                                // Only the bottom surfaces near a crack can take part: one that contains it must contain its box,
-                                // and one whose box misses the grown crack is left unchanged by removing it. A layer cut through
-                                // a fine relief has thousands of both, which made this loop quadratic.
                                 for (const auto& crack : cracks) {
                                     if (offset_ex(crack, small_crack_threshold).empty()) {
                                         // For small cracks, if it's part of a large bottom surface, then it should be added to bottom as well
-                                        const BoundingBox crack_bbox = get_extents(crack);
-                                        if (std::any_of(bottom.begin(), bottom.end(), [&crack, &crack_bbox, small_crack_threshold](const Surface& s) {
+                                        if (std::any_of(bottom.begin(), bottom.end(), [&crack, small_crack_threshold](const Surface& s) {
                                                 const auto& se = s.expolygon;
-                                                return get_extents(se).inflated(SCALED_EPSILON).contains(crack_bbox)
-                                                    && diff_ex(crack, se, ApplySafetyOffset::Yes).empty()
+                                                return diff_ex(crack, se, ApplySafetyOffset::Yes).empty()
                                                     && se.area() > crack.area() * 2
                                                     && !offset_ex(diff_ex(se, crack), small_crack_threshold).empty();
                                         })) continue;
 
                                         // Crack too small, leave it as part of the top surface, remove it from bottom surfaces
-                                        const ExPolygons  grown_crack = offset_ex(crack, -small_crack_threshold);
-                                        const BoundingBox grown_bbox  = get_extents(grown_crack);
                                         Surfaces bot_tmp;
                                         for (auto& b : bottom) {
-                                            if (get_extents(b.expolygon).overlap(grown_bbox))
-                                                surfaces_append(bot_tmp, diff_ex(b.expolygon, grown_crack), b.surface_type);
-                                            else
-                                                bot_tmp.emplace_back(std::move(b));
+                                            surfaces_append(bot_tmp, diff_ex(b.expolygon, offset_ex(crack, -small_crack_threshold)), b.surface_type);
                                         }
                                         bottom = std::move(bot_tmp);
                                     }
                                 }
                             }
 
-                            ExPolygons top_expolygons = to_expolygons(std::move(top));
+                            Polygons top_polygons = to_polygons(std::move(top));
                             top.clear();
-                            surfaces_append(top, diff_ex_by_piece(top_expolygons, to_polygons(bottom)), stTop);
+                            surfaces_append(top, diff_ex(top_polygons, bottom), stTop);
                         }
                     }
 
@@ -2177,7 +2163,7 @@ void PrintObject::detect_surfaces_type()
                     {
                         Polygons topbottom = to_polygons(top);
                         polygons_append(topbottom, to_polygons(bottom));
-                        surfaces_append(surfaces_out, diff_ex_by_piece(surfaces_prev_expolys, topbottom), stInternal);
+                        surfaces_append(surfaces_out, diff_ex(surfaces_prev_expolys, topbottom), stInternal);
                     }
 
                     surfaces_append(surfaces_out, std::move(top));
@@ -2354,31 +2340,29 @@ void PrintObject::detect_surfaces_type()
                 }
             }
             );
+            // ==============================================================================================================
+            // === ORCA: Interim workaround - for now the new stInternalAfterExternalBridge surfaace is re-classified  ==============
+            // === back to a bottom bridge. As a starting point, this improves bridging reliability as it extrudes ==========
+            // === two external bridge layers. However, TODO: Implement a new surface type throughout the codebase ==========
+            // ==============================================================================================================
+            for (size_t region_id = 0; region_id < this->num_printing_regions(); ++region_id) {
+                tbb::parallel_for( tbb::blocked_range<size_t>(0, m_layers.size()), [this, region_id](const tbb::blocked_range<size_t> &range) {
+                    for (size_t idx_layer = range.begin(); idx_layer < range.end(); ++idx_layer) {
+                        Surfaces &surfs = m_layers[idx_layer]->m_regions[region_id]->slices.surfaces;
+                        for (Surface &s : surfs) {
+                            if (s.surface_type == stInternalAfterExternalBridge) {
+                                s.surface_type = stBottomBridge;
+                            }
+                        }
+                    }
+                }
+              );
+            }
         }
         // ==============================================================================================================
         // === ORCA: End of second external bridge layer changes  =======================================================
         // ==============================================================================================================
         
-    }); // for each this->print->region_count
-
-    // ==============================================================================================================
-    // === ORCA: Interim workaround - for now the new stInternalAfterExternalBridge surfaace is re-classified  ==============
-    // === back to a bottom bridge. As a starting point, this improves bridging reliability as it extrudes ==========
-    // === two external bridge layers. However, TODO: Implement a new surface type throughout the codebase ==========
-    // ==============================================================================================================
-    // Once all the regions have their second bridge layer, and before their slices are trimmed into fill surfaces below.
-    if ((this->config().enable_extra_bridge_layer.value == eblApplyToAll) || (this->config().enable_extra_bridge_layer.value == eblExternalBridgeOnly)) {
-        tbb::parallel_for(tbb::blocked_range<size_t>(0, m_layers.size()), [this](const tbb::blocked_range<size_t> &range) {
-            for (size_t idx_layer = range.begin(); idx_layer < range.end(); ++idx_layer)
-                for (LayerRegion *layerm : m_layers[idx_layer]->regions())
-                    for (Surface &s : layerm->slices.surfaces)
-                        if (s.surface_type == stInternalAfterExternalBridge)
-                            s.surface_type = stBottomBridge;
-        });
-        m_print->throw_if_canceled();
-    }
-
-    tbb::parallel_for(size_t(0), this->num_printing_regions(), [&](size_t region_id) {
         BOOST_LOG_TRIVIAL(debug) << "Detecting solid surfaces for region " << region_id << " - clipping in parallel - start";
         // Fill in layerm->fill_surfaces by trimming the layerm->slices by the cummulative layerm->fill_surfaces.
         tbb::parallel_for(
@@ -2395,7 +2379,7 @@ void PrintObject::detect_surfaces_type()
             });
         m_print->throw_if_canceled();
         BOOST_LOG_TRIVIAL(debug) << "Detecting solid surfaces for region " << region_id << " - clipping in parallel - end";
-    });
+    } // for each this->print->region_count
 
     // Mark the object to have the region slices classified (typed, which also means they are split based on whether they are supported, bridging, top layers etc.)
     m_typed_slices = true;
@@ -2462,10 +2446,8 @@ void PrintObject::process_external_surfaces()
 	    BOOST_LOG_TRIVIAL(debug) << "Collecting surfaces covered with extrusions in parallel - end";
 	}
 
-    BOOST_LOG_TRIVIAL(debug) << "Processing external surfaces in parallel - start";
-    // The regions of a layer do not see each other here, and a layer cut through a fine relief takes far longer than the
-    // others, so the regions run next to each other instead of one after another, each still over all layers.
-    tbb::parallel_for(size_t(0), this->num_printing_regions(), [this, &surfaces_covered](size_t region_id) {
+	for (size_t region_id = 0; region_id < this->num_printing_regions(); ++region_id) {
+        BOOST_LOG_TRIVIAL(debug) << "Processing external surfaces for region " << region_id << " in parallel - start";
         tbb::parallel_for(
             tbb::blocked_range<size_t>(0, m_layers.size()),
             [this, &surfaces_covered, region_id](const tbb::blocked_range<size_t>& range) {
@@ -2480,9 +2462,9 @@ void PrintObject::process_external_surfaces()
                 }
             }
         );
-    });
-    m_print->throw_if_canceled();
-    BOOST_LOG_TRIVIAL(debug) << "Processing external surfaces in parallel - end";
+        m_print->throw_if_canceled();
+        BOOST_LOG_TRIVIAL(debug) << "Processing external surfaces for region " << region_id << " in parallel - end";
+    }
 }
 
 void PrintObject::discover_vertical_shells()
@@ -2521,10 +2503,10 @@ void PrintObject::discover_vertical_shells()
             // The "ensure vertical wall thickness" feature is not applicable to any of the regions. Quit.
             return;
         BOOST_LOG_TRIVIAL(debug) << "Discovering vertical shells in parallel - start : cache top / bottom";
-        // One layer per task: on a layer cut through a fine relief the unions below take far longer than elsewhere, and a
-        // few such layers next to each other must not end up in one task.
+        //FIXME Improve the heuristics for a grain size.
+        size_t grain_size = std::max(num_layers / 16, size_t(1));
         tbb::parallel_for(
-            tbb::blocked_range<size_t>(0, num_layers, 1),
+            tbb::blocked_range<size_t>(0, num_layers, grain_size),
             [this, &cache_top_botom_regions](const tbb::blocked_range<size_t>& range) {
                 const std::initializer_list<SurfaceType> surfaces_bottom { stBottom, stBottomBridge };
                 const size_t num_regions = this->num_printing_regions();
@@ -2532,198 +2514,67 @@ void PrintObject::discover_vertical_shells()
                     m_print->throw_if_canceled();
                     const Layer                      &layer = *m_layers[idx_layer];
                     DiscoverVerticalShellsCacheEntry &cache = cache_top_botom_regions[idx_layer];
-                    const auto top_bottom_expansion = [&layer](size_t region_id) {
-                        return float(layer.m_regions[region_id]->flow(frSolidInfill).scaled_spacing()) * top_bottom_expansion_coeff;
-                    };
+                    // Simulate single set of perimeters over all merged regions.
+                    float                             perimeter_offset = 0.f;
+                    float                             perimeter_min_spacing = FLT_MAX;
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
                     static size_t debug_idx = 0;
                     ++ debug_idx;
 #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-                    // The top surfaces, the bottom surfaces and the holes are independent of each other.
-                    tbb::parallel_invoke(
-                        [&]() {
-                            for (size_t region_id = 0; region_id < num_regions; ++ region_id)
-                                append(cache.top_surfaces, offset(layer.m_regions[region_id]->slices.filter_by_type(stTop), top_bottom_expansion(region_id)));
-//                              append(cache.top_surfaces, offset(layerm.fill_surfaces.filter_by_type(stTop), top_bottom_expansion));
-                            // Save some computing time by reducing the number of polygons.
-                            cache.top_surfaces = union_(cache.top_surfaces);
-                        },
-                        [&]() {
-                            for (size_t region_id = 0; region_id < num_regions; ++ region_id)
-                                append(cache.bottom_surfaces, offset(layer.m_regions[region_id]->slices.filter_by_types(surfaces_bottom), top_bottom_expansion(region_id)));
-//                              append(cache.bottom_surfaces, offset(layerm.fill_surfaces.filter_by_types(surfaces_bottom), top_bottom_expansion));
-                            cache.bottom_surfaces = union_(cache.bottom_surfaces);
-                        },
-                        [&]() {
-                            // Simulate single set of perimeters over all merged regions.
-                            float perimeter_offset      = 0.f;
-                            float perimeter_min_spacing = FLT_MAX;
-                            for (size_t region_id = 0; region_id < num_regions; ++ region_id) {
-                                const LayerRegion &layerm = *layer.m_regions[region_id];
-                                // Calculate the maximum perimeter offset as if the slice was extruded with a single extruder only.
-                                // First find the maxium number of perimeters per region slice.
-                                unsigned int perimeters = 0;
-                                for (const Surface &s : layerm.slices.surfaces)
-                                    perimeters = std::max<unsigned int>(perimeters, s.extra_perimeters);
-                                perimeters += layerm.region().config().wall_loops.value;
-                                // Then calculate the infill offset.
-                                if (perimeters > 0) {
-                                    Flow extflow = layerm.flow(frExternalPerimeter);
-                                    Flow flow    = layerm.flow(frPerimeter);
-                                    perimeter_offset = std::max(perimeter_offset,
-                                        0.5f * float(extflow.scaled_width() + extflow.scaled_spacing()) + (float(perimeters) - 1.f) * flow.scaled_spacing());
-                                    perimeter_min_spacing = std::min(perimeter_min_spacing, float(std::min(extflow.scaled_spacing(), flow.scaled_spacing())));
-                                }
-                                polygons_append(cache.holes, to_polygons(layerm.fill_expolygons));
-                            }
-                            // For a multi-material print, simulate perimeter / infill split as if only a single extruder has been used for the whole print.
-                            if (perimeter_offset > 0.) {
-                                // The layer.lslices are forced to merge by expanding them first.
-                                polygons_append(cache.holes, offset2(layer.lslices, 0.3f * perimeter_min_spacing, - perimeter_offset - 0.3f * perimeter_min_spacing));
+                    for (size_t region_id = 0; region_id < num_regions; ++ region_id) {
+                        LayerRegion &layerm               = *layer.m_regions[region_id];
+                        float        top_bottom_expansion = float(layerm.flow(frSolidInfill).scaled_spacing()) * top_bottom_expansion_coeff;
+                        // Top surfaces.
+                        append(cache.top_surfaces, offset(layerm.slices.filter_by_type(stTop), top_bottom_expansion));
+//                        append(cache.top_surfaces, offset(layerm.fill_surfaces.filter_by_type(stTop), top_bottom_expansion));
+                        // Bottom surfaces.
+                        append(cache.bottom_surfaces, offset(layerm.slices.filter_by_types(surfaces_bottom), top_bottom_expansion));
+//                        append(cache.bottom_surfaces, offset(layerm.fill_surfaces.filter_by_types(surfaces_bottom), top_bottom_expansion));
+                        // Calculate the maximum perimeter offset as if the slice was extruded with a single extruder only.
+                        // First find the maxium number of perimeters per region slice.
+                        unsigned int perimeters = 0;
+                        for (Surface &s : layerm.slices.surfaces)
+                            perimeters = std::max<unsigned int>(perimeters, s.extra_perimeters);
+                        perimeters += layerm.region().config().wall_loops.value;
+                        // Then calculate the infill offset.
+                        if (perimeters > 0) {
+                            Flow extflow = layerm.flow(frExternalPerimeter);
+                            Flow flow    = layerm.flow(frPerimeter);
+                            perimeter_offset = std::max(perimeter_offset,
+                                0.5f * float(extflow.scaled_width() + extflow.scaled_spacing()) + (float(perimeters) - 1.f) * flow.scaled_spacing());
+                            perimeter_min_spacing = std::min(perimeter_min_spacing, float(std::min(extflow.scaled_spacing(), flow.scaled_spacing())));
+                        }
+                        polygons_append(cache.holes, to_polygons(layerm.fill_expolygons));
+                    }
+                    // Save some computing time by reducing the number of polygons.
+                    cache.top_surfaces    = union_(cache.top_surfaces);
+                    cache.bottom_surfaces = union_(cache.bottom_surfaces);
+                    // For a multi-material print, simulate perimeter / infill split as if only a single extruder has been used for the whole print.
+                    if (perimeter_offset > 0.) {
+                        // The layer.lslices are forced to merge by expanding them first.
+                        polygons_append(cache.holes, offset2(layer.lslices, 0.3f * perimeter_min_spacing, - perimeter_offset - 0.3f * perimeter_min_spacing));
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
-                                {
-                                    Slic3r::SVG svg(debug_out_path("discover_vertical_shells-extra-holes-%d.svg", debug_idx), get_extents(layer.lslices));
-                                    svg.draw(layer.lslices, "blue");
-                                    svg.draw(union_ex(cache.holes), "red");
-                                    svg.draw_outline(union_ex(cache.holes), "black", "blue", scale_(0.05));
-                                    svg.Close();
-                                }
+                        {
+                            Slic3r::SVG svg(debug_out_path("discover_vertical_shells-extra-holes-%d.svg", debug_idx), get_extents(layer.lslices));
+                            svg.draw(layer.lslices, "blue");
+                            svg.draw(union_ex(cache.holes), "red");
+                            svg.draw_outline(union_ex(cache.holes), "black", "blue", scale_(0.05));
+                            svg.Close();
+                        }
 #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-                            }
-                            cache.holes = union_(cache.holes);
-                        });
+                    }
+                    cache.holes = union_(cache.holes);
                 }
             });
         m_print->throw_if_canceled();
         BOOST_LOG_TRIVIAL(debug) << "Discovering vertical shells in parallel - end : cache top / bottom";
     }
 
-    // With one top/bottom cache for all regions, the shell and hole accumulation in the loop below depends on nothing
-    // region-specific but the shell settings and the external perimeter spacing, so a region sharing them with an earlier
-    // one reuses its result instead of repeating it: that accumulation is a union over several layers of top/bottom
-    // surfaces, and a multi-material print has a region per filament.
-    using AccumulationKey = std::array<double, 5>;
-    struct ShellAccumulation
-    {
-        AccumulationKey key;
-        Polygons        shell;
-        Polygons        holes;
-    };
-    const auto accumulation_key = [](const PrintRegionConfig &region_config, const LayerRegion *layerm) {
-        return AccumulationKey{ double(region_config.top_shell_layers.value), region_config.top_shell_thickness.value,
-                                double(region_config.bottom_shell_layers.value), region_config.bottom_shell_thickness.value,
-                                double(layerm->flow(frExternalPerimeter).scaled_spacing()) };
-    };
-    const auto accumulate_shell = [this, &cache_top_botom_regions](size_t idx_layer, const PrintRegionConfig &region_config,
-                                                                   const LayerRegion *layerm, Polygons &shell, Polygons &holes) {
-        const Layer *layer = m_layers[idx_layer];
-    			        polygons_append(holes, cache_top_botom_regions[idx_layer].holes);
-                        auto combine_holes = [&holes](const Polygons &holes2) {
-                            if (holes.empty() || holes2.empty())
-                                holes.clear();
-                            else
-                                holes = intersection(holes, holes2);
-                        };
-                        auto combine_shells = [&shell](const Polygons &shells2) {
-                            if (shell.empty())
-                                shell = std::move(shells2);
-                            else if (! shells2.empty()) {
-                                polygons_append(shell, shells2);
-                                // Running the union_ using the Clipper library piece by piece is cheaper
-                                // than running the union_ all at once.
-                                shell = union_(shell);
-                            }
-                        };
-                        static constexpr const bool one_more_layer_below_top_bottom_surfaces = false;
-    			        if (int n_top_layers = region_config.top_shell_layers.value; n_top_layers > 0) {
-                            // Gather top regions projected to this layer.
-                            coordf_t print_z = layer->print_z;
-                            int i = int(idx_layer) + 1;
-                            int itop = int(idx_layer) + n_top_layers;
-                            bool at_least_one_top_projected = false;
-    	                    for (; i < int(cache_top_botom_regions.size()) &&
-    	                         (i < itop || m_layers[i]->print_z - print_z < region_config.top_shell_thickness - EPSILON);
-    	                        ++ i) {
-                                at_least_one_top_projected = true;
-    	                        const DiscoverVerticalShellsCacheEntry &cache = cache_top_botom_regions[i];
-                                combine_holes(cache.holes);
-                                combine_shells(cache.top_surfaces);
-    	                    }
-                            if (!at_least_one_top_projected && i < int(cache_top_botom_regions.size())) {
-                                // Lets consider this a special case - with only 1 top solid and minimal shell thickness settings, the
-                                // boundaries of solid layers are not anchored over/under perimeters, so lets fix it by adding at least one
-                                // perimeter width of area
-                                Polygons anchor_area = intersection(expand(cache_top_botom_regions[idx_layer].top_surfaces,
-                                                                           layerm->flow(frExternalPerimeter).scaled_spacing()),
-                                                                    to_polygons(m_layers[i]->lslices));
-                                combine_shells(anchor_area);
-                            }
-
-                            if (one_more_layer_below_top_bottom_surfaces)
-                                if (i < int(cache_top_botom_regions.size()) &&
-                                    (i <= itop || m_layers[i]->bottom_z() - print_z < region_config.top_shell_thickness - EPSILON))
-                                    combine_holes(cache_top_botom_regions[i].holes);
-    	                }
-    	                if (int n_bottom_layers = region_config.bottom_shell_layers.value; n_bottom_layers > 0) {
-                            // Gather bottom regions projected to this layer.
-                            coordf_t bottom_z = layer->bottom_z();
-                            int i = int(idx_layer) - 1;
-                            int ibottom = int(idx_layer) - n_bottom_layers;
-                            bool at_least_one_bottom_projected = false;
-    	                    for (; i >= 0 &&
-    	                         (i > ibottom || bottom_z - m_layers[i]->bottom_z() < region_config.bottom_shell_thickness - EPSILON);
-    	                        -- i) {
-                                    at_least_one_bottom_projected = true;
-    	                        const DiscoverVerticalShellsCacheEntry &cache = cache_top_botom_regions[i];
-    							combine_holes(cache.holes);
-                                combine_shells(cache.bottom_surfaces);
-    	                    }
-
-                            if (!at_least_one_bottom_projected && i >= 0) {
-                                Polygons anchor_area = intersection(expand(cache_top_botom_regions[idx_layer].bottom_surfaces,
-                                                                           layerm->flow(frExternalPerimeter).scaled_spacing()),
-                                                                    to_polygons(m_layers[i]->lslices));
-                                combine_shells(anchor_area);
-                            }
-
-                            if (one_more_layer_below_top_bottom_surfaces)
-                                if (i >= 0 &&
-                                    (i > ibottom || bottom_z - m_layers[i]->print_z < region_config.bottom_shell_thickness - EPSILON))
-                                    combine_holes(cache_top_botom_regions[i].holes);
-    	                }
-    };
-    std::vector<std::vector<ShellAccumulation>> shell_accumulations(top_bottom_surfaces_all_regions ? num_layers : 0);
-    if (! shell_accumulations.empty()) {
-        // Every (layer, key) pair is accumulated once, before the regions, so that nothing in the loop below is shared
-        // between them and they can run next to each other.
-        std::vector<std::array<size_t, 3>> todo; // layer, its slot, a region holding the key
-        for (size_t idx_layer = 0; idx_layer < num_layers; ++ idx_layer) {
-            std::vector<ShellAccumulation> &accumulations = shell_accumulations[idx_layer];
-            for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id) {
-                if (this->printing_region(region_id).config().ensure_vertical_shell_thickness.value != evstAll)
-                    continue;
-                const LayerRegion    *layerm = m_layers[idx_layer]->m_regions[region_id];
-                const AccumulationKey key    = accumulation_key(layerm->region().config(), layerm);
-                if (std::none_of(accumulations.begin(), accumulations.end(), [&key](const ShellAccumulation &a) { return a.key == key; })) {
-                    todo.push_back({ idx_layer, accumulations.size(), region_id });
-                    accumulations.push_back({ key, {}, {} });
-                }
-            }
-        }
-        tbb::parallel_for(size_t(0), todo.size(), [this, &todo, &shell_accumulations, &accumulate_shell](size_t i) {
-            m_print->throw_if_canceled();
-            const LayerRegion *layerm = m_layers[todo[i][0]]->m_regions[todo[i][2]];
-            ShellAccumulation &out    = shell_accumulations[todo[i][0]][todo[i][1]];
-            accumulate_shell(todo[i][0], layerm->region().config(), layerm, out.shell, out.holes);
-        });
-        m_print->throw_if_canceled();
-    }
-
-    const auto process_region = [&](size_t region_id) {
+    for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id) {
         const PrintRegion &region = this->printing_region(region_id);
         if (region.config().ensure_vertical_shell_thickness.value != evstAll )
             // This region will be handled by discover_horizontal_shells().
-            return;
+            continue;
 
         //FIXME Improve the heuristics for a grain size.
         size_t grain_size = std::max(num_layers / 16, size_t(1));
@@ -2763,7 +2614,7 @@ void PrintObject::discover_vertical_shells()
         grain_size = 1;
         tbb::parallel_for(
             tbb::blocked_range<size_t>(0, num_layers, grain_size),
-            [this, region_id, &shell_accumulations, &accumulation_key, &accumulate_shell]
+            [this, region_id, &cache_top_botom_regions]
             (const tbb::blocked_range<size_t>& range) {
                 // printf("discover_vertical_shells from %d to %d\n", range.begin(), range.end());
                 for (size_t idx_layer = range.begin(); idx_layer < range.end(); ++ idx_layer) {
@@ -2813,19 +2664,80 @@ void PrintObject::discover_vertical_shells()
                         }
                     }
 #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-                    const AccumulationKey key = accumulation_key(region_config, layerm);
-                    const ShellAccumulation *reused = shell_accumulations.empty() ? nullptr :
-                        [&]() -> const ShellAccumulation * {
-                            for (const ShellAccumulation &a : shell_accumulations[idx_layer])
-                                if (a.key == key)
-                                    return &a;
-                            return nullptr;
-                        }();
-                    if (reused != nullptr) {
-                        shell = reused->shell;
-                        holes = reused->holes;
-                    } else
-                        accumulate_shell(idx_layer, region_config, layerm, shell, holes);
+			        polygons_append(holes, cache_top_botom_regions[idx_layer].holes);
+                    auto combine_holes = [&holes](const Polygons &holes2) {
+                        if (holes.empty() || holes2.empty())
+                            holes.clear();
+                        else
+                            holes = intersection(holes, holes2);
+                    };
+                    auto combine_shells = [&shell](const Polygons &shells2) {
+                        if (shell.empty())
+                            shell = std::move(shells2);
+                        else if (! shells2.empty()) {
+                            polygons_append(shell, shells2);
+                            // Running the union_ using the Clipper library piece by piece is cheaper
+                            // than running the union_ all at once.
+                            shell = union_(shell);
+                        }
+                    };
+                    static constexpr const bool one_more_layer_below_top_bottom_surfaces = false;
+			        if (int n_top_layers = region_config.top_shell_layers.value; n_top_layers > 0) {
+                        // Gather top regions projected to this layer.
+                        coordf_t print_z = layer->print_z;
+                        int i = int(idx_layer) + 1;
+                        int itop = int(idx_layer) + n_top_layers;
+                        bool at_least_one_top_projected = false;
+	                    for (; i < int(cache_top_botom_regions.size()) &&
+	                         (i < itop || m_layers[i]->print_z - print_z < region_config.top_shell_thickness - EPSILON);
+	                        ++ i) {
+                            at_least_one_top_projected = true;
+	                        const DiscoverVerticalShellsCacheEntry &cache = cache_top_botom_regions[i];
+                            combine_holes(cache.holes);
+                            combine_shells(cache.top_surfaces);
+	                    }
+                        if (!at_least_one_top_projected && i < int(cache_top_botom_regions.size())) {
+                            // Lets consider this a special case - with only 1 top solid and minimal shell thickness settings, the
+                            // boundaries of solid layers are not anchored over/under perimeters, so lets fix it by adding at least one
+                            // perimeter width of area
+                            Polygons anchor_area = intersection(expand(cache_top_botom_regions[idx_layer].top_surfaces,
+                                                                       layerm->flow(frExternalPerimeter).scaled_spacing()),
+                                                                to_polygons(m_layers[i]->lslices));
+                            combine_shells(anchor_area);
+                        }
+
+                        if (one_more_layer_below_top_bottom_surfaces)
+                            if (i < int(cache_top_botom_regions.size()) &&
+                                (i <= itop || m_layers[i]->bottom_z() - print_z < region_config.top_shell_thickness - EPSILON))
+                                combine_holes(cache_top_botom_regions[i].holes);
+	                }
+	                if (int n_bottom_layers = region_config.bottom_shell_layers.value; n_bottom_layers > 0) {
+                        // Gather bottom regions projected to this layer.
+                        coordf_t bottom_z = layer->bottom_z();
+                        int i = int(idx_layer) - 1;
+                        int ibottom = int(idx_layer) - n_bottom_layers;
+                        bool at_least_one_bottom_projected = false;
+	                    for (; i >= 0 &&
+	                         (i > ibottom || bottom_z - m_layers[i]->bottom_z() < region_config.bottom_shell_thickness - EPSILON);
+	                        -- i) {
+                                at_least_one_bottom_projected = true;
+	                        const DiscoverVerticalShellsCacheEntry &cache = cache_top_botom_regions[i];
+							combine_holes(cache.holes);
+                            combine_shells(cache.bottom_surfaces);
+	                    }
+
+                        if (!at_least_one_bottom_projected && i >= 0) {
+                            Polygons anchor_area = intersection(expand(cache_top_botom_regions[idx_layer].bottom_surfaces,
+                                                                       layerm->flow(frExternalPerimeter).scaled_spacing()),
+                                                                to_polygons(m_layers[i]->lslices));
+                            combine_shells(anchor_area);
+                        }
+
+                        if (one_more_layer_below_top_bottom_surfaces)
+                            if (i >= 0 &&
+                                (i > ibottom || bottom_z - m_layers[i]->print_z < region_config.bottom_shell_thickness - EPSILON))
+                                combine_holes(cache_top_botom_regions[i].holes);
+	                }
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
                     {
         				Slic3r::SVG svg(debug_out_path("discover_vertical_shells-perimeters-before-union-%d.svg", debug_idx), get_extents(shell));
@@ -2919,8 +2831,11 @@ void PrintObject::discover_vertical_shells()
                         Polygons object_volume;
                         Polygons internal_volume;
                         {
-                            if (idx_layer > 0 && idx_layer + 1 < m_layers.size())
-                                object_volume = to_polygons(intersection_ex_by_piece(m_layers[idx_layer - 1]->lslices, to_polygons(m_layers[idx_layer + 1]->lslices)));
+                            Polygons shrinked_bottom_slice = idx_layer > 0 ? to_polygons(m_layers[idx_layer - 1]->lslices) : Polygons{};
+                            Polygons shrinked_upper_slice  = (idx_layer + 1) < m_layers.size() ?
+                                                                 to_polygons(m_layers[idx_layer + 1]->lslices) :
+                                                                 Polygons{};
+                            object_volume = intersection(shrinked_bottom_slice, shrinked_upper_slice);
                             internal_volume = closing(polygonsInternal, SCALED_EPSILON);
                         }
 
@@ -2931,34 +2846,15 @@ void PrintObject::discover_vertical_shells()
                         //      the in-model condition is there due to small sloping surfaces, e.g. top of the hull of the benchy
                         //   2. the area does not fully cover an internal polygon
                         //         This is there mainly for a very thin parts, where the solid layers would be missing if the part area is quite small
-                        // Both tests below compare a small piece against the whole layer. Done literally, that is
-                        // quadratic in the number of pieces, which is what a layer split up by colour painting has,
-                        // so each is restricted to the part of the layer near the piece with an identical result:
-                        // object_volume is clipped to the piece's box, and only the internal polygons whose box meets
-                        // the expanded piece take part in the count, since the others pass through the difference
-                        // unchanged and add the same number to both sides of it.
-                        std::vector<BoundingBox> internal_bboxes;
-                        internal_bboxes.reserve(internal_volume.size());
-                        for (const Polygon &poly : internal_volume)
-                            internal_bboxes.emplace_back(get_extents(poly));
                         regularized_shell.erase(std::remove_if(regularized_shell.begin(), regularized_shell.end(),
-                                                               [&internal_volume, &internal_bboxes, &min_perimeter_infill_spacing,
+                                                               [&internal_volume, &min_perimeter_infill_spacing,
                                                                 &object_volume](const ExPolygon &p) {
-                                                                   const bool small = p.area() < min_perimeter_infill_spacing * scaled(1.5) ||
-                                                                                      (p.area() < min_perimeter_infill_spacing * scaled(8.0) &&
-                                                                                       diff(to_polygons(p),
-                                                                                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(
-                                                                                                object_volume, get_extents(p).inflated(SCALED_EPSILON)))
-                                                                                           .empty());
-                                                                   if (!small)
-                                                                       return false;
-                                                                   const Polygons    expanded = expand(to_polygons(p), min_perimeter_infill_spacing);
-                                                                   const BoundingBox bbox     = get_extents(expanded);
-                                                                   Polygons          nearby;
-                                                                   for (size_t i = 0; i < internal_volume.size(); ++i)
-                                                                       if (internal_bboxes[i].overlap(bbox))
-                                                                           nearby.emplace_back(internal_volume[i]);
-                                                                   return diff(nearby, expanded).size() >= nearby.size();
+                                                                   return (p.area() < min_perimeter_infill_spacing * scaled(1.5) ||
+                                                                           (p.area() < min_perimeter_infill_spacing * scaled(8.0) &&
+                                                                            diff(to_polygons(p), object_volume).empty())) &&
+                                                                          diff(internal_volume,
+                                                                               expand(to_polygons(p), min_perimeter_infill_spacing))
+                                                                                  .size() >= internal_volume.size();
                                                                }),
                                                 regularized_shell.end());
                     }
@@ -2980,9 +2876,8 @@ void PrintObject::discover_vertical_shells()
 #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
 
                     // Trim the internal & internalvoid by the shell.
-                    const Polygons     regularized_shell_polygons = to_polygons(regularized_shell);
-                    Slic3r::ExPolygons new_internal = diff_ex_by_piece(to_expolygons(layerm->fill_surfaces.filter_by_type(stInternal)), regularized_shell_polygons);
-                    Slic3r::ExPolygons new_internal_void = diff_ex_by_piece(to_expolygons(layerm->fill_surfaces.filter_by_type(stInternalVoid)), regularized_shell_polygons);
+                    Slic3r::ExPolygons new_internal = diff_ex(layerm->fill_surfaces.filter_by_type(stInternal), regularized_shell);
+                    Slic3r::ExPolygons new_internal_void = diff_ex(layerm->fill_surfaces.filter_by_type(stInternalVoid), regularized_shell);
 
 #ifdef SLIC3R_DEBUG_SLICE_PROCESSING
                     {
@@ -3009,15 +2904,7 @@ void PrintObject::discover_vertical_shells()
 			layerm->export_region_fill_surfaces_to_svg_debug("3_discover_vertical_shells-final");
 		}
 #endif /* SLIC3R_DEBUG_SLICE_PROCESSING */
-    }; // for each region
-    if (top_bottom_surfaces_all_regions)
-        // Nothing is shared between the regions, and a layer cut through a fine relief takes far longer than the others,
-        // so they run next to each other instead of one after another.
-        tbb::parallel_for(size_t(0), this->num_printing_regions(), process_region);
-    else
-        // Here every region fills the one top/bottom cache with its own surfaces first.
-        for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id)
-            process_region(region_id);
+    } // for each region
 } // void PrintObject::discover_vertical_shells()
 
 // #define DEBUG_BRIDGE_OVER_INFILL
@@ -3538,16 +3425,6 @@ void PrintObject::bridge_over_infill()
                 vertical_lines[i].b = Point{x, y_max};
             }
 
-            // The vertical lines only span the bridged area's x range, so anchors entirely outside it can never be
-            // hit. Leaving them out gives the same intersections without building a tree over the whole layer's
-            // boundary for every bridge.
-            const coord_t scan_x_min = bb_x.min.x();
-            const coord_t scan_x_max = bb_x.min.x() + coord_t(n_vlines) * scan_spacing;
-            anchors.erase(std::remove_if(anchors.begin(), anchors.end(),
-                                         [scan_x_min, scan_x_max](const Line &l) {
-                                             return std::max(l.a.x(), l.b.x()) < scan_x_min || std::min(l.a.x(), l.b.x()) > scan_x_max;
-                                         }),
-                          anchors.end());
             auto anchors_and_walls_tree = AABBTreeLines::LinesDistancer<Line>{std::move(anchors)};
             auto bridged_area_tree      = AABBTreeLines::LinesDistancer<Line>{to_lines(bridged_area)};
 
@@ -3792,58 +3669,26 @@ void PrintObject::bridge_over_infill()
 
                 std::vector<CandidateSurface> expanded_surfaces;
                 expanded_surfaces.reserve(surfaces_by_layer[lidx].size());
-                // The expanded fill boundary depends only on the bridging flow, and total_fill_area is not
-                // modified below, so build it once per spacing rather than once per candidate. A layer split
-                // into many candidates (e.g. by colour painting) otherwise repeats a layer-wide offset for each.
-                std::map<coord_t, Polylines> boundary_by_spacing;
-                // expansion_area is a clean, non-overlapping set, so cutting a bridge out of it only changes the
-                // polygons near that bridge. The rest are passed through untouched instead of being fed to Clipper
-                // with the whole layer again for every candidate.
-                // Not `near`/`far`: the Windows headers still define those as macros, and they expand to
-                // nothing, which turns the declaration below into an empty one.
-                const auto split_near = [](const Polygons &polys, const BoundingBox &bbox, Polygons &rest) {
-                    Polygons nearby;
-                    for (const Polygon &p : polys)
-                        (get_extents(p).overlap(bbox) ? nearby : rest).emplace_back(p);
-                    return nearby;
-                };
                 for (const CandidateSurface &candidate : surfaces_by_layer[lidx]) {
                     const auto &region_config = candidate.region->region().config();
                     const bool turning_pattern = region_config.sparse_infill_pattern == ipHilbertCurve ||
                                                  region_config.sparse_infill_pattern == ipOctagramSpiral;
                     const Flow &flow              = candidate.region->bridging_flow(frSolidInfill, true);
-                    const Polygons expanded_polys = expand(candidate.new_polys, flow.scaled_spacing());
-                    // deep_infill_area and internal_unsupported_area cover the whole layer; only their part under
-                    // this candidate can change the results, so they are clipped to its box first.
-                    ExPolygons bridge_components;
-                    if (!expanded_polys.empty())
-                        bridge_components = intersection_ex(expanded_polys,
-                                                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(
-                                                                deep_infill_area, get_extents(expanded_polys).inflated(SCALED_EPSILON)));
+                    ExPolygons bridge_components = intersection_ex(expand(candidate.new_polys, flow.scaled_spacing()), deep_infill_area);
                     // Orca: Filter whole bridge areas so their holes remain holes.
                     bridge_components.erase(std::remove_if(bridge_components.begin(), bridge_components.end(),
                                                            [&internal_unsupported_area](const ExPolygon &component) {
-                                                               return intersection_ex(component, ClipperUtils::clip_clipper_polygons_with_subject_bbox(
-                                                                                                     internal_unsupported_area,
-                                                                                                     get_extents(component).inflated(SCALED_EPSILON)))
-                                                                   .empty();
+                                                               return intersection_ex(component, internal_unsupported_area).empty();
                                                            }),
                                             bridge_components.end());
                     Polygons area_to_be_bridge = to_polygons(std::move(bridge_components));
 
+                    Polygons limiting_area = union_(area_to_be_bridge, expansion_area);
+
                     if (area_to_be_bridge.empty())
                         continue;
 
-                    // Not split like the cut of expansion_area below: the whole limiting area is grown by 30% of the spacing,
-                    // which merges neighbouring polygons, and any of its boundary can anchor the bridge.
-                    Polygons limiting_area = union_(area_to_be_bridge, expansion_area);
-
-                    auto boundary_it = boundary_by_spacing.find(flow.scaled_spacing());
-                    if (boundary_it == boundary_by_spacing.end())
-                        boundary_it = boundary_by_spacing
-                                          .emplace(flow.scaled_spacing(), to_polylines(expand(total_fill_area, 1.3f * flow.scaled_spacing())))
-                                          .first;
-                    Polylines boundary_plines = boundary_it->second;
+                    Polylines boundary_plines = to_polylines(expand(total_fill_area, 1.3f * flow.scaled_spacing()));
                     {
                         Polylines limiting_plines = to_polylines(expand(limiting_area, 0.3f * flow.scaled_spacing()));
                         boundary_plines.insert(boundary_plines.end(), limiting_plines.begin(), limiting_plines.end());
@@ -3919,12 +3764,9 @@ void PrintObject::bridge_over_infill()
                     // Check collision with other expanded surfaces
                     {
                         bool     reconstruct       = false;
-                        Polygons          tmp_expanded_area = expand(bridging_area, 3.0 * flow.scaled_spacing());
-                        const BoundingBox tmp_expanded_bbox = get_extents(tmp_expanded_area);
+                        Polygons tmp_expanded_area = expand(bridging_area, 3.0f * flow.scaled_spacing());
                         for (const CandidateSurface &s : expanded_surfaces) {
-                            // Surfaces whose boxes miss each other cannot intersect, which is most pairs on a busy layer.
-                            if (get_extents(s.new_polys).overlap(tmp_expanded_bbox) &&
-                                !intersection(s.new_polys, tmp_expanded_area).empty()) {
+                            if (!intersection(s.new_polys, tmp_expanded_area).empty()) {
                                 bridging_angle = s.bridge_angle;
                                 reconstruct    = true;
                                 break;
@@ -3948,20 +3790,10 @@ void PrintObject::bridge_over_infill()
                         bridging_area = union_(bridging_area, construct_anchored_polygon(bridging_area, to_lines(boundary_plines), flow,
                                                                                        bridging_angle, scan_spacing, true));
                     }
-                    // Each of these meets one bridge with the whole layer, so the layer side is first cut down to the
-                    // bridge's box (and expansion_area split as above); the result is the same.
-                    if (!bridging_area.empty()) {
-                        const BoundingBox bridging_bbox = get_extents(bridging_area).inflated(SCALED_EPSILON);
-                        bridging_area = intersection(bridging_area, ClipperUtils::clip_clipper_polygons_with_subject_bbox(limiting_area, bridging_bbox));
-                        bridging_area = intersection(bridging_area, ClipperUtils::clip_clipper_polygons_with_subject_bbox(total_fill_area, bridging_bbox));
-                        bridging_area = diff(bridging_area, ClipperUtils::clip_clipper_polygons_with_subject_bbox(total_top_area, bridging_bbox));
-                    }
-                    if (!bridging_area.empty()) {
-                        Polygons       kept;
-                        const Polygons cut = split_near(expansion_area, get_extents(bridging_area).inflated(SCALED_EPSILON), kept);
-                        append(kept, diff(cut, bridging_area));
-                        expansion_area = std::move(kept);
-                    }
+                    bridging_area          = intersection(bridging_area, limiting_area);
+                    bridging_area          = intersection(bridging_area, total_fill_area);
+                    bridging_area          = diff(bridging_area, total_top_area);
+                    expansion_area         = diff(expansion_area, bridging_area);
 
 #ifdef DEBUG_BRIDGE_OVER_INFILL
                     debug_draw(std::to_string(lidx) + "_" + std::to_string(cluster_idx) + "_" + std::to_string(job_idx) + "_" + "_expanded_bridging" +  std::to_string(r),

src/libslic3r/Support/SupportMaterial.cpp

@@ -1004,9 +1004,9 @@ public:
                 ::fread(&y, sizeof(coord_t), 1, file);
                 poly.points.emplace_back(Point(x * scale, y * scale));
             }
-            printf("Polygon %d, area: %lf\n", i, area(poly.points));
             if (which == -1 || which == i)
                 m_support_polygons_deserialized.emplace_back(std::move(poly));
+            printf("Polygon %d, area: %lf\n", i, area(poly.points));
         }
         ::fread(&n_polygons, 4, 1, file);
         m_trimming_polygons_deserialized.reserve(n_polygons);

src/libslic3r/Support/TreeSupport.cpp

@@ -996,46 +996,16 @@ void TreeSupport::detect_overhangs(bool check_support_necessity/* = false*/)
                 if (is_auto(stype) && config_detect_sharp_tails)
                 {
                     // BBS detect sharp tail
-                    // On a belt, "below" has to include the belt itself and the
-                    // shear-advanced lower layer, or every belt-contact island reads as
-                    // a sharp tail -- which is what the empty-predecessor skip above was
-                    // really masking. effective_lower is exactly that notion of below.
-                    const ExPolygons &tail_lower = belt_ovh_active ? effective_lower : lower_polys;
-                    // Each island is tested only against the lower islands whose box meets its own; overlaps() tries
-                    // every pair, which is quadratic in the island counts of the two layers.
-                    std::vector<BoundingBox> lower_bboxes;
-                    lower_bboxes.reserve(tail_lower.size());
-                    for (const ExPolygon &lower : tail_lower)
-                        lower_bboxes.emplace_back(get_extents(lower));
                     for (const ExPolygon& expoly : curr_polys) {
                         bool  is_sharp_tail = false;
                         // 1. nothing below
-                        // this is a sharp tail region if it's floating and non-ignorable
-                        const ExPolygons  expanded = offset_ex(expoly, 0.1 * extrusion_width_scaled);
-                        const BoundingBox bbox     = get_extents(expanded);
-                        ExPolygons        lower_nearby;
-                        for (size_t i = 0; i < tail_lower.size(); ++i)
-                            if (lower_bboxes[i].overlap(bbox))
-                                lower_nearby.emplace_back(tail_lower[i]);
-                        // As overlaps(expanded, lower_nearby), with each lower island cut to the island's box first:
-                        // below a fine relief the lower layer is a few islands with thousands of holes, and the whole
-                        // of that boundary would otherwise be intersected once per island above.
-                        const auto overlaps_nearby = [&]() {
-                            for (const ExPolygon &a : expanded) {
-                                if (a.empty())
-                                    continue;
-                                const BoundingBox a_bbox = get_extents(a);
-                                for (const ExPolygon &b : lower_nearby) {
-                                    if (b.empty() || !get_extents(b).overlap(a_bbox))
-                                        continue;
-                                    const Polygons b_near = ClipperUtils::clip_clipper_polygons_with_subject_bbox(b, a_bbox.inflated(SCALED_EPSILON));
-                                    if (!intersection_pl(to_polylines(b_near), a).empty() || b.contains(a.contour.points.front()))
-                                        return true;
-                                }
-                            }
-                            return false;
-                        };
-                        if (!overlaps_nearby()) {
+                        // this is a sharp tail region if it's floating and non-ignorable.
+                        // On a belt, "below" has to include the belt itself and the
+                        // shear-advanced lower layer, or every belt-contact island reads as
+                        // a sharp tail -- which is what the empty-predecessor skip above was
+                        // really masking. effective_lower is exactly that notion of below.
+                        const ExPolygons &tail_lower = belt_ovh_active ? effective_lower : lower_polys;
+                        if (!overlaps(offset_ex(expoly, 0.1 * extrusion_width_scaled), tail_lower)) {
                             is_sharp_tail = !offset_ex(expoly, -0.1 * extrusion_width_scaled).empty();
                         }
 

src/libslic3r/Surface.hpp

@@ -68,7 +68,7 @@ public:
             thickness(other.thickness), thickness_layers(other.thickness_layers),
             bridge_angle(other.bridge_angle), extra_perimeters(other.extra_perimeters)
         {};
-    Surface(Surface &&rhs) noexcept
+    Surface(Surface &&rhs)
         : surface_type(rhs.surface_type), expolygon(std::move(rhs.expolygon)),
             thickness(rhs.thickness), thickness_layers(rhs.thickness_layers),
             bridge_angle(rhs.bridge_angle), extra_perimeters(rhs.extra_perimeters)
@@ -94,7 +94,7 @@ public:
         return *this;
     }
 
-    Surface& operator=(Surface &&rhs) noexcept
+    Surface& operator=(Surface &&rhs)
     {
         surface_type     = rhs.surface_type;
         expolygon        = std::move(rhs.expolygon);

src/libslic3r/libslic3r.h

@@ -167,10 +167,10 @@ inline void append(std::vector<T, Alloc> &dest, std::vector<T, Alloc> &&src)
 {
     if (dest.empty())
         dest = std::move(src);
-    else
-        // insert() grows the capacity geometrically; reserving exactly the new size reallocated on every call, which
-        // made appending piece by piece quadratic.
-        dest.insert(dest.end(), std::make_move_iterator(src.begin()), std::make_move_iterator(src.end()));
+    else {
+        dest.reserve(dest.size() + src.size());
+        std::move(std::begin(src), std::end(src), std::back_inserter(dest));
+    }
     src.clear();
     src.shrink_to_fit();
 }

src/libslic3r/utils.cpp

@@ -2024,9 +2024,7 @@ static Semver installable_cache_version(const boost::filesystem::path& dir, cons
     const auto cache_ver = Semver::parse(VendorCacheFile::peek_version((dir / (vendor + ".opc")).string(), vendor));
     if (! cache_ver)
         return Semver::invalid();
-    // Packaging prunes the profile of every vendor that ships a cache.
-    const boost::filesystem::path json = dir / (vendor + ".json");
-    const Semver profile_ver = boost::filesystem::exists(json) ? get_version_from_json(json.string()) : Semver();
+    const Semver profile_ver = get_version_from_json((dir / (vendor + ".json")).string());
     return cache_covers(*cache_ver, profile_ver) ? *cache_ver : Semver::invalid();
 }
 

src/slic3r/CMakeLists.txt

@@ -707,6 +707,10 @@ set(SLIC3R_GUI_SOURCES
     plugin/PluginManager.hpp
     plugin/PluginAuditManager.cpp
     plugin/PluginAuditManager.hpp
+    plugin/PluginAuditManagerGui.cpp
+    plugin/PluginAuditManagerInternal.hpp
+    plugin/PluginModule.cpp
+    plugin/PluginText.hpp
     plugin/PluginResolver.cpp
     plugin/PluginResolver.hpp
     plugin/pluginTypes/printerAgent/PrinterAgentPluginCapability.hpp
@@ -1092,3 +1096,65 @@ if (ORCA_BUILD_PYTHON_STUBGEN_MODULE)
         PREFIX ""
     )
 endif()
+
+# Headless plugin permission probe. A distinct executable so normal GUI loading and prompt
+# behavior stay untouched. It compiles the GUI-free plugin sources directly instead of linking
+# libslic3r_gui, so neither the GUI library nor wx is pulled into the probe. The permission
+# front end is selected by source composition: PluginAuditManagerGui.cpp for the GUI app and
+# probe/PluginAuditManagerHeadless.cpp here.
+#
+# Ownership: files under plugin/probe/ belong to the probe only; never link them into the GUI
+# application or libslic3r_gui. Sources listed outside that directory are shared production code
+# compiled unchanged by both.
+#
+# Residual cost: the probe still links libslic3r (the large core library) for Utils,
+# LifecycleEvents, the model/print types used by the GUI-free host bindings and libslic3r's own
+# transitive dependencies. It does not link libslic3r_gui, wx or the GUI-only host/plugin sources.
+# Developer/security-analysis tool, so it is off by default.
+if (ORCA_BUILD_PLUGIN_PERMISSION_PROBE)
+    add_executable(orca-plugin-probe
+        plugin/probe/PluginPermissionProbe.cpp
+        plugin/probe/PluginProbeCollector.hpp
+        plugin/probe/NanoSvgImplementation.cpp
+        plugin/PluginAuditManager.cpp
+        plugin/PluginAuditManagerInternal.hpp
+        plugin/PluginModule.cpp
+        plugin/PluginText.hpp
+        plugin/probe/PluginAuditManagerHeadless.cpp
+        plugin/PluginFsUtils.cpp
+        plugin/PluginLoader.cpp
+        plugin/PythonInterpreter.cpp
+        plugin/PythonPluginBridge.cpp
+        plugin/probe/PluginHostProbe.cpp
+        plugin/probe/PluginProbeConfig.cpp
+        plugin/host/PluginHostGeometry.cpp
+        plugin/host/PluginHostMesh.cpp
+        plugin/host/PluginHostModel.cpp
+        plugin/host/PluginHostSlicing.cpp
+        plugin/pluginTypes/printerAgent/PrinterAgentPluginCapability.cpp
+        plugin/pluginTypes/pages/PagesPluginCapability.cpp
+        plugin/pluginTypes/resourceTexture/ResourceTexturePluginCapability.cpp
+        plugin/pluginTypes/script/ScriptPluginCapability.cpp
+        plugin/pluginTypes/slicingPipeline/SlicingPipelinePluginCapability.cpp
+    )
+
+    target_compile_definitions(orca-plugin-probe PRIVATE ORCA_PLUGIN_PROBE_BUILD)
+
+    target_include_directories(orca-plugin-probe PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_CURRENT_BINARY_DIR}
+        ${CMAKE_SOURCE_DIR}/src
+        Utils
+    )
+
+    target_link_libraries(orca-plugin-probe PRIVATE
+        libslic3r
+        nanosvg
+        pybind11::embed
+    )
+
+    set_target_properties(orca-plugin-probe PROPERTIES
+        OUTPUT_NAME orca-plugin-probe
+        FOLDER "tools"
+    )
+endif()

src/slic3r/GUI/3DScene.cpp

@@ -700,7 +700,7 @@ void GLVolume::render_with_outline(const GUI::Size& cnv_size)
 }
 
 //BBS add render for simple case
-void GLVolume::simple_render(GLShaderProgram* shader, ModelObjectPtrs& model_objects, std::vector<ColorRGBA>& extruder_colors, bool ban_light, bool ban_color_volume)
+void GLVolume::simple_render(GLShaderProgram* shader, ModelObjectPtrs& model_objects, std::vector<ColorRGBA>& extruder_colors, bool ban_light)
 {
     if (this->is_left_handed())
         glFrontFace(GL_CW);
@@ -734,7 +734,7 @@ void GLVolume::simple_render(GLShaderProgram* shader, ModelObjectPtrs& model_obj
         }
     } while (0);
 
-    if (color_volume && !picking && !ban_color_volume) {
+    if (color_volume && !picking) {
         const bool brighten_selected = selected && !disabled && !force_native_color && !force_neutral_color;
 
         // when force_transparent, we need to keep the alpha

src/slic3r/GUI/3DScene.hpp

@@ -370,7 +370,7 @@ public:
     virtual void render_with_outline(const GUI::Size& cnv_size);
 
     //BBS: add simple render function for thumbnail
-    void simple_render(GLShaderProgram* shader, ModelObjectPtrs& model_objects, std::vector<ColorRGBA>& extruder_colors, bool ban_light =false, bool ban_color_volume = false);
+    void simple_render(GLShaderProgram* shader, ModelObjectPtrs& model_objects, std::vector<ColorRGBA>& extruder_colors, bool ban_light =false);
 
     void                set_bounding_boxes_as_dirty() {
         m_transformed_bounding_box.reset();

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2804,9 +2804,7 @@ void GLCanvas3D::_render_scene(const Camera& camera, const Size& cnv_size)
             _render_bed(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), show_axes);
         }
         m_frame_profiler.mark("bed");
-        // Exception: the painting gizmos hide the bed mesh on purpose and draw the plate instead,
-        // so there the plate list is the only bed reference in the scene.
-        if (show_bed || _is_below_plate_view_active()) //BBS: add outline logic
+        if (show_bed) //BBS: add outline logic
             _render_platelist(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), only_current, only_body, hover_id, true, show_grid);
         if (m_design_canvas && show_bed)
             // Design tab: replace the plate's corner-origin grid with the origin-centred CAD grid.
@@ -2818,7 +2816,6 @@ void GLCanvas3D::_render_scene(const Camera& camera, const Size& cnv_size)
         _render_shadows(camera.get_view_matrix(), camera.get_projection_matrix());
         m_frame_profiler.mark("shadows");
         _render_objects(GLVolumeCollection::ERenderType::Opaque, !m_gizmos.is_running());
-        _render_below_plate_volumes();
         m_frame_profiler.mark("objects");
         _render_sla_slices();
         _render_selection();
@@ -5635,10 +5632,14 @@ void GLCanvas3D::do_move(const std::string& snapshot_type, bool force_volume_mov
     // Fixes sinking/flying instances (snaps object to buildplate)
     for (const std::pair<int, int>& i : done) {
         ModelObject* mo = m_model->objects[i.first];
+            
+        if (!mo->auto_drop) {
+            continue;
+        }
 
         const double shift_z = mo->get_instance_min_z(i.second);
         //BBS: don't call translate if the z is zero
-        if (mo->auto_drop && (current_printer_technology() == ptSLA || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
+        if ((current_printer_technology() == ptSLA || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
             const Vec3d shift(0.0, 0.0, -shift_z);
             m_selection.translate(i.first, i.second, shift);
             mo->translate_instance(i.second, shift);
@@ -5762,10 +5763,14 @@ void GLCanvas3D::do_rotate(const std::string& snapshot_type)
         for (const std::pair<int, int> &i : done) {
             ModelObject *mo = m_model->objects[i.first];
 
+            if (!mo->auto_drop) {
+                continue;
+            }
+
             // BBS: don't call translate if the z is zero
             const double shift_z = mo->get_instance_min_z(i.second);
             // leave sinking instances as sinking
-            if (mo->auto_drop && (min_zs.find({i.first, i.second})->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
+            if ((min_zs.find({i.first, i.second})->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
                 const Vec3d shift(0.0, 0.0, -shift_z);
                 m_selection.translate(i.first, i.second, shift);
                 mo->translate_instance(i.second, shift);
@@ -5860,10 +5865,14 @@ void GLCanvas3D::do_scale(const std::string& snapshot_type)
     for (const std::pair<int, int>& i : done) {
         ModelObject* mo = m_model->objects[i.first];
 
+        if (!mo->auto_drop) {
+            continue;
+        }
+
         //BBS: don't call translate if the z is zero
         double shift_z = mo->get_instance_min_z(i.second);
         // leave sinking instances as sinking
-        if (mo->auto_drop && (min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
+        if ((min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
             Vec3d shift(0.0, 0.0, -shift_z);
             m_selection.translate(i.first, i.second, shift);
             mo->translate_instance(i.second, shift);
@@ -5976,10 +5985,14 @@ void GLCanvas3D::do_mirror(const std::string& snapshot_type)
     for (const std::pair<int, int>& i : done) {
         ModelObject* mo = m_model->objects[i.first];
 
+        if (!mo->auto_drop) {
+            continue;
+        }
+
         //BBS: don't call translate if the z is zero
         double shift_z = mo->get_instance_min_z(i.second);
         // leave sinking instances as sinking
-        if (mo->auto_drop && (min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
+        if ((min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD)&&(shift_z != 0.0f)) {
             Vec3d shift(0.0, 0.0, -shift_z);
             m_selection.translate(i.first, i.second, shift);
             mo->translate_instance(i.second, shift);
@@ -8827,84 +8840,6 @@ void GLCanvas3D::_render_bed(const Transform3d& view_matrix, const Transform3d&
     m_bed.render(*this, view_matrix, projection_matrix, bottom, scale_factor, show_axes);
 }
 
-bool GLCanvas3D::_is_below_plate_view_active() const
-{
-    return dynamic_cast<const GLGizmoPainterBase*>(m_gizmos.get_current()) != nullptr && m_gizmos.is_hiding_instances();
-}
-
-// The painting gizmo clips the selected object at the plate, so the part under the plate is not drawn.
-// This pass draws that part of the selected instance again at 50% opacity, depth writes off.
-void GLCanvas3D::_render_below_plate_volumes()
-{
-    if (!_is_below_plate_view_active() || m_volumes.empty())
-        return;
-
-    GLShaderProgram* shader = wxGetApp().get_shader("gouraud");
-    if (shader == nullptr)
-        return;
-
-    const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d& view_matrix = camera.get_view_matrix();
-    const Transform3d& proj_matrix = camera.get_projection_matrix();
-    const int object_idx = m_selection.get_object_idx();
-    const int instance_idx = m_selection.get_instance_idx();
-
-    // Depth test stays on so whatever is already in the depth buffer hides the ghost; depth writes
-    // are off and back faces are culled, so each pixel blends only the near surface once.
-    const GLboolean cull_face = ::glIsEnabled(GL_CULL_FACE);
-    glsafe(::glEnable(GL_DEPTH_TEST));
-    glsafe(::glEnable(GL_CULL_FACE));
-    glsafe(::glCullFace(GL_BACK));
-    glsafe(::glDepthMask(GL_FALSE));
-    glsafe(::glEnable(GL_BLEND));
-    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
-
-    shader->start_using();
-    // Keep z <= SINKING_Z_THRESHOLD, the complement of the clip the painting gizmo applies.
-    shader->set_uniform("z_range", std::array<float, 2>{ -FLT_MAX, float(SINKING_Z_THRESHOLD) });
-    shader->set_uniform("clipping_plane", m_volumes.get_clipping_plane());
-    shader->set_uniform("use_color_clip_plane", false);
-    shader->set_uniform("is_outline", false);
-    shader->set_uniform("slope.actived", false);
-    shader->set_uniform("print_volume.type", -1);
-    shader->set_uniform("extruder_printable_heights", std::array<float, 3>{ 0.0f, 0.0f, 0.0f });
-    shader->set_uniform("shadow_intensity", 0.0f);
-
-    // simple_render() needs these to reach the plain surface; with ban_color_volume it ignores both.
-    ModelObjectPtrs&       model_objects   = wxGetApp().model().objects;
-    std::vector<ColorRGBA> extruder_colors = wxGetApp().plater()->get_extruders_colors();
-
-    for (GLVolume* volume : m_volumes.volumes) {
-        // is_active cannot gate this pass: the color painter marks the whole instance inactive and
-        // draws it in its own gizmo pass. The instance and print-part checks below are what pick
-        // this ghost out of the scene.
-        if (volume->object_idx() != object_idx || volume->instance_idx() != instance_idx ||
-            volume->is_modifier || volume->is_wipe_tower || volume->volume_idx() < 0)
-            continue;
-
-        volume->set_render_color();
-        ColorRGBA color = volume->render_color;
-        color.a(0.5f);
-        volume->model.set_color(color);
-
-        const Transform3d model_matrix = volume->world_matrix();
-        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
-        shader->set_uniform("projection_matrix", proj_matrix);
-        shader->set_uniform("volume_world_matrix", model_matrix);
-        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
-        shader->set_uniform("view_normal_matrix", view_normal_matrix);
-        // Painted facets would send render() through the MMU segmentation sub-models, which carry
-        // their own opaque filament colours; the ghost draws the plain surface so the alpha holds.
-        volume->simple_render(shader, model_objects, extruder_colors, false, true);
-    }
-    shader->stop_using();
-
-    glsafe(::glDisable(GL_BLEND));
-    glsafe(::glDepthMask(GL_TRUE));
-    if (cull_face == GL_FALSE)
-        glsafe(::glDisable(GL_CULL_FACE));
-}
-
 bool GLCanvas3D::_hides_inactive_plates() const
 {
     return m_canvas_type == ECanvasType::CanvasView3D && !m_design_canvas && wxGetApp().focus_mode();
@@ -12033,10 +11968,9 @@ bool GLCanvas3D::is_bed_visible() const
     if (!m_main_toolbar.is_enabled())
         return true;
 
-    // The painting gizmos clip the selected instance at the plate (see InstancesHider), so the bed
-    // mesh would sit in front of the part below it. They draw the plate and its grid instead (see
-    // _render_scene) and the below-plate part as a translucent ghost.
-    return !_is_below_plate_view_active();
+    const auto type = m_gizmos.get_current_type();
+    return type != GLGizmosManager::FdmSupports && type != GLGizmosManager::Seam &&
+        type != GLGizmosManager::MmSegmentation && type != GLGizmosManager::FuzzySkin;
 }
 
 Vec3d GLCanvas3D::get_camera_pan_anchor(Camera& camera, ECameraNavigationType navigation_type,

src/slic3r/GUI/GLCanvas3D.hpp

@@ -1552,8 +1552,6 @@ private:
     void _render_imex_ghost_tooltip();
     void _render_section_view_caps();
     void _render_wireframe_overlay();
-    bool _is_below_plate_view_active() const;
-    void _render_below_plate_volumes();
     bool _is_xray_view_active() const;
     void _render_xray_volumes();
     //BBS: GUI refactor: add canvas size as parameters

src/slic3r/GUI/GUI_App.cpp

@@ -3002,8 +3002,7 @@ void GUI_App::init_plugin_gui_wiring()
     };
 
     // why: a newly loaded plugin only adds a selectable agent
-    // refresh the dropdown and leave the live agent alone, unless the selected preset was
-    // waiting for this agent: plugins load after the startup preset is applied
+    // refresh the dropdown and leave the live agent alone
     auto refresh_printer_agent_dropdown_after_load = [](const std::string&)
     {
         if (!wxTheApp)
@@ -3015,11 +3014,8 @@ void GUI_App::init_plugin_gui_wiring()
 
         app->CallAfter([app]
         {
-            if (app->is_closing())
-                return;
-
-            app->switch_printer_agent_if_pending();
-            app->refresh_printer_agent_dropdown();
+            if (!app->is_closing())
+                app->refresh_printer_agent_dropdown();
         });
     };
 
@@ -4307,21 +4303,6 @@ void GUI_App::switch_printer_agent()
     select_machine(effective_agent_id);
 }
 
-void GUI_App::switch_printer_agent_if_pending()
-{
-    if (!m_agent || !preset_bundle)
-        return;
-
-    const std::string wanted_agent_id = resolve_printer_agent_id(preset_bundle->printers.get_edited_preset().config.opt_string("printer_agent"));
-    const auto        live_agent      = m_agent->get_printer_agent();
-    if (live_agent && live_agent->get_agent_info().id == wanted_agent_id)
-        return;
-    if (!NetworkAgentFactory::get_printer_agent_info(wanted_agent_id))
-        return;
-
-    switch_printer_agent();
-}
-
 void GUI_App::select_machine(const std::string& agent_id)
 {
     // Skip for BBL agent for now - uses its own device discovery/selection

src/slic3r/GUI/GUI_App.hpp

@@ -412,9 +412,6 @@ public:
 
     // Reconcile the live printer agent with the stored preset selection.
     void switch_printer_agent();
-    // Install the selected preset's agent if it is registered but not live, e.g. when its plugin
-    // finishes loading after the startup preset was applied. Otherwise leave the live agent alone.
-    void switch_printer_agent_if_pending();
 
     std::string resolve_printer_agent_id(const std::string& stored_id) const;
     // ORCA TODO: in the future, bbl presets should specify "bbl" printer agent id

src/slic3r/GUI/GUI_ObjectList.cpp

@@ -1618,9 +1618,7 @@ void ObjectList::list_manipulation(const wxPoint& mouse_pos, bool evt_context_me
             get_selected_item_indexes(obj_idx, vol_idx, item);
             if (obj_idx != -1) {
                 Plater::TakeSnapshot snapshot(plater, _u8L("Shift objects to bed"));
-                // Shift on request also when auto drop is off, which ensure_on_bed() skips.
-                ModelObject* mo = (*m_objects)[obj_idx];
-                mo->translate_instances(-mo->min_z() * Vec3d::UnitZ());
+                (*m_objects)[obj_idx]->ensure_on_bed();
                 cnv->reload_scene(true, true);
                 update_info_items(obj_idx);
                 notify_instance_updated(obj_idx);
@@ -6736,9 +6734,7 @@ void ObjectList::OnEditingStarted(wxDataViewEvent &event)
         Plater::TakeSnapshot snapshot(plater, _u8L("Shift objects to bed"));
         int obj_idx, vol_idx;
         get_selected_item_indexes(obj_idx, vol_idx, item);
-        // Shift on request also when auto drop is off, which ensure_on_bed() skips.
-        ModelObject* mo = (*m_objects)[obj_idx];
-        mo->translate_instances(-mo->min_z() * Vec3d::UnitZ());
+        (*m_objects)[obj_idx]->ensure_on_bed();
         cnv->reload_scene(true, true);
         update_info_items(obj_idx);
         notify_instance_updated(obj_idx);

src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp

@@ -7,6 +7,7 @@
 
 
 #include <cstddef>
+#include <glad/gl.h>
 #include "slic3r/GUI/Selection.hpp"
 #include <limits>
 #include "libslic3r/Model.hpp"
@@ -173,9 +174,6 @@ void InstancesHider::on_update()
                 m_clippers.emplace_back(new MeshClipper);
                 m_clippers.back()->set_plane(ClippingPlane(-Vec3d::UnitZ(), z_min));
                 m_clippers.back()->set_mesh(mesh->its);
-                // Outline only: a filled cap would read as a surface the object does not have, and it
-                // covers the model below it. 0.4 mm matches the cut gizmo's contour width.
-                m_clippers.back()->set_behaviour(false, 0.4);
             }
             m_old_meshes = meshes;
         }
@@ -216,7 +214,10 @@ void InstancesHider::render_cut() const
         else
             clipper->set_limiting_plane(ClippingPlane::ClipsNothing());
 
-        clipper->render_contour(mv->is_model_part() ? ColorRGBA(0.8f, 0.3f, 0.0f, 1.0f) : color_from_model_volume(*mv));
+        glsafe(::glPushAttrib(GL_DEPTH_TEST));
+        glsafe(::glDisable(GL_DEPTH_TEST));
+        clipper->render_cut(mv->is_model_part() ? ColorRGBA(0.8f, 0.3f, 0.0f, 1.0f) : color_from_model_volume(*mv));
+        glsafe(::glPopAttrib());
 
         ++clipper_id;
     }

src/slic3r/GUI/Plater.cpp

@@ -2865,8 +2865,7 @@ Sidebar::Sidebar(Plater *parent)
 
         // add printer title
         scrolled_sizer->Add(p->m_panel_printer_title, 0, wxEXPAND | wxALL, 0);
-        // ORCA Bind with LEFT_DOWN, since closing a dialog over the title bar can send it a stray LEFT_UP
-        auto toggle_printer_section = ([this] (wxMouseEvent & e) {
+        p->m_panel_printer_title->Bind(wxEVT_LEFT_UP, [this] (auto & e) {
             if (!p || !p->combo_printer || !p->m_text_printer_settings || !p->m_panel_printer_content || !m_scrolled_sizer)
                 return;
             // ORCA Show printer name on title when its folded to inform user without expanding it again
@@ -2877,8 +2876,6 @@ Sidebar::Sidebar(Plater *parent)
             p->m_panel_printer_separator->Show(isShown);
             m_scrolled_sizer->Layout();
         });
-        p->m_panel_printer_title->Bind(wxEVT_LEFT_DOWN  , toggle_printer_section);
-        p->m_panel_printer_title->Bind(wxEVT_LEFT_DCLICK, toggle_printer_section);
         // ORCA add bottom border for seperation wile sections folded
         p->m_panel_printer_separator = new wxPanel(p->scrolled, wxID_ANY, wxDefaultPosition, wxSize(-1, FromDIP(2))); // ORCA staticline class not works without string
         p->m_panel_printer_separator->SetBackgroundColour("#FFFFFF");
@@ -3251,8 +3248,7 @@ Sidebar::Sidebar(Plater *parent)
     p->m_panel_filament_title = new StaticBox(p->scrolled, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxBORDER_NONE);
     p->m_panel_filament_title->SetBackgroundColor(title_bg);
     p->m_panel_filament_title->SetBackgroundColor2(0xF1F1F1);
-    // ORCA Bind with LEFT_DOWN, since closing a dialog over the title bar can send it a stray LEFT_UP
-    auto toggle_filament_section = ([this](wxMouseEvent &e) {
+    p->m_panel_filament_title->Bind(wxEVT_LEFT_UP, [this](wxMouseEvent &e) {
         if (!p || !p->m_filament_area_wrapper || !m_scrolled_sizer || !p->m_bpButton_set_filament || !p->m_purge_mode_btn || !p->m_flushing_volume_btn || !p->m_bpButton_add_filament || !ams_btn)
             return;
         // ORCA exclude area of del button from titlebar collapse/expand feature to fix undesired collapse when user spams del filament button
@@ -3271,8 +3267,6 @@ Sidebar::Sidebar(Plater *parent)
 
         CallAfter([this]{update_filaments_counter(true);}); // call after all UI processing done
     });
-    p->m_panel_filament_title->Bind(wxEVT_LEFT_DOWN  , toggle_filament_section);
-    p->m_panel_filament_title->Bind(wxEVT_LEFT_DCLICK, toggle_filament_section);
 
     wxBoxSizer* bSizer39;
     bSizer39 = new wxBoxSizer( wxHORIZONTAL );

src/slic3r/GUI/Selection.cpp

@@ -579,12 +579,29 @@ void Selection::drop()
 
     wxGetApp().plater()->take_snapshot(L("Move object"));
 
-    // do_move() writes every volume back to the model and refreshes the view.
-    setup_cache();
-    TransformationType transformation_type;
-    transformation_type.set_relative();
-    translate(Vec3d(0, 0, -min_z), transformation_type);
-    wxGetApp().plater()->get_view3D_canvas3D()->do_move("");
+    this->move_to_center(Vec3d(0, 0, -min_z));
+
+    for (unsigned int i : m_list) {
+        GLVolume&    volume = *(*m_volumes)[i];
+        // Skip the wipe tower: its synthetic id (>= 1000) is not an index into m_model->objects.
+        if (volume.object_idx() >= 1000)
+            continue;
+        ModelObject* model_object = m_model->objects[volume.object_idx()];
+
+        if (model_object != nullptr) {
+            if (m_mode == Volume) {
+                ModelVolume* cur_mv = model_object->volumes[volume.volume_idx()];
+                cur_mv->set_transformation(volume.get_volume_transformation());
+            } else if (m_mode == Instance) {
+                model_object->instances[volume.instance_idx()]->set_transformation(volume.get_instance_transformation());
+            }
+
+            model_object->invalidate_bounding_box();
+            this->notify_instance_update(volume.object_idx(), volume.instance_idx());
+        }
+    }
+
+    wxGetApp().plater()->get_view3D_canvas3D()->post_event(SimpleEvent(EVT_GLCANVAS_INSTANCE_MOVED));
 }
 
 void Selection::center_plate(const int plate_idx) {

src/slic3r/GUI/Widgets/Label.cpp

@@ -310,7 +310,7 @@ Label::Label(wxWindow *parent, wxFont const &font, wxString const &text, long st
     SetBackgroundColour(StaticBox::GetParentBackgroundColor(parent));
     SetForegroundColour("#262E30");
     if (style & LB_PROPAGATE_MOUSE_EVENT) {
-        for (auto evt : { wxEVT_LEFT_UP, wxEVT_LEFT_DOWN, wxEVT_LEFT_DCLICK}) // ORCA also propagete LEFT_DCLICK event that used on sidebar titlebars
+        for (auto evt : { wxEVT_LEFT_UP, wxEVT_LEFT_DOWN })
             Bind(evt, [this] (auto & e) { GetParent()->GetEventHandler()->ProcessEventLocally(e); });
     };
     if (style & LB_AUTO_WRAP) {

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -73,14 +73,7 @@ bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode
     // 3. Fetch slot info and build AmsTrayData directly
     std::vector<AmsTrayData> trays;
     int                      box_count = 0;
-    bool                     slots_ok  = false;
-    try {
-        slots_ok = fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error);
-    } catch (const nlohmann::json::exception& e) {
-        // A slot value of an unexpected type fails the sync instead of escaping to the UI
-        error = e.what();
-    }
-    if (!slots_ok) {
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
         BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
         return false;
     }
@@ -98,7 +91,7 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables&multi_color_controller=box");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -171,12 +164,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         AmsTrayData tray;
         tray.slot_index = i;
 
-        // Read slot variables. Newer firmware stores a hex color list and a material id instead of dictionary
-        // indexes, and only in the slots it has rewritten, so each slot is checked for both forms.
-        const auto color_value    = variables.value("color_slot" + std::to_string(i), nlohmann::json(1));
-        const auto filament_value = variables.value("filament_slot" + std::to_string(i), nlohmann::json(1));
-        const int color_index     = color_value.is_number() ? color_value.get<int>() : 0;
-        const int filament_type   = filament_value.is_number() ? filament_value.get<int>() : 0;
+        // Read slot variables
+        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
         const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
@@ -197,13 +187,6 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
             if (filament_it != dict.filaments.end()) {
                 filament_name = filament_it->second;
             }
-            if (filament_value.is_string()) {
-                const nlohmann::json::json_pointer decoded_type("/multi_color_controller/box/box" + std::to_string(i / 4) +
-                                                                "_filament_info_" + std::to_string(i % 4) + "_filament_type");
-                if (status.contains(decoded_type) && status[decoded_type].is_string()) {
-                    filament_name = status[decoded_type].get<std::string>();
-                }
-            }
             tray.tray_type = normalize_filament_type(filament_name);
 
             // Try Qidi-specific setting ID first; fall back to visible preset by type
@@ -219,9 +202,7 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
 
             // Look up color from dictionary
             auto color_it = dict.colors.find(color_index);
-            if (color_value.is_array() && !color_value.empty() && color_value[0].is_string()) {
-                tray.tray_color = color_value[0].get<std::string>();
-            } else if (color_it != dict.colors.end()) {
+            if (color_it != dict.colors.end()) {
                 tray.tray_color = color_it->second;
             } else {
                 tray.tray_color = "FFFFFFFF";

src/slic3r/Utils/SimplyPrint.cpp

@@ -350,13 +350,9 @@ bool SimplyPrint::do_temp_upload(const boost::filesystem::path& file_path,
             if (should_open_in_external_browser()) {
                 wxLaunchDefaultBrowser(url);
             } else {
-                // The tab switch queues a reload of the printer's home page, so switch synchronously
-                // first and queue the import page after it.
-                GUI::wxGetApp().CallAfter([url = wxString::FromUTF8(url)] {
-                    const auto mainframe = GUI::wxGetApp().mainframe;
-                    mainframe->select_tab(TAB_ID_MONITOR);
-                    mainframe->load_printer_url(url);
-                });
+                const auto mainframe = GUI::wxGetApp().mainframe;
+                mainframe->request_select_tab(TAB_ID_MONITOR);
+                mainframe->load_printer_url(url);
             }
 
             return true;

src/slic3r/plugin/PluginAuditManager.cpp

@@ -1,4 +1,5 @@
 #include "PluginAuditManager.hpp"
+#include "PluginAuditManagerInternal.hpp"
 
 #include "../Utils/OrcaCloudServiceAgent.hpp"
 #include "libslic3r/Utils.hpp"
@@ -15,25 +16,12 @@
 #include <cctype>
 #include <cstddef>
 #include <cstdlib>
-#include <future>
 #include <mutex>
-#include <memory>
-#include <slic3r/GUI/BindDialog.hpp>
-#include <slic3r/GUI/GUI_App.hpp>
-#include <slic3r/plugin/PluginFsUtils.hpp>
-#include <slic3r/plugin/PluginManager.hpp>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <wx/app.h>
-#include <wx/event.h>
-#include <wx/msgdlg.h>
-#include <wx/string.h>
-#include <wx/thread.h>
-#include "slic3r/GUI/I18N.hpp"
-#include "slic3r/plugin/PluginDescriptor.hpp"
 #include <Python.h>
 
 namespace Slic3r {
@@ -161,8 +149,10 @@ static bool is_fs_category(AuditEventCategory category)
     }
 }
 
+namespace plugin_audit {
+
 // The category's name in a saved event grant, e.g. "FsRead" in "FsRead:open".
-static const char* category_name(AuditEventCategory category)
+const char* category_name(AuditEventCategory category)
 {
     switch (category) {
     case AuditEventCategory::FsRead:         return "FsRead";
@@ -179,6 +169,29 @@ static const char* category_name(AuditEventCategory category)
     return "None";
 }
 
+int report_denied(PluginAuditManager&       mgr,
+                  const std::string&        event_name,
+                  const AuditDecision&      decision,
+                  const std::string&        target)
+{
+    AuditViolation violation;
+    violation.plugin_key = mgr.current_plugin();
+    violation.event_name = event_name;
+    violation.reason     = decision.reason;
+    mgr.report_violation(violation);
+
+    std::string message = "Plugin attempted audited operation \"" + event_name + "\" without permission";
+    if (!decision.reason.empty())
+        message += ": " + decision.reason;
+    if (!target.empty())
+        message += ": " + target;
+
+    PyErr_SetString(PyExc_PermissionError, message.c_str());
+    return -1;
+}
+
+} // namespace plugin_audit
+
 // ---------------------------------------------------------------------------
 // Path safety
 // ---------------------------------------------------------------------------
@@ -247,6 +260,7 @@ bool is_inside_allowed_root(const boost::filesystem::path& candidate, const boos
 
 thread_local std::string PluginAuditManager::m_current_plugin_key = "";
 thread_local std::string PluginAuditManager::m_current_capability_name = "";
+thread_local std::string PluginAuditManager::m_current_audit_phase = "";
 thread_local std::vector<AllowedRoot> PluginAuditManager::m_scoped_allowed_roots;
 thread_local std::vector<PyObject*> PluginAuditManager::m_root_frames;
 thread_local int PluginAuditManager::m_releasing_frames = 0;
@@ -316,6 +330,76 @@ std::string PluginAuditManager::current_capability() const { return m_current_ca
 
 void PluginAuditManager::clear_current_capability() { m_current_capability_name.clear(); }
 
+void PluginAuditManager::set_current_audit_phase(const std::string& phase) { m_current_audit_phase = phase; }
+
+const std::string& PluginAuditManager::current_audit_phase() const { return m_current_audit_phase; }
+
+void PluginAuditManager::clear_current_audit_phase() { m_current_audit_phase.clear(); }
+
+void PluginAuditManager::set_observation_observer(AuditObserver observer)
+{
+    std::lock_guard<std::mutex> lock(m_observer_mutex);
+    m_observation_observer = std::move(observer);
+}
+
+void PluginAuditManager::clear_observation_observer()
+{
+    std::lock_guard<std::mutex> lock(m_observer_mutex);
+    m_observation_observer = nullptr;
+}
+
+bool PluginAuditManager::observation_mode() const
+{
+    std::lock_guard<std::mutex> lock(m_observer_mutex);
+    return static_cast<bool>(m_observation_observer);
+}
+
+// The audit hook holds the GIL here. Copy the observer out before invoking it so a callback that
+// reads the manager cannot deadlock on m_observer_mutex.
+bool PluginAuditManager::record_observation(const std::string&              event_name,
+                                            const std::string&              category,
+                                            const std::vector<std::string>& targets)
+{
+    AuditObserver observer;
+    {
+        std::lock_guard<std::mutex> lock(m_observer_mutex);
+        observer = m_observation_observer;
+    }
+    if (!observer)
+        return false;
+
+    // The observer is called from a CPython C callback; a C++ exception must not unwind through
+    // the audit hook. The probe's collector only allocates, so a throw here is a lost observation,
+    // not a reason to abort the audited operation.
+    try {
+        AuditObservation observation;
+        observation.plugin_key = m_current_plugin_key;
+        observation.capability = m_current_capability_name;
+        observation.phase      = m_current_audit_phase;
+        observation.event_name = event_name;
+        observation.category   = category;
+        observation.targets    = targets;
+        // Probe mode never denies: the hook returns 0 after recording. A later failure of the
+        // surrounding Python operation is reported by the probe's callback/load result, not here.
+        observation.continued = true;
+        observer(observation);
+    } catch (...) {
+    }
+    return true;
+}
+
+ScopedPluginAuditPhase::ScopedPluginAuditPhase(std::string phase)
+    : m_phase(std::move(phase))
+    , m_previous_phase(PluginAuditManager::instance().current_audit_phase())
+{
+    PluginAuditManager::instance().set_current_audit_phase(m_phase);
+}
+
+ScopedPluginAuditPhase::~ScopedPluginAuditPhase()
+{
+    PluginAuditManager::instance().set_current_audit_phase(m_previous_phase);
+}
+
 void PluginAuditManager::add_global_allowed_root(const boost::filesystem::path& root, bool allow_write)
 {
     if (root.empty())
@@ -500,12 +584,6 @@ AuditDecision PluginAuditManager::check_path_access(const boost::filesystem::pat
             candidate = absolute_candidate;
     }
 
-    // Importing Python modules reads their source and may inspect package directories. These
-    // reads are normal interpreter work, not plugin data access; keep the exemption read-only
-    // and exclude third-party packages from the stdlib roots.
-    if (!is_write && is_stdlib_path(candidate))
-        return {true, ""};
-
     // A root that doesn't allow writes only matches a read-shaped request; a write/create/
     // delete-shaped one falls through to "outside allowed root" for that root even though the
     // path is physically inside it.
@@ -542,73 +620,14 @@ bool PluginAuditManager::request_filesystem_read_permissions(const std::string&
     if (plugin_key.empty() || paths.empty())
         return true;
 
-    PluginDescriptor descriptor;
-    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
-        return false;
-
-    PluginInstallState state;
-    read_install_state(boost::filesystem::path(descriptor.plugin_root), state);
-
-    std::vector<std::string> missing;
-    for (const std::string& path : paths) {
-        if (std::find(state.permissions.fs_read.begin(), state.permissions.fs_read.end(), path) == state.permissions.fs_read.end())
-            missing.push_back(path);
-    }
-    if (missing.empty())
+    // Probe mode records the declaration and proceeds. It must not consult the install state,
+    // open the permission dialog, or persist a grant.
+    if (observation_mode()) {
+        record_observation("orca.request_permissions", "FsRead", paths);
         return true;
-
-    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
-        return false;
-
-    auto show_dialog = [&descriptor, &missing]() {
-        wxString requested_paths;
-        for (const std::string& path : missing)
-            requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
-
-        wxMessageDialog dialog(
-            nullptr,
-            wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
-                             wxString::FromUTF8(descriptor.name.c_str()), requested_paths),
-            _L("Plugin permissions"),
-            wxYES_NO | wxICON_WARNING);
-        return dialog.ShowModal() == wxID_YES;
-    };
-
-    bool granted = false;
-    if (wxIsMainThread()) {
-        granted = show_dialog();
-    } else {
-        auto result = std::make_shared<std::promise<bool>>();
-        auto future = result->get_future();
-        GUI::wxGetApp().CallAfter([result, descriptor_name = descriptor.name, missing]() {
-            wxString requested_paths;
-            for (const std::string& path : missing)
-                requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
-
-            wxMessageDialog dialog(
-                nullptr,
-                wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
-                                 wxString::FromUTF8(descriptor_name.c_str()), requested_paths),
-                _L("Plugin permissions"),
-                wxYES_NO | wxICON_WARNING);
-            result->set_value(dialog.ShowModal() == wxID_YES);
-        });
-        granted = future.get();
     }
 
-    if (!granted)
-        return false;
-
-    if (state.plugin_name.empty()) {
-        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
-        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
-        state.plugin_name       = descriptor.name;
-        state.cloud_uuid        = descriptor.cloud_uuid();
-        state.enabled            = true;
-    }
-
-    state.permissions.fs_read.insert(state.permissions.fs_read.end(), missing.begin(), missing.end());
-    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
+    return plugin_audit::request_filesystem_read_permissions(plugin_key, paths);
 }
 
 void PluginAuditManager::report_violation(const AuditViolation& violation)
@@ -870,265 +889,18 @@ std::vector<std::string> audit_targets(const std::string& event_name, AuditEvent
     return targets;
 }
 
-// The saved list that grants an event: its category's target list, or the event-grant list for
-// an event with no target. Kept apart, so that no grant doubles as a target of the same name (an
-// os.fork grant is not an os.exec of a command named "os.fork").
-std::vector<std::string>* permission_list_for(AuditEventCategory category, bool by_event, PluginPermissions& permissions)
-{
-    if (by_event)
-        return &permissions.events;
-
-    switch (category) {
-    case AuditEventCategory::FsRead:        return &permissions.fs_read;
-    case AuditEventCategory::FsReadWrite:   return &permissions.fs_readwrite;
-    case AuditEventCategory::Http:          return &permissions.network_http;
-    case AuditEventCategory::Socket:        return &permissions.network_socket;
-    case AuditEventCategory::ProcessCreate: return &permissions.process;
-    case AuditEventCategory::Threading:     return &permissions.threading;
-    case AuditEventCategory::ProcessReplace: return &permissions.process;
-    default:                                return nullptr;
-    }
-}
-
-// An event with no target is granted by its effective category and name, e.g. "FsRead:open"
-// for a read of a file descriptor, which does not grant a write of one ("FsReadWrite:open").
-std::string event_grant_key(AuditEventCategory category, const std::string& event_name)
-{
-    return std::string(category_name(category)) + ":" + event_name;
-}
-
-bool has_permission(const std::vector<std::string>& granted, const std::string& target)
-{
-    return std::find(granted.begin(), granted.end(), target) != granted.end();
-}
-
-bool persist_permission(const std::string&        plugin_key,
-                        PluginInstallState&       state,
-                        std::vector<std::string>& permission_list,
-                        const std::string&        target)
-{
-    PluginDescriptor descriptor;
-    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
-        return false;
-
-    // A sandbox plugin may not have a sidecar yet.  Seed the small amount of install metadata
-    // needed by the writer so clicking Yes still creates the JSON file.
-    if (state.plugin_name.empty()) {
-        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
-        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
-        state.plugin_name       = descriptor.name;
-        state.cloud_uuid        = descriptor.cloud_uuid();
-        state.enabled            = true;
-    }
-
-    if (!has_permission(permission_list, target))
-        permission_list.push_back(target);
-    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
-}
-
-int report_denied(PluginAuditManager&            mgr,
-                  const std::string&             event_name,
-                  const AuditDecision&           decision,
-                  const std::string&             target = {})
-{
-    AuditViolation violation;
-    violation.plugin_key = mgr.current_plugin();
-    violation.event_name = event_name;
-    violation.reason     = decision.reason;
-    mgr.report_violation(violation);
-
-    std::string message = "Plugin attempted audited operation \"" + event_name + "\" without permission";
-    if (!decision.reason.empty())
-        message += ": " + decision.reason;
-    if (!target.empty())
-        message += ": " + target;
-
-    PyErr_SetString(PyExc_PermissionError, message.c_str());
-    return -1;
-}
-
-wxString audit_message(AuditEventCategory category, const wxString& plugin_name, const wxString& event_name,
-                       const wxString& target_list, size_t target_count)
-{
-    if (target_list.IsEmpty())
-        return wxString::Format(
-            _L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\".\n\n"
-                "This operation does not expose a target the audit hook can display."),
-            plugin_name, event_name);
-
-    switch (category) {
-    case AuditEventCategory::FsRead:
-        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read the following file:\n%s",
-                                          "Plugin \"%s\" is requesting to read the following files:\n%s", target_count),
-                                plugin_name, target_list);
-    case AuditEventCategory::FsReadWrite:
-        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read/write the following file:\n%s",
-                                          "Plugin \"%s\" is requesting to read/write the following files:\n%s", target_count),
-                                plugin_name, target_list);
-    case AuditEventCategory::FsCreate:
-        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to create the following file:\n%s",
-                                          "Plugin \"%s\" is requesting to create the following files:\n%s", target_count),
-                                plugin_name, target_list);
-    case AuditEventCategory::FsDelete:
-        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to delete the following file:\n%s",
-                                          "Plugin \"%s\" is requesting to delete the following files:\n%s", target_count),
-                                plugin_name, target_list);
-    case AuditEventCategory::Http:
-        return wxString::Format(_L("Plugin \"%s\" is requesting to make an HTTP request to:\n%s"), plugin_name, target_list);
-    case AuditEventCategory::Socket:
-        return wxString::Format(_L("Plugin \"%s\" is requesting to open a network connection to:\n%s"), plugin_name, target_list);
-    case AuditEventCategory::ProcessCreate:
-        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to run the following command:\n%s",
-                                          "Plugin \"%s\" is requesting to run the following commands:\n%s", target_count),
-                                plugin_name, target_list);
-    case AuditEventCategory::Threading:
-        return wxString::Format(_L("Plugin \"%s\" is requesting permission to create a thread."), plugin_name);
-    case AuditEventCategory::ProcessReplace:
-        return wxString::Format(_L("Plugin \"%s\" is requesting to replace the running application with:\n%s"), plugin_name, target_list);
-    default:
-        return wxString::Format(_L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\"."), plugin_name, event_name);
-    }
-}
-
-// Builds and shows the modal permission prompt. Must run on the GUI thread.
-bool prompt_for_targets(AuditEventCategory category, const std::string& plugin_name, const std::string& event_name,
-                        const std::vector<std::string>& unresolved)
-{
-    wxString target_list;
-    for (const auto& target : unresolved)
-        target_list += wxString::FromUTF8(target.c_str()) + "\n";
-
-    wxMessageDialog dialog(nullptr,
-                           audit_message(category, wxString::FromUTF8(plugin_name.c_str()),
-                                        wxString::FromUTF8(event_name.c_str()), target_list, unresolved.size()),
-                           _L("Plugin permission request"), wxYES_NO | wxICON_WARNING);
-    return dialog.ShowModal() == wxID_YES;
-}
-
-// Records a grant in the plugin's sidecar so it is not asked again. Reads the install state
-// freshly because the async prompt outlives the caller's stack copy of it.
-void persist_grant(const std::string& plugin_key, AuditEventCategory category, bool by_event, const std::vector<std::string>& keys)
-{
-    PluginInstallState state;
-    if (!PluginManager::instance().get_install_state(plugin_key, state))
-        return;
-
-    std::vector<std::string>* permission_list = permission_list_for(category, by_event, state.permissions);
-    if (!permission_list)
-        return;
-
-    for (const auto& key : keys)
-        persist_permission(plugin_key, state, *permission_list, key);
-}
-
-static PluginAuditManager::PermissionPrompt s_permission_prompt_for_testing;
-
-static const char* audit_category_name(AuditEventCategory category)
-{
-    switch (category) {
-    case AuditEventCategory::FsRead: return "FsRead";
-    case AuditEventCategory::FsReadWrite: return "FsReadWrite";
-    case AuditEventCategory::FsCreate: return "FsCreate";
-    case AuditEventCategory::FsDelete: return "FsDelete";
-    case AuditEventCategory::Http: return "Http";
-    case AuditEventCategory::Socket: return "Socket";
-    case AuditEventCategory::ProcessCreate: return "ProcessCreate";
-    case AuditEventCategory::ProcessReplace: return "ProcessReplace";
-    case AuditEventCategory::Threading: return "Threading";
-    default: return "None";
-    }
-}
-
-// Asks the user to grant an audited event, returning true when they approve an inline prompt.
-// `keys` are what a Yes saves: the unresolved targets, or the event-grant key when the event has
-// no target (by_event), which the prompt does not show as a target.
-//
-// An audited event can fire on a thread the UI thread may itself be blocked waiting on: the
-// SlicingPipeline hook runs on the slicing worker thread (see PluginHooks.cpp), and
-// BackgroundSlicingProcess::stop()/stop_internal() park the UI thread until that worker stops.
-// Blocking the worker on a marshaled modal -- which is safe for the plugin-load worker that
-// request_filesystem_read_permissions runs on -- would therefore deadlock the application (the
-// invariant PluginHostUi.cpp documents for slicing-hook UI calls). Off the main thread the prompt
-// is therefore posted asynchronously and the current event denied (fail closed, like an unanswered
-// prompt); the grant is persisted once the user accepts, so a later attempt succeeds without
-// re-prompting.
-bool request_permission(AuditEventCategory category, const std::string& plugin_key, const std::string& plugin_name,
-                        const std::string& event_name, bool by_event, const std::vector<std::string>& keys)
-{
-    const std::vector<std::string> shown = by_event ? std::vector<std::string>{} : keys;
-    std::string targets_text = by_event ? "<none>" : "";
-    for (const auto& target : shown) {
-        if (!targets_text.empty())
-            targets_text += ", ";
-        targets_text += target;
-    }
-
-    BOOST_LOG_TRIVIAL(info) << "[AUDIT PROMPT] plugin=" << plugin_key << " event=" << event_name
-                            << " category=" << audit_category_name(category) << " targets=[" << targets_text << "]"
-                            << (by_event && !keys.empty() ? " grant=" + keys.front() : std::string{});
-
-    if (s_permission_prompt_for_testing)
-        return s_permission_prompt_for_testing(event_name, shown);
-
-    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
-        return false;
-
-    if (wxIsMainThread())
-        return prompt_for_targets(category, plugin_name, event_name, shown);
-
-    GUI::wxGetApp().CallAfter([category, plugin_key, plugin_name, event_name, by_event, keys, shown]() {
-        if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
-            return;
-        if (prompt_for_targets(category, plugin_name, event_name, shown))
-            persist_grant(plugin_key, category, by_event, keys);
-    });
-    return false;
-}
-
-// Decides an event that no allowed root or running operation covers: a saved grant allows it,
-// otherwise the user is asked and a Yes is saved.
-int decide_audited_event(PluginAuditManager&             mgr,
-                         PluginInstallState&              state,
-                         const std::string&                plugin_key,
-                         const std::string&                plugin_name,
-                         const std::string&                event_name,
-                         AuditEventCategory                category,
-                         const std::vector<std::string>&   targets)
-{
-    const bool                     by_event = targets.empty();
-    const std::vector<std::string> keys     = by_event ? std::vector<std::string>{event_grant_key(category, event_name)} : targets;
-    std::vector<std::string>*      permission_list = permission_list_for(category, by_event, state.permissions);
-
-    std::vector<std::string> unresolved = keys;
-    if (permission_list) {
-        unresolved.clear();
-        for (const auto& key : keys)
-            if (!has_permission(*permission_list, key))
-                unresolved.push_back(key);
-        if (unresolved.empty())
-            return 0;
-    }
-
-    // Letting a root frame go runs finalizers inside a scope destructor or another event's hook,
-    // where no dialog may open: what they do must already be granted.
-    if (mgr.releasing_frames())
-        return report_denied(mgr, event_name, {false, "audit permission required"});
-
-    if (!request_permission(category, plugin_key, plugin_name, event_name, by_event, unresolved))
-        return report_denied(mgr, event_name, {false, "audit permission required"});
-
-    if (permission_list)
-        for (const auto& key : unresolved)
-            persist_permission(plugin_key, state, *permission_list, key);
-    return 0;
-}
-
 // Judges an audited event raised while a plugin context is active.
 int audit_plugin_event(PluginAuditManager& mgr, const std::string& event_name, AuditEventCategory event_type, PyObject* args)
 {
     const bool                      fs_category = is_fs_category(event_type);
     const std::vector<std::string>  targets      = audit_targets(event_name, event_type, args);
 
+    // Probe mode: report the classified event and let it through. Deliberately before the deny
+    // registry and allowed-root checks, so the report covers operations that production would
+    // block as well as those it would allow. No grant is read or written.
+    if (mgr.record_observation(event_name, plugin_audit::category_name(event_type), targets))
+        return 0;
+
     // A denied path (secrets, certificates, config files -- see is_denied_path) is an
     // unconditional block: checked before the running-operation check below, so no granted
     // operation can launder access to one, and before the allowed-root shortcut further down,
@@ -1137,7 +909,7 @@ int audit_plugin_event(PluginAuditManager& mgr, const std::string& event_name, A
     if (fs_category) {
         for (const auto& target : targets) {
             if (mgr.is_denied_path(boost::filesystem::path(target)))
-                return report_denied(mgr, event_name, {false, "denied path"}, target);
+                return plugin_audit::report_denied(mgr, event_name, {false, "denied path"}, target);
         }
     }
 
@@ -1162,15 +934,7 @@ int audit_plugin_event(PluginAuditManager& mgr, const std::string& event_name, A
             return 0;
     }
 
-    PluginInstallState state;
-    const bool have_install_state = PluginManager::instance().get_install_state(mgr.current_plugin(), state);
-    if (!have_install_state) {
-        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " Failed to get install state for " << mgr.current_plugin();
-    }
-
-    const std::string plugin_name = state.plugin_name.empty() ? mgr.current_plugin() : state.plugin_name;
-
-    const int result = decide_audited_event(mgr, state, mgr.current_plugin(), plugin_name, event_name, event_type, targets);
+    const int result = plugin_audit::decide_event(mgr, event_name, event_type, targets);
 
     // A granted operation covers its nested events while it runs. A targetless grant names no
     // operation, so it covers nothing else.
@@ -1232,18 +996,6 @@ bool PluginAuditManager::is_stdlib_file(const std::string& filename)
     return it->second;
 }
 
-bool PluginAuditManager::is_stdlib_path(const boost::filesystem::path& path)
-{
-    if (path.empty())
-        return false;
-
-    const auto inside_any = [&path](const std::vector<boost::filesystem::path>& dirs) {
-        return std::any_of(dirs.begin(), dirs.end(),
-                           [&path](const boost::filesystem::path& dir) { return is_inside_allowed_root(path, dir); });
-    };
-    return inside_any(PluginAuditDetail::s_stdlib_dirs) && !inside_any(PluginAuditDetail::s_site_package_dirs);
-}
-
 void PluginAuditManager::release_frames(std::vector<PyObject*>& frames)
 {
     if (frames.empty())
@@ -1269,11 +1021,6 @@ void PluginAuditManager::release_frames(std::vector<PyObject*>& frames)
     PyErr_SetRaisedException(error);
 }
 
-void PluginAuditManager::set_permission_prompt_for_testing(PermissionPrompt prompt)
-{
-    PluginAuditDetail::s_permission_prompt_for_testing = std::move(prompt);
-}
-
 int PluginAuditManager::audit_hook(const char* event, PyObject* args, void* user_data)
 {
     auto* mgr = static_cast<PluginAuditManager*>(user_data);
@@ -1312,7 +1059,7 @@ int PluginAuditManager::audit_hook(const char* event, PyObject* args, void* user
 
 void PluginAuditManager::install_hook()
 {
-    // Identifies stdlib frames for operation roots and stdlib paths for read-only access.
+    // Tells the stdlib's own frames apart, for the operation-root frames (see record_root_frame).
     PluginAuditDetail::collect_stdlib_dirs();
 
     // data_dir() is the primary globally-allowed root during plugin execution: read+write. It

src/slic3r/plugin/PluginAuditManager.hpp

@@ -24,6 +24,19 @@ struct AuditViolation {
     std::string            reason;
 };
 
+// One classified CPython audit event observed while the probe is in record-only mode. This is
+// evidence about the code path that ran, not a grant request: the hook allowed the operation to
+// continue and did not consult the permission dialog or the persisted install state.
+struct AuditObservation {
+    std::string              plugin_key;
+    std::string              capability;
+    std::string              phase;
+    std::string              event_name;
+    std::string              category;
+    std::vector<std::string> targets;
+    bool                     continued = true;
+};
+
 // A filesystem root a plugin may access while an audit context is active. allow_write is
 // false for a root that only grants reads (e.g. the bundled, shared resources folder) --
 // a write-shaped event never matches such a root, even though a read-shaped one does.
@@ -137,6 +150,30 @@ public:
     bool request_filesystem_read_permissions(const std::string& plugin_key,
                                              const std::vector<std::string>& paths);
 
+    // --- probe observation mode (thread-safe, never used by the GUI) ---
+    // When an observer is installed, every classified event raised by plugin-authored code is
+    // reported to it and then allowed through (the hook returns 0). The permission dialogs, saved
+    // grants and .install_state.json are never consulted, so this is not a containment boundary.
+    // The observer must not touch Python objects: it runs inside the audit hook with the GIL held.
+    using AuditObserver = std::function<void(const AuditObservation&)>;
+    void set_observation_observer(AuditObserver observer);
+    void clear_observation_observer();
+    bool observation_mode() const;
+
+    // Stop after classification/target extraction; true means an observer consumed the event.
+    // Exposed for the probe and its tests, not for production callers.
+    bool record_observation(const std::string& event_name,
+                            const std::string& category,
+                            const std::vector<std::string>& targets);
+
+    // --- probe phase attribution (thread_local) ---
+    // Labels events for the probe's report. Production leaves it empty. A Python thread spawned by
+    // plugin code inherits no phase, so its events are reported as unattributed rather than being
+    // guessed at.
+    void               set_current_audit_phase(const std::string& phase);
+    const std::string& current_audit_phase() const;
+    void               clear_current_audit_phase();
+
     void report_violation(const AuditViolation& violation);
     bool audit_denial_pending() const;
     void clear_audit_denial();
@@ -173,16 +210,12 @@ private:
 
     static int audit_hook(const char* event, PyObject* args, void* user_data);
 
-    // True for paths inside the interpreter's stdlib, excluding site-packages. Unlike
-    // is_stdlib_file(), this query is not cached because filesystem paths may resolve through
-    // symlinks that can change.
-    static bool is_stdlib_path(const boost::filesystem::path& path);
-
     // Drops the references in `frames`, keeping the caller's error and denial state intact.
     void release_frames(std::vector<PyObject*>& frames);
 
     static thread_local std::string                   m_current_plugin_key;
     static thread_local std::string                   m_current_capability_name;
+    static thread_local std::string                   m_current_audit_phase;
     static thread_local std::vector<AllowedRoot>       m_scoped_allowed_roots;
     static thread_local std::vector<PyObject*>         m_root_frames; // strong references
     static thread_local int                            m_releasing_frames;
@@ -195,6 +228,11 @@ private:
     std::vector<AllowedRoot>             m_global_allowed_roots;
     std::vector<std::string>             m_denied_filenames;
     std::vector<std::string>             m_denied_path_keywords;
+
+    // Kept apart from m_mutex: observation_mode() is queried from the audit hook while the hook
+    // already holds the GIL, and the setter runs before plugin code starts.
+    mutable std::mutex m_observer_mutex;
+    AuditObserver      m_observation_observer;
 };
 
 // RAII guard that sets the current plugin key and capability name, restoring the previous
@@ -225,6 +263,22 @@ private:
     std::vector<PyObject*>        m_previous_root_frames;
 };
 
+// Sets the probe's phase label on the current thread and restores the previous one on scope exit.
+// Empty in production, where no phase is ever set.
+class ScopedPluginAuditPhase
+{
+public:
+    explicit ScopedPluginAuditPhase(std::string phase);
+    ~ScopedPluginAuditPhase();
+
+    ScopedPluginAuditPhase(const ScopedPluginAuditPhase&)            = delete;
+    ScopedPluginAuditPhase& operator=(const ScopedPluginAuditPhase&) = delete;
+
+private:
+    std::string m_phase;
+    std::string m_previous_phase;
+};
+
 } // namespace Slic3r
 
 #endif // slic3r_PluginAuditManager_hpp_

src/slic3r/plugin/PluginAuditManagerGui.cpp

@@ -0,0 +1,332 @@
+#include "PluginAuditManagerInternal.hpp"
+
+#include "PluginDescriptor.hpp"
+#include "PluginFsUtils.hpp"
+#include "PluginManager.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <future>
+#include <memory>
+#include <slic3r/plugin/PluginAuditManager.hpp>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <slic3r/GUI/GUI_App.hpp>
+#include <slic3r/GUI/I18N.hpp>
+
+#include <wx/app.h>
+#include <wx/msgdlg.h>
+#include <wx/string.h>
+#include <wx/thread.h>
+
+namespace Slic3r {
+namespace {
+
+// The saved list that grants an event: its category's target list, or the event-grant list for
+// an event with no target. Kept apart, so that no grant doubles as a target of the same name (an
+// os.fork grant is not an os.exec of a command named "os.fork").
+std::vector<std::string>* permission_list_for(AuditEventCategory category, bool by_event, PluginPermissions& permissions)
+{
+    if (by_event)
+        return &permissions.events;
+
+    switch (category) {
+    case AuditEventCategory::FsRead:        return &permissions.fs_read;
+    case AuditEventCategory::FsReadWrite:   return &permissions.fs_readwrite;
+    case AuditEventCategory::Http:          return &permissions.network_http;
+    case AuditEventCategory::Socket:        return &permissions.network_socket;
+    case AuditEventCategory::ProcessCreate: return &permissions.process;
+    case AuditEventCategory::Threading:     return &permissions.threading;
+    case AuditEventCategory::ProcessReplace: return &permissions.process;
+    default:                                return nullptr;
+    }
+}
+
+// An event with no target is granted by its effective category and name, e.g. "FsRead:open"
+// for a read of a file descriptor, which does not grant a write of one ("FsReadWrite:open").
+std::string event_grant_key(AuditEventCategory category, const std::string& event_name)
+{
+    return std::string(plugin_audit::category_name(category)) + ":" + event_name;
+}
+
+bool has_permission(const std::vector<std::string>& granted, const std::string& target)
+{
+    return std::find(granted.begin(), granted.end(), target) != granted.end();
+}
+
+bool persist_permission(const std::string&        plugin_key,
+                        PluginInstallState&       state,
+                        std::vector<std::string>& permission_list,
+                        const std::string&        target)
+{
+    PluginDescriptor descriptor;
+    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
+        return false;
+
+    // A sandbox plugin may not have a sidecar yet.  Seed the small amount of install metadata
+    // needed by the writer so clicking Yes still creates the JSON file.
+    if (state.plugin_name.empty()) {
+        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
+        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
+        state.plugin_name       = descriptor.name;
+        state.cloud_uuid        = descriptor.cloud_uuid();
+        state.enabled            = true;
+    }
+
+    if (!has_permission(permission_list, target))
+        permission_list.push_back(target);
+    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
+}
+
+wxString audit_message(AuditEventCategory category, const wxString& plugin_name, const wxString& event_name,
+                       const wxString& target_list, size_t target_count)
+{
+    if (target_list.IsEmpty())
+        return wxString::Format(
+            _L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\".\n\n"
+                "This operation does not expose a target the audit hook can display."),
+            plugin_name, event_name);
+
+    switch (category) {
+    case AuditEventCategory::FsRead:
+        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read the following file:\n%s",
+                                          "Plugin \"%s\" is requesting to read the following files:\n%s", target_count),
+                                plugin_name, target_list);
+    case AuditEventCategory::FsReadWrite:
+        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to read/write the following file:\n%s",
+                                          "Plugin \"%s\" is requesting to read/write the following files:\n%s", target_count),
+                                plugin_name, target_list);
+    case AuditEventCategory::FsCreate:
+        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to create the following file:\n%s",
+                                          "Plugin \"%s\" is requesting to create the following files:\n%s", target_count),
+                                plugin_name, target_list);
+    case AuditEventCategory::FsDelete:
+        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to delete the following file:\n%s",
+                                          "Plugin \"%s\" is requesting to delete the following files:\n%s", target_count),
+                                plugin_name, target_list);
+    case AuditEventCategory::Http:
+        return wxString::Format(_L("Plugin \"%s\" is requesting to make an HTTP request to:\n%s"), plugin_name, target_list);
+    case AuditEventCategory::Socket:
+        return wxString::Format(_L("Plugin \"%s\" is requesting to open a network connection to:\n%s"), plugin_name, target_list);
+    case AuditEventCategory::ProcessCreate:
+        return wxString::Format(_L_PLURAL("Plugin \"%s\" is requesting to run the following command:\n%s",
+                                          "Plugin \"%s\" is requesting to run the following commands:\n%s", target_count),
+                                plugin_name, target_list);
+    case AuditEventCategory::Threading:
+        return wxString::Format(_L("Plugin \"%s\" is requesting permission to create a thread."), plugin_name);
+    case AuditEventCategory::ProcessReplace:
+        return wxString::Format(_L("Plugin \"%s\" is requesting to replace the running application with:\n%s"), plugin_name, target_list);
+    default:
+        return wxString::Format(_L("Plugin \"%s\" is requesting permission for the Python audit event \"%s\"."), plugin_name, event_name);
+    }
+}
+
+// Builds and shows the modal permission prompt. Must run on the GUI thread.
+bool prompt_for_targets(AuditEventCategory category, const std::string& plugin_name, const std::string& event_name,
+                        const std::vector<std::string>& unresolved)
+{
+    wxString target_list;
+    for (const auto& target : unresolved)
+        target_list += wxString::FromUTF8(target.c_str()) + "\n";
+
+    wxMessageDialog dialog(nullptr,
+                           audit_message(category, wxString::FromUTF8(plugin_name.c_str()),
+                                        wxString::FromUTF8(event_name.c_str()), target_list, unresolved.size()),
+                           _L("Plugin permission request"), wxYES_NO | wxICON_WARNING);
+    return dialog.ShowModal() == wxID_YES;
+}
+
+// Records a grant in the plugin's sidecar so it is not asked again. Reads the install state
+// freshly because the async prompt outlives the caller's stack copy of it.
+void persist_grant(const std::string& plugin_key, AuditEventCategory category, bool by_event, const std::vector<std::string>& keys)
+{
+    PluginInstallState state;
+    if (!PluginManager::instance().get_install_state(plugin_key, state))
+        return;
+
+    std::vector<std::string>* permission_list = permission_list_for(category, by_event, state.permissions);
+    if (!permission_list)
+        return;
+
+    for (const auto& key : keys)
+        persist_permission(plugin_key, state, *permission_list, key);
+}
+
+PluginAuditManager::PermissionPrompt s_permission_prompt_for_testing;
+
+// Asks the user to grant an audited event, returning true when they approve an inline prompt.
+// `keys` are what a Yes saves: the unresolved targets, or the event-grant key when the event has
+// no target (by_event), which the prompt does not show as a target.
+//
+// An audited event can fire on a thread the UI thread may itself be blocked waiting on: the
+// SlicingPipeline hook runs on the slicing worker thread (see PluginHooks.cpp), and
+// BackgroundSlicingProcess::stop()/stop_internal() park the UI thread until that worker stops.
+// Blocking the worker on a marshaled modal -- which is safe for the plugin-load worker that
+// request_filesystem_read_permissions runs on -- would therefore deadlock the application (the
+// invariant PluginHostUi.cpp documents for slicing-hook UI calls). Off the main thread the prompt
+// is therefore posted asynchronously and the current event denied (fail closed, like an unanswered
+// prompt); the grant is persisted once the user accepts, so a later attempt succeeds without
+// re-prompting.
+bool request_permission(AuditEventCategory category, const std::string& plugin_key, const std::string& plugin_name,
+                        const std::string& event_name, bool by_event, const std::vector<std::string>& keys)
+{
+    const std::vector<std::string> shown = by_event ? std::vector<std::string>{} : keys;
+
+    if (s_permission_prompt_for_testing)
+        return s_permission_prompt_for_testing(event_name, shown);
+
+    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
+        return false;
+
+    if (wxIsMainThread())
+        return prompt_for_targets(category, plugin_name, event_name, shown);
+
+    GUI::wxGetApp().CallAfter([category, plugin_key, plugin_name, event_name, by_event, keys, shown]() {
+        if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
+            return;
+        if (prompt_for_targets(category, plugin_name, event_name, shown))
+            persist_grant(plugin_key, category, by_event, keys);
+    });
+    return false;
+}
+
+// Decides an event that no allowed root or running operation covers: a saved grant allows it,
+// otherwise the user is asked and a Yes is saved.
+int decide_audited_event(PluginAuditManager&             mgr,
+                         PluginInstallState&              state,
+                         const std::string&                plugin_key,
+                         const std::string&                plugin_name,
+                         const std::string&                event_name,
+                         AuditEventCategory                category,
+                         const std::vector<std::string>&   targets)
+{
+    const bool                     by_event = targets.empty();
+    const std::vector<std::string> keys     = by_event ? std::vector<std::string>{event_grant_key(category, event_name)} : targets;
+    std::vector<std::string>*      permission_list = permission_list_for(category, by_event, state.permissions);
+
+    std::vector<std::string> unresolved = keys;
+    if (permission_list) {
+        unresolved.clear();
+        for (const auto& key : keys)
+            if (!has_permission(*permission_list, key))
+                unresolved.push_back(key);
+        if (unresolved.empty())
+            return 0;
+    }
+
+    // Letting a root frame go runs finalizers inside a scope destructor or another event's hook,
+    // where no dialog may open: what they do must already be granted.
+    if (mgr.releasing_frames())
+        return plugin_audit::report_denied(mgr, event_name, {false, "audit permission required"});
+
+    if (!request_permission(category, plugin_key, plugin_name, event_name, by_event, unresolved))
+        return plugin_audit::report_denied(mgr, event_name, {false, "audit permission required"});
+
+    if (permission_list)
+        for (const auto& key : unresolved)
+            persist_permission(plugin_key, state, *permission_list, key);
+    return 0;
+}
+
+} // namespace
+
+bool plugin_audit::request_filesystem_read_permissions(const std::string&              plugin_key,
+                                                       const std::vector<std::string>& paths)
+{
+    PluginDescriptor descriptor;
+    if (!PluginManager::instance().try_get_plugin_descriptor(plugin_key, descriptor) || descriptor.plugin_root.empty())
+        return false;
+
+    PluginInstallState state;
+    read_install_state(boost::filesystem::path(descriptor.plugin_root), state);
+
+    std::vector<std::string> missing;
+    for (const std::string& path : paths) {
+        if (std::find(state.permissions.fs_read.begin(), state.permissions.fs_read.end(), path) == state.permissions.fs_read.end())
+            missing.push_back(path);
+    }
+    if (missing.empty())
+        return true;
+
+    if (wxTheApp == nullptr || GUI::wxGetApp().is_closing())
+        return false;
+
+    auto show_dialog = [&descriptor, &missing]() {
+        wxString requested_paths;
+        for (const std::string& path : missing)
+            requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
+
+        wxMessageDialog dialog(
+            nullptr,
+            wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
+                             wxString::FromUTF8(descriptor.name.c_str()), requested_paths),
+            _L("Plugin permissions"),
+            wxYES_NO | wxICON_WARNING);
+        return dialog.ShowModal() == wxID_YES;
+    };
+
+    bool granted = false;
+    if (wxIsMainThread()) {
+        granted = show_dialog();
+    } else {
+        auto result = std::make_shared<std::promise<bool>>();
+        auto future = result->get_future();
+        GUI::wxGetApp().CallAfter([result, descriptor_name = descriptor.name, missing]() {
+            wxString requested_paths;
+            for (const std::string& path : missing)
+                requested_paths += wxString::FromUTF8(path.c_str()) + "\n";
+
+            wxMessageDialog dialog(
+                nullptr,
+                wxString::Format(_L("Plugin \"%s\" requests filesystem read access to:\n%s"),
+                                 wxString::FromUTF8(descriptor_name.c_str()), requested_paths),
+                _L("Plugin permissions"),
+                wxYES_NO | wxICON_WARNING);
+            result->set_value(dialog.ShowModal() == wxID_YES);
+        });
+        granted = future.get();
+    }
+
+    if (!granted)
+        return false;
+
+    if (state.plugin_name.empty()) {
+        state.installed_from    = descriptor.is_cloud_plugin() ? "cloud" : "local";
+        state.installed_version = !descriptor.installed_version.empty() ? descriptor.installed_version : descriptor.version;
+        state.plugin_name       = descriptor.name;
+        state.cloud_uuid        = descriptor.cloud_uuid();
+        state.enabled            = true;
+    }
+
+    state.permissions.fs_read.insert(state.permissions.fs_read.end(), missing.begin(), missing.end());
+    return write_install_state(boost::filesystem::path(descriptor.plugin_root), state);
+}
+
+int plugin_audit::decide_event(PluginAuditManager&             mgr,
+                               const std::string&              event_name,
+                               AuditEventCategory              category,
+                               const std::vector<std::string>& targets)
+{
+    PluginInstallState state;
+    const bool have_install_state = PluginManager::instance().get_install_state(mgr.current_plugin(), state);
+    if (!have_install_state) {
+        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " Failed to get install state for " << mgr.current_plugin();
+    }
+
+    const std::string plugin_name = state.plugin_name.empty() ? mgr.current_plugin() : state.plugin_name;
+
+    return decide_audited_event(mgr, state, mgr.current_plugin(), plugin_name, event_name, category, targets);
+}
+
+void PluginAuditManager::set_permission_prompt_for_testing(PermissionPrompt prompt)
+{
+    s_permission_prompt_for_testing = std::move(prompt);
+}
+
+} // namespace Slic3r

src/slic3r/plugin/PluginAuditManagerInternal.hpp

@@ -0,0 +1,38 @@
+#ifndef slic3r_PluginAuditManagerInternal_hpp_
+#define slic3r_PluginAuditManagerInternal_hpp_
+
+// Internal seam between the GUI-free audit core and the permission front end. The GUI library
+// supplies the dialogs, prompts and .install_state.json persistence; the headless probe supplies
+// a fail-closed implementation that never links wx. Production behavior lives in the GUI
+// implementation, which is the code that used to be part of PluginAuditManager.cpp.
+
+#include "PluginAuditManager.hpp"
+
+#include <string>
+#include <vector>
+
+namespace Slic3r::plugin_audit {
+
+const char* category_name(AuditEventCategory category);
+
+int report_denied(PluginAuditManager&       mgr,
+                  const std::string&        event_name,
+                  const AuditDecision&      decision,
+                  const std::string&        target = {});
+
+// Used only when the manager is not in observation mode. The GUI implementation consults the
+// install state, prompts and persists; the probe implementation fails closed.
+bool request_filesystem_read_permissions(const std::string&              plugin_key,
+                                         const std::vector<std::string>& paths);
+
+// Decides an event that no allowed root or running operation covered. The GUI implementation
+// reads the install state and prompts; the probe implementation fails closed. In observation
+// mode the audit hook records and returns before reaching this seam.
+int decide_event(PluginAuditManager&             mgr,
+                 const std::string&              event_name,
+                 AuditEventCategory              category,
+                 const std::vector<std::string>& targets);
+
+} // namespace Slic3r::plugin_audit
+
+#endif // slic3r_PluginAuditManagerInternal_hpp_

src/slic3r/plugin/PluginFsUtils.cpp

@@ -14,8 +14,7 @@
 
 #include "PluginAuditManager.hpp"
 #include "PythonInterpreter.hpp"
-#include "slic3r/GUI/I18N.hpp"
-#include "slic3r/GUI/format.hpp"
+#include "PluginText.hpp"
 
 #include <exception>
 #include <miniz.h>
@@ -92,7 +91,7 @@ bool resolve_allowed_plugin_root(const PluginDescriptor& descriptor,
 
     const fs::path plugin_root = resolve_plugin_root_from_descriptor(descriptor);
     if (plugin_root.empty()) {
-        error = _u8L("Plugin folder could not be determined.");
+        error = PLUGIN_U8L("Plugin folder could not be determined.");
         return false;
     }
 
@@ -103,7 +102,7 @@ bool resolve_allowed_plugin_root(const PluginDescriptor& descriptor,
         resolved_root = fs::absolute(plugin_root, ec);
     }
     if (ec || resolved_root.empty()) {
-        error = GUI::format(_u8L("Failed to resolve plugin folder: %1%"), plugin_root.string());
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to resolve plugin folder: %1%"), plugin_root.string());
         return false;
     }
 
@@ -123,7 +122,7 @@ bool delete_plugin_root(const boost::filesystem::path& resolved_root, const std:
     const auto removed_count = fs::remove_all(resolved_root, ec);
     if (ec) {
         // TRN %1% is a folder path, %2% the system error message.
-        error = GUI::format(_u8L("Failed to delete plugin folder %1%: %2%"), resolved_root.string(), ec.message());
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to delete plugin folder %1%: %2%"), resolved_root.string(), ec.message());
         return false;
     }
 
@@ -1199,7 +1198,7 @@ boost::filesystem::path find_installed_plugin_entry(const boost::filesystem::pat
     namespace fs = boost::filesystem;
 
     if (!fs::exists(plugin_dir) || !fs::is_directory(plugin_dir)) {
-        error = GUI::format(_u8L("Plugin directory does not exist: %1%"), plugin_dir.string());
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin directory does not exist: %1%"), plugin_dir.string());
         return {};
     }
 
@@ -1216,7 +1215,7 @@ boost::filesystem::path find_installed_plugin_entry(const boost::filesystem::pat
         if (ext == ".py") {
             if (!py_entry.empty()) {
                 // TRN %1% and %2% are file names.
-                error = GUI::format(_u8L("Plugin directory contains multiple .py files: %1% and %2%"),
+                error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin directory contains multiple .py files: %1% and %2%"),
                                     py_entry.filename().string(), it->path().filename().string());
                 return {};
             }
@@ -1224,7 +1223,7 @@ boost::filesystem::path find_installed_plugin_entry(const boost::filesystem::pat
         } else if (ext == ".whl") {
             if (!whl_entry.empty()) {
                 // TRN %1% and %2% are file names.
-                error = GUI::format(_u8L("Plugin directory contains multiple .whl files: %1% and %2%"),
+                error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin directory contains multiple .whl files: %1% and %2%"),
                                     whl_entry.filename().string(), it->path().filename().string());
                 return {};
             }
@@ -1233,7 +1232,7 @@ boost::filesystem::path find_installed_plugin_entry(const boost::filesystem::pat
     }
 
     if (!py_entry.empty() && !whl_entry.empty()) {
-        error = _u8L("Plugin directory contains both .py and .whl entry files");
+        error = PLUGIN_U8L("Plugin directory contains both .py and .whl entry files");
         return {};
     }
 
@@ -1243,7 +1242,7 @@ boost::filesystem::path find_installed_plugin_entry(const boost::filesystem::pat
     if (!whl_entry.empty())
         return whl_entry;
 
-    error = _u8L("Plugin directory does not contain a .py or .whl entry file");
+    error = PLUGIN_U8L("Plugin directory does not contain a .py or .whl entry file");
     return {};
 }
 
@@ -1260,34 +1259,34 @@ std::vector<std::string> collect_resource_texture_files(const std::string& dir,
     error.clear();
 
     if (dir.empty()) {
-        error = _u8L("Resource texture directory is not set");
+        error = PLUGIN_U8L("Resource texture directory is not set");
         return files;
     }
     if (plugin_root.empty()) {
-        error = _u8L("Plugin folder could not be determined.");
+        error = PLUGIN_U8L("Plugin folder could not be determined.");
         return files;
     }
 
     boost::system::error_code ec;
     const fs::path resolved_dir = fs::weakly_canonical(fs::path(dir), ec);
     if (ec) {
-        error = _u8L("Resource texture directory could not be resolved");
+        error = PLUGIN_U8L("Resource texture directory could not be resolved");
         return files;
     }
 
     if (!fs::is_directory(resolved_dir, ec) || ec) {
-        error = _u8L("Resource texture path is not a directory");
+        error = PLUGIN_U8L("Resource texture path is not a directory");
         return files;
     }
 
     const fs::path resolved_root = fs::weakly_canonical(fs::path(plugin_root), ec);
     if (ec) {
-        error = _u8L("Plugin folder could not be resolved");
+        error = PLUGIN_U8L("Plugin folder could not be resolved");
         return files;
     }
 
     if (!is_inside_allowed_root(resolved_dir, resolved_root)) {
-        error = _u8L("Resource texture directory is outside the plugin folder");
+        error = PLUGIN_U8L("Resource texture directory is outside the plugin folder");
         return files;
     }
 
@@ -1312,7 +1311,7 @@ std::vector<std::string> collect_resource_texture_files(const std::string& dir,
     }
 
     if (ec) {
-        error = _u8L("Resource texture directory could not be read");
+        error = PLUGIN_U8L("Resource texture directory could not be read");
         return {};
     }
 

src/slic3r/plugin/PluginLoader.cpp

@@ -11,8 +11,7 @@
 #include "PythonPluginBridge.hpp"
 #include "pluginTypes/resourceTexture/ResourceTexturePluginCapability.hpp"
 #include "libslic3r/Utils.hpp"
-#include "slic3r/GUI/I18N.hpp"
-#include "slic3r/GUI/format.hpp"
+#include "PluginText.hpp"
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
@@ -102,7 +101,7 @@ bool read_local_plugin_package_metadata(const boost::filesystem::path& source_pa
 
     const std::string ext = plugin_package_extension(source_path);
     if (ext != ".py" && ext != ".whl") {
-        error = GUI::format(_u8L("Plugin package must be a .py or .whl file, got: %1%"), ext);
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin package must be a .py or .whl file, got: %1%"), ext);
         return false;
     }
 
@@ -179,14 +178,14 @@ bool add_wheel_dependencies_to_sys_path(const PluginDescriptor& descriptor,
             std::string extract_error;
             if (!extract_zip_to_directory(it->path(), dep_dir, extract_error)) {
                 // TRN %1% is the dependency file, %2% the error detail.
-                error = GUI::format(_u8L("Failed to extract plugin .whl dependency %1%: %2%"), it->path().string(), extract_error);
+                error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to extract plugin .whl dependency %1%: %2%"), it->path().string(), extract_error);
                 return false;
             }
         }
 
         std::string syspath_error;
         if (!interpreter.add_plugin_sys_path(dep_dir.string(), syspath_error)) {
-            error = GUI::format(_u8L("Failed to add .whl dependency to sys.path: %1%"), syspath_error);
+            error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to add .whl dependency to sys.path: %1%"), syspath_error);
             return false;
         }
         plugin_paths.push_back(dep_dir.string());
@@ -248,12 +247,12 @@ bool load(const PluginDescriptor&                          descriptor,
 
     PythonInterpreter& interpreter = PythonInterpreter::instance();
     if (!interpreter.is_initialized()) {
-        error = GUI::format(_u8L("Python interpreter not initialized: %1%"), interpreter.last_error());
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Python interpreter not initialized: %1%"), interpreter.last_error());
         return false;
     }
 
     if (!descriptor.is_metadata_valid()) {
-        error = GUI::format(_u8L("Plugin manifest is invalid: %1%"), descriptor.plugin_key);
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin manifest is invalid: %1%"), descriptor.plugin_key);
         if (descriptor.has_error())
             error += " - " + descriptor.normalized_error();
         return false;
@@ -274,7 +273,7 @@ bool load(const PluginDescriptor&                          descriptor,
     if (!skip_deps) {
         std::string pkg_install_error;
         if (!install_packages(descriptor.dependencies, pkg_install_error)) {
-            error = GUI::format(_u8L("Failed to install plugin dependencies: %1%"), pkg_install_error);
+            error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to install plugin dependencies: %1%"), pkg_install_error);
             return false;
         }
     }
@@ -293,7 +292,7 @@ bool load(const PluginDescriptor&                          descriptor,
     PyObject*   module = import_plugin_module(descriptor, plugin.plugin_sys_paths, plugin.plugin_modules, load_error);
     if (module == nullptr) {
         bridge.cancel_plugin_capture(descriptor.entry_path);
-        error = GUI::format(_u8L("Failed to load plugin module: %1%"), load_error);
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Failed to load plugin module: %1%"), load_error);
         return false;
     }
 
@@ -308,13 +307,13 @@ bool load(const PluginDescriptor&                          descriptor,
     auto        capabilities_found = bridge.finalize_plugin_capture(descriptor.entry_path, descriptor.plugin_key, bridge_error);
     if (!bridge_error.empty()) {
         capabilities_found.clear();
-        error = GUI::format(_u8L("Plugin registration failed: %1%"), bridge_error);
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin registration failed: %1%"), bridge_error);
         if (registration_failed != nullptr)
             *registration_failed = true;
         return false;
     }
     if (capabilities_found.empty()) {
-        error = _u8L("Plugin module did not register any capabilities");
+        error = PLUGIN_U8L("Plugin module did not register any capabilities");
         return false;
     }
 
@@ -366,7 +365,7 @@ bool load(const PluginDescriptor&                          descriptor,
 
                     if (!seen_capabilities[type].insert(found.name).second) {
                         // TRN %1% is the capability name, %2% the capability type (e.g. Script).
-                        materialization_error = GUI::format(_u8L("Plugin declares duplicate capability '%1%' for type %2%"),
+                        materialization_error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin declares duplicate capability '%1%' for type %2%"),
                                                             found.name, PluginConfig::capability_type_label(type));
                         break;
                     }
@@ -422,9 +421,9 @@ bool load(const PluginDescriptor&                          descriptor,
                     capabilities.push_back(std::move(instance));
                 }
             } catch (const std::exception& ex) {
-                materialization_error = GUI::format(_u8L("Plugin capability materialization failed: %1%"), ex.what());
+                materialization_error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin capability materialization failed: %1%"), ex.what());
             } catch (...) {
-                materialization_error = _u8L("Plugin capability materialization failed");
+                materialization_error = PLUGIN_U8L("Plugin capability materialization failed");
             }
         }
 
@@ -466,11 +465,11 @@ bool load(const PluginDescriptor&                          descriptor,
     } catch (const std::exception& ex) {
         teardown_capabilities(plugin.capabilities, lifecycle_count);
         // TRN on_load is the name of the plugin's startup function; keep it untranslated.
-        error = GUI::format(_u8L("Plugin on_load failed: %1%"), ex.what());
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin on_load failed: %1%"), ex.what());
         return false;
     } catch (...) {
         teardown_capabilities(plugin.capabilities, lifecycle_count);
-        error = _u8L("Plugin on_load failed");
+        error = PLUGIN_U8L("Plugin on_load failed");
         return false;
     }
 
@@ -651,7 +650,7 @@ bool install_plugin(const boost::filesystem::path& filepath,
     bool     backup_created = false;
 
     auto fail = [&error](const std::string& message) {
-        error = GUI::format(_u8L("Plugin installation failed: %1%"), message);
+        error = PLUGIN_FORMAT(PLUGIN_U8L("Plugin installation failed: %1%"), message);
         return false;
     };
 
@@ -659,23 +658,23 @@ bool install_plugin(const boost::filesystem::path& filepath,
     const fs::path            source_path = canonical_or_absolute(filepath);
 
     if (!fs::exists(source_path, ec) || !fs::is_regular_file(source_path, ec))
-        return fail(GUI::format(_u8L("Plugin package is not a file: %1%"), filepath.string()));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Plugin package is not a file: %1%"), filepath.string()));
 
     const std::string ext = plugin_package_extension(source_path);
     if (ext != ".py" && ext != ".whl")
-        return fail(GUI::format(_u8L("Plugin package must be a .py or .whl file, got: %1%"), ext));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Plugin package must be a .py or .whl file, got: %1%"), ext));
     // The cloud UUID is concatenated into the install path (final_dir = plugin_root / cloud_uuid).
     // It comes verbatim from the server's catalog JSON, so reject anything that could escape the
     // per-user plugin root (traversal, leading dots, separators) before touching the filesystem.
     if (is_cloud_install && !is_valid_plugin_id(cloud_uuid))
-        return fail(GUI::format(_u8L("Cloud plugin UUID is not a valid identifier: %1%"), cloud_uuid));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Cloud plugin UUID is not a valid identifier: %1%"), cloud_uuid));
 
     const fs::path plugin_root = is_cloud_install && !cloud_user_id.empty() ? fs::path(get_cloud_plugin_dir(cloud_user_id)) :
                                                                              local_plugin_root();
     fs::create_directories(plugin_root, ec);
     if (ec)
         // TRN %1% is a folder path, %2% the system error message.
-        return fail(GUI::format(_u8L("Failed to create plugin directory %1%: %2%"), plugin_root.string(), ec.message()));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Failed to create plugin directory %1%: %2%"), plugin_root.string(), ec.message()));
 
     std::string meta_error;
     if (is_cloud_install) {
@@ -718,7 +717,7 @@ bool install_plugin(const boost::filesystem::path& filepath,
         fs::rename(final_dir, backup_dir, ec);
         if (ec)
             // TRN %1% is a folder path, %2% the system error message.
-            return fail(GUI::format(_u8L("Failed to back up existing plugin %1%: %2%"), final_dir.string(), ec.message()));
+            return fail(PLUGIN_FORMAT(PLUGIN_U8L("Failed to back up existing plugin %1%: %2%"), final_dir.string(), ec.message()));
         backup_created = true;
     }
 
@@ -729,7 +728,7 @@ bool install_plugin(const boost::filesystem::path& filepath,
             boost::system::error_code restore_ec;
             fs::rename(backup_dir, final_dir, restore_ec);
         }
-        return fail(GUI::format(_u8L("Failed to create plugin directory %1%: %2%"), final_dir.string(), ec.message()));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Failed to create plugin directory %1%: %2%"), final_dir.string(), ec.message()));
     }
 
     fs::copy_file(source_path, dest_file, ec);
@@ -740,7 +739,7 @@ bool install_plugin(const boost::filesystem::path& filepath,
             fs::rename(backup_dir, final_dir, restore_ec);
         }
         // TRN %1% is a file path, %2% the system error message.
-        return fail(GUI::format(_u8L("Failed to copy plugin file to %1%: %2%"), dest_file.string(), ec.message()));
+        return fail(PLUGIN_FORMAT(PLUGIN_U8L("Failed to copy plugin file to %1%: %2%"), dest_file.string(), ec.message()));
     }
 
     // Update entry_path to the installed location.
@@ -760,7 +759,7 @@ bool install_plugin(const boost::filesystem::path& filepath,
             fs::remove_all(final_dir, rollback_ec);
             if (backup_created)
                 fs::rename(backup_dir, final_dir, rollback_ec);
-            return fail(GUI::format(_u8L("Failed to write plugin install state: %1%"), (final_dir / INSTALL_STATE_FILE).string()));
+            return fail(PLUGIN_FORMAT(PLUGIN_U8L("Failed to write plugin install state: %1%"), (final_dir / INSTALL_STATE_FILE).string()));
         }
     }
 

src/slic3r/plugin/PluginManager.cpp

@@ -53,18 +53,6 @@ const char* const LOAD_CANCELLED = "__plugin_load_cancelled__";
 
 } // namespace
 
-void Plugin::release_module()
-{
-    if (module == nullptr && plugin_sys_paths.empty() && plugin_modules.empty())
-        return;
-
-    PythonInterpreter::instance().unload_module(module, module_name, plugin_sys_paths, plugin_modules);
-    module = nullptr;
-    module_name.clear();
-    plugin_sys_paths.clear();
-    plugin_modules.clear();
-}
-
 PluginManager& PluginManager::instance()
 {
     // Touch the interpreter first so its static outlives this one: ~Plugin needs it alive to

src/slic3r/plugin/PluginModule.cpp

@@ -0,0 +1,22 @@
+// Plugin module ownership is part of the loader's contract, not of the registry's GUI-facing
+// surface. Kept in its own translation unit so the headless probe can link the loader without
+// pulling PluginManager.cpp (and therefore wx/GUI) into the probe.
+
+#include "PluginManager.hpp"
+#include "PythonInterpreter.hpp"
+
+namespace Slic3r {
+
+void Plugin::release_module()
+{
+    if (module == nullptr && plugin_sys_paths.empty() && plugin_modules.empty())
+        return;
+
+    PythonInterpreter::instance().unload_module(module, module_name, plugin_sys_paths, plugin_modules);
+    module = nullptr;
+    module_name.clear();
+    plugin_sys_paths.clear();
+    plugin_modules.clear();
+}
+
+} // namespace Slic3r

src/slic3r/plugin/PluginText.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+// User-facing plugin messages are translated in the GUI build. The headless probe links neither
+// libslic3r_gui nor wx, so it formats the same English text without wxGetTranslation. The GUI path
+// expands to exactly the calls the plugin sources used before this header existed.
+
+#if defined(ORCA_PLUGIN_PROBE_BUILD)
+
+#include "libslic3r/format.hpp"
+
+#include <string>
+#include <utility>
+
+namespace Slic3r::plugin_text {
+
+inline std::string translate_utf8(const char* text) { return text == nullptr ? std::string{} : std::string(text); }
+inline std::string translate_utf8(const std::string& text) { return text; }
+
+template<typename... TArgs>
+inline std::string format(const char* fmt, TArgs&&... args)
+{
+    return Slic3r::format(fmt, std::forward<TArgs>(args)...);
+}
+
+template<typename... TArgs>
+inline std::string format(const std::string& fmt, TArgs&&... args)
+{
+    return Slic3r::format(fmt, std::forward<TArgs>(args)...);
+}
+
+} // namespace Slic3r::plugin_text
+
+#define PLUGIN_U8L(text) ::Slic3r::plugin_text::translate_utf8(text)
+#define PLUGIN_FORMAT(...) ::Slic3r::plugin_text::format(__VA_ARGS__)
+
+#else
+
+#include "slic3r/GUI/I18N.hpp"
+#include "slic3r/GUI/format.hpp"
+
+#define PLUGIN_U8L(text) _u8L(text)
+#define PLUGIN_FORMAT(...) GUI::format(__VA_ARGS__)
+
+#endif

src/slic3r/plugin/PythonPluginBridge.cpp

@@ -30,7 +30,7 @@
 #include "pluginTypes/slicingPipeline/SlicingPipelinePluginCapability.hpp"
 #include <pybind11/pytypes.h>
 #include <pybind11/gil.h>
-#include "slic3r/GUI/I18N.hpp"
+#include "PluginText.hpp"
 
 namespace py = pybind11;
 
@@ -193,7 +193,7 @@ std::vector<CapturedCapability> PythonPluginBridge::finalize_plugin_capture(cons
                     granted = PluginAuditManager::instance().request_filesystem_read_permissions(plugin_key, fs_read_permissions);
                 }
                 if (!granted) {
-                    error = _u8L("Plugin filesystem read permission request denied");
+                    error = PLUGIN_U8L("Plugin filesystem read permission request denied");
                     BOOST_LOG_TRIVIAL(warning) << error << " for key " << plugin_key;
                     discard_pending_for_key();
                     clear_active_key();

src/slic3r/plugin/probe/NanoSvgImplementation.cpp

@@ -0,0 +1,4 @@
+// libslic3r references NanoSVG without carrying its header-only implementation. This probe links
+// libslic3r without the GUI BitmapCache.cpp that supplies the implementation in the application.
+#define NANOSVG_IMPLEMENTATION
+#include "nanosvg/nanosvg.h"

src/slic3r/plugin/probe/PluginAuditManagerHeadless.cpp

@@ -0,0 +1,32 @@
+// Headless replacement for the GUI permission front end. The probe installs an observation
+// observer, so the audit hook records and returns before reaching this seam. If that observer is
+// ever absent, permission decisions fail closed instead of consulting GUI or install state.
+
+#include "slic3r/plugin/PluginAuditManagerInternal.hpp"
+
+#include <boost/log/trivial.hpp>
+
+#include <string>
+#include <vector>
+
+namespace Slic3r::plugin_audit {
+
+bool request_filesystem_read_permissions(const std::string&              plugin_key,
+                                         const std::vector<std::string>& paths)
+{
+    BOOST_LOG_TRIVIAL(warning) << "[PROBE] Refusing filesystem read permission request for " << plugin_key
+                               << " (" << paths.size() << " path(s)): the headless probe does not evaluate grants";
+    return false;
+}
+
+int decide_event(PluginAuditManager&             mgr,
+                 const std::string&              event_name,
+                 AuditEventCategory              category,
+                 const std::vector<std::string>& targets)
+{
+    (void) category;
+    (void) targets;
+    return report_denied(mgr, event_name, {false, "permission decisions are unavailable in the headless probe"});
+}
+
+} // namespace Slic3r::plugin_audit

src/slic3r/plugin/probe/PluginHostProbe.cpp

@@ -0,0 +1,75 @@
+// Probe-only `orca.host` registration. The GUI-free domains use the production bindings; the
+// domains that need a live GUI application, main window or preset bundle are exposed as explicit
+// unsupported submodules instead of being compiled (and linked) into the probe.
+//
+// A plugin that touches one of those domains fails its own callback with a clear message; the
+// failure is recorded by the probe's callback report rather than becoming a link dependency.
+
+#include "slic3r/plugin/host/PluginHost.hpp"
+#include "slic3r/plugin/host/PluginHostBindings.hpp"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/pytypes.h>
+
+#include <stdexcept>
+#include <string>
+
+namespace py = pybind11;
+
+namespace Slic3r {
+namespace {
+
+void add_unavailable_domain(py::module_& host, const char* name, const char* description)
+{
+    py::module_ domain = host.def_submodule(name, description);
+    const std::string prefix = std::string("orca.host.") + name + ".";
+    domain.attr("__getattr__") = py::cpp_function([prefix](const std::string& attribute) -> py::object {
+        throw std::runtime_error(prefix + attribute +
+                                 " is not available in the headless plugin permission probe because it needs the GUI application");
+    });
+}
+
+void add_unavailable_function(py::module_& host, const char* name)
+{
+    // Production registers these in PluginHostApp::register_app(). Do not overwrite a slot that
+    // another registrar already claimed (the model domain binds the Model class through
+    // register_model); the probe only fills the GUI-backed accessors that are absent here.
+    if (py::hasattr(host, name))
+        return;
+
+    const std::string detail = std::string("orca.host.") + name +
+                               " is not available in the headless plugin permission probe because it needs the GUI application";
+    host.def(name, [detail](py::args, py::kwargs) -> py::object { throw std::runtime_error(detail); }, detail.c_str());
+}
+
+} // namespace
+
+void PluginHost::RegisterBindings(py::module_& module)
+{
+    auto host = module.def_submodule("host", "Host application API");
+
+    // Value types first so the docstring signatures of later registrars resolve to the bound names.
+    host_bindings::register_geometry(host);
+    host_bindings::register_mesh(host);
+    host_bindings::register_model(host);
+    host_bindings::register_slicing(host);
+
+    // These domains are backed by the live GUI, its Plater/MainFrame and the preset bundle.
+    add_unavailable_domain(host, "presets", "Preset bundle access (headless probe: unavailable)");
+    add_unavailable_domain(host, "app", "Live application and Plater access (headless probe: unavailable)");
+    add_unavailable_domain(host, "ui", "Native dialogs and HTML windows (headless probe: unavailable)");
+    for (const char* name : {"plater", "model", "preset_bundle", "app_info", "gl_info", "selected_printer"})
+        add_unavailable_function(host, name);
+
+    // Storage needs the PluginManager registry, which is not part of the headless probe.
+    auto plugin_host = host.def_submodule("plugin", "Plugin host API (headless probe: storage unavailable)");
+    plugin_host.def("storage", []() -> std::string {
+        throw std::runtime_error("orca.host.plugin.storage() is not available in the headless plugin permission probe");
+    }, "Return the installed folder of the current plugin.");
+    plugin_host.attr("__getattr__") = py::cpp_function([](const std::string& attribute) -> py::object {
+        throw std::runtime_error("orca.host.plugin." + attribute +
+                                 " is not available in the headless plugin permission probe");
+    });
+}
+
+} // namespace Slic3r

src/slic3r/plugin/probe/PluginPermissionProbe.cpp

@@ -0,0 +1,800 @@
+// Headless, record-only plugin permission probe.
+//
+// This is a developer/security-analysis tool, not a second production loader. It reuses the
+// embedded interpreter, the production plugin_loader sequence and the GUI-free `orca` bindings
+// (capability types plus the geometry/model/slicing host domains), so the observations come from
+// the same audit classification and target extraction as the GUI. It then lets every audited
+// operation continue instead of consulting permission grants or dialogs. Host domains that need
+// the live GUI (app, presets, ui) and plugin.storage are registered as explicit unsupported
+// errors; the config API reports an empty config and refuses writes.
+//
+// It is NOT a sandbox. Plugin code runs with the probe's filesystem, network and process
+// privileges. The temporary data directory only keeps OrcaSlicer's own state out of the user's
+// tree; it does not confine plugin-authored code. Use OS-level restrictions (container, user,
+// seccomp/AppArmor, firewall) when the package is not trusted.
+//
+// The report describes only the paths this run exercised. CPython audit events are observations of
+// particular operations, not a notification for every Python call, so absence of a category in the
+// report is not evidence that the plugin cannot perform it.
+//
+// The report separates package validation, runtime compatibility, callback results and observed
+// audit activity, then derives an advisory readiness status from them. Readiness never changes the
+// process exit status, which stays load-based for existing callers.
+
+#include "slic3r/plugin/PluginAuditManager.hpp"
+#include "slic3r/plugin/PluginDescriptor.hpp"
+#include "slic3r/plugin/PluginFsUtils.hpp"
+#include "slic3r/plugin/PluginLoader.hpp"
+#include "slic3r/plugin/PluginManager.hpp"
+#include "slic3r/plugin/PythonInterpreter.hpp"
+#include "slic3r/plugin/PythonPluginInterface.hpp"
+#include "slic3r/plugin/probe/PluginProbeCollector.hpp"
+
+#include "libslic3r/LifecycleEvents.hpp"
+#include "libslic3r/Utils.hpp"
+
+#include <boost/algorithm/string/case_conv.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/system/error_code.hpp>
+#include <nlohmann/json.hpp>
+#include <pybind11/embed.h>
+#include <pybind11/gil.h>
+#include <pybind11/pytypes.h>
+
+#include <cstddef>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace fs = boost::filesystem;
+namespace py = pybind11;
+
+using namespace Slic3r;
+
+namespace {
+
+constexpr const char* kLoadPhase = "load:import+registration+on_load";
+
+struct Options
+{
+    fs::path plugin_path;
+    bool json = false;
+};
+
+void print_usage(std::ostream& out)
+{
+    out << "Usage: orca-plugin-probe [--json] <plugin.py|plugin.whl>\n"
+           "\n"
+           "Runs a plugin in a temporary data/working directory and reports the CPython audit\n"
+           "events observed while its import, registration, on_load and discoverable callbacks\n"
+           "execute. The probe does not prompt for permissions, write grants, install dependencies,\n"
+           "or start the OrcaSlicer GUI. The report summarizes package validation, runtime\n"
+           "compatibility, callback results and audit activity, plus an advisory readiness status.\n"
+           "\n"
+           "  --json   Emit the report as JSON (default: human-readable text)\n"
+           "  --help   Show this message\n"
+           "\n"
+           "WARNING: this is not a sandbox. Plugin Python code runs with this process's privileges.\n"
+           "Results are observational and non-exhaustive. Use OS-level restrictions for untrusted\n"
+           "packages.\n"
+           "\n"
+           "Exit status: 0 plugin loaded, 1 initialization/load failure, 2 usage error.\n";
+}
+
+bool parse_options(int argc, char** argv, Options& options, std::string& error)
+{
+    for (int index = 1; index < argc; ++index) {
+        const std::string argument = argv[index];
+        if (argument == "--help" || argument == "-h") {
+            print_usage(std::cout);
+            std::exit(0);
+        }
+        if (argument == "--json") {
+            options.json = true;
+            continue;
+        }
+        if (!argument.empty() && argument.front() == '-') {
+            error = "Unknown option: " + argument;
+            return false;
+        }
+        if (!options.plugin_path.empty()) {
+            error = "Only one plugin package may be probed at a time.";
+            return false;
+        }
+        options.plugin_path = fs::path(argument);
+    }
+
+    if (options.plugin_path.empty()) {
+        error = "No plugin package given.";
+        return false;
+    }
+    return true;
+}
+
+// Keep every write OrcaSlicer makes during the run inside a throwaway tree, and keep relative
+// paths opened by plugin code out of the caller's working directory. This is hygiene, not
+// confinement: an absolute path supplied by the plugin is still opened normally.
+class ScopedProbeWorkspace
+{
+public:
+    ScopedProbeWorkspace()
+        : m_root(fs::temp_directory_path() / fs::unique_path("orca-plugin-probe-%%%%-%%%%-%%%%"))
+        , m_previous_data_dir(data_dir())
+        , m_previous_working_dir(fs::current_path())
+    {
+        fs::create_directories(m_root);
+        set_data_dir(m_root.string());
+        fs::current_path(m_root);
+        m_moved = true;
+    }
+
+    ~ScopedProbeWorkspace()
+    {
+        boost::system::error_code ec;
+        set_data_dir(m_previous_data_dir);
+        if (m_moved)
+            fs::current_path(m_previous_working_dir, ec);
+        fs::remove_all(m_root, ec);
+    }
+
+    const fs::path& root() const { return m_root; }
+
+private:
+    fs::path m_root;
+    std::string m_previous_data_dir;
+    fs::path m_previous_working_dir;
+    bool m_moved = false;
+};
+
+class ScopedObservationObserver
+{
+public:
+    explicit ScopedObservationObserver(PluginProbeCollector& collector) : m_collector(collector)
+    {
+        PluginAuditManager::instance().set_observation_observer(
+            [this](const AuditObservation& observation) { m_collector.record(observation); });
+    }
+
+    ~ScopedObservationObserver() { PluginAuditManager::instance().clear_observation_observer(); }
+
+    ScopedObservationObserver(const ScopedObservationObserver&)            = delete;
+    ScopedObservationObserver& operator=(const ScopedObservationObserver&) = delete;
+
+private:
+    PluginProbeCollector& m_collector;
+};
+
+bool prepare_descriptor(const fs::path& plugin_path, PluginDescriptor& descriptor, std::string& error)
+{
+    boost::system::error_code ec;
+    const fs::path canonical = fs::weakly_canonical(plugin_path, ec);
+    if (ec || !fs::exists(canonical) || !fs::is_regular_file(canonical)) {
+        error = "Plugin package is not a readable file: " + plugin_path.string();
+        return false;
+    }
+
+    std::string extension = canonical.extension().string();
+    boost::algorithm::to_lower(extension);
+    if (extension != ".py" && extension != ".whl") {
+        error = "Plugin package must be a .py or .whl file, got: " + extension;
+        return false;
+    }
+
+    if (extension == ".whl") {
+        if (!read_wheel_plugin_metadata(canonical, descriptor, error))
+            return false;
+    } else {
+        if (!read_python_plugin_metadata(canonical, descriptor, error))
+            return false;
+    }
+
+    descriptor.entry_path     = canonical.string();
+    descriptor.plugin_key     = make_local_plugin_key(canonical.stem().string());
+    descriptor.metadata_valid = true;
+    // Leaving plugin_root empty keeps the probe independent of any .install_state.json next to
+    // the package and avoids the production sidecar path.
+    descriptor.plugin_root.clear();
+    if (descriptor.name.empty())
+        descriptor.name = descriptor.plugin_key;
+    return true;
+}
+
+void redirect_python_stdout()
+{
+    py::gil_scoped_acquire gil;
+    py::object sys = py::module_::import("sys");
+    // Keep plugin prints from corrupting the C++ report on stdout. sys.stderr is the interpreter's
+    // tee to the temporary log, so plugin output remains available there.
+    sys.attr("stdout") = sys.attr("stderr");
+}
+
+// Captured while the interpreter is still alive. Best effort: a failed lookup leaves the field
+// empty and does not overwrite the initialization error.
+std::string query_python_version()
+{
+    py::gil_scoped_acquire gil;
+    try {
+        return py::module_::import("platform").attr("python_version")().cast<std::string>();
+    } catch (const std::exception&) {
+        return {};
+    }
+}
+
+std::string package_format(const fs::path& path)
+{
+    std::string extension = path.extension().string();
+    boost::algorithm::to_lower(extension);
+    if (extension == ".whl")
+        return "wheel";
+    if (extension == ".py")
+        return "python-script";
+    return extension.empty() ? "unknown" : extension;
+}
+
+template<class Function>
+void invoke_callback(const std::shared_ptr<PluginCapabilityInterface>& capability,
+                     const std::string& phase,
+                     const std::string& callback,
+                     PluginProbeCollector& collector,
+                     Function&& function)
+{
+    ScopedPluginAuditPhase phase_scope(phase);
+    try {
+        std::forward<Function>(function)();
+        collector.record_callback({capability ? capability->name() : std::string{}, phase, callback, "invoked", {}});
+    } catch (const std::exception& error) {
+        collector.record_callback({capability ? capability->name() : std::string{}, phase, callback, "failed", error.what()});
+    } catch (...) {
+        collector.record_callback({capability ? capability->name() : std::string{}, phase, callback, "failed", "non-standard exception"});
+    }
+}
+
+struct ProbeCapability
+{
+    std::string name;
+    std::string type;
+    bool enabled = true;
+};
+
+std::vector<ProbeCapability> describe_capabilities(const Plugin& plugin)
+{
+    std::vector<ProbeCapability> capabilities;
+    capabilities.reserve(plugin.capabilities.size());
+    for (const auto& capability : plugin.capabilities) {
+        if (!capability)
+            continue;
+        capabilities.push_back({capability->name(), plugin_capability_type_to_string(capability->type()), capability->is_enabled()});
+    }
+    return capabilities;
+}
+
+void exercise_callbacks(const Plugin& plugin, PluginProbeCollector& collector)
+{
+    // on_load() already ran inside plugin_loader::load. The callbacks below are the additional
+    // entry points a loaded capability exposes to the host. Synthetic inputs are used; a callback
+    // may behave differently with a real application state, which the report cannot capture.
+    static constexpr LifecycleEvent lifecycle_events[] = {
+        LifecycleEvent::NewProject,          LifecycleEvent::ProjectOpened,         LifecycleEvent::ProjectBeforeSave,
+        LifecycleEvent::ProjectAfterSave,    LifecycleEvent::ProjectClosed,         LifecycleEvent::ProjectDirtyChanged,
+        LifecycleEvent::SliceStarted,        LifecycleEvent::SliceGeometryFinished, LifecycleEvent::GCodeExportStarted,
+        LifecycleEvent::GCodeExportFinished, LifecycleEvent::SlicingJobComplete,    LifecycleEvent::ObjectAdded,
+        LifecycleEvent::ObjectDeleted,       LifecycleEvent::ObjectTransformed,     LifecycleEvent::ObjectChanged,
+        LifecycleEvent::ObjectRenamed,       LifecycleEvent::PlateCreated,          LifecycleEvent::PlateDeleted,
+        LifecycleEvent::PlateSelected,       LifecycleEvent::PlateRenamed,          LifecycleEvent::PresetSelected,
+        LifecycleEvent::PresetSaved,         LifecycleEvent::PrintStateChanged,     LifecycleEvent::DeviceOnline,
+        LifecycleEvent::DeviceOffline,       LifecycleEvent::DeviceDiscovered,      LifecycleEvent::DeviceSelected,
+        LifecycleEvent::UploadStarted,       LifecycleEvent::UploadFinished,        LifecycleEvent::PrintJobStarted,
+        LifecycleEvent::PrintJobFinished,    LifecycleEvent::SendJobStarted,        LifecycleEvent::SendJobFinished,
+    };
+
+    for (const auto& capability : plugin.capabilities) {
+        if (!capability)
+            continue;
+
+        invoke_callback(capability, "callback:get_default_config", "get_default_config", collector,
+                        [&capability]() { (void) capability->get_default_config(); });
+
+        if (capability->config_ui_available()) {
+            invoke_callback(capability, "callback:get_config_ui", "get_config_ui", collector,
+                            [&capability]() { (void) capability->get_config_ui(); });
+        } else {
+            collector.record_callback(
+                {capability->name(), "callback:get_config_ui", "get_config_ui", "skipped", "has_config_ui() is false"});
+        }
+
+        for (const LifecycleEvent event : lifecycle_events) {
+            const std::string event_name = lifecycle_event_to_string(event);
+            const std::string phase      = "callback:on_lifecycle_event(" + event_name + ")";
+            LifecycleEventContext context;
+            context.source = "orca-plugin-probe";
+            context.msg    = "synthetic event generated by the permission probe";
+            invoke_callback(capability, phase, "on_lifecycle_event(" + event_name + ")", collector,
+                            [&capability, event, &context]() { capability->on_lifecycle_event(event, context); });
+        }
+
+        // Cancellation is a load-time path; calling it after a successful load would misrepresent
+        // the capability's real lifecycle. Report it as skipped instead.
+        collector.record_callback(
+            {capability->name(), "callback:on_cancelled", "on_cancelled", "skipped", "not invoked after a successful load"});
+    }
+}
+
+nlohmann::json observation_json(const AuditObservation& observation)
+{
+    return {
+        {"plugin", observation.plugin_key},
+        {"capability", observation.capability},
+        {"phase", observation.phase.empty() ? "unattributed" : observation.phase},
+        {"event", observation.event_name},
+        {"category", observation.category},
+        {"targets", observation.targets},
+        {"continued", observation.continued},
+    };
+}
+
+nlohmann::json callback_json(const ProbeCallbackRecord& callback)
+{
+    return {
+        {"capability", callback.capability}, {"phase", callback.phase},   {"callback", callback.callback},
+        {"status", callback.status},         {"detail", callback.detail},
+    };
+}
+
+nlohmann::json capability_json(const ProbeCapability& capability)
+{
+    return {
+        {"name", capability.name},
+        {"type", capability.type},
+        {"enabled", capability.enabled},
+    };
+}
+
+nlohmann::json build_report(const Options& options,
+                            const PluginProbeCollector& collector,
+                            const std::vector<ProbeCapability>& capabilities,
+                            const std::string& plugin_key,
+                            const PluginDescriptor& descriptor,
+                            bool descriptor_ready,
+                            const std::string& descriptor_error,
+                            bool python_initialized,
+                            const std::string& python_version,
+                            const std::string& python_error,
+                            bool loaded,
+                            const std::string& load_error,
+                            const std::string& data_dir)
+{
+    const std::vector<AuditObservation> observed_events = collector.observations();
+    nlohmann::json observations                         = nlohmann::json::array();
+    std::size_t unattributed_events                     = 0;
+    std::size_t non_continued_events                    = 0;
+    for (const AuditObservation& observation : observed_events) {
+        observations.push_back(observation_json(observation));
+        if (observation.phase.empty())
+            ++unattributed_events;
+        if (!observation.continued)
+            ++non_continued_events;
+    }
+
+    const std::vector<ProbeCallbackRecord> callback_records = collector.callbacks();
+    nlohmann::json callbacks                                = nlohmann::json::array();
+    std::size_t invoked_callbacks                           = 0;
+    std::size_t failed_callbacks                            = 0;
+    std::size_t skipped_callbacks                           = 0;
+    for (const ProbeCallbackRecord& callback : callback_records) {
+        callbacks.push_back(callback_json(callback));
+        if (callback.status == "invoked")
+            ++invoked_callbacks;
+        else if (callback.status == "failed")
+            ++failed_callbacks;
+        else if (callback.status == "skipped")
+            ++skipped_callbacks;
+    }
+
+    nlohmann::json capability_list = nlohmann::json::array();
+    for (const ProbeCapability& capability : capabilities)
+        capability_list.push_back(capability_json(capability));
+
+    const nlohmann::json summary      = collector.summary();
+    const bool package_valid          = descriptor_ready && descriptor.metadata_valid;
+    const std::string entry_path      = descriptor.entry_path.empty() ? options.plugin_path.string() : descriptor.entry_path;
+    const std::string observed_plugin = plugin_key.empty() ? make_local_plugin_key(options.plugin_path.stem().string()) : plugin_key;
+
+    nlohmann::json readiness_issues = nlohmann::json::array();
+    if (!descriptor_ready) {
+        readiness_issues.push_back({{"severity", "blocking"}, {"detail", "package validation failed: " + descriptor_error}});
+    } else if (!python_initialized) {
+        readiness_issues.push_back(
+            {{"severity", "blocking"},
+             {"detail", "Python interpreter initialization failed" + (python_error.empty() ? std::string{} : ": " + python_error)}});
+    } else if (!loaded) {
+        readiness_issues.push_back({{"severity", "blocking"},
+                                    {"detail", "plugin_loader::load failed" + (load_error.empty() ? std::string{} : ": " + load_error)}});
+    }
+    if (package_valid && python_initialized && loaded && failed_callbacks > 0)
+        readiness_issues.push_back(
+            {{"severity", "warning"},
+             {"detail", std::to_string(failed_callbacks) + " callback(s) failed; see callbacks for the individual records"}});
+
+    const char* readiness_status = (!package_valid || !python_initialized || !loaded) ? "not_ready" :
+                                   failed_callbacks > 0                               ? "degraded" :
+                                                                                        "ready";
+
+    return {
+        {"tool", "orca-plugin-permission-probe"},
+        {"mode", "record-only"},
+        {"observed_by_this_run_only", true},
+        {"plugin",
+         {
+             {"path", options.plugin_path.string()},
+             {"key", observed_plugin},
+         }},
+        {"readiness",
+         {
+             {"status", readiness_status},
+             {"advisory", true},
+             {"checks",
+              {
+                  {"package_valid", package_valid},
+                  {"python_initialized", python_initialized},
+                  {"load_ok", loaded},
+                  {"failed_callback_count", failed_callbacks},
+              }},
+             {"issues", readiness_issues},
+             {"exit_status",
+              {
+                  {"code", loaded ? 0 : 1},
+                  {"semantics", "0 when the plugin loaded, 1 on package validation, initialization or load failure, 2 on a usage error"},
+                  {"driven_by", "load"},
+                  {"note", "Readiness is advisory and does not change the exit status; degraded still exits 0."},
+              }},
+         }},
+        {"package",
+         {
+             {"valid", package_valid},
+             {"metadata_read", descriptor_ready},
+             {"entry_path", entry_path},
+             {"entry_format", package_format(fs::path(entry_path))},
+             {"metadata",
+              {
+                  {"name", descriptor.name},
+                  {"version", descriptor.version},
+                  {"author", descriptor.author},
+                  {"description", descriptor.description},
+                  {"entry_package", descriptor.entry_package},
+              }},
+             {"declared_dependencies", descriptor.dependencies},
+             {"error", descriptor_ready ? std::string{} : descriptor_error},
+             {"installation",
+              {
+                  {"performed", false},
+                  {"dependencies_installed", false},
+                  {"note", "The probe inspects the given package in place; it does not install the package or its dependencies."},
+              }},
+         }},
+        {"environment",
+         {
+             {"python_initialized", python_initialized},
+             {"python_error", python_error},
+             {"temporary_data_dir", data_dir},
+             {"temporary_data_dir_removed_on_exit", true},
+             {"working_directory", data_dir},
+             {"interactive_prompts", false},
+             {"grants_persisted", false},
+         }},
+        {"runtime",
+         {
+             {"python",
+              {
+                  {"initialized", python_initialized},
+                  {"version", python_version},
+              }},
+             {"headless", true},
+             {"gui_initialized", false},
+             {"unavailable_gui_domains", nlohmann::json::array({"orca.host.app", "orca.host.presets", "orca.host.ui", "orca.host.plugin"})},
+             {"gui_domain_behavior",
+              "Attribute access raises an unsupported error; the probe records it as a failed callback when plugin code "
+              "touches the domain."},
+             {"config_api",
+              {
+                  {"get_config", "empty object"},
+                  {"get_config_version", "empty string"},
+                  {"save_config", "refused"},
+                  {"persisted", false},
+              }},
+             {"storage_api",
+              {
+                  {"available", false},
+                  {"detail", "orca.host.plugin.storage() raises an unsupported error because the probe does not start the "
+                             "PluginManager registry."},
+              }},
+         }},
+        {"load", {{"ok", loaded}, {"error", load_error}, {"capabilities", capability_list}}},
+        {"callback_results",
+         {
+             {"records_section", "callbacks"},
+             {"total", callback_records.size()},
+             {"invoked", invoked_callbacks},
+             {"failed", failed_callbacks},
+             {"skipped", skipped_callbacks},
+             {"note", "The callbacks array holds the individual records; this section summarizes them and feeds readiness."},
+         }},
+        {"callbacks", callbacks},
+        {"audit_activity",
+         {
+             {"records_section", "observations"},
+             {"summary_section", "summary"},
+             {"observed_event_count", observed_events.size()},
+             {"category_count", summary["categories"].size()},
+             {"unattributed_event_count", unattributed_events},
+             {"non_continued_event_count", non_continued_events},
+             {"side_effects",
+              {
+                  {"plugin_code_executed", true},
+                  {"installation_performed", false},
+                  {"dependencies_installed", false},
+                  {"grants_persisted", false},
+                  {"filesystem_network_process_contained", false},
+                  {"temporary_data_dir_removed_on_exit", true},
+              }},
+             {"note", "Side effects are the probe's own actions plus what the audit hook observed; only exercised paths are "
+                      "represented."},
+         }},
+        {"observations", observations},
+        {"summary", summary},
+        {"coverage",
+         {
+             {"exhaustive", false},
+             {"sandbox", false},
+             {"plugin_code_executed", true},
+             {"notes",
+              {
+                  "Only the code paths this probe exercised are represented. Audit events cover "
+                  "particular operations, not every Python call.",
+                  "The probe does not start the GUI. Host APIs that require a live application or "
+                  "UI (orca.host.app/presets/ui) and plugin.storage report an explicit unsupported "
+                  "error and are reported as failed callbacks.",
+                  "The probe links libslic3r for core geometry/print types, but not libslic3r_gui "
+                  "or wx.",
+                  "The temporary data directory isolates OrcaSlicer state, not plugin-authored file, "
+                  "network or process access. Use OS-level restrictions for untrusted packages.",
+                  "The loader may extract adjacent .whl dependencies into the package's directory; "
+                  "probe a copy of the package when that side effect is unwanted.",
+                  "Import, registration and on_load share one loader phase; the production loader "
+                  "does not expose a finer boundary without changing its behavior.",
+                  "Callbacks run with synthetic inputs, which can change plugin control flow "
+                  "compared with a real application session.",
+                  "continued=true means the audit hook did not block the operation. A surrounding "
+                  "callback or load step can still fail afterwards, as reported in callbacks/load.",
+                  "Events raised on a plugin-spawned thread carry no phase label and are reported "
+                  "as unattributed.",
+                  "Plugin code can spawn threads/processes, write anywhere this process can, or "
+                  "terminate the process. None of that is contained by the probe.",
+              }},
+         }},
+    };
+}
+
+void print_text_report(const nlohmann::json& report)
+{
+    const auto or_none = [](const std::string& value) { return value.empty() ? std::string("(none)") : value; };
+
+    std::cout << "OrcaSlicer plugin readiness report (record-only)\n"
+                 "WARNING: observational only; not exhaustive and not a sandbox.\n\n";
+    std::cout << "Plugin: " << report["plugin"]["path"].get<std::string>() << "\n";
+    std::cout << "Readiness: " << report["readiness"]["status"].get<std::string>() << " (advisory; exit status follows the load result)\n";
+    for (const auto& issue : report["readiness"]["issues"])
+        std::cout << "  " << issue["severity"].get<std::string>() << ": " << issue["detail"].get<std::string>() << "\n";
+    std::cout << "Python initialized: " << (report["environment"]["python_initialized"].get<bool>() ? "yes" : "no") << "\n";
+    if (!report["environment"]["python_error"].get<std::string>().empty())
+        std::cout << "Python error: " << report["environment"]["python_error"].get<std::string>() << "\n";
+    std::cout << "Load: " << (report["load"]["ok"].get<bool>() ? "ok" : "failed") << "\n";
+    if (!report["load"]["error"].get<std::string>().empty())
+        std::cout << "Load error: " << report["load"]["error"].get<std::string>() << "\n";
+
+    const auto& package = report["package"];
+    std::cout << "\nPackage: valid=" << (package["valid"].get<bool>() ? "yes" : "no")
+              << " format=" << package["entry_format"].get<std::string>() << "\n";
+    std::cout << "  entry: " << package["entry_path"].get<std::string>() << "\n";
+    std::cout << "  name=" << or_none(package["metadata"]["name"].get<std::string>())
+              << " version=" << or_none(package["metadata"]["version"].get<std::string>())
+              << " author=" << or_none(package["metadata"]["author"].get<std::string>()) << "\n";
+    if (!package["metadata"]["entry_package"].get<std::string>().empty())
+        std::cout << "  entry package: " << package["metadata"]["entry_package"].get<std::string>() << "\n";
+    std::cout << "  declared dependencies:";
+    if (package["declared_dependencies"].empty()) {
+        std::cout << " (none)";
+    } else {
+        bool first = true;
+        for (const auto& dependency : package["declared_dependencies"]) {
+            if (!first)
+                std::cout << ", ";
+            std::cout << dependency.get<std::string>();
+            first = false;
+        }
+    }
+    std::cout << "\n  installed: no; the probe does not install the package or its dependencies\n";
+    if (!package["error"].get<std::string>().empty())
+        std::cout << "  package error: " << package["error"].get<std::string>() << "\n";
+
+    const auto& runtime = report["runtime"];
+    std::cout << "\nRuntime: python_version=" << or_none(runtime["python"]["version"].get<std::string>())
+              << " headless=yes gui=not_started\n";
+    std::cout << "  unavailable GUI domains:";
+    {
+        bool first = true;
+        for (const auto& domain : runtime["unavailable_gui_domains"]) {
+            if (!first)
+                std::cout << ", ";
+            std::cout << domain.get<std::string>();
+            first = false;
+        }
+    }
+    std::cout << "\n  config API: returns an empty object, saves are refused, nothing persisted\n";
+    std::cout << "  storage API: unavailable (orca.host.plugin.storage raises)\n";
+
+    std::cout << "\nCapabilities (" << report["load"]["capabilities"].size() << "):\n";
+    for (const auto& capability : report["load"]["capabilities"])
+        std::cout << "  " << capability["name"].get<std::string>() << " [" << capability["type"].get<std::string>()
+                  << "] enabled=" << (capability["enabled"].get<bool>() ? "yes" : "no") << "\n";
+
+    const auto& callback_results = report["callback_results"];
+    std::cout << "\nCallbacks (" << callback_results["total"].get<std::size_t>() << ": " << callback_results["invoked"].get<std::size_t>()
+              << " invoked, " << callback_results["failed"].get<std::size_t>() << " failed, "
+              << callback_results["skipped"].get<std::size_t>() << " skipped)\n";
+    for (const auto& callback : report["callbacks"]) {
+        std::cout << "  " << callback["status"].get<std::string>() << " " << callback["callback"].get<std::string>();
+        if (!callback["capability"].get<std::string>().empty())
+            std::cout << " capability=" << callback["capability"].get<std::string>();
+        if (!callback["detail"].get<std::string>().empty())
+            std::cout << " - " << callback["detail"].get<std::string>();
+        std::cout << "\n";
+    }
+
+    std::cout << "\nObserved audit events (" << report["audit_activity"]["observed_event_count"].get<std::size_t>() << " events, "
+              << report["audit_activity"]["category_count"].get<std::size_t>() << " categories):\n";
+    for (const auto& observation : report["observations"]) {
+        std::cout << "  phase=" << observation["phase"].get<std::string>() << " event=" << observation["event"].get<std::string>()
+                  << " category=" << observation["category"].get<std::string>();
+        if (!observation["capability"].get<std::string>().empty())
+            std::cout << " capability=" << observation["capability"].get<std::string>();
+        if (!observation["targets"].empty()) {
+            std::cout << " targets=";
+            bool first = true;
+            for (const auto& target : observation["targets"]) {
+                if (!first)
+                    std::cout << ",";
+                std::cout << target.get<std::string>();
+                first = false;
+            }
+        }
+        std::cout << " continued=" << (observation["continued"].get<bool>() ? "yes" : "no") << "\n";
+    }
+
+    std::cout << "\nObserved permission categories:\n";
+    for (const auto& [category, detail] : report["summary"]["categories"].items()) {
+        std::cout << "  " << category << ":";
+        for (const auto& event : detail["events"])
+            std::cout << " " << event.get<std::string>();
+        if (!detail["targets"].empty()) {
+            std::cout << " -> ";
+            bool first = true;
+            for (const auto& target : detail["targets"]) {
+                if (!first)
+                    std::cout << ", ";
+                std::cout << target.get<std::string>();
+                first = false;
+            }
+        }
+        std::cout << "\n";
+    }
+    if (report["summary"]["categories"].empty())
+        std::cout << "  (none observed)\n";
+
+    std::cout << "\nObserved side effects: plugin code executed; package and dependencies not installed; no grants persisted; "
+                 "filesystem, network and process access not contained\n";
+    std::cout << "Exit status: " << report["readiness"]["exit_status"]["code"].get<int>() << " (driven by load; readiness is advisory)\n";
+
+    std::cout << "\nCoverage limits:\n";
+    for (const auto& note : report["coverage"]["notes"])
+        std::cout << "  - " << note.get<std::string>() << "\n";
+}
+
+} // namespace
+
+int main(int argc, char** argv)
+{
+    Options options;
+    std::string option_error;
+    if (!parse_options(argc, argv, options, option_error)) {
+        std::cerr << "orca-plugin-probe: " << option_error << "\n\n";
+        print_usage(std::cerr);
+        return 2;
+    }
+
+    boost::system::error_code ec;
+    const fs::path canonical_plugin = fs::weakly_canonical(options.plugin_path, ec);
+    if (!ec)
+        options.plugin_path = canonical_plugin;
+
+    ScopedProbeWorkspace workspace;
+    PluginProbeCollector collector;
+    ScopedObservationObserver observer(collector);
+
+    PluginDescriptor descriptor;
+    std::string descriptor_error;
+    const bool descriptor_ready = prepare_descriptor(options.plugin_path, descriptor, descriptor_error);
+
+    PythonInterpreter& interpreter = PythonInterpreter::instance();
+    bool python_initialized        = false;
+    std::string python_error;
+    if (descriptor_ready) {
+        python_initialized = interpreter.initialize();
+        if (!python_initialized)
+            python_error = interpreter.last_error();
+    }
+
+    if (python_initialized) {
+        try {
+            redirect_python_stdout();
+        } catch (const std::exception& error) {
+            python_error = std::string("Could not redirect Python stdout: ") + error.what();
+        }
+    }
+
+    std::string python_version;
+    if (python_initialized)
+        python_version = query_python_version();
+
+    bool loaded            = false;
+    std::string load_error = descriptor_error;
+    Plugin plugin;
+    std::vector<ProbeCapability> capabilities;
+
+    if (python_initialized && descriptor_ready) {
+        // The outer context covers import, registration and on_load in plugin_loader::load; the
+        // per-callback scopes below cover the follow-up calls. The production loader is unchanged.
+        ScopedPluginAuditContext audit_context(descriptor.plugin_key);
+        {
+            ScopedPluginAuditPhase load_phase(kLoadPhase);
+            loaded = plugin_loader::load(descriptor, /*skip_deps=*/true, /*capabilities_to_enable=*/{}, nullptr, plugin, load_error);
+            collector.record_callback({std::string{}, kLoadPhase, "plugin_loader::load", loaded ? "invoked" : "failed", load_error});
+            collector.record_callback({std::string{}, "callback:on_load", "on_load", loaded ? "invoked" : "skipped",
+                                       loaded ? "invoked by plugin_loader::load for each materialized capability" :
+                                                "plugin_loader::load failed before completing on_load"});
+        }
+
+        capabilities = describe_capabilities(plugin);
+
+        if (loaded)
+            exercise_callbacks(plugin, collector);
+
+        if (loaded) {
+            ScopedPluginAuditPhase unload_phase("callback:on_unload");
+            plugin_loader::unload(plugin);
+            collector.record_callback({std::string{}, "callback:on_unload", "on_unload", "invoked",
+                                       "invoked by plugin_loader::unload; per-capability failures are logged by the loader"});
+        }
+    }
+
+    if (interpreter.is_initialized())
+        interpreter.shutdown();
+
+    const nlohmann::json report = build_report(options, collector, capabilities,
+                                               descriptor.plugin_key.empty() ? make_local_plugin_key(options.plugin_path.stem().string()) :
+                                                                               descriptor.plugin_key,
+                                               descriptor, descriptor_ready, descriptor_error, python_initialized, python_version,
+                                               python_error, loaded, load_error, workspace.root().string());
+
+    if (options.json)
+        std::cout << report.dump(2, ' ', false, nlohmann::json::error_handler_t::replace) << "\n";
+    else
+        print_text_report(report);
+
+    return loaded ? 0 : 1;
+}

src/slic3r/plugin/probe/PluginProbeCollector.hpp

@@ -0,0 +1,97 @@
+#ifndef slic3r_PluginProbeCollector_hpp_
+#define slic3r_PluginProbeCollector_hpp_
+
+// Record-only collection for the headless plugin permission probe. This is deliberately a plain
+// in-memory store: it has no dialog, grant or persistence path, and it never decides whether an
+// audited operation may proceed. Keeping it independent of wx/Python also makes its grouping and
+// phase attribution testable without starting the interpreter.
+
+#include "slic3r/plugin/PluginAuditManager.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <map>
+#include <mutex>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace Slic3r {
+
+// What the probe attempted and what came back. `status` is one of "invoked", "failed" or
+// "skipped"; a skipped callback is reported so the absence of observations is not mistaken for a
+// clean result.
+struct ProbeCallbackRecord
+{
+    std::string capability;
+    std::string phase;
+    std::string callback;
+    std::string status;
+    std::string detail;
+};
+
+class PluginProbeCollector
+{
+public:
+    void record(const AuditObservation& observation)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_observations.push_back(observation);
+    }
+
+    void record_callback(ProbeCallbackRecord record)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_callbacks.push_back(std::move(record));
+    }
+
+    std::vector<AuditObservation> observations() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_observations;
+    }
+
+    std::vector<ProbeCallbackRecord> callbacks() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_callbacks;
+    }
+
+    // Groups the run by the permission categories the audit hook already assigned, and lists the
+    // distinct targets and event names seen in each. This is a view of this run only; it says
+    // nothing about code paths the plugin did not exercise.
+    nlohmann::json summary() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        std::map<std::string, std::set<std::string>> events;
+        std::map<std::string, std::set<std::string>> targets;
+        for (const AuditObservation& observation : m_observations) {
+            events[observation.category].insert(observation.event_name);
+            targets[observation.category].insert(observation.targets.begin(), observation.targets.end());
+        }
+
+        nlohmann::json categories = nlohmann::json::object();
+        for (const auto& [category, category_events] : events) {
+            categories[category] = {
+                {"events", category_events},
+                {"targets", targets[category]},
+            };
+        }
+
+        return {
+            {"observed_event_count", m_observations.size()},
+            {"categories", categories},
+        };
+    }
+
+private:
+    mutable std::mutex m_mutex;
+    std::vector<AuditObservation> m_observations;
+    std::vector<ProbeCallbackRecord> m_callbacks;
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_PluginProbeCollector_hpp_

src/slic3r/plugin/probe/PluginProbeConfig.cpp

@@ -0,0 +1,32 @@
+// Minimal replacement for the config API PythonPluginBridge binds into `orca`.
+//
+// The production implementation (PluginConfig.cpp) resolves presets, reads the sidebar's effective
+// config and writes config.json through PluginManager, all of which pull in the GUI and the
+// registry. The probe has neither: a capability reports an empty config, an empty version and a
+// refused save. That keeps the bridge's Python surface intact without pretending to reproduce
+// application state the probe does not have.
+
+#include "slic3r/plugin/PluginConfig.hpp"
+#include "slic3r/plugin/PythonPluginInterface.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <string>
+
+namespace Slic3r {
+
+nlohmann::json capability_get_config(const PluginCapabilityInterface&)
+{
+    return nlohmann::json::object();
+}
+
+std::string capability_get_config_version(const PluginCapabilityInterface&) { return {}; }
+
+bool capability_save_config(const PluginCapabilityInterface&, const nlohmann::json&) { return false; }
+
+std::string PluginConfig::capability_type_label(PluginCapabilityType type)
+{
+    return plugin_capability_type_display_name(type);
+}
+
+} // namespace Slic3r

tests/fff_print/test_gcode.cpp

@@ -4,7 +4,6 @@
 #include <catch2/catch_message.hpp>
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Config.hpp"
-#include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/ModelArrange.hpp"
 #include "libslic3r/Print.hpp"
@@ -90,28 +89,6 @@ TEST_CASE("The exclude object tolerance defaults to the former fixed 0.1 mm", "[
                Catch::Matchers::WithinAbs(0.1, 1e-9));
 }
 
-TEST_CASE("The filament flow ratio scales the extruded length once", "[GCode]")
-{
-    // Retraction off, so every positive relative E move is extrusion and scales with the ratio.
-    auto extruded_length = [](double flow_ratio) {
-        DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-        config.set_deserialize_strict({ { "use_relative_e_distances", "1" }, { "retraction_length", "0" }, { "wipe", "0" } });
-        config.set_key_value("filament_flow_ratio", new ConfigOptionFloatsNullable{ flow_ratio });
-        double total = 0.;
-        GCodeReader reader;
-        reader.parse_buffer(Test::slice({ Test::cube(20) }, config),
-                            [&](GCodeReader &, const GCodeReader::GCodeLine &line) {
-                                if ((line.cmd_is("G1") || line.cmd_is("G2") || line.cmd_is("G3")) && line.has_e() && line.e() > 0.f)
-                                    total += line.e();
-                            });
-        return total;
-    };
-
-    const double full = extruded_length(1.);
-    REQUIRE(full > 0.);
-    CHECK_THAT(extruded_length(0.9) / full, Catch::Matchers::WithinRel(0.9, 1e-3));
-}
-
 // Firmwares read the compatibility header lines (Anycubic's GoKlipper heats the bed with
 // first_layer_bed_temperature), so they must describe the filament the plate prints, not filament 1.
 TEST_CASE("The G-code header names the first layer temperatures of the filament the plate prints", "[GCode]")

tests/fff_print/test_print.cpp

@@ -22,7 +22,6 @@
 #include "libslic3r/TriangleMesh.hpp"
 #include <catch2/matchers/catch_matchers.hpp>
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <catch2/matchers/catch_matchers_string.hpp>
 
 #include <catch2/catch_all.hpp>
 
@@ -547,31 +546,6 @@ TEST_CASE("Print::validate tolerates a null warnings pointer", "[Print][validate
     CHECK(err.string.empty());
 }
 
-TEST_CASE("Print::validate refuses a used filament with a flow ratio of 0", "[Print][validate][Regression]")
-{
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_key_value("filament_flow_ratio", new ConfigOptionFloatsNullable{ 0. });
-
-    std::vector<StringObjectException> warnings;
-    StringObjectException err = validate_cubes(config, warnings);
-
-    CHECK_FALSE(err.string.empty());
-    CHECK_FALSE(err.is_warning);
-    CHECK(err.opt_key == "filament_flow_ratio");
-}
-
-TEST_CASE("Print::validate ignores a flow ratio of 0 on an unused filament", "[Print][validate]")
-{
-    // The cube prints with filament 1, so filament 2's ratio is never used.
-    DynamicPrintConfig config = multifilament_config(2, { { "filament_self_index", "1,2" } });
-    config.set_key_value("filament_flow_ratio", new ConfigOptionFloatsNullable{ 1., 0. });
-
-    std::vector<StringObjectException> warnings;
-    StringObjectException err = validate_cubes(config, warnings);
-
-    CHECK(err.string.empty());
-}
-
 TEST_CASE("Purge tower selection keeps ordinary printers on the classic path", "[Print][PurgeTower][Regression]")
 {
     DynamicPrintConfig config = multifilament_config(2, {
@@ -820,20 +794,6 @@ TEST_CASE("Print statistics in custom G-code match the final print statistics",
     }
 }
 
-TEST_CASE("Print statistics in custom G-code cannot be used in a calculation", "[Print]")
-{
-    const std::string key = GENERATE(as<std::string>{}, "total_weight", "used_filament", "total_cost", "print_time", "normal_print_time",
-                                     "silent_print_time", "total_wipe_tower_cost", "total_wipe_tower_filament", "print_time_total_sec",
-                                     "print_time_day", "print_time_hour", "print_time_minute", "print_time_sec", "used_filament_length");
-    CAPTURE(key);
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_deserialize_strict({ { "file_start_gcode", "; {" + key + " + 1}\n" } });
-    Print print;
-    Model model;
-    init_print({ cube(20) }, print, model, config);
-    CHECK_THROWS_WITH(Slic3r::Test::gcode(print), Catch::Matchers::ContainsSubstring("known only after the G-code is generated"));
-}
-
 TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
 {
     Print print;

tests/libslic3r/CMakeLists.txt

@@ -42,7 +42,6 @@ add_executable(${_TEST_NAME}_tests
     test_fill_plane_path.cpp
     test_adaptive_infill_field.cpp
     test_geometry.cpp
-    test_kdtree.cpp
     test_imex_arrange.cpp
     test_imex_helpers.cpp
     test_imex_zones.cpp

tests/libslic3r/test_clipper_utils.cpp

@@ -7,18 +7,12 @@
 #include "libslic3r/libslic3r.h"
 #include <numeric>
 #include <iostream>
-#include <utility>
 #include <boost/filesystem.hpp>
 #include <utility>
 #include <vector>
-#include <cstdlib>
-#include <optional>
 
 #include <catch2/catch_test_macros.hpp>
-#include <catch2/generators/catch_generators.hpp>
 #include <catch2/catch_approx.hpp>
-#include <catch2/matchers/catch_matchers.hpp>
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Point.hpp"
@@ -306,331 +300,3 @@ TEST_CASE("Top level expolygons of an even-odd union", "[ClipperUtils]") {
     REQUIRE(area_sum == Catch::Approx(area(top_level) + area(nested)));
     REQUIRE(top_level_expolygons(reference).size() == 1);
 }
-
-// Rings flattened to x,y,x,y... and sorted, with each ring rotated to start at its lowest point: two
-// encodings of the same geometry compare equal however the pieces came back or wherever a ring started.
-static std::vector<std::vector<coord_t>> canonical_rings(const ExPolygons &expolygons)
-{
-    std::vector<std::vector<coord_t>> rings;
-    const auto add = [&rings](const Polygon &poly) {
-        if (poly.points.empty())
-            return;
-        Points pts = poly.points;
-        std::rotate(pts.begin(),
-                    std::min_element(pts.begin(), pts.end(), [](const Point &a, const Point &b) {
-                        return std::make_pair(a.x(), a.y()) < std::make_pair(b.x(), b.y());
-                    }),
-                    pts.end());
-        std::vector<coord_t> flat;
-        flat.reserve(pts.size() * 2);
-        for (const Point &p : pts) {
-            flat.emplace_back(p.x());
-            flat.emplace_back(p.y());
-        }
-        rings.emplace_back(std::move(flat));
-    };
-    for (const ExPolygon &expoly : expolygons) {
-        add(expoly.contour);
-        for (const Polygon &hole : expoly.holes)
-            add(hole);
-    }
-    std::sort(rings.begin(), rings.end());
-    return rings;
-}
-
-// The same rings, every coordinate within `tolerance`.
-static bool same_rings(const ExPolygons &a, const ExPolygons &b, coord_t tolerance)
-{
-    const std::vector<std::vector<coord_t>> ra = canonical_rings(a), rb = canonical_rings(b);
-    return std::equal(ra.begin(), ra.end(), rb.begin(), rb.end(), [tolerance](const std::vector<coord_t> &x, const std::vector<coord_t> &y) {
-        return std::equal(x.begin(), x.end(), y.begin(), y.end(), [tolerance](coord_t u, coord_t v) { return std::abs(u - v) <= tolerance; });
-    });
-}
-
-TEST_CASE("Tiled diff and intersection return the same polygons as the plain calls", "[ClipperUtils]") {
-    // A grid of disjoint framed squares, enough of them to be split into several tiles.
-    const int  n    = 40;
-    const coord_t cell = scaled<coord_t>(2.), side = scaled<coord_t>(1.5), frame = scaled<coord_t>(0.3);
-    ExPolygons subject;
-    for (int y = 0; y < n; ++ y)
-        for (int x = 0; x < n; ++ x) {
-            const Point o(x * cell, y * cell);
-            ExPolygon square(Polygon({ o, o + Point(side, 0), o + Point(side, side), o + Point(0, side) }));
-            Polygon hole({ o + Point(frame, frame), o + Point(frame, side - frame), o + Point(side - frame, side - frame), o + Point(side - frame, frame) });
-            square.holes.emplace_back(std::move(hole));
-            subject.emplace_back(std::move(square));
-        }
-    // Clip polygons crossing many squares, one of them large with holes of its own.
-    Polygons clip;
-    const coord_t span = n * cell;
-    for (int i = 0; i < 8; ++ i) {
-        const coord_t y0 = coord_t(i) * span / 8, y1 = y0 + scaled<coord_t>(0.9);
-        clip.emplace_back(Polygon({ Point(- cell, y0), Point(span, y0 + cell * 3), Point(span, y1 + cell * 3), Point(- cell, y1) }));
-    }
-    ExPolygon big(Polygon({ Point(span / 4, span / 4), Point(3 * span / 4, span / 4), Point(3 * span / 4, 3 * span / 4), Point(span / 4, 3 * span / 4) }));
-    for (int i = 0; i < 4; ++ i) {
-        const Point o(span / 4 + scaled<coord_t>(3.1) + i * scaled<coord_t>(9.7), span / 4 + scaled<coord_t>(5.3));
-        big.holes.emplace_back(Polygon({ o, o + Point(0, scaled<coord_t>(20.)), o + Point(scaled<coord_t>(5.), scaled<coord_t>(20.)), o + Point(scaled<coord_t>(5.), 0) }));
-    }
-    polygons_append(clip, to_polygons(big));
-
-    const ApplySafetyOffset safety = GENERATE(ApplySafetyOffset::No, ApplySafetyOffset::Yes);
-
-    // The point of the fixture: below 128 pieces the helpers fall back to a single tile and the tiled
-    // path under test is never taken.
-    REQUIRE(ClipperUtils::tile_expolygons(subject, 32).size() > 1);
-
-    // With the safety offset a tile unites fewer clip polygons, so Clipper2 can round a crossing 1 unit differently.
-    const coord_t tolerance = safety == ApplySafetyOffset::Yes ? 1 : 0;
-
-    const ExPolygons diff_plain = diff_ex(subject, clip, safety);
-    const ExPolygons diff_tiled = diff_ex_by_piece(subject, clip, safety);
-    REQUIRE(area(diff_plain) > 0.);
-    CHECK(same_rings(diff_tiled, diff_plain, tolerance));
-
-    const ExPolygons intersection_plain = intersection_ex(subject, clip, safety);
-    const ExPolygons intersection_tiled = intersection_ex_by_piece(subject, clip, safety);
-    REQUIRE(area(intersection_plain) > 0.);
-    CHECK(same_rings(intersection_tiled, intersection_plain, tolerance));
-}
-
-// An outline with a small clockwise hole well inside it, cut along its edge by three clip polygons that never reach the
-// hole. Clipper2 puts the hole at the top level of its PolyTree, beside the outline rather than under it. The coordinates
-// come from a sliced layer reduced to the few paths that still do this; most changes to them don't.
-static const Polygons misnesting_subject{
-    Polygon({ { 23000000, 31000000 }, { 7500000, 25900000 }, { 200000, 26450004 }, { 0, 26450004 }, { 0, 26550004 },
-              { -100000, 26550004 }, { -300000, 26600000 }, { 13000000, 0 } }),
-    Polygon({ { 10200000, 24250000 }, { 10500000, 24250000 }, { 9800000, 24000000 } }),
-    Polygon({ { 4500000, 22500000 }, { 5000000, 22000000 }, { 4000000, 22000000 } }),
-};
-static const Polygons misnesting_clip{
-    Polygon({ { 0, 26550004 }, { -200000, 26550004 }, { -200000, 26000000 } }),
-    Polygon({ { 0, 26450004 }, { 100000, 26450004 }, { 0, 26000000 } }),
-    Polygon({ { 10000000, 24000000 }, { 10199999, 24250000 }, { 10500000, 24250000 }, { 8000000, 26500000 } }),
-};
-
-// The case above inside a frame, a square outline with a square hole around the case, and with an island in its hole.
-// Clipper2 then puts the hole beside the outline inside the frame's hole, where the frame and the outline both enclose
-// it, and the island under the misplaced hole.
-static Polygons misnesting_framed_subject()
-{
-    Polygons subject = misnesting_subject;
-    subject.emplace_back(Polygon({ { -2000000, -2000000 }, { 25000000, -2000000 }, { 25000000, 33000000 }, { -2000000, 33000000 } }));
-    subject.emplace_back(Polygon({ { -1000000, -1000000 }, { -1000000, 32000000 }, { 24000000, 32000000 }, { 24000000, -1000000 } }));
-    subject.emplace_back(Polygon({ { 4400000, 22100000 }, { 4600000, 22100000 }, { 4500000, 22300000 } }));
-    return subject;
-}
-// In the hole of the framed case, beside its island.
-static const Point in_framed_hole(4500000, 22400000);
-// In the island of the framed case.
-static const Point in_framed_island(4500000, 22150000);
-
-static void check_orientation(const ExPolygons &expolygons)
-{
-    for (const ExPolygon &expoly : expolygons) {
-        CHECK(expoly.contour.is_counter_clockwise());
-        for (const Polygon &hole : expoly.holes)
-            CHECK(hole.is_clockwise());
-    }
-}
-
-// How many of the expolygons contain the point, each on its own, as a per-piece operation sees them.
-static size_t pieces_containing(const ExPolygons &expolygons, const Point &pt)
-{
-    return std::count_if(expolygons.begin(), expolygons.end(), [&pt](const ExPolygon &expoly) { return expoly.contains(pt); });
-}
-
-TEST_CASE("Every hole of a boolean result belongs to the expolygon around it", "[ClipperUtils]") {
-    const Polygon &hole = misnesting_subject.back();
-    REQUIRE(hole.is_clockwise());
-    const ExPolygons result = diff_ex(misnesting_subject, misnesting_clip);
-    check_orientation(result);
-    CHECK(pieces_containing(result, hole.centroid()) == 0);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(misnesting_subject, misnesting_clip)), 1e-9));
-}
-
-TEST_CASE("A misplaced hole goes to the innermost contour around it, an island in it stays filled", "[ClipperUtils]") {
-    const Polygons   subject = misnesting_framed_subject();
-    const ExPolygons result  = diff_ex(subject, misnesting_clip);
-    check_orientation(result);
-    // Given to the frame instead of the outline, the hole would leave the outline covering it.
-    CHECK(pieces_containing(result, in_framed_hole) == 0);
-    CHECK(pieces_containing(result, in_framed_island) == 1);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, misnesting_clip)), 1e-9));
-}
-
-TEST_CASE("A misplaced hole touching the contour around it goes to that contour", "[ClipperUtils]") {
-    // The first two vertices of the hole the subject's triangle cuts round a fraction of a unit outside the outline, the
-    // third is well inside it. Reduced from a sliced layer; Clipper2 puts the hole at the top level of its PolyTree.
-    const Polygons subject{
-        Polygon({ { 1000000, 5000000 }, { 1000000, 4000000 }, { 6000000, 0 } }),
-        Polygon({ { 1024999, 4500000 }, { 1100011, 4574998 }, { 1100011, 4450000 } }),
-    };
-    const Polygons clip{
-        Polygon({ { 1500000, 5000000 }, { 1062508, 4612507 }, { 1212486, 4462504 } }),
-        Polygon({ { 1100000, 4430000 }, { 1024998, 4500001 }, { 2000000, 3000000 } }),
-    };
-    const ExPolygons result = diff_ex(subject, clip);
-    check_orientation(result);
-    CHECK(pieces_containing(result, subject.back().centroid()) == 0);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, clip)), 1e-9));
-}
-
-TEST_CASE("A misplaced island comes out as an expolygon of its own", "[ClipperUtils]") {
-    // Clipper2 puts the island of this result directly under the outer contour, at the level of its holes, instead of
-    // under the hole around it. Reduced from a sliced layer.
-    const Polygons subject{
-        Polygon({ { 5200000, 700000 }, { 0, 5000000 }, { 0, 0 } }),
-        Polygon({ { 3100000, 825000 }, { 3250000, 900001 }, { 3250000, 1000000 }, { 4000000, 1500000 }, { 3000000, 500000 } }),
-    };
-    const Polygons clip{
-        Polygon({ { 4500000, 1200000 }, { 4000000, 1000000 }, { 5000000, 800000 } }),
-        Polygon({ { 3250000, 900001 }, { 3250000, 1000000 }, { 3000000, 1000000 }, { 3500000, 1100000 }, { 3100000, 1000000 }, { 3183343, 866672 } }),
-        Polygon({ { 4000000, 1000000 }, { 4000000, 1000000 }, { 4000000, 1000000 } }),
-    };
-    const ExPolygons result = diff_ex(subject, clip);
-    check_orientation(result);
-    // In the island.
-    CHECK(pieces_containing(result, Point(3230000, 1020000)) == 1);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, clip)), 1e-9));
-}
-
-TEST_CASE("Nested islands of an even-odd union keep their misplaced holes", "[ClipperUtils]") {
-    // The framed case as one even-odd union: the frame is the top level, everything in its hole is nested, and Clipper2
-    // puts the case's hole beside the outline among the nested islands.
-    ExPolygons input;
-    for (const Polygon &polygon : misnesting_framed_subject())
-        input.emplace_back(polygon);
-    for (const Polygon &polygon : misnesting_clip)
-        input.emplace_back(polygon);
-    ExPolygons       nested;
-    const ExPolygons top_level = top_level_expolygons(input, &nested);
-    REQUIRE(top_level.size() == 1);
-    check_orientation(nested);
-    CHECK(pieces_containing(nested, in_framed_hole) == 0);
-    CHECK(pieces_containing(nested, in_framed_island) == 1);
-}
-
-TEST_CASE("Loops chained outside in keep their nesting where Clipper2 misplaces one", "[ClipperUtils]") {
-    // An even-odd union of the case's paths leaves the hole at the top level of the PolyTree, among the outer loops.
-    Polygons loops = misnesting_subject;
-    polygons_append(loops, misnesting_clip);
-    const Polygons chained = union_pt_chained_outside_in(loops);
-    REQUIRE(chained.size() == 7);
-    for (const Polygon &loop : chained)
-        CHECK(loop.is_counter_clockwise());
-    // The hole's loop comes right after the outline's, which has no other loop inside it.
-    const auto outline = std::max_element(chained.begin(), chained.end(), [](const Polygon &a, const Polygon &b) { return a.area() < b.area(); });
-    REQUIRE(outline + 1 != chained.end());
-    CHECK((outline + 1)->area() == Catch::Approx(- misnesting_subject.back().area()));
-}
-
-TEST_CASE("A misplaced hole hugging an island inside it still goes to the outline", "[ClipperUtils]") {
-    // The case's hole with an island filling most of it, 20 units from it: the hole's vertices all lie close to the
-    // island and its middle inside it, yet the island is inside the hole, not around it.
-    Polygons subject = misnesting_subject;
-    subject.emplace_back(Polygon({ { 4000020, 22000010 }, { 4500000, 22150000 }, { 4999980, 22000010 },
-                                   { 4650000, 22160000 }, { 4500000, 22499980 }, { 4350000, 22160000 } }));
-    const ExPolygons result = diff_ex(subject, misnesting_clip);
-    check_orientation(result);
-    // In the hole below the island, and in the island.
-    CHECK(pieces_containing(result, Point(4500000, 22050000)) == 0);
-    CHECK(pieces_containing(result, Point(4500000, 22300000)) == 1);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, misnesting_clip)), 1e-9));
-}
-
-TEST_CASE("A concave misplaced hole touching the outline at every vertex goes to it", "[ClipperUtils]") {
-    // The case with the outline drawn in to two more vertices and the hole replaced by a concave pentagon, each of its
-    // vertices within 3 units of the outline; the middle of its bounding box is outside both.
-    Polygons subject = misnesting_subject;
-    subject.front().points.insert(subject.front().points.end(), { { 7000000, 20000000 }, { 20000000, 22000000 } });
-    subject.back() = Polygon({ { 1500002, 22999999 }, { 20333332, 22999999 }, { 19999999, 22000001 }, { 6999998, 20000001 }, { 12999995, 13 } });
-    const ExPolygons result = diff_ex(subject, misnesting_clip);
-    check_orientation(result);
-    CHECK(pieces_containing(result, Point(10000000, 22500000)) == 0);
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, misnesting_clip)), 1e-9));
-}
-
-TEST_CASE("A point strictly inside a polygon, where there is one", "[ClipperUtils]") {
-    // A notch with a horizontal edge at the middle of its bounding box, so a line through that middle runs along the edge;
-    // two lobes joined by a one unit neck and a square with a one unit spike, where the widest band between vertex heights
-    // runs through the thin part.
-    const Polygons wide{
-        Polygon({ { 0, 0 }, { 2000000, 0 }, { 2000000, 5000000 }, { 8000000, 5000000 }, { 8000000, 0 }, { 10000000, 0 },
-                  { 10000000, 10000000 }, { 0, 10000000 } }),
-        Polygon({ { 0, 0 }, { 100, 0 }, { 100, 5 }, { 51, 5 }, { 51, 25 }, { 100, 25 }, { 100, 30 }, { 0, 30 }, { 0, 25 },
-                  { 50, 25 }, { 50, 5 }, { 0, 5 } }),
-        Polygon({ { 0, 0 }, { 1000000, 0 }, { 1000000, 1000000 }, { 500001, 1000000 }, { 500001, 5000000 }, { 500000, 5000000 },
-                  { 500000, 1000000 }, { 0, 1000000 } }),
-    };
-    for (Polygon polygon : wide)
-        for (int winding = 0; winding < 2; ++ winding, polygon.reverse()) {
-            const std::optional<Point> pt = ClipperUtils::interior_point(polygon);
-            REQUIRE(pt);
-            CHECK(contains(polygon, *pt, false));
-        }
-    // One unit thick everywhere, these hold no grid point strictly inside: a strip, and rows one unit high joined at the
-    // left.
-    CHECK_FALSE(ClipperUtils::interior_point(Polygon({ { 0, 0 }, { 1000, 0 }, { 1000, 1 }, { 0, 1 } })));
-    Polygon rows({ { 0, 0 }, { 100, 0 } });
-    for (coord_t y = 1; y < 100; y += 2)
-        rows.points.insert(rows.points.end(), { { 100, y }, { 1, y }, { 1, y + 1 }, { 100, y + 1 } });
-    rows.points.emplace_back(0, 100);
-    CHECK_FALSE(ClipperUtils::interior_point(rows));
-}
-
-TEST_CASE("A correctly nested result converts in the order of its tree", "[ClipperUtils]") {
-    // Two squares, one with a hole holding an island, the other with two holes and a corner cut off. Clipper2 nests this
-    // correctly, so the expolygons follow its tree, each path as Clipper2 returned it: an outline with its holes in tree
-    // order, then the islands of those holes, outline by outline.
-    const Polygons subject{
-        Polygon({ { 0, 0 }, { 10000000, 0 }, { 10000000, 10000000 }, { 0, 10000000 } }),
-        Polygon({ { 2000000, 2000000 }, { 2000000, 8000000 }, { 8000000, 8000000 }, { 8000000, 2000000 } }),
-        Polygon({ { 4000000, 4000000 }, { 6000000, 4000000 }, { 6000000, 6000000 }, { 4000000, 6000000 } }),
-        Polygon({ { 20000000, 0 }, { 32000000, 0 }, { 32000000, 12000000 }, { 20000000, 12000000 } }),
-        Polygon({ { 21000000, 1000000 }, { 21000000, 4000000 }, { 24000000, 4000000 }, { 24000000, 1000000 } }),
-        Polygon({ { 26000000, 6000000 }, { 26000000, 10000000 }, { 30000000, 10000000 }, { 30000000, 6000000 } }),
-    };
-    const Polygons clip{ Polygon({ { 31000000, -1000000 }, { 33000000, -1000000 }, { 33000000, 1000000 }, { 31000000, 1000000 } }) };
-    ExPolygons expected(3);
-    expected[0].contour = Polygon({ { 31000000, 1000000 }, { 32000000, 1000000 }, { 32000000, 12000000 }, { 20000000, 12000000 },
-                                    { 20000000, 0 }, { 31000000, 0 } });
-    expected[0].holes   = { Polygon({ { 26000000, 10000000 }, { 30000000, 10000000 }, { 30000000, 6000000 }, { 26000000, 6000000 } }),
-                            Polygon({ { 21000000, 4000000 }, { 24000000, 4000000 }, { 24000000, 1000000 }, { 21000000, 1000000 } }) };
-    expected[1].contour = Polygon({ { 10000000, 10000000 }, { 0, 10000000 }, { 0, 0 }, { 10000000, 0 } });
-    expected[1].holes   = { Polygon({ { 2000000, 8000000 }, { 8000000, 8000000 }, { 8000000, 2000000 }, { 2000000, 2000000 } }) };
-    expected[2].contour = Polygon({ { 6000000, 6000000 }, { 4000000, 6000000 }, { 4000000, 4000000 }, { 6000000, 4000000 } });
-    CHECK(diff_ex(subject, clip) == expected);
-}
-
-TEST_CASE("Loops of a correctly nested union chain in the order of its tree", "[ClipperUtils]") {
-    // Three nested squares and two more beside them, as concentric fill hands them over: chained outside in, depth first,
-    // each loop as Clipper2 returned it, the holes reversed to run counter-clockwise.
-    const Polygons loops{
-        Polygon({ { 0, 0 }, { 10000000, 0 }, { 10000000, 10000000 }, { 0, 10000000 } }),
-        Polygon({ { 1000000, 1000000 }, { 9000000, 1000000 }, { 9000000, 9000000 }, { 1000000, 9000000 } }),
-        Polygon({ { 2000000, 2000000 }, { 8000000, 2000000 }, { 8000000, 8000000 }, { 2000000, 8000000 } }),
-        Polygon({ { 20000000, 0 }, { 32000000, 0 }, { 32000000, 12000000 }, { 20000000, 12000000 } }),
-        Polygon({ { 21000000, 1000000 }, { 31000000, 1000000 }, { 31000000, 11000000 }, { 21000000, 11000000 } }),
-    };
-    const Polygons expected{
-        Polygon({ { 10000000, 10000000 }, { 0, 10000000 }, { 0, 0 }, { 10000000, 0 } }),
-        Polygon({ { 9000000, 1000000 }, { 9000000, 9000000 }, { 1000000, 9000000 }, { 1000000, 1000000 } }),
-        Polygon({ { 8000000, 8000000 }, { 2000000, 8000000 }, { 2000000, 2000000 }, { 8000000, 2000000 } }),
-        Polygon({ { 32000000, 12000000 }, { 20000000, 12000000 }, { 20000000, 0 }, { 32000000, 0 } }),
-        Polygon({ { 31000000, 1000000 }, { 31000000, 11000000 }, { 21000000, 11000000 }, { 21000000, 1000000 } }),
-    };
-    CHECK(union_pt_chained_outside_in(loops) == expected);
-}
-
-TEST_CASE("A clockwise sliver with nothing around it comes back as Clipper2 returned it", "[ClipperUtils]") {
-    // Rounding leaves a clockwise sliver of half a square unit beside the result's one piece, outside it. Reduced from a
-    // sliced layer. It is no hole of anything, so it stays a contour of its own, neither dropped nor given to the piece.
-    const Polygons subject{ Polygon({ { 875000, 200000 }, { 900002, 175002 }, { 950001, 150004 } }) };
-    const Polygons clip{ Polygon({ { 879409, 185299 }, { 950000, 150004 }, { 1000000, 200000 } }) };
-    const ExPolygons result = diff_ex(subject, clip);
-    REQUIRE(result.size() == 2);
-    CHECK(std::count_if(result.begin(), result.end(), [](const ExPolygon &expoly) { return expoly.contour.is_clockwise() && expoly.holes.empty(); }) == 1);
-    CHECK(std::all_of(result.begin(), result.end(), [](const ExPolygon &expoly) { return expoly.holes.empty(); }));
-    CHECK_THAT(area(result), Catch::Matchers::WithinRel(area(diff(subject, clip)), 1e-9));
-}

tests/libslic3r/test_kdtree.cpp

@@ -1,72 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <numeric>
-#include <random>
-#include <vector>
-#include <algorithm>
-#include <cstddef>
-
-#include <catch2/catch_test_macros.hpp>
-#include <catch2/generators/catch_generators.hpp>
-
-#include "libslic3r/KDTreeIndirect.hpp"
-#include "libslic3r/Point.hpp"
-
-using namespace Slic3r;
-
-TEST_CASE("Visiting the nearby points gives what collecting them gives", "[KDTree]") {
-    std::mt19937                          rng(19937);
-    std::uniform_real_distribution<float> coord(-50.f, 50.f);
-    // Points in a box, so that a radius search returns anything from none of them to all of them.
-    std::vector<Vec3f> points(2000);
-    for (Vec3f &p : points)
-        p = Vec3f(coord(rng), coord(rng), coord(rng));
-
-    auto coordinate = [&points](size_t idx, size_t dimension) { return points[idx](int(dimension)); };
-    KDTreeIndirect<3, float, decltype(coordinate)> tree(coordinate);
-    std::vector<size_t> indices(points.size());
-    std::iota(indices.begin(), indices.end(), 0);
-    tree.build(indices);
-
-    const float radius = GENERATE(0.5f, 5.f, 25.f, 200.f);
-    for (int i = 0; i < 20; ++ i) {
-        const Vec3f center(coord(rng), coord(rng), coord(rng));
-
-        const std::vector<size_t> collected = find_nearby_points(tree, center, radius);
-        std::vector<size_t>       visited;
-        visit_nearby_points(tree, center, radius, [&visited](size_t idx) { visited.emplace_back(idx); });
-
-        // Same points, and in the same order: a caller that keeps the first of several equally good ones
-        // must get the same answer either way.
-        REQUIRE(visited == collected);
-    }
-}
-
-TEST_CASE("A radius search returns every point within the radius and no other", "[KDTree]") {
-    std::mt19937                          rng(2024);
-    std::uniform_real_distribution<float> coord(-20.f, 20.f);
-    std::vector<Vec3f> points(500);
-    for (Vec3f &p : points)
-        p = Vec3f(coord(rng), coord(rng), coord(rng));
-
-    auto coordinate = [&points](size_t idx, size_t dimension) { return points[idx](int(dimension)); };
-    KDTreeIndirect<3, float, decltype(coordinate)> tree(coordinate);
-    std::vector<size_t> indices(points.size());
-    std::iota(indices.begin(), indices.end(), 0);
-    tree.build(indices);
-
-    const Vec3f center(1.f, -2.f, 3.f);
-    const float radius = 7.f;
-
-    std::vector<size_t> expected;
-    for (size_t i = 0; i < points.size(); ++ i)
-        if ((points[i] - center).squaredNorm() < radius * radius)
-            expected.emplace_back(i);
-
-    std::vector<size_t> visited;
-    visit_nearby_points(tree, center, radius, [&visited](size_t idx) { visited.emplace_back(idx); });
-    std::sort(visited.begin(), visited.end());
-
-    REQUIRE(! expected.empty());
-    REQUIRE(visited == expected);
-}

tests/libslic3r/test_placeholder_parser.cpp

@@ -5,7 +5,6 @@
 
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>
-#include <catch2/catch_message.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
 #include <catch2/matchers/catch_matchers_string.hpp>
 #include "libslic3r/PlaceholderParser.hpp"
@@ -399,53 +398,3 @@ SCENARIO("Placeholder parser names in branches that are not taken", "[Placeholde
         CHECK(PlaceholderParser::evaluate_boolean_expression("false ? no_such_var == 1 : true", config));
     }
 }
-
-TEST_CASE("Placeholder parser deferred values can be printed but not computed with", "[PlaceholderParser]") {
-    PlaceholderParser parser;
-    parser.set_deferred("total_weight", "@TOTAL_WEIGHT@");
-    parser.set_deferred("used_filament", "@USED_FILAMENT_LENGTH@");
-    parser.set("label", "W");
-    PlaceholderParser::ContextData context;
-    context.global_config = std::make_unique<DynamicConfig>();
-    auto process = [&parser, &context](const std::string &templ) { return parser.process(templ, 0, nullptr, nullptr, &context); };
-
-    SECTION("printed") {
-        CHECK(process("{total_weight}") == "@TOTAL_WEIGHT@");
-        CHECK(process("[total_weight]") == "@TOTAL_WEIGHT@");
-        CHECK(process("{label + \": \" + total_weight + \"g\"}") == "W: @TOTAL_WEIGHT@g");
-        CHECK(process("{total_weight + \"g, \" + used_filament + \"m\"}") == "@TOTAL_WEIGHT@g, @USED_FILAMENT_LENGTH@m");
-        CHECK(process("{\"W \" + total_weight + \"g for \" + 3 + \" parts\"}") == "W @TOTAL_WEIGHT@g for 3 parts");
-        CHECK(process("{true ? total_weight : 0}") == "@TOTAL_WEIGHT@");
-        CHECK(process("{regex_replace(\"x\", /x/, total_weight)}") == "@TOTAL_WEIGHT@");
-        CHECK(process("{local w = total_weight}{w}") == "@TOTAL_WEIGHT@");
-    }
-    SECTION("used in a calculation or a comparison") {
-        const auto deferred_error = Catch::Matchers::ContainsSubstring("known only after the G-code is generated");
-        for (const std::string templ : {
-                 "{total_weight + 1}", "{1 + total_weight}", "{total_weight * 2}", "{-total_weight}", "{int(total_weight)}",
-                 "{min(total_weight, 5)}", "{digits(total_weight, 5)}", "{total_weight + used_filament}",
-                 "{if total_weight > 100}heavy{endif}", "{if total_weight == \"1\"}one{endif}", "{total_weight and true}",
-                 "{total_weight ? 1 : 0}", "{if total_weight =~ /1.*/}one{endif}", "{one_of(total_weight, \"1\")}",
-                 "{regex_replace(total_weight, /1/, \"2\")}", "{(\"W\" + total_weight) == \"W1\"}", "{filament_change(total_weight)}",
-                 "{regex_replace(\"x\", /x/, total_weight) * 2}", "{if regex_replace(\"x\", /x/, \"W\" + total_weight) > \"W1\"}heavy{endif}",
-                 // A deferred value copied to a variable is still deferred.
-                 "{local w = total_weight}{w > 1}", "{global g = \"W\" + total_weight}{if g == \"W1\"}one{endif}" }) {
-            CAPTURE(templ);
-            CHECK_THROWS_WITH(process(templ), deferred_error);
-        }
-        // A mistake unrelated to the value being deferred keeps its own message.
-        CHECK_THROWS_WITH(process("{global v = (1, 2)}{global v = \"W\" + total_weight}"),
-                          Catch::Matchers::ContainsSubstring("Cannot assign a scalar value to a vector variable"));
-    }
-    SECTION("ignored in a branch that is not taken") {
-        CHECK(process("{if false}{total_weight * 2}{endif}ok") == "ok");
-        struct Restore { ~Restore() { PlaceholderParser::check_inactive_branches = false; } } restore;
-        PlaceholderParser::check_inactive_branches = true;
-        CHECK(process("{if false}{total_weight * 2}{endif}ok") == "ok");
-    }
-    SECTION("other strings keep their behavior") {
-        CHECK(process("{label + 1}") == "W1");
-        CHECK(process("{if label > \"A\"}yes{endif}") == "yes");
-        CHECK(process("{if regex_replace(label, /X/, total_weight) == \"W\"}yes{endif}") == "yes");
-    }
-}

tests/slic3rutils/test_plugin_audit.cpp

@@ -3,11 +3,13 @@
 #include <boost/system/error_code.hpp>
 #include <catch2/catch_all.hpp>
 
+#include <cstddef>
 #include <libslic3r/Utils.hpp>
 #include <libslic3r/libslic3r.h>         // GCODEVIEWER_APP_KEY, SLIC3R_APP_KEY (via libslic3r_version.h)
 #include <slic3r/plugin/PluginAuditManager.hpp>
 #include <slic3r/plugin/PluginFsUtils.hpp>
 #include <slic3r/plugin/PluginManager.hpp>
+#include <slic3r/plugin/probe/PluginProbeCollector.hpp>
 #include <slic3r/plugin/PythonInterpreter.hpp>
 #include <slic3r/plugin/PythonPluginBridge.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
@@ -32,6 +34,7 @@
 #include <pybind11/pytypes.h>
 #include <pybind11/stl.h>
 
+#include <algorithm>
 #include <fstream>
 #include <functional>
 #include <ios>
@@ -67,6 +70,26 @@ void seed_denied_keywords()
         mgr.add_denied_path_keyword(keyword);
 }
 
+// Installs the record-only observer for a test and always clears it, so a failed CHECK cannot
+// leave a callback pointing at a destroyed collector for the next test in this process.
+struct ScopedTestObservationObserver
+{
+    explicit ScopedTestObservationObserver(PluginProbeCollector& collector)
+        : m_collector(collector)
+    {
+        PluginAuditManager::instance().set_observation_observer(
+            [this](const AuditObservation& observation) { m_collector.record(observation); });
+    }
+
+    ~ScopedTestObservationObserver() { PluginAuditManager::instance().clear_observation_observer(); }
+
+    ScopedTestObservationObserver(const ScopedTestObservationObserver&)            = delete;
+    ScopedTestObservationObserver& operator=(const ScopedTestObservationObserver&) = delete;
+
+private:
+    PluginProbeCollector& m_collector;
+};
+
 } // namespace
 
 TEST_CASE("Plugin audit denies host-managed filenames anywhere", "[audit]")
@@ -667,6 +690,71 @@ const char* const PLUGIN = "AuditPlugin";
 
 } // namespace
 
+TEST_CASE("Probe phase scope restores the previous phase", "[audit]")
+{
+    PluginAuditManager& mgr = PluginAuditManager::instance();
+    mgr.set_current_audit_phase("outer");
+    {
+        ScopedPluginAuditPhase inner("inner");
+        CHECK(mgr.current_audit_phase() == "inner");
+    }
+    CHECK(mgr.current_audit_phase() == "outer");
+    mgr.clear_current_audit_phase();
+    CHECK(mgr.current_audit_phase().empty());
+}
+
+TEST_CASE("Record-only probe observations bypass prompts and retain phase attribution", "[audit][Python]")
+{
+    AuditHarness harness;
+    if (!harness.initialized)
+        SKIP("Bundled Python interpreter unavailable: " + PythonInterpreter::instance().last_error());
+    harness.add_plugin(PLUGIN);
+    py::gil_scoped_acquire gil;
+    PythonSide              python(harness);
+
+    PluginProbeCollector          collector;
+    ScopedTestObservationObserver observer(collector);
+
+    // A declared read permission is recorded and allowed, but must not be written to the sidecar.
+    {
+        ScopedPluginAuditContext context(PLUGIN);
+        CHECK(PluginAuditManager::instance().request_filesystem_read_permissions(PLUGIN, {"/tmp/probe-declared"}));
+    }
+
+    {
+        ScopedPluginAuditPhase phase("probe:callback");
+        python.run_as(PLUGIN, "outcome = attempt(lambda: open(PRIVATE).close())");
+    }
+
+    CHECK(python.str("outcome") == "ok");
+    CHECK(harness.prompts.empty());
+    CHECK(harness.saved_permissions(PLUGIN).fs_read.empty());
+
+    const std::vector<AuditObservation> observations = collector.observations();
+    const auto                          open_event   = std::find_if(
+        observations.begin(), observations.end(), [](const AuditObservation& observation) {
+            return observation.event_name == "open";
+        });
+    REQUIRE(open_event != observations.end());
+    CHECK(open_event->plugin_key == PLUGIN);
+    CHECK(open_event->phase == "probe:callback");
+    CHECK(open_event->category == "FsRead");
+    CHECK(open_event->continued);
+    CHECK(std::find(open_event->targets.begin(), open_event->targets.end(), python.str("PRIVATE")) !=
+          open_event->targets.end());
+
+    const auto declared = std::find_if(observations.begin(), observations.end(), [](const AuditObservation& observation) {
+        return observation.event_name == "orca.request_permissions";
+    });
+    REQUIRE(declared != observations.end());
+    CHECK(declared->category == "FsRead");
+    CHECK(std::find(declared->targets.begin(), declared->targets.end(), "/tmp/probe-declared") != declared->targets.end());
+
+    const nlohmann::json summary = collector.summary();
+    CHECK(summary["categories"].contains("FsRead"));
+    CHECK(summary["observed_event_count"].get<std::size_t>() == observations.size());
+}
+
 TEST_CASE("A saved request grant covers the request's own connection in a later session", "[audit][Python]")
 {
     AuditHarness harness;
@@ -1132,37 +1220,3 @@ TEST_CASE("Stdlib code is recognized through a symlinked Python home", "[audit][
     CHECK_FALSE(PluginAuditManager::is_stdlib_file((harness.outside.path() / "plugin.py").string()));
     CHECK_FALSE(PluginAuditManager::is_stdlib_file("<string>"));
 }
-
-TEST_CASE("A plugin may read the CPython stdlib without a prompt, but not site-packages or for writing", "[audit][Python]")
-{
-    AuditHarness harness;
-    if (!harness.initialized)
-        SKIP("Bundled Python interpreter unavailable: " + PythonInterpreter::instance().last_error());
-    harness.add_plugin(PLUGIN);
-    py::gil_scoped_acquire gil;
-    PythonSide python(harness);
-
-    const py::dict paths   = py::module_::import("sysconfig").attr("get_paths")();
-    const fs::path stdlib  = py::str(paths["stdlib"]).cast<std::string>();
-    const fs::path purelib = py::str(paths["purelib"]).cast<std::string>();
-    // os.py ships with every CPython installation. A site-packages path is third-party code even
-    // when the directory is empty: the prompt must come before the missing file is noticed.
-    const fs::path stdlib_file = stdlib / "os.py";
-    REQUIRE(fs::exists(stdlib_file));
-
-    python.globals["STDLIB_FILE"]       = stdlib_file.string();
-    python.globals["SITE_PACKAGE_FILE"] = (purelib / "regression_probe.py").string();
-    python.run_as(PLUGIN, R"PY(
-read_outcome = attempt(lambda: open(STDLIB_FILE).read())
-write_outcome = attempt(lambda: open(STDLIB_FILE, "r+").close())
-site_packages_outcome = attempt(lambda: open(SITE_PACKAGE_FILE).close())
-)PY");
-
-    CHECK(python.str("read_outcome") == "ok");
-    CHECK(python.str("write_outcome") == "denied");
-    CHECK(python.str("site_packages_outcome") == "denied");
-    // Only the write and the site-packages read are asked about; the stdlib read is implicit.
-    const std::string write_prompt         = "open: " + python.str("STDLIB_FILE") + "\n";
-    const std::string site_packages_prompt = "open: " + python.str("SITE_PACKAGE_FILE") + "\n";
-    CHECK(describe(harness.prompts) == write_prompt + site_packages_prompt);
-}