Merge Main into Belt Printer

Merge origin/main (00429da739) into belt-printer.

Conflicts resolved:
- src/CMakeLists.txt: keep both wxInspector workarounds.
- GCodeProcessor.cpp: keep the belt compare_pos / z_for_height lines.
- PrintObjectSlice.cpp: the belt bbox-Z guard also covers main's
  printable_region_ids bookkeeping.
- TreeSupport.cpp: the belt-floor check runs before main's PendingNode
  queueing.
- Tab.hpp: keep the belt fields, drop the removed upload description
  fields.
- tests/libslic3r/CMakeLists.txt: keep both test files.

Also included:
- eSUN PLA belt presets declare their own filament_id (OFkrxQC4) and
  scripts/filament_id_snapshot.json is regenerated, as main's filament_id
  check requires.
- Custom.json version bumped to 02.04.00.05 so the belt entries reach
  existing installs.
- Fix the ambiguous WithinRel call in the belt apron width test, which
  otherwise breaks the fff_print build.

tests/fff_print/CMakeLists.txt

@@ -19,6 +19,7 @@ add_executable(${_TEST_NAME}_tests
 	test_skirt_brim.cpp
 	test_slicing_pipeline_hook.cpp
 	test_support_material.cpp
+	test_tree_support.cpp
 	test_trianglemesh.cpp
 	test_wipe_tower.cpp
 	)

tests/fff_print/test_cooling.cpp

@@ -2,7 +2,10 @@
 
 #include "test_helpers.hpp"
 
+#include <algorithm>
+#include <sstream>
 #include <string>
+#include <vector>
 
 using namespace Slic3r;
 using namespace Slic3r::Test;
@@ -25,3 +28,68 @@ TEST_CASE("Cooling consumes its internal speed markers", "[Cooling]")
     const std::string gcode = slice({ cube(20) }, { { "layer_height", 0.2 } });
     CHECK(gcode.find(";_EXTRUDE_SET_SPEED") == std::string::npos);
 }
+
+TEST_CASE("Overhang fan transitions do not depend on overhang speed", "[Cooling][Regression]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "bridge_speed",                   2.0 },
+        { "enable_arc_fitting",             false },
+        { "enable_overhang_bridge_fan",     true },
+        { "enable_overhang_speed",          false },
+        { "initial_layer_print_height",     0.3 },
+        { "inner_wall_speed",              30.0 },
+        { "layer_height",                   0.3 },
+        { "outer_wall_speed",              30.0 },
+        { "overhang_1_4_speed",            "30" },
+        { "overhang_2_4_speed",            "29" },
+        { "overhang_3_4_speed",             "6" },
+        { "overhang_4_4_speed",             "3" },
+        { "slow_down_for_layer_cooling",    false },
+        { "slowdown_for_curled_perimeters", false },
+    });
+    config.set_key_value("fan_max_speed", new ConfigOptionFloats{20.0});
+    config.set_key_value("fan_min_speed", new ConfigOptionFloats{20.0});
+    config.set_key_value("overhang_fan_speed", new ConfigOptionInts{100});
+    config.set_key_value("overhang_fan_threshold", new ConfigOptionEnumsGeneric{Overhang_threshold_2_4});
+    config.set_key_value("layer_change_gcode", new ConfigOptionString{";TEST_LAYER_Z=[layer_z]"});
+
+    const auto fan_commands = [](const std::string &gcode) {
+        std::vector<std::pair<std::string, std::string>> commands;
+        std::istringstream input(gcode);
+        std::string layer;
+        std::string line;
+        while (std::getline(input, line)) {
+            if (line.rfind(";TEST_LAYER_Z=", 0) == 0)
+                layer = line;
+            else if (!layer.empty() && (line.rfind("M106", 0) == 0 || line.rfind("M107", 0) == 0))
+                commands.emplace_back(layer, line);
+        }
+        return commands;
+    };
+    const auto feedrates = [](const std::string &gcode) {
+        std::vector<std::string> values;
+        std::istringstream input(gcode);
+        std::string word;
+        while (input >> word)
+            if (!word.empty() && word.front() == 'F')
+                values.push_back(word);
+        return values;
+    };
+
+    constexpr double sphere_radius = 50.0; // 100 mm diameter.
+    const std::string without_speed_gcode = slice({make_sphere(sphere_radius, PI / 24.0)}, config);
+    config.set_deserialize_strict({{"enable_overhang_speed", true}});
+    const std::string with_speed_gcode = slice({make_sphere(sphere_radius, PI / 24.0)}, config);
+
+    const auto without_speed_fan = fan_commands(without_speed_gcode);
+    const auto with_speed_fan = fan_commands(with_speed_gcode);
+    const auto without_speed_feedrates = feedrates(without_speed_gcode);
+    const auto with_speed_feedrates = feedrates(with_speed_gcode);
+
+    REQUIRE_FALSE(without_speed_fan.empty());
+    REQUIRE(std::any_of(without_speed_fan.begin(), without_speed_fan.end(),
+                        [](const auto &command) { return command.second.find("S255") != std::string::npos; }));
+    REQUIRE(with_speed_feedrates != without_speed_feedrates);
+    CHECK(with_speed_fan == without_speed_fan);
+}

tests/fff_print/test_fill.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/AABBTreeLines.hpp"
 #include "libslic3r/Fill/Fill.hpp"
 #include "libslic3r/Flow.hpp"
 #include "libslic3r/Geometry.hpp"
@@ -699,6 +700,213 @@ TEST_CASE("Solid infill direction offsets every layer when no template is set",
     }
 }
 
+// Orca: the spiral inset pattern chains the concentric loops into a single continuous path per
+// island, so it has to cope with the degenerate loops offsetting leaves behind and it must not join
+// loops that only look adjacent.
+namespace {
+
+Slic3r::Polylines spiral_inset_fill(const Slic3r::ExPolygon &surface_shape, double spacing)
+{
+    std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("spiralinset"));
+    filler->spacing = spacing;
+    // Cancel the half-spacing contraction fill_surface() applies, so the filler sees the shape as given.
+    filler->overlap = 0.5 * spacing;
+
+    Slic3r::FillParams fill_params;
+    fill_params.density     = 1.f;
+    fill_params.dont_adjust = true;
+
+    Slic3r::Surface surface(Slic3r::stBottom, surface_shape);
+    return filler->fill_surface(&surface, fill_params);
+}
+
+Slic3r::ExPolygon rectangle(double x, double y, double w, double h)
+{
+    return Slic3r::ExPolygon({Slic3r::Point::new_scale(x, y), Slic3r::Point::new_scale(x + w, y),
+                              Slic3r::Point::new_scale(x + w, y + h), Slic3r::Point::new_scale(x, y + h)});
+}
+
+// Area of the surface the toolpaths fail to cover, and the largest single patch of it, in mm2. Each
+// bead is measured at its own width so the variable width walls are not sold short.
+std::pair<double, double> uncovered_area(const Slic3r::ExPolygon &surface_shape, const Slic3r::Polygons &covered)
+{
+    double total = 0, biggest = 0;
+    for (const Slic3r::ExPolygon &gap : Slic3r::diff_ex(Slic3r::ExPolygons{surface_shape}, Slic3r::union_(covered))) {
+        const double area = unscale<double>(unscale<double>(gap.area()));
+        total += area;
+        biggest = std::max(biggest, area);
+    }
+    return {total, biggest};
+}
+
+Slic3r::Polygons beads_of(const Slic3r::Polylines &paths, double width)
+{
+    return Slic3r::offset(paths, float(scale_(0.5 * width)));
+}
+
+Slic3r::Polygons beads_of(const Slic3r::ThickPolylines &paths)
+{
+    Slic3r::Polygons covered;
+    for (const Slic3r::ThickPolyline &path : paths)
+        for (size_t i = 0; i + 1 < path.points.size(); ++i) {
+            Slic3r::Polyline segment;
+            segment.points = {path.points[i], path.points[i + 1]};
+            Slic3r::append(covered, Slic3r::offset(Slic3r::Polylines{segment},
+                                                  float(0.5 * std::max(path.width[2 * i], path.width[2 * i + 1]))));
+        }
+    return covered;
+}
+
+} // namespace
+
+TEST_CASE("Spiral inset fill drops loops shorter than the end clipping", "[Fill][Regression]")
+{
+    // A sliver whose whole perimeter is shorter than the length clipped off the end of a loop, so the
+    // clipping consumes the path entirely. Such a loop carries no extrusion and must be dropped
+    // rather than kept as an empty path and read back from.
+    const double spacing = 0.45;
+
+    Slic3r::Polylines paths;
+    REQUIRE_NOTHROW(paths = spiral_inset_fill(rectangle(0, 0, 0.05, 0.05), spacing));
+    for (const Slic3r::Polyline &path : paths)
+        CHECK(path.size() >= 2);
+
+    // The same surface at a size the clipping cannot swallow still gets filled.
+    REQUIRE_NOTHROW(paths = spiral_inset_fill(rectangle(0, 0, 5, 5), spacing));
+    REQUIRE(paths.size() == 1);
+    CHECK(paths.front().size() >= 2);
+}
+
+TEST_CASE("Spiral inset fill keeps separate islands on separate paths", "[Fill]")
+{
+    // Two lobes joined by a neck narrower than the loop spacing: the inward offsets break the surface
+    // into two islands, which cannot share one spiral, and no path may leave the surface.
+    const double spacing = 0.45;
+    Slic3r::ExPolygon dumbbell = rectangle(0, 0, 6, 6);
+    dumbbell = Slic3r::union_ex(Slic3r::ExPolygons{dumbbell, rectangle(6, 2.9, 4, 0.2), rectangle(10, 0, 6, 6)}).front();
+
+    const Slic3r::Polylines paths = spiral_inset_fill(dumbbell, spacing);
+    REQUIRE(paths.size() >= 2);
+
+    // Inflate by a hair so that loops sitting exactly on the outline still count as contained.
+    const Slic3r::ExPolygons within = Slic3r::offset_ex(dumbbell, float(SCALED_EPSILON));
+    REQUIRE(within.size() == 1);
+    for (const Slic3r::Polyline &path : paths) {
+        CHECK(path.size() >= 2);
+        CHECK(within.front().contains(path));
+    }
+}
+
+
+TEST_CASE("Spiral inset fill stays connected across sharp corners", "[Fill][Regression]")
+{
+    // At a corner of half-angle a, the next ring inward retreats along the bisector by spacing/sin(a),
+    // which leaves it several spacings from the end of the ring it continues. Judging the break by
+    // distance broke the spiral into loose rings at every spike; nesting is what decides the island.
+    const double spacing = 0.45;
+    const Slic3r::ExPolygon spike({Slic3r::Point::new_scale(0, 0), Slic3r::Point::new_scale(30, 0),
+                                   Slic3r::Point::new_scale(15, 4)});
+
+    const Slic3r::Polylines paths = spiral_inset_fill(spike, spacing);
+    CHECK(paths.size() == 1);
+
+    const Slic3r::ExPolygons within = Slic3r::offset_ex(spike, float(SCALED_EPSILON));
+    REQUIRE(within.size() == 1);
+    for (const Slic3r::Polyline &path : paths)
+        CHECK(within.front().contains(path));
+}
+
+TEST_CASE("Spiral inset fill starts on a convex corner", "[Fill][Regression]")
+{
+    // The only right angle on this outline is the reflex one: the two edges meeting at the origin
+    // span 90 degrees exactly as a square corner would, but the material lies outside them. The next
+    // ring in steps away from a reflex corner along the bisector instead of hugging it, so starting
+    // the spiral there sent it across a long diagonal on every single ring.
+    const double spacing = 0.45;
+    const Slic3r::ExPolygon notched({Slic3r::Point::new_scale(0, 0), Slic3r::Point::new_scale(0, 10),
+                                     Slic3r::Point::new_scale(-16, 18), Slic3r::Point::new_scale(-16, -2),
+                                     Slic3r::Point::new_scale(-8, -16), Slic3r::Point::new_scale(18, -16),
+                                     Slic3r::Point::new_scale(10, 0)});
+
+    const Slic3r::Polylines paths = spiral_inset_fill(notched, spacing);
+    REQUIRE(paths.size() >= 1);
+
+    // Every edge of the outline is at least 45 degrees off the bisector of that reflex corner, and
+    // so is every ring offset from it. A long segment running along the bisector can therefore only
+    // be the spiral striking out across the rings to reach the next one.
+    for (const Slic3r::Polyline &path : paths)
+        for (const Slic3r::Line &segment : path.lines()) {
+            const Vec2d  v         = (segment.b - segment.a).cast<double>();
+            const double direction = std::fmod(std::atan2(v.y(), v.x()) * 180.0 / M_PI + 180.0, 180.0);
+            if (std::abs(direction - 45.0) > 25.0)
+                continue;
+            CAPTURE(direction, unscale<double>(segment.length()));
+            CHECK(segment.length() <= scale_(1.5 * spacing));
+        }
+}
+
+TEST_CASE("Spiral inset fill closes the gaps with variable width walls", "[Fill]")
+{
+    // Fixed width loops cannot fill a region that is not a whole number of lines across and leave the
+    // remainder open, which on a ring shows up as a wedge several lines wide. Plain concentric avoids
+    // that by building solid surfaces out of Arachne's variable width walls, and so must this pattern.
+    const double spacing = 0.45;
+    Slic3r::ExPolygon ring = rectangle(0, 0, 24, 24);
+    Slic3r::Polygon   hole;
+    for (int i = 0; i < 64; ++i) {
+        const double angle = -2.0 * PI * i / 64.0; // clockwise, so it reads as a hole
+        hole.points.emplace_back(Slic3r::Point::new_scale(12 + 7.3 * std::cos(angle), 12 + 7.3 * std::sin(angle)));
+    }
+    ring.holes.emplace_back(hole);
+
+    Slic3r::PrintConfig       print_config;
+    Slic3r::PrintObjectConfig object_config;
+    auto make_filler = [&]() {
+        std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("spiralinset"));
+        filler->spacing             = spacing;
+        filler->overlap             = 0.5 * spacing; // cancel the contraction, so both see the same surface
+        filler->print_config        = &print_config;
+        filler->print_object_config = &object_config;
+        return filler;
+    };
+
+    Slic3r::FillParams params;
+    params.density      = 1.f;
+    params.dont_adjust  = false;
+    params.layer_height = 0.2;
+
+    const Slic3r::Surface surface(Slic3r::stTop, ring);
+
+    std::unique_ptr<Slic3r::Fill> fixed = make_filler();
+    const Slic3r::Polylines fixed_width = fixed->fill_surface(&surface, params);
+    REQUIRE(!fixed_width.empty());
+    const auto fixed_gaps = uncovered_area(ring, beads_of(fixed_width, fixed->spacing));
+
+    params.use_arachne = true;
+    std::unique_ptr<Slic3r::Fill> variable = make_filler();
+    const Slic3r::ThickPolylines variable_width = variable->fill_surface_arachne(&surface, params);
+    REQUIRE(!variable_width.empty());
+    const auto variable_gaps = uncovered_area(ring, beads_of(variable_width));
+
+    CAPTURE(fixed_gaps.first, fixed_gaps.second, variable_gaps.first, variable_gaps.second);
+    // The wedges the fixed width loops leave behind are what the variable width walls take up.
+    CHECK(variable_gaps.second < 0.5 * fixed_gaps.second);
+    CHECK(variable_gaps.first < fixed_gaps.first);
+
+    // And it is still a spiral: far fewer paths than the ring has loops.
+    // And the walls are still chained into spirals rather than printed one path per wall. The ring is
+    // at its narrowest (12 - 7.3) mm across and is filled from both sides, so it is at least this many
+    // walls thick there and thicker elsewhere. Arachne's short thin feature walls cannot join a spiral,
+    // so only the substantial paths count towards this.
+    const size_t walls_across = size_t(2.0 * (12.0 - 7.3) / spacing);
+    size_t       spirals      = 0;
+    for (const Slic3r::ThickPolyline &path : variable_width)
+        if (path.length() > scale_(10.0 * spacing))
+            ++spirals;
+    CAPTURE(spirals, walls_across, variable_width.size(), fixed_width.size());
+    CHECK(2 * spirals < walls_across);
+}
+
 TEST_CASE("Honeycomb infill rounds its cell corners with the smooth factor", "[Fill]")
 {
     // A cell whose sides are several times the line width, so that the corners have room to be rounded.
@@ -1022,3 +1230,68 @@ TEST_CASE("Smoothing multiline lightning infill keeps its outlines connected", "
     REQUIRE(smooth.point_count > sharp.point_count);
     REQUIRE(smooth.sharp_turns < sharp.sharp_turns);
 }
+
+TEST_CASE("Sparse plane-path anchors match the printed infill", "[Fill][InternalBridge][Regression]")
+{
+    // Orca: Compare generated anchors with actual extrusion across plane-path patterns,
+    // smoothing, multiline and rotations; an origin shift must not pass as valid support.
+    const std::string pattern = GENERATE("hilbertcurve", "octagramspiral", "archimedeanchords");
+    const std::string smoothing = GENERATE("0%", "100%");
+    const int multiline = GENERATE(1, 2);
+    const bool rotated = GENERATE(false, true);
+    const bool separated = GENERATE(false, true);
+    CAPTURE(pattern, smoothing, multiline, rotated, separated);
+
+    auto config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({{"sparse_infill_pattern", pattern},
+                                   {"sparse_infill_density", "15%"},
+                                   {"sparse_infill_smooth_factor", smoothing},
+                                   {"fill_multiline", multiline},
+                                   {"infill_direction", 45},
+                                   {"sparse_infill_rotate_template", rotated ? "0,25,50" : ""},
+                                   {"align_infill_direction_to_model", rotated},
+                                   {"separated_infills", separated},
+                                   {"top_shell_layers", 0},
+                                   {"bottom_shell_layers", 0},
+                                   {"top_shell_thickness", 0},
+                                   {"bottom_shell_thickness", 0},
+                                   {"layer_height", 0.2},
+                                   {"initial_layer_print_height", 0.2},
+                                   {"resolution", 0.012}});
+    Print print;
+    Model model;
+    TriangleMesh mesh = make_cube(30, 24, 1);
+    if (separated) {
+        // Orca: Two disconnected bodies in one object must each use their own infill origin.
+        TriangleMesh second = make_cube(30, 24, 1);
+        second.translate(50, 0, 0);
+        mesh.merge(second);
+    }
+    Slic3r::Test::init_print({mesh}, print, model, config, nullptr, false);
+    if (rotated) {
+        model.objects.front()->instances.front()->set_rotation(Vec3d(0., 0., Geometry::deg2rad(23.)));
+        print.apply(model, config);
+    }
+    print.process();
+
+    const Layer &layer = *print.objects().front()->get_layer(4);
+    Polylines printed;
+    for (const LayerRegion *region : layer.regions())
+        for (const ExtrusionEntity *entity : region->fills.flatten().entities)
+            if (entity->role() == erInternalInfill)
+                entity->collect_polylines(printed);
+    REQUIRE_FALSE(printed.empty());
+    const AABBTreeLines::LinesDistancer<Line> printed_tree(to_lines(printed));
+
+    // Orca: Exclude perimeter connections: anchoring and extrusion can trim those differently.
+    const Polylines anchors = intersection_pl(layer.generate_sparse_infill_polylines_for_anchoring(nullptr, nullptr, nullptr),
+                                              shrink(to_polygons(layer.lslices), scale_(3.)));
+    REQUIRE_FALSE(anchors.empty());
+    double max_distance = 0.;
+    for (const Polyline &path : anchors)
+        for (const Point &point : path.equally_spaced_points(scale_(0.25)))
+            max_distance = std::max(max_distance, printed_tree.distance_from_lines<false>(point));
+    // Orca: Allow only the configured simplification tolerance; infill-scale offsets
+    // would hide anchors that no longer coincide with printed lines.
+    CHECK(unscale<double>(max_distance) <= config.opt_float("resolution"));
+}

tests/fff_print/test_gcodewriter.cpp

@@ -618,6 +618,9 @@ static DynamicPrintConfig dual_extruder_toolchange_config()
     config.set_key_value("nozzle_temperature_range_high", new ConfigOptionInts({240, 240}));
     config.set_key_value("flush_multiplier",     new ConfigOptionFloats({1}));
     config.set_key_value("flush_volumes_matrix", new ConfigOptionFloats({0, 140, 140, 0}));
+    // Inside the 200x200 test bed; the default y, 220, is not, and generation rejects that.
+    config.set_key_value("wipe_tower_x",         new ConfigOptionFloats({50.}));
+    config.set_key_value("wipe_tower_y",         new ConfigOptionFloats({50.}));
     return config;
 }
 

tests/fff_print/test_printobject.cpp

@@ -4,11 +4,18 @@
 #include "libslic3r/Print.hpp"
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/GCodeReader.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/AABBTreeLines.hpp"
 
 #include "test_helpers.hpp"
 
+#include <cmath>
 #include <iterator>
+#include <map>
 #include <set>
+#include <string>
+#include <utility>
+#include <vector>
 
 using namespace Slic3r;
 using namespace Slic3r::Test;
@@ -130,3 +137,438 @@ TEST_CASE("Initial layer height is honored", "[PrintObject]")
     REQUIRE_THAT(*layer_zs.begin(),            Catch::Matchers::WithinAbs(0.3, 1e-4));
     REQUIRE_THAT(*std::next(layer_zs.begin()), Catch::Matchers::WithinAbs(0.5, 1e-4));
 }
