Make the exclude-object outline tolerance a user setting (#16503 )

* Make the exclude-object outline tolerance configurable Signed-off-by: Sergei Rozhkov <zmod@zmod.link> * fix(config): move exclude_object_tolerance to developer mode Signed-off-by: Sergei Rozhkov <zmod@zmod.link> * fix(config): move exclude_object_tolerance to expert mode Signed-off-by: Sergei Rozhkov <zmod@zmod.link> * feat(ui): hide exclude_object_tolerance for non-Klipper firmwares mend Signed-off-by: Sergei Rozhkov <zmod@zmod.link> * Test that a larger exclude object tolerance writes fewer outline points Signed-off-by: Sergei Rozhkov <zmod@zmod.link> --------- Signed-off-by: Sergei Rozhkov <zmod@zmod.link>
Keep Auto Drop off for projects saved by 2.4.x (#16633 )
2026-10-19 13:41:03 +00:00 · 2026-10-19 08:17:20 -03:00 · 2026-10-19 16:08:59 +08:00 · 2026-10-19 16:06:41 +08:00
43 changed files with 1504 additions and 5 deletions
@@ -15648,6 +15648,12 @@ msgstr ""
 msgid "Enable this option to add EXCLUDE OBJECT command in G-code."
 msgstr ""

+msgid "Outline tolerance"
+msgstr ""
+
+msgid "Maximum deviation of the object outline written to EXCLUDE_OBJECT_DEFINE from the original outline. Larger values give fewer points, which helps firmware that stalls while parsing G-code with many objects. 0 keeps every point."
+msgstr ""
+
 msgid "Verbose G-code"
 msgstr ""

@@ -988,7 +988,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)

            MetadataList metadata;
            VolumeMetadataList volumes;
-            bool auto_drop { true };
+            std::optional<bool> auto_drop;
        };

        struct CutObjectInfo
@@ -1208,6 +1208,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        //IdToGeometryMap m_orig_geometries; // backup & restore
        CurrentConfig m_curr_config;
        IdToMetadataMap m_objects_metadata;
+        std::set<int>   m_items_auto_drop_off; // object ids with a build item auto_drop="0" (2.4.x layout)
        IdToCutObjectInfoMap       m_cut_object_infos;
        IdToLayerHeightsProfileMap m_layer_heights_profiles;
        IdToLayerConfigRangesMap m_layer_config_ranges;
@@ -1463,6 +1464,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        m_objects.clear();
        m_instances.clear();
        m_objects_metadata.clear();
+        m_items_auto_drop_off.clear();
        m_curr_metadata_name.clear();
        m_curr_characters.clear();

@@ -1502,6 +1504,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        m_curr_config.object_id = -1;
        m_curr_config.volume_id = -1;
        m_objects_metadata.clear();
+        m_items_auto_drop_off.clear();
        m_layer_heights_profiles.clear();
        m_layer_config_ranges.clear();
        m_brim_ear_points.clear();
@@ -2257,11 +2260,14 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
            ObjectMetadata::VolumeMetadataList volumes;
            ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;

+            // 2.4.x stored auto_drop on build items, shared by all instances of an object; any "off" wins
+            const bool legacy_auto_drop = !m_items_auto_drop_off.count(object.first.second);
+
            IdToMetadataMap::iterator obj_metadata = m_objects_metadata.find(object.first.second);
            if (obj_metadata != m_objects_metadata.end()) {
                // config data has been found, this model was saved using slic3r pe

-                model_object->auto_drop = obj_metadata->second.auto_drop;
+                model_object->auto_drop = obj_metadata->second.auto_drop.value_or(legacy_auto_drop);

                // apply object's name and config data
                for (const Metadata& metadata : obj_metadata->second.metadata) {
@@ -2279,6 +2285,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
            }
            else {
                // config data not found, this model was not saved using slic3r pe
+                model_object->auto_drop = legacy_auto_drop;

                // add the entire geometry as the single volume to generate
                //volumes.emplace_back(0, (int)obj_geometry->second.triangles.size() - 1);
@@ -4121,6 +4128,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        std::string path = bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR);
        Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
        int printable = bbs_get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
+        if (const char* auto_drop = bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR); auto_drop != nullptr && !::atoi(auto_drop))
+            m_items_auto_drop_off.insert(object_id);
        return !m_load_model || _create_object_instance(path, object_id, transform, printable, 1);
    }

@@ -4489,7 +4498,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
        // int instances_count_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);

        ObjectMetadata metadata;
-        metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
+        if (bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR) != nullptr)
+            metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
        m_objects_metadata.insert({ object_id, std::move(metadata) });
        m_curr_config.object_id = object_id;
        return true;
@@ -1421,6 +1421,7 @@ static std::vector<std::string> s_Preset_print_options{
    "initial_layer_travel_acceleration",
    "initial_layer_travel_jerk",
    "exclude_object",
+    "exclude_object_tolerance",
    "slow_down_layers",
    "infill_anchor",
    "infill_anchor_max",
@@ -309,6 +309,7 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
        "gcode_comments",
        "gcode_label_objects", 
        "exclude_object",
+        "exclude_object_tolerance",
        "support_material_interface_fan_speed",
        "internal_bridge_fan_speed", // ORCA: Add support for separate internal bridge fan speed control
        "ironing_fan_speed",
@@ -6929,7 +6930,7 @@ BoundingBoxf3 PrintInstance::get_bounding_box() const {

 Polygon PrintInstance::get_convex_hull_2d() {
    Polygon poly = print_object->model_object()->convex_hull_2d(model_instance->get_matrix());
-    poly.douglas_peucker(scale_(0.1));
+    poly.douglas_peucker(scale_(print_object->print()->config().exclude_object_tolerance.value));
    return poly;
 }

@@ -4629,6 +4629,17 @@ void PrintConfigDef::init_fff_params()
    def->mode = comAdvanced;
    def->set_default_value(new ConfigOptionBool(false));

+    def = this->add("exclude_object_tolerance", coFloat);
+    def->label = L("Outline tolerance");
+    def->tooltip = L("Maximum deviation of the object outline written to EXCLUDE_OBJECT_DEFINE from the "
+                     "original outline. Larger values give fewer points, which helps firmware that stalls "
+                     "while parsing G-code with many objects. 0 keeps every point.");
+    def->sidetext = L("mm");
+    def->min = 0;
+    def->max = 5;
+    def->mode = comExpert;
+    def->set_default_value(new ConfigOptionFloat(0.1));
+
    def = this->add("gcode_comments", coBool);
    def->label = L("Verbose G-code");
    def->tooltip = L("Enable this to get a commented G-code file, with each line explained by a descriptive text. "
@@ -2130,6 +2130,7 @@ PRINT_CONFIG_CLASS_DERIVED_DEFINE(
    ((ConfigOptionPercents,            filament_shrinkage_compensation_z))
    ((ConfigOptionBool,                gcode_label_objects))
    ((ConfigOptionBool,                exclude_object))
+    ((ConfigOptionFloat,               exclude_object_tolerance))
    ((ConfigOptionFloats,             grab_length))
    ((ConfigOptionBool,                gcode_comments))
    ((ConfigOptionInt,                 slow_down_layers))
@@ -1245,6 +1245,8 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, in
    if(gcf_is_klipper)
        toggle_field("accel_to_decel_factor", config->opt_bool("accel_to_decel_enable"));

+    toggle_line("exclude_object_tolerance", gcf_is_klipper && config->opt_bool("exclude_object"));
+
    bool have_make_overhang_printable = config->opt_bool("make_overhang_printable");
    toggle_line("make_overhang_printable_angle", have_make_overhang_printable);
    toggle_line("make_overhang_printable_hole_size", have_make_overhang_printable);
@@ -3269,6 +3269,7 @@ void TabPrint::build()
        optgroup->append_single_option_line("gcode_comments", "others_settings_g_code_output#verbose-g-code");
        optgroup->append_single_option_line("gcode_label_objects", "others_settings_g_code_output#label-objects");
        optgroup->append_single_option_line("exclude_object", "others_settings_g_code_output#exclude-objects");
+        optgroup->append_single_option_line("exclude_object_tolerance", "others_settings_g_code_output#outline-tolerance");
        option = optgroup->get_option("filename_format");
        // option.opt.full_width = true;
        option.opt.is_code = true;
@@ -0,0 +1 @@
+solid STL generated by MeshLab
  facet normal  0.000000e+00 -0.000000e+00 -1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal -0.000000e+00  0.000000e+00 -1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  0.000000e+00  1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  0.000000e+00  0.000000e+00  1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  1.000000e+00  0.000000e+00 -0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal -1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
    endloop
  endfacet
  facet normal -1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
    endloop
  endfacet
endsolid vcg
@@ -44,6 +44,7 @@
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SVG.hpp"
 #include "libslic3r/libslic3r.h"

 #include "test_helpers.hpp"
@@ -52,6 +53,15 @@ using namespace Slic3r;

 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle = 0, double density = 1.0);

+#if 0
+TEST_CASE("Adjusted solid distance", "[Fill]") {
+    int surface_width = 250;
+    int distance = Slic3r::Flow::solid_spacing(surface_width, 47);
+    REQUIRE(distance == Catch::Approx(50));
+    REQUIRE(surface_width % distance == 0);
+}
+#endif
+
 TEST_CASE("Pattern path length", "[Fill]") {
    std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
    filler->angle = float(-(PI)/2.0);
@@ -110,6 +120,15 @@ TEST_CASE("Pattern path length", "[Fill]") {
                filler->angle = float(angle);
                ExPolygon e(test_square, test_hole);
                Slic3r::Polylines paths = test(e);
+#if 0
+				{
+					BoundingBox bbox = get_extents(e);
+					SVG svg("c:\\data\\temp\\square_with_holes.svg", bbox);
+					svg.draw(e);
+					svg.draw(paths);
+					svg.Close();
+				}
+#endif
                REQUIRE((paths.size() >= 1 && paths.size() <= 3));
                // paths don't cross hole
                REQUIRE(diff_pl(paths, offset(e, float(SCALED_EPSILON*10))).size() == 0);
@@ -156,6 +175,25 @@ TEST_CASE("Pattern path length", "[Fill]") {
        }
    }

+    #if 0   // Disabled temporarily due to precision issues on the Mac VM
+    SECTION("Solid surface fill") {
+        Slic3r::Points points {
+            Point::new_scale(6883102, 9598327.01296997),
+            Point::new_scale(6883102, 20327272.01297),
+            Point::new_scale(3116896, 20327272.01297),
+            Point::new_scale(3116896, 9598327.01296997) 
+        };
+        Slic3r::ExPolygon expolygon(points);
+         
+        REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
+        for (size_t i = 0; i <= 20; ++i)
+        {
+            expolygon.scale(1.05);
+            REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
+        }
+    }
+    #endif
+
    SECTION("Solid surface fill") {
        Slic3r::Points points {
                Slic3r::Point(59515297,5422499),Slic3r::Point(59531249,5578697),Slic3r::Point(59695801,6123186),
@@ -188,6 +226,245 @@ TEST_CASE("Pattern path length", "[Fill]") {
    }
 }

+/*
+{
+    my $collection = Slic3r::Polyline::Collection->new(
+            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
+            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
+            );
+    is_deeply
+        [ map $_->[Y], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
+        [20, 18, 15, 10, 8, 5],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::Polyline::Collection->new(
+            Slic3r::Polyline->new([4,0], [10,0], [15,0]),
+            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
+            );
+    is_deeply
+        [ map $_->[X], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
+        [reverse 4, 10, 15, 10, 15, 20],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::ExtrusionPath::Collection->new(
+            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
+            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
+            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
+            );
+    is_deeply
+        [ map $_->[Y], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
+        [20, 18, 15, 10, 8, 5],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::ExtrusionPath::Collection->new(
+            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
+            Slic3r::Polyline->new([15,0], [10,0], [4,0]),
+            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
+            );
+    is_deeply
+        [ map $_->[X], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
+        [reverse 4, 10, 15, 10, 15, 20],
+        'chained path';
+}
+
+for my $pattern (qw(rectilinear honeycomb hilbertcurve concentric)) {
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('fill_pattern', $pattern);
+    $config->set('external_fill_pattern', $pattern);
+    $config->set('perimeters', 1);
+    $config->set('skirts', 0);
+    $config->set('fill_density', 20);
+    $config->set('layer_height', 0.05);
+    $config->set('perimeter_extruder', 1);
+    $config->set('infill_extruder', 2);
+    my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale => 2);
+    ok my $gcode = Slic3r::Test::gcode($print), "successful $pattern infill generation";
+    my $tool = undef;
+    my @perimeter_points = my @infill_points = ();
+    Slic3r::GCode::Reader->new->parse($gcode, sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            if ($tool == $config->perimeter_extruder-1) {
+            push @perimeter_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
+            } elsif ($tool == $config->infill_extruder-1) {
+            push @infill_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
+            }
+            }
+            });
+    my $convex_hull = convex_hull(\@perimeter_points);
+    ok !(defined first { !$convex_hull->contains_point($_) } @infill_points), "infill does not exceed perimeters ($pattern)";
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('infill_only_where_needed', 1);
+    $config->set('bottom_solid_layers', 0);
+    $config->set('infill_extruder', 2);
+    $config->set('infill_extrusion_width', 0.5);
+    $config->set('fill_density', 40);
+    $config->set('cooling', 0);                 # for preventing speeds from being altered
+        $config->set('first_layer_speed', '100%');  # for preventing speeds from being altered
+
+        my $test = sub {
+            my $print = Slic3r::Test::init_print('pyramid', config => $config);
+
+            my $tool = undef;
+            my @infill_extrusions = ();  # array of polylines
+                Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+                        my ($self, $cmd, $args, $info) = @_;
+
+                        if ($cmd =~ /^T(\d+)/) {
+                        $tool = $1;
+                        } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+                        if ($tool == $config->infill_extruder-1) {
+                        push @infill_extrusions, Slic3r::Line->new_scale(
+                                [ $self->X, $self->Y ],
+                                [ $info->{new_X}, $info->{new_Y} ],
+                                );
+                        }
+                        }
+                        });
+            return 0 if !@infill_extrusions;  # prevent calling convex_hull() with no points
+
+                my $convex_hull = convex_hull([ map $_->pp, map @$_, @infill_extrusions ]);
+            return unscale unscale sum(map $_->area, @{offset([$convex_hull], scale(+$config->infill_extrusion_width/2))});
+        };
+
+    my $tolerance = 5;  # mm^2
+
+        $config->set('solid_infill_below_area', 0);
+    ok $test->() < $tolerance,
+       'no infill is generated when using infill_only_where_needed on a pyramid';
+
+    $config->set('solid_infill_below_area', 70);
+    ok abs($test->() - $config->solid_infill_below_area) < $tolerance,
+       'infill is only generated under the forced solid shells';
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('skirts', 0);
+    $config->set('perimeters', 1);
+    $config->set('fill_density', 0);
+    $config->set('top_solid_layers', 0);
+    $config->set('bottom_solid_layers', 0);
+    $config->set('solid_infill_below_area', 20000000);
+    $config->set('solid_infill_every_layers', 2);
+    $config->set('perimeter_speed', 99);
+    $config->set('external_perimeter_speed', 99);
+    $config->set('cooling', 0);
+    $config->set('first_layer_speed', '100%');
+
+    my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
+    my %layers_with_extrusion = ();
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd eq 'G1' && $info->{dist_XY} > 0 && $info->{extruding}) {
+            if (($args->{F} // $self->F) != $config->perimeter_speed*60) {
+            $layers_with_extrusion{$self->Z} = ($args->{F} // $self->F);
+            }
+            }
+            });
+
+    ok !%layers_with_extrusion,
+       "solid_infill_below_area and solid_infill_every_layers are ignored when fill_density is 0";
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('skirts', 0);
+    $config->set('perimeters', 3);
+    $config->set('fill_density', 0);
+    $config->set('layer_height', 0.2);
+    $config->set('first_layer_height', 0.2);
+    $config->set('nozzle_diameter', [0.35]);
+    $config->set('infill_extruder', 2);
+    $config->set('solid_infill_extruder', 2);
+    $config->set('infill_extrusion_width', 0.52);
+    $config->set('solid_infill_extrusion_width', 0.52);
+    $config->set('first_layer_extrusion_width', 0);
+
+    my $print = Slic3r::Test::init_print('A', config => $config);
+    my %infill = ();  # Z => [ Line, Line ... ]
+        my $tool = undef;
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            if ($tool == $config->infill_extruder-1) {
+            my $z = 1 * $self->Z;
+            $infill{$z} ||= [];
+            push @{$infill{$z}}, Slic3r::Line->new_scale(
+                    [ $self->X, $self->Y ],
+                    [ $info->{new_X}, $info->{new_Y} ],
+                    );
+            }
+            }
+            });
+    my $grow_d = scale($config->infill_extrusion_width)/2;
+    my $layer0_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.2} } ]);
+    my $layer1_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.4} } ]);
+    my $diff = diff($layer0_infill, $layer1_infill);
+    $diff = offset2_ex($diff, -$grow_d, +$grow_d);
+    $diff = [ grep { $_->area > 2*(($grow_d*2)**2) } @$diff ];
+    is scalar(@$diff), 0, 'no missing parts in solid shell when fill_density is 0';
+}
+
+{
+    # GH: #2697
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('perimeter_extrusion_width', 0.72);
+    $config->set('top_infill_extrusion_width', 0.1);
+    $config->set('infill_extruder', 2);         # in order to distinguish infill
+        $config->set('solid_infill_extruder', 2);   # in order to distinguish infill
+
+        my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
+    my %infill = ();  # Z => [ Line, Line ... ]
+        my %other  = ();  # Z => [ Line, Line ... ]
+        my $tool = undef;
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            my $z = 1 * $self->Z;
+            my $line = Slic3r::Line->new_scale(
+                    [ $self->X, $self->Y ],
+                    [ $info->{new_X}, $info->{new_Y} ],
+                    );
+            if ($tool == $config->infill_extruder-1) {
+            $infill{$z} //= [];
+            push @{$infill{$z}}, $line;
+            } else {
+            $other{$z} //= [];
+            push @{$other{$z}}, $line;
+            }
+            }
+            });
+    my $top_z = max(keys %infill);
+    my $top_infill_grow_d = scale($config->top_infill_extrusion_width)/2;
+    my $top_infill = union([ map @{$_->grow($top_infill_grow_d)}, @{ $infill{$top_z} } ]);
+    my $perimeters_grow_d = scale($config->perimeter_extrusion_width)/2;
+    my $perimeters = union([ map @{$_->grow($perimeters_grow_d)}, @{ $other{$top_z} } ]);
+    my $covered = union_ex([ @$top_infill, @$perimeters ]);
+    my @holes = map @{$_->holes}, @$covered;
+    ok sum(map unscale unscale $_->area*-1, @holes) < 1, 'no gaps between top solid infill and perimeters';
+}
+*/
+
 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle, double density)
 {
    std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
@@ -221,6 +498,18 @@ bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacin
    const double scaled_flow_spacing = std::pow(scale_(flow_spacing), 2);
    uncovered.erase(std::remove_if(uncovered.begin(), uncovered.end(), [scaled_flow_spacing](const ExPolygon& poly) { return poly.area() < scaled_flow_spacing; }), uncovered.end());

+#if 0
+	if (! uncovered.empty()) {
+		BoundingBox bbox = get_extents(expolygon.contour);
+		bbox.merge(get_extents(uncovered));
+		bbox.merge(get_extents(grown_paths));
+		SVG svg("c:\\data\\temp\\test_if_solid_surface_filled.svg", bbox);
+		svg.draw(expolygon);
+		svg.draw(uncovered, "red");
+		svg.Close();
+	}
+#endif
+
    return uncovered.empty(); // solid surface is fully filled
 }

@@ -58,6 +58,23 @@ SCENARIO("Flow math for non-bridges", "[Flow]") {
            }
        }
    }
+
+#if 0
+    /// Check for an edge case in the maths where the spacing could be 0; original
+    /// math is 0.99. Slic3r issue #4654
+    GIVEN("Input spacing of 0.414159 and a total width of 2") {
+        double in_spacing = 0.414159;
+        double total_width = 2.0;
+        auto flow = Flow::new_from_spacing(1.0, 0.4, 0.3);
+        WHEN("solid_spacing() is called") {
+            double result = flow.solid_spacing(total_width, in_spacing);
+            THEN("Yielded spacing is greater than 0") {
+                REQUIRE(result > 0);
+            }
+        }
+    }
+#endif    
+
 }

 /// Spacing, width calculation for bridge extrusions
@@ -51,6 +51,44 @@ TEST_CASE("Klipper object labels name each copy without the characters Klipper c
    }
 }