+
+static TriangleMesh internal_bridge_step()
+{
+    // Orca: The smaller tower leaves a shoulder whose solid skin needs internal bridges
+    // over the sparse infill in the base, without relying on an external model file.
+    TriangleMesh mesh = make_cube(30, 24, 3);
+    TriangleMesh tower = make_cube(14, 10, 1);
+    tower.translate(8, 7, 3);
+    mesh.merge(tower);
+    return mesh;
+}
+
+static DynamicPrintConfig internal_bridge_config(const std::string &pattern, int multiline)
+{
+    auto config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({{"sparse_infill_pattern", pattern},
+                                   {"fill_multiline", multiline},
+                                   {"sparse_infill_density", "15%"},
+                                   {"sparse_infill_smooth_factor", "100%"},
+                                   {"infill_direction", 45},
+                                   {"internal_bridge_angle", 0},
+                                   {"thick_internal_bridges", true},
+                                   {"top_shell_layers", 3},
+                                   {"bottom_shell_layers", 2},
+                                   {"top_shell_thickness", 0},
+                                   {"bottom_shell_thickness", 0},
+                                   {"layer_height", 0.2},
+                                   {"initial_layer_print_height", 0.2}});
+    return config;
+}
+
+TEST_CASE("Internal bridge angles follow the lower infill layer and model rotation", "[PrintObject][InternalBridge][Regression]")
+{
+    const std::string pattern = GENERATE("hilbertcurve", "octagramspiral");
+    // Orca: Cover both a central line (odd counts) and offset pairs (even counts).
+    const int multiline = GENERATE(1, 2, 3);
+    CAPTURE(multiline);
+    const double rotation = GENERATE(23., -123.);
+    const std::vector<double> cycle{10., 30., 70.};
+    auto config = internal_bridge_config(pattern, multiline);
+    config.set_deserialize_strict({{"sparse_infill_rotate_template", "10,30,70"},
+                                   {"align_infill_direction_to_model", true},
+                                   {"separated_infills", false}});
+    Print print;
+    Model model;
+    init_print({internal_bridge_step()}, print, model, config, nullptr, false);
+    model.objects.front()->instances.front()->set_rotation(Vec3d(0., 0., Geometry::deg2rad(rotation)));
+    print.apply(model, config);
+    print.process();
+    const PrintObject &object = *print.objects().front();
+    size_t bridges = 0;
+    for (size_t i = 1; i < object.layer_count(); ++i) {
+        // Orca: The support is one layer below the bridge. Check the template and model
+        // rotation together, including normalization when the resulting angle is negative.
+        double expected = std::fmod(cycle[(i - 1) % cycle.size()] + 90. + rotation, 180.);
+        if (expected < 0.) expected += 180.;
+        for (const LayerRegion *region : object.get_layer(i)->regions())
+            for (const Surface *surface : region->fill_surfaces.filter_by_type(stInternalBridge)) {
+                CAPTURE(pattern, rotation, i);
+                CHECK_THAT(Geometry::rad2deg(surface->bridge_angle), Catch::Matchers::WithinAbs(expected, 0.001));
+                ++bridges;
+            }
+    }
+    REQUIRE(bridges > 0);
+}
+
+TEST_CASE("Turning infill does not replace the anchors of another region", "[PrintObject][InternalBridge][Regression]")
+{
+    // Orca: Keep the right-hand region fixed while changing the left-hand pattern in the
+    // same object. Its bridge areas must be independent of a previous candidate's anchors.
+    const int multiline = GENERATE(1, 2, 3);
+    CAPTURE(multiline);
+    auto right_bridges = [multiline](const std::string &left_pattern) {
+        auto config = internal_bridge_config(left_pattern, multiline);
+        Print print;
+        Model model;
+        init_print({internal_bridge_step()}, print, model, config, nullptr, false);
+        TriangleMesh right = internal_bridge_step();
+        right.translate(50, 0, 0);
+        ModelVolume *volume = model.objects.front()->add_volume(std::move(right));
+        volume->config.set_key_value("sparse_infill_pattern", new ConfigOptionEnum<InfillPattern>(ipRectilinear));
+        volume->config.set_key_value("infill_direction", new ConfigOptionFloat(17.));
+        print.apply(model, config);
+        print.process();
+        std::map<size_t, Polygons> result;
+        const PrintObject &object = *print.objects().front();
+        for (size_t i = 0; i < object.layer_count(); ++i)
+            for (const LayerRegion *region : object.get_layer(i)->regions())
+                if (region->region().config().infill_direction == 17.)
+                    polygons_append(result[i], to_polygons(region->fill_surfaces.filter_by_type(stInternalBridge)));
+        return result;
+    };
+    const auto baseline = right_bridges("rectilinear");
+    const auto actual = right_bridges(GENERATE("hilbertcurve", "octagramspiral"));
+    REQUIRE(actual.size() == baseline.size());
+    double total_area = 0.;
+    for (const auto &[layer, expected] : baseline) {
+        CAPTURE(layer);
+        const auto &polys = actual.at(layer);
+        CHECK(area(diff(expected, polys)) < scaled<double>(1.) * scaled<double>(1.) * 1e-6);
+        CHECK(area(diff(polys, expected)) < scaled<double>(1.) * scaled<double>(1.) * 1e-6);
+        total_area += area(expected);
+    }
+    REQUIRE(total_area > 0.);
+}
+
+TEST_CASE("Rounded internal bridges end on printed support", "[PrintObject][InternalBridge][Regression]")
+{
+    const std::string pattern = GENERATE("hilbertcurve", "octagramspiral");
+    const bool separated = GENERATE(false, true);
+    CAPTURE(pattern, separated);
+    auto config = internal_bridge_config(pattern, 1);
+    config.set_deserialize_strict({{"infill_wall_overlap", "0%"}, {"separated_infills", separated}});
+    TriangleMesh mesh = internal_bridge_step();
+    if (separated) {
+        TriangleMesh second = internal_bridge_step();
+        second.translate(50, 0, 0);
+        mesh.merge(second);
+    }
+    Print print;
+    Model model;
+    init_print({mesh}, print, model, config, nullptr, false);
+    print.process();
+
+    // Orca: Check final extrusion endpoints after polygon cleanup and fill generation.
+    // A correct bridge angle and correct sparse anchors alone do not guarantee contact.
+    const PrintObject &object = *print.objects().front();
+    size_t checked = 0;
+    for (size_t i = 1; i < object.layer_count(); ++i) {
+        Polygons support;
+        Polylines walls;
+        for (const LayerRegion *region : object.get_layer(i - 1)->regions()) {
+            region->perimeters.polygons_covered_by_width(support, 0.f);
+            region->fills.polygons_covered_by_width(support, 0.f);
+            region->perimeters.collect_polylines(walls);
+        }
+        REQUIRE_FALSE(support.empty());
+        const AABBTreeLines::LinesDistancer<Line> support_tree(to_lines(union_(support)));
+        const AABBTreeLines::LinesDistancer<Line> wall_tree(to_lines(walls));
+        for (const LayerRegion *region : object.get_layer(i)->regions())
+            for (const ExtrusionEntity *entity : region->fills.flatten().entities) {
+                if (entity->role() != erInternalBridgeInfill)
+                    continue;
+                const auto *path = dynamic_cast<const ExtrusionPath *>(entity);
+                REQUIRE(path != nullptr);
+                for (const Line &line : path->polyline.to_polyline().lines()) {
+                    // Orca: Sample span ends, excluding short connectors and wall overlap.
+                    if (line.length() < scale_(std::max(0.7, 3. * path->width)))
+                        continue;
+                    for (const Point &point : {line.a, line.b}) {
+                        if (wall_tree.distance_from_lines<false>(point) <= scale_(0.5))
+                            continue;
+                        CAPTURE(i, point.x(), point.y());
+                        const double gap = unscale<double>(support_tree.distance_from_lines<true>(point)) - 0.5 * path->width;
+                        CHECK(gap <= 0.1);
+                        ++checked;
+                    }
+                }
+            }
+    }
+    REQUIRE(checked > 0);
+}
+
+TEST_CASE("Enabling separated infill recomputes body origins", "[PrintObject][InternalBridge][Regression]")
+{
+    const std::string pattern = GENERATE("hilbertcurve", "octagramspiral", "archimedeanchords");
+    CAPTURE(pattern);
+    auto footprint = [&](bool reslice) {
+        auto config = internal_bridge_config(pattern, 2);
+        config.set_deserialize_strict({{"separated_infills", !reslice}});
+        TriangleMesh mesh = internal_bridge_step();
+        TriangleMesh second = internal_bridge_step();
+        second.translate(50, 0, 0);
+        mesh.merge(second);
+        Print print;
+        Model model;
+        init_print({mesh}, print, model, config, nullptr, false);
+        print.process();
+        if (reslice) {
+            // Orca: Enabling centering after a completed slice must rebuild the body
+            // origins now shared by bridge preparation and printed infill.
+            config.set_deserialize_strict({{"separated_infills", true}});
+            print.apply(model, config);
+            print.process();
+        }
+        Polygons result;
+        for (const LayerRegion *region : print.objects().front()->get_layer(4)->regions())
+            region->fills.polygons_covered_by_width(result, 0.f);
+        return union_(result);
+    };
+    const Polygons fresh = footprint(false);
+    const Polygons resliced = footprint(true);
+    REQUIRE_FALSE(fresh.empty());
+    CHECK(area(diff(fresh, resliced)) < scaled<double>(1.) * scaled<double>(1.) * 1e-6);
+    CHECK(area(diff(resliced, fresh)) < scaled<double>(1.) * scaled<double>(1.) * 1e-6);
+}
+
+TEST_CASE("Surface centering survives changes to separated infill settings", "[PrintObject][SurfaceInfill][Regression]")
+{
+    const std::string pattern = GENERATE("archimedeanchords", "octagramspiral");
+    const std::string initial_center = GENERATE("each_surface", "each_model", "each_assembly");
+    const std::string final_center = GENERATE("each_surface", "each_model", "each_assembly");
+    const bool separated = GENERATE(false, true);
+    const std::string top_order = GENERATE("default", "outward", "inward");
+    const std::string bottom_order = top_order == "outward" ? "inward" : top_order == "inward" ? "outward" : "default";
+    const std::string density = GENERATE("80%", "100%");
+    const bool change_center = initial_center != final_center;
+    CAPTURE(pattern, initial_center, final_center, separated, top_order, bottom_order, density);
+
+    auto config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({{"top_surface_pattern", pattern},
+                                   {"bottom_surface_pattern", pattern},
+                                   {"top_surface_fill_order", top_order},
+                                   {"bottom_surface_fill_order", bottom_order},
+                                   {"top_surface_density", density},
+                                   {"bottom_surface_density", density},
+                                   {"center_of_surface_pattern", initial_center},
+                                   {"separated_infills", change_center ? separated : !separated},
+                                   {"sparse_infill_pattern", "rectilinear"},
+                                   {"sparse_infill_density", "15%"},
+                                   {"top_shell_layers", 2},
+                                   {"bottom_shell_layers", 2},
+                                   {"top_shell_thickness", 0},
+                                   {"bottom_shell_thickness", 0},
+                                   {"layer_height", 0.2},
+                                   {"initial_layer_print_height", 0.2}});
+
+    // Orca: Two disconnected bodies exercise per-body centering. The offset tower also
+    // makes each-surface and each-model centering differ on the top surfaces.
+    TriangleMesh mesh = make_cube(30, 24, 2);
+    TriangleMesh tower = make_cube(12, 10, 1);
+    tower.translate(4, 3, 2);
+    mesh.merge(tower);
+    TriangleMesh second = mesh;
+    second.translate(50, 0, 0);
+    mesh.merge(second);
+
+    // Orca: Equal footprints can hide reordered or reversed paths. Retain their point
+    // sequences and ordering protection to cover the directional surface behavior too.
+    struct SurfaceFillSnapshot {
+        std::map<bool, std::vector<Points>> paths;
+        bool protected_order = true;
+    };
+    auto surface_fills = [](const Print &print) {
+        std::map<std::pair<size_t, ExtrusionRole>, SurfaceFillSnapshot> result;
+        const PrintObject &object = *print.objects().front();
+        for (size_t i = 0; i < object.layer_count(); ++i) {
+            auto collect = [&](const auto &self, const ExtrusionEntity &entity, bool no_sort) -> void {
+                if (const auto *collection = dynamic_cast<const ExtrusionEntityCollection *>(&entity)) {
+                    for (const ExtrusionEntity *child : collection->entities)
+                        self(self, *child, no_sort || collection->no_sort);
+                } else if (entity.role() == erTopSolidInfill || entity.role() == erBottomSurface) {
+                    const auto *path = dynamic_cast<const ExtrusionPath *>(&entity);
+                    REQUIRE(path != nullptr);
+                    auto &snapshot = result[{i, entity.role()}];
+                    // Orca: The centered test model has one body on either side of X=0.
+                    // Their traversal order may vary; preserve path order within each body.
+                    Points points = path->polyline.to_polyline().points;
+                    REQUIRE_FALSE(points.empty());
+                    snapshot.paths[points.front().x() > 0].push_back(std::move(points));
+                    snapshot.protected_order &= no_sort && !path->can_reverse();
+                }
+            };
+            for (const LayerRegion *region : object.get_layer(i)->regions())
+                collect(collect, region->fills, false);
+        }
+        return result;
+    };
+
+    Print print;
+    Model model;
+    init_print({mesh}, print, model, config, nullptr, false);
+    print.process();
+    const auto initial = surface_fills(print);
+    config.set_deserialize_strict({{"center_of_surface_pattern", final_center}, {"separated_infills", separated}});
+    print.apply(model, config);
+    // Orca: Preparation owns the body origins, and its invalidation must also force
+    // regeneration of top/bottom extrusion paths, even when sparse infill is unchanged.
+    CHECK_FALSE(print.objects().front()->is_step_done(posPrepareInfill));
+    CHECK_FALSE(print.objects().front()->is_step_done(posInfill));
+    print.process();
+    const auto resliced = surface_fills(print);
+
+    Print fresh_print;
+    Model fresh_model;
+    init_print({mesh}, fresh_print, fresh_model, config, nullptr, false);
+    fresh_print.process();
+    const auto fresh = surface_fills(fresh_print);
+    REQUIRE_FALSE(fresh.empty());
+    REQUIRE(resliced.size() == fresh.size());
+    std::set<ExtrusionRole> roles;
+    bool changed_paths = false;
+    for (const auto &entry : fresh) {
+        CAPTURE(entry.first.first, entry.first.second);
+        REQUIRE_FALSE(entry.second.paths.empty());
+        roles.insert(entry.first.second);
+        REQUIRE(resliced.count(entry.first) == 1);
+        REQUIRE(initial.count(entry.first) == 1);
+        const auto &actual = resliced.at(entry.first);
+        const auto &expected = entry.second;
+        const auto &before = initial.at(entry.first);
+        CHECK((actual.paths == expected.paths));
+        if (!change_center)
+            CHECK((actual.paths == before.paths));
+        if (top_order != "default") {
+            CHECK(expected.protected_order);
+            CHECK(actual.protected_order);
+            CHECK(before.protected_order);
+        }
+        changed_paths |= expected.paths != before.paths;
+    }
+    CHECK(roles.count(erTopSolidInfill) == 1);
+    CHECK(roles.count(erBottomSurface) == 1);
+    // Orca: Guard against a vacuous comparison: changing surface centering must change
+    // the printed pattern, while toggling separated sparse infill must leave it alone.
+    CHECK(changed_paths == change_center);
+}
+
+TEST_CASE("Separated infill keeps fragmented and nested bodies independent", "[PrintObject][SurfaceInfill][Regression]")
+{
+    constexpr size_t grid_size = 8;
+    TriangleMesh mesh;
+    auto add_box = [&](double x, double y, double width, double depth) {
+        TriangleMesh box = make_cube(width, depth, 0.6);
+        box.translate(x, y, 0);
+        mesh.merge(box);
+    };
+    // Orca: Many small islands exercise spatial pruning and the tree's original
+    // island indices. A pillar inside a frame also overlaps its bounding box,
+    // but must remain a separate body because it lies entirely inside the hole.
+    for (size_t x = 0; x < grid_size; ++ x)
+        for (size_t y = 0; y < grid_size; ++ y)
+            add_box(6 * x, 6 * y, 3, 3);
+    add_box(54, 0, 20, 4);
+    add_box(54, 16, 20, 4);
+    add_box(54, 0, 4, 20);
+    add_box(70, 0, 4, 20);
+    add_box(62, 8, 4, 4);
+
+    auto config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({{"separated_infills", true},
+                                   {"center_of_surface_pattern", "each_surface"},
+                                   {"layer_height", 0.2},
+                                   {"initial_layer_print_height", 0.2},
+                                   {"elefant_foot_compensation", 0},
+                                   {"wall_loops", 1}});
+    Print print;
+    Model model;
+    init_print({mesh}, print, model, config, nullptr, false);
+    // Orca: Prepare body bounds through the public pipeline, then inspect the object read-only.
+    print.process();
+    const PrintObject &object = *print.objects().front();
+    REQUIRE(object.layer_count() > 1);
+    for (const Layer *layer : object.layers()) {
+        REQUIRE(layer->lslices.size() == grid_size * grid_size + 2);
+        REQUIRE(layer->lslices_separated_component_bboxes.size() == layer->lslices.size());
+        size_t holes = 0;
+        for (size_t i = 0; i < layer->lslices.size(); ++ i) {
+            const BoundingBox &body = layer->lslices_separated_component_bboxes[i];
+            const BoundingBox &island = layer->lslices_bboxes[i];
+            CHECK(body.min == island.min);
+            CHECK(body.max == island.max);
+            holes += layer->lslices[i].holes.size();
+        }
+        CHECK(holes == 1);
+    }
+}
+
+TEST_CASE("Body centering survives islands merging and splitting between layers", "[PrintObject][SurfaceInfill][Regression]")
+{
+    const bool separated = GENERATE(false, true);
+    CAPTURE(separated);
+    // Orca: Four posts join through horizontal then vertical rails, creating a
+    // cycle of overlaps before splitting into four islands again. This exercises
+    // redundant connections and indexing either adjacent layer. A fifth post
+    // stays separate at every height.
+    TriangleMesh mesh;
+    for (int x : {0, 8})
+        for (int y : {0, 8}) {
+            TriangleMesh post = make_cube(4, 4, 1);
+            post.translate(x, y, 0);
+            mesh.merge(post);
+        }
+    for (int y : {0, 8}) {
+        TriangleMesh rail = make_cube(12, 4, 0.2);
+        rail.translate(0, y, 0.2);
+        mesh.merge(rail);
+    }
+    for (int x : {0, 8}) {
+        TriangleMesh rail = make_cube(4, 12, 0.2);
+        rail.translate(x, 0, 0.4);
+        mesh.merge(rail);
+    }
+    TriangleMesh isolated = make_cube(4, 4, 1);
+    isolated.translate(20, 0, 0);
+    mesh.merge(isolated);
+
+    auto config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({{"separated_infills", separated},
+                                   {"center_of_surface_pattern", separated ? "each_surface" : "each_model"},
+                                   {"layer_height", 0.2},
+                                   {"initial_layer_print_height", 0.2},
+                                   {"elefant_foot_compensation", 0},
+                                   {"wall_loops", 1}});
+    Print print;
+    Model model;
+    init_print({mesh}, print, model, config, nullptr, false);
+    // Orca: Prepare body bounds through the public pipeline, then inspect the object read-only.
+    print.process();
+    const PrintObject &object = *print.objects().front();
+    REQUIRE(object.layer_count() == 5);
+    REQUIRE(object.get_layer(0)->lslices.size() == 5);
+    REQUIRE(object.get_layer(1)->lslices.size() == 3);
+    REQUIRE(object.get_layer(2)->lslices.size() == 3);
+    REQUIRE(object.get_layer(4)->lslices.size() == 5);
+
+    BoundingBox isolated_bbox = object.get_layer(0)->lslices_bboxes.front();
+    for (const BoundingBox &bbox : object.get_layer(0)->lslices_bboxes)
+        if (bbox.min.x() > isolated_bbox.min.x())
+            isolated_bbox = bbox;
+    BoundingBox connected_bbox;
+    for (const Layer *layer : object.layers())
+        for (const BoundingBox &bbox : layer->lslices_bboxes)
+            if (bbox.min.x() < isolated_bbox.min.x())
+                connected_bbox.merge(bbox);
+    for (const Layer *layer : object.layers()) {
+        REQUIRE(layer->lslices_separated_component_bboxes.size() == layer->lslices.size());
+        for (size_t i = 0; i < layer->lslices.size(); ++ i) {
+            const BoundingBox &expected = layer->lslices_bboxes[i].min.x() < isolated_bbox.min.x() ? connected_bbox : isolated_bbox;
+            const BoundingBox &actual = layer->lslices_separated_component_bboxes[i];
+            CHECK(actual.min == expected.min);
+            CHECK(actual.max == expected.max);
+        }
+    }
+}

tests/fff_print/test_skirt_brim.cpp

@@ -1086,7 +1086,7 @@ TEST_CASE("Belt brim lines all have the same width", "[SkirtBrim][belt]")
     REQUIRE(widths.size() > 10);
     const float lo = *std::min_element(widths.begin(), widths.end());
     const float hi = *std::max_element(widths.begin(), widths.end());
-    CHECK_THAT(hi, Catch::Matchers::WithinRel(lo, 1e-4));
+    CHECK_THAT(hi, Catch::Matchers::WithinRel(lo, 1e-4f));
 }
 
 TEST_CASE("Belt apron survives another object printing at the same Z", "[SkirtBrim][belt]")

tests/fff_print/test_support_material.cpp

@@ -3,11 +3,103 @@
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Layer.hpp"
 
+#include <cmath>
+#include <map>
+#include <set>
+#include <vector>
+
 #include "test_helpers.hpp" // get access to init_print, etc
 
+// Not self-contained: its inline constructor uses PrintObject, PrintRegion, SlicingParameters and
+// Geometry, so it must follow the headers (pulled in via test_helpers.hpp) that define them.
+#include "libslic3r/Support/SupportParameters.hpp"
+
 using namespace Slic3r::Test;
 using namespace Slic3r;
 