+// The outline written to EXCLUDE_OBJECT_DEFINE is simplified with exclude_object_tolerance. A larger value must
+// leave fewer points, which keeps the exclude-object array small on printers that stall while parsing it.
+TEST_CASE("A larger exclude object tolerance writes fewer outline points", "[GCode]")
+{
+    const auto slice_with_tolerance = [](const std::string &tolerance) {
+        DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+        config.set_deserialize_strict({{"gcode_flavor", "klipper"}, {"exclude_object", "1"},
+                                       {"exclude_object_tolerance", tolerance}});
+        // Default facet angle (2 degrees): 180 hull points, well inside either tolerance.
+        return Test::slice({make_cylinder(20., 5.)}, config);
+    };
+    // Points of the POLYGON=[[x,y],...] on the first EXCLUDE_OBJECT_DEFINE line.
+    const auto polygon_points = [](const std::string &gcode) {
+        const size_t define = gcode.find("EXCLUDE_OBJECT_DEFINE");
+        REQUIRE(define != std::string::npos);
+        const size_t begin = gcode.find("POLYGON=", define);
+        REQUIRE(begin != std::string::npos);
+        const std::string polygon = gcode.substr(begin, gcode.find('\n', begin) - begin);
+        size_t points = 1;
+        for (size_t pos = polygon.find("],["); pos != std::string::npos; pos = polygon.find("],[", pos + 1))
+            ++points;
+        return points;
+    };
+
+    const size_t fine   = polygon_points(slice_with_tolerance("0.1"));
+    const size_t coarse = polygon_points(slice_with_tolerance("0.4"));
+    INFO("points at 0.1 mm: " << fine << ", at 0.4 mm: " << coarse);
+    CHECK(coarse >= 4);
+    CHECK(coarse < fine);
+}
+
+// Existing profiles must keep writing the outlines they wrote when the tolerance was a constant 0.1 mm.
+TEST_CASE("The exclude object tolerance defaults to the former fixed 0.1 mm", "[GCode]")
+{
+    CHECK_THAT(DynamicPrintConfig::full_print_config().opt_float("exclude_object_tolerance"),
+               Catch::Matchers::WithinAbs(0.1, 1e-9));
+}
+
 // Firmwares read the compatibility header lines (Anycubic's GoKlipper heats the bed with
 // first_layer_bed_temperature), so they must describe the filament the plate prints, not filament 1.
 TEST_CASE("The G-code header names the first layer temperatures of the filament the plate prints", "[GCode]")
@@ -142,6 +142,21 @@ SCENARIO("z_hop lifts the nozzle when a lift is requested", "[GCodeWriter]") {
    }
 }

+SCENARIO("Origin manipulation", "[GCodeWriter]") {
+	Slic3r::GCode gcodegen;
+	WHEN("set_origin to (10,0)") {
+    	gcodegen.set_origin(Vec2d(10,0));
+    	REQUIRE(gcodegen.origin() == Vec2d(10, 0));
+    }
+	WHEN("set_origin to (10,0) and translate by (5, 5)") {
+		gcodegen.set_origin(Vec2d(10,0));
+		gcodegen.set_origin(gcodegen.origin() + Vec2d(5, 5));
+		THEN("origin returns reference to point") {
+    		REQUIRE(gcodegen.origin() == Vec2d(15,5));
+    	}
+    }
+}
+
 TEST_CASE("A cached config slot is looked up again whenever its key changes", "[GCodeWriter]")
 {
    GCode::ConfigIndexCache cache;
@@ -5,7 +5,6 @@
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Print.hpp"
-#include "libslic3r/Model.hpp"

 #include <algorithm>
 #include <cstdlib>
@@ -503,3 +502,27 @@ std::vector<std::string> role_sequence(const std::string &gcode, const std::vect
 }

 } } // namespace Slic3r::Test
+
+#include <catch2/catch_all.hpp>
+#include "libslic3r/Arrange.hpp"
+#include "libslic3r/Model.hpp"
+
+SCENARIO("init_print functionality", "[test_helpers]") {
+	GIVEN("A default config") {
+		Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+		WHEN("init_print is called with a single mesh.") {
+			Slic3r::Model model;
+			Slic3r::Print print;
+			Slic3r::Test::init_print({ Slic3r::Test::cube(20) }, print, model, config);
+			THEN("One mesh/printobject is in the resulting Print object.") {
+				REQUIRE(print.objects().size() == 1);
+			}
+			THEN("print.process() doesn't crash.") {
+				REQUIRE_NOTHROW(print.process());
+			}
+			THEN("Export gcode functions outputs text.") {
+				REQUIRE(! Slic3r::Test::gcode(print).empty());
+			}
+		}
+	}
+}
@@ -327,6 +327,24 @@ TEST_CASE("A printer with IMEX disabled resolves the mode placeholders to nothin
    CHECK_FALSE(has_line(gcode, kQuadScript));
 }

+// The placeholders are set unconditionally, ahead of the is_imex check, so they are defined for
+// every printer. A single-extruder preset that mentions {imex_mode} must expand it to an empty
+// string rather than fail the export on an unknown variable.
+TEST_CASE("IMEX mode placeholders are defined on an ordinary single-extruder printer",
+          "[ImexModeGcode][IMEX]")
+{
+    const std::string gcode = slice({ cube(20) }, {
+        { "skirt_loops",         "0" },
+        { "brim_type",           "no_brim" },
+        { "gcode_flavor",        "klipper" },
+        { "machine_start_gcode", kReportStartGcode },
+    });
+
+    CHECK(has_line(gcode, ";IMEX_MODE:"));
+    CHECK(has_line(gcode, ";IMEX_MODE_INDEX:0"));
+    CHECK(has_line(gcode, ";IMEX_MODE_GCODE:"));
+}
+
 // In a parallel mode no tool changes occur, so every active carriage has to be addressed
 // explicitly: once before the print for pressure advance, and again at the second layer for the
 // drop from the initial-layer temperature. Nothing else in the suite covers either emission, and
@@ -66,6 +66,21 @@ void count_mixed(ToolOrdering &to, size_t &groups, size_t &resolutions)

 } // namespace

+TEST_CASE("enable_mixed_color_sublayer reaches the Print config", "[MixedFilament]")
+{
+    Print print;
+    Model model;
+    init_print({cube(20)}, print, model, mixed_config(true));
+
+    // The option lives in PrintConfig; if it did not survive Print::apply the slicer would
+    // silently fall back to the whole-layer path.
+    CHECK(print.config().enable_mixed_color_sublayer.value == true);
+    REQUIRE(print.config().filament_is_mixed.values.size() == 3);
+    CHECK(print.config().filament_is_mixed.values[2] == true);
+    REQUIRE(print.config().filament_mixed_components.values.size() == 3);
+    CHECK(print.config().filament_mixed_components.values[2] == "1,2");
+}
+
 TEST_CASE("Mixed filament splits layers into sub-layers when the option is on", "[MixedFilament]")
 {
    Print print;
@@ -840,6 +840,32 @@ static void all_regions_on_filament(DynamicPrintConfig &config, int filament_1ba
        config.set_deserialize_strict({ { key, std::to_string(filament_1based) } });
 }

+// IMEX parallel modes emit per-carriage temperatures from a branch that is mutually
+// exclusive with the standard per-extruder path, and that branch skipped the head the
+// print's own toolpaths run on. That head therefore never received its 1st->2nd layer
+// transition and held nozzle_temperature_initial_layer for the whole job.
+TEST_CASE("Parallel-mode IMEX prints transition the printing head to its second-layer temperature",
+          "[MultiFilament][IMEX]")
+{
+    DynamicPrintConfig config = multifilament_config(7);
+    imex_7x4_printer(config);
+    all_regions_on_filament(config, 1); // filament 1 => logical slot 0 => physical head 0
+    // The multi-extruder normalization collapses per-filament temperature vectors to a
+    // single value, so heads are told apart by their tool qualifier, not by temperature.
+    config.set_deserialize_strict({
+        { "imex_parallel_mode",                "copy" },
+        { "nozzle_temperature_initial_layer",  "200" },
+        { "nozzle_temperature",                "240" },
+    });
+
+    const std::string gcode = slice({ cube(20) }, config);
+
+    // Head 0 runs the print's own toolpaths and must step 200 -> 240 at the second layer.
+    CHECK(gcode.find("M104 S240 T0") != std::string::npos);
+    // Head 1 is the copy carriage; it already worked and must keep working.
+    CHECK(gcode.find("M104 S240 T1") != std::string::npos);
+}
+
 // IMEX supplements is_extruder_used for the secondary carriages a parallel mode drives.
 // `primary` drives exactly one tool, so the supplement must not run: routing every region
 // to filament 6 puts the initial tool on physical head 2, while the mode's only declared
@@ -54,6 +54,8 @@
 #include <cstdlib>
 #include <sstream>
 #include <limits>
+#include <fstream>
+#include <iterator>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -792,6 +794,25 @@ TEST_CASE("Print statistics in custom G-code match the final print statistics",
    }
 }

+TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
+{
+    Print print;
+    Model model;
+    Slic3r::Test::init_print({cube(20)}, print, model);
+    print.process();
+
+    SECTION("non-BBL printer") {}
+    SECTION("BBL printer") { print.is_BBL_printer() = true; }
+
+    ScopedTemporaryFile temp(".gcode");
+    REQUIRE_NOTHROW(print.export_gcode(temp.string(), nullptr, nullptr));
+
+    std::ifstream in(temp.string());
+    const std::string gcode((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+
+    REQUIRE_FALSE(gcode.empty());
+}
+
 TEST_CASE("Exporting a sliced print again gives the same G-code", "[Print][export_gcode][Regression]")
 {
    const int instances = GENERATE(1, 3);
@@ -1041,6 +1062,34 @@ TEST_CASE("Belt printers keep the part fan off within the band above the belt",
    CHECK(clear_fan_off == 0);
 }

+// Organic supports under an overhang on a belt printer reach below the object's first layer,
+// where the virtual belt raft layers sit at negative Z. The lowest of them used to get a
+// negative height and abort slicing with a negative flow error.
+TEST_CASE("Belt printers slice organic tree supports that reach the belt", "[Print][belt][Support]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "belt_printer",               1 },
+        { "belt_slice_rotation",        "x" },
+        { "belt_slice_rotation_angle",  45 },
+        { "gcode_remap_x",              "rev_x" },
+        { "gcode_remap_y",              "pos_z" },
+        { "gcode_remap_z",              "pos_y" },
+        { "layer_height",               0.2 },
+        { "initial_layer_print_height", 0.2 },
+        { "skirt_loops",                0 },
+        { "z_hop",                      0 },
+        { "enable_support",             1 },
+        { "support_type",               "tree(auto)" },
+        { "support_style",              "organic" },
+        { "machine_start_gcode",        "T[initial_tool]\n" },
+        { "layer_change_gcode",         "G92 E0\n" },
+    });
+    std::string gcode;
+    REQUIRE_NOTHROW(gcode = slice({ TestMesh::overhang }, config));
+    CHECK(! gcode.empty());
+}
+
 TEST_CASE("Slicing errors are reported per object with the object's name", "[Print]")
 {
    Print print;
@@ -837,6 +837,30 @@ TEST_CASE("Belt brim on an object layer precedes its perimeters, once", "[SkirtB
    CHECK(role_passes(gc, "brim") <= bands);
 }

+// B - single extruder (filament id 1).  Every band must survive the 1-based -> 0-based
+// filament-id conversion the apron path performs: a wrong conversion drops all single-extruder
+// bands, so the pass count would collapse.  The expected count is derived from the sliced
+// layers, not a ratio.
+TEST_CASE("Belt brim on a single extruder emits every band once", "[SkirtBrim][belt]")
+{
+    DynamicPrintConfig config = belt_brim_config();
+    config.set_deserialize_strict({
+        { "brim_type",       "outer_only" },
+        { "brim_width",      4 },
+        { "brim_object_gap", 0 },
+    });
+    Print print;
+    Model model;
+    init_print({ cube(20) }, print, model, config);
+    const std::string gc = gcode(print);
+
+    const PrintObject &object = *print.objects().front();
+    const int expected = nonempty_belt_brim_layers(object) + belt_brim_apron_bands(object);
+    REQUIRE(expected > 0);
+    CHECK(role_layers(gc, "brim") == expected);
+    CHECK(belt_tools_for_role(gc, "brim") == std::set<int>{ 0 });   // filament 1 -> tool 0
+}
+
 // Number of brim segments the belt brim generator produced for `object`: the lattice
 // lines of every per-layer band plus the apron prologue.  Each segment is written as one
 // extruding move, so this is what a G-code count has to match.  A pass count cannot see a
@@ -27,6 +27,14 @@ TEST_CASE("slicing_pipeline_plugin option exists and defaults empty", "[slicing_

 #include "libslic3r/Print.hpp"

+TEST_CASE("slicing pipeline hook setter is a no-op-safe injection", "[slicing_pipeline]") {
+    int calls = 0;
+    Slic3r::Print::set_slicing_pipeline_hook_fn(
+        [&](Slic3r::Print&, const Slic3r::PrintObject*, Slic3r::SlicingPipelineStepPlugin){ ++calls; });
+    Slic3r::Print::set_slicing_pipeline_hook_fn(nullptr); // reset — must be legal
+    CHECK(calls == 0);
+}
+
 #include <vector>
 #include <algorithm>
 using namespace Slic3r::Test;
@@ -10,6 +10,8 @@
 #include <cstdlib>
 #include <cstddef>
 #include <cmath>
+#include <future>
+#include <chrono>
 #include <vector>
 #include <math.h>
 #include "libslic3r/ExPolygon.hpp"
@@ -57,6 +59,12 @@ SCENARIO("Basic mesh statistics", "[TriangleMesh]") {
            REQUIRE(cube.facets_count() == facets.size());
        }

+#if 0
+        THEN( "Number of normals is equal to the number of facets.") {
+            REQUIRE(cube.normals().size() == facets.size());
+        }
+#endif
+
        THEN( "center() returns the center of the object.") {
            REQUIRE(cube.center() == Vec3d(10.0,10.0,10.0));
        }
@@ -257,6 +265,20 @@ SCENARIO("Split functionality", "[TriangleMesh]") {
    }
 }

+SCENARIO("Mesh merge functions", "[TriangleMesh]") {
+    GIVEN( "Two 20mm cubes, each with one corner on the origin") {
+		auto cube = make_cube();
+		TriangleMesh cube2(cube);
+
+        WHEN( "The two meshes are merged") {
+            cube.merge(cube2);
+            THEN( "There are twice as many facets in the merged mesh as the original.") {
+                REQUIRE(cube.facets_count() == 2 * cube2.facets_count());
+            }
+        }
+    }
+}
+
 SCENARIO("Cut behavior", "[TriangleMesh]") {
    GIVEN( "A 20mm cube with one corner on the origin") {
 		auto cube = make_cube();
@@ -284,3 +306,53 @@ SCENARIO("Cut behavior", "[TriangleMesh]") {
        }
    }
 }
+#ifdef TEST_PERFORMANCE
+TEST_CASE("Large mesh slices within the time budget (#4486)", "[TriangleMesh][Regression]") {
+    TriangleMesh mesh;
+    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/100_000.stl");
+
+    config.set("layer_height", 500);
+    config.set("first_layer_height", 250);
+    config.set("nozzle_diameter", 500);
+
+    Slic3r::Print print;
+    Slic3r::Model model;
+    Slic3r::Test::init_print({mesh}, print, model, config);
+
+    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
+
+    std::future<void> fut = std::async([&print] () { print.process(); });
+    std::chrono::milliseconds span {120000};
+    bool timedout {false};
+    if(fut.wait_for(span) == std::future_status::timeout) {
+        timedout = true;
+    }
+    REQUIRE(timedout == false);
+
+}
+#endif // TEST_PERFORMANCE
+
+#ifdef BUILD_PROFILE
+TEST_CASE("Large mesh slicing profile (#4486)", "[TriangleMesh][Profile]") {
+    TriangleMesh mesh;
+    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/10_000.stl");
+
+    config.set("layer_height", 500);
+    config.set("first_layer_height", 250);
+    config.set("nozzle_diameter", 500);
+    config.set("fill_density", "5%");
+
+    Slic3r::Print print;
+    Slic3r::Model model;
+    Slic3r::Test::init_print({mesh}, print, model, config);
+
+    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
+
+    print.process();
+
+    REQUIRE(true);
+
+}
+#endif //BUILD_PROFILE
@@ -348,6 +348,21 @@ TEST_CASE("Inactive inward wipe settings preserve the exported trajectory", "[Wi
    CHECK_FALSE(trajectories_differ(regular_paths, inward_paths));
 }

+TEST_CASE("Inward wipe changes the exported trajectory when outer wall width is Auto", "[Wipe][Regression]")
+{
+    const char *wall_generator = GENERATE("classic", "arachne");
+    INFO("wall generator: " << wall_generator);
+
+    const std::vector<Vec2d> regular = wipe_destinations(
+        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, false)));
+    const std::vector<Vec2d> inward = wipe_destinations(
+        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, true)));
+
+    REQUIRE_FALSE(regular.empty());
+    REQUIRE_FALSE(inward.empty());
+    REQUIRE(trajectories_differ(regular, inward));
+}
+
 TEST_CASE("Inward wipe recognizes an external wall starting on an overhang", "[Wipe][Regression]")
 {
    const char *wall_generator = GENERATE("classic", "arachne");
@@ -505,6 +505,28 @@ TEST_CASE("A project whose components reference themselves fails to load", "[3mf
    REQUIRE_FALSE(loaded);
 }

+TEST_CASE("A project in the 2.4.x layout keeps auto drop off from its build item", "[3mf][Regression]")
+{
+    // 2.4.x wrote auto_drop on the build item and left it off the object, so the object is re-laid out here.
+    ScopedTemporaryFile temp(".3mf");
+    {
+        Model        model;
+        ModelObject* object = model.add_object();
+        object->add_volume(make_cube(10., 10., 10.));
+        object->add_instance();
+        object->auto_drop = false;
+        store_project(model, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
+    }
+    REQUIRE(replace_in_3mf_entry(temp.string(), "model_settings.config", " auto_drop=\"0\"", ""));
+    REQUIRE(replace_in_3mf_entry(temp.string(), "3dmodel.model", "printable=\"1\"/>", "printable=\"1\" auto_drop=\"0\"/>"));
+
+    ScopedTemporaryDir backup_dir("orca_auto_drop_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    CHECK_FALSE(model.objects.front()->auto_drop);
+}
+
 TEST_CASE("An object loads up to the component reference budget and fails past it", "[3mf][Regression]")
 {
    // The importer queues at most 100000 component references per object. Every reference besides the
@@ -1647,6 +1669,69 @@ SCENARIO("Legacy 3MF without published metadata loads unchanged", "[3mf]") {
    }
 }

+// 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;
@@ -159,6 +159,15 @@ TEST_CASE("overlap_area detects overlap and ignores touching edges", "[Arrange]"
    }
 }

+TEST_CASE("Arrange places every item on the physical bed", "[Arrange]")
+{
+    ArrangePolygons items = squares(5, 20.);
+    arrange(items, bed(200, 200), quiet_params(scaled(1.)));
+
+    for (const ArrangePolygon &ap : items)
+        REQUIRE(ap.bed_idx == 0);
+}
+
 TEST_CASE("Arranged items stay within the bed", "[Arrange]")
 {
    ArrangePolygons items = squares(6, 30.);
@@ -2061,6 +2061,49 @@ TEST_CASE("mass properties: invalid body index", "[CadDocument]")
    REQUIRE_FALSE(mp3.valid);
 }

+TEST_CASE("serialize_recipe roundtrip with two bodies", "[CadDocument]")
+{
+    using Catch::Matchers::WithinRel;
+    CadDocument doc;
+
+    // Body 1: rectangle sketch + extrude + fillet
+    int sk1 = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(),
+                             20, 20, 10, "Rect1");
+    REQUIRE(sk1 >= 0);
+    doc.add_extrude(sk1, 10.0, false, BooleanMode::New, "Extrude1");
+    doc.add_fillet(2.0, FaceGroup::All, "Fillet1");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    // Body 2: circle sketch + extrude (separate New body)
+    SketchEntity circ;
+    circ.type   = SketchEntity::Type::Circle;
+    circ.center = Vec2d(0, 0);
+    circ.radius = 8.0;
+    int sk2 = doc.add_sketch_entities({circ}, SketchPlane::XZ(), "Circle2");
+    doc.add_extrude(sk2, 6.0, false, BooleanMode::New, "Extrude2");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    REQUIRE(doc.bodies.size() >= 2);
+    std::vector<double> orig_vols;
+    for (const auto& b : doc.bodies)
+        orig_vols.push_back(double(SketchEngine::tessellate(b.shape).volume()));
+
+    auto blob = doc.serialize_recipe();
+    REQUIRE_FALSE(blob.empty());
+
+    CadDocument doc2;
+    REQUIRE(doc2.deserialize_recipe(blob));
+    REQUIRE(doc2.error.empty());
+    REQUIRE(doc2.bodies.size() == doc.bodies.size());
+
+    for (size_t i = 0; i < doc.bodies.size(); ++i) {
+        double v2 = double(SketchEngine::tessellate(doc2.bodies[i].shape).volume());
+        REQUIRE_THAT(v2, WithinRel(orig_vols[i], 1e-6));
+    }
+}
+
 TEST_CASE("deserialize_recipe rejects future version with error", "[CadDocument]")
 {
    CadDocument doc;
@@ -2104,6 +2147,41 @@ TEST_CASE("deserialize_recipe handles empty blob without throwing", "[CadDocumen
    REQUIRE_FALSE(doc.error.empty());
 }

+TEST_CASE("deserialize_recipe error is non-empty on every failure path", "[CadDocument]")
+{
+    CadDocument doc;
+    auto reset = [&]() { doc = CadDocument{}; };
+
+    // too new
+    {
+        std::ostringstream oss;
+        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 999; ar(v); }
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // too old
+    {
+        std::ostringstream oss;
+        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 1; ar(v); }
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // truncated / garbage
+    {
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe("not a valid blob \x00\x01\x02"));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // empty
+    {
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(""));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+}
+
 TEST_CASE("a v4 project still opens", "[CadDocument][recipe]")
 {
    // The regression guard for everyone who already has projects: a pre-framing v4
@@ -4131,6 +4209,25 @@ static CadDocument make_golden_doc_v1()
    return doc;
 }

+TEST_CASE("regenerate golden recipe fixture", "[.regen]")
+{
+    CadDocument doc = make_golden_doc_v1();
+    // ponytail: serialize_recipe() only needs features, recompute is unnecessary
+    // for a fixture that exercises the serialization format.
+    auto blob = doc.serialize_recipe();
+    REQUIRE_FALSE(blob.empty());
+
+    // Version-free on purpose: this writes whatever today's format is, so a version bump does
+    // not have to remember to edit it. The version-stamped fixtures beside it are frozen
+    // evidence from older builds and are never regenerated.
+    std::string path = std::string(TEST_DATA_DIR) + "/cad_recipe_current.bin";
+    std::ofstream ofs(path, std::ios::binary);
+    REQUIRE(ofs.is_open());
+    ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
+    ofs.close();
+    SUCCEED("Fixture written to " << path);
+}
+
 // The previous format's real blob, kept on disk deliberately. It is the only thing that can
 // prove the version gate does its job: a v3 recipe carries FEWER fields per feature than this
 // build reads, so without the bump to v4 it would have passed the gate and had two ints read
@@ -5595,6 +5692,45 @@ TEST_CASE("surface-loft round-trip serialize/deserialize", "[CadDocument][surfac

 // --- Mate tests (M8a) ---

+TEST_CASE("fastened mate with zero offset/angle", "[CadDocument][mate]")
+{
+    using Catch::Matchers::WithinAbs;
+
+    CadDocument doc;
+    int sk_box = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
+    doc.add_extrude(sk_box, 5.0, false, BooleanMode::New, "BoxExt");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int cs_fixed = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(5, 5, 5), "CS_Fixed");
+    doc.features[cs_fixed].coordsys_body = 0;
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int sk_cyl = doc.add_sketch(SketchShape::Circle, SketchPlane::XY(), 0, 0, 3, "Cyl");
+    doc.add_extrude(sk_cyl, 10.0, false, BooleanMode::New, "CylExt");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+    REQUIRE(doc.bodies.size() == 2);
+
+    int cs_moving = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(0, 0, 5), "CS_Moving");
+    doc.features[cs_moving].coordsys_body = 1;
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int mi = doc.add_mate(0, cs_fixed, cs_moving, 0.0, 0.0, false, "Mate");
+    REQUIRE(mi >= 0);
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    GProp_GProps props;
+    BRepGProp::VolumeProperties(doc.bodies[1].shape, props);
+    gp_Pnt com = props.CentreOfMass();
+    REQUIRE_THAT(double(com.X()), WithinAbs(5.0, 1e-4));
+    REQUIRE_THAT(double(com.Y()), WithinAbs(5.0, 1e-4));
+    REQUIRE_THAT(double(com.Z()), WithinAbs(5.0, 1e-4));
+}
+
 TEST_CASE("fastened mate with offset", "[CadDocument][mate]")
 {
    using Catch::Matchers::WithinAbs;
@@ -5791,6 +5927,30 @@ TEST_CASE("mate round-trip serialization", "[CadDocument][mate]")
    REQUIRE(mf->mate_flip   == true);
 }

+TEST_CASE("version 2 blob is rejected", "[CadDocument][mate]")
+{
+
+    CadDocument doc;
+    int sk = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
+    doc.add_extrude(sk, 5.0, false, BooleanMode::New, "E");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    std::ostringstream oss;
+    {
+        cereal::BinaryOutputArchive ar(oss);
+        uint32_t fake_v = 2;
+        ar(fake_v);
+        ar(doc.features);
+        ar(doc.variables);
+    }
+    std::string blob = oss.str();
+
+    CadDocument fresh;
+    REQUIRE_FALSE(fresh.deserialize_recipe(blob));
+    REQUIRE_CONTAINS(fresh.error, "older version");
+}
+
 TEST_CASE("mate error: out of range connectors", "[CadDocument][mate]")
 {

@@ -7533,6 +7693,17 @@ TEST_CASE("two holes are both subtracted", "[CadDocument][sketchwire]")
    REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
 }

+TEST_CASE("a lone circle still extrudes exactly as before", "[CadDocument][sketchwire]")
+{
+    std::vector<SketchEntity> ents = { circle_entity({0, 0}, 8.0) };
+    CadDocument doc = plate_doc(ents, 5.0);
+
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+    const double expected = M_PI * 64.0 * 5.0;
+    REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
+}
+
 TEST_CASE("a closed polygon still extrudes exactly as before", "[CadDocument][sketchwire]")
 {
    std::vector<SketchEntity> ents = rect_entities(20, 20);
@@ -155,6 +155,51 @@ SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
            REQUIRE(result.front().length() == Catch::Approx(subject.length()));
        }
    }