+// Distinct layer Z heights carrying support interface extrusion.
+static size_t support_interface_layer_count(const std::string &gcode)
+{
+    return layers_with_role(gcode, "support material interface").size();
+}
+
+// Distinct layer Z heights carrying support base extrusion. The base G-code label "support material"
+// is a substring of "support material interface", so a base line is a support line that is not an
+// interface line.
+static size_t support_base_layer_count(const std::string &gcode)
+{
+    std::set<double> layers;
+    GCodeReader parser;
+    parser.parse_buffer(gcode, [&layers](GCodeReader &self, const GCodeReader::GCodeLine &line) {
+        if (! line.extruding(self)) return;
+        const std::string_view comment = line.comment();
+        if (comment.find("support material") != std::string_view::npos &&
+            comment.find("interface") == std::string_view::npos)
+            layers.insert(self.z());
+    });
+    return layers.size();
+}
+
+// Dominant support-interface fill direction per interface layer, in radians [0, pi). Uses the
+// length-weighted axial mean (each segment angle doubled so a line and its reverse agree, then
+// halved): the parallel infill lines reinforce while the surrounding perimeter cancels.
+static std::map<double, double> interface_fill_angle_by_layer(const std::string &gcode)
+{
+    std::map<double, std::pair<double, double>> acc; // z -> summed length*(cos2a, sin2a)
+    GCodeReader parser;
+    parser.parse_buffer(gcode, [&acc](GCodeReader &self, const GCodeReader::GCodeLine &line) {
+        if (! line.extruding(self)) return;
+        if (line.comment().find("support material interface") == std::string_view::npos) return;
+        const double dx = line.dist_X(self), dy = line.dist_Y(self);
+        const double len = std::hypot(dx, dy);
+        if (len < 1e-6) return;
+        const double a2 = 2.0 * std::atan2(dy, dx);
+        auto &p = acc[self.z()];
+        p.first  += len * std::cos(a2);
+        p.second += len * std::sin(a2);
+    });
+    std::map<double, double> out;
+    for (const auto &kv : acc) {
+        double a = 0.5 * std::atan2(kv.second.second, kv.second.first);
+        if (a < 0) a += M_PI;
+        out[kv.first] = a;
+    }
+    return out;
+}
+
+// Acute angle (degrees) between two axial fill directions in [0, pi).
+static double axial_angle_diff_deg(double a, double b)
+{
+    const double d = std::fmod(std::fabs(a - b), M_PI);
+    return std::min(d, M_PI - d) * 180.0 / M_PI;
+}
+
+// Denser interface spacing yields more extruded length.
+static double support_interface_extrusion_length(const std::string &gcode)
+{
+    double len = 0;
+    GCodeReader parser;
+    parser.parse_buffer(gcode, [&len](GCodeReader &self, const GCodeReader::GCodeLine &line) {
+        if (! line.extruding(self)) return;
+        if (line.comment().find("support material interface") == std::string_view::npos) return;
+        len += std::hypot(line.dist_X(self), line.dist_Y(self));
+    });
+    return len;
+}
+
+// A cap slab overhanging a base, joined by a central stem: the cap can only be supported by resting on the
+// base, forcing a genuine bottom contact. A horizontal tunnel does not work here -- tree/organic can arch a
+// branch in from the opening and avoid the floor entirely.
+static TriangleMesh support_capital()
+{
+    TriangleMesh model = make_cube(40, 40, 2);                              // base  [0,40]x[0,40]x[0,2]
+    TriangleMesh stem  = make_cube(8, 8, 12);   stem.translate(16, 16, 1);  // stem  centered, z 1..13
+    TriangleMesh cap   = make_cube(40, 40, 2);  cap.translate(0, 0, 12);    // cap   z 12..14
+    model.merge(stem);
+    model.merge(cap);
+    return model;
+}
+
 TEST_CASE("Three raft layers are created", "[SupportMaterial]")
 {
 	Slic3r::Print print;
@@ -104,3 +196,272 @@ TEST_CASE("Support G-code emission survives a second slice in the same process",
     const std::string second = slice({ TestMesh::overhang }, { { "enable_support", 1 } });
     REQUIRE(! layers_with_role(second, "support").empty());
 }
+
+// The contact layer counts toward the configured interface layer count, so N configured top
+// interface layers produce exactly N interface layers, not N+1.
+TEST_CASE("Support top interface layer count matches the configured value", "[SupportMaterial]")
+{
+    const int top = GENERATE(1, 2, 3, 4, 6);
+    const std::string g = slice({ TestMesh::overhang }, {
+        { "enable_support",                  1 },
+        { "layer_height",                    0.2 },
+        { "support_on_build_plate_only",     1 },
+        { "support_interface_top_layers",    top },
+        { "support_interface_bottom_layers", 0 },
+    });
+    CAPTURE(top);
+    REQUIRE(support_base_layer_count(g)      > 0);          // support actually formed
+    REQUIRE(support_interface_layer_count(g) == size_t(top));
+}
+
+// A rotated cube-with-hole is a horizontal tunnel whose ceiling and floor both receive support, so top
+// and bottom interfaces can be exercised independently (the floor is the bottom contact).
+static TriangleMesh support_tunnel()
+{
+    TriangleMesh tunnel = Slic3r::Test::mesh(TestMesh::cube_with_hole);
+    tunnel.rotate_x(float(M_PI / 2));
+    return tunnel;
+}
+
+static size_t tunnel_interface_layers(const TriangleMesh &tunnel, int top, int bottom)
+{
+    const std::string g = slice({ tunnel }, {
+        { "enable_support",                  1 },
+        { "layer_height",                    0.2 },
+        { "support_on_build_plate_only",     0 },
+        { "support_interface_top_layers",    top },
+        { "support_interface_bottom_layers", bottom },
+    });
+    REQUIRE(support_base_layer_count(g) > 0); // support actually formed
+    return support_interface_layer_count(g);
+}
+
+TEST_CASE("No support interface is generated when neither top nor bottom is configured", "[SupportMaterial]")
+{
+    REQUIRE(tunnel_interface_layers(support_tunnel(), 0, 0) == 0);
+}
+
+TEST_CASE("Bottom interface layer count matches its setting with top interface off", "[SupportMaterial]")
+{
+    const int bottom = GENERATE(1, 3, 6);
+    CAPTURE(bottom);
+    REQUIRE(tunnel_interface_layers(support_tunnel(), 0, bottom) == size_t(bottom));
+}
+
+// support_interface_bottom_layers = -1 means "same as top".
+TEST_CASE("Support interface bottom layers default to the top layer count", "[SupportMaterial]")
+{
+    const TriangleMesh tunnel = support_tunnel();
+    REQUIRE(tunnel_interface_layers(tunnel, 0, -1) == tunnel_interface_layers(tunnel, 0, 0));
+    REQUIRE(tunnel_interface_layers(tunnel, 3, -1) == tunnel_interface_layers(tunnel, 3, 3));
+}
+
+TEST_CASE("Default support still emits base and interface material", "[SupportMaterial][Regression]")
+{
+    const std::string g = slice({ TestMesh::overhang }, { { "enable_support", 1 } });
+    REQUIRE(support_base_layer_count(g)      > 0);
+    REQUIRE(support_interface_layer_count(g) > 0);
+}
+
+// Organic runs TreeSupport3D + TreeModelVolumes, the others the classic TreeSupport.cpp path.
+TEST_CASE("Every tree support style produces base and interface material", "[SupportMaterial]")
+{
+    const char *style = GENERATE("organic", "tree_slim", "tree_strong", "tree_hybrid");
+    INFO("style=" << style);
+    const std::string g = slice({ TestMesh::overhang }, {
+        { "enable_support",               1 },
+        { "layer_height",                 0.2 },
+        { "support_type",                 "tree(auto)" },
+        { "support_style",                style },
+        { "support_interface_top_layers", 3 },
+    });
+    CHECK(support_base_layer_count(g)      > 0);
+    CHECK(support_interface_layer_count(g) > 0);
+}
+
+TEST_CASE("Raft interface angle alternates by 45 degrees per interface id", "[SupportMaterial]")
+{
+    Slic3r::Print print;
+    Slic3r::Test::init_and_process_print({ TestMesh::overhang }, print, { { "enable_support", 1 } });
+    SupportParameters sp(*print.objects().front());
+    sp.raft_angle_interface = 0.5f;
+    REQUIRE_THAT(sp.raft_interface_angle(0), Catch::Matchers::WithinAbs(0.5 + M_PI / 4., 1e-6));
+    REQUIRE_THAT(sp.raft_interface_angle(1), Catch::Matchers::WithinAbs(0.5 - M_PI / 4., 1e-6));
+}
+
+// The angle inputs are overwritten directly, so the pattern-to-angle mapping is checked
+// independently of the sliced object's configuration.
+TEST_CASE("Support interface fill angle follows the configured interface pattern", "[SupportMaterial]")
+{
+    Slic3r::Print print;
+    Slic3r::Test::init_and_process_print({ TestMesh::overhang }, print, { { "enable_support", 1 } });
+    SupportParameters sp(*print.objects().front());
+    sp.interface_angle = 0.3f;
+    sp.base_angle      = 1.1f;
+    const double tol   = 1e-6;
+
+    SECTION("Rectilinear shifts the interface angle by -45deg for snug support") {
+        sp.support_interface_pattern = smipRectilinear;
+        sp.support_style             = smsSnug;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.interface_angle - M_PI_4, tol));
+        REQUIRE_THAT(sp.support_interface_angle(3), Catch::Matchers::WithinAbs(sp.interface_angle - M_PI_4, tol));
+    }
+    SECTION("Rectilinear leaves the interface angle alone for the other styles") {
+        sp.support_interface_pattern = smipRectilinear;
+        sp.support_style             = smsGrid;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.interface_angle, tol));
+    }
+    SECTION("Rectilinear interlaced alternates -/+45deg by interface id parity") {
+        sp.support_interface_pattern = smipRectilinearInterlaced;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.interface_angle - M_PI_4, tol));
+        REQUIRE_THAT(sp.support_interface_angle(1), Catch::Matchers::WithinAbs(sp.interface_angle + M_PI_4, tol));
+    }
+    SECTION("Grid uses the base angle") {
+        sp.support_interface_pattern = smipGrid;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.base_angle, tol));
+    }
+    SECTION("Auto and concentric use the interface angle unchanged") {
+        sp.support_interface_pattern = smipAuto;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.interface_angle, tol));
+        sp.support_interface_pattern = smipConcentric;
+        REQUIRE_THAT(sp.support_interface_angle(0), Catch::Matchers::WithinAbs(sp.interface_angle, tol));
+    }
+}
+
+// End-to-end that the pattern reaches the emitted fill, not just support_interface_angle().
+TEST_CASE("Interlaced support interface alternates fill angle while rectilinear does not", "[SupportMaterial]")
+{
+    auto interface_angles = [](const char *pattern) {
+        std::vector<double> a;
+        for (const auto &kv : interface_fill_angle_by_layer(slice({ TestMesh::overhang }, {
+                 { "enable_support",               1 },
+                 { "layer_height",                 0.2 },
+                 { "support_on_build_plate_only",  1 },
+                 { "support_interface_top_layers", 6 },
+                 { "support_interface_pattern",    pattern } })))
+            a.push_back(kv.second);
+        return a;
+    };
+
+    const std::vector<double> rectilinear = interface_angles("rectilinear");
+    const std::vector<double> interlaced  = interface_angles("rectilinear_interlaced");
+    REQUIRE(rectilinear.size() >= 3);
+    REQUIRE(interlaced.size()  >= 3);
+
+    for (size_t i = 1; i < rectilinear.size(); ++i)
+        REQUIRE(axial_angle_diff_deg(rectilinear[i], rectilinear[0]) < 15.0);
+
+    for (size_t i = 1; i < interlaced.size(); ++i)
+        REQUIRE(axial_angle_diff_deg(interlaced[i], interlaced[i - 1]) > 60.0);
+}
+
+// Normal and non-organic tree support share the same interface angle logic: with a rectilinear interface
+// pattern both emit their interface fill at the same angle (both go through support_interface_angle()).
+TEST_CASE("Normal and tree support use the same interface fill angle", "[SupportMaterial]")
+{
+    auto mean_interface_angle = [](const char *type, const char *style) {
+        const auto angles = interface_fill_angle_by_layer(slice({ TestMesh::overhang }, {
+            { "enable_support", 1 }, { "layer_height", 0.2 }, { "support_on_build_plate_only", 1 },
+            { "support_type", type }, { "support_style", style },
+            { "support_interface_top_layers", 6 }, { "support_interface_pattern", "rectilinear" } }));
+        REQUIRE(angles.size() >= 3);
+        // Axial mean, as in interface_fill_angle_by_layer: a plain mean would split angles either
+        // side of the [0, pi) wrap.
+        double x = 0, y = 0;
+        for (const auto &kv : angles) {
+            x += std::cos(2.0 * kv.second);
+            y += std::sin(2.0 * kv.second);
+        }
+        double mean = 0.5 * std::atan2(y, x);
+        if (mean < 0) mean += M_PI;
+        return mean;
+    };
+    REQUIRE(axial_angle_diff_deg(mean_interface_angle("normal(auto)", "default"),
+                                 mean_interface_angle("tree(auto)", "tree_slim")) < 10.0);
+}
+
+// Every style, because the non-organic tree styles once emitted one more top interface layer than the rest.
+TEST_CASE("Top interface layer count equals the configured value for every support style", "[SupportMaterial]")
+{
+    auto [type, style] = GENERATE(table<const char *, const char *>({
+        { "normal(auto)", "grid" },        { "normal(auto)", "snug" },
+        { "tree(auto)",   "organic" },     { "tree(auto)",   "tree_slim" },
+        { "tree(auto)",   "tree_strong" }, { "tree(auto)",   "tree_hybrid" },
+    }));
+    CAPTURE(style);
+    const std::string g = slice({ TestMesh::overhang }, {
+        { "enable_support",               1 },
+        { "layer_height",                 0.2 },
+        { "support_type",                 type },
+        { "support_style",                style },
+        { "support_interface_top_layers", 4 },
+    });
+    REQUIRE(support_interface_layer_count(g) == 4u);
+}
+
+// The bottom interface was dropped in earlier versions when support started on the model rather
+// than the plate.
+TEST_CASE("Non-organic tree support generates a bottom interface on internal geometry", "[SupportMaterial]")
+{
+    const std::string g = slice({ support_tunnel() }, {
+        { "enable_support",                  1 },
+        { "layer_height",                    0.2 },
+        { "support_on_build_plate_only",     0 },
+        { "support_type",                    "tree(auto)" },
+        { "support_style",                   "tree_slim" },
+        { "support_interface_top_layers",    0 },
+        { "support_interface_bottom_layers", 6 },
+    });
+    REQUIRE(support_base_layer_count(g)      > 0);
+    REQUIRE(support_interface_layer_count(g) > 0);
+}
+
+// The capital forces the model contact; on a horizontal tunnel organic can arch a branch in and make none.
+TEST_CASE("A bottom interface is produced for every support style on a forced model contact", "[SupportMaterial]")
+{
+    auto [type, style] = GENERATE(table<const char *, const char *>({
+        { "normal(auto)", "default" },     { "tree(auto)", "tree_slim" },
+        { "tree(auto)",   "tree_strong" }, { "tree(auto)", "tree_hybrid" },
+        { "tree(auto)",   "organic" },
+    }));
+    CAPTURE(style);
+    REQUIRE(support_interface_layer_count(slice({ support_capital() }, {
+        { "enable_support", 1 }, { "layer_height", 0.2 }, { "support_on_build_plate_only", 0 },
+        { "support_type", type }, { "support_style", style },
+        { "support_interface_top_layers", 0 }, { "support_interface_bottom_layers", 6 } })) > 0);
+}
+
+TEST_CASE("Bottom interface spacing controls bottom interface density for every support style", "[SupportMaterial]")
+{
+    auto [type, style] = GENERATE(table<const char *, const char *>({
+        { "normal(auto)", "default" },     { "tree(auto)", "tree_slim" },
+        { "tree(auto)",   "tree_strong" }, { "tree(auto)", "tree_hybrid" },
+        { "tree(auto)",   "organic" },
+    }));
+    CAPTURE(style);
+    const TriangleMesh model = support_capital();
+    auto len = [&model](const char *support_type, const char *support_style, double spacing) {
+        return support_interface_extrusion_length(slice({ model }, {
+            { "enable_support", 1 }, { "layer_height", 0.2 }, { "support_on_build_plate_only", 0 },
+            { "support_type", support_type }, { "support_style", support_style }, { "support_interface_top_layers", 0 },
+            { "support_interface_bottom_layers", 6 }, { "support_bottom_interface_spacing", spacing } }));
+    };
+    REQUIRE(len(type, style, 0.0) > len(type, style, 4.0) * 1.5);
+}
+
+// Interface and base flows are identical in width and rate unless a separate support-interface
+// filament is used, so density is the observable here, not flow.
+TEST_CASE("Bottom-only support interface keeps the dense interface density", "[SupportMaterial]")
+{
+    Slic3r::Print print;
+    Slic3r::Test::init_and_process_print({ TestMesh::overhang }, print, {
+        { "enable_support",                   1 },
+        { "support_interface_top_layers",     0 },
+        { "support_interface_bottom_layers",  6 },
+        { "support_bottom_interface_spacing", 0.0 },  // solid: density resolves to 1.0
+        { "support_base_pattern_spacing",     2.5 },  // sparse: density stays below 1.0
+    });
+    SupportParameters sp(*print.objects().front());
+    REQUIRE(sp.bottom_interface_density > sp.support_density);
+}
+

tests/fff_print/test_tree_support.cpp

@@ -0,0 +1,190 @@
+#include <catch2/catch_all.hpp>
+
+#include <algorithm>
+
+#include "libslic3r/Layer.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+
+#include "test_helpers.hpp"
+
+using namespace Slic3r::Test;
+using namespace Slic3r;
+
+namespace {
+
+// The upper plate overhangs both the lower plate and open air, so branches land on the model and on
+// the bed in the same slice.
+TriangleMesh two_tier_mesh()
+{
+    TriangleMesh lower  = make_cube(30, 30, 3);
+    TriangleMesh column = make_cube(8, 8, 15);
+    TriangleMesh upper  = make_cube(50, 50, 3);
+    // Each part overlaps the one below rather than resting on it; a coplanar join slices ambiguously.
+    column.translate(11.f, 11.f, 2.f);
+    upper.translate(-10.f, -10.f, 16.f);
+    TriangleMesh mesh = lower;
+    mesh.merge(column);
+    mesh.merge(upper);
+    return mesh;
+}
+
+TriangleMesh scaled(TestMesh id, float scale)
+{
+    TriangleMesh mesh = Slic3r::Test::mesh(id);
+    mesh.scale(scale);
+    return mesh;
+}
+
+// `extra` is applied last, so a caller can add or override any key.
+void slice_with_tree_support(const TriangleMesh &mesh, Slic3r::Print &print, const char *style,
+                             int threshold_angle = 30, int build_plate_only = 0, int raft_layers = 0,
+                             std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> extra = {})
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "enable_support",              1 },
+        { "support_type",                "tree(auto)" },
+        { "support_style",               style },
+        { "support_on_build_plate_only", build_plate_only },
+        { "support_threshold_angle",     threshold_angle },
+        { "raft_layers",                 raft_layers },
+        { "layer_height",                0.2 },
+    });
+    config.set_deserialize_strict(extra);
+    Slic3r::Test::init_and_process_print({ mesh }, print, config);
+}
+
+Points support_points(const Slic3r::Print &print)
+{
+    Points points;
+    for (const SupportLayer *layer : print.objects().front()->support_layers())
+        layer->support_fills.collect_points(points);
+    return points;
+}
+
+size_t support_point_count(const TriangleMesh &mesh, const char *style, int threshold_angle = 30,
+                           int build_plate_only = 0)
+{
+    Slic3r::Print print;
+    slice_with_tree_support(mesh, print, style, threshold_angle, build_plate_only);
+    return support_points(print).size();
+}
+
+// Index of the first differing point, or the common length when they match. An index keeps a
+// failure readable; comparing the vectors themselves dumps thousands of points.
+size_t first_difference(const Points &a, const Points &b)
+{
+    const size_t common = std::min(a.size(), b.size());
+    for (size_t i = 0; i < common; ++i)
+        if (a[i] != b[i])
+            return i;
+    return common;
+}
+
+// Slice `mesh` twice and require an identical support point sequence. Point counts and total
+// length are order insensitive, so the sequence is what a reordering shows up in.
+void sliced_twice_matches(const TriangleMesh &mesh, int build_plate_only, const char *style = "tree_slim",
+                          std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> extra = {})
+{
+    Slic3r::Print first_print, second_print;
+    slice_with_tree_support(mesh, first_print, style, 30, build_plate_only, 0, extra);
+    slice_with_tree_support(mesh, second_print, style, 30, build_plate_only, 0, extra);
+    const Points first  = support_points(first_print);
+    const Points second = support_points(second_print);
+    REQUIRE(first.size() > 1000); // without support the comparison below passes vacuously
+    REQUIRE(second.size() == first.size());
+    REQUIRE(first_difference(first, second) == first.size());
+}
+
+} // namespace
+
+TEST_CASE("Tree support is generated for an overhang and not for a plain cube", "[TreeSupport]")
+{
+    REQUIRE(support_point_count(scaled(TestMesh::overhang, 2.f), "tree_slim") > 1000);
+    REQUIRE(support_point_count(Slic3r::Test::cube(20), "tree_slim") == 0);
+}
+
+TEST_CASE("Restricting tree support to the build plate changes what is generated", "[TreeSupport]")
+{
+    const TriangleMesh mesh = two_tier_mesh();
+    const size_t anywhere    = support_point_count(mesh, "tree_slim", 30, 0);
+    const size_t plate_only  = support_point_count(mesh, "tree_slim", 30, 1);
+    REQUIRE(anywhere > 1000);
+    REQUIRE(plate_only > 1000);
+    // The upper plate overhangs the lower one, so some branches would land on the model.
+    REQUIRE(plate_only != anywhere);
+}
+
+TEST_CASE("Tree support layers rise monotonically within the layer height limits", "[TreeSupport]")
+{
+    Slic3r::Print print;
+    slice_with_tree_support(scaled(TestMesh::overhang, 2.f), print, "tree_slim");
+    const double nozzle = print.config().nozzle_diameter.values.front();
+
+    size_t checked = 0;
+    double previous = 0;
+    bool   previous_was_adjacent = false;
+    for (const SupportLayer *layer : print.objects().front()->support_layers()) {
+        if (layer->print_z <= 0 || layer->height <= 0) {
+            // Layers with no nodes are left at zero. Skipping one leaves a hole, so the next pair
+            // spans more than one layer and its gap says nothing about the layer height limit.
+            previous_was_adjacent = false;
+            continue;
+        }
+        if (previous > 0) {
+            CAPTURE(previous, layer->print_z);
+            REQUIRE(layer->print_z > previous);
+            if (previous_was_adjacent)
+                REQUIRE(layer->print_z - previous <= nozzle + EPSILON);
+        }
+        previous = layer->print_z;
+        previous_was_adjacent = true;
+        ++checked;
+    }
+    REQUIRE(checked > 10);
+}
+
+TEST_CASE("A raft is still generated under tree support", "[TreeSupport]")
+{
+    // The mesh supports itself, so a layer count alone passes with no raft at all.
+    Slic3r::Print rafted, unrafted;
+    slice_with_tree_support(scaled(TestMesh::overhang, 2.f), rafted, "tree_slim", 30, 0, 3);
+    slice_with_tree_support(scaled(TestMesh::overhang, 2.f), unrafted, "tree_slim", 30, 0, 0);
+    const PrintObject *rafted_object   = rafted.objects().front();
+    const PrintObject *unrafted_object = unrafted.objects().front();
+    REQUIRE(rafted_object->support_layers().size() > unrafted_object->support_layers().size());
+    // The raft goes under the object.
+    REQUIRE(rafted_object->layers().front()->print_z > unrafted_object->layers().front()->print_z);
+}
+
+// drop_nodes() decides the node merges and spawns the next layer's nodes in parallel. Every one of
+// those decisions has to be applied in a fixed order, or the same model gives different branches on
+// each slice.
+TEST_CASE("Tree support toolpaths do not depend on thread scheduling", "[TreeSupport][Regression]")
+{
+    // Scaled up so that a layer holds enough nodes for the parallel range to be split. At stock
+    // size it stays in one chunk and the order never varies.
+    SECTION("overhang")            { sliced_twice_matches(scaled(TestMesh::overhang, 2.f), 0); }
+    SECTION("bridge with hole")    { sliced_twice_matches(scaled(TestMesh::bridge_with_hole, 3.f), 0); }
+    // Dropping every branch that cannot reach the bed leaves the survivors dense enough that the
+    // neighbour merge fires in bulk.
+    SECTION("on the build plate")  { sliced_twice_matches(scaled(TestMesh::overhang, 4.f), 1); }
+    // Branches resting on the model are what put nodes in a part group other than 0, which is the
+    // only way to reach the prune in the second pass. tree_hybrid additionally builds polygon
+    // nodes, so it is the only style that exercises the overhang merge.
+    SECTION("resting on the model") { sliced_twice_matches(two_tier_mesh(), 0); }
+    SECTION("hybrid on the model")  { sliced_twice_matches(two_tier_mesh(), 0, "tree_hybrid"); }
+}
+
+// Prim breaks equal-distance ties by heap address. A 1 mm branch diameter puts neighbours close
+// enough to tie, and an explicit line width pins max_move_dist, so the moved tie winner reaches
+// the support toolpaths.
+TEST_CASE("Tree support toolpaths do not depend on the MST tie order", "[TreeSupport][Regression]")
+{
+    sliced_twice_matches(two_tier_mesh(), 0, "tree_hybrid", {
+        { "tree_support_branch_diameter", 1.0 },
+        { "tree_support_branch_distance", 5.0 },
+        { "tree_support_branch_angle",    40 },
+        { "support_line_width",           0.4 },
+    });
+}

tests/fff_print/test_wipe_tower.cpp

@@ -152,6 +152,8 @@ static DynamicPrintConfig wipe_tower_toolchange_config(const std::string &gcode_
         { "outer_wall_filament_id",     2 },
         { "inner_wall_filament_id",     2 },
         { "enable_prime_tower",         true },
+        { "wipe_tower_x",               50 }, // inside the 200x200 test bed
+        { "wipe_tower_y",               50 }, // (the default y, 220, is not)
         { "layer_height",               0.3 },
         { "gcode_flavor",               gcode_flavor },
     });
@@ -182,3 +184,148 @@ TEST_CASE("The wipe tower's toolchange planner flush follows the gcode flavor",
         CHECK_THAT(tower, !Catch::Matchers::ContainsSubstring(unexpected));
     }
 }
+
+// What Print feeds the shared estimate. The libslic3r WipeTowerEstimate cases cannot see this:
+// they call the estimator directly. The estimate counts the filaments the print really uses,
+// so the two-filament shape gives the outer wall the second one.
+static DynamicPrintConfig tower_estimate_config(const char *wall_type, unsigned int filaments = 2)
+{
+    // 100 mm3 per purge on a 50 mm wide tower: one purge is 100/(layer_height * 50) of depth.
+    return multifilament_config(filaments, {
+        { "outer_wall_filament_id",         filaments == 2 ? "2" : "1" },
+        { "enable_prime_tower",             "1"       },
+        { "wipe_tower_wall_type",           wall_type },
+        { "prime_tower_width",              "50"      },
+        { "prime_volume",                   "100"     },
+        { "prime_tower_infill_gap",         "100%"    },
+        { "prime_tower_brim_width",         "3"       },
+        { "purge_in_prime_tower",           "0"       },
+        { "single_extruder_multi_material", "0"       },
+        { "timelapse_type",                 "0"       },
+        { "layer_height",                   "0.2"     },
+        { "enable_wrapping_detection",      "0"       },
+        { "raft_layers",                    "0"       } });
+}
+
+TEST_CASE("The tower is sized for the thinnest layer any object on the plate is sliced at", "[WipeTower]")
+{
+    // The tower has to survive its thinnest layer, so an override finer than the preset drives
+    // the estimate even on the second object. Two 20 mm cubes, the second at 0.1 mm.
+    const DynamicPrintConfig config = tower_estimate_config("rectangle");
+    const std::vector<std::vector<ConfigBase::SetDeserializeItem>> overrides = {
+        {}, { { "layer_height", "0.1" } } };
+
+    Print print;
+    Model model;
+    init_print({ cube(20), cube(20) }, print, model, config, &overrides);
+
+    // One purge at 0.1 mm: 100 / (0.1 * 50) = 20 mm, above the 20 mm-tall tower's stability
+    // floor. At the preset's 0.2 mm it would be half that, so the two are easy to tell apart.
+    const float floor_20mm = WipeTower::get_limit_depth_by_height(20.f);
+    REQUIRE(floor_20mm < 10.f);
+    CHECK_THAT(print.wipe_tower_data(2).depth, Catch::Matchers::WithinAbs(20., 1e-4));
+}
+
+TEST_CASE("Validation is given the tower's effective width, not the configured one", "[WipeTower]")
+{
+    // A rib wall squares the tower, so its width is its depth. Validation reads this rather
+    // than re-deriving the rule from the wall type.
+    Print print;
+    Model model;
+
+    SECTION("a rectangle wall keeps the configured width") {
+        const DynamicPrintConfig config = tower_estimate_config("rectangle");
+        init_print({ cube(20) }, print, model, config);
+        const WipeTowerData &data = print.wipe_tower_data(2);
+        CHECK_THAT(data.width, Catch::Matchers::WithinAbs(50., 1e-4));
+        CHECK(data.depth < data.width);
+    }
+
+    SECTION("a rib wall reports the squared footprint") {
+        const DynamicPrintConfig config = tower_estimate_config("rib");
+        init_print({ cube(20) }, print, model, config);
+        const WipeTowerData &data = print.wipe_tower_data(2);
+        CHECK_THAT(data.width, Catch::Matchers::WithinAbs(data.depth, 1e-4));
+        CHECK(data.width > 0.f);
+    }
+}
+
+TEST_CASE("Generating the tower keeps its reported width current", "[WipeTower]")
+{
+    // width is handed out after the slice, so leaving it at the estimate reports a zero-width
+    // tower to every post-generation consumer.
+    const DynamicPrintConfig config = wipe_tower_toolchange_config("marlin");
+    Print print;
+    Model model;
+    init_print({ cube(10) }, print, model, config);
+    print.apply(model, config);
+    REQUIRE(print.wipe_tower_data(2).width > 0.f);
+
+    print.process();
+    REQUIRE(print.is_step_done(psWipeTower));
+    const WipeTowerData &data = print.wipe_tower_data();
+    // A width the generator never wrote reads as zero. A rib wall squares the tower, so the
+    // generated width is the body square: under the configured 50 mm, and inside the depth.
+    CHECK(data.width > 0.f);
+    CHECK(data.width < 50.f);
+    CHECK(data.width <= data.depth + EPSILON);
+}
+
+TEST_CASE("A single-filament plate reserves a tower only when one is actually printed", "[WipeTower]")
+{
+    // The estimate has to answer this the way Print::apply does: reporting no tower for one
+    // that is built collapses the validation hull to a point, and reporting one for a tower
+    // that is not built takes that bed area away from the arranger and draws a preview box
+    // over nothing.
+    Print print;
+    Model model;
+
+    SECTION("no tool change and nothing else that prints one") {
+        const DynamicPrintConfig config = tower_estimate_config("rib", 1);
+        init_print({ cube(20) }, print, model, config);
+        REQUIRE_FALSE(print.has_wipe_tower());
+        CHECK_THAT(print.wipe_tower_data(1).depth, Catch::Matchers::WithinAbs(0., 1e-6));
+    }
+
+    // A raft puts the tower on every layer below the object, but only where there is a tower:
+    // Print::apply runs normalize_fdm_2, which clears enable_prime_tower for a plate that
+    // purges one filament and has neither smooth timelapse nor wrapping detection on.
+    SECTION("a raft alone does not print one") {
+        DynamicPrintConfig config = tower_estimate_config("rib", 1);
+        config.set_deserialize_strict({ { "raft_layers", "3" } });
+        init_print({ cube(20) }, print, model, config);
+        REQUIRE_FALSE(print.config().enable_prime_tower.value);
+        REQUIRE_FALSE(print.has_wipe_tower());
+        CHECK_THAT(print.wipe_tower_data(1).depth, Catch::Matchers::WithinAbs(0., 1e-6));
+    }
+
+    SECTION("smooth timelapse prints one, and keeps enable_prime_tower on") {
+        DynamicPrintConfig config = tower_estimate_config("rib", 1);
+        config.set_deserialize_strict({ { "timelapse_type", "1" } });
+        init_print({ cube(20) }, print, model, config);
+        REQUIRE(print.has_wipe_tower());
+        CHECK(print.wipe_tower_data(1).depth > 0.f);
+    }
+}
+
+TEST_CASE("A tower printed without a tool change is still validated against the bed", "[WipeTower]")
+{
+    // Wrapping detection prints a tower on a plate that purges one filament. Neither the old
+    // estimate (which read the wall type and smooth timelapse) nor the old containment gate (the
+    // filament count or smooth timelapse) knew about it, so between them that tower was never
+    // checked against the bed.
+    Print print;
+    Model model;
+    DynamicPrintConfig config = tower_estimate_config("rectangle", 1);
+    // Relative E without a per-layer G92 is rejected before the tower is ever looked at, and
+    // has_wipe_tower() wants a real exclusion polygon before it honours wrapping detection.
+    config.set_deserialize_strict({ { "enable_wrapping_detection", "1" },
+                                    { "wrapping_exclude_area", "180x180,190x180,190x190,180x190" },
+                                    { "wipe_tower_x", "500" }, { "wipe_tower_y", "500" },                                    { "use_relative_e_distances", "0" } });
+
+    init_print({ cube(20) }, print, model, config);
+    REQUIRE(print.extruders(true).size() == 1);
+    REQUIRE(print.has_wipe_tower());
+    CHECK(print.wipe_tower_data(1).depth > 0.f);
+    CHECK_THAT(print.validate().string, Catch::Matchers::ContainsSubstring("printable area"));
+}