+
+#if 0
+    {
+        # Clipper does not preserve polyline orientation
+        my $polyline = Slic3r::Polyline->new([50, 150], [300, 150]);
+        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
+        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
+        is_deeply $result->[0]->pp, [[100, 150], [200, 150]], 'clipped line orientation is preserved';
+    }
+    {
+        # Clipper does not preserve polyline orientation
+        my $polyline = Slic3r::Polyline->new([300, 150], [50, 150]);
+        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
+        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
+        is_deeply $result->[0]->pp, [[200, 150], [100, 150]], 'clipped line orientation is preserved';
+    }
+    {
+        # Disabled until Clipper bug #127 is fixed
+        my $subject = [
+            Slic3r::Polyline->new([-90000000, -100000000], [-90000000, 100000000]), # vertical
+                Slic3r::Polyline->new([-100000000, -10000000], [100000000, -10000000]), # horizontal
+                Slic3r::Polyline->new([-100000000, 0], [100000000, 0]), # horizontal
+                Slic3r::Polyline->new([-100000000, 10000000], [100000000, 10000000]), # horizontal
+        ];
+        my $clip = Slic3r::Polygon->new(# a circular, convex, polygon
+            [99452190, 10452846], [97814760, 20791169], [95105652, 30901699], [91354546, 40673664], [86602540, 50000000],
+            [80901699, 58778525], [74314483, 66913061], [66913061, 74314483], [58778525, 80901699], [50000000, 86602540],
+            [40673664, 91354546], [30901699, 95105652], [20791169, 97814760], [10452846, 99452190], [0, 100000000],
+            [-10452846, 99452190], [-20791169, 97814760], [-30901699, 95105652], [-40673664, 91354546],
+            [-50000000, 86602540], [-58778525, 80901699], [-66913061, 74314483], [-74314483, 66913061],
+            [-80901699, 58778525], [-86602540, 50000000], [-91354546, 40673664], [-95105652, 30901699],
+            [-97814760, 20791169], [-99452190, 10452846], [-100000000, 0], [-99452190, -10452846],
+            [-97814760, -20791169], [-95105652, -30901699], [-91354546, -40673664], [-86602540, -50000000],
+            [-80901699, -58778525], [-74314483, -66913061], [-66913061, -74314483], [-58778525, -80901699],
+            [-50000000, -86602540], [-40673664, -91354546], [-30901699, -95105652], [-20791169, -97814760],
+            [-10452846, -99452190], [0, -100000000], [10452846, -99452190], [20791169, -97814760],
+            [30901699, -95105652], [40673664, -91354546], [50000000, -86602540], [58778525, -80901699],
+            [66913061, -74314483], [74314483, -66913061], [80901699, -58778525], [86602540, -50000000],
+            [91354546, -40673664], [95105652, -30901699], [97814760, -20791169], [99452190, -10452846], [100000000, 0]
+            );
+        my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
+        is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
+        is sum(map scalar(@$_), @$result), scalar(@$subject) * 2, 'intersection_pl - expected number of points in polylines';
+    }
+#endif
 }

 SCENARIO("Various Clipper operations - t/clipper.t", "[ClipperUtils]") {
@@ -643,6 +643,45 @@ SCENARIO("update_non_diff_values_to_base_config keeps a project's changed values
    }
 }