tests/libslic3r/CMakeLists.txt

@@ -9,6 +9,7 @@ add_executable(${_TEST_NAME}_tests
     test_arrange.cpp
     test_bambu_networking.cpp
     test_belt_brim.cpp
+    test_buildvolume.cpp
     test_calib.cpp
     test_clipper_offset.cpp
     test_clipper_utils.cpp
@@ -19,6 +20,7 @@ add_executable(${_TEST_NAME}_tests
     test_preset_setting_id.cpp
     test_preset_diff.cpp
     test_vendor_cache.cpp
+    test_preset_options.cpp
     test_elephant_foot_compensation.cpp
     test_fill_corner_smoothing.cpp
     test_filament_mixer.cpp
@@ -29,6 +31,7 @@ add_executable(${_TEST_NAME}_tests
     test_polygon.cpp
     test_mutable_polygon.cpp
     test_mutable_priority_queue.cpp
+    test_minimum_spanning_tree.cpp
     test_nozzle_volume_type.cpp
     test_step.cpp
     test_stl.cpp
@@ -39,6 +42,8 @@ add_executable(${_TEST_NAME}_tests
     test_utils.cpp
     test_timeutils.cpp
     test_voronoi.cpp
+    test_wipe_tower_estimate.cpp
+    test_wipe_tower.cpp
     test_optimizers.cpp
     test_ordering_strategies.cpp
     # test_png_io.cpp

tests/libslic3r/test_3mf.cpp

@@ -1,6 +1,5 @@
 
 #include "libslic3r/Model.hpp"
-#include "libslic3r/TriangleSelector.hpp"
 #include "libslic3r/Format/3mf.hpp"
 #include "libslic3r/Format/bbs_3mf.hpp"
 #include "libslic3r/Format/STL.hpp"
@@ -9,9 +8,12 @@
 #include "libslic3r/Preset.hpp"
 #include "libslic3r/MultiNozzleUtils.hpp"
 #include "libslic3r/ProjectTask.hpp"
+#include "libslic3r/PublishSettings.hpp"
 
 #include "test_utils.hpp"
 
+#include <nlohmann/json.hpp>
+
 #include <boost/filesystem/operations.hpp>
 
 #include <catch2/catch_tostring.hpp>
@@ -499,7 +501,6 @@ SCENARIO("Nozzle-group metadata .3mf round-trip", "[3mf][MultiNozzle]") {
     }
 }
 
-
 // A mixed-color filament occupies an ordinary filament slot, and painting with it stores an
 // ordinary extruder state: a project saved by BambuStudio encodes filament 5 of a 5-slot setup
 // as paint state 5, with the mix described by the parallel filament_mixed_* project arrays.
@@ -590,3 +591,639 @@ SCENARIO("Mixed-color filament setup and painting round-trip through a .3mf", "[
         }
     }
 }
+// Locks the serialization contract of the "Publish" metadata: the orca_published flag and the
+// orca_published_keys JSON array in model.model_info->metadata_items must survive a store_bbs_3mf ->
+// load_bbs_3mf round-trip unchanged. (The full preset-preservation behavior is exercised
+// headlessly in test_preset_bundle_loading.cpp.)
+SCENARIO("Published 3MF round-trips the published flag and published_keys metadata", "[3mf]") {
+    GIVEN("a model carrying published metadata") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_TAG]      = "1";
+        model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] = R"(["layer_height","wall_thickness"])";
+
+        // store_bbs_3mf stages project_settings.config through the model's backup path; point
+        // it at a writable temp dir (the default lives under a read-only root in CI).
+        ScopedTemporaryDir backup_dir("orca_pub");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored to and reloaded from a .3mf") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> project_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the published metadata round-trips unchanged") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_TAG] == "1");
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] == R"(["layer_height","wall_thickness"])");
+
+                // The orca_published_keys value is a JSON array of setting keys; it must parse back to
+                // the same keys that were selected.
+                nlohmann::json keys = nlohmann::json::parse(dst_model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG]);
+                REQUIRE(keys.is_array());
+                REQUIRE(keys.size() == 2);
+                REQUIRE(keys[0] == "layer_height");
+                REQUIRE(keys[1] == "wall_thickness");
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+// A normal 3MF (no Publish metadata) must load identically: the loader must not fabricate a
+// "orca_published" flag or orca_published_keys for files that never carried them.
+SCENARIO("Legacy 3MF without published metadata loads unchanged", "[3mf]") {
+    GIVEN("a model without any published metadata") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        ScopedTemporaryDir backup_dir("orca_legacy");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored to and reloaded from a .3mf") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> project_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("no published key is fabricated") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items.count(ORCA_PUBLISHED_TAG) == 0);
+                REQUIRE(dst_model.model_info->metadata_items.count(ORCA_PUBLISHED_KEYS_TAG) == 0);
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+// Locks the serialization contract of the orca_published_material_keys metadata: the per-entry JSON
+// must survive a store_bbs_3mf -> load_bbs_3mf round-trip verbatim, exactly like orca_published_keys.
+SCENARIO("Published 3MF round-trips the published_material_keys metadata", "[3mf]") {
+    GIVEN("a model carrying published material keys metadata") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        const std::string material_keys_json =
+            R"([{"material":{"filament_type":"PLA","filament_vendor":"Generic","filament_id":"GFL99"},"slot":0,"keys":["filament_retraction_length","filament_z_hop"]}])";
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = material_keys_json;
+
+        ScopedTemporaryDir backup_dir("orca_pub_mat");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored to and reloaded from a .3mf") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> project_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the published material keys metadata round-trips unchanged") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] == material_keys_json);
+
+                // The value must parse back to one material entry carrying the nested identity
+                // object, the author slot ordinal and the key list.
+                nlohmann::json entries = nlohmann::json::parse(material_keys_json);
+                REQUIRE(entries.is_array());
+                REQUIRE(entries.size() == 1);
+                REQUIRE(entries[0]["material"]["filament_type"] == "PLA");
+                REQUIRE(entries[0]["material"]["filament_vendor"] == "Generic");
+                REQUIRE(entries[0]["material"]["filament_id"] == "GFL99");
+                REQUIRE(entries[0]["slot"] == 0);
+                REQUIRE(entries[0]["keys"].is_array());
+                REQUIRE(entries[0]["keys"].size() == 2);
+                REQUIRE(entries[0]["keys"][0] == "filament_retraction_length");
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+SCENARIO("Minimal published 3MF omits project config, preset dumps and slicer tags", "[3mf]") {
+    GIVEN("a multi-instance model carrying published metadata and a published_config payload") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+        // A second instance: tag-less third-party files get their multi-instance objects split,
+        // published files must not (the loader recognizes them by their metadata).
+        model.objects.front()->add_instance();
+
+        DynamicPrintConfig full_cfg = DynamicPrintConfig::full_print_config();
+        full_cfg.set_key_value("layer_height", new ConfigOptionFloat(0.24));
+        full_cfg.set_key_value("retraction_length", new ConfigOptionFloats({ 1.2 }));
+
+        const std::vector<std::string> published_keys = { "layer_height", "retraction_length" };
+        const std::vector<PublishedMaterialEntry> material_keys = {
+            { "PLA", "Generic", "GFL99", "", "Generic PLA", 0, { "filament_retraction_length" } }
+        };
+
+        // The payload builder keeps the published and identity keys and drops everything else.
+        DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, published_keys, material_keys);
+        REQUIRE(filtered_cfg.option("layer_height") != nullptr);
+        REQUIRE(filtered_cfg.option("retraction_length") != nullptr);
+        REQUIRE(filtered_cfg.option("filament_colour") != nullptr);
+        REQUIRE(filtered_cfg.option("filament_type") != nullptr);
+        REQUIRE(filtered_cfg.option("wipe_tower_x") != nullptr);
+        REQUIRE(filtered_cfg.option("sparse_infill_density") == nullptr);
+        REQUIRE(filtered_cfg.option("machine_start_gcode") == nullptr);
+
+        // Serialize the payload exactly like export_published_3mf does.
+        std::string payload;
+        for (const std::string &key : filtered_cfg.keys())
+            payload += key + " = " + filtered_cfg.opt_serialize(key) + "\n";
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_TAG]      = "1";
+        model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] = R"(["layer_height","retraction_length"])";
+        model.model_info->metadata_items[ORCA_PUBLISHED_CONFIG_TAG] = payload;
+
+        ScopedTemporaryDir backup_dir("orca_min_pub");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored using SaveStrategy::MinimalPublished and reloaded") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            // Create a fake project preset to verify MinimalPublished omits it.
+            Preset preset(Preset::TYPE_PRINT, "TestPrintPreset");
+            preset.config = full_cfg;
+            std::vector<Preset*> project_presets = { &preset };
+
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &filtered_cfg;
+            store_params.project_presets = project_presets;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::MinimalPublished;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            ScopedTemporaryDir loaded_backup_dir("orca_min_pub_loaded");
+            dst_model.set_backup_path(loaded_backup_dir.string());
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> loaded_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &loaded_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the 3MF loads without project config or embedded presets") {
+                REQUIRE(loaded);
+                REQUIRE(dst_config.empty());
+                REQUIRE(loaded_presets.empty());
+            }
+            THEN("the file carries no slicer tags and classifies as a generic 3MF") {
+                REQUIRE_FALSE(is_bbl_3mf);
+                REQUIRE_FALSE(is_orca_3mf);
+                // No Application / OrcaSlicer tag: old receivers import the geometry silently
+                // instead of showing a baked-in, wrong "old version" popup.
+                REQUIRE_FALSE(file_version.valid());
+            }
+            THEN("the geometry keeps BBS-grade handling: instances are not split") {
+                REQUIRE(dst_model.objects.size() == 1);
+                REQUIRE(dst_model.objects.front()->instances.size() == 2);
+            }
+            THEN("the published metadata and payload round-trip unchanged") {
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_TAG] == "1");
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] == R"(["layer_height","retraction_length"])");
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_CONFIG_TAG] == payload);
+            }
+            THEN("the payload parses back to the published values") {
+                DynamicPrintConfig parsed_payload;
+                parsed_payload.load_from_ini_string(dst_model.model_info->metadata_items[ORCA_PUBLISHED_CONFIG_TAG], ForwardCompatibilitySubstitutionRule::Enable);
+                REQUIRE(parsed_payload.option("layer_height") != nullptr);
+                REQUIRE_THAT(parsed_payload.opt_float("layer_height"), Catch::Matchers::WithinAbs(0.24, 1e-6));
+                REQUIRE(parsed_payload.option("retraction_length") != nullptr);
+                REQUIRE_THAT(parsed_payload.opt<ConfigOptionFloats>("retraction_length")->get_at(0), Catch::Matchers::WithinAbs(1.2, 1e-6));
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+// A minimal published 3MF must not leak the slicer tags of the source project. The exporter seeds
+// metadata_item_map from the input file's metadata_items, so re-publishing a project opened from a
+// regular Orca/BBS 3MF (the typical remix flow) must strip the Application / OrcaSlicer tags it
+// came with, otherwise old receivers route onto the baked-in "old version" popup.
+SCENARIO("MinimalPublished strips slicer tags carried by the source project", "[3mf]") {
+    GIVEN("a model loaded from a regular Orca/BBS 3MF whose metadata carries the slicer tags") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_TAG] = "1";
+        model.model_info->metadata_items["Application"]     = "BambuStudio-2.0.0";
+        model.model_info->metadata_items["OrcaSlicer"]      = "2.1.0";
+
+        ScopedTemporaryDir backup_dir("orca_strip_tags");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored using SaveStrategy::MinimalPublished and reloaded") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::MinimalPublished;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> loaded_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &loaded_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the source slicer tags are stripped, not carried through") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items.count("Application") == 0);
+                REQUIRE(dst_model.model_info->metadata_items.count("OrcaSlicer") == 0);
+                // The published marker itself must survive.
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_TAG] == "1");
+            }
+            THEN("the file classifies as a generic 3MF without a version popup") {
+                REQUIRE_FALSE(is_bbl_3mf);
+                REQUIRE_FALSE(is_orca_3mf);
+                REQUIRE_FALSE(file_version.valid());
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+// An entry masks the non-published slots to their defaults so publishing slot 1 never leaks slot
+// 0's value into the file. Both a full entry (the whole-slot key list) and a partial entry (a
+// per-slot key) go through the same masking path in filter_published_config (keys and full_keys
+// are filtered identically), so the two forms are exercised together.
+SCENARIO("Published entries mask the other slots to their defaults", "[3mf]") {
+    const bool full = GENERATE(true, false);
+    GIVEN("a full print configuration with two filament slots") {
+        DynamicPrintConfig full_cfg = DynamicPrintConfig::full_print_config();
+        full_cfg.opt<ConfigOptionFloats>("filament_diameter")->values = { 1.75, 1.75 };
+        full_cfg.opt<ConfigOptionStrings>("filament_colour")->values = { "#111111", "#222222" };
+        // filament_flow_ratio carries a non-empty option default (1.0) of the same type, so the
+        // mask can restore it on the non-published slot.
+        full_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio", true)->values = { 1.02, 0.98 };
+
+        WHEN("filtering with a published entry for slot 1") {
+            PublishedMaterialEntry entry;
+            entry.slot = 1;
+            if (full) {
+                entry.full      = true;
+                entry.full_keys = { "filament_flow_ratio" };
+            } else {
+                entry.keys = { "filament_flow_ratio" };
+            }
+            DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, {}, { entry });
+
+            THEN("the selected key is present with the author's slot value") {
+                REQUIRE(filtered_cfg.option("filament_flow_ratio") != nullptr);
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio")->values[1], Catch::Matchers::WithinAbs(0.98, 1e-6));
+            }
+            THEN("the non-published slot is masked to its default") {
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio")->values[0], Catch::Matchers::WithinAbs(1.0, 1e-6));
+            }
+            THEN("the identity keys stay present") {
+                REQUIRE(filtered_cfg.option("filament_colour") != nullptr);
+            }
+        }
+    }
+}
+
+// A key needing slot masking that cannot be masked (no registered option default of the same
+// type) is dropped from the payload entirely instead of shipping the author's whole vector.
+SCENARIO("Unmaskable keys are dropped from the published payload instead of leaking", "[3mf]") {
+    GIVEN("a config carrying a synthetic def-less vector key and a maskable one") {
+        DynamicPrintConfig full_cfg = DynamicPrintConfig::full_print_config();
+        full_cfg.opt<ConfigOptionFloats>("filament_diameter")->values = { 1.75, 1.75 };
+        full_cfg.opt<ConfigOptionStrings>("filament_colour")->values  = { "#111111", "#222222" };
+        // Not a PrintConfig key: print_config_def has no default to mask with.
+        full_cfg.set_key_value("orca_synthetic_setting", new ConfigOptionFloats({ 9.9, 8.8 }));
+        full_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio", true)->values = { 1.02, 0.98 };
+
+        PublishedMaterialEntry partial_entry;
+        partial_entry.slot = 1;
+        partial_entry.keys = { "orca_synthetic_setting", "filament_flow_ratio" };
+
+        WHEN("filtering with a partial entry for slot 1") {
+            DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, {}, { partial_entry });
+
+            THEN("the unmaskable synthetic key is not published") {
+                REQUIRE(filtered_cfg.option("orca_synthetic_setting") == nullptr);
+            }
+            THEN("the maskable key is present, author slot kept, other slot masked") {
+                REQUIRE(filtered_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio") != nullptr);
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio")->values[1], Catch::Matchers::WithinAbs(0.98, 1e-6));
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloatsNullable>("filament_flow_ratio")->values[0], Catch::Matchers::WithinAbs(1.0, 1e-6));
+            }
+            THEN("the identity keys stay present") {
+                REQUIRE(filtered_cfg.option("filament_colour") != nullptr);
+            }
+        }
+    }
+}
+
+// A per-extruder printer key carrying a "#N" variant (e.g. retraction_length#1) must not serialize
+// every extruder's value: the base is masked to the author's extruder and the other slots are
+// restored to their option default, matching the material-side slot-masking invariant. A bare
+// printer base key (no variant) keeps whole-vector serialization.
+SCENARIO("Published per-extruder printer keys mask the other extruders to their defaults", "[3mf]") {
+    GIVEN("a full print configuration with three extruders carrying per-extruder retraction values") {
+        DynamicPrintConfig full_cfg = DynamicPrintConfig::full_print_config();
+        // Non-default values on the un-selected slots, so a leak is distinguishable from the mask
+        // restoring the option default (retraction_length defaults to {0.8}).
+        full_cfg.opt<ConfigOptionFloats>("retraction_length")->values = { 3.0, 1.2, 4.0 };
+
+        WHEN("filtering with only extruder 1's retraction_length checked") {
+            DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, { "retraction_length#1" }, {});
+
+            THEN("the author's extruder value survives") {
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[1], Catch::Matchers::WithinAbs(1.2, 1e-6));
+            }
+            THEN("the other extruders are masked to their default") {
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[0], Catch::Matchers::WithinAbs(0.8, 1e-6));
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[2], Catch::Matchers::WithinAbs(0.8, 1e-6));
+            }
+        }
+        WHEN("filtering the bare base key without a '#N' variant") {
+            DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, { "retraction_length" }, {});
+
+            THEN("the whole vector is serialized unmasked") {
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[0], Catch::Matchers::WithinAbs(3.0, 1e-6));
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[1], Catch::Matchers::WithinAbs(1.2, 1e-6));
+                REQUIRE_THAT(filtered_cfg.opt<ConfigOptionFloats>("retraction_length")->values[2], Catch::Matchers::WithinAbs(4.0, 1e-6));
+            }
+        }
+    }
+}
+
+// The extended per-entry fields (full dump list, published type and colour) travel inside the
+// published_material_keys metadata and round-trip unchanged.
+SCENARIO("Published 3MF round-trips the extended material metadata", "[3mf]") {
+    GIVEN("a model carrying extended published material keys metadata") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        const std::string material_keys_json =
+            R"([{"material":{"filament_type":"PLA","filament_vendor":"Generic","filament_id":"GFL99","setting_id":"RFs9eCKYOMUSmvZf","name":"Generic PLA Matte @System"},"slot":1,"keys":[],"full":true,"full_keys":["filament_retraction_length","filament_colour"],"publish_type":true,"type":"PLA","publish_color":false,"color":""}])";
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = material_keys_json;
+
+        ScopedTemporaryDir backup_dir("orca_pub_mat2");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored to and reloaded from a .3mf") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path     = test_file.c_str();
+            store_params.model    = &model;
+            store_params.config   = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> project_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the extended material metadata round-trips unchanged") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] == material_keys_json);
+
+                // The value must parse back with every extended field intact.
+                nlohmann::json entries = nlohmann::json::parse(material_keys_json);
+                REQUIRE(entries.is_array());
+                REQUIRE(entries.size() == 1);
+                REQUIRE(entries[0]["full"].get<bool>() == true);
+                REQUIRE(entries[0]["full_keys"].is_array());
+                REQUIRE(entries[0]["full_keys"].size() == 2);
+                REQUIRE(entries[0]["publish_type"].get<bool>() == true);
+                REQUIRE(entries[0]["type"] == "PLA");
+                REQUIRE(entries[0]["publish_color"].get<bool>() == false);
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
+// A published mixed filament serializes its whole definition (components, ratios, gradient)
+// masked to the author's slot: the mix slot's values survive, the non-published slots reset to
+// their defaults, so a partial publish never leaks another slot's mix data.
+SCENARIO("Published mixed-filament keys are masked to the author's slot", "[3mf]") {
+    GIVEN("a full print configuration with three slots, one of them mixed") {
+        DynamicPrintConfig full_cfg = DynamicPrintConfig::full_print_config();
+        full_cfg.opt<ConfigOptionFloats>("filament_diameter")->values = { 1.75, 1.75, 1.75 };
+        full_cfg.opt<ConfigOptionStrings>("filament_colour")->values  = { "#111111", "#222222", "#333333" };
+        full_cfg.opt<ConfigOptionBools>("filament_is_mixed")->values  = { 0, 0, 1 };
+        full_cfg.opt<ConfigOptionStrings>("filament_mixed_components")->values       = { "", "", "1,2" };
+        full_cfg.opt<ConfigOptionStrings>("filament_mixed_sublayer_ratios")->values   = { "", "", "0.6,0.4" };
+        full_cfg.opt<ConfigOptionBools>("filament_mixed_gradient")->values            = { 0, 0, 1 };
+        full_cfg.opt<ConfigOptionStrings>("filament_mixed_gradient_range")->values    = { "", "", "0.9,0.1" };
+        full_cfg.opt<ConfigOptionStrings>("filament_mixed_gradient_curve")->values    = { "", "", "0,0.1|1,0.9" };
+        full_cfg.opt<ConfigOptionBools>("filament_mixed_gradient_per_part")->values   = { 0, 0, 1 };
+
+        PublishedMaterialEntry mix_entry;
+        mix_entry.slot = 2;
+        mix_entry.keys = {
+            "filament_is_mixed",          "filament_mixed_components",       "filament_mixed_sublayer_ratios",
+            "filament_mixed_gradient",    "filament_mixed_gradient_range",   "filament_mixed_gradient_curve",
+            "filament_mixed_gradient_per_part"
+        };
+
+        WHEN("filtering with a mixed entry for slot 2") {
+            DynamicPrintConfig filtered_cfg = filter_published_config(full_cfg, {}, { mix_entry });
+
+            THEN("the author's mixed slot keeps its definition") {
+                REQUIRE(filtered_cfg.option("filament_is_mixed") != nullptr);
+                REQUIRE(filtered_cfg.opt<ConfigOptionBools>("filament_is_mixed")->values == std::vector<unsigned char>{ 0, 0, 1 });
+                const auto& components = filtered_cfg.opt<ConfigOptionStrings>("filament_mixed_components")->values;
+                REQUIRE(components.size() == 3);
+                CHECK(components[2] == "1,2");
+                CHECK(filtered_cfg.opt<ConfigOptionStrings>("filament_mixed_sublayer_ratios")->values[2] == "0.6,0.4");
+                CHECK(filtered_cfg.opt<ConfigOptionStrings>("filament_mixed_gradient_curve")->values[2] == "0,0.1|1,0.9");
+                CHECK(filtered_cfg.opt<ConfigOptionBools>("filament_mixed_gradient")->values[2]);
+                CHECK(filtered_cfg.opt<ConfigOptionBools>("filament_mixed_gradient_per_part")->values[2]);
+            }
+            THEN("the non-published slots are masked to their defaults") {
+                CHECK(filtered_cfg.opt<ConfigOptionStrings>("filament_mixed_components")->values[0] == "");
+                CHECK(filtered_cfg.opt<ConfigOptionStrings>("filament_mixed_components")->values[1] == "");
+                CHECK(filtered_cfg.opt<ConfigOptionBools>("filament_is_mixed")->values[0] == 0);
+                CHECK(filtered_cfg.opt<ConfigOptionBools>("filament_is_mixed")->values[1] == 0);
+            }
+            THEN("the identity keys stay present") {
+                REQUIRE(filtered_cfg.option("filament_colour") != nullptr);
+            }
+        }
+    }
+}
+
+// The published flag is gated on the exact string "1": any other serialized value means "not
+// published", so a receiver never treats a file as published on a loose truthiness check.
+TEST_CASE("is_published_3mf_flag accepts only the literal \"1\"", "[3mf]") {
+    CHECK(is_published_3mf_flag("1"));
+    CHECK_FALSE(is_published_3mf_flag("0"));
+    CHECK_FALSE(is_published_3mf_flag("false"));
+    CHECK_FALSE(is_published_3mf_flag("true"));
+    CHECK_FALSE(is_published_3mf_flag(""));
+    CHECK_FALSE(is_published_3mf_flag("YES"));
+}
+
+// bbs_3mf_is_published is the lightweight metadata probe used to decide whether a file was
+// produced by the publish feature (GUI "recently published" tracking). It must return true only
+// for a file whose metadata carries the flag set to "1", and false for legacy files and for a
+// file whose flag is present but not "1" (which loads as a normal, non-published 3MF).
+SCENARIO("bbs_3mf_is_published detects only genuinely published 3MFs", "[3mf]") {
+    auto store_model = [](const std::string &path, const std::string &flag_value, const std::string &keys_value) {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+        model.model_info = std::make_shared<ModelInfo>();
+        // An empty flag_value means "don't write the flag at all" (a legacy file).
+        if (!flag_value.empty())
+            model.model_info->metadata_items[ORCA_PUBLISHED_TAG] = flag_value;
+        model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] = keys_value;
+        ScopedTemporaryDir backup_dir("orca_is_pub");
+        model.set_backup_path(backup_dir.string());
+        DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+        StoreParams store_params;
+        store_params.path     = path.c_str();
+        store_params.model    = &model;
+        store_params.config   = &config;
+        store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+        REQUIRE(store_bbs_3mf(store_params));
+    };
+
+    GIVEN("a minimal published 3MF whose flag is \"1\"") {
+        ScopedTemporaryFile temp(".3mf");
+        store_model(temp.string(), "1", R"(["layer_height"])");
+        WHEN("probed by bbs_3mf_is_published") {
+            THEN("it is recognized as published") {
+                CHECK(bbs_3mf_is_published(temp.string()));
+            }
+        }
+    }
+    GIVEN("a legacy 3MF without any published flag") {
+        ScopedTemporaryFile temp(".3mf");
+        store_model(temp.string(), "", R"(["layer_height"])");
+        WHEN("probed by bbs_3mf_is_published") {
+            THEN("it is not recognized as published") {
+                CHECK_FALSE(bbs_3mf_is_published(temp.string()));
+            }
+        }
+    }
+    GIVEN("a 3MF carrying the flag set to \"0\"") {
+        ScopedTemporaryFile temp(".3mf");
+        store_model(temp.string(), "0", R"(["layer_height"])");
+        WHEN("probed and loaded") {
+            THEN("it is not recognized as published") {
+                CHECK_FALSE(bbs_3mf_is_published(temp.string()));
+            }
+            THEN("it loads as a normal, non-published 3MF") {
+                Model dst_model;
+                DynamicPrintConfig dst_config;
+                ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+                PlateDataPtrs        dst_plates;
+                std::vector<Preset*> project_presets;
+                bool   is_bbl_3mf = false, is_orca_3mf = false;
+                Semver file_version;
+                REQUIRE(load_bbs_3mf(temp.string().c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                     &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                     LoadStrategy::LoadModel | LoadStrategy::LoadConfig));
+                REQUIRE(dst_model.model_info != nullptr);
+                // The key is present but not "1", so nothing treats the file as published; the
+                // stored keys still round-trip verbatim.
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_TAG] == "0");
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_KEYS_TAG] == R"(["layer_height"])");
+                release_PlateData_list(dst_plates);
+            }
+        }
+    }
+}
+

tests/libslic3r/test_arachne_walls.cpp

@@ -22,6 +22,8 @@
 #include "libslic3r/Arachne/utils/ExtrusionLine.hpp"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategyFactory.hpp"
 #include "libslic3r/Arachne/BeadingStrategy/BeadingStrategy.hpp"
+#include "libslic3r/Feature/FuzzySkin/FuzzySkin.hpp"
+#include "libslic3r/Flow.hpp"
 #include "libslic3r/Polygon.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/ClipperUtils.hpp"
@@ -309,3 +311,71 @@ TEST_CASE("Beading interpolation tolerates a thicker side with fewer insets", "[
         CHECK(result.bead_widths[i] == expected.bead_widths[i]);
     }
 }
+
+namespace {
+
+// Closed 20 mm square loop at a uniform width.
+Arachne::ExtrusionJunctions square_loop(coord_t width)
+{
+    const coord_t s = scaled<coord_t>(20.);
+    return {{Point(0, 0), width, 0}, {Point(s, 0), width, 0}, {Point(s, s), width, 0}, {Point(0, s), width, 0}, {Point(0, 0), width, 0}};
+}
+
+FuzzySkinConfig thick_fuzzy_config(FuzzySkinMode mode, NoiseType noise_type, double thickness_mm)
+{
+    FuzzySkinConfig cfg{};
+    cfg.type              = FuzzySkinType::All;
+    cfg.thickness         = scaled<coord_t>(thickness_mm);
+    cfg.point_distance    = scaled<coord_t>(0.3);
+    cfg.fuzzy_first_layer = true;
+    cfg.noise_type        = noise_type;
+    cfg.noise_scale       = 1.0;
+    cfg.noise_octaves     = 4;
+    cfg.noise_persistence = 0.5;
+    cfg.mode              = mode;
+    cfg.layer_id          = 5;
+    return cfg;
+}
+
+} // namespace
+
+// Extrusion and Combined mode add noise to each junction's width. A junction narrower than
+// height * (1 - PI/4) makes Flow::rounded_rectangle_extrusion_spacing() throw and fails the slice.
+// The fuzz thickness is 3x the line width so the clamp is hit on every run regardless of RNG seed.
+// Ridged multifractal is covered because its output is not bounded to [-1, 1], so it scales past
+// the configured thickness; the floor has to hold for any noise value, not just an in-range one.
+TEST_CASE("Fuzzy skin extrusion width is floored at the minimum the flow accepts", "[Arachne][FuzzySkin]") {
+    using namespace Slic3r::Feature::FuzzySkin;
+
+    const double layer_height = GENERATE(0.08, 0.2, 0.28);
+    const auto   mode         = GENERATE(FuzzySkinMode::Extrusion, FuzzySkinMode::Combined);
+    const auto   noise_type   = GENERATE(NoiseType::Classic, NoiseType::Perlin, NoiseType::Billow, NoiseType::RidgedMulti, NoiseType::Voronoi);
+    CAPTURE(layer_height, int(mode), int(noise_type));
+
+    const double line_width_mm = 0.42;
+    auto         loop          = square_loop(scaled<coord_t>(line_width_mm));
+    fuzzy_extrusion_line(loop, /*slice_z*/ 1.0, layer_height, thick_fuzzy_config(mode, noise_type, 3 * line_width_mm));
+
+    REQUIRE(loop.size() > 100);
+
+    const auto   narrowest    = std::min_element(loop.begin(), loop.end(), [](const auto& a, const auto& b) { return a.w < b.w; });
+    const double narrowest_mm = unscaled<double>(narrowest->w);
+    const double floor_mm     = layer_height * (1. - 0.25 * PI);
+    CAPTURE(narrowest_mm, floor_mm);
+
+    CHECK(narrowest_mm < line_width_mm); // the clamp was exercised
+    CHECK(narrowest_mm > floor_mm);
+    CHECK_NOTHROW(Flow::rounded_rectangle_extrusion_spacing(float(narrowest_mm), float(layer_height)));
+}
+
+// Displacement mode only moves points; widths must pass through unchanged.
+TEST_CASE("Fuzzy skin displacement mode leaves widths untouched", "[Arachne][FuzzySkin]") {
+    using namespace Slic3r::Feature::FuzzySkin;
+
+    const coord_t width = scaled<coord_t>(0.42);
+    auto          loop  = square_loop(width);
+    fuzzy_extrusion_line(loop, /*slice_z*/ 1.0, /*layer_height*/ 0.2, thick_fuzzy_config(FuzzySkinMode::Displacement, NoiseType::Classic, 1.26));
+
+    REQUIRE(loop.size() > 100);
+    CHECK(std::all_of(loop.begin(), loop.end(), [width](const auto& j) { return j.w == width; }));
+}

tests/libslic3r/test_arrange.cpp

@@ -4,6 +4,8 @@
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
+#include "libslic3r/Print.hpp"
+#include "libslic3r/PrintConfig.hpp"
 
 using namespace Slic3r;
 using namespace Slic3r::arrangement;
@@ -24,11 +26,13 @@ ArrangePolygon make_square(coord_t side)
     return ap;
 }
 
-ArrangePolygons squares(int n, double side_mm)
+ArrangePolygons squares(int n, double side_mm, double height_mm = 0.)
 {
     ArrangePolygons items;
-    for (int i = 0; i < n; ++i)
+    for (int i = 0; i < n; ++i) {
         items.emplace_back(make_square(scaled(side_mm)));
+        items.back().height = height_mm;
+    }
     return items;
 }
 
@@ -82,6 +86,38 @@ void require_no_overlap(const ArrangePolygons &items)
     REQUIRE(disjoint(placed_shapes(items)));
 }
 
+// The sequential-print floor is chosen by comparing object height against the nozzle,
+// so the two are defined together and every expectation is derived from them.
+constexpr double NOZZLE_HEIGHT_MM = 2.5;
+constexpr double CLEARANCE_MM     = 30.;
+constexpr double NOZZLE_FLOOR_MM  = MAX_OUTER_NOZZLE_DIAMETER / 2.;
+
+ArrangeParams seq_print_params(coord_t min_dist)
+{
+    ArrangeParams p       = quiet_params(min_dist);
+    p.is_seq_print        = true;
+    p.clearance_radius    = float(CLEARANCE_MM);
+    p.nozzle_height       = float(NOZZLE_HEIGHT_MM);
+    p.object_skirt_offset = 0.f;
+    return p;
+}
+
+// update_selected_items_inflation reads the bed out of the config to cap inflation.
+DynamicPrintConfig bed_config()
+{
+    DynamicPrintConfig c;
+    c.set_key_value("printable_area", new ConfigOptionPoints{{0, 0}, {200, 0}, {200, 200}, {0, 200}});
+    return c;
+}
+
+ArrangePolygons squares_of_heights(const std::vector<double> &heights_mm)
+{
+    ArrangePolygons items;
+    for (double height_mm : heights_mm)
+        items.push_back(squares(1, 20., height_mm).front());
+    return items;
+}
+
 } // namespace
 
 // Prove the overlap check the other tests rely on actually detects overlap.
@@ -222,3 +258,61 @@ TEST_CASE("Arrange aligns the pile to a custom center", "[Arrange]")
         REQUIRE(ap.bed_idx == 0);
     require_no_overlap(items);
 }
+
+TEST_CASE("Sequential print floors the object distance by object height", "[Arrange]")
+{
+    // The only place sequential-print clearance is enforced. The arrange menu offers
+    // no floor of its own, so a stored 0 has to be raised here or not at all.
+    struct Case
+    {
+        std::string         description;
+        std::vector<double> heights;
+        double              skirt_offset_mm;
+        double              expected_floor_mm;
+    };
+
+    auto c = GENERATE(values<Case>({
+        {"objects taller than the nozzle need the full clearance",     {NOZZLE_HEIGHT_MM * 2, NOZZLE_HEIGHT_MM * 2}, 0., CLEARANCE_MM},
+        {"an object exactly at the nozzle height counts as tall",      {NOZZLE_HEIGHT_MM,     NOZZLE_HEIGHT_MM},     0., CLEARANCE_MM},
+        {"one tall object among short ones is enough",                 {NOZZLE_HEIGHT_MM / 2, NOZZLE_HEIGHT_MM * 2}, 0., CLEARANCE_MM},
+        {"objects the nozzle clears keep only the nozzle-width floor", {NOZZLE_HEIGHT_MM / 2, NOZZLE_HEIGHT_MM / 2}, 0., NOZZLE_FLOOR_MM},
+        {"a wide skirt raises the floor for short objects",            {NOZZLE_HEIGHT_MM / 2, NOZZLE_HEIGHT_MM / 2}, 3., 6.},
+    }));
+
+    DYNAMIC_SECTION(c.description)
+    {
+        ArrangePolygons    items = squares_of_heights(c.heights);
+        DynamicPrintConfig cfg   = bed_config();
+        ArrangeParams      p     = seq_print_params(0);
+        p.object_skirt_offset    = float(c.skirt_offset_mm);
+
+        update_selected_items_inflation(items, &cfg, p);
+
+        CHECK(p.min_obj_distance >= scaled(c.expected_floor_mm));
+        CHECK(p.min_obj_distance <= scaled(c.expected_floor_mm + 0.01));
+        // Half each, so a pair ends up a full min_obj_distance apart.
+        CHECK(items.front().inflation == p.min_obj_distance / 2);
+    }
+}
+
+TEST_CASE("Sequential print keeps an object distance already above the floor", "[Arrange]")
+{
+    const coord_t      stored = scaled(CLEARANCE_MM * 2);
+    ArrangePolygons    items  = squares_of_heights({NOZZLE_HEIGHT_MM * 2, NOZZLE_HEIGHT_MM * 2});
+    DynamicPrintConfig cfg    = bed_config();
+    ArrangeParams      p      = seq_print_params(stored);
+
+    update_selected_items_inflation(items, &cfg, p);
+    CHECK(p.min_obj_distance == stored);
+}
+
+TEST_CASE("Layered printing does not floor the object distance", "[Arrange]")
+{
+    ArrangePolygons    items = squares_of_heights({NOZZLE_HEIGHT_MM * 2, NOZZLE_HEIGHT_MM * 2});
+    DynamicPrintConfig cfg   = bed_config();
+    ArrangeParams      p     = seq_print_params(0);
+    p.is_seq_print           = false;
+
+    update_selected_items_inflation(items, &cfg, p);
+    CHECK(p.min_obj_distance == 0);
+}

tests/libslic3r/test_buildvolume.cpp

@@ -0,0 +1,40 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/BuildVolume.hpp"
+
+using namespace Slic3r;
+
+static std::vector<Vec2d> rect_area(double w, double d)
+{
+    return { { 0., 0. }, { w, 0. }, { w, d }, { 0., d } };
+}
+
+// extruder_printable_height and extruder_printable_area are independent config options, so a
+// profile can leave the heights short. BuildVolume must not index past the end of the heights.
+TEST_CASE("BuildVolume falls back to the bed height when extruder_printable_height is short", "[BuildVolume]")
+{
+    const std::vector<Vec2d>              bed     = rect_area(200., 200.);
+    const std::vector<std::vector<Vec2d>> areas   = { rect_area(200., 200.), rect_area(100., 200.) };
+    const std::vector<double>             heights = { 180. };
+
+    const BuildVolume build_volume(bed, 250., areas, heights);
+
+    REQUIRE(build_volume.get_extruder_area_count() == 2);
+    // The extruder with a height of its own keeps it, and differs from the bed, so it gets its own volume.
+    CHECK_THAT(build_volume.get_extruder_area_volume(0).bboxf.max.z(), Catch::Matchers::WithinAbs(180., 1e-6));
+    // The extruder without one falls back to the bed's printable_height instead of reading out of range.
+    CHECK_THAT(build_volume.get_extruder_area_volume(1).bboxf.max.z(), Catch::Matchers::WithinAbs(250., 1e-6));
+}
+
+TEST_CASE("BuildVolume keeps per-extruder heights when both vectors match", "[BuildVolume]")
+{
+    const std::vector<Vec2d>              bed     = rect_area(200., 200.);
+    const std::vector<std::vector<Vec2d>> areas   = { rect_area(120., 200.), rect_area(100., 200.) };
+    const std::vector<double>             heights = { 180., 200.5 };
+
+    const BuildVolume build_volume(bed, 250., areas, heights);
+
+    REQUIRE(build_volume.get_extruder_area_count() == 2);
+    CHECK_THAT(build_volume.get_extruder_area_volume(0).bboxf.max.z(), Catch::Matchers::WithinAbs(180., 1e-6));
+    CHECK_THAT(build_volume.get_extruder_area_volume(1).bboxf.max.z(), Catch::Matchers::WithinAbs(200.5, 1e-6));
+}

tests/libslic3r/test_config.cpp

@@ -828,3 +828,391 @@ SCENARIO("ConfigOptionVector::set_to_index throws on incompatible type", "[Confi
         }
     }
 }