+// SCENARIO("DynamicPrintConfig JSON serialization", "[Config]") {
+//     WHEN("DynamicPrintConfig is serialized and deserialized") {
+// 	auto now = std::chrono::high_resolution_clock::now();
+// 	auto timestamp = now.time_since_epoch().count();
+// 	std::stringstream ss;
+// 	ss << "catch_test_serialization_" << timestamp << ".json";
+// 	std::string filename = (fs::temp_directory_path() / ss.str()).string();
+
+// TODO: Finish making a unit test for JSON serialization
+//         FullPrintConfig full_print_config;
+//         DynamicPrintConfig cfg;
+//         cfg.apply(full_print_config, false);
+
+//         std::string serialized;
+//         try {
+//             std::ostringstream ss;
+//             cereal::BinaryOutputArchive oarchive(ss);
+//             oarchive(cfg);
+//             serialized = ss.str();
+//         } catch (const std::runtime_error & /* e */) {
+//             // e.what();
+//         }
+// 	CAPTURE(serialized.length());
+
+//         THEN("Config object contains ini file options.") {
+//             DynamicPrintConfig cfg2;
+//             try {
+//                 std::stringstream ss(serialized);
+//                 cereal::BinaryInputArchive iarchive(ss);
+//                 iarchive(cfg2);
+//             } catch (const std::runtime_error & /* e */) {
+//                 // e.what();
+//             }
+// 	    CAPTURE(cfg.diff_report(cfg2));
+//             REQUIRE(cfg == cfg2);
+//         }
+//     }
+// }
+
 TEST_CASE("save_to_json round-trips plugin capability references as strings", "[Config][plugins]") {
    ScopedTemporaryFile tmp(".json");
    const std::vector<std::string> refs = {
@@ -17,6 +17,10 @@ using namespace Slic3r;

 // #define TESTS_EXPORT_SVGS

+namespace Slic3r {
+	Points mittered_offset_path_scaled(const Points& contour, const std::vector<float>& deltas, double miter_limit);
+}
+
 static ExPolygon spirograph_gear_1mm()
 {
 	ExPolygon out;
@@ -475,6 +479,33 @@ SCENARIO("Elephant foot compensation", "[ElephantFoot]") {
        }
 	}

+#if 0
+	GIVEN("Varying inner offset") {
+		ExPolygon input = spirograph_gear_1mm().simplify(SCALED_EPSILON).front();
+		ExPolygon output;
+		std::vector<float> deltas(input.contour.points.size(), scale_(1.));
+                // mittered_offset_path_scaled_points is commented out somewhere above
+		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
+#ifdef TESTS_EXPORT_SVGS
+		{
+			SVG svg(debug_out_path("elephant_foot_compensation_0.svg").c_str(), get_extents(output));
+			svg.draw(input, "blue");
+			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
+		}
+#endif /* TESTS_EXPORT_SVGS */
+		for (size_t i = 0; i <= deltas.size() / 2; ++ i)
+			deltas[i] = deltas[deltas.size() - i - 1] = scale_(1.) * double(i) / (0.5 * double(deltas.size()));
+		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
+#ifdef TESTS_EXPORT_SVGS
+		{
+			SVG svg(debug_out_path("elephant_foot_compensation_varying.svg").c_str(), get_extents(output));
+			svg.draw(input, "blue");
+			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
+		}
+#endif /* TESTS_EXPORT_SVGS */
+	}
+#endif
+
    GIVEN("Rectangle with a narrow part sticking out") {				
 		// Rectangle
 		ExPolygon expoly;
@@ -208,3 +208,20 @@ TEST_CASE("Octagram spiral smooth factor controls corner curvature", "[FillPlane
    REQUIRE(path_length(half_smooth) < path_length(sharp));
    REQUIRE(invalid_factor == sharp);
 }
+
+TEST_CASE("Hilbert curve smooth factor controls corner curvature", "[FillPlanePath]")
+{
+    const Points sharp       = TestableHilbertCurve().generate_points(0.005);
+    const Points half_smooth = TestableHilbertCurve().generate_points(0.005, 0.5);
+    const Points full_smooth = TestableHilbertCurve().generate_points(0.005, 1.);
+    const Points invalid_factor = TestableHilbertCurve().generate_points(
+        0.005, std::numeric_limits<double>::quiet_NaN());
+
+    REQUIRE(full_smooth.front() == half_smooth.front());
+    REQUIRE(full_smooth.back() == half_smooth.back());
+    REQUIRE(path_length(full_smooth) < path_length(half_smooth));
+    REQUIRE(invalid_factor == sharp);
+
+    for (size_t i = 1; i < full_smooth.size(); ++i)
+        REQUIRE((full_smooth[i] - full_smooth[i - 1]).squaredNorm() > 0);
+}
@@ -18,6 +18,8 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ShortestPath.hpp"

+//#include <random>
+//#include "libnest2d/tools/benchmark.h"
 #include "libslic3r/SVG.hpp"

 #include "../libnest2d/printer_parts.hpp"
@@ -603,6 +605,73 @@ TEST_CASE("Convex polygon intersection on two overlapping squares", "[Geometry][
    REQUIRE(is_inters == true);
 }

+//// Only for benchmarking
+//static Polygon gen_convex_poly(std::mt19937_64 &rg, size_t point_cnt)
+//{
+//    std::uniform_int_distribution<coord_t> dist(0, 100);
+
+//    Polygon out;
+//    out.points.reserve(point_cnt);
+
+//    coord_t tr = dist(rg) * 2 / SCALING_FACTOR;
+
+//    for (size_t i = 0; i < point_cnt; ++i)
+//        out.points.emplace_back(tr + dist(rg) / SCALING_FACTOR,
+//                                tr + dist(rg) / SCALING_FACTOR);
+
+//    return Geometry::convex_hull(out.points);
+//}
+//TEST_CASE("Convex polygon intersection test on random polygons", "[Geometry]") {
+//    constexpr size_t TEST_CNT = 1000;
+//    constexpr size_t POINT_CNT = 1000;
+
+//    auto seed = std::random_device{}();
+////    unsigned long seed = 2525634386;
+//    std::mt19937_64 rg{seed};
+//    Benchmark bench;
+
+//    auto tests = reserve_vector<std::pair<Polygon, Polygon>>(TEST_CNT);
+//    auto results = reserve_vector<bool>(TEST_CNT);
+//    auto expects = reserve_vector<bool>(TEST_CNT);
+
+//    for (size_t i = 0; i < TEST_CNT; ++i) {
+//        tests.emplace_back(gen_convex_poly(rg, POINT_CNT), gen_convex_poly(rg, POINT_CNT));
+//    }
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        results.emplace_back(Geometry::convex_polygons_intersect(test.first, test.second));
+//    bench.stop();
+
+//    std::cout << "Test time: " << bench.getElapsedSec() << std::endl;
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        expects.emplace_back(!intersection(test.first, test.second).empty());
+//    bench.stop();
+
+//    std::cout << "Clipper time: " << bench.getElapsedSec() << std::endl;
+
+//    REQUIRE(results.size() == expects.size());
+
+//    auto seedstr = std::to_string(seed);
+//    for (size_t i = 0; i < results.size(); ++i) {
+//        // std::cout << expects[i] << " ";
+
+//        if (results[i] != expects[i]) {
+//            SVG svg{std::string("fail_seed") + seedstr + "_" + std::to_string(i) + ".svg"};
+//            svg.draw(tests[i].first, "blue");
+//            svg.draw(tests[i].second, "green");
+//            svg.Close();
+
+//            // std::cout << std::endl;
+//        }
+//        REQUIRE(results[i] == expects[i]);
+//    }
+//    std::cout << std::endl;
+
+//}
+
 struct Pair
 {
    size_t first, second;
@@ -71,6 +71,15 @@ TEST_CASE("effective_physical_extruder_map - degenerate nozzle count still yield
    REQUIRE(effective_physical_extruder_map(nullptr, 0).values == std::vector<int>{0});
 }

+TEST_CASE("effective_physical_extruder_map - IDEX ghost-color regression guard", "[IMEX]") {
+    // Dual extruder, no authored map. Before the GUI fix this produced a black ghost on T1
+    // because first_filament_for_physical_head({0}, 1) == -1.
+    auto default_pem = make_pem({0});
+    auto pem         = effective_physical_extruder_map(&default_pem, 2);
+    REQUIRE(first_filament_for_physical_head(pem, 0) == 0);
+    REQUIRE(first_filament_for_physical_head(pem, 1) == 1); // no longer -1
+}
+
 TEST_CASE("imex_pem_tool_for - non-parallel mode returns -1", "[IMEX]") {
    // Empty mode string (not in IMEX) and "primary" (IMEX present but not parallel) both
    // short-circuit to bare-firmware PA/temp emission.
@@ -1049,6 +1058,12 @@ TEST_CASE("compute_imex_slice_offset - flag on + copy mode returns primary zone
    REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
 }

+TEST_CASE("compute_imex_slice_offset - flag on + mirror mode returns primary zone center", "[IMEX]") {
+    auto z = compute_imex_slice_offset(true, "mirror", kPrimaryZoneCenteredAt60_40);
+    REQUIRE_THAT(z.x(), WithinAbs(60.0, 1e-9));
+    REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
+}
+
 TEST_CASE("compute_imex_slice_offset - user-defined non-primary mode names trigger shift", "[IMEX]") {
    // Mode names are user-defined; anything not "primary" or "" should activate.
    auto z = compute_imex_slice_offset(true, "iq-copy", kPrimaryZoneCenteredAt60_40);
@@ -6,6 +6,7 @@
 #include "libslic3r/Point.hpp"
 #include "libslic3r/libslic3r.h"
 #include <limits>
+#include <random>
 #include <catch2/catch_all.hpp>
 #include <vector>
 #include <string>
@@ -116,6 +117,68 @@ TEST_CASE("Split two watertight meshes", "[its_split][its]") {
 }

 #include <libslic3r/QuadricEdgeCollapse.hpp>
+static float triangle_area(const Vec3f &v0, const Vec3f &v1, const Vec3f &v2)
+{
+    Vec3f ab = v1 - v0;
+    Vec3f ac = v2 - v0;
+    return ab.cross(ac).norm() / 2.f;
+}
+
+static float triangle_area(const stl_triangle_vertex_indices &triangle_indices, const std::vector<Vec3f> &vertices)
+{
+    return triangle_area(vertices[triangle_indices[0]],
+                         vertices[triangle_indices[1]],
+                         vertices[triangle_indices[2]]);
+}
+
+#if 0
+// clang complains about unused functions
+static std::mt19937 create_random_generator() {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    return gen;
+}
+#endif
+
+std::vector<Vec3f> its_sample_surface(const indexed_triangle_set &its,
+                                      double        sample_per_mm2,
+                                      std::mt19937 random_generator) // = create_random_generator())
+{
+    std::vector<Vec3f> samples;
+    std::uniform_real_distribution<float> rand01(0.f, 1.f);
+    for (const auto &triangle_indices : its.indices) {
+        float area = triangle_area(triangle_indices, its.vertices);
+        float countf;
+        float fractional = std::modf(area * sample_per_mm2, &countf);
+        int count = static_cast<int>(countf);
+
+        float generate = rand01(random_generator);
+        if (generate < fractional) ++count;
+        if (count == 0) continue;
+
+        const Vec3f &v0 = its.vertices[triangle_indices[0]];
+        const Vec3f &v1 = its.vertices[triangle_indices[1]];
+        const Vec3f &v2 = its.vertices[triangle_indices[2]];
+        for (int c = 0; c < count; c++) {
+            // barycentric coordinate
+            Vec3f b;
+            b[0] = rand01(random_generator);
+            b[1] = rand01(random_generator);
+            if ((b[0] + b[1]) > 1.f) {
+                b[0] = 1.f - b[0];
+                b[1] = 1.f - b[1];
+            }
+            b[2] = 1.f - b[0] - b[1];
+            Vec3f pos;
+            for (int i = 0; i < 3; i++) {
+                pos[i] = b[0] * v0[i] + b[1] * v1[i] + b[2] * v2[i];
+            }
+            samples.push_back(pos);
+        }        
+    }
+    return samples;
+}
+

 #include "libslic3r/AABBTreeIndirect.hpp"

@@ -261,6 +261,16 @@ TEST_CASE("snake_core produces valid paths on ring", "[Snake]") {
    REQUIRE(is_permutation(p2, centers.size()));
 }

+// --- Core Strategy Tests: Random Layout ---
+
+TEST_CASE("snake_core produces valid paths on random input", "[Snake]") {
+    Points centers = make_random_16();
+
+    auto p2 = snake_core(centers);
+
+    REQUIRE(is_permutation(p2, centers.size()));
+}
+
 // --- Quality Comparison Tests ---

 TEST_CASE("snake has no crossings on random input", "[Snake]") {
@@ -730,6 +730,25 @@ TEST_CASE("Neighboring vertices distinguish repeated anchors on different lobes"
    CHECK(edges == std::vector<size_t>{0, 2, 3, 4, 6, 7});
 }

+TEST_CASE("Modifier holes subtract coverage while separate components add intervals", "[PreciseSeam][SegmentExtraction]")
+{
+    const Polygon perimeter = rectangle(0, 0, 20, 20);
+    ExPolygon area(rectangle(1, -3, 10, 3));
+    area.holes.push_back(rectangle(4, -1, 7, 1));
+    area.holes.back().reverse();
+    const auto result = PreciseSeam::extract_perimeter_segments(PreciseSeam::PreparedPerimeter(perimeter),
+        PreciseSeam::prepare_modifier_regions({area, ExPolygon(rectangle(14, -3, 18, 3))}), ModelVolumeType::PRECISE_SEAM_CENTER);
+    check_provenance(perimeter, result);
+    REQUIRE(result.segments.size() == 3);
+    const std::vector<Point> starts{mm(1, 0), mm(7, 0), mm(14, 0)};
+    const std::vector<Point> ends{mm(4, 0), mm(10, 0), mm(18, 0)};
+    for (size_t i = 0; i < 3; ++i) {
+        CHECK(result.segments[i].polyline.points.front() == starts[i]);
+        CHECK(result.segments[i].polyline.points.back() == ends[i]);
+    }
+    CHECK_FALSE(result.full_containment);
+}
+
 TEST_CASE("Full coverage is distinct from an empty or point-only intersection", "[PreciseSeam][SegmentExtraction]")
 {
    const bool reverse = GENERATE(false, true);
@@ -239,6 +239,30 @@ TEST_CASE("DistanceX on two Points binds real roles with non-negative prefill",
    REQUIRE(p.defs[0].eb == 0);
 }

+TEST_CASE("Horizontal on a Point rejects with NeedALine", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_point(1, 2) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, -1, -1, SketchConstraintType::Horizontal);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedALine);
+}
+
+TEST_CASE("Angle on two Circles rejects with NeedTwoLines", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 1) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Angle);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
+}
+
+TEST_CASE("Parallel on a Line + Circle rejects with NeedTwoLines (new guard)", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_line(0, 0, 1, 0), mk_circle(5, 0, 1) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Parallel);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
+}
+
 TEST_CASE("Equal on two Circles promotes to EqualRadius", "[SketchConstraints]")
 {
    std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 2) };
@@ -44,6 +44,17 @@ SCENARIO("Reading an STL file", "[stl]") {
 				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
 			}
 		}
+#if 0
+		// ASCII STLs ending with just carriage returns are not supported. These were used by the old Macs, while the Unix based MacOS uses LFs as any other Unix.
+		WHEN("line endings CR") {
+			Slic3r::Model model;
+			THEN("load should succeed") {
+				REQUIRE(Slic3r::load_stl(stl_path("ASCII/20mmbox-CR.stl").c_str(), &model));
+				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
+			}
+		}
+
+#endif
 		WHEN("nonstandard STL file (text after ending tags, invalid normals, for example infinities)") {
 			Slic3r::Model model;
 			THEN("load should succeed") {
@@ -3285,6 +3285,33 @@ TEST_CASE("a ModelUV layer falls back to Triplanar when the volume carries no UV
        CHECK_THAT((no_channel.vertices[i] - as_triplanar.vertices[i]).norm(), WithinAbs(0.f, 1e-5f));
 }

+TEST_CASE("a bake with colour off on every layer reports no colour at all", "[TextureDisplacement]")
+{
+    const indexed_triangle_set cube = its_make_cube(10., 10., 10.);
+
+    TextureDisplacementLayer layer;
+    layer.slot          = 0;
+    layer.depth_mm      = 1.0f;
+    layer.tiling_scale  = 5.0f;
+    layer.image_data    = make_flat_rgb_png(200, 40, 10); // has colour to give...
+    layer.color_enabled = false;                          // ...but is not asked for it
+
+    TextureDisplacementFacetsData facets{};
+    facets[0] = paint_whole_mesh(cube);
+
+    std::vector<uint8_t> triangle_color;
+    TextureColorRequest  request;
+    request.quantize     = [](const Vec3f &) { return 0; }; // would colour everything, if asked
+    request.out_triangle = &triangle_color;
+
+    const indexed_triangle_set out = build_texture_displacement(cube, {layer}, facets, classic_options(), {}, &request);
+    REQUIRE_FALSE(out.vertices.empty());
+    // Every entry 0 ("this triangle takes no colour from the texture"), so the commit leaves whatever
+    // the model was already painted with exactly as it was.
+    for (const uint8_t entry : triangle_color)
+        CHECK(entry == 0);
+}
+
 TEST_CASE("transfer_uv_channel resamples a UV channel onto a subdivided copy of the same surface",
          "[TextureDisplacement]")
 {
@@ -1110,6 +1110,28 @@ TEST_CASE("a cache with the wrong cache version is rejected", "[VendorCache]")
    REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
 }

+TEST_CASE("a cache truncated mid-blob is rejected", "[VendorCache]")
+{
+    TempDir           tmp;
+    const std::string vid   = "Acme";
+    const fs::path     cache = tmp.path / "vendor.opc";
+
+    REQUIRE(save_one_vendor(cache.string(), one_vendor(vid), vid, "1.0.0",
+                            {filament_entry(vid + " PLA")}));
+
+    {
+        std::ifstream in(cache.string(), std::ios::binary);
+        std::vector<char> buf(30); // 20-byte header + 10 bytes of blob
+        in.read(buf.data(), 30);
+        in.close();
+        std::ofstream out(cache.string(), std::ios::binary | std::ios::trunc);
+        out.write(buf.data(), 30);
+    }
+
+    PresetBundle out;
+    REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
+}
+
 TEST_CASE("printer model bed texture fields survive a cache round-trip", "[VendorCache]")
 {
    TempDir           tmp;
@@ -34,6 +34,53 @@ using namespace Slic3r;
 using VD = Geometry::VoronoiDiagram;
 using BoostVD = boost::polygon::voronoi_diagram<double>;

+// https://svn.boost.org/trac10/ticket/12067
+// This bug seems to be confirmed.
+// Vojtech supposes that there may be no Voronoi edges produced for
+// the 1st and last sweep line positions.
+TEST_CASE("Voronoi missing edges - points 12067", "[Voronoi]")
+{
+    Points pts {
+        { -10, -20 },
+        {  10, -20 },
+        {   5,   0 },
+        {  10,  20 },
+        { -10,  20 },
+        {  -5,   0 }
+    };
+
+#if 0
+    for (Point &p : pts) {
+        Vec2d q = p.cast<double>();
+        p.x() = scale_(p.x());
+        p.y() = scale_(p.y());
+    }
+#endif
+
+#if 0
+    // Try to rotate, maybe the issue is caused by incorrect handling of vertical or horizontal edges?
+    double a = 0.18764587962597876897475f;
+    double c = cos(a);
+    double s = sin(a);
+    for (Point &p : poly.points) {
+        Vec2d q = p.cast<double>();
+        p.x() = coord_t(q.x() * c + q.y() * s + 0.5);
+        p.y() = coord_t(- q.x() * s + q.y() * c + 0.5);
+    }
+#endif
+
+    // Construction of the Voronoi Diagram.
+    BoostVD vd;
+    construct_voronoi(pts.begin(), pts.end(), &vd);
+
+#ifdef VORONOI_DEBUG_OUT
+    dump_voronoi_to_svg(debug_out_path("voronoi-pts.svg").c_str(),
+        vd, pts, Lines());
+#endif
+
+//    REQUIRE(closest_point.z() == Catch::Approx(1.));
+}
+
 // https://svn.boost.org/trac10/ticket/12707
 // This issue is confirmed, there are no self intersections in the polygon.
 // A minimal test case is created at the end of this test,
@@ -268,6 +315,36 @@ TEST_CASE("Voronoi weirdness", "[Voronoi]")
 #endif
 }

+// https://svn.boost.org/trac10/ticket/12903
+// division by zero reported, but this issue is most likely a non-issue, as it produces an infinity for the interval of validity
+// of the floating point calculation, therefore forcing a recalculation with extended accuracy.
+TEST_CASE("Voronoi division by zero 12903", "[Voronoi]")
+{
+    Points pts { { 1, 1 }, { 3, 1 }, { 1, 3 }, { 3, 3 },
+                 { -1, 1 }, { 1, -1 }, { 5, 1 }, { 3, -1 },
+                 { -1, 3 }, { 1, 5 }, { 5, 3 }, { 3, 5 } };
+    {
+        auto pts2 { pts };
+        std::sort(pts2.begin(), pts2.end(), [](auto &l, auto &r) { return (l.x() == r.x()) ? l.y() < r.y() : l.x() < r.x(); });
+        // No point removed -> no duplicate.
+        REQUIRE(std::unique(pts2.begin(), pts2.end()) == pts2.end());
+    }
+
+    BoostVD vd;
+    construct_voronoi(pts.begin(), pts.end(), &vd);
+
+#ifdef VORONOI_DEBUG_OUT
+    // Scale the voronoi vertices and input points, so that the dump_voronoi_to_svg will display them correctly.
+    for (auto &pt : vd.vertices()) {
+        const_cast<double&>(pt.x()) = scale_(pt.x());
+        const_cast<double&>(pt.y()) = scale_(pt.y());
+    }
+    for (auto &pt : pts)
+        pt = Point::new_scale(pt.x(), pt.y());
+    dump_voronoi_to_svg(debug_out_path("voronoi-div-by-zero.svg").c_str(), vd, pts, Lines());
+#endif
+}
+
 // https://svn.boost.org/trac10/ticket/12139
 // Funny sample from a dental industry?
 // Vojtech confirms this test fails and rightly so, because the input data contain self intersections.
@@ -1306,6 +1383,15 @@ TEST_CASE("Voronoi offset", "[VoronoiOffset]")
            OffsetTest { scale_(0.55), 1, 0 }
      }) {

+#if 0
+      Polygons offsetted_polygons_out = Slic3r::Voronoi::offset(vd, lines, ot.distance, scale_(0.005));
+#ifdef VORONOI_DEBUG_OUT
+      dump_voronoi_to_svg(debug_out_path("voronoi-offset-out-%lf.svg", ot.distance).c_str(),
+          vd, Points(), lines, offsetted_polygons_out);
+#endif
+      REQUIRE(offsetted_polygons_out.size() == ot.num_outer);
+#endif
+
      Polygons offsetted_polygons_in = Slic3r::Voronoi::offset(vd, lines, - ot.distance, scale_(0.005));
 #ifdef VORONOI_DEBUG_OUT
      dump_voronoi_to_svg(debug_out_path("voronoi-offset-in-%lf.svg", ot.distance).c_str(),
@@ -1 +1,61 @@
 #include <catch2/catch_all.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+#include "slic3r/Utils/Http.hpp"
+
+TEST_CASE("Check SSL certificates paths", "[Http][NotWorking]") {
+    
+    Slic3r::Http g = Slic3r::Http::get("https://github.com/");
+    
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+    
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+    
+    g.perform_sync();
+    
+    REQUIRE(status == 200);
+}
+
+TEST_CASE("Http digest authentication", "[Http][NotWorking]") {
+    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/digest-auth/auth/guest/guest");
+
+    g.auth_digest("guest", "guest");
+
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+
+    g.perform_sync();
+
+    REQUIRE(status == 200);
+}
+
+TEST_CASE("Http basic authentication", "[Http][NotWorking]") {
+    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/basic-auth/guest/guest");
+
+    g.auth_basic("guest", "guest");
+
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+
+    g.perform_sync();
+
+    REQUIRE(status == 200);
+}
+
@@ -73,6 +73,34 @@ TEST_CASE("ActionRegistry takes exclusive ownership of published actions", "[Act
    STATIC_CHECK(std::is_same_v<decltype(&ActionRegistry::upsert), ExpectedUpsert>);
 }

+// A dynamic "Go to Plate N" action is keyed by plate index (not the display title), so renaming
+// a plate never re-keys it - the same contract as a setting action.
+TEST_CASE("Go-to-plate actions are keyed by index, not title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_plate_goto", "0", "orca") == "orca_plate_goto:0:orca");
+    CHECK(AppAction::compose_id("orca_plate_goto", "2", "orca") == "orca_plate_goto:2:orca");
+}
+
+// A dynamic "Open recent project" action is keyed by file path (not the display name), so renaming
+// a project or reordering the recents list never re-keys it - the same contract as a setting action.
+TEST_CASE("Recent-project actions are keyed by path, not title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_recent_project", "/a/b/project.3mf", "orca") ==
+          "orca_recent_project:/a/b/project.3mf:orca");
+    CHECK(AppAction::compose_id("orca_recent_project", "C:/Data/cube.3mf", "orca") ==
+          "orca_recent_project:C:/Data/cube.3mf:orca");
+}
+
+// A built-in command is keyed by its stable catalog key (not the localized display title), so a
+// rename or a UI-language switch never re-keys the action and its persisted favourite/stats survive.
+TEST_CASE("Command actions are keyed by catalog key, not display title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") == "orca_command:save_project:orca");
+    // The second field is the stable key, so distinct commands never collide.
+    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") !=
+          AppAction::compose_id("orca_command", "load_project", "orca"));
+}
+
 // The real catalog -> action mapping keys by the stable catalog key and copies presentation from the
 // catalog, so a rename or a UI-language switch never re-keys the action. The catalog's English title
 // and group become the action's English search aliases; no translation catalog is loaded in the tests,