+
+TEST_CASE("read_cli applies valid values and collects non-option arguments", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--nozzle-temperature", "210,190", "--reduce-crossing-wall=1", "model.3mf"};
+    REQUIRE(config.read_cli(5, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionInts>("nozzle_temperature")->values == std::vector<int>{210, 190});
+    REQUIRE(config.opt<ConfigOptionBool>("reduce_crossing_wall")->value);
+    REQUIRE(extra == t_config_option_keys{"model.3mf"});
+    REQUIRE(keys == t_config_option_keys{"nozzle_temperature", "reduce_crossing_wall"});
+}
+
+TEST_CASE("read_cli rejects nil for a non-nullable vector option", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--nozzle-temperature", "nil"};
+    REQUIRE_FALSE(config.read_cli(3, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli rejects an invalid boolean value", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--reduce-crossing-wall=maybe"};
+    REQUIRE_FALSE(config.read_cli(2, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli accepts the common spellings of a boolean value", "[Config]") {
+    const auto [text, expected] = GENERATE(table<const char*, bool>({
+        {"--reduce-crossing-wall=1", true},
+        {"--reduce-crossing-wall=true", true},
+        {"--reduce-crossing-wall=Yes", true},
+        {"--reduce-crossing-wall=on", true},
+        {"--reduce-crossing-wall=enabled", true},
+        {"--reduce-crossing-wall=TRUE", true},
+        {"--reduce-crossing-wall=oN", true},
+        {"--reduce-crossing-wall=0", false},
+        {"--reduce-crossing-wall=false", false},
+        {"--reduce-crossing-wall=No", false},
+        {"--reduce-crossing-wall=off", false},
+        {"--reduce-crossing-wall=disabled", false},
+        {"--reduce-crossing-wall=FALSE", false},
+        {"--reduce-crossing-wall=DiSaBlEd", false},
+    }));
+
+    DYNAMIC_SECTION(text) {
+        Slic3r::DynamicPrintConfig config;
+        t_config_option_keys extra, keys;
+        const char* argv[] = {"orca-slicer", text};
+        REQUIRE(config.read_cli(2, argv, &extra, &keys));
+        REQUIRE(config.opt<ConfigOptionBool>("reduce_crossing_wall")->value == expected);
+    }
+}
+
+TEST_CASE("read_cli accepts the common boolean spellings inside a bools vector", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=true,no,1"};
+    REQUIRE(config.read_cli(2, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBools>("filament_soluble")->values == std::vector<unsigned char>{1, 0, 1});
+}
+
+TEST_CASE("read_cli trims whitespace around boolean spellings", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--reduce-crossing-wall= true ", "--filament-soluble= true , no ,1"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBool>("reduce_crossing_wall")->value);
+    REQUIRE(config.opt<ConfigOptionBools>("filament_soluble")->values == std::vector<unsigned char>{1, 0, 1});
+}
+
+TEST_CASE("read_cli normalizes boolean spellings when a bools vector is repeated", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=true", "--filament-soluble=off"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBools>("filament_soluble")->values == std::vector<unsigned char>{1, 0});
+}
+
+TEST_CASE("read_cli keeps nil alongside boolean spellings in a nullable bools vector", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--enable-overhang-speed=nil,yes,off"};
+    REQUIRE(config.read_cli(2, argv, &extra, &keys));
+    auto* opt = config.opt<ConfigOptionBoolsNullable>("enable_overhang_speed");
+    REQUIRE(opt != nullptr);
+    REQUIRE(opt->values.size() == 3);
+    REQUIRE(opt->is_nil(0));
+    REQUIRE(opt->values[1] == 1);
+    REQUIRE(opt->values[2] == 0);
+}
+
+TEST_CASE("read_cli rejects an empty item inside a bools vector", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=true,,1"};
+    REQUIRE_FALSE(config.read_cli(2, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli rejects an unknown spelling next to a valid one in a bools vector", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=true,affirmative"};
+    REQUIRE_FALSE(config.read_cli(2, argv, &extra, &keys));
+}
+
+// The normalization lives in read_cli's boolean branches, so options of other types keep the
+// value verbatim - a path named "on" or a colour named "true" must not turn into "1".
+TEST_CASE("read_cli leaves boolean spellings alone for non-boolean options", "[Config]") {
+    SECTION("string option") {
+        Slic3r::DynamicPrintAndCLIConfig config;
+        t_config_option_keys extra, keys;
+        const char* argv[] = {"orca-slicer", "--logfile=true"};
+        REQUIRE(config.read_cli(2, argv, &extra, &keys));
+        REQUIRE(config.opt<ConfigOptionString>("logfile")->value == "true");
+    }
+    SECTION("strings vector option") {
+        Slic3r::DynamicPrintConfig config;
+        t_config_option_keys extra, keys;
+        const char* argv[] = {"orca-slicer", "--filament-colour=on;off"};
+        REQUIRE(config.read_cli(2, argv, &extra, &keys));
+        REQUIRE(config.opt<ConfigOptionStrings>("filament_colour")->values == std::vector<std::string>{"on", "off"});
+    }
+}
+
+TEST_CASE("read_cli treats a bare boolean flag as true without consuming the next argument", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--reduce-crossing-wall", "model.3mf"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBool>("reduce_crossing_wall")->value);
+    REQUIRE(extra == t_config_option_keys{"model.3mf"});
+}
+
+TEST_CASE("read_cli rejects an invalid scalar numeric value", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--top-shell-layers", "several"};
+    REQUIRE_FALSE(config.read_cli(3, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli appends values when a vector option is repeated", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--nozzle-temperature", "210", "--nozzle-temperature", "190,200"};
+    REQUIRE(config.read_cli(5, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionInts>("nozzle_temperature")->values == std::vector<int>{210, 190, 200});
+    // the key is recorded once, on first use
+    REQUIRE(keys == t_config_option_keys{"nozzle_temperature"});
+}
+
+TEST_CASE("read_cli parses a bools vector given in the --flag=values form", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=1,0,1"};
+    REQUIRE(config.read_cli(2, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBools>("filament_soluble")->values == std::vector<unsigned char>{1, 0, 1});
+}
+
+TEST_CASE("read_cli rejects an invalid value inside a bools vector", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble=1,maybe"};
+    REQUIRE_FALSE(config.read_cli(2, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli appends true for a bare bools vector flag", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-soluble"};
+    REQUIRE(config.read_cli(2, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionBools>("filament_soluble")->values == std::vector<unsigned char>{1});
+}
+
+TEST_CASE("read_cli splits a strings vector on semicolons and unescapes quoted items", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-colour", "#FF0000;\"a\\nb\";#00FF00"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    auto& values = config.opt<ConfigOptionStrings>("filament_colour")->values;
+    REQUIRE(values == std::vector<std::string>{"#FF0000", "a\nb", "#00FF00"});
+}
+
+TEST_CASE("read_cli rejects a strings vector with an unterminated quote", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-colour", "\"oops"};
+    REQUIRE_FALSE(config.read_cli(3, argv, &extra, &keys));
+}
+
+TEST_CASE("read_cli parses a points vector in the NxM coordinate form", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--printable-area", "0x0,200x0,200x200,0x200"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    auto& points = config.opt<ConfigOptionPoints>("printable_area")->values;
+    REQUIRE(points.size() == 4);
+    REQUIRE_THAT(points[1].x(), Catch::Matchers::WithinAbs(200.0, 1e-9));
+    REQUIRE_THAT(points[1].y(), Catch::Matchers::WithinAbs(0.0, 1e-9));
+    REQUIRE_THAT(points[3].x(), Catch::Matchers::WithinAbs(0.0, 1e-9));
+    REQUIRE_THAT(points[3].y(), Catch::Matchers::WithinAbs(200.0, 1e-9));
+}
+
+// logfile is a CLI-only option, so it needs the config type whose def pulls in cli_misc_config_def.
+TEST_CASE("read_cli stores the log file path as a string", "[Config]") {
+    Slic3r::DynamicPrintAndCLIConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--logfile", "orca.log"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    REQUIRE(config.opt<ConfigOptionString>("logfile")->value == "orca.log");
+}
+
+TEST_CASE("read_cli accepts nil entries for a nullable vector option", "[Config]") {
+    Slic3r::DynamicPrintConfig config;
+    t_config_option_keys extra, keys;
+    const char* argv[] = {"orca-slicer", "--filament-retraction-length", "nil,2.5"};
+    REQUIRE(config.read_cli(3, argv, &extra, &keys));
+    auto* opt = config.opt<ConfigOptionFloatsNullable>("filament_retraction_length");
+    REQUIRE(opt != nullptr);
+    REQUIRE(opt->values.size() == 2);
+    REQUIRE(opt->is_nil(0));
+    REQUIRE_FALSE(opt->is_nil(1));
+    REQUIRE_THAT(opt->values[1], Catch::Matchers::WithinAbs(2.5, 1e-9));
+}
+
+// get_at() returns values.front() for an out-of-range index, so calling it on an empty vector
+// option is UB. filament_id and filament_is_support are unpopulated on a CLI from-scratch slice.
+TEST_CASE("get_filament_type treats empty vector options as absent", "[Config][Filament]")
+{
+    DynamicPrintConfig config;
+    std::string displayed;
+
+    SECTION("an empty filament_type yields no type at all")
+    {
+        config.set_key_value("filament_type", new ConfigOptionStrings());
+        REQUIRE(config.get_filament_type(displayed, 0) == "");
+    }
+
+    SECTION("an empty filament_is_support falls back to the plain filament type")
+    {
+        config.set_key_value("filament_type", new ConfigOptionStrings({"PETG"}));
+        config.set_key_value("filament_is_support", new ConfigOptionBools());
+        REQUIRE(config.get_filament_type(displayed, 0) == "PETG");
+        REQUIRE(displayed == "PETG");
+    }
+
+    SECTION("a support filament with an empty filament_id resolves from the type alone")
+    {
+        config.set_key_value("filament_type", new ConfigOptionStrings({"PLA"}));
+        config.set_key_value("filament_is_support", new ConfigOptionBools({true}));
+        config.set_key_value("filament_id", new ConfigOptionStrings());
+        REQUIRE(config.get_filament_type(displayed, 0) == "PLA-S");
+        REQUIRE(displayed == "Sup.PLA");
+    }
+
+    SECTION("a populated filament_id still selects the support type by id")
+    {
+        config.set_key_value("filament_type", new ConfigOptionStrings({"PETG"}));
+        config.set_key_value("filament_is_support", new ConfigOptionBools({true}));
+        config.set_key_value("filament_id", new ConfigOptionStrings({"GFS00"}));
+        REQUIRE(config.get_filament_type(displayed, 0) == "PLA-S");
+        REQUIRE(displayed == "Sup.PLA");
+    }
+}
+
+namespace {
+
+// min_object_distance reads exactly these three options.
+DynamicPrintConfig spacing_config(PrinterTechnology tech, PrintSequence seq, double clearance_radius)
+{
+    DynamicPrintConfig c;
+    c.set_key_value("printer_technology", new ConfigOptionEnum<PrinterTechnology>(tech));
+    c.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(seq));
+    c.set_key_value("extruder_clearance_radius", new ConfigOptionFloat(clearance_radius));
+    return c;
+}
+
+} // namespace
+
+TEST_CASE("min_object_distance floors object spacing per print sequence", "[Config]")
+{
+    struct Case
+    {
+        std::string       description;
+        PrinterTechnology tech;
+        PrintSequence     sequence;
+        double            clearance_radius;
+        double            expected;
+    };
+
+    auto c = GENERATE(values<Case>({
+        {"sequential FFF takes a clearance radius above the floor", ptFFF, PrintSequence::ByObject, 12., 12.},
+        {"sequential FFF holds the floor at the radius",            ptFFF, PrintSequence::ByObject,  6.,  6.},
+        {"sequential FFF holds the floor below the radius",         ptFFF, PrintSequence::ByObject,  4.,  6.},
+        {"layered FFF ignores the clearance radius",                ptFFF, PrintSequence::ByLayer,  12.,  6.},
+        {"SLA is a flat 6mm",                                       ptSLA, PrintSequence::ByObject, 12.,  6.},
+        {"SLA ignores the print sequence too",                      ptSLA, PrintSequence::ByLayer,  12.,  6.},
+    }));
+
+    DYNAMIC_SECTION(c.description)
+    {
+        CHECK_THAT(min_object_distance(spacing_config(c.tech, c.sequence, c.clearance_radius)),
+                   Catch::Matchers::WithinAbs(c.expected, 1e-9));
+    }
+}
+
+TEST_CASE("min_object_distance yields no floor when an FFF config lacks the options", "[Config]")
+{
+    // Missing options yield 0 rather than an error, so a caller gets no floor at all.
+    SECTION("no clearance radius") {
+        DynamicPrintConfig c;
+        c.set_key_value("printer_technology", new ConfigOptionEnum<PrinterTechnology>(ptFFF));
+        c.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(PrintSequence::ByObject));
+        CHECK_THAT(min_object_distance(c), Catch::Matchers::WithinAbs(0., 1e-9));
+    }
+
+    SECTION("no print sequence") {
+        DynamicPrintConfig c;
+        c.set_key_value("printer_technology", new ConfigOptionEnum<PrinterTechnology>(ptFFF));
+        c.set_key_value("extruder_clearance_radius", new ConfigOptionFloat(12.));
+        CHECK_THAT(min_object_distance(c), Catch::Matchers::WithinAbs(0., 1e-9));
+    }
+
+    SECTION("nothing at all") {
+        CHECK_THAT(min_object_distance(DynamicPrintConfig{}), Catch::Matchers::WithinAbs(0., 1e-9));
+    }
+
+    SECTION("an unset printer technology is treated as FFF") {
+        DynamicPrintConfig c;
+        c.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(PrintSequence::ByObject));
+        c.set_key_value("extruder_clearance_radius", new ConfigOptionFloat(12.));
+        CHECK_THAT(min_object_distance(c), Catch::Matchers::WithinAbs(12., 1e-9));
+    }
+}
+
+TEST_CASE("Static print configs compare, order and hash by their option values", "[Config]")
+{
+    // PrintObjectConfig comes from PRINT_CONFIG_CLASS_DEFINE; PrintConfig combines MachineEnvelopeConfig
+    // and GCodeConfig through PRINT_CONFIG_CLASS_DERIVED_DEFINE. Both generate hash(), operator==,
+    // operator< and the option registration from the same option list. The hash inequalities use fixed
+    // inputs, so they are deterministic; they check that hash() covers the changed option.
+    SECTION("default-constructed configs are equal and find their options by key")
+    {
+        PrintObjectConfig a, b;
+        REQUIRE(a == b);
+        REQUIRE(a.hash() == b.hash());
+        REQUIRE_FALSE(a < b);
+        REQUIRE_FALSE(b < a);
+        REQUIRE(a.optptr("layer_height") == &a.layer_height);
+        REQUIRE(a.optptr("brim_object_gap") == &a.brim_object_gap);
+    }
+
+    SECTION("one differing option makes the configs unequal and orders them")
+    {
+        PrintObjectConfig a, b;
+        b.layer_height.value = a.layer_height.value + 0.05;
+        REQUIRE(a != b);
+        REQUIRE(a.hash() != b.hash());
+        REQUIRE(a < b);
+        REQUIRE_FALSE(b < a);
+    }
+
+    SECTION("ordering is decided by the first option in declaration order that differs")
+    {
+        PrintObjectConfig a, b;
+        a.brim_object_gap.value = b.brim_object_gap.value + 1.0;  // declared first
+        a.layer_height.value    = b.layer_height.value - 0.05;    // declared later, points the other way
+        REQUIRE(b < a);
+        REQUIRE_FALSE(a < b);
+    }
+
+    SECTION("a derived config sees differences in its parents and in its own options")
+    {
+        PrintConfig a, b;
+        REQUIRE(a == b);
+        REQUIRE(a.hash() == b.hash());
+
+        b.gcode_flavor.value = b.gcode_flavor.value == gcfMarlinLegacy ? gcfKlipper : gcfMarlinLegacy;  // GCodeConfig parent
+        REQUIRE(a != b);
+        REQUIRE(a.hash() != b.hash());
+
+        PrintConfig c, d;
+        d.skirt_distance.value = c.skirt_distance.value + 1.0;  // PrintConfig's own list
+        REQUIRE(c != d);
+        REQUIRE(c.hash() != d.hash());
+        REQUIRE(c.optptr("skirt_distance") == &c.skirt_distance);
+        REQUIRE(c.optptr("gcode_flavor") == &c.gcode_flavor);
+    }
+}

tests/libslic3r/test_config_variant_expansion.cpp

@@ -130,6 +130,12 @@ TEST_CASE("get_config_index_base resolves (volume type, extruder type, id) to a
     }
 }
 
+TEST_CASE("support interface pattern registry includes spiral inset", "[Config]")
+{
+    const auto &values = ConfigOptionEnum<SupportMaterialInterfacePattern>::get_enum_values();
+    REQUIRE(values.at("spiralinset") == SupportMaterialInterfacePattern::smipSpiralInset);
+}
+
 TEST_CASE("get_extruder_nozzle_volume_count reads the per-extruder volume-type layout", "[Config]")
 {
     std::vector<std::vector<NozzleVolumeType>> nozzle_volume_types;
@@ -478,4 +484,113 @@ TEST_CASE("update_values_to_printer_extruders_for_multiple_filaments resolves pe
         REQUIRE(config.option<ConfigOptionFloats>("filament_max_volumetric_speed")->values == std::vector<double>({12., 21.}));
         REQUIRE(config.option<ConfigOptionInts>("filament_self_index")->values == std::vector<int>({1, 2}));
     }
+
+    SECTION("a variant option shorter than the filament slots keeps its first value instead of zero") {
+        DynamicPrintConfig config;
+        config.option<ConfigOptionEnumsGeneric>("extruder_type", true)->values = {etDirectDrive, etDirectDrive};
+        config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type", true)->values = {nvtStandard, nvtHighFlow};
+        config.option<ConfigOptionStrings>("extruder_variant_list", true)->values = {"Direct Drive Standard,Direct Drive High Flow",
+                                                                                     "Direct Drive Standard,Direct Drive High Flow"};
+        make_filament_arrays(config);
+        config.option<ConfigOptionInts>("filament_map", true)->values = {1, 2};
+        // no loaded preset carries the key, so only its single registered default is present
+        config.option<ConfigOptionFloatsNullable>("filament_cooling_before_tower", true)->values = {10.};
+        // only the first filament's two variant columns were loaded
+        config.option<ConfigOptionFloatsNullable>("filament_ramming_volumetric_speed", true)->values = {-1., -2.};
+
+        std::vector<std::vector<NozzleVolumeType>> nozzle_volume_types;
+        int extruder_count = 2;
+        int count = config.get_extruder_nozzle_volume_count(extruder_count, nozzle_volume_types);
+
+        config.update_values_to_printer_extruders_for_multiple_filaments(config, extruder_count, count, filament_keys,
+            "filament_self_index", "filament_extruder_variant");
+
+        // filament 2 resolves to column 3 (its extruder's High Flow column), past the end of both vectors
+        REQUIRE_THAT(config.option<ConfigOptionFloatsNullable>("filament_cooling_before_tower")->values,
+                     Catch::Matchers::Approx(std::vector<double>({10., 10.})));
+        REQUIRE_THAT(config.option<ConfigOptionFloatsNullable>("filament_ramming_volumetric_speed")->values,
+                     Catch::Matchers::Approx(std::vector<double>({-1., -1.})));
+        REQUIRE(config.option<ConfigOptionFloats>("filament_max_volumetric_speed")->values == std::vector<double>({12., 21.}));
+    }
+}
+
+// update_values_from_multi_to_multi_2 walks the DESTINATION PRINTER's variant list while writing
+// into a row taken from the destination PRINT preset, whose arrays are sized to its own
+// print_extruder_variant. Those two widths disagree until the print preset is re-selected for the
+// new printer -- Tab::load_current_preset() runs this migration first -- so a project authored on
+// a single-variant printer, opened and switched to a wider one, wrote past the end of the row.
+TEST_CASE("update_values_from_multi_to_multi_2 sizes the destination row to the variant count",
+          "[Config][VariantExpansion]")
+{
+    const std::vector<std::string> src_variants{"Direct Drive Standard"};
+    const std::vector<std::string> dst_variants{"Direct Drive Standard", "Direct Drive High Flow",
+                                                "Direct Drive Standard", "Direct Drive High Flow"};
+    const std::set<std::string>    keys{"outer_wall_speed"};
+
+    // The per-object override as authored on the single-variant printer.
+    const auto object_override = [] {
+        DynamicPrintConfig c;
+        c.option<ConfigOptionFloatsNullable>("outer_wall_speed", true)->values = {42.};
+        return c;
+    };
+
+    SECTION("a row narrower than the variant list is grown, not overrun") {
+        DynamicPrintConfig object_config = object_override();
+        DynamicPrintConfig dst;
+        dst.option<ConfigOptionFloatsNullable>("outer_wall_speed", true)->values = {200.};
+
+        REQUIRE(object_config.update_values_from_multi_to_multi_2(src_variants, dst_variants, dst, keys) == 0);
+
+        const auto& out = object_config.option<ConfigOptionFloatsNullable>("outer_wall_speed")->values;
+        REQUIRE(out.size() == dst_variants.size());
+        // Both "Direct Drive Standard" columns match the source variant, so they take the override.
+        CHECK(out[0] == Catch::Approx(42.));
+        CHECK(out[2] == Catch::Approx(42.));
+        // The High Flow columns have no matching source variant: nil, so the destination keeps
+        // tracking the print preset rather than being pinned to another variant's value.
+        CHECK(std::isnan(out[1]));
+        CHECK(std::isnan(out[3]));
+    }
+
+    // The regression guard: where the row already matches the variant list -- every case that was
+    // not corrupting the heap -- the resize is a no-op and the output is unchanged.
+    SECTION("a correctly sized row is untouched") {
+        DynamicPrintConfig object_config = object_override();
+        DynamicPrintConfig dst;
+        dst.option<ConfigOptionFloatsNullable>("outer_wall_speed", true)->values = {200., 500., 210., 510.};
+
+        REQUIRE(object_config.update_values_from_multi_to_multi_2(src_variants, dst_variants, dst, keys) == 0);
+
+        const auto& out = object_config.option<ConfigOptionFloatsNullable>("outer_wall_speed")->values;
+        REQUIRE(out.size() == 4);
+        CHECK(out[0] == Catch::Approx(42.));    // matched -> override
+        CHECK(out[1] == Catch::Approx(500.));   // unmatched -> preset value preserved
+        CHECK(out[2] == Catch::Approx(42.));
+        CHECK(out[3] == Catch::Approx(510.));
+    }
+
+    // is_nil(idx) indexes values[idx] with no bounds check, so a source shorter than its own
+    // variant list read out of range before the guard was added.
+    SECTION("a source shorter than its variant list is read in range") {
+        DynamicPrintConfig object_config = object_override();   // one value...
+        DynamicPrintConfig dst;
+        dst.option<ConfigOptionFloatsNullable>("outer_wall_speed", true)->values = {200., 500.};
+
+        REQUIRE(object_config.update_values_from_multi_to_multi_2(
+            {"Direct Drive Standard", "Direct Drive Standard"},   // ...but two source variants
+            {"Direct Drive Standard", "Direct Drive High Flow"}, dst, keys) == 0);
+
+        const auto& out = object_config.option<ConfigOptionFloatsNullable>("outer_wall_speed")->values;
+        REQUIRE(out.size() == 2);
+        CHECK(out[0] == Catch::Approx(42.));
+        CHECK(out[1] == Catch::Approx(500.));
+    }
+
+    SECTION("an empty destination variant list is refused") {
+        DynamicPrintConfig object_config = object_override();
+        DynamicPrintConfig dst;
+        dst.option<ConfigOptionFloatsNullable>("outer_wall_speed", true)->values = {200.};
+
+        CHECK(object_config.update_values_from_multi_to_multi_2(src_variants, {}, dst, keys) == -1);
+    }
 }

tests/libslic3r/test_marchingsquares.cpp

@@ -1,4 +1,6 @@
+#ifndef NOMINMAX
 #define NOMINMAX
+#endif
 
 #include <catch2/catch_all.hpp>
 #include "test_utils.hpp"

tests/libslic3r/test_minimum_spanning_tree.cpp

@@ -0,0 +1,66 @@
+#include <catch2/catch_all.hpp>
+
+#include <algorithm>
+
+#include "libslic3r/MinimumSpanningTree.hpp"
+#include "libslic3r/Point.hpp"
+
+using namespace Slic3r;
+
+// A 5x5 lattice: at every step of Prim's algorithm several candidates sit at the same
+// distance from the tree, so the tie-break decides the tree's shape.
+static std::vector<Point> lattice()
+{
+    std::vector<Point> vertices;
+    for (int y = 0; y < 5; ++y)
+        for (int x = 0; x < 5; ++x)
+            vertices.emplace_back(Point::new_scale(x, y));
+    return vertices;
+}
+
+static std::vector<Point> sorted_neighbours(const MinimumSpanningTree &mst, const Point &vertex)
+{
+    std::vector<Point> neighbours = mst.adjacent_nodes(vertex);
+    std::sort(neighbours.begin(), neighbours.end());
+    return neighbours;
+}
+
+TEST_CASE("Minimum spanning tree connects every vertex", "[MinimumSpanningTree]")
+{
+    const std::vector<Point> vertices = lattice();
+    const MinimumSpanningTree mst(vertices);
+
+    REQUIRE(mst.vertices().size() == vertices.size());
+    size_t adjacency_entries = 0;
+    for (const Point &vertex : vertices) {
+        const std::vector<Point> neighbours = mst.adjacent_nodes(vertex);
+        REQUIRE(! neighbours.empty());
+        adjacency_entries += neighbours.size();
+    }
+    // A tree on n vertices has n - 1 edges, each listed from both ends.
+    REQUIRE(adjacency_entries == 2 * (vertices.size() - 1));
+}
+
+TEST_CASE("Minimum spanning tree does not depend on the order of the non-root vertices", "[MinimumSpanningTree][Regression]")
+{
+    const std::vector<Point> vertices = lattice();
+    const MinimumSpanningTree reference(vertices);
+
+    // The root stays first: Prim's tree legitimately depends on where it starts.
+    // Every other order of the remaining vertices must give the same tree.
+    std::vector<std::vector<Point>> orders;
+    orders.emplace_back(vertices);
+    std::reverse(orders.back().begin() + 1, orders.back().end());
+    for (size_t shift = 1; shift + 1 < vertices.size(); ++shift) {
+        orders.emplace_back(vertices);
+        std::rotate(orders.back().begin() + 1, orders.back().begin() + 1 + shift, orders.back().end());
+    }
+
+    for (const std::vector<Point> &order : orders) {
+        const MinimumSpanningTree mst(order);
+        for (const Point &vertex : vertices) {
+            INFO("vertex " << vertex.x() << "," << vertex.y());
+            REQUIRE(sorted_neighbours(mst, vertex) == sorted_neighbours(reference, vertex));
+        }
+    }
+}

tests/libslic3r/test_preset_options.cpp

@@ -0,0 +1,70 @@
+// Regression test for the "option in def + UI but missing from preset key list"
+// crash class.
+//
+// The print preset's DynamicPrintConfig is seeded with only the keys returned by
+// Preset::print_options() (PresetBundle.cpp). A field added to PrintRegionConfig
+// or PrintObjectConfig and registered via print_config_def plus a TabPrint
+// optgroup, but left out of print_options(), still gets its control built; on tab
+// activation reload_config -> get_config_value dispatches to opt_bool/opt_int on a
+// DynamicPrintConfig with no entry for the key, and the accessor null-derefs the
+// result of option<T>(key).
+//
+// The invariant asserted here is the inverse: every key declared on
+// PrintRegionConfig and PrintObjectConfig appears in Preset::print_options() or
+// Preset::filament_options(), the two preset key lists that seed a print preset's
+// DynamicConfig.
+
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/PrintConfig.hpp"
+
+#include <set>
+
+using namespace Slic3r;
+
+namespace {
+
+// Deprecated keys renamed in handle_legacy() (ironing_direction ->
+// ironing_angle, wall_infill_order -> wall_sequence); neither is in a
+// preset list. Register new options in a preset list, not here.
+const std::set<std::string> kDeprecatedRegionFields = {
+    "ironing_direction",
+    "wall_infill_order",
+};
+
+void check_keys_are_in_a_preset(const t_config_option_keys& keys, const std::string& class_name)
+{
+    REQUIRE_FALSE(keys.empty());
+    const auto& print_options    = Preset::print_options();
+    const auto& filament_options = Preset::filament_options();
+    const std::set<std::string> in_print(print_options.begin(), print_options.end());
+    const std::set<std::string> in_filament(filament_options.begin(), filament_options.end());
+    for (const std::string& key : keys) {
+        DYNAMIC_SECTION(class_name << "::" << key)
+        {
+            INFO("'" << key << "' on " << class_name
+                     << " is missing from "
+                        "Preset::print_options()/filament_options(); add it to "
+                        "s_Preset_print_options (or s_Preset_filament_options) in Preset.cpp.");
+            const bool registered = in_print.count(key) || in_filament.count(key) || kDeprecatedRegionFields.count(key);
+            REQUIRE(registered);
+        }
+    }
+}
+
+} // namespace
+
+// Bodies are laid out like the rest of the test suite rather than collapsed
+// onto the brace line.
+// clang-format off
+TEST_CASE("Every PrintRegionConfig field is registered in a preset key list", "[Preset][Config]")
+{
+    check_keys_are_in_a_preset(PrintRegionConfig::defaults().keys(), "PrintRegionConfig");
+}
+
+TEST_CASE("Every PrintObjectConfig field is registered in a preset key list", "[Preset][Config]")
+{
+    check_keys_are_in_a_preset(PrintObjectConfig::defaults().keys(), "PrintObjectConfig");
+}
+// clang-format on

tests/libslic3r/test_preset_setting_id.cpp

@@ -5,10 +5,10 @@
 using namespace Slic3r;
 
 // Golden vectors from the Python reference generate_preset_setting_id (defined in
-// scripts/assign_vendor_setting_ids.py). The C++ generate_preset_setting_id() MUST stay
-// byte-identical to it, otherwise app-side on-the-fly ids would diverge from the
+// scripts/orca_id_tool.py). The C++ generate_preset_setting_id() MUST stay byte-identical
+// to it, otherwise app-side on-the-fly ids would diverge from the
 // script-assigned ones in the profiles. Regenerate a vector with:
-//   python3 -c "from assign_vendor_setting_ids import generate_preset_setting_id as g; print(g('Afinia','filament','Afinia ABS @Afinia H400'))"
+//   python3 -c "import sys; sys.path.insert(0, 'scripts'); from orca_id_tool import generate_preset_setting_id as g; print(g('Afinia','filament','Afinia ABS @Afinia H400'))"
 TEST_CASE("preset setting_id matches the Python reference", "[Preset][setting_id]") {
     struct Vec { const char* vendor; const char* type; const char* name; const char* expected; };
     const Vec vectors[] = {

tests/libslic3r/test_utils.cpp

@@ -2,6 +2,13 @@
 
 #include "libslic3r/Utils.hpp"
 
+#include "test_utils.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <fstream>
+#include <string>
+
 #ifndef _WIN32
 #include <unistd.h>     // getuid
 #endif
@@ -52,3 +59,32 @@ TEST_CASE("per-user temp root is unchanged on Windows, isolated elsewhere", "[ut
     REQUIRE_THAT(root, Catch::Matchers::StartsWith(base + "/orcaslicer_"));
 #endif
 }
+
+TEST_CASE("copy_file reports the OS error when the destination cannot be written", "[utils]") {
+    ScopedTemporaryFile source(".txt");
+    {
+        std::ofstream ofs(source.string(), std::ios::binary);
+        ofs << "orca";
+    }
+    REQUIRE(boost::filesystem::exists(source.path()));
+
+    // A directory that was never created, so the copy fails on every platform.
+    const boost::filesystem::path destination = source.path().parent_path() / "orca-missing-dir" / "copy.txt";
+    REQUIRE_FALSE(boost::filesystem::exists(destination.parent_path()));
+
+    std::string error_message;
+    REQUIRE(copy_file(source.string(), destination.string(), error_message) == FAIL_COPY_FILE);
+    REQUIRE_FALSE(error_message.empty());
+
+#ifdef _WIN32
+    // The Windows branch formats GetLastError() itself. Writing that as
+    // "Error: " + errCode adds an integer to a string literal, which indexes into the
+    // literal instead of appending and runs off its end for any code above 7.
+    const std::string prefix = "Error: ";
+    REQUIRE(error_message.rfind(prefix, 0) == 0);
+
+    const std::string code = error_message.substr(prefix.size());
+    REQUIRE_FALSE(code.empty());
+    REQUIRE(std::all_of(code.begin(), code.end(), [](unsigned char c) { return std::isdigit(c) != 0; }));
+#endif // _WIN32
+}

tests/libslic3r/test_wipe_tower.cpp

@@ -0,0 +1,93 @@
+#include <catch2/catch_all.hpp>
+
+#include <cmath>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/GCode/WipeTower2.hpp"
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+
+// A Bambu P1S project that reproduced the off-plate brim: two PLAs priming 30 and 45 mm3 in
+// separate adhesiveness categories on a 35 mm tower, 0.21 mm layers, 0.4 nozzle (0.5 mm lines),
+// 150 % infill gap (0.75 mm line pitch), rib width 8, 16 mm tall.
+static std::vector<WipeTower::PurgeEstimate> cube_purges(int first_category = 100)
+{
+    return {{30.f, first_category}, {45.f, 0}};
+}
+
+TEST_CASE("Cone base polygon bulges past the body box", "[WipeTower]") {
+    // Zero angle: plain body box.
+    const Polygon box = WipeTower2::cone_base_polygon(35., 20., 100., 0.);
+    CHECK(box.points.size() == 4);
+    CHECK(get_extents(box).size() == Point::new_scale(Vec2d(35., 20.)));
+    // A 25-degree cone on a 100 mm tower: base radius R = tan(12.5deg)*100 = 22.2 mm,
+    // which exceeds the body half-depth, so the footprint bulges to center +- R in y
+    // (support_scale keeps the x extent compressed near the body).
+    const Polygon     base = WipeTower2::cone_base_polygon(35., 20., 100., 25.);
+    const BoundingBox bb   = get_extents(base);
+    const double      R    = std::tan(25. / 2. * M_PI / 180.) * 100.;
+    CHECK_THAT(unscaled(bb.min.y()), WithinAbs(10. - R, 0.1));
+    CHECK_THAT(unscaled(bb.max.y()), WithinAbs(10. + R, 0.1));
+    // The footprint always contains the body box.
+    CHECK(diff(Polygons{box}, Polygons{base}).empty());
+}
+
+TEST_CASE("Type1 block-stack depth quantizes each purge to whole lines", "[WipeTower]") {
+    // A 0.5 mm line at 0.21 mm carries 0.0955 mm3 per mm, so across the 34 mm between the
+    // perimeters 30 mm3 is 10 lines and 45 mm3 is 14: 7.5 + 10.5 at the 0.75 mm pitch behind
+    // one perimeter width. The generated mesh of the project measured exactly this.
+    CHECK_THAT(WipeTower::estimate_tower_blocks_depth(cube_purges(), 35.f, 0.21f, 0.4f, 1.5f), WithinAbs(18.5f, 0.01f));
+    // Sharing one category, a layer can never purge into every filament (one of them starts
+    // the layer), so the block is sized by its worst layer and the 10-line purge drops out.
+    CHECK_THAT(WipeTower::estimate_tower_blocks_depth(cube_purges(0), 35.f, 0.21f, 0.4f, 1.5f), WithinAbs(11.0f, 0.01f));
+    CHECK_THAT(WipeTower::estimate_tower_blocks_depth({}, 35.f, 0.2f, 0.4f, 1.f), WithinAbs(0.f, 1e-6f));
+    // A width narrower than two perimeter widths cannot hold purge lines.
+    CHECK_THAT(WipeTower::estimate_tower_blocks_depth({{45.f, 0}}, 0.9f, 0.2f, 0.4f, 1.f), WithinAbs(0.f, 1e-6f));
+}
+
+TEST_CASE("A nozzle change adds its ramming lines to the block", "[WipeTower]") {
+    // 10 mm of 1.75 mm filament (24.05 mm3) laid as 1.0 mm nozzle-change lines at 0.2 mm
+    // (0.1914 mm2 each) is 125.7 mm; across the 48.5 mm available that is 3 lines of 1.0 mm.
+    std::vector<WipeTower::PurgeEstimate> purges{{100.f, 0}, {100.f, 0}};
+    const float without_change = WipeTower::estimate_tower_blocks_depth(purges, 50.f, 0.2f, 0.4f, 1.f);
+    purges.front().filament_change_length = 10.f;
+    CHECK_THAT(WipeTower::estimate_tower_blocks_depth(purges, 50.f, 0.2f, 0.4f, 1.f) - without_change, WithinAbs(3.f, 1e-4f));
+}
+
+TEST_CASE("Rib tower footprint estimate covers the generated footprint", "[WipeTower]") {
+    // The generated first-layer wall bbox of the project measured 29.56 mm from the sliced
+    // G-code; the volume-only estimate said 23.585 mm.
+    const float side = WipeTower::estimate_rib_tower_bbox_side(cube_purges(), 35.f, 0.21f, 0.4f, 1.5f, 8.f, 0.f, 16.f);
+    CHECK(side >= 29.56f);
+    CHECK(side <= 29.56f + 4.f); // without grossly over-reserving plate space
+    // Separate categories stack their blocks, so the footprint must not shrink when they differ.
+    CHECK(side >= WipeTower::estimate_rib_tower_bbox_side(cube_purges(0), 35.f, 0.21f, 0.4f, 1.5f, 8.f, 0.f, 16.f));
+    CHECK_THAT(WipeTower::estimate_rib_tower_bbox_side({}, 35.f, 0.2f, 0.4f, 1.f, 8.f, 0.f, 16.f), WithinAbs(0.f, 1e-6f));
+}
+
+TEST_CASE("Rib footprint extends the ribs, not the body, below the stability minimum", "[WipeTower]") {
+    // A 10 mm body under a 90 mm print: the ribs stretch to the minimum depth's diagonal, and
+    // the rib width is capped at half the body, so the square grows to minimum + 5 / sqrt(2).
+    const float min_depth = WipeTower::get_limit_depth_by_height(90.f);
+    REQUIRE(min_depth > 10.f);
+    CHECK_THAT(WipeTower::rib_footprint_side(10.f, 10.f, 8.f, 0.f, 90.f), WithinAbs(min_depth + 5.f / std::sqrt(2.f), 1e-4f));
+    // The extra rib length runs along the diagonal, so it shows as its projection on each axis.
+    const float plain = WipeTower::rib_footprint_side(30.f, 30.f, 8.f, 0.f, 5.f);
+    CHECK_THAT(plain, WithinAbs(30.f + 8.f / std::sqrt(2.f), 1e-4f));
+    CHECK_THAT(WipeTower::rib_footprint_side(30.f, 30.f, 8.f, 4.f, 5.f) - plain, WithinAbs(4.f / std::sqrt(2.f), 1e-4f));
+    // A negative extra length cannot pull the ribs inside the diagonal.
+    CHECK_THAT(WipeTower::rib_footprint_side(30.f, 30.f, 8.f, -4.f, 5.f), WithinAbs(plain, 1e-4f));
+    CHECK_THAT(WipeTower::rib_footprint_side(0.f, 30.f, 8.f, 0.f, 5.f), WithinAbs(0.f, 1e-6f));
+}
+
+TEST_CASE("Brim width estimate matches each generator's loop quantization", "[WipeTower]") {
+    // 3 mm configured, 0.4 nozzle, 0.2 first layer: 0.4571 mm spacing, 7 loops. WipeTower2
+    // prints and reports the 7 loops; WipeTower reports half a spacing of line width on top.
+    const float spacing = 0.5f - 0.2f * float(1. - M_PI_4);
+    CHECK_THAT(WipeTower::estimate_brim_real_width(3.f, 0.4f, 0.2f, true), WithinAbs(7.f * spacing, 1e-4f));
+    CHECK_THAT(WipeTower::estimate_brim_real_width(3.f, 0.4f, 0.2f, false), WithinAbs(7.5f * spacing, 1e-4f));
+    CHECK_THAT(WipeTower::estimate_brim_real_width(0.f, 0.4f, 0.2f, true), WithinAbs(0.f, 1e-6f));
+}

tests/libslic3r/test_wipe_tower_estimate.cpp

@@ -0,0 +1,351 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/GCode/WipeTower2.hpp"
+#include "libslic3r/GCode/WipeTowerEstimate.hpp"
+#include "libslic3r/PrintConfig.hpp"
+
+#include <cmath>
+#include <numeric>
+#include <string>
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+
+// Rectangle wall, one nozzle, 100 mm3 prime volume on a 50 mm wide tower at 0.2 mm layers: one
+// purge is 10 mm of depth. The flush matrix is off here; the shipped-default case covers it.
+// Built as PresetBundle::full_config builds the GUI's: apply() creates each enum as a
+// ConfigOptionEnumGeneric, where full_print_config() would clone the static defaults'
+// ConfigOptionEnum<T>. The estimate has to read either.
+static DynamicPrintConfig preset_shaped_defaults()
+{
+    DynamicPrintConfig config;
+    config.apply(FullPrintConfig::defaults());
+    return config;
+}
+
+static DynamicPrintConfig make_config(const char *wall_type = "rectangle")
+{
+    DynamicPrintConfig config = preset_shaped_defaults();
+    config.set_key_value("prime_tower_width", new ConfigOptionFloat(50.));
+    config.set_key_value("prime_volume", new ConfigOptionFloat(100.));
+    config.set_key_value("filament_prime_volume", new ConfigOptionFloats({100.}));
+    config.set_key_value("filament_adhesiveness_category", new ConfigOptionInts({0}));
+    config.set_key_value("prime_tower_infill_gap", new ConfigOptionPercent(100.));
+    config.set_key_value("wipe_tower_extra_spacing", new ConfigOptionPercent(100.));
+    config.set_key_value("prime_tower_brim_width", new ConfigOptionFloat(3.));
+    config.set_deserialize_strict("wipe_tower_wall_type", wall_type);
+    config.set_key_value("wipe_tower_rib_width", new ConfigOptionFloat(8.));
+    config.set_key_value("wipe_tower_extra_rib_length", new ConfigOptionFloat(0.));
+    config.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4}));
+    config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(0.2));
+    config.set_deserialize_strict("timelapse_type", "0");
+    config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
+    config.set_key_value("raft_layers", new ConfigOptionInt(0));
+    config.set_key_value("purge_in_prime_tower", new ConfigOptionBool(false));
+    config.set_key_value("single_extruder_multi_material", new ConfigOptionBool(false));
+    return config;
+}
+
+static std::vector<unsigned int> filaments(size_t count)
+{
+    std::vector<unsigned int> ids(count);
+    std::iota(ids.begin(), ids.end(), 0u);
+    return ids;
+}
+
+// The first `count` filaments on the given planner; Type2 unless a case says otherwise.
+static WipeTowerFootprint estimate(const ConfigBase &config, size_t count, double layer_height, double height, WipeTowerType type = WipeTowerType::Type2)
+{
+    return estimate_wipe_tower_footprint(config, type, filaments(count), layer_height, height);
+}
+
+// What both planners print for a 3 mm brim at 0.4 nozzle and 0.2 first layer (0.4571 mm loops).
+static double printed_brim(double configured, WipeTowerType type)
+{
+    return WipeTower::estimate_brim_real_width(float(configured), 0.4f, 0.2f, type == WipeTowerType::Type2);
+}
+
+TEST_CASE("A rectangle wall tower is sized by the purge volume", "[WipeTowerEstimate]") {
+    const DynamicPrintConfig config = make_config();
+    // Three filaments purge twice per layer; a 5 mm object keeps the stability floor at 5 mm.
+    const WipeTowerFootprint fp = estimate(config, 3, 0.2, 5.);
+    CHECK_THAT(fp.width, WithinAbs(50., 1e-9));
+    CHECK_THAT(fp.depth, WithinAbs(20., 1e-9));
+    CHECK_THAT(fp.height, WithinAbs(5., 1e-9));
+    CHECK_THAT(fp.brim_width, WithinAbs(printed_brim(3., WipeTowerType::Type2), 1e-6));
+    // Thinner layers need more depth for the same volume.
+    CHECK_THAT(estimate(config, 3, 0.1, 5.).depth, WithinAbs(40., 1e-9));
+}
+
+TEST_CASE("Each planner spaces its purge lines by its own option", "[WipeTowerEstimate]") {
+    // Type2 reads wipe_tower_extra_spacing and Type1 prime_tower_infill_gap; neither sees the
+    // other's key. Type2's extra flow cancels out of its depth.
+    DynamicPrintConfig config = make_config();
+    config.set_key_value("wipe_tower_extra_flow", new ConfigOptionPercent(250.));
+    CHECK_THAT(estimate(config, 3, 0.2, 5.).depth, WithinAbs(20., 1e-9));
+    config.set_key_value("wipe_tower_extra_spacing", new ConfigOptionPercent(150.));
+    CHECK_THAT(estimate(config, 3, 0.2, 5.).depth, WithinAbs(30., 1e-9));
+    const double type1_spaced = estimate(config, 3, 0.2, 5., WipeTowerType::Type1).depth;
+    config.set_key_value("prime_tower_infill_gap", new ConfigOptionPercent(150.));
+    CHECK_THAT(estimate(config, 3, 0.2, 5.).depth, WithinAbs(30., 1e-9));
+    // Type1 stacks whole lines behind one 0.5 mm perimeter width, so only the stack scales.
+    CHECK_THAT(estimate(config, 3, 0.2, 5., WipeTowerType::Type1).depth - 0.5, WithinAbs(1.5 * (type1_spaced - 0.5), 1e-6));
+}
+
+TEST_CASE("Type1 sizes the tower from each filament's own prime volume", "[WipeTowerEstimate]") {
+    // The Bambu P1S project of the WipeTower cases: 30 and 45 mm3 in two categories on a 35 mm
+    // tower at 0.21 mm, 150 % gap, is 18.5 mm of stacked blocks (11 mm sharing one category).
+    DynamicPrintConfig config = make_config();
+    config.set_key_value("prime_tower_width", new ConfigOptionFloat(35.));
+    config.set_key_value("prime_tower_infill_gap", new ConfigOptionPercent(150.));
+    config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(0.21));
+    config.set_key_value("filament_prime_volume", new ConfigOptionFloats({30., 45.}));
+    config.set_key_value("filament_adhesiveness_category", new ConfigOptionInts({100, 0}));
+    const std::vector<WipeTower::PurgeEstimate> purges{{30.f, 100}, {45.f, 0}};
+    const double blocks = WipeTower::estimate_tower_blocks_depth(purges, 35.f, 0.21f, 0.4f, 1.5f);
+    REQUIRE_THAT(blocks, WithinAbs(18.5, 0.01));
+    CHECK_THAT(estimate(config, 2, 0.21, 5., WipeTowerType::Type1).depth, WithinAbs(blocks, 1e-4));
+    // The ids pick the volumes, so their order does not matter and a lone filament has no purge.
+    CHECK_THAT(estimate_wipe_tower_footprint(config, WipeTowerType::Type1, {1, 0}, 0.21, 5.).depth, WithinAbs(blocks, 1e-4));
+    CHECK_THAT(estimate(config, 1, 0.21, 5., WipeTowerType::Type1).depth, WithinAbs(0., 1e-9));
+    config.set_key_value("filament_adhesiveness_category", new ConfigOptionInts({0, 0}));
+    CHECK_THAT(estimate(config, 2, 0.21, 5., WipeTowerType::Type1).depth, WithinAbs(11., 0.01));
+    // A rib wall squares the same stack.
+    config.set_deserialize_strict("wipe_tower_wall_type", "rib");
+    const WipeTowerFootprint rib = estimate(config, 2, 0.21, 5., WipeTowerType::Type1);
+    CHECK_THAT(rib.width, WithinAbs(rib.depth, 1e-9));
+    CHECK_THAT(rib.depth, WithinAbs(WipeTower::estimate_rib_tower_bbox_side({{30.f, 0}, {45.f, 0}}, 35.f, 0.21f, 0.4f, 1.5f, 8.f, 0.f, 5.f), 1e-4));
+}
+
+TEST_CASE("A second nozzle adds the ramming of one nozzle change per layer", "[WipeTowerEstimate]") {
+    // Two filaments on two nozzles: the tool order crosses once per layer, and Type1 rams 10 mm
+    // of filament as three 1.0 mm nozzle-change lines (see the WipeTower case).
+    DynamicPrintConfig config = make_config();
+    config.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4, 0.4}));
+    config.set_key_value("filament_change_length", new ConfigOptionFloats({10., 10.}));
+    config.set_key_value("filament_diameter", new ConfigOptionFloats({1.75, 1.75}));
+    config.set_key_value("filament_map", new ConfigOptionInts({1, 1}));
+    const double same_nozzle = estimate(config, 2, 0.2, 5., WipeTowerType::Type1).depth;
+    config.set_key_value("filament_map", new ConfigOptionInts({1, 2}));
+    CHECK_THAT(estimate(config, 2, 0.2, 5., WipeTowerType::Type1).depth - same_nozzle, WithinAbs(3., 1e-4));
+}
+
+TEST_CASE("The tower is sized for the first layer when it is the thinnest", "[WipeTowerEstimate]") {
+    // Both planners reserve the worst layer: a 0.28 mm print with a 0.2 mm first layer needs
+    // the 0.2 mm depth, while a thicker first layer changes nothing.
+    DynamicPrintConfig config = make_config();
+    const double at_thinnest = estimate(config, 3, 0.2, 5.).depth;
+    CHECK_THAT(estimate(config, 3, 0.28, 5.).depth, WithinAbs(at_thinnest, 1e-9));
+    config.set_key_value("initial_layer_print_height", new ConfigOptionFloat(0.3));
+    CHECK(estimate(config, 3, 0.28, 5.).depth < at_thinnest);
+}
+
+TEST_CASE("Object height sets the stability floor and the auto brim", "[WipeTowerEstimate]") {
+    DynamicPrintConfig config = make_config();
+    // Two filaments purge once: 10 mm, lifted to the 20 mm floor of a 100 mm tower.
+    CHECK_THAT(estimate(config, 2, 0.2, 100.).depth, WithinAbs(20., 1e-9));
+    config.set_key_value("prime_tower_brim_width", new ConfigOptionFloat(-1.));
+    const double auto_brim = WipeTower::get_auto_brim_by_height(50.f);
+    CHECK_THAT(estimate(config, 2, 0.2, 50.).brim_width, WithinAbs(printed_brim(auto_brim, WipeTowerType::Type2), 1e-6));
+    CHECK_THAT(estimate(config, 2, 0.2, 50., WipeTowerType::Type1).brim_width, WithinAbs(printed_brim(auto_brim, WipeTowerType::Type1), 1e-6));
+}
+
+TEST_CASE("A single filament only gets a tower when one is printed anyway", "[WipeTowerEstimate]") {
+    DynamicPrintConfig config = make_config();
+    CHECK_THAT(estimate(config, 1, 0.2, 100.).depth, WithinAbs(0., 1e-9));
+    CHECK_THAT(estimate(config, 0, 0.2, 100.).width, WithinAbs(0., 1e-9));
+
+    // Wrapping detection prints a tower on the first layers whatever the filament count: the
+    // Type1 planner's fixed 10 mm, the stability floor otherwise.
+    config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(true));
+    CHECK_THAT(estimate(config, 1, 0.2, 100.).depth, WithinAbs(20., 1e-9));
+    CHECK_THAT(estimate(config, 1, 0.2, 100., WipeTowerType::Type1).depth, WithinAbs(WipeTower::get_wrapping_detection_depth(), 1e-9));
+    config.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
+
+    // A raft is not one of them: normalize_fdm_2 clears enable_prime_tower for a plate that
+    // purges one filament unless smooth timelapse or wrapping detection is on, so a raft
+    // alone leaves no tower to reserve for.
+    config.set_key_value("raft_layers", new ConfigOptionInt(3));
+    CHECK_THAT(estimate(config, 1, 0.2, 100.).depth, WithinAbs(0., 1e-9));
+    config.set_key_value("raft_layers", new ConfigOptionInt(0));
+
+    config.set_deserialize_strict("timelapse_type", "1");
+    // A tower printed with no tool change is exactly the planner's idle depth: there is
+    // nothing to purge, and WipeTower2 sizes it at the stability floor.
+    CHECK_THAT(estimate(config, 1, 0.2, 100.).depth, WithinAbs(20., 1e-9));
+    CHECK_THAT(estimate(config, 1, 0.2, 5.).depth, WithinAbs(WipeTower::get_limit_depth_by_height(5.f), 1e-9));
+}
+
+TEST_CASE("A tool change reserves a tower even with nothing to purge", "[WipeTowerEstimate]") {
+    // The purge volumes are configurable down to zero, but the tool changes are still printed
+    // on the tower and both planners still floor it - so the estimate has to floor it too.
+    // Type1 plans per filament and already reserves one; Type2 has only the volume to go on.
+    const double     height = GENERATE(5., 100.);
+    const float      floor  = WipeTower::get_limit_depth_by_height(float(height));
+    const char      *wall   = GENERATE("rectangle", "rib");
+    DynamicPrintConfig config = make_config(wall);
+    config.set_key_value("prime_volume", new ConfigOptionFloat(0.));
+    config.set_key_value("filament_prime_volume", new ConfigOptionFloats({0.}));
+
+    CHECK(estimate(config, 3, 0.2, height, WipeTowerType::Type2).depth >= floor);
+    CHECK(estimate(config, 3, 0.2, height, WipeTowerType::Type1).depth >= floor);
+    // Still nothing for a lone filament with no other reason.
+    CHECK_THAT(estimate(config, 1, 0.2, height, WipeTowerType::Type2).depth, WithinAbs(0., 1e-9));
+    CHECK_THAT(estimate(config, 1, 0.2, height, WipeTowerType::Type1).depth, WithinAbs(0., 1e-9));
+}
+
+TEST_CASE("Both wall types agree on whether there is a tower at all", "[WipeTowerEstimate]") {
+    // A wall type may only change the shape of the tower, never whether one is reserved:
+    // reporting no tower for one that is built collapses the validation hull to a point.
+    const double height = GENERATE(5., 100.);
+    DynamicPrintConfig rect = make_config();
+    DynamicPrintConfig rib  = make_config("rib");
+
+    // No tool change and nothing else that prints a tower - neither wall type reserves one.
+    CHECK_THAT(estimate(rect, 1, 0.2, height).depth, WithinAbs(0., 1e-9));
+    CHECK_THAT(estimate(rib, 1, 0.2, height).depth, WithinAbs(0., 1e-9));
+
+    // Not even on a dual-nozzle printer, where a lone filament still needs no purge.
+    rect.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4, 0.4}));
+    rib.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4, 0.4}));
+    CHECK_THAT(estimate(rect, 1, 0.2, height).depth, WithinAbs(0., 1e-9));
+    CHECK_THAT(estimate(rib, 1, 0.2, height).depth, WithinAbs(0., 1e-9));
+
+    // With a tool change both reserve one, and both respect the stability floor.
+    CHECK(estimate(rect, 2, 0.2, height).depth >= WipeTower::get_limit_depth_by_height(float(height)));
+    CHECK(estimate(rib, 2, 0.2, height).depth >= WipeTower::get_limit_depth_by_height(float(height)));
+}
+
+TEST_CASE("A rib wall squares the tower and caps the rib width", "[WipeTowerEstimate]") {
+    DynamicPrintConfig config = make_config("rib");
+    // sqrt(200 / 0.2) = 31.62 mm square, plus the 8 mm rib bulge along the diagonal.
+    const double body = std::sqrt(1000.);
+    WipeTowerFootprint fp = estimate(config, 3, 0.2, 5.);
+    CHECK_THAT(fp.depth, WithinAbs(8. / std::sqrt(2.) + body, 1e-5));
+    CHECK_THAT(fp.width, WithinAbs(fp.depth, 1e-9));
+    // The extra rib length runs along the diagonal and grows the footprint by its projection.
+    config.set_key_value("wipe_tower_extra_rib_length", new ConfigOptionFloat(4.));
+    CHECK_THAT(estimate(config, 3, 0.2, 5.).depth, WithinAbs((8. + 4.) / std::sqrt(2.) + body, 1e-5));
+    // A tiny tower caps the rib width at half its depth: 5 mm body, 2.5 mm rib.
+    config.set_key_value("wipe_tower_extra_rib_length", new ConfigOptionFloat(0.));
+    config.set_key_value("prime_volume", new ConfigOptionFloat(5.));
+    CHECK_THAT(estimate(config, 2, 0.2, 5.).depth, WithinAbs(2.5 / std::sqrt(2.) + 5., 1e-5));
+}
+
+TEST_CASE("Every wall and tower type is read the same from a preset and a static config", "[WipeTowerEstimate]") {
+    // The GUI, arrange and the CLI pass a DynamicPrintConfig whose enums are
+    // ConfigOptionEnumGeneric; Print passes a static config whose enums are ConfigOptionEnum<T>.
+    // Both the wall type and the planner selection are read by value, so both give the same shape.
+    const char *wall_type  = GENERATE("rectangle", "cone", "rib");
+    const char *tower_type = GENERATE("type1", "type2");
+    DynamicPrintConfig preset = make_config(wall_type);
+    preset.set_deserialize_strict("wipe_tower_type", tower_type);
+    REQUIRE(dynamic_cast<const ConfigOptionEnumGeneric *>(preset.option("wipe_tower_wall_type")) != nullptr);
+
+    FullPrintConfig static_config;
+    static_config.apply(preset, true);
+    REQUIRE(static_config.wipe_tower_wall_type.serialize() == wall_type);
+    REQUIRE(static_config.wipe_tower_type.serialize() == tower_type);
+
+    const WipeTowerType type = resolve_wipe_tower_type(preset);
+    CHECK(type == (std::string(tower_type) == "type1" ? WipeTowerType::Type1 : WipeTowerType::Type2));
+    CHECK(resolve_wipe_tower_type(static_config) == type);
+
+    // Three filaments purge twice per layer on a 5 mm object.
+    const WipeTowerFootprint fp          = estimate(preset, 3, 0.2, 5., type);
+    const WipeTowerFootprint from_static = estimate(static_config, 3, 0.2, 5., type);
+    CHECK(fp.depth > 0.);
+    if (std::string(wall_type) == "rib")
+        CHECK_THAT(fp.width, WithinAbs(fp.depth, 1e-9));
+    else
+        CHECK_THAT(fp.width, WithinAbs(50., 1e-9));
+    CHECK_THAT(from_static.width, WithinAbs(fp.width, 1e-9));
+    CHECK_THAT(from_static.depth, WithinAbs(fp.depth, 1e-9));
+    CHECK_THAT(from_static.brim_width, WithinAbs(fp.brim_width, 1e-9));
+
+    // Smooth timelapse is the other enum the estimate reads: a lone filament gets a tower
+    // through both storages too.
+    preset.set_deserialize_strict("timelapse_type", "1");
+    static_config.apply(preset, true);
+    CHECK(estimate(preset, 1, 0.2, 5., type).depth > 0.);
+    CHECK(estimate(static_config, 1, 0.2, 5., type).depth > 0.);
+}
+
+TEST_CASE("The first-layer outline bulges only for a Type2 cone wall", "[WipeTowerEstimate]") {
+    // Read off a preset-shaped config, whose enums are ConfigOptionEnumGeneric: a cast to
+    // ConfigOptionEnum<T> sees no wall type there and would never find the cone.
+    DynamicPrintConfig config = make_config("cone");
+    config.set_key_value("wipe_tower_cone_angle", new ConfigOptionFloat(25.));
+    REQUIRE(dynamic_cast<const ConfigOptionEnumGeneric *>(config.option("wipe_tower_wall_type")) != nullptr);
+    const Polygon box = Polygon::new_scale({{0., 0.}, {35., 0.}, {35., 20.}, {0., 20.}});
+    auto is_box = [&box](const Polygon &outline) { return diff(Polygons{outline}, Polygons{box}).empty(); };
+
+    // A 25-degree cone on a 100 mm tower has a 22 mm base radius, past the 10 mm half-depth.
+    const Polygon cone = estimate_wipe_tower_first_layer_outline(config, WipeTowerType::Type2, 35., 20., 100.);
+    CHECK(unscaled(get_extents(cone).max.y()) > 20. + 1.);
+    CHECK(diff(Polygons{box}, Polygons{cone}).empty());
+    // Type1 ignores the cone option, and the other wall types have no cone.
+    CHECK(is_box(estimate_wipe_tower_first_layer_outline(config, WipeTowerType::Type1, 35., 20., 100.)));
+    for (const char *wall_type : {"rectangle", "rib"}) {
+        config.set_deserialize_strict("wipe_tower_wall_type", wall_type);
+        CHECK(is_box(estimate_wipe_tower_first_layer_outline(config, WipeTowerType::Type2, 35., 20., 100.)));
+    }
+    // The static config Print holds gives the same outline.
+    config.set_deserialize_strict("wipe_tower_wall_type", "cone");
+    FullPrintConfig static_config;
+    static_config.apply(config, true);
+    const Polygon from_static = estimate_wipe_tower_first_layer_outline(static_config, WipeTowerType::Type2, 35., 20., 100.);
+    CHECK(from_static.points == cone.points);
+}
+
+TEST_CASE("A Bambu Lab printer always gets the Type1 planner", "[WipeTowerEstimate]") {
+    DynamicPrintConfig config = make_config();
+    config.set_deserialize_strict("wipe_tower_type", "type2");
+    config.set_key_value("printer_model", new ConfigOptionString("Bambu Lab X1 Carbon"));
+    CHECK(resolve_wipe_tower_type(config) == WipeTowerType::Type1);
+    config.set_key_value("printer_model", new ConfigOptionString("Voron 2.4"));
+    CHECK(resolve_wipe_tower_type(config) == WipeTowerType::Type2);
+    config.erase("wipe_tower_type");
+    CHECK(resolve_wipe_tower_type(config) == WipeTowerType::Type2);
+}
+
+TEST_CASE("A dual nozzle purges every filament plus the filament change", "[WipeTowerEstimate]") {
+    DynamicPrintConfig config = make_config();
+    config.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4, 0.4}));
+    config.set_key_value("filament_change_length", new ConfigOptionFloats({10., 10.}));
+    config.set_key_value("filament_diameter", new ConfigOptionFloats({1.75, 1.75}));
+    // Two purges of 100 mm3 plus one 10 mm filament change: (200 + 10 * pi * 1.75^2 / 4) / (0.2 * 50).
+    const double change_volume = 10. * PI * 1.75 * 1.75 / 4.;
+    CHECK_THAT(estimate(config, 2, 0.2, 5.).depth, WithinAbs((200. + change_volume) / 10., 1e-9));
+}
+
+TEST_CASE("The shipped defaults size the tower from the flush matrix", "[WipeTowerEstimate]") {
+    // Both keys default to true, so the shipped configuration purges the flush volumes rather
+    // than the prime volume, with no infill gap on top - the flush volumes already hold it.
+    DynamicPrintConfig config = preset_shaped_defaults();
+    REQUIRE(config.opt_bool("purge_in_prime_tower"));
+    REQUIRE(config.opt_bool("single_extruder_multi_material"));
+    config.set_key_value("prime_tower_width", new ConfigOptionFloat(50.));
+    config.set_deserialize_strict("wipe_tower_wall_type", "rectangle");
+    config.set_key_value("nozzle_diameter", new ConfigOptionFloats({0.4}));
+
+    const double flush_volume = WipeTower2::estimate_semm_flush_volume(config, 2);
+    const double expected     = std::max(double(WipeTower::get_limit_depth_by_height(5.f)), flush_volume / (0.2 * 50.));
+    CHECK_THAT(estimate(config, 2, 0.2, 5.).depth, WithinAbs(expected, 1e-6));
+}
+
+TEST_CASE("A config missing a tower key falls back to that key's default", "[WipeTowerEstimate]") {
+    // The signature takes any ConfigBase: an absent key must read as its declared default.
+    const DynamicPrintConfig full = make_config();
+    DynamicPrintConfig       partial = full;
+    partial.erase("wipe_tower_extra_spacing");
+    REQUIRE(partial.option("wipe_tower_extra_spacing") == nullptr);
+
+    DynamicPrintConfig defaulted = full;
+    defaulted.set_key_value("wipe_tower_extra_spacing",
+                            print_config_def.get("wipe_tower_extra_spacing")->default_value->clone());
+    CHECK_THAT(estimate(partial, 3, 0.2, 5.).depth, WithinAbs(estimate(defaulted, 3, 0.2, 5.).depth, 1e-9));
+}