@@ -150,6 +150,13 @@ public:
        return m_close_frames;
    }

+    // The printer answers a close frame before its own read completes, so the agent's stop can return first.
+    bool wait_for_close_frames(int count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_close_frames >= count; });
+    }
+
    // Hangs up every connection that is waiting.
    void release()
    {
@@ -277,6 +284,7 @@ private:
                if (ec == websocket::error::closed) {
                    std::lock_guard<std::mutex> lock(m_mutex);
                    ++m_close_frames;
+                    m_changed.notify_all();
                }
                if (ec)
                    reading = false;
@@ -449,6 +457,7 @@ TEST_CASE("Stopping the status stream sends the printer a close frame", "[Moonra
    REQUIRE(f.printer.wait_for_ready_connections(1));

    CHECK(f.stops_within(3s));
+    CHECK(f.printer.wait_for_close_frames(1));
    CHECK(f.printer.close_frames() == 1);
 }

@@ -138,6 +138,22 @@ TEST_CASE("PluginConfig serializes the documented on-disk schema", "[PluginConfi
    CHECK(entry.size() == 5);
 }

+TEST_CASE("PluginConfig keeps a capability's config after its plugin goes away", "[PluginConfig]")
+{
+    ScopedDataDir data_dir_guard("plugin-config-retention");
+
+    {
+        PluginConfig config;
+        REQUIRE(config.store_capability_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"), json{{"token", "keep me"}}));
+    }
+
+    // config.json is deliberately not keyed to installed plugins: a record outlives its plugin and is
+    // still there on reinstall. Asserts no cleanup path silently drops it.
+    PluginConfig after_removal;
+    after_removal.load();
+    CHECK(after_removal.get_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"))->config == json{{"token", "keep me"}});
+}
+
 TEST_CASE("PluginConfig treats a missing config file as an empty store", "[PluginConfig]")
 {
    ScopedDataDir data_dir_guard("plugin-config-missing");
				`@@ -0,0 +1 @@`
				solid STL generated by MeshLab facet normal 0.000000e+00 -0.000000e+00 -1.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 0.000000e+00 vertex 2.000000e+01 0.000000e+00 0.000000e+00 vertex 0.000000e+00 0.000000e+00 0.000000e+00 endloop endfacet facet normal -0.000000e+00 0.000000e+00 -1.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 0.000000e+00 vertex 0.000000e+00 0.000000e+00 0.000000e+00 vertex 0.000000e+00 2.000000e+01 0.000000e+00 endloop endfacet facet normal 0.000000e+00 0.000000e+00 1.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 2.000000e+01 vertex 0.000000e+00 2.000000e+01 2.000000e+01 vertex 0.000000e+00 0.000000e+00 2.000000e+01 endloop endfacet facet normal 0.000000e+00 0.000000e+00 1.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 2.000000e+01 vertex 0.000000e+00 0.000000e+00 2.000000e+01 vertex 2.000000e+01 0.000000e+00 2.000000e+01 endloop endfacet facet normal 1.000000e+00 0.000000e+00 -0.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 0.000000e+00 vertex 2.000000e+01 2.000000e+01 2.000000e+01 vertex 2.000000e+01 0.000000e+00 2.000000e+01 endloop endfacet facet normal 1.000000e+00 0.000000e+00 0.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 0.000000e+00 vertex 2.000000e+01 0.000000e+00 2.000000e+01 vertex 2.000000e+01 0.000000e+00 0.000000e+00 endloop endfacet facet normal 0.000000e+00 -1.000000e+00 0.000000e+00 outer loop vertex 2.000000e+01 0.000000e+00 0.000000e+00 vertex 2.000000e+01 0.000000e+00 2.000000e+01 vertex 0.000000e+00 0.000000e+00 2.000000e+01 endloop endfacet facet normal 0.000000e+00 -1.000000e+00 0.000000e+00 outer loop vertex 2.000000e+01 0.000000e+00 0.000000e+00 vertex 0.000000e+00 0.000000e+00 2.000000e+01 vertex 0.000000e+00 0.000000e+00 0.000000e+00 endloop endfacet facet normal -1.000000e+00 0.000000e+00 0.000000e+00 outer loop vertex 0.000000e+00 0.000000e+00 0.000000e+00 vertex 0.000000e+00 0.000000e+00 2.000000e+01 vertex 0.000000e+00 2.000000e+01 2.000000e+01 endloop endfacet facet normal -1.000000e+00 0.000000e+00 0.000000e+00 outer loop vertex 0.000000e+00 0.000000e+00 0.000000e+00 vertex 0.000000e+00 2.000000e+01 2.000000e+01 vertex 0.000000e+00 2.000000e+01 0.000000e+00 endloop endfacet facet normal 0.000000e+00 1.000000e+00 0.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 2.000000e+01 vertex 2.000000e+01 2.000000e+01 0.000000e+00 vertex 0.000000e+00 2.000000e+01 0.000000e+00 endloop endfacet facet normal 0.000000e+00 1.000000e+00 0.000000e+00 outer loop vertex 2.000000e+01 2.000000e+01 2.000000e+01 vertex 0.000000e+00 2.000000e+01 0.000000e+00 vertex 0.000000e+00 2.000000e+01 2.000000e+01 endloop endfacet endsolid vcg