tests/slic3rutils/CMakeLists.txt

@@ -1,6 +1,8 @@
 get_filename_component(_TEST_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
 add_executable(${_TEST_NAME}_tests
     ${_TEST_NAME}_tests_main.cpp
+    test_bambu_filament_ids.cpp
+    test_creality_cfs_match.cpp
     test_dev_mapping.cpp
     test_filament_bitmap_utils.cpp
     test_network_versions.cpp

tests/slic3rutils/plugin_test_utils.hpp

@@ -34,4 +34,24 @@ struct ScopedDataDir
     ScopedDataDir& operator=(const ScopedDataDir&) = delete;
 };
 
+// Point resources_dir() at a throwaway directory for the lifetime of a test and restore the
+// previous value afterwards, mirroring ScopedDataDir.
+struct ScopedResourcesDir
+{
+    ScopedTemporaryDir      tmp;
+    boost::filesystem::path dir;
+    std::string             previous;
+
+    explicit ScopedResourcesDir(const std::string& tag)
+        : tmp("orca-" + tag), dir(tmp.path()), previous(resources_dir())
+    {
+        set_resources_dir(dir.string());
+    }
+
+    ~ScopedResourcesDir() { set_resources_dir(previous); }
+
+    ScopedResourcesDir(const ScopedResourcesDir&)            = delete;
+    ScopedResourcesDir& operator=(const ScopedResourcesDir&) = delete;
+};
+
 } // namespace Slic3r

tests/slic3rutils/test_bambu_filament_ids.cpp

@@ -0,0 +1,81 @@
+#include <catch2/catch_all.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <nlohmann/json.hpp>
+
+#include "libslic3r/Utils.hpp"
+#include "slic3r/Utils/BBLPrinterAgent.hpp"
+#include "slic3r/Utils/OrcaPrinterAgent.hpp"
+
+using json = nlohmann::json;
+using namespace Slic3r;
+
+namespace {
+
+// Point resources_dir() at the repo's own tree for the lifetime of a test and restore it
+// afterwards, mirroring ScopedResourcesDir (which only ever makes a throwaway directory).
+// PROFILES_DIR is <repo>/resources/profiles; the map lives in <repo>/resources/printers.
+struct ScopedRepoResourcesDir
+{
+    std::string previous{resources_dir()};
+
+    ScopedRepoResourcesDir() { set_resources_dir(boost::filesystem::path(PROFILES_DIR).parent_path().string()); }
+    ~ScopedRepoResourcesDir() { set_resources_dir(previous); }
+
+    ScopedRepoResourcesDir(const ScopedRepoResourcesDir&)            = delete;
+    ScopedRepoResourcesDir& operator=(const ScopedRepoResourcesDir&) = delete;
+};
+
+std::string orca_id_of(const std::string& bambu_id)
+{
+    boost::nowide::ifstream file(resources_dir() + "/printers/bambu_filament_ids.json");
+    json doc;
+    file >> doc;
+    for (const auto& [orca_id, row] : doc["filaments"].items())
+        if (row["bambu_id"] == bambu_id)
+            return orca_id;
+    FAIL("no map row for " << bambu_id);
+    return {};
+}
+
+} // namespace
+
+TEST_CASE("Bambu filament id map is one-to-one and leaves unmapped ids alone", "[BambuFilamentIds]")
+{
+    const ScopedRepoResourcesDir repo_resources;
+    const BBLPrinterAgent bbl;
+    const std::string abs = orca_id_of("GFB00");                      // Bambu ABS
+    REQUIRE(abs.rfind("OF", 0) == 0);
+    CHECK(bbl.from_orca_filament_id(abs) == "GFB00");
+    CHECK(bbl.to_orca_filament_id("GFB00") == abs);
+    CHECK(bbl.from_orca_filament_id("OFnotarow") == "OFnotarow");
+    CHECK(bbl.to_orca_filament_id("GFZZ99") == "GFZZ99");             // Bambu id we do not ship
+    CHECK(bbl.to_orca_filament_id("P1234567") == "P1234567");         // user root
+    CHECK(bbl.from_orca_filament_id("") == "");
+
+    // An agent whose printers already speak our ids inherits IPrinterAgent's identity default.
+    const OrcaPrinterAgent other{""};
+    CHECK(other.from_orca_filament_id(abs) == abs);
+    CHECK(other.to_orca_filament_id("GFB00") == "GFB00");
+}
+
+TEST_CASE("Payload rewrite covers nested trays, calibration lists and mapping info", "[BambuFilamentIds]")
+{
+    const ScopedRepoResourcesDir repo_resources;
+    const std::string abs = orca_id_of("GFB00"), pla = orca_id_of("GFA00");
+    const std::string status =
+        R"({"print":{"ams":{"ams":[{"tray":[{"tray_info_idx":"GFB00"},{"tray_info_idx":"GFZZ99"}]}]},)"
+        R"("vt_tray":{"tray_info_idx":"GFA00"},"filaments":[{"filament_id":"GFA00","setting_id":"GFB00"}]}})";
+    json inbound = json::parse(BBLPrinterAgent::to_orca_payload(status));
+    CHECK(inbound["print"]["ams"]["ams"][0]["tray"][0]["tray_info_idx"] == abs);
+    CHECK(inbound["print"]["ams"]["ams"][0]["tray"][1]["tray_info_idx"] == "GFZZ99");    // no row: untouched
+    CHECK(inbound["print"]["vt_tray"]["tray_info_idx"] == pla);
+    CHECK(inbound["print"]["filaments"][0]["filament_id"] == pla);
+    CHECK(inbound["print"]["filaments"][0]["setting_id"] == "GFB00");                    // not an id key: has a map row but must stay put
+    CHECK(json::parse(BBLPrinterAgent::from_orca_payload(inbound.dump())) == json::parse(status));    // round trip
+
+    const std::string mapping = R"([{"ams":0,"filamentId":")" + abs + R"(","filamentType":"ABS"}])";
+    CHECK(BBLPrinterAgent::from_orca_payload(mapping) == R"([{"ams":0,"filamentId":"GFB00","filamentType":"ABS"}])");
+    CHECK(BBLPrinterAgent::from_orca_payload("not json") == "not json");
+    CHECK(BBLPrinterAgent::from_orca_payload(R"({"print":{"command":"pushall"}})") == R"({"print":{"command":"pushall"}})");
+}

tests/slic3rutils/test_creality_cfs_match.cpp

@@ -0,0 +1,141 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/PresetBundle.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "slic3r/Utils/CrealityPrintAgent.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+// A standalone filament collection, built the same way PresetBundle builds its own, so the
+// CFS matcher can be exercised without loading the shipped profiles or touching a printer.
+struct FilamentTestCollection : public PresetCollection
+{
+    FilamentTestCollection()
+        : PresetCollection(Preset::TYPE_FILAMENT, Preset::filament_options(),
+                           static_cast<const PrintRegionConfig &>(FullPrintConfig::defaults()))
+    {}
+};
+
+struct FilamentSpec
+{
+    const char *name;
+    const char *filament_id;
+    const char *filament_type;
+    bool        is_library = false;   // belongs to the Orca Filament Library, not the printer vendor
+    bool        is_system  = true;
+};
+
+// Load the specs into the collection, then stamp the fields the matcher reads. Done in a second
+// pass because load_preset() keeps m_presets sorted, so a reference taken during the first pass
+// can be left dangling by a later load.
+void populate(PresetCollection &filaments, const std::vector<FilamentSpec> &specs,
+              const VendorProfile &vendor, const VendorProfile &library)
+{
+    for (const FilamentSpec &spec : specs) {
+        DynamicPrintConfig config(filaments.default_preset().config);
+        config.option<ConfigOptionStrings>("filament_type", true)->values = {spec.filament_type};
+        filaments.load_preset(std::string(), spec.name, config, /*select=*/false);
+    }
+    for (auto it = filaments.begin(); it != filaments.end(); ++it) {
+        const auto spec = std::find_if(specs.begin(), specs.end(),
+                                       [&](const FilamentSpec &s) { return it->name == s.name; });
+        if (spec == specs.end())
+            continue;
+        it->filament_id  = spec->filament_id;
+        it->vendor       = spec->is_library ? &library : &vendor;
+        it->is_system    = spec->is_system;
+        it->is_default   = false;
+        it->is_visible   = true;
+        it->is_compatible = true;
+    }
+}
+
+// What a stock K2 with a 0.4 nozzle sees after the filament_id rework: the vendor's plain generics
+// carry no "Creality" in their name (they are "Generic <material> @<scope>"), while the subtype
+// variants that do keep a vendor scope are separate products with their own filament_ids.
+const std::vector<FilamentSpec> k2_stock_nozzle{
+    {"AliZ PLA @System",                       "ALIZ-PLA",     "PLA",  /*is_library=*/true},
+    {"Generic PETG @K2-all",                   "PETG-GENERIC", "PETG"},
+    {"Generic PLA @K2-all",                    "PLA-GENERIC",  "PLA"},
+    {"Generic PLA High Speed @Creality K2-all","PLA-HS",       "PLA"},
+    {"Generic PLA Matte @Creality K2-all",     "PLA-MATTE",    "PLA"},
+    {"Generic PLA Silk @Creality K2-all",      "PLA-SILK",     "PLA"},
+    {"Hyper PLA @K2-all",                      "PLA-HYPER",    "PLA"},
+};
+
+std::string match(const std::vector<FilamentSpec> &specs, const std::string &spool_vendor,
+                  const std::string &spool_name, const std::string &base_type)
+{
+    FilamentTestCollection filaments;
+    VendorProfile          vendor("Creality");
+    VendorProfile          library(PresetBundle::ORCA_FILAMENT_LIBRARY);
+    vendor.name  = "Creality";
+    library.name = PresetBundle::ORCA_FILAMENT_LIBRARY;
+    populate(filaments, specs, vendor, library);
+    return CrealityPrintAgent::match_filament_preset(filaments, spool_vendor, spool_name, base_type);
+}
+
+} // namespace
+
+// Orca: a CFS spool that names no recognised product must map to the vendor's plain generic. The
+// subtype variants ("High Speed", "Matte", "Silk") score just as well on vendor alone, and since
+// each is its own product with its own filament_id, letting one of them win sends the printer the
+// id of a filament the user does not have loaded.
+TEST_CASE("An unbranded CFS spool maps to the vendor's plain generic, not a subtype", "[CFS][Creality]")
+{
+    CHECK(match(k2_stock_nozzle, "Creality", "", "PLA") == "PLA-GENERIC");
+}
+
+// Orca: the vendor bonus reads the preset's owning VendorProfile. "Generic PETG @K2-all" does not
+// repeat "Creality" anywhere in its name, so a name based vendor test scored nothing for it and the
+// spool fell through to the collection wide first-of-type - an unrelated third party PETG.
+TEST_CASE("A CFS spool matches its vendor's presets even when the name omits the vendor", "[CFS][Creality]")
+{
+    CHECK(match(k2_stock_nozzle, "Creality", "", "PETG") == "PETG-GENERIC");
+}
+
+TEST_CASE("A branded CFS spool still beats the generic", "[CFS][Creality]")
+{
+    CHECK(match(k2_stock_nozzle, "Creality", "Hyper PLA", "PLA") == "PLA-HYPER");
+}
+
+// Orca: the specificity penalty must not stop a spool that genuinely asks for a subtype from
+// getting it - only unclaimed qualifiers are penalised.
+TEST_CASE("A CFS spool that names a subtype gets that subtype", "[CFS][Creality]")
+{
+    CHECK(match(k2_stock_nozzle, "Creality", "Generic PLA Silk", "PLA") == "PLA-SILK");
+    CHECK(match(k2_stock_nozzle, "Creality", "Generic PLA Matte", "PLA") == "PLA-MATTE");
+}
+
+// Orca: a third party spool matches no preset by brand or vendor, so it falls back to the first
+// visible preset of the same type rather than returning nothing. Which one that is depends on the
+// collection's ordering, so only the type is pinned here - what matters is that a PLA spool never
+// comes back empty and never comes back as another material.
+TEST_CASE("A CFS spool from an unknown vendor falls back to a preset of the same type", "[CFS][Creality]")
+{
+    const std::string matched = match(k2_stock_nozzle, "SomeOtherBrand", "", "PLA");
+    REQUIRE_FALSE(matched.empty());
+    const auto spec = std::find_if(k2_stock_nozzle.begin(), k2_stock_nozzle.end(),
+                                   [&](const FilamentSpec &s) { return matched == s.filament_id; });
+    REQUIRE(spec != k2_stock_nozzle.end());
+    CHECK(std::string(spec->filament_type) == "PLA");
+}
+
+
+// Orca: Creality's bundle also ships third party filaments ("eSUN PLA+ @K2 Plus-all"). Those carry
+// Creality's VendorProfile but name their real brand, so the vendor bonus has to accept a name
+// match as well as a profile match - otherwise an eSUN spool stops matching its own preset.
+TEST_CASE("A third party spool matches its preset inside the printer vendor's bundle", "[CFS][Creality]")
+{
+    const std::vector<FilamentSpec> with_third_party{
+        {"Generic PLA @K2-all",     "PLA-GENERIC", "PLA"},
+        {"eSUN PLA+ @K2 Plus-all",  "ESUN-PLA",    "PLA"},   // shipped by Creality, branded eSUN
+    };
+    CHECK(match(with_third_party, "eSUN", "", "PLA") == "ESUN-PLA");
+    // ... and a Creality spool still prefers Creality's own generic over the eSUN preset, which
+    // carries Creality's profile too but adds a brand word the spool never claimed.
+    CHECK(match(with_third_party, "Creality", "", "PLA") == "PLA-GENERIC");
+}

tests/slic3rutils/test_plugin_audit.cpp

@@ -27,6 +27,16 @@ void seed_denied_names()
         mgr.add_denied_filename(name);
 }
 
+// Seed the keyword registry with the same list install_hook() uses. Same rationale as
+// seed_denied_names(): a process-singleton registry, seeded from the single shared source so
+// production and tests cannot drift apart.
+void seed_denied_keywords()
+{
+    PluginAuditManager& mgr = PluginAuditManager::instance();
+    for (const auto& keyword : PluginAuditManager::default_denied_path_keywords())
+        mgr.add_denied_path_keyword(keyword);
+}
+
 } // namespace
 
 TEST_CASE("Plugin audit denies app config and token filenames anywhere", "[audit]")
@@ -81,7 +91,7 @@ TEST_CASE("Plugin audit denies app config and token filenames anywhere", "[audit
     }
 }
 
-TEST_CASE("Plugin audit deny beats allowed roots and the Loading read exemption", "[audit]")
+TEST_CASE("Plugin audit deny beats allowed roots", "[audit]")
 {
     ScopedDataDir data_dir_guard("plugin-audit-deny");
     seed_denied_names();
@@ -91,8 +101,8 @@ TEST_CASE("Plugin audit deny beats allowed roots and the Loading read exemption"
     // config and the token would otherwise be reachable simply by living inside it.
     mgr.add_global_allowed_root(data_dir());
 
-    // Enter a plugin context. The deny must hold in Loading mode, which every scope runs in.
-    ScopedPluginAuditContext ctx("test_plugin", "", PluginAuditManager::AuditMode::Loading);
+    // Enter a plugin context. The deny must hold even inside a globally allowed root.
+    ScopedPluginAuditContext ctx("test_plugin", "");
 
     const fs::path conf  = fs::path(data_dir()) / (SLIC3R_APP_KEY ".conf");
     const fs::path token = fs::path(data_dir()) / secret_constants::USER_SECRET_FILENAME;
@@ -103,6 +113,13 @@ TEST_CASE("Plugin audit deny beats allowed roots and the Loading read exemption"
         CHECK(decision.allowed);
     }
 
+    SECTION("a file outside the allowed root is blocked for reads as well as writes")
+    {
+        AuditDecision decision = mgr.check_open((fs::path(data_dir()).parent_path() / "outside.txt").string(), "r");
+        CHECK_FALSE(decision.allowed);
+        CHECK(decision.reason == "outside allowed root");
+    }
+
     SECTION("writing the app config is blocked despite data_dir() being allowed")
     {
         AuditDecision decision = mgr.check_open(conf.string(), "w");
@@ -110,16 +127,14 @@ TEST_CASE("Plugin audit deny beats allowed roots and the Loading read exemption"
         CHECK(decision.reason == "denied filename");
     }
 
-    SECTION("reading the app config is blocked even though Loading exempts reads")
+    SECTION("reading the app config is blocked despite the allowed root")
     {
-        // Without the deny, a read in Loading mode short-circuits to allow. The deny sits above
-        // that exemption, so this must still be blocked.
         AuditDecision decision = mgr.check_open(conf.string(), "r");
         CHECK_FALSE(decision.allowed);
         CHECK(decision.reason == "denied filename");
     }
 
-    SECTION("reading the cloud refresh token is blocked in Loading mode")
+    SECTION("reading the cloud refresh token is blocked")
     {
         AuditDecision decision = mgr.check_open(token.string(), "r");
         CHECK_FALSE(decision.allowed);
@@ -150,7 +165,7 @@ TEST_CASE("Plugin audit deny beats a plugin's own scoped root", "[audit]")
     const fs::path plugin_dir = fs::path(data_dir()) / "plugins" / "test_plugin";
     fs::create_directories(plugin_dir);
 
-    ScopedPluginAuditContext ctx("test_plugin", "", PluginAuditManager::AuditMode::Loading);
+    ScopedPluginAuditContext ctx("test_plugin", "");
     mgr.add_scoped_allowed_root(plugin_dir);
 
     SECTION("the plugin's own non-denied file opens for read and write")
@@ -185,3 +200,139 @@ TEST_CASE("Plugin audit does not constrain non-plugin code", "[audit]")
     CHECK(mgr.check_open(conf.string(), "w").allowed);
     CHECK(mgr.check_open(conf.string(), "r").allowed);
 }
+
+TEST_CASE("Plugin audit denies secret/certificate/config-like paths by keyword", "[audit]")
+{
+    seed_denied_keywords();
+    const PluginAuditManager& mgr = PluginAuditManager::instance();
+
+    SECTION("a 'secrets' directory component is denied")
+    {
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/secrets/api_key.json")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/secret/token.txt")));
+    }
+
+    SECTION("a 'certificate(s)' directory component is denied")
+    {
+        CHECK(mgr.is_denied_path_keyword(fs::path("/resources/cert/slicer_base64.cer")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/resources/certificates/ca.pem")));
+    }
+
+    SECTION("a 'conf'/'config' directory or file component is denied")
+    {
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/conf/settings.json")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/config/settings.json")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/plugin.conf")));
+    }
+
+    SECTION("matching is case-insensitive")
+    {
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/SECRETS/token.txt")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/resources/CertBundle/ca.pem")));
+        CHECK(mgr.is_denied_path_keyword(fs::path("/plugin/CONFIG.JSON")));
+    }
+
+    SECTION("matching is not limited to the base name -- any ancestor component counts")
+    {
+        CHECK(mgr.is_denied_path_keyword(fs::path("/data/secrets/nested/deep/file.txt")));
+    }
+
+    SECTION("an unrelated path is not denied")
+    {
+        CHECK_FALSE(mgr.is_denied_path_keyword(fs::path("/plugin/output/model.gcode")));
+        CHECK_FALSE(mgr.is_denied_path_keyword(fs::path("/plugin/storage/state.json")));
+    }
+
+    SECTION("an empty path is not denied")
+    {
+        CHECK_FALSE(mgr.is_denied_path_keyword(fs::path()));
+    }
+}
+
+TEST_CASE("Plugin audit is_denied_path combines the filename and keyword registries", "[audit]")
+{
+    seed_denied_names();
+    seed_denied_keywords();
+    const PluginAuditManager& mgr = PluginAuditManager::instance();
+
+    SECTION("a filename-registry match is denied")
+    {
+        CHECK(mgr.is_denied_path(fs::path(SLIC3R_APP_KEY ".conf")));
+    }
+
+    SECTION("a keyword-registry match is denied")
+    {
+        CHECK(mgr.is_denied_path(fs::path("/plugin/secrets/token.txt")));
+    }
+
+    SECTION("a path matching neither registry is not denied")
+    {
+        CHECK_FALSE(mgr.is_denied_path(fs::path("/plugin/output/model.gcode")));
+    }
+}
+
+TEST_CASE("Plugin audit a read-only allowed root blocks writes but not reads", "[audit]")
+{
+    ScopedDataDir      data_dir_guard("plugin-audit-readonly");
+    ScopedResourcesDir resources_dir_guard("plugin-audit-readonly-resources");
+    seed_denied_names();
+    seed_denied_keywords();
+
+    PluginAuditManager& mgr = PluginAuditManager::instance();
+    mgr.add_global_allowed_root(resources_dir(), /*allow_write=*/false);
+
+    ScopedPluginAuditContext ctx("test_plugin", "");
+
+    const fs::path readonly_file = fs::path(resources_dir()) / "profiles" / "vendor.json";
+
+    SECTION("a read inside the read-only root is allowed")
+    {
+        CHECK(mgr.check_open(readonly_file.string(), "r").allowed);
+    }
+
+    SECTION("a write inside the read-only root is blocked")
+    {
+        AuditDecision decision = mgr.check_open(readonly_file.string(), "w");
+        CHECK_FALSE(decision.allowed);
+        CHECK(decision.reason == "outside allowed root");
+    }
+
+    SECTION("a create inside the read-only root is blocked")
+    {
+        AuditDecision decision = mgr.check_path_access(readonly_file, /*is_write=*/true);
+        CHECK_FALSE(decision.allowed);
+    }
+
+    SECTION("the bundled cert underneath the read-only root is denied even for reads")
+    {
+        const fs::path cert = fs::path(resources_dir()) / "cert" / "slicer_base64.cer";
+        AuditDecision  decision = mgr.check_open(cert.string(), "r");
+        CHECK_FALSE(decision.allowed);
+        CHECK(decision.reason == "denied path keyword");
+    }
+}
+
+TEST_CASE("Plugin audit a scoped root can also be registered read-only", "[audit]")
+{
+    ScopedDataDir data_dir_guard("plugin-audit-scoped-readonly");
+    seed_denied_names();
+    seed_denied_keywords();
+
+    PluginAuditManager& mgr = PluginAuditManager::instance();
+
+    const fs::path readonly_dir = fs::path(data_dir()) / "readonly_scope";
+    fs::create_directories(readonly_dir);
+
+    ScopedPluginAuditContext ctx("test_plugin", "");
+    mgr.add_scoped_allowed_root(readonly_dir, /*allow_write=*/false);
+
+    SECTION("a read inside the scoped read-only root is allowed")
+    {
+        CHECK(mgr.check_open((readonly_dir / "vendor.json").string(), "r").allowed);
+    }
+
+    SECTION("a write inside the scoped read-only root is blocked")
+    {
+        CHECK_FALSE(mgr.check_open((readonly_dir / "vendor.json").string(), "w").allowed);
+    }
+}

tests/slic3rutils/test_plugin_install.cpp

@@ -112,6 +112,22 @@ TEST_CASE("install-state sidecar is the source of truth for a cloud plugin's ins
     REQUIRE(read_install_state(plugin_dir, state));
     CHECK(state.installed_version == "1.2.0");
 
+    state.permissions.fs_read       = {"/path/to/read"};
+    state.permissions.fs_readwrite  = {"/path/to/readwrite"};
+    state.permissions.network_http  = {"https://api.example.com"};
+    state.permissions.network_socket = {"192.168.45.6:443"};
+    state.permissions.process        = {"/usr/bin/curl"};
+    REQUIRE(write_install_state(plugin_dir, state));
+
+    // Permission data is persisted in the same sidecar as the installation metadata.
+    PluginInstallState persisted;
+    REQUIRE(read_install_state(plugin_dir, persisted));
+    CHECK(persisted.permissions.fs_read == state.permissions.fs_read);
+    CHECK(persisted.permissions.fs_readwrite == state.permissions.fs_readwrite);
+    CHECK(persisted.permissions.network_http == state.permissions.network_http);
+    CHECK(persisted.permissions.network_socket == state.permissions.network_socket);
+    CHECK(persisted.permissions.process == state.permissions.process);
+
     // Reading the sidecar back onto a freshly-scanned descriptor (whose header version is still
     // 1.0.0) must surface the cloud-installed 1.2.0. This is what lets update_cloud_metadata compare
     // the cloud's latest version against the installed version instead of the stale header, so an
@@ -120,4 +136,4 @@ TEST_CASE("install-state sidecar is the source of truth for a cloud plugin's ins
     scanned.version = "1.0.0"; // as parsed from the unchanged PEP723 header
     read_install_state(plugin_dir, scanned);
     CHECK(scanned.installed_version == "1.2.0");
-}
+}