Fix z-fighting between feature previews and the bodies in the Design tab

The bodies now always draw over the preview on every face a feature leaves unchanged, for
all features. Since a hole's cut sits inside the body, the Hole preview now hides the
bodies and shows the result alone, as Fillet/Chamfer and Draft do.

.clang-tidy

@@ -0,0 +1,69 @@
+# clang-tidy configuration, enforced by the clang-tidy CI job on the lines a pull
+# request changes (scripts/clang_tidy_diff.py). Only missing includes are reported
+# for now: a file should include the header for every symbol it uses, not rely on
+# the precompiled header or another header's includes. Run with --fix to add them.
+# Every check listed here gates pull requests, so enable a new one only once the
+# code it flags on touched lines is reasonable to fix in passing.
+Checks: '-*,misc-include-cleaner'
+WarningsAsErrors: '*'
+CheckOptions:
+  # Missing includes only. Builds without the precompiled header break on these.
+  misc-include-cleaner.UnusedIncludes: false
+  # Headers that declare a symbol but are not the one to include: per-platform
+  # implementations of wxWidgets and Boost.Thread (a Linux run would suggest the
+  # GTK or pthread one), library internals and forward declarations (MSVC's STL
+  # __msvc_* and the Windows UCRT's corecrt_* included), CPython's headers behind
+  # Python.h (python3.x/ on Linux and macOS, libpython/include/ on Windows),
+  # curl's behind curl.h, oneTBB's behind tbb/, and
+  # admesh's stl.h, which the include path also exposes without its directory.
+  # Clipper's own clipper.hpp is only included through libslic3r/clipper.hpp or
+  # clipper_z.hpp, which configure it first, and Boost.Polygon's headers only
+  # work through boost/polygon/polygon.hpp or voronoi.hpp. Clipper2's headers
+  # are included through clipper2/clipper.h, or clipper2_z.hpp, which defines
+  # USINGZ first. minilzo's config
+  # headers are internal to minilzo.h.
+  # FFmpeg's C headers are left alone because they are only included inside
+  # extern "C", which an inserted include would miss. OS-specific headers (GLib,
+  # GTK, D-Bus, POSIX, the Windows SDK) are only used inside platform #if blocks,
+  # and an include added at the top of the file would break the other platforms'
+  # builds. A symbol these provide is not reported missing.
+  # Write every / as [/\\] so the patterns also match Windows paths.
+  # No comments inside the block below, because a # there silently becomes part of a pattern.
+  misc-include-cleaner.IgnoreHeaders: >-
+    wx[/\\](gtk|gtk1|msw|osx|unix|x11|motif|univ|qt|dfb|generic|private)[/\\].*;
+    .*[/\\]detail[/\\].*;
+    .*[/\\]impl[/\\].*;
+    .*_fwd\.hpp;
+    python3\.[0-9]+[/\\].*;
+    libpython[/\\]include[/\\].*;
+    bits[/\\].*;
+    corecrt_.*\.h;
+    __msvc_.*\.hpp;
+    boost[/\\]multiprecision[/\\]fwd\.hpp;
+    imconfig\.h;
+    expat_external\.h;
+    admesh[/\\]stl\.h;
+    boost[/\\]thread[/\\](pthread|win32)[/\\].*;
+    boost[/\\]regex[/\\]v[0-9]+[/\\].*;
+    curl[/\\](easy|multi|system|urlapi|header|options|websockets|mprintf)\.h;
+    oneapi[/\\]tbb[/\\].*;
+    opencv2[/\\]core[/\\]hal[/\\].*;
+    openssl[/\\]ossl_typ\.h;
+    libav[a-z]+[/\\].*;
+    libsw[a-z]+[/\\].*;
+    glib-2\.0[/\\].*;
+    gtk-3\.0[/\\].*;
+    dbus-1\.0[/\\].*;
+    sys[/\\].*;
+    unistd\.h;
+    strings\.h;
+    fcntl\.h;
+    termios\.h;
+    [/\\](um|shared)[/\\].*;
+    sal\.h;
+    clipper[/\\]clipper\.hpp;
+    png(lib)?conf\.h;
+    mcut[/\\]platform\.h;
+    boost[/\\]polygon[/\\].*;
+    clipper2[/\\]clipper\.(core|engine|offset|minkowski|rectclip|export|triangulation|version)\.h;
+    lzo(conf|defs)\.h

.claude/skills/orca-wxwidgets/SKILL.md

@@ -30,8 +30,9 @@ how you read the wx docs:
 Look things up in the source the app is built from — it beats memory, and 3.3 changed real behaviour:
 
 ```bash
-WX=$(find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' | head -1)
-# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux: deps/build/dep_wxWidgets-prefix/...
+WX=$(find -L deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets' 2>/dev/null | head -1)
+# macOS: deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets   Linux, Windows: deps/<tree>/dep_wxWidgets-prefix/...
+# -L follows a worktree's deps/<tree> symlinked to the main checkout. Not a glob: zsh aborts on one that matches nothing.
 # If deps are not built: git clone --depth 1 -b v3.3.2 https://github.com/SoftFever/Orca-deps-wxWidgets
 grep -n "CaptureMouse" -A 30 $WX/interface/wx/window.h      # documented contract (doxygen source)
 grep -rn "@onlyfor\|not implemented" $WX/interface/wx/popupwin.h   # documented platform limits
@@ -40,6 +41,13 @@ grep -n "IsDark" $WX/docs/changes.txt                         # what changed in
 grep -n "NotifyCaptureLost" -r $WX/src/osx $WX/src/gtk $WX/src/msw   # what each port actually does
 ```
 
+On Windows these lookups are bash: run them from Git Bash. PowerShell has no `grep`, and its `find` is
+Windows' text-search `find.exe`. To locate the wx tree from PowerShell:
+
+```powershell
+$WX = Resolve-Path deps\*\dep_wxWidgets-prefix\src\dep_wxWidgets, deps\*\*\dep_wxWidgets-prefix\src\dep_wxWidgets -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty Path
+```
+
 `interface/wx/<class>.h` is the documentation; `src/common` holds shared behaviour and
 `src/{msw,osx,gtk,unix,generic}` the per-port implementation. When the docs and the source disagree,
 the source is what runs — the references mark such facts **[source]**. Orca-side design docs live in
@@ -206,7 +214,8 @@ known class with a pitfall entry and a fixing commit.
 - **macOS:** capture-lost is never sent (a leaked capture freezes all clicks); transient popups hover-
   dismiss across a gap — anchor flush and re-verify the cursor; native modals (file/dir dialogs, native
   message boxes) and generic progress dialogs re-activate the main window, so re-raise a secondary window
-  afterwards with a deferred, liveness-guarded `Raise()`; a live menu accelerator consumes the key before
+  afterwards with a deferred, liveness-guarded `Raise()` — but never `Raise()` a `wxPopupWindow`, which makes
+  it the key window; a live menu accelerator consumes the key before
   any wx key event; Control+click arrives as a right-click.
 - **Windows:** `IsDark()` and `wxSYS_COLOUR_*` follow the system app mode, not Orca's theme — use
   `dark_mode()`; menu bitmaps follow `check_dark_mode()`; windows are not double-buffered by default in

.claude/skills/orca-wxwidgets/references/controls-dataview.md

@@ -331,6 +331,10 @@ OrcaSlicer: integer spinners are `::SpinInput` ([below](#spininput)); progress b
 Contract:
 - A page must be created with the book as its parent and added once; the book owns and deletes it
   (`interface/wx/bookctrl.h:253-254, 273`). `RemovePage` detaches without deleting, and you then own it (`:324-330`).
+- Removing the selected page selects the page before it (the new first page if it was first) through `SetSelection`,
+  so that page is shown and PAGE_CHANGING/CHANGED are sent; removing a page before the selection only shifts the
+  index. This is `wxBookCtrlBase::DoSetSelectionAfterRemoval` (`src/common/bookctrl.cpp:477-495` **[source]**),
+  called from `DoRemovePage` by `wxSimplebook`, `wxChoicebook`, `wxListbook`, `wxToolbook` and Orca's `Notebook`.
 - `GetSelection()` inside a `PAGE_CHANGED` handler may return the old or the new page depending on the platform; use
   `event.GetSelection()` (`interface/wx/bookctrl.h:160-166`).
 - `wxSimplebook` has no UI; switch with `ChangeSelection()`. `SetSelection()` sends PAGE_CHANGING/CHANGED

.claude/skills/orca-wxwidgets/references/mouse-keyboard-focus.md

@@ -10,7 +10,7 @@ wx asserts are compiled out in Orca (`wxDEBUG_LEVEL=0`), so every misuse below t
 an assert fails silently. "GTK" means wxGTK3, Orca's Linux default (X11 and Wayland); GTK2 is only
 an opt-out build (`-DDEP_WX_GTK3=OFF`), noted where it differs. Paths starting `interface/`,
 `include/`, `src/`, `docs/` are in the wx tree
-(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`); Orca paths are
+(located as in `SKILL.md` §Ground truth); Orca paths are
 relative to `src/slic3r/GUI/`.
 
 Contents: [Rules](#rules) · [Mouse capture](#mouse-capture) · [Mouse events](#mouse-events) ·

.claude/skills/orca-wxwidgets/references/orca-architecture.md

@@ -332,7 +332,9 @@ indices: pages come and go per printer and per feature flag.
   pages depending on the printer and on `use_printer_agents`; a removed page stays registered but is
   not prebuilt (its `LazyPage::in_book()` is false).
 - Plugin pages are appended by `PluginPages::initialize` (`plugin/host/PluginPages.hpp`) with
-  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`.
+  namespaced ids (`plugin.<plugin_key>.<name>`) that cannot collide with `TAB_ID_*`. Each is a
+  `LazyPage<PluginPage>` with order −1, destroyed when its capability goes away.
+  → [Deferred construction](#deferred-construction-lazy-lazypage-stagedbuild-idlescheduler)
 
 ### Preset tabs
 
@@ -403,9 +405,13 @@ page object to insert and remove by pointer). `LazyPage(parent, name, order, fac
 factory is `new Panel(parent)`. Its `Show(true)` builds the panel the first time (only once the
 top-level frame is shown — `MainFrame::Show` completes the start page on the frame's first show) and
 forwards later shows/hides to the panel, so the panel's own `Show()` override stays its activation
-hook. A panel built while its page is hidden stays hidden, and `when_built` gives it the dark-UI pass
-the frame ran before it existed (`apply_dark_ui_to_lazy_panel`). `pending()` is true only while the page
-is in the book.
+hook. The build runs before the placeholder's own `wxPanel::Show(true)`, so an on-demand build creates
+its controls in a hidden window as a prebuild does: on MSW each control created or moved inside a
+shown window re-clips and repaints its shown siblings, which made a large panel's first show take
+seconds. A lazy panel's constructor therefore runs off screen (except the start page's) and must not
+rely on `IsShownOnScreen()`. A panel built while its page is hidden stays hidden, and `when_built`
+gives it the dark-UI pass the frame ran before it existed (`apply_dark_ui_to_lazy_panel`).
+`pending()` is true only while the page is in the book.
 
 ### Staged construction: StagedBuild
 
@@ -529,6 +535,32 @@ the main frame does nothing to a panel after creating it.
   m_idle.add(m_diff_dialog);
   ```
   Cite: `IdleScheduler::tick`, `docs/HLSD/deferred-page-construction.md`.
+- **Rule:** A lazy page that can be destroyed while the main frame lives takes a negative order and
+  stays out of `m_lazy_pages`.
+  **Why:** `m_lazy_pages` and `PrebuildQueue` hold raw `LazyBase*` and nothing removes one
+  (`PrebuildQueue` has only `add` and `clear`). The queue calls `pending()` on every task each slice,
+  and `prebuild_pages_when_idle` reads every entry of `m_lazy_pages`, so a page destroyed while still
+  listed can be read after it is freed. A page only taken out of the book is fine: it stays registered
+  and its `pending()` is false (`MainFrame::show_device`).
+  ```cpp
+  // Right (PluginPages::create_page): order -1, and no m_lazy_pages.push_back
+  auto* page = new GUI::LazyPage<PluginPage>(m_parent, name, -1, [capability](wxWindow* parent) {
+      return new PluginPage(parent, capability);
+  });
+  ```
+  Cite: `PluginPages::create_page`, `PluginPages::remove_page`.
+- **Rule:** Remove several lazy pages from a book left to right.
+  **Why:** removing the selected page selects and shows the page before it
+  (`references/controls-dataview.md` §Book controls), and showing an unbuilt `LazyPage` while the frame
+  is shown builds it. In any other order the page before the selected one can be one removed next,
+  built only to be destroyed; left to right it is one that stays (unless the selected page is the
+  book's first).
+  ```cpp
+  // Right (PluginPages::shutdown): m_order is the tabs' left-to-right order
+  for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
+      remove_page(id);
+  ```
+  Cite: `PluginPages::shutdown`, `PluginPages::relayout`, `PluginPages::on_plugin_deregister`.
 
 ## Plater and Sidebar
 
@@ -613,8 +645,10 @@ Spacing constants come from `SidebarProps` (`Plater.hpp`): `TitlebarMargin()`, `
 
 ### Docking
 
-`Plater::priv` owns `AuiMgr m_aui_mgr` (a `wxAuiManager` subclass whose `CreateFloatingFrame` returns a
-themed `FloatFrame : wxAuiFloatingFrame`), managing the plater. Panes: `"sidebar"` (left, no close
+Docks are `AuiMgr`s (`AuiMgr.hpp`), a `wxAuiManager` subclass carrying Orca's dock art, theme and
+Wayland rule (`references/webview-gl-aui-media.md`). `Plater::priv` owns `m_aui_mgr`, managing the
+plater; the Design tab owns its own for its sidebar (`DesignPanel::m_aui`, layout in
+`design_window_layout`). Plater panes: `"sidebar"` (left, no close
 button, not top/bottom dockable), `"main"` (`CenterPane()`, the `panel_3d`), `"uv_editor"` (right,
 hidden until the texture-displacement gizmo shows it), plus dynamic dock panes. The default perspective
 is saved right after `AddPane`; the app-config `window_layout` is applied with

.claude/skills/orca-wxwidgets/references/painting-custom-widgets.md

@@ -6,7 +6,7 @@ to write a custom control on the wx side and how to author an Orca widget on the
 `StaticBox`/`StateHandler` foundation. Read it before writing or reviewing any `wxEVT_PAINT`
 handler, `render`/`doRender` method, `messureSize`, or a new class under `src/slic3r/GUI/Widgets/`.
 
-wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
+wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every
 wx assert below is compiled out and `wxCHECK*` returns silently, so paint misuse shows up only as
 wrong, missing or stale pixels, never as an assert dialog.

.claude/skills/orca-wxwidgets/references/platforms.md

@@ -78,8 +78,9 @@ Contents: [Rules](#rules) · [The wx build Orca uses](#the-wx-build-orca-uses)
   `references/colours-dark-mode.md`.
 - The checked-out source is the tree that every wx citation in this skill refers to:
   `deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets` on macOS and
-  `deps/build/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux. Find it with
-  `find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`. On macOS its
+  `deps/<tree>/dep_wxWidgets-prefix/src/dep_wxWidgets` on Linux and Windows (`deps/build` for a
+  release build; `build_win.bat` names the others). Locate it with the bash or PowerShell lookup in
+  `SKILL.md` §Ground truth. On macOS its
   `src/osx/cocoa/colour.mm` already has the patch applied.
 - **Flatpak builds wx separately.** `deps/CMakeLists.txt` leaves `dep_wxWidgets` out of the deps
   target when `FLATPAK` is set. Instead, `scripts/flatpak/com.orcaslicer.OrcaSlicer.yml` has its own
@@ -270,6 +271,14 @@ Each bullet names the mechanism and the file that owns it.
 - **Painting:** in 3.3.2 windows are not double-buffered by default (the 3.3.0 global
   `WS_EX_COMPOSITED` was reverted, `docs/changes.txt:308`). Custom widgets buffer by hand →
   `references/painting-custom-widgets.md`.
+- **Building large panels:** every control is a native child window, and outside a sizer pass a move
+  or resize is immediate, repainting when the window is shown [source: `src/msw/window.cpp:2036`
+  `DoMoveSibling` → `MSWMoveWindowToAnyPosition(..., IsShown())`]; `wxStaticText::SetLabel`/`SetFont`
+  resize the control that way (`src/common/stattextcmn.cpp:334` `AutoResizeIfNecessary`). Created
+  inside a shown parent, each control re-clips and erases its shown, overlapping siblings, so the
+  cost grows with the number already built and hundreds of controls take seconds. Build a large
+  panel while its parent is hidden and show it once complete — `LazyPage::Show` builds its panel
+  before showing the page for this reason → `references/orca-architecture.md` §Deferred construction.
 - **Modal loops:** idle events do not run inside the Windows sizing/moving modal loop, so the 3D
   canvas renders from `on_paint` on MSW (c06a0223a7) → `references/webview-gl-aui-media.md` §GLCanvas3D rendering.
 - **Mouse capture:** `wxEVT_MOUSE_CAPTURE_LOST` and `wxEVT_MOUSE_CAPTURE_CHANGED` are delivered →
@@ -473,7 +482,7 @@ start there when looking for prior art. The sites below are exemplars, cited by
   data-view cell editors an explicit top-level transient parent.
   `DropDown::ShouldDismissOnTopWindowDeactivate` handles Wayland chains.
 - `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton` (`wxExtensions.cpp`),
-  `ObjColorDialog`, `PresetComboBoxes` call `RemoveButtonBorder`; `TextInput` and `SpinInput` call
+  `PresetComboBoxes` call `RemoveButtonBorder`; `TextInput` and `SpinInput` call
   `RemoveInputBorder` on their inner `wxTextCtrl`.
 - `Plater::priv::priv` together with `sanitize_window_layout_for_wayland`: AUI floating is disabled on
   Wayland.
@@ -811,7 +820,7 @@ widgets do it in their constructors.
   (`"*.GtkBitmapToggleButton"`, class `"GtkEntry"`). The first call changes every matching widget in
   the process, not just the one passed in.
 
-**Callers:** `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton`, `ObjColorDialog` and
+**Callers:** `CheckBox::CheckBox`, `SwitchButton`, `RadioBox`, `ScalableButton` and
 `PresetComboBoxes` (`RemoveButtonBorder`); the inner `wxTextCtrl` of `TextInput` and `SpinInput`
 (`RemoveInputBorder`). A new owner-drawn control built on a native GTK widget needs the same call.
 

.claude/skills/orca-wxwidgets/references/popups-menus.md

@@ -5,7 +5,7 @@ How wx 3.3.2 popups and menus behave on each port, and the Orca wrappers built o
 `append_menu_item`, `Plater::PopupMenu` and the macOS menubar versus `BBLTopbar`. Read it before you add
 or change anything that opens over other UI and must close by itself, or any context menu or menubar item.
 
-wx cites are relative to the wx tree root (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
+wx cites are relative to the wx tree root (located as in `SKILL.md` §Ground truth).
 **[source]** marks behaviour derived from the implementation that the wx docs do not state or contradict.
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0`, so every "asserts" below means "fails silently in Orca".
 "GTK" means wxGTK3 (X11 and Wayland), the default Linux build; GTK2 is only an opt-out (`-DDEP_WX_GTK3=OFF`).
@@ -57,8 +57,9 @@ Contents: [Rules](#rules) · [1. Choosing the window kind](#1-choosing-the-windo
 17. Don't shrink a dropdown below two rows to fit the screen. (§7)
 18. Content that needs typing focus or hosts a `wxWebView` uses a frameless `wxDialog` that hides on
     deactivation, not a transient popup. (§10)
-19. Display-only overlays (HUDs, toasts) use a plain `wxPopupWindow`: it never takes focus and never
-    auto-dismisses. (§4, §10)
+19. Display-only overlays (HUDs, toasts) use a plain `wxPopupWindow`: `Show()` never gives it focus and it
+    never auto-dismisses. Never `Raise()` any `wxPopupWindow`: `Raise()` is for top-level windows only, and on
+    macOS it makes the popup the key window. (§4, §5, §10)
 20. On MSW, don't `SetFocus()` another window on hover while `wxCurrentPopupWindow` is non-null. (§8)
 21. Menu items use `wxID_ANY` and read `item->GetId()`. `wxNewId()` is deprecated. (§13)
 22. Set a menu item's bitmap before `Append`. Don't expect icons on check or radio items. Never call
@@ -356,6 +357,13 @@ compensates for (§6).
   with `ShowWithoutActivating` → `setHidesOnDeactivate:YES` + `orderFront` (`src/osx/carbon/popupwin.cpp:56-75`,
   `nonownedwnd.mm:938-945`). When the app deactivates, Cocoa hides the panel and shows it again on reactivation.
   wx never calls `OnDismiss`, and `IsShown()` stays true. This applies to plain `wxPopupWindow` overlays too.
+- `Raise()` activates the popup. It is `makeKeyAndOrderFront` (`src/osx/nonownedwnd_osx.cpp:289-295`,
+  `nonownedwnd.mm:897-899`), and `wxNSPanel` answers `canBecomeKeyWindow` with YES (`nonownedwnd.mm:271`), so
+  the popup becomes the key window. Keys go to it, and the frame loses key status: `windowDidResignKey` →
+  `HandleActivated(0, false)` → `wxEVT_ACTIVATE(false)` on the frame (`nonownedwnd.mm:567-576`,
+  `nonownedwnd_osx.cpp:303-310`). Hiding the key popup gives key back to the frame, which then gets
+  `wxEVT_ACTIVATE(true)` (observed; AppKit behaviour, not in the wx tree). A popup at `NSPopUpMenuWindowLevel`
+  is already above its frame, so `Raise()` buys nothing.
 - Capture: `Show(true)` makes `m_child` capture the mouse ("Assume that the mouse is outside the popup to begin
   with", `popupcmn.cpp:421-426`). `OnIdle` releases the capture while the cursor is inside and re-captures it
   outside, but only when the mouse position has changed since the last idle pass. `s_posLast` is a
@@ -739,8 +747,26 @@ created with `wxBORDER_NONE | wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT | wxF
 - **Rule:** For overlays that must never take keyboard focus (above a GL surface), use a plain
   `wxPopupWindow(top, wxBORDER_NONE)`, not a `wxFrame`.
   **Why:** A frame took the X input focus and swallowed every shortcut until the user clicked the canvas. A popup
-  window cannot take focus. On macOS these overlays hide while the app is inactive (§5).
+  window does not take focus when shown. On macOS these overlays hide while the app is inactive (§5).
   Cite: `CAD/DesignCanvas.cpp` (`m_hud`, `m_status_hud`).
+- **Rule:** Never `Raise()` a `wxPopupWindow`. To bring an overlay up, `Show()` it if it is hidden, then
+  `Move()` it.
+  **Why:** `Raise()` is documented for top-level windows only (`interface/wx/window.h:3028-3029`), and a popup
+  derives from `wxNonOwnedWindow`, not `wxTopLevelWindow` (`include/wx/popupwin.h:33`). On macOS it makes the
+  popup the key window (§5): the popup takes the keys meant for the window below it, and the frame receives
+  `wxEVT_ACTIVATE(false)`. A frame activate handler that hides the overlay on deactivation and re-places it on
+  activation then loops: each `Raise()` deactivates the frame, the hide reactivates it, and the re-place raises
+  again, recursing until the main thread's stack overflows. A popup's `Show()` is `ShowWithoutActivating`
+  and is safe.
+  ```cpp
+  // Wrong
+  if (!overlay->IsShown()) overlay->Show();
+  overlay->Move(pos);
+  overlay->Raise();
+  // Right
+  if (!overlay->IsShown()) overlay->Show();
+  overlay->Move(pos);
+  ```
 
 ## 11. wxComboCtrl / wxComboPopup
 

.claude/skills/orca-wxwidgets/references/threads-timers-app.md

@@ -7,7 +7,7 @@ yields and nested event loops, progress dialogs, startup, shutdown and exception
 screen, and the access rules for `wxGetApp()` and `app_config`. Read it whenever code runs off the
 main thread, defers work, starts a timer, yields, shows progress, or runs during startup or shutdown.
 
-wx cites are relative to the pinned wx 3.3.2 tree (`deps/build/<arch>/dep_wxWidgets-prefix/src/dep_wxWidgets`).
+wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth).
 Orca builds wx with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`, so `wxASSERT`
 is compiled out and `wxCHECK*` returns silently: a timer started off the main thread never fires on macOS,
 `Exit()` on a loop that is not the active one is ignored, `Start(0)` on macOS fails — all without

.claude/skills/orca-wxwidgets/references/webview-gl-aui-media.md

@@ -88,6 +88,7 @@ available; GTK2/WebKit1 is an opt-out configuration the GUI does not support.
 24. ImGui text uses `_u8L`; ImGui sizes are physical pixels (scale by `GLCanvas3D::get_scale()`);
     a font atlas must fit `GL_MAX_TEXTURE_SIZE`. §[ImGui boundary](#the-imgui-layer-boundary)
 25. After `AddPane` or any `wxAuiPaneInfo` change, call `wxAuiManager::Update()` once for the batch.
+    Keep a docked pane hidden until the managed window has been laid out.
     §[AUI](#wxauimanager-and-orcas-docking)
 26. Give every pane a unique, stable `Name()` free of layout delimiters (`|`, `;`, `=`, `\`).
     §[AUI](#wxauimanager-and-orcas-docking)
@@ -920,6 +921,16 @@ widgets beside the canvas (a sibling, not a child over it), or in a popup.
 - **Update.** "Update() must be invoked after AddPane() or InsertPane() … any number of changes may be
   made to wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to realize the changes,
   Update() must be called" (`interface/wx/aui/framemanager.h:747-756`). Batch, then `Update()` once.
+- **Dock size** [source]. The docs limit "any new dock" to a `SetDockSizeConstraint` fraction of the
+  window (`interface/wx/aui/framemanager.h:660-672`). The source applies it to the managed window's client
+  size at the `Update()` that creates the dock, sizing the dock from its panes' `best_size` and then
+  raising it to their `min_size` (`src/aui/framemanager.cpp:2748-2848`); a dock with a resizable pane
+  keeps that size (`2674-2677`), and resizing the managed window only re-lays the docks out
+  (`4542-4546`). A pane first shown before its managed window is laid out — a `wxDefaultSize` window is
+  20×20 until its first sizer layout (`references/sizers-layout.md`) — docks at that width or its
+  `min_size` and stays there. Hiding a dock's last shown pane empties it, and the next `Update()`
+  removes it (`2733-2738`) with any `dock_size` a `LoadPerspective` restored, so the pane comes back
+  at its `best_size`.
 - **Names** [source]. A duplicate `Name()` hits `wxFAIL` (silent in Orca); duplicate and empty names
   get a random identifier (`src/aui/framemanager.cpp:949-1010`), which `LoadPerspective` can never
   match. `AddPane` rejects a null window, but its "already managed" check looks up `paneInfo.window`
@@ -953,11 +964,12 @@ widgets beside the canvas (a sibling, not a child over it), or in a popup.
 - `wxAuiNotebook` (not used by Orca): page indices are logical; use `GetPagePosition()` for on-screen
   order (`docs/changes.txt:121-126`); the default tab art changed (`35-37`).
 
-**OrcaSlicer.** `Plater::priv` owns `AuiMgr m_aui_mgr`, a `wxAuiManager` whose `CreateFloatingFrame`
-returns `FloatFrame : wxAuiFloatingFrame` (applies `UpdateFrameDarkUI`).
-- Setup: `SetManagedWindow(q)` (the Plater), `SetDockSizeConstraint(1, 1)`; on Wayland clears
-  `wxAUI_MGR_ALLOW_FLOATING` (`disable_wayland_floating`); dock-art metrics set here, colours in the
-  dark-mode update (`Plater::priv::apply_color_mode`).
+**OrcaSlicer.** Orca's docks use `AuiMgr` (`AuiMgr.hpp`), a `wxAuiManager` whose `CreateFloatingFrame`
+returns a `wxAuiFloatingFrame` that applies `UpdateFrameDarkUI`. `init(window)` calls
+`SetManagedWindow(window)` and `SetDockSizeConstraint(1, 1)`, clears `wxAUI_MGR_ALLOW_FLOATING` on
+Wayland and sets the dock-art metrics and colours; `apply_color_mode()` re-colours captions, sashes and
+borders and is called from the owner's theme-switch handler. `Plater::priv::m_aui_mgr` manages the
+Plater (Prepare and Preview); `DesignPanel::m_aui` manages the Design tab's body below its toolbar.
 - Panes: `"sidebar"` (left, no close button, not top/bottom dockable, `BestSize` in em units),
   `"uv_editor"` (right, hidden; forced hidden again after a layout load), `"main"`
   (`CenterPane().PaneBorder(false)`, holding `panel_3d` with View3D, Preview and AssembleView in one
@@ -966,8 +978,8 @@ returns `FloatFrame : wxAuiFloatingFrame` (applies `UpdateFrameDarkUI`).
   `window_layout` app-config string goes through `sanitize_window_layout_for_wayland` (strips
   floating/floatable bits on Wayland) and `LoadPerspective(layout, false)`, falling back to the default
   on failure; then one `Update()`. `Plater::priv::reset` saves `SavePerspective()` back to
-  `window_layout`. An idle handler copies the docked sidebar width into `BestSize` (wxAUI does not record
-  a dragged sash there), so the width persists. `Plater::priv::reset_window_layout` is the model for
+  `window_layout`. `AuiMgr::track_docked_size` copies a docked pane's size into `BestSize` on idle
+  (wxAUI does not record a dragged sash there), so the width persists. `Plater::priv::reset_window_layout` is the model for
   re-establishing panes after a load: it loads the default perspective, then re-shows each plugin pane
   the perspective does not list.
 - Plugin panes: `Plater::add_dock_pane(window, name, caption, dock, size, on_close)` (window must be a
@@ -977,13 +989,29 @@ returns `FloatFrame : wxAuiFloatingFrame` (applies `UpdateFrameDarkUI`).
   `Destroy()`s without running `on_close`; `show_dock_pane` toggles and updates. Pane names come from
   `plugin_pane_name` (`DockPanel.cpp`), which replaces `|`, `;`, `=`, `\` — the perspective-string
   delimiters.
+- Other pages: a page outside the Plater docks through its own `AuiMgr` member, since the Plater's
+  manages only the Plater. Its managed window is a body panel below the page's toolbar; a sidebar
+  takes `AuiMgr::sidebar_pane_info()`; the layout has its own app-config key, is reset from
+  `Plater::reset_window_layout`, and is saved by a `shutdown()` called from `MainFrame::shutdown`,
+  which also detaches a floating pane (Lifetime below). Where floating is disabled it forces
+  `Dock().Floatable(false)` after loading, as plugin panes do. A `LazyPage` builds its panel at 20×20
+  and lays it out only as the tab shows, so the sidebar stays hidden until the tab is first shown (Dock
+  size above). `DesignPanel` is the model
+  (`docs/HLSD/design-tab.md`). A `GLCanvas3D` beside such a sidebar gets that sidebar's collapse
+  button with `set_collapse_toolbar`; without it the canvas falls back to the Plater's button, which
+  collapses Prepare's sidebar.
 - Lifetime: no explicit `UnInit`. `m_aui_mgr` is a `Plater::priv` member, so it is destroyed in
   `~Plater`, before `~wxWindow` destroys the Plater's children (`wxWindowBase::DestroyChildren`,
   `src/common/wincmn.cpp:586-609`); a floating frame is such a child (`CreateFloatingFrame(m_frame, …)`,
   `src/aui/framemanager.cpp:3151`), so a pane still floating at that point outlives the manager [source].
-  Plugin panes are removed earlier (`MainFrame::shutdown` → `Plater::remove_dock_panes`). The sidebar
-  `GetPane()` reference captured by the idle lambda is safe across `AddPane`; never `DetachPane` a pane
-  whose reference is captured.
+  Plugin panes are removed earlier (`MainFrame::shutdown` → `Plater::remove_dock_panes`). A handler
+  that can outlive its pane looks the pane up when it runs, as `track_docked_size` does: an idle
+  handler bound on the pane's window outlives the `DetachPane` in `DesignPanel::shutdown`. Never detach
+  a pane whose `GetPane()` reference is captured (Pane references above). `DesignPanel::shutdown` is
+  the model for a member manager: it detaches a
+  floating sidebar, which `Destroy()`s the frame into the pending-delete list, and the main frame's
+  deletion deletes pending top-level children before its own children (`~wxTopLevelWindowBase`,
+  `src/common/toplvcmn.cpp:67-93`), while the panel and its manager are still alive [source].
 
 **Pitfalls.**
 - **Rule:** Call `Update()` once after a batch of `AddPane`/`wxAuiPaneInfo` changes.

.claude/skills/orca-wxwidgets/references/windows-dialogs.md

@@ -6,10 +6,9 @@ port; what Orca's `DPIDialog`/`DPIFrame` add; the Orca dialog recipe; and the `M
 Read it before writing or reviewing any dialog, frame, close handler, `Destroy()`/`delete`, or code
 that keeps a pointer to a window across an event, a `CallAfter` or a modal loop.
 
-wx cites are relative to the pinned wx 3.3.2 tree (`find deps -maxdepth 5 -type d -path
-'*dep_wxWidgets-prefix/src/dep_wxWidgets'`). wx is built with `wxBUILD_DEBUG_LEVEL=0` and
-`libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert quoted below is compiled out, so misuse
-fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
+wx cites are relative to the pinned wx 3.3.2 tree (located as in `SKILL.md` §Ground truth). wx is
+built with `wxBUILD_DEBUG_LEVEL=0` and `libslic3r_gui` with `wxDEBUG_LEVEL=0`: every wx assert
+quoted below is compiled out, so misuse fails silently (dropped call, stuck loop, freed memory), never with an assert dialog. "GTK" below
 means wxGTK as Orca builds it on Linux: GTK3 by default (X11 or Wayland); GTK2 is only an opt-out.
 
 Contents: [Rules](#rules) · [1 Creating and parenting](#1-creating-and-parenting-windows) ·
@@ -428,7 +427,8 @@ this function does *not* show it", top-level windows only (`interface/wx/window.
 since 3.3 (`docs/changes.txt:144-146`). **[source]** MSW = `::SetForegroundWindow`, subject to the
 foreground lock — Windows may only flash the taskbar button (`src/msw/toplevel.cpp:650-655`); GTK =
 `gtk_window_present` only if shown (`src/gtk/toplevel.cpp:1301-1310`; during a deferred X11 first show it
-already counts as shown); macOS = `makeKeyAndOrderFront` only if shown (`src/osx/nonownedwnd_osx.cpp:289-295`, `src/osx/cocoa/nonownedwnd.mm:896-899`).
+already counts as shown); macOS = `makeKeyAndOrderFront` only if shown (`src/osx/nonownedwnd_osx.cpp:289-295`, `src/osx/cocoa/nonownedwnd.mm:897-899`),
+which also makes a `wxPopupWindow` the key window — never `Raise()` a popup (`references/popups-menus.md` §5, §10).
 
 **Enable.** `Enable(false)` on a parent disables children logically: `IsEnabled()` reflects ancestors,
 `IsThisEnabled()` the window's own flag (`interface/wx/window.h:3060-3070, 3116-3138`). **[source]** On MSW/macOS wx

.claude/skills/orca-wxwidgets/references/wx-33-changes.md

@@ -14,7 +14,7 @@ Contents: [Rules](#rules) · [1 Reading the change logs](#1-reading-the-change-l
 [8 Migration done in Orca](#8-migration-already-done-in-orca)
 
 All `docs/`, `interface/`, `include/`, `src/`, `build/` cites are relative to the pinned wx tree
-(`find deps -maxdepth 5 -type d -path '*dep_wxWidgets-prefix/src/dep_wxWidgets'`), except paths
+(located as in `SKILL.md` §Ground truth), except paths
 explicitly called Orca's (`deps/…`, Orca's `src/CMakeLists.txt`) and bare Orca file + symbol cites.
 
 ## Rules
@@ -198,7 +198,7 @@ change, its line, and what it means for Orca.
 | `wxAuiGenericTabArt` subclasses (also via `wxAuiMSWTabArt`) override `DrawPageTab()`/`GetPageTabSize()` instead of `DrawTab()`/`GetTabSize()`; direct `wxAuiTabArt` subclasses still work | :115-120 | none: no Orca tab art |
 | `wxAuiNotebook` page index is logical (reorder-independent); `GetPagePosition()` gives the screen position | :122-126 | none; index math under `wxAUI_NB_TAB_MOVE` is what breaks |
 | `wxListbook`/`wxChoicebook` interpret mnemonics in page titles "just as the other wx*book classes already did" | :128-130 | Orca uses neither (`BedShapeDialog` uses `wxSimplebook` + a combo); every book interprets `&` (`interface/wx/bookctrl.h:141-147`) → rule 11 |
-| `wxAUI_MGR_HINT_FADE` is not in the default `wxAuiManager` style | :132-133 | Plater's `AuiMgr` keeps the default flags (minus `wxAUI_MGR_ALLOW_FLOATING` on Wayland, `Plater::priv::priv`), so the docking hint no longer fades; add the flag if wanted |
+| `wxAUI_MGR_HINT_FADE` is not in the default `wxAuiManager` style | :132-133 | Orca's `AuiMgr` keeps the default flags (minus `wxAUI_MGR_ALLOW_FLOATING` on Wayland, `AuiMgr::init`), so the docking hint no longer fades; add the flag if wanted |
 | `wxPrintDialogData::SetAllPages(false)`/`SetSelection(false)` changed meaning | :135-137 | none |
 | `wxGetTranslation()` returns `wxString` by value | :139-142 | pitfall below |
 | `wxWindow::Raise()` no longer shows a hidden window on any port | :144-146 | pitfall below; ba867cc534 |

.gitattributes

@@ -10,3 +10,6 @@
 # resume after `call :label`. With LF endings that offset can land wrong and the
 # label lookup fails, so keep these CRLF whatever the platform.
 *.bat text eol=crlf
+
+# OCCT BRep fixtures, kept byte for byte as OCCT wrote them.
+*.brep -text

.github/workflows/build_all.yml

@@ -127,7 +127,7 @@ jobs:
     if: ${{ !cancelled() && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
     uses: ./.github/workflows/build_check_cache.yml
     with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
       arch: ${{ matrix.arch }}
       build-deps-only: ${{ inputs.build-deps-only || false }}
       force-build: ${{ github.event_name == 'schedule' }}
@@ -138,7 +138,7 @@ jobs:
     if: ${{ !cancelled() && needs.build_macos_arch.result == 'success' && !inputs.build-deps-only && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
     uses: ./.github/workflows/build_orca.yml
     with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
       arch: universal
       macos-combine-only: true
     secrets: inherit
@@ -182,7 +182,7 @@ jobs:
     if: ${{ !cancelled() && success() }}
     uses: ./.github/workflows/unit_tests.yml
     with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
+      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-15' }}
       artifact: ${{ github.sha }}-tests-macos-arm64
       test-dir: build/arm64/tests
   # Slice a two-colour cube through every shipped printer, and through every

.github/workflows/build_check_cache.yml

@@ -40,7 +40,7 @@ jobs:
           # Anything that changes how the tree is built belongs in the key, or a job
           # restores one it cannot use. Linux amd64 passes no arch deliberately, so
           # 'linux-clang' keeps the cache it already has.
-          cache-os: ${{ runner.os == 'macOS' && format('macos-{0}', inputs.arch) || (runner.os == 'Windows' && format('windows-{0}-{1}', inputs.arch, inputs.compiler) || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
+          cache-os: ${{ runner.os == 'macOS' && format('{0}-{1}', inputs.os, inputs.arch) || (runner.os == 'Windows' && format('windows-{0}-{1}', inputs.arch, inputs.compiler) || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
           # The Windows ARM64 deps build in build-arm64, all others under build;
           # build_deps.yml and build_orca.yml pass the Windows directory to build_win.bat.
           dep-folder-name: ${{ runner.os == 'macOS' && format('/{0}', inputs.arch) || (runner.os == 'Windows' && inputs.arch == 'arm64') && '-arm64/OrcaSlicer_dep' || '/OrcaSlicer_dep' }}

.github/workflows/build_deps.yml

@@ -49,28 +49,11 @@ jobs:
           key: ${{ inputs.cache-key }}
 
       - uses: lukka/get-cmake@latest
-        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
-        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
         with:
           cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
           useLocalCache: true         # <--= Use the local cache (default is 'false').
           useCloudCache: true
 
-      - name: Install CMake 3.31.x (Windows ARM64)
-        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
-        # compatibility AND has incomplete ASM_ARMASM linker modules
-        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        shell: pwsh
-        run: |
-          $ver = "3.31.6"
-          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
-          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
-          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
-          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
-          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
-          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
-
       - name: setup dev on Windows
         if: runner.os == 'Windows'
         uses: microsoft/setup-msbuild@v3

.github/workflows/build_orca.yml

@@ -54,28 +54,11 @@ jobs:
           fail-on-cache-miss: true
 
       - uses: lukka/get-cmake@latest
-        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
-        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
         with:
           cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
           useLocalCache: true         # <--= Use the local cache (default is 'false').
           useCloudCache: true
 
-      - name: Install CMake 3.31.x (Windows ARM64)
-        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
-        # compatibility AND has incomplete ASM_ARMASM linker modules
-        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        shell: pwsh
-        run: |
-          $ver = "3.31.6"
-          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
-          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
-          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
-          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
-          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
-          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
-
       # Compiler cache. Pushes save it, so main keeps it warm; pull requests
       # restore it and discard what they compiled. Objects are keyed on the
       # preprocessed source, the compiler and the flags, so a leg only ever
@@ -200,10 +183,12 @@ jobs:
       - name: Free disk space
         if: runner.os == 'macOS' && !inputs.macos-combine-only && !vars.SELF_HOSTED
         run: |
-          df -hI /dev/disk3s1s1
-          sudo find /Applications -maxdepth 1 -type d -name "Xcode_*.app" ! -name "Xcode_15.4.app" -exec rm -rf {} +
+          df -hI /
+          # Keep only the selected Xcode
+          xcode=$(basename "$(cd "$(xcode-select -p)/../.." && pwd -P)")
+          sudo find /Applications -maxdepth 1 -type d -name "Xcode_*.app" ! -name "$xcode" -exec rm -rf {} +
           sudo rm -rf ~/Library/Developer/CoreSimulator/Caches/*
-          df -hI /dev/disk3s1s1
+          df -hI /
 
       - name: Build slicer mac
         if: runner.os == 'macOS' && !inputs.macos-combine-only
@@ -276,6 +261,7 @@ jobs:
  # Thanks to RaySajuuk, it's working now
       - name: Sign app and notary
         if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
+        timeout-minutes: 30
         working-directory: ${{ github.workspace }}
         env:
           BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}

.github/workflows/clang_tidy.yml

@@ -0,0 +1,89 @@
+name: clang-tidy
+
+# Runs clang-tidy, with the checks in .clang-tidy, over the C++ lines a pull
+# request changes (scripts/clang_tidy_diff.py). The compile database is
+# configured without the precompiled header, so code that only builds because
+# the PCH supplied an include fails here.
+#
+# No paths filter: the job is a required check, and a workflow skipped by a
+# paths filter leaves a required check pending forever. A PR with no C++
+# changes finishes after the first step.
+on:
+  pull_request:
+    branches:
+      - main
+      - release/*
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  clang_tidy:
+    # Branch protection requires this check by name. Renaming the job disables
+    # that gate.
+    name: clang-tidy
+    runs-on: ${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+        with:
+          lfs: 'false'
+          # The PR merge commit plus its first parent, the base it is diffed against.
+          fetch-depth: 2
+
+      - name: Look for changed C++ files
+        id: changes
+        run: |
+          if git diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
+            echo "cpp=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "No C++ changes under src/ or tests/."
+          fi
+
+      # Parsing needs the dependency headers, not a build of this PR's deps/, so
+      # a PR that changes deps/ falls back to the newest cache main has.
+      - name: Restore cached deps
+        if: steps.changes.outputs.cpp == 'true'
+        uses: actions/cache/restore@v6
+        with:
+          path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
+          key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
+          restore-keys: linux-clang-cache-orcaslicer_deps-build-
+          fail-on-cache-miss: true
+
+      - name: Apt-Install Dependencies
+        if: steps.changes.outputs.cpp == 'true' && !vars.SELF_HOSTED
+        uses: ./.github/actions/apt-install-deps
+
+      - name: Install clang-tidy
+        if: steps.changes.outputs.cpp == 'true'
+        run: |
+          python3 -m venv "$RUNNER_TEMP/clang-tidy"
+          "$RUNNER_TEMP/clang-tidy/bin/pip" install --quiet -r scripts/clang_tidy_requirements.txt
+
+      # DEP_BUILD_DIR is named outright: CMake would otherwise derive it from the build
+      # directory's name and look for the dependencies in deps/build-tidy.
+      - name: Configure without the precompiled header
+        if: steps.changes.outputs.cpp == 'true'
+        run: >
+          cmake -S . -B build-tidy -G Ninja
+          -DCMAKE_BUILD_TYPE=Release
+          -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+          -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+          -DSLIC3R_PCH=OFF -DORCA_TOOLS=ON -DBUILD_TESTS=ON
+          -DDEP_BUILD_DIR=${{ github.workspace }}/deps/build
+
+      # The one header the build generates rather than the configure.
+      - name: Generate git_commit_hash.h
+        if: steps.changes.outputs.cpp == 'true'
+        run: cmake --build build-tidy --target git_commit_hash_header
+
+      - name: Run clang-tidy on the changed lines
+        if: steps.changes.outputs.cpp == 'true'
+        run: >
+          python3 scripts/clang_tidy_diff.py -p build-tidy --base HEAD^1
+          --clang-tidy "$RUNNER_TEMP/clang-tidy/bin/clang-tidy" -j "$(nproc)"

.github/workflows/unit_tests.yml

@@ -44,14 +44,6 @@ jobs:
         uses: actions/download-artifact@v8
         with:
           name: ${{ inputs.artifact }}
-      # run_unit_tests.sh installs the plugin tests' numpy with the uv the build stages
-      # beside them; the Windows arm64 build bundles none, so put one on PATH there.
-      - name: Install uv
-        if: runner.os == 'Windows' && runner.arch == 'ARM64'
-        uses: astral-sh/setup-uv@v10.2.0
-        with:
-          version: "0.11.21"  # ORCA_UV_VERSION in CMakeLists.txt
-          enable-cache: false
       - uses: lukka/get-cmake@latest
         with:
           cmakeVersion: "~4.3.0"  # use most recent 4.3.x version

AGENTS.md

@@ -36,6 +36,7 @@ ctest --test-dir ./tests/fff_print -C Release
 
 - C++17, selective C++20. PascalCase classes, snake_case functions/variables
 - `#pragma once` for headers. Smart pointers and RAII preferred
+- Include what you use: include the header for every symbol a file uses, and keep headers compilable on their own. Never rely on the precompiled header or a transitive include. The `clang-tidy` CI job enforces this on changed lines; run the same check locally with `scripts/run_clang_tidy.sh` (`scripts\run_clang_tidy.ps1` on Windows), which sets up everything it needs
 - Parallelization via TBB — be mindful of shared state
 - Always use `SetSizerAndFit(sizer)` instead of `SetSizer(sizer)` on top level window. Unless `SetSizer` must be called before the full layout is built, call `sizer->SetSizeHints(window)` afterwards in this case.
 

CMakeLists.txt

@@ -135,6 +135,7 @@ set(ORCA_UV_SHA256_aarch64-apple-darwin      "1f921d491ba5ffeea774eb04d6681ecee3
 set(ORCA_UV_SHA256_x86_64-apple-darwin       "f3c8e5708a84b920c18b691214d54d2b0da6b984789caae95d47c95120cb7765")
 set(ORCA_UV_SHA256_aarch64-unknown-linux-gnu "88e800834007cc5efd4675f166eb2a51e7e3ad19876d85fa8805a6fb5c922397")
 set(ORCA_UV_SHA256_x86_64-unknown-linux-gnu  "8c88519b0ef0af9801fcdee419bbb12116bd9e6b18e162ae093c932d8b264050")
+set(ORCA_UV_SHA256_aarch64-pc-windows-msvc   "74e443f8004022dde57a1bd0d10c097830f9ea8feb4ec927db52cd5d805c2f48")
 set(ORCA_UV_SHA256_x86_64-pc-windows-msvc    "ace861f360c6de2babedc1607d0f454b6b09a820dbc8182dc15af927e4df9589")
 
 # Version-scoped cache dir so a version bump invalidates the cached binary.
@@ -173,7 +174,10 @@ if(NOT ORCA_BUNDLED_UV_EXECUTABLE)
                 set(ORCA_UV_ARCH "x86_64-unknown-linux-gnu")
             endif()
         elseif(_orca_uv_proc MATCHES "aarch64|arm64|ARM64")
-            if(APPLE)
+            if(WIN32)
+                set(ORCA_UV_ARCH "aarch64-pc-windows-msvc")
+                set(ORCA_UV_EXT "zip")
+            elseif(APPLE)
                 set(ORCA_UV_ARCH "aarch64-apple-darwin")
             else()
                 set(ORCA_UV_ARCH "aarch64-unknown-linux-gnu")
@@ -819,7 +823,9 @@ if(SLIC3R_STATIC)
     set(TBB_STATIC 1)
 endif()
 set(TBB_DEBUG 1)
-set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release "")
+if ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" OR MSVC)
+    set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release "")
+endif()
 find_package(TBB REQUIRED)
 # include_directories(SYSTEM ${TBB_INCLUDE_DIRS})
 # add_definitions(${TBB_DEFINITIONS})
@@ -1125,7 +1131,8 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
     if (NOT OCCT_LIBS)
         message(FATAL_ERROR "OCCT_LIBS is not set; libslic3r must be configured first.")
     endif ()
-    set(_occt_bin "${CMAKE_PREFIX_PATH}/bin/occt")
+    string(TOUPPER "${config}" _config_upper)
+    set(_occt_bin "${OCCT_BIN_DIR_${_config_upper}}")
     set(_occt_dlls "")
     set(_occt_staged "")
     set(_missing_occt "")
@@ -1301,6 +1308,14 @@ if (WIN32)
     endif()
     set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
     include(InstallRequiredSystemLibraries)
+    # A missing MSVC runtime is an error because an installer without it cannot start on a clean machine.
+    set(_orca_runtime_names ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS})
+    list(TRANSFORM _orca_runtime_names REPLACE "^.*/" "")
+    if (MSVC AND (NOT "msvcp140.dll" IN_LIST _orca_runtime_names OR NOT "vcruntime140.dll" IN_LIST _orca_runtime_names))
+        set(_orca_runtime_error "CMake ${CMAKE_VERSION} did not find msvcp140.dll and vcruntime140.dll for MSVC ${MSVC_VERSION}. Update CMake to a release that supports this Visual Studio.")
+        message(WARNING "${_orca_runtime_error}")
+        install(CODE "message(FATAL_ERROR \"${_orca_runtime_error}\")")
+    endif ()
     install (PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION ".")
 elseif (SLIC3R_FHS)
     # CMAKE_INSTALL_FULL_DATAROOTDIR: read-only architecture-independent data root (share)

build_win.bat

@@ -282,11 +282,7 @@ if "%install_deps%" == "ON" (
         call :note_failed "Visual Studio" !errorlevel!
     )
 
-    REM CMake 4 dropped pre-3.5 policy support and ships incomplete ASM_ARMASM
-    REM linker modules, which breaks Boost.Context on ARM64. CI pins the same way.
-    set "cmake_version_flag="
-    if /I "%arch%" == "ARM64" set "cmake_version_flag=--version 3.31.8"
-    call :print_and_run winget install !winget_args! --id=Kitware.CMake !cmake_version_flag!
+    call :print_and_run winget install !winget_args! --id=Kitware.CMake
     call :note_failed CMake !errorlevel!
     call :print_and_run winget install !winget_args! --id=StrawberryPerl.StrawberryPerl
     call :note_failed Perl !errorlevel!

deps/OCCT/0001-OCCT-fix.patch

@@ -1,264 +0,0 @@
-diff --git a/adm/cmake/occt_defs_flags.cmake b/adm/cmake/occt_defs_flags.cmake
-index 00000000..00000001 100644
---- a/adm/cmake/occt_defs_flags.cmake
-+++ b/adm/cmake/occt_defs_flags.cmake
-@@ -134,7 +134,11 @@
-     set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
-   endif()
-   # Optimize size of binaries
--  set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
-+  # clang-cl reports the Clang compiler ID, and OCCT builds shared on Windows,
-+  # where the MSVC-style linker gets this flag as an argument it does not know.
-+  if (NOT WIN32)
-+    set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
-+  endif()
- elseif(MINGW)
-   add_definitions(-D_WIN32_WINNT=0x0601)
-   # _WIN32_WINNT=0x0601 (use Windows 7 SDK)
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index d98acc0f..28eb8eb4 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -225,7 +225,7 @@ if (NOT DEFINED INSTALL_DIR_BIN)
-   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
-     set (INSTALL_DIR_BIN "bin" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
-   else()
--    set (INSTALL_DIR_BIN "${OS_WITH_BIT}/${COMPILER}/bin" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
-+    set (INSTALL_DIR_BIN "bin/occt" CACHE PATH "${INSTALL_DIR_BIN_DESCR}")
-   endif()
- endif()
- 
-@@ -243,11 +243,11 @@ if (NOT DEFINED INSTALL_DIR_LIB)
-   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
-     set (INSTALL_DIR_LIB "lib" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
-   else()
--    set (INSTALL_DIR_LIB "${OS_WITH_BIT}/${COMPILER}/lib" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
-+    set (INSTALL_DIR_LIB "lib/occt" CACHE PATH "${INSTALL_DIR_LIB_DESCR}")
-   endif()
- endif()
- 
--# OCCT headers: <prefix>/inc for windows,
-+# OCCT headers: <prefix>/include for windows,
- #               <prefix>/include/opencascade-7.0.0 for unix
- if (NOT DEFINED INSTALL_DIR_INCLUDE)
-   if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
-@@ -256,7 +256,7 @@ if (NOT DEFINED INSTALL_DIR_INCLUDE)
-       set (INSTALL_DIR_INCLUDE "include/opencascade-${OCC_VERSION_STRING_EXT}" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}" FORCE)
-     endif()
-   else()
--    set (INSTALL_DIR_INCLUDE "inc" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}")
-+    set (INSTALL_DIR_INCLUDE "include/occt" CACHE PATH "${INSTALL_DIR_INCLUDE_DESCR}")
-   endif()
- endif()
- 
-@@ -330,7 +330,7 @@ if (NOT DEFINED INSTALL_DIR_CMAKE)
-       set (INSTALL_DIR_CMAKE "lib/cmake/opencascade" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
-     endif()
-   else()
--    set (INSTALL_DIR_CMAKE "cmake" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
-+    set (INSTALL_DIR_CMAKE "lib/cmake/occt" CACHE PATH "${INSTALL_DIR_CMAKE_DESCR}")
-   endif()
- endif()
- 
-@@ -338,13 +338,13 @@ endif()
- OCCT_INCLUDE_CMAKE_FILE ("adm/cmake/occt_resources")
- 
- # install LICENSE_LGPL_21.txt and OCCT_LGPL_EXCEPTION.txt files
--if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
--  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR_DOC}")
--  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR_DOC}")
--else()
--  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" ".")
--  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" ".")
--endif()
-+#if ("${INSTALL_DIR_LAYOUT}" STREQUAL "Unix")
-+#  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" "${INSTALL_DIR_DOC}")
-+#  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" "${INSTALL_DIR_DOC}")
-+#else()
-+#  OCCT_INSTALL_FILE_OR_DIR ("LICENSE_LGPL_21.txt" ".")
-+#  OCCT_INSTALL_FILE_OR_DIR ("OCCT_LGPL_EXCEPTION.txt" ".")
-+#endif()
- 
- if(APPLE)
-   set (INSTALL_NAME_DIR "" CACHE STRING "install_name library suffix on OS X (e.g. @executable_path/../Frameworks)")
-@@ -850,34 +850,34 @@ endif()
- 
- # build directories
- if (SINGLE_GENERATOR)
--  set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib${BIN_LETTER}")
--  set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin${BIN_LETTER}")
--  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib${BIN_LETTER}")
-+  set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/occt")
-+  set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/occt")
-+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/occt")
-   if (WIN32)
--    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin${BIN_LETTER}")
-+    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/occt")
-   endif()
- endif()
- 
--set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib")
--set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin")
--set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/lib")
-+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/lib/occt")
-+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/bin/occt")
-+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}/lib/occt")
- 
--set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libi")
--set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bini")
--set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libi")
-+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/lib/occt/RelWithDebInfo")
-+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/bin/occt/RelWithDebInfo")
-+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/lib/occt/RelWithDebInfo")
- 
--set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libd")
--set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind")
--set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/libd")
-+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/lib/occt/Debug")
-+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/bin/occt/Debug")
-+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}/lib/occt/Debug")
- 
- if (WIN32)
--  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE        "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin")
--  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bini")
--  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG          "${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bind")
-+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE        "${CMAKE_BINARY_DIR}/bin/occt")
-+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}/bin/occt/RelWithDebInfo")
-+  set (CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG          "${CMAKE_BINARY_DIR}/bin/occt/Debug")
- endif()
- 
- string(TIMESTAMP CURRENT_TIME "%H:%M:%S")
--message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT header files into ${CMAKE_BINARY_DIR}/inc ...")
-+message (STATUS "\nInfo: \(${CURRENT_TIME}\) Start collecting all OCCT header files into ${CMAKE_BINARY_DIR}/include/occt ...")
- 
- # collect all the headers to <binary dir>/inc folder
- COLLECT_AND_INSTALL_OCCT_HEADER_FILES ("${CMAKE_BINARY_DIR}" "${BUILD_TOOLKITS}" "${CMAKE_SOURCE_DIR}/src" "${INSTALL_DIR_INCLUDE}")
-@@ -984,9 +984,9 @@ if (EXISTS "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}")
- 
-   set (CUSTOM_CONTENT "${CUSTOM_CONTENT} ${ADDITIONAL_CUSTOM_CONTENT}")
- 
--  file (WRITE "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
-+  #file (WRITE "${INSTALL_DIR}/${INSTALL_DIR_SCRIPT}/custom.${SCRIPT_EXT}" "${CUSTOM_CONTENT}")
- else()
--  OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR_SCRIPT}")
-+  #OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.${SCRIPT_EXT}.main" "custom.${SCRIPT_EXT}" "custom.${SCRIPT_EXT}" "${INSTALL_DIR_SCRIPT}")
- endif()
- 
- if (WIN32)
-@@ -1007,7 +1007,7 @@ endforeach()
- 
- # write current custom.bat/sh (for install directory)
- set (SUB_CUSTOM_BUILD_NAME "custom_${COMPILER}_${COMPILER_BITNESS}.install.${SCRIPT_EXT}")
--OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR_SCRIPT}")
-+#OCCT_CONFIGURE_AND_INSTALL ("adm/templates/custom.install.${SCRIPT_EXT}.in" "${SUB_CUSTOM_BUILD_NAME}" "${SUB_CUSTOM_NAME}" "${INSTALL_DIR_SCRIPT}")
- 
- # write current custom.bat/sh (for build directory)
- OCCT_CONFIGURE ("adm/templates/custom.build.${SCRIPT_EXT}.in" "${SUB_CUSTOM_NAME}")
-@@ -1019,9 +1019,9 @@ endif()
- 
- if (WIN32)
-   # env script for draw in building environment
--  OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
-+  #OCCT_CONFIGURE ("adm/templates/env.${SCRIPT_EXT}.in" "env.${SCRIPT_EXT}")
-   # install env script
--  install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SCRIPT}")
-+  #install (FILES "${CMAKE_BINARY_DIR}/env.${SCRIPT_EXT}" DESTINATION "${INSTALL_DIR_SCRIPT}")
-   # copy build.bat and install.bat scripts to CMake binary folder
-   OCCT_COPY_FILE_OR_DIR ("adm/templates/build.bat" "${CMAKE_BINARY_DIR}")
-   OCCT_COPY_FILE_OR_DIR ("adm/templates/install.bat" "${CMAKE_BINARY_DIR}")
-@@ -1043,12 +1043,12 @@ endif()
- FILE_TO_LIST ("adm/RESOURCES" RESOURCES)
- foreach(RESOURCE ${RESOURCES})
-   get_filename_component(RESOURCE_FOLDER ${RESOURCE} DIRECTORY)
--  if(NOT "${RESOURCE_FOLDER}" STREQUAL "")
--    get_filename_component(RESOURCE_FOLDER ${RESOURCE_FOLDER} NAME)
--    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
--  else()
--    OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}")
--  endif()
-+  #if(NOT "${RESOURCE_FOLDER}" STREQUAL "")
-+  #  get_filename_component(RESOURCE_FOLDER ${RESOURCE_FOLDER} NAME)
-+  #  OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}/${RESOURCE_FOLDER}")
-+  #else()
-+  #  OCCT_INSTALL_FILE_OR_DIR ("src/${RESOURCE}" "${INSTALL_DIR_RESOURCE}")
-+  #endif()
- endforeach()
- 
- if (BUILD_SAMPLES_QT)
-diff --git a/adm/cmake/occt_macros.cmake b/adm/cmake/occt_macros.cmake
-index 224c96b1..8c94a1c5 100644
---- a/adm/cmake/occt_macros.cmake
-+++ b/adm/cmake/occt_macros.cmake
-@@ -608,7 +608,7 @@ macro (OCCT_INSERT_CODE_FOR_TARGET)
-   install(CODE "if (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$\")
-     set (OCCT_INSTALL_BIN_LETTER \"\")
-   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ww][Ii][Tt][Hh][Dd][Ee][Bb][Ii][Nn][Ff][Oo])$\")
--    set (OCCT_INSTALL_BIN_LETTER \"i\")
-+    set (OCCT_INSTALL_BIN_LETTER \"\")
-   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Dd][Ee][Bb][Uu][Gg])$\")
-     set (OCCT_INSTALL_BIN_LETTER \"d\")
-   endif()")
-diff --git a/adm/cmake/occt_toolkit.cmake b/adm/cmake/occt_toolkit.cmake
-index 550e0e2f..7ac1a3b8 100644
---- a/adm/cmake/occt_toolkit.cmake
-+++ b/adm/cmake/occt_toolkit.cmake
-@@ -241,7 +241,7 @@
-     else()
-       set (aReleasePdbConf)
-     endif()
--    install (FILES  ${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin\${OCCT_INSTALL_BIN_LETTER}/${PROJECT_NAME}.pdb
-+    install (FILES  $<TARGET_PDB_FILE:${PROJECT_NAME}>
-              CONFIGURATIONS Debug ${aReleasePdbConf} RelWithDebInfo
-              DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
-   endif()
-diff --git a/src/Font/Font_FTFont.cxx b/src/Font/Font_FTFont.cxx
-index 5ae9899f..0a17372b 100644
---- a/src/Font/Font_FTFont.cxx
-+++ b/src/Font/Font_FTFont.cxx
-@@ -103,9 +103,11 @@ bool Font_FTFont::Init (const Handle(NCollection_Buffer)& theData,
-   {
-     throw Standard_ProgramError ("Font_FTFont, Light and Normal hinting styles are mutually exclusive");
-   }
-+#ifdef HAVE_FREETYPE
-   setLoadFlag (FT_LOAD_TARGET_LIGHT,   (theParams.FontHinting & Font_Hinting_Light) != 0);
-   setLoadFlag (FT_LOAD_NO_HINTING,     (theParams.FontHinting & Font_Hinting_Normal) == 0
-                                     && (theParams.FontHinting & Font_Hinting_Light)  == 0);
-+#endif
- 
-   // manage native / autohinting
-   if ((theParams.FontHinting & Font_Hinting_ForceAutohint) != 0
-@@ -113,8 +115,10 @@ bool Font_FTFont::Init (const Handle(NCollection_Buffer)& theData,
-   {
-     throw Standard_ProgramError ("Font_FTFont, ForceAutohint and NoAutohint are mutually exclusive");
-   }
-+#ifdef HAVE_FREETYPE
-   setLoadFlag (FT_LOAD_FORCE_AUTOHINT, (theParams.FontHinting & Font_Hinting_ForceAutohint) != 0);
-   setLoadFlag (FT_LOAD_NO_AUTOHINT,    (theParams.FontHinting & Font_Hinting_NoAutohint) != 0);
-+#endif
- 
-   if (!myFTLib->IsValid())
-   {
-From 7236e83dcc1e7284e66dc61e612154617ef715d6 Mon Sep 17 00:00:00 2001
-From: dpasukhi <dpasukhi@opencascade.com>
-Date: Tue, 27 Aug 2024 11:33:29 +0100
-Subject: [PATCH] 0033808: Coding - FreeType Use unsigned point and contour
- indexing in `FT_Outline`
-
-Changes to auto instead of specific type
----
- src/StdPrs/StdPrs_BRepFont.cxx | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/StdPrs/StdPrs_BRepFont.cxx b/src/StdPrs/StdPrs_BRepFont.cxx
-index ab2d9b3c9f..cd701879b1 100644
---- a/src/StdPrs/StdPrs_BRepFont.cxx
-+++ b/src/StdPrs/StdPrs_BRepFont.cxx
-@@ -457,7 +457,7 @@ Standard_Boolean StdPrs_BRepFont::renderGlyph (const Standard_Utf32Char theChar,
-   for (short aContour = 0, aStartIndex = 0; aContour < anOutline->n_contours; ++aContour)
-   {
-     const FT_Vector* aPntList = &anOutline->points[aStartIndex];
--    const char* aTags      = &anOutline->tags[aStartIndex];
-+    const auto* aTags      = &anOutline->tags[aStartIndex];
-     const short anEndIndex = anOutline->contours[aContour];
-     const short aPntsNb    = (anEndIndex - aStartIndex) + 1;
-     aStartIndex = anEndIndex + 1;

deps/OCCT/OCCT.cmake

@@ -1,5 +1,5 @@
-# clang-cl cannot emit IGESAppli_GeneralModule.cxx on ARM64
-# (llvm/llvm-project#62081). cl and clang-cl share an ABI.
+# clang-cl cannot emit some OCCT sources for ARM64 (llvm/llvm-project#62081).
+# cl and clang-cl share an ABI.
 set(_occt_compiler_args "")
 if ("${DEPS_ARCH}" STREQUAL "arm64" AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
     set(_occt_compiler_args -DCMAKE_C_COMPILER:STRING=cl -DCMAKE_CXX_COMPILER:STRING=cl)
@@ -15,31 +15,31 @@ endif()
 # (fillet/offset/loft), whose only consumer is the parametric Design/CAD tab. With it OFF
 # the deps prefix matches upstream exactly.
 #
-# With it ON the delta is THREE toolkits, not two: TKFillet (7.40 MiB archive, used via
-# BRepFilletAPI), TKOffset (5.38 MiB, used via BRepOffsetAPI) and TKFeat (4.42 MiB), which
-# nothing here references but which the module flag builds anyway -- it is all-or-nothing
-# per module. The module's other nine toolkits are built either way, because DataExchange
-# (the STEP path upstream already ships) depends on them.
+# With it ON OCCT also builds TKFillet (used via BRepFilletAPI), TKOffset (used via
+# BRepOffsetAPI), and TKFeat, TKHelix, TKXMesh and TKExpress, which nothing here references
+# but which the module flag builds anyway, since module flags are all-or-nothing. The
+# module's other toolkits are built either way, because DataExchange (the STEP path)
+# depends on them.
 #
 # On macOS/Linux OCCT links statically, so an unreferenced toolkit costs build time and no
-# shipped bytes. The Windows figure is a real DLL cost and has NOT been measured -- an
-# earlier "3.77 MiB, Windows only" note here covered only two of the three toolkits and is
-# not a number to quote. See docs/HLSD/design-tab.md.
-
-if (IN_GIT_REPO)
-    set(OCCT_DIRECTORY_FLAG --directory ${BINARY_DIR_REL}/dep_OCCT-prefix/src/dep_OCCT)
-endif ()
+# shipped bytes. Windows ships only the DLLs libslic3r links, so the tab adds the TKFillet,
+# TKOffset and TKBool DLLs. See docs/HLSD/design-tab.md.
 
 orcaslicer_add_cmake_project(OCCT
-    URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V7_6_0.zip
-    URL_HASH SHA256=28334f0e98f1b1629799783e9b4d21e05349d89e695809d7e6dfa45ea43e1dbc
-    #PATCH_COMMAND ${PATCH_CMD} ${CMAKE_CURRENT_LIST_DIR}/0001-OCCT-fix.patch
-    PATCH_COMMAND git apply ${OCCT_DIRECTORY_FLAG} --verbose --ignore-space-change --whitespace=fix ${CMAKE_CURRENT_LIST_DIR}/0001-OCCT-fix.patch
+    URL https://github.com/Open-Cascade-SAS/OCCT/archive/refs/tags/V8_0_1.zip
+    URL_HASH SHA256=7c033d917ee8f040c0512d289dcc5f02c148889d5bac17c3e25639accb44f0da
     #DEPENDS dep_Boost
     DEPENDS ${FREETYPE_PKG}
     CMAKE_ARGS
         -DCMAKE_CXX_STANDARD=17
         -DBUILD_LIBRARY_TYPE=${library_build_type}
+        # With the Unix layout, OCCT's resources and licenses go under share/ and its scripts
+        # into bin/occt on Windows too. libslic3r finds the CMake package in lib/cmake/occt.
+        -DINSTALL_DIR_LAYOUT=Unix
+        -DINSTALL_DIR_BIN=bin/occt
+        -DINSTALL_DIR_LIB=lib/occt
+        -DINSTALL_DIR_INCLUDE=include/occt
+        -DINSTALL_DIR_CMAKE=lib/cmake/occt
         -DUSE_TK=OFF
         -DUSE_TBB=OFF
 	#-DUSE_FREETYPE=OFF

deps/OpenSSL/OpenSSL.cmake

@@ -29,6 +29,15 @@ if(WIN32)
     # driven through nmake from a Ninja configure step.
     set(_conf_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} perl Configure )
     set(_cross_comp_prefix_line "")
+    if("${DEPS_ARCH}" STREQUAL "arm64")
+        # OpenSSL's VC configs pass /Gs0, which puts a __chkstk probe in every
+        # function. MSVC 14.51 and 14.52 (VS 2026) for ARM64 emit that call
+        # before the prologue saves LR, so the function returns into itself;
+        # in tls_parse_all_extensions that breaks every TLS handshake. 14.44
+        # (VS 2022) is unaffected. Restore cl's default threshold: Configure
+        # appends /Gs4096 after /Gs0, and the later option wins.
+        set(_openssl_extra_cflags /Gs4096)
+    endif()
     set(_make_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake)
     set(_install_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake install_sw )
 else()
@@ -71,6 +80,7 @@ ExternalProject_Add(dep_OpenSSL
         # prefix stays single-layout.
         "--libdir=lib"
         ${_cross_comp_prefix_line}
+        ${_openssl_extra_cflags}
         no-shared
         no-asm
         no-ssl3-method

deps_src/CMakeLists.txt

@@ -15,7 +15,6 @@ add_subdirectory(stb_dxt)     # Header-only STB DXT compression library
 # Static libraries
 add_subdirectory(Shiny)
 add_subdirectory(admesh)
-add_subdirectory(clipper)
 add_subdirectory(clipper2)
 add_subdirectory(expat)
 add_subdirectory(glu-libtess)

deps_src/admesh/stlinit.cpp

@@ -75,6 +75,19 @@ static FILE *stl_open_count_facets(stl_file *stl, const char *file, unsigned int
       		break;
     	}
   	}
+  	// Zero normals and coordinates like 10 or 15 have no byte above 127, so the test above can miss a binary file.
+  	// Its size still matches its facet count; text read as that count would need a file of gigabytes.
+  	if (stl->stats.type == ascii) {
+    	uint32_t header_num_facets;
+    	fseek(fp, custom_header_length, SEEK_SET);
+    	if (fread(&header_num_facets, sizeof(uint32_t), 1, fp) == 1) {
+#if BOOST_ENDIAN_BIG_BYTE
+      		stl_internal_reverse_quads((char*)&header_num_facets, 4);
+#endif /* BOOST_ENDIAN_BIG_BYTE */
+      		if (header_size + uint64_t(header_num_facets) * SIZEOF_STL_FACET == file_size)
+        		stl->stats.type = binary;
+    	}
+  	}
   	rewind(fp);
 
   	uint32_t num_facets = 0;

deps_src/clipper/CMakeLists.txt

@@ -1,20 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-project(clipper)
-
-add_library(clipper STATIC
-# We are using ClipperLib compiled as part of the libslic3r project using Slic3r::Point as its base type.
-#    clipper.cpp
-#    clipper.hpp
-    clipper_z.cpp
-    clipper_z.hpp
-)
-
-target_include_directories(clipper SYSTEM
-    PUBLIC
-        ${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-target_link_libraries(clipper 
-    PUBLIC Eigen3::Eigen
-    PRIVATE TBB::tbb TBB::tbbmalloc
-)

deps_src/clipper/clipper.hpp

@@ -1,606 +0,0 @@
-/*******************************************************************************
-*                                                                              *
-* Author    :  Angus Johnson                                                   *
-* Version   :  6.4.2                                                           *
-* Date      :  27 February 2017                                                *
-* Website   :  http://www.angusj.com                                           *
-* Copyright :  Angus Johnson 2010-2017                                         *
-*                                                                              *
-* License:                                                                     *
-* Use, modification & distribution is subject to Boost Software License Ver 1. *
-* http://www.boost.org/LICENSE_1_0.txt                                         *
-*                                                                              *
-* Attributions:                                                                *
-* The code in this library is an extension of Bala Vatti's clipping algorithm: *
-* "A generic solution to polygon clipping"                                     *
-* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
-* http://portal.acm.org/citation.cfm?id=129906                                 *
-*                                                                              *
-* Computer graphics and geometric modeling: implementation and algorithms      *
-* By Max K. Agoston                                                            *
-* Springer; 1 edition (January 4, 2005)                                        *
-* http://books.google.com/books?q=vatti+clipping+agoston                       *
-*                                                                              *
-* See also:                                                                    *
-* "Polygon Offsetting by Computing Winding Numbers"                            *
-* Paper no. DETC2005-85513 pp. 565-575                                         *
-* ASME 2005 International Design Engineering Technical Conferences             *
-* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
-* September 24-28, 2005 , Long Beach, California, USA                          *
-* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
-*                                                                              *
-*******************************************************************************/
-
-#ifndef clipper_hpp
-#define clipper_hpp
-
-#include <inttypes.h>
-#include <functional>
-
-#include <Eigen/Geometry> 
-
-#include <oneapi/tbb/scalable_allocator.h>
-
-#define CLIPPER_VERSION "6.2.6"
-
-//CLIPPERLIB_USE_XYZ: adds a Z member to IntPoint. Adds a minor cost to perfomance.
-//#define CLIPPERLIB_USE_XYZ
-
-//use_lines: Enables line clipping. Adds a very minor cost to performance.
-#define use_lines
-  
-//use_deprecated: Enables temporary support for the obsolete functions
-//#define use_deprecated  
-
-#include <array>
-#include <vector>
-#include <deque>
-#include <stdexcept>
-#include <cstring>
-#include <cstdlib>
-#include <ostream>
-#include <functional>
-#include <queue>
-
-#ifdef CLIPPERLIB_NAMESPACE_PREFIX
-  namespace CLIPPERLIB_NAMESPACE_PREFIX {
-#endif // CLIPPERLIB_NAMESPACE_PREFIX
-
-#ifdef CLIPPERLIB_USE_XYZ
-  namespace ClipperLib_Z {
-#else
-  namespace ClipperLib {
-#endif
-
-enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
-enum PolyType { ptSubject, ptClip };
-//By far the most widely used winding rules for polygon filling are
-//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
-//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
-//see http://glprogramming.com/red/chapter11.html
-enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
-
-// If defined, Clipper will work with 32bit signed int coordinates to reduce memory
-// consumption and to speed up exact orientation predicate calculation.
-// In that case, coordinates and their differences (vectors of the coordinates) have to fit int32_t.
-// #define CLIPPERLIB_INT32
-
-// Point coordinate type
-#ifdef CLIPPERLIB_INT32
-  // Coordinates and their differences (vectors of the coordinates) have to fit int32_t.
-  using cInt = int32_t;
-  using CrossProductType = int64_t;
-#else
-  using cInt = int64_t;
-  using CrossProductType = double;
-  // Maximum cInt value to allow a cross product calculation using 32bit expressions.
-  static constexpr cInt const loRange = 0x3FFFFFFF; // 0x3FFFFFFF = 1 073 741 823
-  // Maximum allowed cInt value.
-  static constexpr cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
-#endif // CLIPPERLIB_INT32
-
-#ifdef CLIPPERLIB_INTPOINT_TYPE
-using IntPoint = CLIPPERLIB_INTPOINT_TYPE;
-#else // CLIPPERLIB_INTPOINT_TYPE
-using IntPoint = Eigen::Matrix<cInt, 
-#ifdef CLIPPERLIB_USE_XYZ
-  3
-#else // CLIPPERLIB_USE_XYZ
-  2
-#endif // CLIPPERLIB_USE_XYZ
-  , 1, Eigen::DontAlign>;
-#endif // CLIPPERLIB_INTPOINT_TYPE
-
-using DoublePoint = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>;
-
-//------------------------------------------------------------------------------
-
-template<typename BaseType>
-using Allocator = tbb::scalable_allocator<BaseType>;
-//using Allocator = std::allocator<BaseType>;
-using Path      = std::vector<IntPoint, Allocator<IntPoint>>;
-using Paths     = std::vector<Path, Allocator<Path>>;
-
-inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;}
-inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;}
-
-std::ostream& operator <<(std::ostream &s, const IntPoint &p);
-std::ostream& operator <<(std::ostream &s, const Path &p);
-std::ostream& operator <<(std::ostream &s, const Paths &p);
-
-//------------------------------------------------------------------------------
-
-#ifdef CLIPPERLIB_USE_XYZ
-typedef std::function<void(const IntPoint& e1bot, const IntPoint& e1top, const IntPoint& e2bot, const IntPoint& e2top, IntPoint& pt)> ZFillCallback;
-#endif
-
-enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
-enum JoinType {jtSquare, jtRound, jtMiter};
-enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
-
-class PolyNode;
-typedef std::vector<PolyNode*, Allocator<PolyNode*>> PolyNodes;
-
-class PolyNode 
-{ 
-public:
-    PolyNode() : Parent(0), Index(0), m_IsOpen(false) {}
-    virtual ~PolyNode(){};
-    Path Contour;
-    PolyNodes Childs;
-    PolyNode* Parent;
-    // Traversal of the polygon tree in a depth first fashion.
-    PolyNode* GetNext() const { return Childs.empty() ? GetNextSiblingUp() : Childs.front(); }
-    bool IsHole() const;
-    bool IsOpen() const { return m_IsOpen; }  
-    int  ChildCount() const { return (int)Childs.size(); }
-private:
-    unsigned Index; //node index in Parent.Childs
-    bool m_IsOpen;
-    JoinType m_jointype;
-    EndType m_endtype;
-    PolyNode* GetNextSiblingUp() const { return Parent ? ((Index == Parent->Childs.size() - 1) ? Parent->GetNextSiblingUp() : Parent->Childs[Index + 1]) : nullptr; }
-    void AddChild(PolyNode& child);
-    friend class Clipper; //to access Index
-    friend class ClipperOffset;
-    friend class PolyTree; //to implement the PolyTree::move operator
-};
-
-class PolyTree: public PolyNode
-{ 
-public:
-    PolyTree() {}
-    PolyTree(PolyTree &&src) { *this = std::move(src); }
-    virtual ~PolyTree(){Clear();};
-    PolyTree& operator=(PolyTree &&src) { 
-        AllNodes   = std::move(src.AllNodes);
-        Contour    = std::move(src.Contour);
-        Childs     = std::move(src.Childs);
-        Parent     = nullptr;
-        Index      = src.Index;
-        m_IsOpen   = src.m_IsOpen;
-        m_jointype = src.m_jointype;
-        m_endtype  = src.m_endtype;
-        for (size_t i = 0; i < Childs.size(); ++ i)
-          Childs[i]->Parent = this;
-        return *this; 
-    }
-    PolyNode* GetFirst() const { return Childs.empty() ? nullptr : Childs.front(); }
-    void Clear() {  AllNodes.clear(); Childs.clear(); }
-    int Total() const;
-    void RemoveOutermostPolygon();
-private:
-    PolyTree(const PolyTree &src) = delete;
-    PolyTree& operator=(const PolyTree &src) = delete;
-    std::vector<PolyNode, Allocator<PolyNode>> AllNodes;
-    friend class Clipper; //to access AllNodes
-};
-
-double Area(const Path &poly);
-inline bool Orientation(const Path &poly) { return Area(poly) >= 0; }
-int PointInPolygon(const IntPoint &pt, const Path &path);
-
-// Union with "strictly simple" fix enabled.
-Paths SimplifyPolygon(const Path &in_poly, PolyFillType fillType = pftNonZero, bool strictly_simple = true);
-
-void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
-void CleanPolygon(Path& poly, double distance = 1.415);
-void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415);
-void CleanPolygons(Paths& polys, double distance = 1.415);
-
-void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
-void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
-void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
-
-void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
-void PolyTreeToPaths(PolyTree&& polytree, Paths& paths);
-void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths);
-void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths);
-
-void ReversePath(Path& p);
-void ReversePaths(Paths& p);
-
-struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };
-
-//enums that are used internally ...
-enum EdgeSide { esLeft = 1, esRight = 2};
-
-// namespace Internal {
-  //forward declarations (for stuff used internally) ...
-  struct TEdge {
-    // Bottom point of this edge (with minimum Y).
-    IntPoint Bot;
-    // Current position.
-    IntPoint Curr;
-    // Top point of this edge (with maximum Y).
-    IntPoint Top;
-    // Slope (dx/dy). For horiontal edges, the slope is set to HORIZONTAL (-1.0E+40).
-    double Dx;
-    PolyType PolyTyp;
-    EdgeSide Side;
-    // Winding number delta. 1 or -1 depending on winding direction, 0 for open paths and flat closed paths.
-    int WindDelta;
-    int WindCnt;
-    int WindCnt2; //winding count of the opposite polytype
-    int OutIdx;
-    // Next edge in the input path.
-    TEdge *Next;
-    // Previous edge in the input path.
-    TEdge *Prev;
-    // Next edge in the Local Minima List chain.
-    TEdge *NextInLML;
-    TEdge *NextInAEL;
-    TEdge *PrevInAEL;
-    TEdge *NextInSEL;
-    TEdge *PrevInSEL;
-  };
-
-  struct IntersectNode {
-    IntersectNode(TEdge *Edge1, TEdge *Edge2, IntPoint Pt) :
-      Edge1(Edge1), Edge2(Edge2), Pt(Pt) {}
-    TEdge          *Edge1;
-    TEdge          *Edge2;
-    IntPoint        Pt;
-  };
-
-  struct LocalMinimum {
-    cInt          Y;
-    TEdge        *LeftBound;
-    TEdge        *RightBound;
-  };
-
-  // Point of an output polygon.
-  // 36B on 64bit system without CLIPPERLIB_USE_XYZ.
-  struct OutPt {
-    // 4B
-    int       Idx;
-    // 16B without CLIPPERLIB_USE_XYZ / 24B with CLIPPERLIB_USE_XYZ
-    IntPoint  Pt;
-    // 4B on 32bit system, 8B on 64bit system
-    OutPt    *Next;
-    // 4B on 32bit system, 8B on 64bit system
-    OutPt    *Prev;
-  };
-
-  using OutPts = std::vector<OutPt, Allocator<OutPt>>;
-
-  // Output polygon.
-  struct OutRec {
-      int       Idx;
-      bool      IsHole;
-      bool      IsOpen;
-      //The 'FirstLeft' field points to another OutRec that contains or is the
-      //'parent' of OutRec. It is 'first left' because the ActiveEdgeList (AEL) is
-      //parsed left from the current edge (owning OutRec) until the owner OutRec
-      //is found. This field simplifies sorting the polygons into a tree structure
-      //which reflects the parent/child relationships of all polygons.
-      //This field should be renamed Parent, and will be later.
-      OutRec* FirstLeft;
-      // Used only by void Clipper::BuildResult2(PolyTree& polytree)
-      PolyNode* PolyNd;
-      // Linked list of output points, dynamically allocated.
-      OutPt* Pts;
-      OutPt* BottomPt;
-  };
-
-  struct Join {
-    Join(OutPt *OutPt1, OutPt *OutPt2, IntPoint OffPt) :
-      OutPt1(OutPt1), OutPt2(OutPt2), OffPt(OffPt) {}
-    OutPt    *OutPt1;
-    OutPt    *OutPt2;
-    IntPoint  OffPt;
-  };
-// }; // namespace Internal
-
-//------------------------------------------------------------------------------
-
-//ClipperBase is the ancestor to the Clipper class. It should not be
-//instantiated directly. This class simply abstracts the conversion of sets of
-//polygon coordinates into edge objects that are stored in a LocalMinima list.
-class ClipperBase
-{
-public:
-  ClipperBase() : 
-#ifndef CLIPPERLIB_INT32
-    m_UseFullRange(false), 
-#endif // CLIPPERLIB_INT32
-    m_HasOpenPaths(false) {}
-  ~ClipperBase() { Clear(); }
-  bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
-
-  template<typename PathsProvider>
-  bool AddPaths(PathsProvider &&paths_provider, PolyType PolyTyp, bool Closed)
-  {
-    size_t num_paths = paths_provider.size();
-    if (num_paths == 0)
-        return false;
-    if (num_paths == 1)
-        return AddPath(*paths_provider.begin(), PolyTyp, Closed);
-
-    std::vector<int, Allocator<int>> num_edges(num_paths, 0);
-    int num_edges_total = 0;
-    size_t i = 0;
-    for (const Path &pg : paths_provider) {
-      // Remove duplicate end point from a closed input path.
-      // Remove duplicate points from the end of the input path.
-      int highI = (int)pg.size() -1;
-      if (Closed) 
-        while (highI > 0 && (pg[highI] == pg[0])) 
-          --highI;
-      while (highI > 0 && (pg[highI] == pg[highI -1])) 
-        --highI;
-      if ((Closed && highI < 2) || (!Closed && highI < 1))
-        highI = -1;
-      num_edges[i ++] = highI + 1;
-      num_edges_total += highI + 1;
-    }
-    if (num_edges_total == 0)
-      return false;
-
-    // Allocate a new edge array.
-    std::vector<TEdge, Allocator<TEdge>> edges(num_edges_total);
-    // Fill in the edge array.
-    bool result = false;
-    TEdge *p_edge = edges.data();
-    i = 0;
-    for (const Path &pg : paths_provider) {
-      if (num_edges[i] && !pg.empty()) {
-        bool res = AddPathInternal(pg, num_edges[i] - 1, PolyTyp, Closed, p_edge);
-        if (res) {
-          p_edge += num_edges[i];
-          result = true;
-        }
-      }
-      ++ i;
-    }
-    if (result)
-      // At least some edges were generated. Remember the edge array.
-      m_edges.emplace_back(std::move(edges));
-    return result;
-  }
-
-  void Clear();
-  IntRect GetBounds();
-  // By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before clipping.
-  // When enabled the PreserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.
-  bool PreserveCollinear() const {return m_PreserveCollinear;};
-  void PreserveCollinear(bool value) {m_PreserveCollinear = value;};
-protected:
-  bool AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, bool Closed, TEdge* edges);
-  TEdge* AddBoundsToLML(TEdge *e, bool IsClosed);
-  void Reset();
-  TEdge* ProcessBound(TEdge* E, bool IsClockwise);
-  TEdge* DescendToMin(TEdge *&E);
-  void AscendToMax(TEdge *&E, bool Appending, bool IsClosed);
-
-  // Local minima (Y, left edge, right edge) sorted by ascending Y.
-  std::vector<LocalMinimum, Allocator<LocalMinimum>> m_MinimaList;
-
-#ifdef CLIPPERLIB_INT32
-  static constexpr const bool m_UseFullRange = false;
-#else // CLIPPERLIB_INT32
-  // True if the input polygons have abs values higher than loRange, but lower than hiRange.
-  // False if the input polygons have abs values lower or equal to loRange.
-  bool              m_UseFullRange;
-#endif // CLIPPERLIB_INT32
-
-  // A vector of edges per each input path.
-  using Edges = std::vector<TEdge, Allocator<TEdge>>;
-  std::vector<Edges, Allocator<Edges>> m_edges;
-  // Don't remove intermediate vertices of a collinear sequence of points.
-  bool             m_PreserveCollinear;
-  // Is any of the paths inserted by AddPath() or AddPaths() open?
-  bool             m_HasOpenPaths;
-};
-//------------------------------------------------------------------------------
-
-class Clipper : public ClipperBase
-{
-public:
-  Clipper(int initOptions = 0);
-  ~Clipper() { Clear(); }
-  void Clear() { ClipperBase::Clear(); DisposeAllOutRecs(); }
-  bool Execute(ClipType clipType,
-      Paths &solution,
-      PolyFillType fillType = pftEvenOdd) 
-    { return Execute(clipType, solution, fillType, fillType); }
-  bool Execute(ClipType clipType,
-      Paths &solution,
-      PolyFillType subjFillType,
-      PolyFillType clipFillType);
-  bool Execute(ClipType clipType,
-      PolyTree &polytree,
-      PolyFillType fillType = pftEvenOdd)
-    { return Execute(clipType, polytree, fillType, fillType); }
-  bool Execute(ClipType clipType,
-      PolyTree &polytree,
-      PolyFillType subjFillType,
-      PolyFillType clipFillType);
-  bool ReverseSolution() const { return m_ReverseOutput; };
-  void ReverseSolution(bool value) {m_ReverseOutput = value;};
-  bool StrictlySimple() const {return m_StrictSimple;};
-  void StrictlySimple(bool value) {m_StrictSimple = value;};
-  //set the callback function for z value filling on intersections (otherwise Z is 0)
-#ifdef CLIPPERLIB_USE_XYZ
-  void ZFillFunction(ZFillCallback zFillFunc) { m_ZFill = zFillFunc; }
-#endif
-protected:
-  void Reset();
-  virtual bool ExecuteInternal();
-private:
-  
-  // Output polygons.
-  std::deque<OutRec, Allocator<OutRec>>  m_PolyOuts;
-  // Output points, allocated by a continuous sets of m_OutPtsChunkSize.
-  static constexpr const size_t m_OutPtsChunkSize = 32;
-  std::deque<std::array<OutPt, m_OutPtsChunkSize>, Allocator<std::array<OutPt, m_OutPtsChunkSize>>> m_OutPts;
-  // List of free output points, to be used before taking a point from m_OutPts or allocating a new chunk.
-  OutPt                *m_OutPtsFree;
-  size_t                m_OutPtsChunkLast;
-
-  std::vector<Join, Allocator<Join>>     m_Joins;
-  std::vector<Join, Allocator<Join>>     m_GhostJoins;
-  std::vector<IntersectNode, Allocator<IntersectNode>> m_IntersectList;
-  ClipType              m_ClipType;
-  // A priority queue (a binary heap) of Y coordinates.
-  using cInts = std::vector<cInt, Allocator<cInt>>;
-  std::priority_queue<cInt, cInts> m_Scanbeam;
-  // Maxima are collected by ProcessEdgesAtTopOfScanbeam(), consumed by ProcessHorizontal().
-  cInts                 m_Maxima;
-  TEdge                *m_ActiveEdges;
-  TEdge                *m_SortedEdges;
-  PolyFillType          m_ClipFillType;
-  PolyFillType          m_SubjFillType;
-  bool                  m_ReverseOutput;
-  // Does the result go to a PolyTree or Paths?
-  bool                  m_UsingPolyTree; 
-  bool                  m_StrictSimple;
-#ifdef CLIPPERLIB_USE_XYZ
-  ZFillCallback         m_ZFill; //custom callback 
-#endif
-  void SetWindingCount(TEdge& edge) const;
-  bool IsEvenOddFillType(const TEdge& edge) const 
-    { return (edge.PolyTyp == ptSubject) ? m_SubjFillType == pftEvenOdd : m_ClipFillType == pftEvenOdd; }
-  bool IsEvenOddAltFillType(const TEdge& edge) const
-    { return (edge.PolyTyp == ptSubject) ? m_ClipFillType == pftEvenOdd : m_SubjFillType == pftEvenOdd; }
-  void InsertLocalMinimaIntoAEL(const cInt botY);
-  void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge);
-  void AddEdgeToSEL(TEdge *edge);
-  void CopyAELToSEL();
-  void DeleteFromSEL(TEdge *e);
-  void DeleteFromAEL(TEdge *e);
-  void UpdateEdgeIntoAEL(TEdge *&e);
-  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
-  bool IsContributing(const TEdge& edge) const;
-  bool IsTopHorz(const cInt XPos);
-  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
-  void DoMaxima(TEdge *e);
-  void ProcessHorizontals();
-  void ProcessHorizontal(TEdge *horzEdge);
-  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
-  OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
-  OutRec* GetOutRec(int idx);
-  void AppendPolygon(TEdge *e1, TEdge *e2);
-  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
-  OutRec* CreateOutRec();
-  OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
-  OutPt* GetLastOutPt(TEdge *e);
-  OutPt* AllocateOutPt();
-  OutPt* DupOutPt(OutPt* outPt, bool InsertAfter);
-  // Add the point to a list of free points.
-  void DisposeOutPt(OutPt *pt) { pt->Next = m_OutPtsFree; m_OutPtsFree = pt; }
-  void DisposeOutPts(OutPt*& pp) { if (pp != nullptr) { pp->Prev->Next = m_OutPtsFree; m_OutPtsFree = pp; } }
-  void DisposeAllOutRecs();
-  bool ProcessIntersections(const cInt topY);
-  void BuildIntersectList(const cInt topY);
-  void ProcessEdgesAtTopOfScanbeam(const cInt topY);
-  void BuildResult(Paths& polys);
-  void BuildResult2(PolyTree& polytree);
-  void SetHoleState(TEdge *e, OutRec *outrec);
-  bool FixupIntersectionOrder();
-  void FixupOutPolygon(OutRec &outrec);
-  void FixupOutPolyline(OutRec &outrec);
-  bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
-  void FixHoleLinkage(OutRec &outrec);
-  bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2);
-  bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, const IntPoint &Pt, bool DiscardLeft);
-  void JoinCommonEdges();
-  void DoSimplePolygons();
-  void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
-  void FixupFirstLefts2(OutRec* InnerOutRec, OutRec* OuterOutRec);
-  void FixupFirstLefts3(OutRec* OldOutRec, OutRec* NewOutRec);
-#ifdef CLIPPERLIB_USE_XYZ
-  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
-#endif
-};
-//------------------------------------------------------------------------------
-
-class ClipperOffset 
-{
-public:
-  ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25, double shortestEdgeLength = 0.) :
-    MiterLimit(miterLimit), ArcTolerance(roundPrecision), ShortestEdgeLength(shortestEdgeLength), m_lowest(-1, 0) {}
-  ~ClipperOffset() { Clear(); }
-  void AddPath(const Path& path, JoinType joinType, EndType endType);
-  template<typename PathsProvider>
-  void AddPaths(PathsProvider &&paths, JoinType joinType, EndType endType) {
-    for (const Path &path : paths)
-      AddPath(path, joinType, endType);
-  }
-  void Execute(Paths& solution, double delta);
-  void Execute(PolyTree& solution, double delta);
-  void Clear();
-  double MiterLimit;
-  double ArcTolerance;
-  double ShortestEdgeLength;
-
-private:
-  Paths m_destPolys;
-  Path m_srcPoly;
-  Path m_destPoly;
-  std::vector<DoublePoint, Allocator<DoublePoint>> m_normals;
-  double m_delta, m_sinA, m_sin, m_cos;
-  double m_miterLim, m_StepsPerRad;
-  // x: index of the lowest contour in m_polyNodes
-  // y: index of the lowest point in the lowest contour
-  IntPoint m_lowest;
-  PolyNode m_polyNodes;
-
-  void FixOrientations();
-  void DoOffset(double delta);
-  void OffsetPoint(int j, int& k, JoinType jointype);
-  void DoSquare(int j, int k);
-  void DoMiter(int j, int k, double r);
-  void DoRound(int j, int k);
-};
-//------------------------------------------------------------------------------
-
-class clipperException : public std::exception
-{
-  public:
-    clipperException(const char* description): m_descr(description) {}
-    virtual ~clipperException() throw() {}
-    virtual const char* what() const throw() {return m_descr.c_str();}
-  private:
-    std::string m_descr;
-};
-//------------------------------------------------------------------------------
-
-// Union with "strictly simple" fix enabled.
-template<typename PathsProvider>
-inline Paths SimplifyPolygons(PathsProvider &&in_polys, PolyFillType fillType = pftNonZero, bool strictly_simple = true) {
-    Clipper c;
-    c.StrictlySimple(strictly_simple);
-    c.AddPaths(std::forward<PathsProvider>(in_polys), ptSubject, true);
-    Paths out;
-    c.Execute(ctUnion, out, fillType, fillType);
-    return out;
-}
-
-} //ClipperLib namespace
-
-#ifdef CLIPPERLIB_NAMESPACE_PREFIX
-} // namespace CLIPPERLIB_NAMESPACE_PREFIX
-#endif // CLIPPERLIB_NAMESPACE_PREFIX
-
-#endif //clipper_hpp

deps_src/clipper/clipper_z.cpp

@@ -1,7 +0,0 @@
-// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
-
-// Enable the Z coordinate support.
-#define CLIPPERLIB_USE_XYZ
-
-// and let it compile
-#include "clipper.cpp"

deps_src/clipper/clipper_z.hpp

@@ -1,18 +0,0 @@
-// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
-
-#ifndef clipper_z_hpp
-#ifdef clipper_hpp
-#error "You should include clipper_z.hpp before clipper.hpp"
-#endif
-
-#define clipper_z_hpp
-
-// Enable the Z coordinate support.
-#define CLIPPERLIB_USE_XYZ
-
-#include "clipper.hpp"
-
-#undef clipper_hpp
-#undef CLIPPERLIB_USE_XYZ
-
-#endif // clipper_z_hpp

deps_src/clipper2/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(Clipper2 VERSION 1.5.2 LANGUAGES C CXX)
+project(Clipper2 VERSION 2.0.1 LANGUAGES C CXX)
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_CXX_STANDARD 17)
@@ -19,6 +19,7 @@ set(CLIPPER2_INC
   Clipper2Lib/include/clipper2/clipper.minkowski.h
   Clipper2Lib/include/clipper2/clipper.offset.h
   Clipper2Lib/include/clipper2/clipper.rectclip.h
+  Clipper2Lib/include/clipper2/clipper.triangulation.h
   Clipper2Lib/include/clipper2/clipper2_z.hpp
 )
 
@@ -26,6 +27,7 @@ set(CLIPPER2_SRC
   Clipper2Lib/src/clipper.engine.cpp
   Clipper2Lib/src/clipper.offset.cpp
   Clipper2Lib/src/clipper.rectclip.cpp
+  Clipper2Lib/src/clipper.triangulation.cpp
   Clipper2Lib/src/clipper2_z.cpp
 )
 
@@ -36,6 +38,9 @@ target_include_directories(Clipper2
   PUBLIC Clipper2Lib/include
 )
 
+# Engine nodes are allocated through tbbmalloc (see clipper.engine.cpp).
+target_link_libraries(Clipper2 PRIVATE TBB::tbbmalloc)
+
 if (WIN32)
   if (MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     target_compile_options(Clipper2 PRIVATE /W4 /WX)

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.core.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  12 May 2024                                                     *
+* Date      :  12 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  Core Clipper Library structures and functions                   *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -251,6 +251,20 @@ namespace Clipper2Lib {
   template <typename T>
   using Paths = std::vector<Path<T>>;
 
+  template <typename T, typename T2=T>
+  Path<T>& operator<<(Path<T>& poly, const Point<T2>& p)
+  {
+    poly.emplace_back(p);
+    return poly;
+  }
+
+  template <typename T>
+  Paths<T>& operator<<(Paths<T>& polys, const Path<T>& p)
+  {
+    polys.emplace_back(p);
+    return polys;
+  }
+
   using Path64 = Path<int64_t>;
   using PathD = Path<double>;
   using Paths64 = std::vector< Path64>;
@@ -685,32 +699,31 @@ namespace Clipper2Lib {
 
   inline int TriSign(int64_t x) // returns 0, 1 or -1
   {
-    return (x > 0) - (x < 0);
+    return (x > 0) - (x < 0); 
   }
 
-  struct MultiplyUInt64Result
+  struct UInt128Struct
   {
-    const uint64_t result = 0;
-    const uint64_t carry = 0;
+    const uint64_t lo = 0;
+    const uint64_t hi = 0;
 
-    bool operator==(const MultiplyUInt64Result& other) const
+    bool operator==(const UInt128Struct& other) const
     {
-      return result == other.result && carry == other.carry;
+      return lo == other.lo && hi == other.hi;
     };
+
   };
 
-  inline MultiplyUInt64Result Multiply(uint64_t a, uint64_t b) // #834, #835
+  inline UInt128Struct MultiplyUInt64(uint64_t a, uint64_t b) // #834, #835
   {
+    // note to self - lamba expressions follow
     const auto lo = [](uint64_t x) { return x & 0xFFFFFFFF; };
     const auto hi = [](uint64_t x) { return x >> 32; };
 
     const uint64_t x1 = lo(a) * lo(b);
     const uint64_t x2 = hi(a) * lo(b) + hi(x1);
     const uint64_t x3 = lo(a) * hi(b) + lo(x2);
-    const uint64_t result = lo(x3) << 32 | lo(x1);
-    const uint64_t carry = hi(a) * hi(b) + hi(x2) + hi(x3);
-
-    return { result, carry };
+    return { uint64_t(lo(x3) << 32 | lo(x1)), uint64_t(hi(a) * hi(b) + hi(x2) + hi(x3)) };
   }
 
   // returns true if (and only if) a * b == c * d
@@ -727,14 +740,50 @@ namespace Clipper2Lib {
     const auto abs_c = static_cast<uint64_t>(std::abs(c));
     const auto abs_d = static_cast<uint64_t>(std::abs(d));
 
-    const auto abs_ab = Multiply(abs_a, abs_b);
-    const auto abs_cd = Multiply(abs_c, abs_d);
+    const auto ab = MultiplyUInt64(abs_a, abs_b);
+    const auto cd = MultiplyUInt64(abs_c, abs_d);
 
     // nb: it's important to differentiate 0 values here from other values
     const auto sign_ab = TriSign(a) * TriSign(b);
     const auto sign_cd = TriSign(c) * TriSign(d);
 
-    return abs_ab == abs_cd && sign_ab == sign_cd;
+    return ab == cd && sign_ab == sign_cd;
+#endif
+  }
+
+  template <typename T>
+  inline int CrossProductSign(const Point<T>& pt1, const Point<T>& pt2, const Point<T>& pt3)
+  {
+    const auto a = pt2.x - pt1.x;
+    const auto b = pt3.y - pt2.y;
+    const auto c = pt2.y - pt1.y;
+    const auto d = pt3.x - pt2.x;
+
+#if (defined(__clang__) || defined(__GNUC__)) && UINTPTR_MAX >= UINT64_MAX
+    const auto ab = static_cast<__int128_t>(a) * static_cast<__int128_t>(b);
+    const auto cd = static_cast<__int128_t>(c) * static_cast<__int128_t>(d);
+    if (ab > cd) return 1;
+    else if (ab < cd) return -1;
+    else return 0;
+#else
+    const auto ab = MultiplyUInt64(std::abs(a), std::abs(b));
+    const auto cd = MultiplyUInt64(std::abs(c), std::abs(d));
+
+    const auto sign_ab = TriSign(a) * TriSign(b);
+    const auto sign_cd = TriSign(c) * TriSign(d);
+
+    if (sign_ab == sign_cd)
+    {
+      int result;
+      if (ab.hi == cd.hi)
+      {
+        if (ab.lo == cd.lo) return 0;
+        result = (ab.lo > cd.lo) ? 1 : -1;
+      }
+      else result = (ab.hi > cd.hi) ? 1 : -1;
+      return (sign_ab > 0) ? result : -result;
+    }
+    return (sign_ab > sign_cd) ? 1 : -1;
 #endif
   }
 
@@ -838,6 +887,10 @@ namespace Clipper2Lib {
     return Area<T>(poly) >= 0;
   }
 
+  // GetLineIntersectPt - a 'true' result is non-parallel. The 'ip' will also
+  // be constrained to seg1. However, it's possible that 'ip' won't be inside
+  // seg2, even when 'ip' hasn't been constrained (ie 'ip' is inside seg1).
+
 #if CLIPPER2_HI_PRECISION
   // caution: this will compromise performance
   // https://github.com/AngusJohnson/Clipper2/issues/317#issuecomment-1314023253
@@ -845,7 +898,7 @@ namespace Clipper2Lib {
   #define CC_MIN(x,y) ((x)>(y)?(y):(x))
   #define CC_MAX(x,y) ((x)<(y)?(y):(x))
   template<typename T>
-  inline bool GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetLineIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
     const Point<T>& ln2a, const Point<T>& ln2b, Point<T>& ip)
   {
     double ln1dy = static_cast<double>(ln1b.y - ln1a.y);
@@ -891,11 +944,14 @@ namespace Clipper2Lib {
       ip.x = originx + static_cast<T>(hitx);
       ip.y = originy + static_cast<T>(hity);
     }
+#ifdef USINGZ
+    ip.z = 0;
+#endif
     return true;
 }
 #else
   template<typename T>
-  inline bool GetSegmentIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
+  inline bool GetLineIntersectPt(const Point<T>& ln1a, const Point<T>& ln1b,
     const Point<T>& ln2a, const Point<T>& ln2b, Point<T>& ip)
   {
     // https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
@@ -913,7 +969,10 @@ namespace Clipper2Lib {
     {
       ip.x = static_cast<T>(ln1a.x + t * dx1);
       ip.y = static_cast<T>(ln1a.y + t * dy1);
-  }
+#ifdef USINGZ
+      ip.z = 0;
+#endif
+    }
     return true;
   }
 #endif
@@ -940,30 +999,53 @@ namespace Clipper2Lib {
   }
 
   template<typename T>
-  inline int GetSign(const T& val)
-  {
-    if (!val) return 0;
+  inline int GetSign(const T& val) 
+  { 
+    if (!val) return 0; 
     return (val > 0) ? 1 : -1;
   }
 
   inline bool SegmentsIntersect(const Point64& seg1a, const Point64& seg1b,
     const Point64& seg2a, const Point64& seg2b, bool inclusive = false)
   {
+    double dy1 = static_cast<double>(seg1b.y - seg1a.y);
+    double dx1 = static_cast<double>(seg1b.x - seg1a.x);
+    double dy2 = static_cast<double>(seg2b.y - seg2a.y);
+    double dx2 = static_cast<double>(seg2b.x - seg2a.x);
+    double cp = dy1 * dx2 - dy2 * dx1;
+    if (cp == 0) return false; // ie parallel segments
+
     if (inclusive)
     {
-      double res1 = CrossProduct(seg1a, seg2a, seg2b);
-      double res2 = CrossProduct(seg1b, seg2a, seg2b);
-      if (res1 * res2 > 0) return false;
-      double res3 = CrossProduct(seg2a, seg1a, seg1b);
-      double res4 = CrossProduct(seg2b, seg1a, seg1b);
-      if (res3 * res4 > 0) return false;
-      return (res1 || res2 || res3 || res4); // ensures not collinear
+      //result **includes** segments that touch at an end point
+      double t = ((seg1a.x - seg2a.x) * dy2 - (seg1a.y - seg2a.y) * dx2);
+      if (t == 0) return true;
+      if (t > 0)
+      {
+        if (cp < 0 || t > cp) return false;
+      }
+      else if (cp > 0 || t < cp) return false; // false when t more neg. than cp
+
+      t = ((seg1a.x - seg2a.x) * dy1 - (seg1a.y - seg2a.y) * dx1);
+      if (t == 0) return true;
+      if (t > 0)  return (cp > 0 && t <= cp);
+      else return (cp < 0 && t >= cp);        // true when t less neg. than cp
     }
-    else {
-      return (GetSign(CrossProduct(seg1a, seg2a, seg2b)) *
-        GetSign(CrossProduct(seg1b, seg2a, seg2b)) < 0) &&
-        (GetSign(CrossProduct(seg2a, seg1a, seg1b)) *
-          GetSign(CrossProduct(seg2b, seg1a, seg1b)) < 0);
+    else 
+    {
+      //result **excludes** segments that touch at an end point
+      double t = ((seg1a.x - seg2a.x) * dy2 - (seg1a.y - seg2a.y) * dx2);
+      if (t == 0) return false;
+      if (t > 0)
+      {
+        if (cp < 0 || t >= cp) return false;
+      }
+      else if (cp > 0 || t <= cp ) return false; // false when t more neg. than cp
+
+      t = ((seg1a.x - seg2a.x) * dy1 - (seg1a.y - seg2a.y) * dx1);
+      if (t == 0) return false;
+      if (t > 0)  return (cp > 0 && t < cp);
+      else return (cp < 0 && t > cp); // true when t less neg. than cp
     }
   }
 
@@ -1051,7 +1133,7 @@ namespace Clipper2Lib {
         val = 1 - val; // toggle val
       else
       {
-        double d = CrossProduct(*prev, *curr, pt);
+        int d = CrossProductSign(*prev, *curr, pt);
         if (d == 0) return PointInPolygonResult::IsOn;
         if ((d < 0) == is_above) val = 1 - val;
       }
@@ -1065,7 +1147,7 @@ namespace Clipper2Lib {
       if (curr == cend) curr = cbegin;
       if (curr == cbegin) prev = cend - 1;
       else prev = curr - 1;
-      double d = CrossProduct(*prev, *curr, pt);
+      int d = CrossProductSign(*prev, *curr, pt);
       if (d == 0) return PointInPolygonResult::IsOn;
       if ((d < 0) == is_above) val = 1 - val;
     }

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.engine.h

@@ -15,6 +15,13 @@
 #include <functional>
 #include <memory>
 
+// Orca: engine nodes are allocated through tbbmalloc, see clipper.engine.cpp.
+#define CLIPPER2_NODE_ALLOCATOR \
+	static void* operator new(size_t size); \
+	static void operator delete(void* ptr) noexcept; \
+	static void* operator new[](size_t size); \
+	static void operator delete[](void* ptr) noexcept;
+
 #ifdef USINGZ
 namespace Clipper2Lib_Z {
 #else
@@ -50,6 +57,7 @@ namespace Clipper2Lib {
 	}
 
 	struct Vertex {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		Vertex* next = nullptr;
 		Vertex* prev = nullptr;
@@ -57,6 +65,7 @@ namespace Clipper2Lib {
 	};
 
 	struct OutPt {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 pt;
 		OutPt*	next = nullptr;
 		OutPt*	prev = nullptr;
@@ -81,6 +90,7 @@ namespace Clipper2Lib {
 	//OutRec: contains a path in the clipping solution. Edges in the AEL will
 	//have OutRec pointers assigned when they form part of the clipping solution.
 	struct OutRec {
+		CLIPPER2_NODE_ALLOCATOR
 		size_t idx = 0;
 		OutRec* owner = nullptr;
 		Active* front_edge = nullptr;
@@ -106,6 +116,7 @@ namespace Clipper2Lib {
 	///////////////////////////////////////////////////////////////////
 
 	struct Active {
+		CLIPPER2_NODE_ALLOCATOR
 		Point64 bot;
 		Point64 top;
 		int64_t curr_x = 0;		//current (updated at every new scanline)
@@ -133,6 +144,7 @@ namespace Clipper2Lib {
 	};
 
 	struct LocalMinima {
+		CLIPPER2_NODE_ALLOCATOR
 		Vertex* vertex;
 		PathType polytype;
 		bool is_open;
@@ -303,6 +315,7 @@ namespace Clipper2Lib {
 	protected:
 		PolyPath* parent_;
 	public:
+		CLIPPER2_NODE_ALLOCATOR
 		PolyPath(PolyPath* parent = nullptr): parent_(parent){}
 		virtual ~PolyPath() {};
 		//https://en.cppreference.com/w/cpp/language/rule_of_three
@@ -330,15 +343,16 @@ namespace Clipper2Lib {
 			//Even levels except level 0
 			return lvl && !(lvl & 1);
 		}
-        template<typename T>
-        static double Clipper2LibArea(const Path<T> &poly)
-        {
+		// Area() of the namespace this header is compiled into (Clipper2Lib or Clipper2Lib_Z).
+		template<typename T>
+		static double Clipper2LibArea(const Path<T> &poly)
+		{
 #ifdef USINGZ
-            return Clipper2Lib_Z::Area<T>(poly);
+			return Clipper2Lib_Z::Area<T>(poly);
 #else
-            return Clipper2Lib::Area<T>(poly);
+			return Clipper2Lib::Area<T>(poly);
 #endif
-        }
+		}
 	};
 
 	typedef typename std::vector<std::unique_ptr<PolyPath64>> PolyPath64List;
@@ -388,7 +402,8 @@ namespace Clipper2Lib {
 
 		double Area() const
 		{
-			return std::accumulate(childs_.cbegin(), childs_.cend(), Clipper2LibArea<int64_t>(polygon_),
+			return std::accumulate(childs_.cbegin(), childs_.cend(),
+				Clipper2LibArea<int64_t>(polygon_),
 				[](double a, const auto& child) {return a + child->Area(); });
 		}
 
@@ -462,7 +477,8 @@ namespace Clipper2Lib {
 
 		double Area() const
 		{
-			return std::accumulate(childs_.begin(), childs_.end(), Clipper2LibArea<double>(polygon_),
+			return std::accumulate(childs_.begin(), childs_.end(),
+				Clipper2LibArea<double>(polygon_),
 				[](double a, const auto& child) {return a + child->Area(); });
 		}
 	};

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.export.h

@@ -19,17 +19,17 @@
 
 The path structures used extensively in other parts of this library are all
 based on std::vector classes. Since C++ classes can't be accessed by other
-languages, these paths are exported here as very simple array structures
-(either of int64_t or double) that can be parsed by just about any
+languages, these paths are exported here as very simple array structures 
+(either of int64_t or double) that can be parsed by just about any 
 programming language.
 
 These 2D paths are defined by series of x and y coordinates together with an
 optional user-defined 'z' value (see Z-values below). Hence, a vertex refers
-to a single x and y coordinate (+/- a user-defined value). Data structures
-have names with suffixes that indicate the array type (either int64_t or
-double). For example, the data structure CPath64 contains an array of int64_t
-values, whereas the data structure CPathD contains an array of double.
-Where documentation omits the type suffix (eg CPath), it is referring to an
+to a single x and y coordinate (+/- a user-defined value). Data structures 
+have names with suffixes that indicate the array type (either int64_t or 
+double). For example, the data structure CPath64 contains an array of int64_t 
+values, whereas the data structure CPathD contains an array of double. 
+Where documentation omits the type suffix (eg CPath), it is referring to an 
 array whose data type could be either int64_t or double.
 
 For conciseness, the following letters are used in the diagrams below:
@@ -39,10 +39,10 @@ A: Number of elements in an array
 
 
 CPath64 and CPathD:
-These are arrays of either int64_t or double values. Apart from
-the first two elements, these arrays are a series of vertices
-that together define a path. The very first element contains the
-number of vertices (N) in the path, while second element should
+These are arrays of either int64_t or double values. Apart from 
+the first two elements, these arrays are a series of vertices 
+that together define a path. The very first element contains the 
+number of vertices (N) in the path, while second element should 
 contain a 0 value.
 _______________________________________________________________
 | counters | vertex1      | vertex2      | ... | vertexN      |
@@ -52,9 +52,9 @@ _______________________________________________________________
 
 CPaths64 and CPathsD:
 These are also arrays of either int64_t or double values that
-contain any number of consecutive CPath structures. However,
+contain any number of consecutive CPath structures. However, 
 preceding the first path is a pair of values. The first value
-contains the length of the entire array structure (A), and the
+contains the length of the entire array structure (A), and the 
 second contains the number (ie count) of contained paths (C).
   Memory allocation for CPaths64 = A * sizeof(int64_t)
   Memory allocation for CPathsD  = A * sizeof(double)
@@ -65,12 +65,12 @@ __________________________________________
 
 
 CPolytree64 and CPolytreeD:
-The entire polytree structure is an array of int64_t or double. The
-first element in the array indicates the array's total length (A).
-The second element indicates the number (C) of CPolyPath structures
+The entire polytree structure is an array of int64_t or double. The 
+first element in the array indicates the array's total length (A). 
+The second element indicates the number (C) of CPolyPath structures 
 that are the TOP LEVEL CPolyPath in the polytree, and these top
-level CPolyPath immediately follow these first two array elements.
-These top level CPolyPath structures may, in turn, contain nested
+level CPolyPath immediately follow these first two array elements. 
+These top level CPolyPath structures may, in turn, contain nested 
 CPolyPath children, and these collectively make a tree structure.
 _________________________________________________________
 | counters | CPolyPath1 | CPolyPath2 | ... | CPolyPathC |
@@ -116,13 +116,10 @@ the four vertices that define the two segments that are intersecting.
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.offset.h"
 #include "clipper2/clipper.rectclip.h"
+#include "clipper2/clipper.triangulation.h"
 #include <cstdlib>
 
-#ifdef USINGZ
-namespace Clipper2Lib_Z {
-#else
 namespace Clipper2Lib {
-#endif
 
 typedef int64_t* CPath64;
 typedef int64_t* CPaths64;
@@ -254,9 +251,9 @@ ZCallback64 dllCallback64 = nullptr;
 ZCallbackD  dllCallbackD  = nullptr;
 
 constexpr int EXPORT_VERTEX_DIMENSIONALITY = 3;
-#else
+#else    
 constexpr int EXPORT_VERTEX_DIMENSIONALITY  = 2;
-#endif
+#endif 
 
 template <typename T>
 static void GetPathCountAndCPathsArrayLen(const Paths<T>& paths,
@@ -396,7 +393,7 @@ static Path<T> ConvertCPathToPathT(T* path)
 #ifdef USINGZ
       z_type z = Reinterpret<z_type>(*v++);
       result.emplace_back(x, y, z);
-#else
+#else  
       result.emplace_back(x, y);
 #endif
   }
@@ -414,7 +411,7 @@ static Paths<T> ConvertCPathsToPathsT(T* paths)
   for (size_t i = 0; i < cnt; ++i)
   {
     size_t cnt2 = static_cast<size_t>(*v);
-    v += 2;
+    v += 2; 
     Path<T> path;
     path.reserve(cnt2);
     for (size_t j = 0; j < cnt2; ++j)
@@ -447,7 +444,7 @@ static Path64 ConvertCPathDToPath64WithScale(const CPathD path, double scale)
 #ifdef USINGZ
         z_type z = Reinterpret<z_type>(*v++);
         result.emplace_back(x, y, z);
-#else
+#else  
         result.emplace_back(x, y);
 #endif
     }
@@ -492,7 +489,7 @@ static void CreateCPolyPath64(const PolyPath64* pp, int64_t*& v)
   {
     *v++ = pt.x;
     *v++ = pt.y;
-#ifdef USINGZ
+#ifdef USINGZ   
     * v++ = Reinterpret<int64_t>(pt.z); // raw memory copy
 #endif
   }
@@ -508,7 +505,7 @@ static void CreateCPolyPathD(const PolyPathD* pp, double*& v)
   {
     *v++ = pt.x;
     *v++ = pt.y;
-#ifdef USINGZ
+#ifdef USINGZ   
     * v++ = Reinterpret<double>(pt.z); // raw memory copy
 #endif
   }
@@ -816,6 +813,24 @@ EXTERN_DLL_EXPORT CPaths64 MinkowskiDiff64(const CPath64& cpattern, const CPath6
   return CreateCPathsFromPathsT(solution);
 }
 
+EXTERN_DLL_EXPORT CPaths64 Triangulate64(const CPaths64 paths, bool use_delaunay)
+{
+  Paths64 pp = ConvertCPathsToPathsT(paths);
+  Paths64 sol;
+  if (Triangulate(pp, sol, use_delaunay) != TriangulateResult::success) return nullptr;
+  return CreateCPathsFromPathsT(sol);
+}
+
+EXTERN_DLL_EXPORT CPathsD TriangulateD(const CPathsD paths, int decimal_precison, bool use_delaunay)
+{
+  if (decimal_precison < -8 || decimal_precison > 8) return nullptr;
+  const double scale = std::pow(10, decimal_precison);
+  Paths64 pp = ConvertCPathsDToPaths64(paths, scale);
+  Paths64 sol;
+  if (Triangulate(pp, sol, use_delaunay) != TriangulateResult::success) return nullptr;
+  return CreateCPathsDFromPaths64(sol, 1 / scale);
+}
+
 #ifdef USINGZ
 typedef void (*DLLZCallback64)(const Point64& e1bot, const Point64& e1top, const Point64& e2bot, const Point64& e2top, Point64& pt);
 typedef void (*DLLZCallbackD)(const PointD& e1bot, const PointD& e1top, const PointD& e2bot, const PointD& e2top, PointD& pt);

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.h

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  27 April 2024                                                   *
+* Date      :  5 March 2025                                                    *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  This module provides a simple interface to the Clipper Library  *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -13,14 +13,15 @@
 #include "clipper2/clipper.core.h"
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.offset.h"
-#include "clipper2/clipper.minkowski.h"
 #include "clipper2/clipper.rectclip.h"
+#include "clipper2/clipper.minkowski.h"
+#include "clipper2/clipper.triangulation.h"
 #include <type_traits>
 
 #ifdef USINGZ
-  namespace Clipper2Lib_Z {
+namespace Clipper2Lib_Z {
 #else
-  namespace Clipper2Lib {
+namespace Clipper2Lib {
 #endif
 
   inline Paths64 BooleanOp(ClipType cliptype, FillRule fillrule,
@@ -154,14 +155,14 @@
     if (!delta) return paths;
     if (error_code) return PathsD();
     const double scale = std::pow(10, precision);
-    ClipperOffset clip_offset(miter_limit, arc_tolerance);
+    ClipperOffset clip_offset(miter_limit, arc_tolerance * scale);
     clip_offset.AddPaths(ScalePaths<int64_t,double>(paths, scale, error_code), jt, et);
     if (error_code) return PathsD();
     Paths64 solution;
     clip_offset.Execute(delta * scale, solution);
     return ScalePaths<double, int64_t>(solution, 1 / scale, error_code);
   }
-
+  
   template <typename T>
   inline Path<T> TranslatePath(const Path<T>& path, T dx, T dy)
   {
@@ -355,6 +356,29 @@
 #endif
     }
 
+    inline size_t GetNext(size_t current, size_t high,
+      const std::vector<bool>& flags)
+    {
+      ++current;
+      while (current <= high && flags[current]) ++current;
+      if (current <= high) return current;
+      current = 0;
+      while (flags[current]) ++current;
+      return current;
+    }
+
+    inline size_t GetPrior(size_t current, size_t high,
+      const std::vector<bool>& flags)
+    {
+      if (current == 0) current = high;
+      else --current;
+      while (current > 0 && flags[current]) --current;
+      if (!flags[current]) return current;
+      current = high;
+      while (flags[current]) --current;
+      return current;
+    }
+
   } // end details namespace
 
   inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp)
@@ -615,29 +639,6 @@
     return result;
   }
 
-  inline size_t GetNext(size_t current, size_t high,
-    const std::vector<bool>& flags)
-  {
-    ++current;
-    while (current <= high && flags[current]) ++current;
-    if (current <= high) return current;
-    current = 0;
-    while (flags[current]) ++current;
-    return current;
-  }
-
-  inline size_t GetPrior(size_t current, size_t high,
-    const std::vector<bool>& flags)
-  {
-    if (current == 0) current = high;
-    else --current;
-    while (current > 0 && flags[current]) --current;
-    if (!flags[current]) return current;
-    current = high;
-    while (flags[current]) --current;
-    return current;
-  }
-
   template <typename T>
   inline Path<T> SimplifyPath(const Path<T> &path,
     double epsilon, bool isClosedPath = true)
@@ -669,13 +670,13 @@
         start = curr;
         do
         {
-          curr = GetNext(curr, high, flags);
+          curr = details::GetNext(curr, high, flags);
         } while (curr != start && distSqr[curr] > epsSqr);
         if (curr == start) break;
       }
 
-      prior = GetPrior(curr, high, flags);
-      next = GetNext(curr, high, flags);
+      prior = details::GetPrior(curr, high, flags);
+      next = details::GetNext(curr, high, flags);
       if (next == prior) break;
 
       // flag for removal the smaller of adjacent 'distances'
@@ -684,14 +685,14 @@
         prior2 = prior;
         prior = curr;
         curr = next;
-        next = GetNext(next, high, flags);
+        next = details::GetNext(next, high, flags);
       }
       else
-        prior2 = GetPrior(prior, high, flags);
+        prior2 = details::GetPrior(prior, high, flags);
 
       flags[curr] = true;
       curr = next;
-      next = GetNext(next, high, flags);
+      next = details::GetNext(next, high, flags);
 
       if (isClosedPath || ((curr != high) && (curr != 0)))
         distSqr[curr] = PerpendicDistFromLineSqrd(path[curr], path[prior], path[next]);
@@ -716,6 +717,35 @@
     return result;
   }
 
+ 
+  template <typename T>
+  inline bool Path2ContainsPath1(const Path<T>& path1, const Path<T>& path2)
+  {
+    // precondition: paths must not intersect, except for
+    // transient (and presumed 'micro') path intersections 
+    PointInPolygonResult pip = PointInPolygonResult::IsOn;
+    for (const Point<T>& pt : path1)
+    {
+      switch (PointInPolygon(pt, path2))
+      {
+      case PointInPolygonResult::IsOutside: 
+        if (pip == PointInPolygonResult::IsOutside) return false; 
+        pip = PointInPolygonResult::IsOutside; 
+        break;
+      case PointInPolygonResult::IsInside:
+        if (pip == PointInPolygonResult::IsInside) return true;
+        pip = PointInPolygonResult::IsInside;
+        break;
+      default: 
+        break;
+      }
+    }
+    if (pip != PointInPolygonResult::IsInside) return false;
+    // result is likely true but check midpoint
+    Point<T> mp1 = GetBounds(path1).MidPoint();
+    return PointInPolygon(mp1, path2) == PointInPolygonResult::IsInside;
+  }
+
   template <typename T>
   inline void RDP(const Path<T> path, std::size_t begin,
     std::size_t end, double epsSqrd, std::vector<bool>& flags)

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.offset.h

@@ -39,7 +39,7 @@ private:
 	class Group {
 	public:
 		Paths64 paths_in;
-        std::optional<size_t> lowest_path_idx{};
+    std::optional<size_t> lowest_path_idx{};
 		bool is_reversed = false;
 		JoinType join_type;
 		EndType end_type;
@@ -100,7 +100,7 @@ public:
 	void AddPath(const Path64& path, JoinType jt_, EndType et_);
 	void AddPaths(const Paths64& paths, JoinType jt_, EndType et_);
 	void Clear() { groups_.clear(); norms.clear(); };
-
+	
 	void Execute(double delta, Paths64& sols_64);
 	void Execute(double delta, PolyTree64& polytree);
 	void Execute(DeltaCallback64 delta_cb, Paths64& paths);
@@ -114,7 +114,7 @@ public:
 
 	bool PreserveCollinear() const { return preserve_collinear_; }
 	void PreserveCollinear(bool preserve_collinear){preserve_collinear_ = preserve_collinear;}
-
+	
 	bool ReverseSolution() const { return reverse_solution_; }
 	void ReverseSolution(bool reverse_solution) {reverse_solution_ = reverse_solution;}
 

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.triangulation.h

@@ -0,0 +1,30 @@
+/*******************************************************************************
+* Author    :  Angus Johnson                                                   *
+* Date      :  6 December 2025                                                 *
+* Release   :  BETA RELEASE                                                    *
+* Website   :  https://www.angusj.com                                          *
+* Copyright :  Angus Johnson 2010-2025                                         *
+* Purpose   :  Delaunay Triangulation                                          *
+* License   :  https://www.boost.org/LICENSE_1_0.txt                           *
+*******************************************************************************/
+
+#ifndef CLIPPER_TRIANGULATION_H
+#define CLIPPER_TRIANGULATION_H
+
+#include <stack>
+#include "clipper2/clipper.core.h"
+
+#ifdef USINGZ
+namespace Clipper2Lib_Z {
+#else
+namespace Clipper2Lib {
+#endif
+
+  enum class TriangulateResult { success, fail, no_polygons, paths_intersect };
+
+  // Triangulate - this function will not accept intesecting paths
+  TriangulateResult Triangulate(const Paths64& pp, Paths64& solution, bool useDelaunay = true);
+  TriangulateResult Triangulate(const PathsD& pp, int decPlaces, PathsD& solution, bool useDelaunay = true);
+
+} // Clipper2Lib namespace
+#endif  // CLIPPER_TRIANGULATION_H

deps_src/clipper2/Clipper2Lib/include/clipper2/clipper.version.h

@@ -1,6 +1,6 @@
 #ifndef CLIPPER_VERSION_H
 #define CLIPPER_VERSION_H
 
-constexpr auto CLIPPER2_VERSION = "1.5.2";
+constexpr auto CLIPPER2_VERSION = "2.0.1";
 
 #endif  // CLIPPER_VERSION_H

deps_src/clipper2/Clipper2Lib/src/clipper.engine.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  17 September 2024                                               *
+* Date      :  5 November 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  This is the main polygon clipping module                        *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -10,6 +10,8 @@
 #include "clipper2/clipper.engine.h"
 #include "clipper2/clipper.h"
 #include <stdexcept>
+#include <new>
+#include <oneapi/tbb/scalable_allocator.h>
 
 // https://github.com/AngusJohnson/Clipper2/discussions/334
 // #discussioncomment-4248602
@@ -27,10 +29,30 @@ namespace Clipper2Lib_Z {
 namespace Clipper2Lib {
 #endif
 
+  // Orca: tbbmalloc scales far better than the default heap when all slicing threads clip at once.
+  static void* NodeAlloc(size_t size)
+  {
+    if (void* p = scalable_malloc(size)) return p;
+    throw std::bad_alloc();
+  }
+
+#define CLIPPER2_DEFINE_NODE_ALLOCATOR(T) \
+  void* T::operator new(size_t size) { return NodeAlloc(size); } \
+  void T::operator delete(void* ptr) noexcept { scalable_free(ptr); } \
+  void* T::operator new[](size_t size) { return NodeAlloc(size); } \
+  void T::operator delete[](void* ptr) noexcept { scalable_free(ptr); }
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(Vertex)
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(OutPt)
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(OutRec)
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(Active)
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(LocalMinima)
+  CLIPPER2_DEFINE_NODE_ALLOCATOR(PolyPath)
+#undef CLIPPER2_DEFINE_NODE_ALLOCATOR
+
   static const Rect64 invalid_rect = Rect64(false);
 
-  // Every closed path (ie polygon) is made up of a series of vertices forming edge
-  // 'bounds' that alternate between ascending bounds (containing edges going up
+  // Every closed path (ie polygon) is made up of a series of vertices forming edge 
+  // 'bounds' that alternate between ascending bounds (containing edges going up 
   // relative to the Y-axis) and descending bounds. 'Local Minima' refers to
   // vertices where ascending and descending bounds join at the bottom, and
   // 'Local Maxima' are where ascending and descending bounds join at the top.
@@ -482,8 +504,7 @@ namespace Clipper2Lib {
   inline void SetOwner(OutRec* outrec, OutRec* new_owner)
   {
     //precondition1: new_owner is never null
-    while (new_owner->owner && !new_owner->owner->pts)
-      new_owner->owner = new_owner->owner->owner;
+    new_owner->owner = GetRealOutRec(new_owner->owner);
     OutRec* tmp = new_owner;
     while (tmp && tmp != outrec) tmp = tmp->owner;
     if (tmp) new_owner->owner = outrec->owner;
@@ -536,9 +557,9 @@ namespace Clipper2Lib {
         val = 1 - val; // toggle val
       else
       {
-        double d = CrossProduct(op2->prev->pt, op2->pt, pt);
-        if (d == 0) return PointInPolygonResult::IsOn;
-        if ((d < 0) == is_above) val = 1 - val;
+        int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
+        if (i == 0) return PointInPolygonResult::IsOn;
+        if ((i < 0) == is_above) val = 1 - val;
       }
       is_above = !is_above;
       op2 = op2->next;
@@ -546,9 +567,9 @@ namespace Clipper2Lib {
 
     if (is_above != starting_above)
     {
-      double d = CrossProduct(op2->prev->pt, op2->pt, pt);
-      if (d == 0) return PointInPolygonResult::IsOn;
-      if ((d < 0) == is_above) val = 1 - val;
+      int i = CrossProductSign(op2->prev->pt, op2->pt, pt);
+      if (i == 0) return PointInPolygonResult::IsOn;
+      if ((i < 0) == is_above) val = 1 - val;
     }
 
     if (val == 0) return PointInPolygonResult::IsOutside;
@@ -578,30 +599,31 @@ namespace Clipper2Lib {
     return result;
   }
 
-  inline bool Path1InsidePath2(OutPt* op1, OutPt* op2)
+  inline bool Path2ContainsPath1(OutPt* op1, OutPt* op2)
   {
-    // we need to make some accommodation for rounding errors
-    // so we won't jump if the first vertex is found outside
-    PointInPolygonResult result;
-    int outside_cnt = 0;
+    // this function accommodates rounding errors that 
+    // can cause path micro intersections
+    PointInPolygonResult pip = PointInPolygonResult::IsOn;
     OutPt* op = op1;
-    do
-    {
-      result = PointInOpPolygon(op->pt, op2);
-      if (result == PointInPolygonResult::IsOutside) ++outside_cnt;
-      else if (result == PointInPolygonResult::IsInside) --outside_cnt;
+    do {
+      switch (PointInOpPolygon(op->pt, op2))
+      {
+      case PointInPolygonResult::IsOutside:
+        if (pip == PointInPolygonResult::IsOutside) return false;
+        pip = PointInPolygonResult::IsOutside;
+        break;
+      case PointInPolygonResult::IsInside:
+        if (pip == PointInPolygonResult::IsInside) return true;
+        pip = PointInPolygonResult::IsInside;
+        break;
+      default: break;
+      }
       op = op->next;
-    } while (op != op1 && std::abs(outside_cnt) < 2);
-    if (std::abs(outside_cnt) > 1) return (outside_cnt < 0);
-    // since path1's location is still equivocal, check its midpoint
-    Point64 mp = GetBounds(GetCleanPath(op1)).MidPoint();
-    Path64 path2 = GetCleanPath(op2);
-    return PointInPolygon(mp, path2) != PointInPolygonResult::IsOutside;
+    } while (op != op1);
+    // result unclear, so try again using cleaned paths
+    return Path2ContainsPath1(GetCleanPath(op1), GetCleanPath(op2)); // (#973)
   }
 
-  //------------------------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
   void AddLocMin(LocalMinimaList& list,
     Vertex& vert, PathType polytype, bool is_open)
   {
@@ -1126,21 +1148,19 @@ namespace Clipper2Lib {
         return newcomer.curr_x > resident.curr_x;
 
     //get the turning direction  a1.top, a2.bot, a2.top
-    double d = CrossProduct(resident.top, newcomer.bot, newcomer.top);
-    if (d != 0) return d < 0;
+    int i = CrossProductSign(resident.top, newcomer.bot, newcomer.top);
+    if (i != 0) return i < 0;
 
     //edges must be collinear to get here
     //for starting open paths, place them according to
     //the direction they're about to turn
     if (!IsMaxima(resident) && (resident.top.y > newcomer.top.y))
     {
-      return CrossProduct(newcomer.bot,
-        resident.top, NextVertex(resident)->pt) <= 0;
+      return (CrossProductSign(newcomer.bot, resident.top, NextVertex(resident)->pt) <= 0);
     }
     else if (!IsMaxima(newcomer) && (newcomer.top.y > resident.top.y))
     {
-      return CrossProduct(newcomer.bot,
-        newcomer.top, NextVertex(newcomer)->pt) >= 0;
+      return (CrossProductSign(newcomer.bot, newcomer.top, NextVertex(newcomer)->pt) >= 0);
     }
 
     int64_t y = newcomer.bot.y;
@@ -1155,7 +1175,7 @@ namespace Clipper2Lib {
       resident.bot, resident.top)) return true;
     else
       //compare turning direction of the alternate bound
-      return (CrossProduct(PrevPrevVertex(resident)->pt,
+      return (CrossProductSign(PrevPrevVertex(resident)->pt,
         newcomer.bot, PrevPrevVertex(newcomer)->pt) > 0) == newcomerIsLeft;
   }
 
@@ -1565,7 +1585,7 @@ namespace Clipper2Lib {
     FixSelfIntersects(outrec);
   }
 
-  void ClipperBase::DoSplitOp(OutRec* outrec, OutPt* splitOp)
+  void ClipperBase::DoSplitOp (OutRec* outrec, OutPt* splitOp)
   {
     // splitOp.prev -> splitOp &&
     // splitOp.next -> splitOp.next.next are intersecting
@@ -1574,7 +1594,7 @@ namespace Clipper2Lib {
     outrec->pts = prevOp;
 
     Point64 ip;
-    GetSegmentIntersectPt(prevOp->pt, splitOp->pt,
+    GetLineIntersectPt(prevOp->pt, splitOp->pt,
       splitOp->next->pt, nextNextOp->pt, ip);
 
 #ifdef USINGZ
@@ -1630,7 +1650,7 @@ namespace Clipper2Lib {
 
       if (using_polytree_)
       {
-        if (Path1InsidePath2(prevOp, newOp))
+        if (Path2ContainsPath1(prevOp, newOp))
         {
           newOr->splits = new OutRecList();
           newOr->splits->emplace_back(outrec);
@@ -1652,19 +1672,32 @@ namespace Clipper2Lib {
   void ClipperBase::FixSelfIntersects(OutRec* outrec)
   {
     OutPt* op2 = outrec->pts;
+    if (op2->prev == op2->next->next) 
+      return; // because triangles can't self-intersect
     for (; ; )
     {
-      // triangles can't self-intersect
-      if (op2->prev == op2->next->next) break;
       if (SegmentsIntersect(op2->prev->pt,
         op2->pt, op2->next->pt, op2->next->next->pt))
       {
-        if (op2 == outrec->pts || op2->next == outrec->pts)
-          outrec->pts = outrec->pts->prev;
-        DoSplitOp(outrec, op2);
-        if (!outrec->pts) break;
-        op2 = outrec->pts;
-        continue;
+        if (SegmentsIntersect(op2->prev->pt,
+          op2->pt, op2->next->next->pt, op2->next->next->next->pt))
+        {
+          // adjacent intersections (ie a micro self-intersections)
+          op2 = DuplicateOp(op2, false);
+          op2->pt = op2->next->next->next->pt;
+          op2 = op2->next;
+        }
+        else
+        {
+          if (op2 == outrec->pts || op2->next == outrec->pts)
+            outrec->pts = outrec->pts->prev;
+          DoSplitOp(outrec, op2);
+          if (!outrec->pts) break;
+          op2 = outrec->pts;
+          if (op2->prev == op2->next->next)
+            break; // again, because triangles can't self-intersect
+          continue;
+        }
       }
       else
         op2 = op2->next;
@@ -1805,14 +1838,14 @@ namespace Clipper2Lib {
 
       switch (fillrule_)
       {
-      case FillRule::Positive:
-        if (edge_c->wind_cnt != 1) return;
+      case FillRule::Positive: 
+        if (edge_c->wind_cnt != 1) return; 
         break;
-      case FillRule::Negative:
-        if (edge_c->wind_cnt != -1) return;
+      case FillRule::Negative: 
+        if (edge_c->wind_cnt != -1) return; 
         break;
-      default:
-        if (std::abs(edge_c->wind_cnt) != 1) return;
+      default: 
+        if (std::abs(edge_c->wind_cnt) != 1) return; 
       }
 
 #ifdef USINGZ
@@ -1933,7 +1966,7 @@ namespace Clipper2Lib {
     const bool e1_windcnt_in_01 = old_e1_windcnt == 0 || old_e1_windcnt == 1;
     const bool e2_windcnt_in_01 = old_e2_windcnt == 0 || old_e2_windcnt == 1;
 
-    if ((!IsHotEdge(e1) && !e1_windcnt_in_01) ||
+    if ((!IsHotEdge(e1) && !e1_windcnt_in_01) || 
       (!IsHotEdge(e2) && !e2_windcnt_in_01))
         return;
 
@@ -2112,10 +2145,9 @@ namespace Clipper2Lib {
       e->prev_in_sel = e->prev_in_ael;
       e->next_in_sel = e->next_in_ael;
       e->jump = e->next_in_sel;
-      if (e->join_with == JoinWith::Left)
-        e->curr_x = e->prev_in_ael->curr_x; // also avoids complications
-      else
-        e->curr_x = TopX(*e, top_y);
+      // it is safe to ignore 'joined' edges here because
+      // if necessary they will be split in IntersectEdges()
+      e->curr_x = TopX(*e, top_y);
       e = e->next_in_ael;
     }
   }
@@ -2262,15 +2294,14 @@ namespace Clipper2Lib {
 
   void MoveSplits(OutRec* fromOr, OutRec* toOr)
   {
-    if (!fromOr->splits) return;
     if (!toOr->splits) toOr->splits = new OutRecList();
     OutRecList::iterator orIter = fromOr->splits->begin();
     for (; orIter != fromOr->splits->end(); ++orIter)
-      toOr->splits->emplace_back(*orIter);
+      if (toOr != *orIter) // #987
+        toOr->splits->emplace_back(*orIter);
     fromOr->splits->clear();
   }
 
-
   void ClipperBase::ProcessHorzJoins()
   {
     for (const HorzJoin& j : horz_join_list_)
@@ -2299,8 +2330,8 @@ namespace Clipper2Lib {
         }
 
         if (using_polytree_) //#498, #520, #584, D#576, #618
-        {
-          if (Path1InsidePath2(or1->pts, or2->pts))
+        {          
+          if (Path2ContainsPath1(or1->pts, or2->pts))
           {
             //swap or1's & or2's pts
             OutPt* tmp = or1->pts;
@@ -2311,7 +2342,7 @@ namespace Clipper2Lib {
             //or2 is now inside or1
             or2->owner = or1;
           }
-          else if (Path1InsidePath2(or2->pts, or1->pts))
+          else if (Path2ContainsPath1(or2->pts, or1->pts))
           {
             or2->owner = or1;
           }
@@ -2324,13 +2355,14 @@ namespace Clipper2Lib {
         else
           or2->owner = or1;
       }
-      else
+      else // joining, not splitting
       {
         or2->pts = nullptr;
         if (using_polytree_)
         {
           SetOwner(or2, or1);
-          MoveSplits(or2, or1); //#618
+          if (or2->splits) 
+            MoveSplits(or2, or1); //#618
         }
         else
           or2->owner = or1;
@@ -2350,7 +2382,7 @@ namespace Clipper2Lib {
   void ClipperBase::AddNewIntersectNode(Active& e1, Active& e2, int64_t top_y)
   {
     Point64 ip;
-    if (!GetSegmentIntersectPt(e1.bot, e1.top, e2.bot, e2.top, ip))
+    if (!GetLineIntersectPt(e1.bot, e1.top, e2.bot, e2.top, ip))
       ip = Point64(e1.curr_x, top_y); //parallel edges
 
     //rounding errors can occasionally place the calculated intersection
@@ -2934,22 +2966,28 @@ namespace Clipper2Lib {
 
   bool ClipperBase::CheckSplitOwner(OutRec* outrec, OutRecList* splits)
   {
-    for (auto split : *splits)
+    // nb: use indexing (not an iterator) in case 'splits' is modified inside this loop (#1029)
+    for (size_t idx = 0; idx < splits->size(); ++idx)
     {
+      OutRec* split = (*splits)[idx]; 
+      if (!split->pts && split->splits &&
+        CheckSplitOwner(outrec, split->splits)) return true; //#942
       split = GetRealOutRec(split);
-      if(!split || split == outrec || split->recursive_split == outrec) continue;
+      if (!split || split == outrec || split->recursive_split == outrec) continue;
       split->recursive_split = outrec; // prevent infinite loops
 
       if (split->splits && CheckSplitOwner(outrec, split->splits))
-          return true;
-      else if (CheckBounds(split) &&
-        IsValidOwner(outrec, split) &&
-        split->bounds.Contains(outrec->bounds) &&
-        Path1InsidePath2(outrec->pts, split->pts))
-      {
-        outrec->owner = split; //found in split
-        return true;
-      }
+        return true;    
+
+      if (!CheckBounds(split) || !split->bounds.Contains(outrec->bounds) ||
+        !Path2ContainsPath1(outrec->pts, split->pts)) continue;
+     
+      if (!IsValidOwner(outrec, split)) // split is owned by outrec! (#957)
+          split->owner = outrec->owner;
+
+      outrec->owner = split;
+      return true;
+      
     }
     return false;
   }
@@ -2960,13 +2998,12 @@ namespace Clipper2Lib {
     // post-condition: if a valid path, outrec will have a polypath
 
     if (outrec->polypath || outrec->bounds.IsEmpty()) return;
-
     while (outrec->owner)
     {
       if (outrec->owner->splits && CheckSplitOwner(outrec, outrec->owner->splits)) break;
       if (outrec->owner->pts && CheckBounds(outrec->owner) &&
         outrec->owner->bounds.Contains(outrec->bounds) &&
-        Path1InsidePath2(outrec->pts, outrec->owner->pts)) break;
+        Path2ContainsPath1(outrec->pts, outrec->owner->pts)) break;
       outrec->owner = outrec->owner->owner;
     }
 
@@ -3029,6 +3066,7 @@ namespace Clipper2Lib {
     {
       OutRec* outrec = outrec_list_[i];
       if (!outrec || !outrec->pts) continue;
+
       if (outrec->is_open)
       {
         Path64 path;

deps_src/clipper2/Clipper2Lib/src/clipper.offset.cpp

@@ -1,6 +1,6 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  22 January 2025                                                 *
+* Date      :  11 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
 * Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  Path Offset (Inflate/Shrink)                                    *
@@ -37,29 +37,35 @@ const double arc_const = 0.002; // <-- 1/500
 // Miscellaneous methods
 //------------------------------------------------------------------------------
 
-std::optional<size_t> GetLowestClosedPathIdx(const Paths64& paths)
+void GetLowestClosedPathInfo(const Paths64& paths, std::optional<size_t>& idx, bool& is_neg_area)
 {
-    std::optional<size_t> result;
+	idx.reset();
 	Point64 botPt = Point64(INT64_MAX, INT64_MIN);
 	for (size_t i = 0; i < paths.size(); ++i)
 	{
+		double a = MAX_DBL;
 		for (const Point64& pt : paths[i])
 		{
 			if ((pt.y < botPt.y) ||
 				((pt.y == botPt.y) && (pt.x >= botPt.x))) continue;
-            result = i;
+			if (a == MAX_DBL) 
+			{
+				a = Area(paths[i]);
+				if (a == 0) break; // invalid closed path, so break from inner loop
+				is_neg_area = a < 0;
+			}
+      idx = i;
 			botPt.x = pt.x;
 			botPt.y = pt.y;
 		}
 	}
-	return result;
 }
 
 inline double Hypot(double x, double y)
 {
 	// given that this is an internal function, and given the x and y parameters
 	// will always be coordinate values (or the difference between coordinate values),
-	// x and y should always be within INT64_MIN to INT64_MAX. Consequently,
+	// x and y should always be within INT64_MIN to INT64_MAX. Consequently, 
 	// there should be no risk that the following computation will overflow
 	// see https://stackoverflow.com/a/32436148/359538
 	return std::sqrt(x * x + y * y);
@@ -145,15 +151,16 @@ ClipperOffset::Group::Group(const Paths64& _paths, JoinType _join_type, EndType
 
 	if (end_type == EndType::Polygon)
 	{
-		lowest_path_idx = GetLowestClosedPathIdx(paths_in);
+		bool is_neg_area;
+		GetLowestClosedPathInfo(paths_in, lowest_path_idx, is_neg_area);
 		// the lowermost path must be an outer path, so if its orientation is negative,
 		// then flag the whole group is 'reversed' (will negate delta etc.)
 		// as this is much more efficient than reversing every path.
-    is_reversed = (lowest_path_idx.has_value()) && Area(paths_in[lowest_path_idx.value()]) < 0;
+    is_reversed = lowest_path_idx.has_value() && is_neg_area;
 	}
 	else
 	{
-    lowest_path_idx = std::nullopt;
+    lowest_path_idx.reset();
 		is_reversed = false;
 	}
 }
@@ -236,7 +243,7 @@ void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
 	{
 		PointD pt4 = PointD(pt3.x + vec.x * group_delta_, pt3.y + vec.y * group_delta_);
 		PointD pt = ptQ;
-		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
 		//get the second intersect point through reflecion
         path_out.emplace_back(ReflectPoint(pt, ptQ));
         path_out.emplace_back(pt);
@@ -245,7 +252,7 @@ void ClipperOffset::DoSquare(const Path64& path, size_t j, size_t k)
 	{
 		PointD pt4 = GetPerpendicD(path[j], norms[k], group_delta_);
 		PointD pt = ptQ;
-		GetSegmentIntersectPt(pt1, pt2, pt3, pt4, pt);
+		GetLineIntersectPt(pt1, pt2, pt3, pt4, pt);
         path_out.emplace_back(pt);
 		//get the second intersect point through reflecion
         path_out.emplace_back(ReflectPoint(pt, ptQ));
@@ -291,7 +298,8 @@ void ClipperOffset::DoRound(const Path64& path, size_t j, size_t k, double angle
 #else
     path_out.emplace_back(pt.x + offsetVec.x, pt.y + offsetVec.y);
 #endif
-	int steps = static_cast<int>(std::ceil(steps_per_rad_ * std::abs(angle))); // #448, #456
+	// Orca: round the step count like Clipper1 did, so round offsets keep their vertices.
+	int steps = std::max(static_cast<int>(std::round(steps_per_rad_ * std::abs(angle))), 1);
 	for (int i = 1; i < steps; ++i) // ie 1 less than steps
 	{
 		offsetVec = PointD(offsetVec.x * step_cos_ - step_sin_ * offsetVec.y,
@@ -333,9 +341,9 @@ void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size
 	if (cos_a > -0.999 && (sin_a * group_delta_ < 0)) // test for concavity first (#593)
 	{
 		// is concave
-		// by far the simplest way to construct concave joins, especially those joining very
-		// short segments, is to insert 3 points that produce negative regions. These regions
-		// will be removed later by the finishing union operation. This is also the best way
+		// by far the simplest way to construct concave joins, especially those joining very 
+		// short segments, is to insert 3 points that produce negative regions. These regions 
+		// will be removed later by the finishing union operation. This is also the best way 
 		// to ensure that path reversals (ie over-shrunk paths) are removed.
 #ifdef USINGZ
         path_out.emplace_back(GetPerpendic(path[j], norms[k], group_delta_), path[j].z);
@@ -366,11 +374,31 @@ void ClipperOffset::OffsetPoint(Group& group, const Path64& path, size_t j, size
 		DoSquare(path, j, k);
 }
 
+// Orca: join concave corners at the crossing of both edge offsets where safe, 3-point loops make dense inward offsets slow.
+static bool OffsetConcaveCrossing(const Path64& path, const PathD& norms, size_t j, size_t k, size_t next,
+	double delta, Path64& path_out)
+{
+	const double sin_a = CrossProduct(norms[j], norms[k]);
+	const double cos_a = DotProduct(norms[j], norms[k]);
+	if (cos_a <= -0.999 || sin_a * delta >= 0) return false;
+	const double x = std::fabs(delta * sin_a) / (1 + cos_a);
+	if (4 * x * x > DistanceSqr(path[k], path[j]) || 4 * x * x > DistanceSqr(path[j], path[next])) return false;
+	const double q = delta / (1 + cos_a);
+#ifdef USINGZ
+	path_out.emplace_back(path[j].x + (norms[k].x + norms[j].x) * q, path[j].y + (norms[k].y + norms[j].y) * q, path[j].z);
+#else
+	path_out.emplace_back(path[j].x + (norms[k].x + norms[j].x) * q, path[j].y + (norms[k].y + norms[j].y) * q);
+#endif
+	return true;
+}
+
 void ClipperOffset::OffsetPolygon(Group& group, const Path64& path)
 {
 	path_out.clear();
 	for (Path64::size_type j = 0, k = path.size() - 1; j < path.size(); k = j, ++j)
-		OffsetPoint(group, path, j, k);
+		if (deltaCallback64_ || path[j] == path[k] ||
+			!OffsetConcaveCrossing(path, norms, j, k, j + 1 == path.size() ? 0 : j + 1, group_delta_, path_out))
+			OffsetPoint(group, path, j, k);
     solution->emplace_back(path_out);
 }
 
@@ -380,7 +408,7 @@ void ClipperOffset::OffsetOpenJoined(Group& group, const Path64& path)
 	Path64 reverse_path(path);
 	std::reverse(reverse_path.begin(), reverse_path.end());
 
-	//rebuild normals
+	//rebuild normals 
 	std::reverse(norms.begin(), norms.end());
     norms.emplace_back(norms[0]);
 	norms.erase(norms.begin());
@@ -601,10 +629,10 @@ void ClipperOffset::ExecuteInternal(double delta)
 
 	if (!solution->size()) return;
 
-		bool paths_reversed = CheckReverseOrientation();
+	bool paths_reversed = CheckReverseOrientation();
 	//clean up self-intersections ...
 	Clipper64 c;
-	c.PreserveCollinear(false);
+	c.PreserveCollinear(preserve_collinear_);
 	//the solution should retain the orientation of the input
 	c.ReverseSolution(reverse_solution_ != paths_reversed);
 #ifdef USINGZ

deps_src/clipper2/Clipper2Lib/src/clipper.rectclip.cpp

@@ -1,8 +1,8 @@
 /*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  5 July 2024                                                     *
+* Date      :  11 October 2025                                                 *
 * Website   :  https://www.angusj.com                                          *
-* Copyright :  Angus Johnson 2010-2024                                         *
+* Copyright :  Angus Johnson 2010-2025                                         *
 * Purpose   :  FAST rectangular clipping                                       *
 * License   :  https://www.boost.org/LICENSE_1_0.txt                           *
 *******************************************************************************/
@@ -77,8 +77,8 @@ namespace Clipper2Lib {
   bool GetSegmentIntersection(const Point64& p1,
     const Point64& p2, const Point64& p3, const Point64& p4, Point64& ip)
   {
-    double res1 = CrossProduct(p1, p3, p4);
-    double res2 = CrossProduct(p2, p3, p4);
+    int res1 = CrossProductSign(p1, p3, p4);
+    int res2 = CrossProductSign(p2, p3, p4);
     if (res1 == 0)
     {
       ip = p1;
@@ -97,8 +97,8 @@ namespace Clipper2Lib {
     }
     if ((res1 > 0) == (res2 > 0)) return false;
 
-    double res3 = CrossProduct(p3, p1, p2);
-    double res4 = CrossProduct(p4, p1, p2);
+    int res3 = CrossProductSign(p3, p1, p2);
+    int res4 = CrossProductSign(p4, p1, p2);
     if (res3 == 0)
     {
       ip = p3;
@@ -116,7 +116,7 @@ namespace Clipper2Lib {
     if ((res3 > 0) == (res4 > 0)) return false;
 
     // segments must intersect to get here
-    return GetSegmentIntersectPt(p1, p2, p3, p4, ip);
+    return GetLineIntersectPt(p1, p2, p3, p4, ip);
   }
 
   inline bool GetIntersection(const Path64& rectPath,
@@ -227,7 +227,7 @@ namespace Clipper2Lib {
     const Point64& prev_pt, const Point64& curr_pt, const Point64& rect_mp)
   {
     if (AreOpposites(prev, curr))
-      return CrossProduct(prev_pt, rect_mp, curr_pt) < 0;
+      return CrossProductSign(prev_pt, rect_mp, curr_pt) < 0;
     else
       return HeadingClockwise(prev, curr);
   }

deps_src/clipper2/Clipper2Lib/src/clipper2_z.cpp

@@ -6,3 +6,4 @@
 #include "clipper.engine.cpp"
 #include "clipper.offset.cpp"
 #include "clipper.rectclip.cpp"
+#include "clipper.triangulation.cpp"

deps_src/libnest2d/include/libnest2d/backends/libslic3r/geometries.hpp

@@ -132,14 +132,14 @@ template<>
 inline void offset(Slic3r::ExPolygon& sh, coord_t distance, const PolygonTag&)
 {
 #define DISABLE_BOOST_OFFSET
-    auto res = Slic3r::offset_ex(sh, distance, Slic3r::ClipperLib::jtSquare);
+    auto res = Slic3r::offset_ex(sh, distance, Slic3r::jtSquare);
     if (!res.empty()) sh = res.front();
 }
 
 template<>
 inline void offset(Slic3r::Polygon& sh, coord_t distance, const PathTag&)
 {
-    auto res = Slic3r::offset(sh, distance, Slic3r::ClipperLib::jtSquare);
+    auto res = Slic3r::offset(sh, distance, Slic3r::jtSquare);
     if (!res.empty()) sh = res.front();
 }
 

deps_src/qhull/CMakeLists.txt

@@ -19,11 +19,7 @@ if(Qhull_FOUND)
 message(STATUS "Using qhull from system.")
 if(SLIC3R_STATIC)
     slic3r_remap_configs("Qhull::qhullcpp;Qhull::qhullstatic_r" RelWithDebInfo Release)
-    if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-        target_link_libraries(qhull INTERFACE Qhull::qhullcpp_d Qhull::qhullstatic_rd)
-    else()
-        target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhullstatic_r)
-    endif()
+    target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhullstatic_r)
 else()
     slic3r_remap_configs("Qhull::qhullcpp;Qhull::qhull_r" RelWithDebInfo Release)
     target_link_libraries(qhull INTERFACE Qhull::qhullcpp Qhull::qhull_r)

docs/HLSD/deferred-page-construction.md

@@ -38,7 +38,11 @@ no wx dependency and is unit-tested.
 The notebook needs a page object for a tab to exist and for tabs to be inserted and
 removed by pointer, and the placeholder is that object. It builds the real panel inside
 itself the first time it is shown and forwards showing and hiding afterwards, so a panel's
-own show handling stays its activation hook. Nothing builds while the main window is
+own show handling stays its activation hook. The build runs before the placeholder shows
+itself, so a panel built on demand is created in a hidden window as a prebuilt one is: on
+Windows every control created or moved inside a shown window re-clips and repaints its
+shown siblings, which makes building a large panel into a shown page many times slower.
+Nothing builds while the main window is
 hidden; the window's first show builds the start page. A page that is out of the book is
 not prebuilt. A panel built while its page is hidden stays hidden, and gets the theming
 the window applied before the panel existed.

docs/HLSD/design-tab.md

@@ -13,8 +13,9 @@ known.
 Its coupling to the rest of the application is deliberately narrow. It adds no stage to the
 slicing pipeline and touches neither the preset system nor `Tab`. It reaches the rest of Orca
 in two places: **Commit to Plate**, which hands finished solids to Prepare as ordinary model
-objects, and one optional 3MF archive entry that carries the recipe. Everything else is
-contained in `src/libslic3r/CAD/` and `src/slic3r/GUI/CAD/`.
+objects (by default one assembly object with a part per body, which keeps the bodies' relative
+placement, or one object per body), and one optional 3MF archive entry that carries the recipe.
+Everything else is contained in `src/libslic3r/CAD/` and `src/slic3r/GUI/CAD/`.
 
 The user-facing manual lives in the wiki
 ([Design Tab](https://www.orcaslicer.com/wiki/design_tab)), not here. This document covers the
@@ -51,14 +52,13 @@ widens the existing OCCT build by one module flag in `deps/OCCT/OCCT.cmake`:
 -DBUILD_MODULE_ModelingAlgorithms=${SLIC3R_CAD}
 ```
 
-Most of that module's twelve toolkits were already being built, because `DataExchange` — the
-STEP path upstream ships — depends on them. The delta is `TKFillet` (used through
-`BRepFilletAPI`), `TKOffset` (`BRepOffsetAPI`) and `TKFeat`, which nothing here references but
-which the module flag builds anyway, because OCCT's module flags are all-or-nothing. On macOS
-and Linux OCCT links statically, so an unreferenced toolkit costs build time and no shipped
-bytes; on Windows OCCT builds shared, so the cost there is real DLL bytes. That Windows figure
-has not been measured, and `OCCT.cmake` says so rather than carrying a number that was derived
-from an incomplete toolkit list.
+Most of that module's toolkits are built either way, because `DataExchange`, which the STEP
+importer uses, depends on them. With the flag on, OCCT also builds `TKFillet` (used through
+`BRepFilletAPI`), `TKOffset` (`BRepOffsetAPI`), and `TKFeat`, `TKHelix`, `TKXMesh` and
+`TKExpress`, which nothing here references but which the module flag builds anyway, because
+OCCT's module flags are all-or-nothing. On macOS and Linux OCCT links statically, so an
+unreferenced toolkit costs build time and no shipped bytes. On Windows OCCT builds shared and
+only the linked toolkits ship, so the tab adds the `TKFillet`, `TKOffset` and `TKBool` DLLs.
 
 On Windows the packaging step asserts that every linked OCCT toolkit has a shipped DLL and
 fails the configure with the name of any that is missing, because the alternative failure — a
@@ -117,6 +117,11 @@ that keep it survivable are:
 `Import` features embed the imported solid as an OCCT BRep string inside the recipe rather than
 referencing the source file, so a project opens without the STEP or mesh it was built from.
 The cost is that saved projects are coupled to an OCCT BRep revision.
+`tests/data/cad_brep_occt76.brep` holds a solid written by OCCT 7.6, and its test fails if the
+bundled OCCT can no longer read it.
+A Text feature follows the same rule: it stores the outlines it was vectorised into alongside
+its string, font and height, so the project opens identically on a machine that lacks the font;
+the three parameters are only what an edit reopens the dialog with.
 
 ## The interaction contract
 
@@ -131,7 +136,7 @@ contract between them is stated in code rather than spread across handlers.
 | `Transient` | a value field or a popup menu | closes it; the tool stays armed |
 | `Gesture` | an uncommitted delta — an entity being drawn, a body being dragged | reverts it; committed work is untouched |
 | `Tool` | a feature card, an armed sketch tool, a constrain session | exits it; drawn entities survive |
-| `Idle` | nothing transient | clears the selection; leaves a sketch session only if it is empty |
+| `Idle` | nothing transient | clears the selection, a Feature tree or Bodies row included; leaves a sketch session only if it is empty |
 
 `cad_escape_level()` is a `constexpr` free function over a POD of four booleans rather than a
 method on the panel, so the ordering that is the entire contract is checkable without a window,
@@ -144,26 +149,126 @@ explicit selection, the sketch ribbon's Cancel, which asks first, or `Ctrl+Z`. A
 *session* is deliberately not a `Tool` level; it is the environment the `Idle` level lives in,
 which makes the destructive path unrepresentable rather than merely unlikely.
 
-Right-click is read at button-up against two independent budgets — 3 px of drift and 200 ms —
-because drift alone still popped a menu at the end of a slow, careful orbit. The raycast uses
-the press position, not the release. An armed sketch tool that already consumed the right
+Right-click is read at button-up against one budget, 3 px of drift, applied to the whole press
+rather than to its end points: a press that wandered past the budget at any moment is
+navigation, even if it comes back to where it started, which is what stops a slow, careful
+orbit from ending in a menu. There is no time budget — a gesture that means something different
+when it is slow is exactly what the interaction charter rules out. The raycast uses the press
+position, not the release. An armed sketch tool that already consumed the right
 button (to terminate a chain, say) declines to also open a menu, through a read-and-clear flag.
 Past either budget the event is navigation, and navigation does not transition the state
 machine.
 
+Navigation itself is Prepare's: the camera reads the drag actions set in Preferences > Control
+for each button. The left button is shared with picking, so a whole body is swept with a
+rectangle on plain left-drag only while no camera action is assigned to it, and with
+Shift+left-drag otherwise — Prepare's own rectangle selection.
+
 Entering a sketch changes three things at once so the mode is legible: a banner above the
 canvas (a sibling of the canvas, not a child over it — on GTK a child window over a
 `wxGLCanvas` is a native window and does not reliably stack over GL), the printer bed muted so
 a plate grid is never read as a sketch grid, and `N` to look normal to the plane. Code that
 changes any of the three belongs with a change to this section.
 
+## Rendering the bodies
+
+The tab draws its bodies through the same `GLCanvas3D` object path as Prepare, so how they look
+is decided in the shared object shader, not in the tab. The slicer's two lights both sit near
+the camera, which leaves the sides of a part in nearly one tone; the Design canvas asks for a
+studio model instead — a world-space sky/ground hemisphere, a key and a fill light, a
+plastic-like highlight and a darker silhouette — through `GLCanvas3D::set_studio_lighting()`
+and the phong shader's `lighting_model` uniform. The program is shared by every canvas, so each
+use sets the uniform (0 for the slicer's canvases) rather than relying on a default: a canvas
+that left it alone would inherit whatever the last canvas chose.
+
+The B-rep edges of every body are drawn over it by the sketch overlay as thin view-facing
+ribbons, depth tested and pulled a few pixels toward the eye so they win against the faces that
+meet at them and still hide behind faces in front; lines are not used because they do not
+rasterise under the software GL context the tab also supports. Seams of closed surfaces and
+degenerate edges are left out (`GeometryEngine::display_edges`), and the polylines are sampled
+once per shape, keyed by its `TShape`, because a recompute that leaves a body unchanged is the
+common case.
+
+While a feature card is open, its preview ghost is the whole model the candidate would produce,
+drawn translucent over the bodies, so every face the feature leaves alone is in both at the same
+depth. The ghost is drawn with a depth bias that pushes it back (`GLVolume::depth_bias`), so on a shared face
+the body always wins instead of the two copies z-fighting, and the ghost shows only where the
+result reaches past the bodies. Material a feature removes lies inside the old solid and would not
+show at all, so the tools whose result mostly coincides with the body — Fillet/Chamfer, Draft,
+Hole and the Mate hover — hide the bodies once the preview is valid and draw the result alone,
+opaque.
+
+## Showing what is selected
+
+A selection is drawn on the faces it names, never as a tint over the body: a translucent
+selection colour blended into the body's own colour turns a different hue on every body and
+vanishes on one close to it. Selected faces are split out of their body into a volume of their
+own, which the canvas draws opaque in the selection colour through the same shader and lighting
+as the body (`DesignCanvas::rebuild_bodies`); the sketch overlay outlines them with a cased line
+— a dark band under a selection-coloured one — so the outline still reads on a body that wears
+the selection colour itself. A body picked whole, a face picked in the viewport and the faces of
+the Feature tree's selected feature all draw this way. The hover pre-highlight is the outline
+alone, uncased: it promises a click, it is not one. The automatic body colours keep clear of the
+selection colour's blues and teals, so no body looks selected before anything is picked; a colour
+the user sets on a body is theirs, and the cased outline keeps its selection readable.
+
+Selecting a feature row lights the faces that feature made, not the whole body it sits on, so a
+fillet row shows its round and the extrude under it keeps the faces the fillet trimmed.
+`CadDocument::faces_made_by` answers it without per-feature history: it replays the recipe to
+just before the feature and then the feature alone, and a face of the finished model belongs to
+the feature when an interior point of it lies on the boundary afterwards and not before, facing
+the same way — the facing keeps a block stacked on a base the owner of its bottom face. A feature
+that makes no face of its own, such as a Boolean union, answers with the bodies it changed. The
+replay costs up to a recompute, so the panel finds the faces once per row and topology
+generation, off the UI thread, and only while no feature card is open. One selection is live at
+a time: a viewport pick clears the feature row and a feature row clears the viewport pick, as the
+Feature tree and Bodies list do between themselves. `Esc`, a click on empty space and an
+empty rubber band all let go of it, whichever list or pick made it.
+
+## Following the app
+
+The tab is a page of Orca's main window and answers to the same settings as Prepare.
+
+- **Theme.** Its chrome is coloured from a table of light/dark token pairs. A theme switch
+  reaches `DesignPanel::on_sys_color_changed` from `MainFrame`, which moves every colour that is
+  one theme's token onto the other theme's and then runs the app's own dark pass; the icons are
+  Orca's sidebar grey, which the icon cache maps per theme, so they are re-rasterised rather
+  than re-tinted.
+- **Scale.** Sizes are in DIP, and a DPI change reaches `DesignPanel::msw_rescale`, which
+  re-rasterises every icon (button faces, flyout rows, card headers, the feature and body lists'
+  row icons).
+- **Sidebar icons.** Every clickable icon in the sidebar shows a hover chip. The card-header and
+  constraint-row buttons are Orca's self-painted `Button`, because a native button cannot take a
+  hover background on macOS. The Feature tree and Bodies lists are a custom-drawn
+  `DesignRowList` rather than a `wxTreeCtrl`, so each row carries its own actions — Edit,
+  Show/hide and Delete on a feature, Move, Show/hide and Delete on a body — and the eye shows
+  whether that row is hidden.
+- **Viewport text.** The status line and the active tool's values are drawn by the canvas in
+  its ImGui pass, so they go with the canvas: a top-level window over GL does not follow its
+  frame and was left floating over other applications.
+- **Undo.** The tab keeps its own history (the recipe is not part of Prepare's snapshots), but
+  it has no Undo/Redo of its own: the top bar, `Ctrl+Z` and Edit drive it while the tab is
+  shown, greyed to what an undo would actually do.
+- **Docking.** The sidebar docks like Prepare's — either side, floating, resized, or collapsed
+  with the canvas's collapse button or `Shift+Tab` — through its own AUI manager under the
+  toolbar, because Prepare's manages the Plater and the Plater is not on this page. The button is
+  the canvas's own toolbar rather than Prepare's, which collapses Prepare's sidebar. The layout,
+  collapse included, is kept apart from Prepare's (`design_window_layout`) and starts where
+  Prepare's sidebar is, at its width, so the canvas edge holds still across the tab switch until
+  the user moves one of them. A floating sidebar is a top-level window, so it is hidden with the
+  tab rather than left over the other pages, and View > Reset Window Layout resets both tabs.
+
 ## The offer is generated, not hand-written
 
 Right-clicking geometry opens the *offer*: eight families in a fixed order, each verb at a
 permanent row index, verbs that do not apply shown disabled **in place with their reason**
 rather than removed. The invariant is that a verb's row index is identical in every selection
 where it appears and that adding a verb never moves an existing one — the hand learns the
-position, so the menu is never re-sorted, compacted or adaptively ordered.
+position, so the menu is never re-sorted, compacted or adaptively ordered. Above the families
+sits one *flat* row, holding Rename and Color — what a selection is opened for most: its verbs are
+items of their own at the top of the menu rather than a family's submenu. It is appended after
+the eight, so it moved no existing index, and it reads the same from the viewport and from a row
+of the Bodies list.
 
 An invariant across 92 verbs and 20 selection kinds does not survive by review, so the map
 exists once, as data: `scripts/CAD/tool_atlas.json` carries every verb with its row, key, icon,
@@ -194,6 +299,7 @@ scripted action and a clicked one cannot diverge. It is off unless the variable
 | `src/libslic3r/CAD/SketchSolver.*` | constraint solving, over the vendored solver |
 | `src/libslic3r/slvs/` | vendored 2D constraint solver (GPLv3) |
 | `src/slic3r/GUI/CAD/DesignPanel.*` | the tab: toolbar, feature cards, tree, key maps |
+| `src/slic3r/GUI/CAD/DesignRowList.*` | the Feature tree and Bodies lists, with per-row actions |
 | `src/slic3r/GUI/CAD/DesignCanvas.*` | viewport integration |
 | `src/slic3r/GUI/CAD/DesignSketchTool.*` | in-canvas sketching |
 | `src/slic3r/GUI/CAD/DesignInteraction.hpp` | the Esc level contract |

docs/HLSD/polygon-clipping.md

@@ -0,0 +1,131 @@
+# Polygon Clipping — High Level Design
+
+## Purpose and scope
+
+Almost every stage of slicing works on 2D regions: slices, perimeters, infill
+areas, bridges, supports and brims are all produced by boolean operations and
+offsets on polygons. libslic3r does this through two interfaces, both built on
+the Clipper2 library vendored in `deps_src/clipper2`:
+
+- `ClipperUtils` (`src/libslic3r/ClipperUtils.hpp`) takes and returns Slic3r
+  geometry: `Polygon(s)`, `ExPolygon(s)`, `Polyline(s)`, `Lines` and
+  `Surfaces`. It provides unions, intersections, differences and xor, closed
+  and open offsets, morphological opening and closing, variable width offsets
+  and polyline clipping.
+- `ClipperZUtils` (`src/libslic3r/ClipperZUtils.hpp`) clips paths whose
+  vertices carry a Z value, which callers use to tag vertices with a source
+  index or an extrusion width.
+
+No other code calls Clipper2.
+
+`ClipperUtils` declares its own `JoinType`, `EndType`, `PolyFillType` and
+`ClipType` enums and maps them to Clipper2's. Every call builds its own
+Clipper2 objects and shares no state, so slicing threads can clip
+concurrently.
+
+Clipping is one of the largest costs of slicing, and nearly all of it goes
+through `ClipperUtils`. The layer is therefore designed for throughput as much
+as for predictable geometry.
+
+## Vendored Clipper2
+
+`deps_src/clipper2` builds the static target `Clipper2`. It carries four
+changes to the upstream sources that must be carried over when Clipper2 is
+updated. The namespace switch sits at the top of every header and source, the
+other three are marked with `Orca:` comments.
+
+| Change | Files | Why |
+| --- | --- | --- |
+| Z build in its own namespace | all headers and sources, `clipper2_z.cpp`, `clipper2_z.hpp` | The library is compiled a second time with `USINGZ` in namespace `Clipper2Lib_Z`, so the 2D and the Z variants link into one binary. |
+| Engine nodes from tbbmalloc | `clipper.engine.h`, `clipper.engine.cpp` | Vertices, active edges, output points and records, local minima and `PolyTree` nodes are allocated one by one. `CLIPPER2_NODE_ALLOCATOR` routes them through `scalable_malloc`, because the default heap does not scale when all slicing threads clip at once. |
+| Concave joins at the edge crossing | `clipper.offset.cpp` | For closed paths, a concave corner is joined at the crossing of the two offset edges when that point lies within half of both adjacent edges. The upstream 3-point loop makes inward offsets of dense curves very slow to union. |
+| Rounded arc steps | `clipper.offset.cpp` | Round joins use the rounded number of steps, not the ceiling, which keeps the vertex count of round offsets that the rest of the code is tuned for. |
+
+## ClipperUtils semantics
+
+The callers of `ClipperUtils` rely on a fixed set of behaviours. Where
+Clipper2 behaves differently by default, the wrapper adjusts it.
+
+### Booleans
+
+- The fill rule is non-zero unless the function takes a `PolyFillType`. One
+  rule applies to both subject and clip; Clipper2 has no per-operand rule.
+- Collinear vertices are removed from the result. Clipper2 keeps them by
+  default, so every boolean sets `PreserveCollinear(false)`.
+- Outer contours are CCW and holes are CW. No output contour touches
+  itself: where one would pass twice through a vertex, it is split there into
+  two contours.
+- `ExPolygons` results are built from one `PolyTree64` pass. An island inside
+  a hole becomes an `ExPolygon` of its own.
+- `ApplySafetyOffset::Yes` grows the clip polygons by `ClipperSafetyOffset`
+  before an intersection or a difference, so that edges shared by subject and
+  clip do not leave slivers.
+- Open polylines are clipped with the non-zero rule and keep their direction.
+
+### Offsets
+
+- Before offsetting, input vertices closer than
+  `ClipperOffsetShortestEdgeFactor` × |delta| to the previously kept vertex
+  are dropped. This bounds the work on dense contours, and the error it
+  introduces is far below the offset distance.
+- The miter limit is at least 2. For `jtRound`, a positive `miterLimit`
+  argument is the arc tolerance, capped at |delta| / 4, and 0.25 is used
+  otherwise. Other joins use the smaller of 0.25 and |delta| / 4 for round end
+  caps.
+- A single `Polygon` keeps its orientation: a CCW polygon grows with a
+  positive delta, a CW polygon is a hole and shrinks.
+- `Polygons` follow the same rule per path. When every CW path lies strictly
+  inside the bounding box of a CCW path, which is the usual case of contours
+  with their holes, all paths are offset in one Clipper2 group. Otherwise
+  each path is offset on its own and the results are united, with the
+  non-zero rule when growing and the positive rule when shrinking.
+- `ExPolygons` and `Surfaces` are offset as one group after the contours are
+  oriented CCW and the holes CW, whatever their input orientation.
+- Zero-area paths vanish under a negative offset instead of growing.
+- Polyline offsets use the requested end type. Clipper2 already unites the
+  result, so no further union is done.
+
+### Coordinate range
+
+Clipper2 computes intersections and slopes in doubles, which hold integers
+exactly only up to 2^53 (about 9e15 units, 9,000 km). Geometry passed to
+`ClipperUtils` must stay well inside that range; near the int64 limit the
+results shift by hundreds of units. This is why the arrange `InfiniteBed` is a
+box of ±2^50 units around its centre rather than libnest2d's infinite box,
+which reaches ±2.3e18.
+
+## ClipperZUtils
+
+`ZPoint` is a `Vec3crd`, and a `ZPath` is a vector of them.
+`clip_zpaths()` runs one boolean with the non-zero rule on the Clipper2 Z
+build. The subject may be open, the clip is closed, and the result lists the
+closed paths before the open ones.
+
+The Z of each output vertex follows these rules:
+
+- An input vertex keeps its Z.
+- An intersection that lies on an end point of one of the two crossing edges
+  takes that end point's Z, preferring the subject edge.
+- Any other intersection gets its Z from the callback, which receives both
+  crossing edges, the subject edge first.
+
+Clipper2 calls the callback only when it creates an output vertex at an
+intersection, not for every crossing it processes. A callback that records
+intersections, like `ClipperZIntersectionVisitor`, therefore sees only those.
+
+The users are:
+
+| User | Z carries |
+| --- | --- |
+| `Algorithm::wave_seeds()` (region expansion) | source and boundary index; intersections get a negative index into the visitor's list of crossing pairs |
+| `Algorithm::split_line()` | index of the source vertex; an intersection gets the negated index of its source edge, so the pieces can be put back in path order |
+| `PerimeterGenerator` overhang and top-surface clipping of Arachne walls | extrusion width, interpolated along the edge at intersections |
+| Tree support anchors in `SupportCommon` | index of the source contour, -1 at intersections |
+| `extrusion_paths_append()` | extrusion width, turned into extrusion paths |
+
+## Testing
+
+`tests/libslic3r/test_clipper_utils.cpp` and `test_clipper_offset.cpp` cover
+the wrapper's booleans, orientation and offset rules. The perimeter, support
+and region expansion users are exercised by the slicing tests in
+`tests/fff_print`.

docs/HLSD/precise-seam.md

@@ -2,238 +2,584 @@
 
 ## Purpose and scope
 
-Precise Seam places the seam where a helper volume intersects the external
-wall. The user attaches a mesh to an object as a Precise Seam modifier, and on
-every layer the seam placer reads the modifier's slice to decide where the seam
-of each external perimeter may, must or must not go. The same mesh keeps
-working after the model changes, so the seam does not have to be repainted
-after every design revision, and a swept helper body can guide the seam along
-any path.
+Precise Seam lets a helper volume decide where the seam of an object goes. The
+user attaches a mesh to an object as a Precise Seam modifier. On every layer,
+the part of the external perimeter that lies inside the modifier's slice
+determines where the seam must, may or must not be placed. The helper is a
+persistent model object rather than paint on the surface, so it keeps working
+when the design changes. A body swept along a path on the surface can guide the
+seam along any trajectory.
 
-The modifier is non-printing geometry. It does not take part in slicing, region
-assignment, filament selection or brim adhesion. It affects only seam
-placement, which runs during G-code export.
+The modifier is non-printing geometry. It takes no part in object slicing,
+region assignment, filament selection or brim adhesion, and it affects only seam
+placement during G-code export. Objects without Precise Seam volumes follow the
+regular seam placement unchanged.
 
-## Volume types and priority
+Precise Seam does not replace the seam placer. It feeds it: a modifier inserts
+the points it needs into the perimeter and changes the enforced/blocked type of
+seam candidates, the same typing mechanism as seam painting, and the configured
+seam position then chooses among them.
 
-Precise Seam adds six `ModelVolumeType` values after `SUPPORT_ENFORCER`. The
-strong types come first and the weak types follow. `is_precise_seam()`,
+## Modifier types
+
+Precise Seam adds six `ModelVolumeType` values after `SUPPORT_ENFORCER`, strong
+types first and weak types after them. `is_precise_seam()`,
 `is_precise_seam_strong()` and `is_precise_seam_weak()` are range checks that
 depend on this order.
 
-| Type | Group | Effect on the perimeter |
+| Type | Group | Effect on an intersected perimeter |
 | --- | --- | --- |
-| `PRECISE_SEAM_CENTER` | strong | seam at the arc-length midpoint of the intersection |
+| `PRECISE_SEAM_CENTER` | strong | seam at the midpoint, by arc length, of the intersection |
 | `PRECISE_SEAM_LEFT` | strong | seam at the first point of the intersection |
 | `PRECISE_SEAM_RIGHT` | strong | seam at the last point of the intersection |
 | `PRECISE_SEAM_ENFORCED` | weak | intersection marked as enforced |
 | `PRECISE_SEAM_BLOCKED` | weak | intersection marked as blocked |
 | `PRECISE_SEAM_NEUTRAL` | weak | intersection reset to neutral |
 
-A strong modifier fixes one point. A weak modifier only changes the
-enforced/blocked type of seam candidates, and the configured seam position then
-chooses among them. First and last are taken along the perimeter made
-counter-clockwise seen from above. On an outer wall seen from outside, Left is
-the left end of the intersection. On the wall of a hole seen from inside the
-hole, the two ends are swapped.
+A strong modifier fixes a single point. The perimeter gets exactly one enforced
+seam candidate there, and every other candidate is blocked. A weak modifier
+retypes, and where needed adds, the candidates inside its intersection, like
+painting does.
+
+An **intersection** is a continuous part of the external perimeter's centerline
+that lies inside the modifier's slice on that layer. It is a portion of the
+perimeter, never a chord through the object. The centerline lies half an
+extrusion width inside the model surface and depends on print settings, so a
+modifier must reach clearly past the surface to cross it unambiguously.
+
+### Terms
+
+- **Segment:** an intersection as the code represents it (`PerimeterSegment`).
+  User-facing texts call it an intersection.
+- **Fragment:** a piece of the perimeter returned by clipping, before it is tied
+  to the source contour.
+- **Interval:** the bound part of one source edge, given by the edge index and a
+  parameter range on that edge.
+- **Zone:** a weak segment with its type (Enforced, Blocked or Neutral).
+- **Boundary:** an end of a zone, inserted into the perimeter polygon.
+- **Candidate:** a seam candidate of the seam placer, built from the points of
+  the processed perimeter polygon (painted enforcers may add more).
+
+First and last are taken along the perimeter oriented counter-clockwise as seen
+from above. On an outer wall seen from outside, Left is therefore the left end
+of the intersection. On the wall of a hole seen from inside the hole, the two
+ends are swapped. Mirroring an object does not mirror the mode: perimeters stay
+counter-clockwise, so Left remains the left end seen from outside, and the seam
+moves to the other end of the modifier instead of following the mirrored model.
+
+## Priority
 
 The order of volumes in the object is the priority order, highest first.
 `ModelObject::sort_volumes()` keeps every strong modifier before every weak one
 and preserves the user's order within each group. The object list lets the user
-drag a modifier only within its own group. A type change that crosses a group
-boundary moves the volume to the end of its new group, where it has the lowest
-priority. Strong modifiers are tried in this order, and the first one that
-yields a seam on a perimeter wins. Weak modifiers are applied from the lowest
-priority to the highest, so the highest one overwrites any overlapping zone.
+drag a modifier only within its own group. A type change that crosses the group
+boundary moves the volume to the end of its new group, with the lowest priority
+there.
 
-## Model storage and 3MF compatibility
+- **Strong:** modifiers are tried in priority order on each perimeter. The first
+  one that yields a usable segment decides the seam. Within that modifier the
+  longest segment wins; lengths are never compared across modifiers. Once a
+  strong point is placed, no later strong modifier and no weak modifier is
+  processed for that perimeter.
+- **Weak:** every weak modifier applies. They are applied from the lowest
+  priority to the highest, so the highest one overwrites overlapping zones. A
+  Blocked modifier that fully contains a perimeter is the exception: it is
+  skipped there (see [Full containment](#full-containment)).
 
-Projects must stay readable by earlier releases, and the modifier must not
-change a print there. Both 3MF writers therefore store a Precise Seam volume as
-an ordinary parameter modifier: `modifier_part` in the Bambu-format part
-subtype, and `ParameterModifier` together with the legacy `modifier` flag in
-the Prusa-format volume metadata. The seam mode is written separately under
+A strong modifier without a usable segment, even one whose fragments were all
+discarded, passes the turn to the next one.
+
+## Data flow
+
+1. **Invalidation.** `Print::apply()` treats a change of Precise Seam volumes as
+   a change of seam placement and invalidates G-code export; the object is not
+   resliced (see [Print invalidation](#print-invalidation)).
+2. **Modifier slices.** `SeamPlacer::init()` collects each object's Precise Seam
+   volumes once, slices every volume separately and caches its regions with
+   their bounding boxes.
+3. **Perimeters.** Seam candidates are gathered in parallel over the layers.
+   For objects with Precise Seam volumes, each external perimeter polygon is
+   normalized and prepared once for all modifiers.
+4. **Extraction.** For each modifier, the perimeter is clipped against the
+   modifier's regions on that layer. The clipped fragments are bound back to the
+   source edges of the perimeter and assembled into segments.
+5. **Strong, then weak.** Strong modifiers try to insert one seam point into the
+   perimeter polygon. If none succeeds, weak modifiers insert their zone
+   boundaries and subdivide enforced edges.
+6. **Candidates.** The seam placer builds candidates from the modified polygon.
+   Painting assigns types first, weak zones overwrite them, and a strong point
+   makes its candidate the only enforced one.
+7. **Selection and restoration.** The configured seam position chooses the
+   seams and aligns them. Afterwards the exact strong points are restored.
+8. **Warnings.** After all objects are processed, `SeamPlacer::init()` prepares
+   one combined warning text if any problem was found; G-code export issues it.
+
+## Modifier slices
+
+`init_precise_seam_data()` collects the Precise Seam volumes of each object:
+strong ones in priority order and weak ones in reverse, so that weak zones can
+be applied with last-write-wins. Each volume is sliced separately with
+`PrintObject::slice_single_volume_regions()`, at the object's layer heights and
+with the same centered transformation as the object. The slices keep every
+region's outer contour together with its holes as an `ExPolygon`. Volumes are
+not merged, so each keeps its own priority, and a modifier may have several
+regions on one layer.
+
+`prepare_modifier_slices()` moves the slices into `ModifierRegionsCache`,
+pairing each region with the bounding box of its exterior. Empty layers keep
+their slots, so the cache is indexed by object layer; `Layer::id()` includes raft
+layers, which are subtracted. The cache is filled before candidates are gathered
+and is only read afterwards, shared by both modifier kinds and all worker
+threads without locking.
+
+## Perimeter preparation
+
+The seam placer works on external perimeter loops, including the walls of
+holes. For objects with Precise Seam volumes, consecutive duplicate points and
+the repeated closing point of each extrusion loop are removed: adjacent
+extrusion paths share endpoints, and the resulting zero-length edges would
+prevent point insertion at their junctions. Distinct visits to one point of a
+self-touching contour are kept. Objects without Precise Seam volumes keep their
+original points, so ordinary seam candidates are unaffected.
+
+Each polygon is made counter-clockwise. A single `PreparedPerimeter` is then
+built for all modifiers of that perimeter. It holds a validity check (at least
+three points, no consecutive or closing duplicates), the bounding box, and the
+clipping line: the polygon as an open polyline with its first point repeated at
+the end. The preparation borrows the polygon and is used only while the polygon
+is unchanged: strong processing returns immediately after inserting its point,
+and weak processing collects all segments before it inserts anything. An
+invalid perimeter receives no Precise Seam processing.
+
+## Segment extraction
+
+`extract_perimeter_segments()` turns one modifier's regions on one layer into
+segments of the perimeter, each with its geometry and its position on the
+source contour. Both modifier kinds consume these segments; the extractor is
+told the modifier type so that it prepares only the data that type needs.
+
+### Clipping
+
+Regions whose bounding box does not overlap the perimeter's are skipped. The
+clipping line is intersected with each remaining region by `intersection_pl()`,
+which clips an open path against an `ExPolygon` with its holes attached, using
+the nonzero rule. Clipping an open line yields only pieces of the perimeter, so
+a modifier crossing the whole object produces two separate pieces rather than a
+chord through the body. Holes in a modifier and several regions of one modifier
+simply produce more pieces. The line is cut at vertex zero, so a piece crossing
+that vertex arrives as two fragments. A border that only touches the line can
+come back as a single point; such fragments carry no coverage and are dropped
+before binding.
+
+### Binding fragments to source edges
+
+Clipper returns coordinates only. Insertion needs the source edge of every
+point, and coordinates alone are ambiguous where a contour visits the same
+point twice. Each fragment is therefore bound to the source edges it covers,
+producing intervals: an edge index with a parameter range on that edge.
+
+- **Exact path.** For fragments with interior points, the second point is used
+  as an anchor that must equal a source vertex exactly. Clipping keeps the
+  vertices of an open path unchanged, including collinear ones. The following
+  points must match successive source vertices in either direction; later
+  occurrences of the anchor are tried if a sequence does not match. Only the two
+  end cuts are projected onto their edges.
+- **Projection path.** Two-point fragments, and fragments the exact path cannot
+  match, are bound by projection. The first source edge that holds both points
+  of the first pair, with distinct parameters, establishes the edge and
+  direction. Every following pair must continue on the same edge or cross to the
+  neighboring edge at their actual shared vertex, in the same direction. A pair
+  continuing on the same edge reuses the previous pair's parameter for their
+  shared point, so the two projections of one point cannot differ.
+- **Failure.** A fragment that cannot be bound continuously is rolled back and
+  discarded. Earlier fragments and other fragments are unaffected. The failure
+  is counted, logged and reported to the user (see
+  [Diagnostics](#diagnostics-and-warnings)).
+
+Two rare rounding cases are handled only after both paths have failed, so the
+normal path never pays for them:
+
+- **Cut beside a vertex.** When a modifier boundary crosses within about one
+  coordinate unit of a source vertex, Clipper can place the cut at the vertex's
+  height but a few units beside it. The end pair then collapses to the vertex's
+  parameter or misses both neighboring edges. An end cut closer than the
+  snapping radius to a vertex of the fragment's own chain is snapped to that
+  vertex: either its neighbor in the fragment (the cut is a rounded copy of it
+  and is dropped) or a vertex that shares a source edge with that neighbor. The
+  neighbor wins whenever it is within the radius. Ends that are themselves source
+  vertices and ambiguous choices are left unchanged. Binding is then retried
+  once with the same strict rules, so a wrong candidate can only fail again.
+- **Contact.** A fragment that still fails but is shorter than the snapping
+  radius is accepted as a contact and binds nothing. Insertion would collapse it
+  onto one point anyway.
+
+Both outcomes are recoveries, not failures: they show no user warning but leave
+a log marker.
+
+### Assembling segments
+
+The intervals are sorted by edge and parameter. Intervals on the same occurrence
+of an edge are united when they overlap or meet, by parameter or at the same
+integer point; equal coordinates on different edges are never united. A
+parameter of 1 is stored as parameter 0 of the next edge, so intervals on
+adjacent edges meet exactly at their shared vertex. Consecutive intervals that
+meet form one `PerimeterSegment`, and the last segment is joined with the first
+when they meet at vertex zero, undoing the artificial cut of the clipping line.
+
+Each segment keeps its polyline, the source edge of every polyline edge, and its
+begin and end positions on the source contour.
+
+### Full containment
+
+A modifier that covers the whole perimeter has no boundaries on it. The policy
+follows seam painting, where painting a whole perimeter green is a meaningful
+choice and forbidding the seam all round is not:
+
+- **Seam Enforced** types the whole perimeter, like a perimeter painted green all
+  round, with subdivision applied as described under [Weak modifiers](#weak-modifiers).
+- **Seam Neutral** types the whole perimeter Neutral, like an unmarked perimeter,
+  clearing painting and lower zones.
+- **Seam Blocked** is skipped for the perimeter, with the full-containment
+  warning. The seam cannot avoid the whole perimeter, so the modifier does not
+  override anything below it: lower zones and painting stay in effect.
+- **Seam Center, Left and Right** are skipped with the same warning: there is no
+  intersection to place the point on.
+
+Enforced and Neutral take part in the usual priority order (see
+[Weak modifiers](#weak-modifiers)).
+
+The perimeter is fully contained when the united intervals cover every source
+edge from parameter 0 to 1. A modifier boundary that merely touches the
+perimeter counts as well:
+
+- At a vertex or on an axis-aligned edge, clipping splits the line exactly at the
+  touch, the pieces meet at one point, and the coverage is complete.
+- On an inclined edge the touching point is usually not representable on the
+  integer grid. The boundary pokes a few units across and leaves a real gap, so
+  a single segment covers everything except that gap.
+
+Weak insertion would collapse such a segment's boundaries onto one vertex and
+turn the intended zone into a single candidate, and strong would put the seam at
+the touch. A single segment is therefore also full containment in the cases
+where insertion collapses it, exactly up to edges shorter than 2 µm:
+
+- the uncovered length from its end to its begin is below 1 µm, or
+- the gap spans one vertex, or starts at a vertex and ends on the next edge, and
+  both ends lie within 1 µm of the vertex that ends the first gap edge, since
+  each end then snaps onto it from its own edge.
+
+A cheap filter runs first: both cases bring the segment's ends within 2 µm of
+each other.
+
+## Strong modifiers
+
+For a strong modifier, the extractor prepares each segment's target point
+before anything is inserted, together with the source edge it lies on:
+
+- **Left:** the segment's first point.
+- **Right:** the segment's last point.
+- **Center:** the point at half the segment's arc length.
+
+Arc length is the sum of Euclidean edge lengths, not the chord or a vertex count.
+
+`insert_strong_seam_point()` selects the longest segment of the first modifier
+that has one. Exactly equal lengths are resolved by the prepared target points:
+greater bed Y first, then smaller X; a complete tie keeps the first segment.
+Slice coordinates already include instance rotation and have the bed axes;
+centering and XY translation do not change this order. Nearly equal lengths are
+not treated as equal, so exact ties occur mainly on axis-aligned geometry.
+Geometrically equal segments, such as a symmetric modifier crossing both faces
+of a thin wall, differ only by rounding noise that varies between layers, so
+the chosen face may alternate. This is accepted deliberately: such a modifier is
+ambiguous by itself: more than one segment raises the "multiple intersections"
+warning. The user should make the modifier cross the perimeter once.
+
+The selected point is inserted on its source edge. A point within 1 µm of an
+existing vertex is snapped to that vertex. Helper points are added 1 µm on both
+sides of it, except on an adjacent edge shorter than 2 µm, which already bounds
+the distance.
+
+When the candidates are built, the candidate at the inserted point is the only
+enforced one and becomes the central enforcer; every other candidate is blocked.
+Every seam position mode therefore selects it. Alignment and random placement
+can still move the final position, so after alignment
+`restore_precise_seam_positions()` writes the exact point and its index back
+into every perimeter that has a strong seam.
+
+## Weak modifiers
+
+`collect_weak_modifier_segments()` extracts the segments of every weak modifier
+before the polygon is modified, so all positions refer to the same contour. Each
+segment becomes a zone with a type and two boundaries, kept in application
+order, lowest priority first. Full containment of an Enforced or Neutral
+modifier becomes a whole-perimeter zone at its place in that order: it has no
+boundaries and takes part in no insertion or helper step below. The boundaries
+carry their positions on the source contour; these remain as provenance after
+insertion and are not indices into the modified polygon.
+
+`prepare_weak_modifier_segments()` then changes the polygon:
+
+1. **Boundary insertion.** Insertion events are sorted by decreasing source edge
+   and parameter, and the polygon is modified from its end towards its start. A
+   pending boundary's source index therefore stays valid. Vertex zero has the
+   canonical position `(0, 0)` and is
+   processed last, and a point on the closing edge is appended rather than
+   inserted at index zero. A boundary within 1 µm of either endpoint of its
+   current edge, an original vertex or a boundary inserted earlier, is snapped to
+   that point, so coincident boundaries share a vertex. A zone narrower than
+   1 µm collapses into a single vertex.
+2. **Helper points.** A helper point is added 1 µm outside every boundary,
+   unless the edge there is shorter than 2 µm, which already bounds it. The
+   helpers keep the edges at a boundary short, so a seam placed along such an
+   edge stays close to the boundary. Coincident boundaries share their helpers.
+3. **Enforced subdivision.** Zone types are resolved for the polygon's edges in
+   priority order. The edges of a zone are those from its left boundary up to,
+   but not including, its right boundary; a whole-perimeter zone types every
+   edge. Enforced edges longer than `SeamPlacer::enforcer_oversampling_distance`
+   (0.2 mm) are subdivided into steps of at most that length; shorter edges and
+   existing vertices are kept.
+   The regular seam placer then chooses the seam as for painted seams.
+
+When candidates are built, painting assigns their types first.
+`apply_weak_modifiers_to_perimeter()` then overwrites the types of the
+candidates between the boundaries of each zone, both boundaries included,
+lowest priority first; a whole-perimeter zone types every candidate. Blocked
+and Enforced zones therefore take precedence over painting, and Neutral clears
+painting inside its zone.
+
+## Numeric tolerances
+
+Coordinates are integers in scaled units: 1 nm by default, and 10 nm when a bed
+larger than 2147 mm switches `SCALING_FACTOR`. Both Precise Seam tolerances are
+deliberately defined in units rather than physical distances. Clipper truncates
+cuts to whole units at any scale, so the on-edge tolerance must follow the unit; the
+snapping radius scales with it to keep its margin over single-precision
+candidate coordinates, which are coarser on large beds. Distances quoted in
+this document in nanometers and
+micrometers assume the default unit; on large printers they are ten times
+larger. The enforced subdivision step is a physical distance and stays 0.2 mm.
+
+| Value | Role |
+| --- | --- |
+| `MACHINE_PRECISION_SQUARED` (2.5 units², about 1.6 nm) | A point lies on an edge if it is this close. It absorbs Clipper's truncation of cuts to whole units (under √2 units from the edge) and never bridges a real gap: a one-unit uncovered gap stays a gap. |
+| `TOLERANCE_LINEAR` (1000 units, 1 µm) | Insertion snaps points this close to an existing vertex, and helper points are placed this far from boundaries. The same radius bounds the rounding fallback, contacts and the sub-micron full-containment rule, so those decisions match what insertion would produce anyway. |
+| `enforcer_oversampling_distance` (0.2 mm) | Maximum step of enforced subdivision. |
+
+Raising the on-edge tolerance would not help with cuts beside a vertex: more
+points past a vertex would be clamped to its parameter and collapse. Lowering it
+would reject ordinary rounded cuts. The snapping radius is kept far above
+clipping precision for robustness: seam candidates hold single-precision
+coordinates, whose step is about 8 to 15 nm at typical object coordinates
+(about 0.25 µm 3 m from the object's centre, on large beds only), and
+weak boundaries and the strong point are located among the candidates by those
+coordinates, so distinct points must stay clearly distinct. 1 µm is also far
+below printing precision.
+
+## Diagnostics and warnings
+
+One `PreciseSeamWarnings` instance is shared by all objects and layers of a
+`SeamPlacer::init()` call. After all objects are processed, `SeamPlacer::init()`
+prepares at most one warning text, available through `precise_seam_warning()`.
+G-code export issues it as one non-critical warning with the ID
+`SlicingPreciseSeamWarning`. It is a single line, "Precise Seam: <causes>. Seam
+placement may differ from expected.", because the export warnings dialog shows
+only the first line of each warning. Repeated warning events replace the
+notification instead of appending to it. Except for the "had no effect" cause,
+the causes name the modifier types involved, as the menu names them, in menu
+order and each type once, for example "(Seam Left, Seam Enforced)".
+The causes are:
+
+- **failed to process some intersections (types):** at least one fragment was
+  discarded by binding. Other segments remain usable.
+- **multiple intersections with a perimeter, only one was used (types):**
+  a Seam Center, Left or Right modifier had more than one segment on a
+  perimeter (see [Strong modifiers](#strong-modifiers)).
+- **a perimeter is fully inside a modifier, the modifier was not applied to it
+  (types):** a Seam Center, Left, Right or Blocked modifier was skipped for a
+  perimeter (see [Full containment](#full-containment)).
+- **modifier "<name>" of "<object>" had no effect on the seam (it might not reach
+  the centerline of the printed perimeter):** a modifier was evaluated on at
+  least one perimeter and never gave a segment, full containment or a discarded
+  fragment. Only the first such modifier in print and volume order is named,
+  followed by "(N in total)" when there are several.
+
+  Only the effect is certain, so the cause is given as a hint. A modifier is
+  evaluated only when its turn comes: on a perimeter where a higher strong
+  modifier placed the seam, lower strong and all weak modifiers are not
+  evaluated. A modifier that was never evaluated is not reported, since nothing
+  is known about it. A point contact gives no segment and does not count as
+  reaching the perimeter.
+
+The log records the following diagnostic markers:
+
+- `[PreciseSeamIntersectionFailed]` for a discarded fragment, with object,
+  modifier, layer, height, fragment and failing pair, the failure reason and
+  point counts.
+- `[PreciseSeamFragmentRecovered]` for a recovery, with `outcome=bound` or
+  `outcome=contact`, the same location fields and the original failure reason.
+- `[PreciseSeamNoEffect]` for every modifier of the "had no effect" cause, with
+  the object and modifier names. Unlike the user warning, the log lists all of
+  them.
+
+Failures and recoveries are counted separately. The first 10 of each per
+`init()` call are logged in detail, in parallel processing order; if a limit is
+exceeded, one summary marker reports the total and the number omitted.
+
+## Known limitations
+
+- **The modifier must reach the perimeter centerline.** Contacts are taken as
+  clipping returns them, without offsets or tangency rules, so boundaries that
+  only graze the centerline are the user's responsibility. Several near-touches
+  on inclined edges can leave several segments separated by gaps of a few units;
+  their zones then cover nearly the whole perimeter instead of being treated as
+  full containment.
+- **Self-touching perimeters.** Extraction keeps distinct visits of one
+  coordinate apart through its source-edge bindings, but the consumers locate
+  inserted points by coordinates. A weak zone is typed and subdivided from the
+  first vertex with its boundary coordinate, while boundary helpers are added at
+  every such vertex. A strong point marks every candidate at its coordinate as
+  enforced, and the last one is restored after alignment. If a boundary or a
+  strong point falls exactly on a repeated coordinate, a zone may therefore start
+  from another visit, or the seam may start at another visit of the same point.
+  Carrying visit identity through insertion, refinement, candidates and
+  restoration would touch the whole pipeline, so it is not done for this rare
+  geometry. Overlapping source visits are likewise outside the binding contract.
+
+## Integration with the application
+
+### Other seam settings
+
+- Precise Seam takes part only in outer and hole perimeter seam placement. In
+  spiral vase mode the seam placer is not used for perimeters, so the modifiers
+  have no effect.
+- Scarf seams, the seam gap and wiping start from the chosen point exactly as
+  they would from an ordinary seam.
+- Seam painting acts only from model parts, the volumes the seam gizmo shows and
+  edits, and from negative volumes. Painting retained on a volume after a change
+  from part to a Precise Seam, ordinary or support modifier is ignored. A type
+  change back to a model part reactivates any retained painting.
+  Negative volumes keep it on purpose: painting a
+  part and turning it into a negative volume is the only way to paint the wall
+  of the hole it cuts. That painting still affects the seam but is invisible in
+  the gizmo and cannot be edited there; this is known technical debt.
+  If painting them is ever made editable, G-code invalidation must track it too:
+  `model_custom_seam_data_changed()` checks model parts only.
+
+### Model storage and 3MF compatibility
+
+Projects must stay readable by earlier releases, and a Precise Seam volume must
+not change a print there. Both 3MF writers therefore store it as an ordinary
+parameter modifier: `modifier_part` in the Bambu-format part subtype, and
+`ParameterModifier` together with the legacy `modifier` flag in the
+Prusa-format volume metadata. The seam mode is written separately under
 `precise_seam_type`, using the names from `ModelVolume::type_to_string()`
 (`precise_seam_center` and so on).
 
-On load, the mode applies after all other volume metadata, regardless of XML
-key order, and only when the base type is a modifier. Missing or unknown modes
-leave an ordinary modifier. Seam metadata on any other base type is ignored.
-Files that stored the seam mode directly as the volume type still load.
+On load, the mode is applied after all other volume metadata, regardless of XML
+key order, and only when the base type is a modifier. A missing or unknown mode
+leaves an ordinary modifier, and seam metadata on any other base type is
+ignored. Files that stored the seam mode directly as the volume type still load.
+A project saved again by an earlier release loses the seam mode for good: the
+volumes stay ordinary modifiers without settings.
 
 A Precise Seam volume keeps any per-volume settings it had as a part or
 modifier, but they are inactive and the object list shows no settings item for
 it. The writers prefix these keys with `precise_seam_config:`, so an earlier
-reader drops them as unknown options. The volume therefore loads there as a
-modifier without settings and has no effect on the print. The current reader
-restores the keys only when the volume ends up as a Precise Seam type, so the
-settings return when the user changes the type back. Configuration values are
-XML-escaped in both writers, for every volume type.
+reader drops them as unknown options and loads a modifier without settings,
+which has no effect on the print. The current reader restores the keys only when
+the volume ends up as a Precise Seam type, so the settings return when the user
+changes the type back.
 
-## Print invalidation
+### Print invalidation
 
 `Print::apply()` compares the Precise Seam volumes of each object by type, ID
-and transformation. Adding, removing, moving, reordering or retyping one
-cancels background processing and invalidates only `psGCodeExport`; the sliced
-layers are kept. `model_volume_list_update_supports_and_seams()` then brings
-the support and Precise Seam volumes of the print's model copy in line with the
-new model in one pass. A volume may switch between the two families, since
-neither affects slicing. A conversion to or from a part or ordinary modifier
-changes the solid and modifier volume lists and reslices as before.
+and transformation. Adding, removing, moving, reordering or retyping one cancels
+background processing and invalidates only `psGCodeExport`; the sliced layers
+are kept. `model_volume_list_update_supports_and_seams()` then brings the
+support and Precise Seam volumes of the print's model copy in line with the new
+model in one pass. A volume may switch between these two families, since neither
+affects object slicing; such a switch also changes the support volumes, so the
+support step is invalidated as well.
 
-## Modifier slices
+A conversion to or from a part or an ordinary modifier changes the solid and
+modifier volume lists and reslices the object as before. The volume keeps its
+ID across the type change, so the region cache treats a former support or
+Precise Seam volume that became a part or modifier as new, since it was never
+cached.
 
-`SeamPlacer::init()` collects the Precise Seam volumes of each object once:
-strong ones in priority order and weak ones reversed. It slices each volume
-separately with `PrintObject::slice_single_volume()`, which shares
-`slice_modifier_volumes()` with support blockers and enforcers but does not
-merge volumes, so each keeps its own priority. The result is cached per volume
-and indexed by object layer; `Layer::id()` includes raft layers, which are
-subtracted. Seam candidates are then gathered in parallel over the layers and
-read the cache without locking.
+Removing the last helper of a single-part object reslices it, as removing any
+last modifier would.
 
-Objects without Precise Seam volumes follow the unchanged seam placement path.
-For objects that have them, perimeter extraction also removes consecutive
-duplicate points and the repeated closing point of each extrusion loop.
-Zero-length edges at path junctions would otherwise prevent point insertion
-there. Distinct visits to one point of a self-touching contour are kept.
-
-## Finding the wall segment
-
-The seam placer works on the external perimeter loops of each layer, both
-outer contours and holes, each made counter-clockwise. For every modifier
-polygon on the layer that overlaps the perimeter's bounding box, the region
-enclosed by the perimeter is clipped against the modifier polygon. The boundary
-of each intersection polygon alternates between runs that follow the perimeter
-and runs that follow the modifier outline. The wall segment is the longest
-continuous run of intersection vertices that lie on the perimeter, measured in
-vertices.
-
-The fast path first finds an intersection vertex that exactly matches a
-perimeter vertex. It then walks forward and backward, expecting the adjacent
-perimeter vertex and falling back to projection when Clipper has merged or
-split collinear edges. A vertex counts as on the perimeter when its projection
-is within about 1.6 nm, which covers Clipper's rounding. If no vertex matches
-exactly, or every vertex lies on the perimeter, the general path projects all
-vertices. When every vertex is on the perimeter, the edge midpoints are checked
-instead: a modifier chord can join two perimeter vertices directly, and the
-chords split the vertex ring into runs. If no edge leaves the perimeter, the
-perimeter lies entirely inside the modifier.
-
-`Polygon::point_projection()` optionally reports the edge that holds the
-projection, and every point of the segment keeps the index of its perimeter
-edge. New points are inserted on that edge. A point within 1 µm of an existing
-vertex snaps to that vertex instead.
-
-## Strong modifiers
-
-For a strong modifier, the target is the first point, the last point or the
-arc-length midpoint of the segment. The midpoint is projected back onto the
-original perimeter, because Clipper may have merged several perimeter edges
-into one segment edge. The target is inserted into the perimeter, and a helper
-point is inserted 1 µm before and after it. Strong modifiers are tried in
-priority order, the first valid intersection decides the seam, and weak
-modifiers are not processed for that perimeter.
-
-When candidates are built, the inserted point is the only enforced candidate
-and becomes the central enforcer; every other candidate is blocked. The seam
-position modes then pick that point: Aligned and Aligned Back prefer the central
-enforcer, while Back, Random and Nearest rank enforced candidates above blocked
-ones. Alignment and random placement can still move the final position along an
-edge. After alignment, `restore_precise_seam_positions()` writes the exact point
-and its index back into every perimeter that has a strong seam. Inner walls take
-their seam from the external seam as usual, including staggering.
-
-## Weak modifiers
-
-Weak modifiers produce one segment per intersection polygon, so one modifier can
-mark several zones on one perimeter. All segment boundaries are inserted into
-the perimeter in order of decreasing arc length. Each insertion then leaves the
-indices of the pending, shorter ones unchanged; a point on the closing edge is
-appended rather than inserted at index zero. A helper point is added 1 µm
-outside each boundary. Random placement picks a position along the edge that
-follows a candidate. These helpers keep that edge 1 µm long at each boundary, so
-a zone cannot extend or intrude further than that. Boundaries that coincide
-share their helper points.
-
-The zone types are then resolved in priority order, and the edges of enforced
-zones are subdivided into steps of at most
-`SeamPlacer::enforcer_oversampling_distance` (0.2 mm). The middle candidate of
-the longest enforced patch is therefore close to the geometric middle of the
-zone. That patch is measured in candidates, across the closing edge, regardless
-of where the contour starts; the same rule applies to painted seams.
-
-Candidates first receive their type from seam painting. The weak zones then
-overwrite it, lowest priority first. Blocked and Enforced zones therefore take
-precedence over painting, and Neutral clears painting inside its zone.
-
-## Unsupported geometry and warnings
-
-Some modifier shapes cannot be resolved to one seam or one zone per crossing.
-They are detected cheaply and reported rather than guessed:
-
-- A strong modifier that crosses a perimeter in more than one place uses only
-  its first valid segment. The other crossings are ignored.
-- A modifier that crosses the whole region enclosed by the perimeter is
-  detected when the modifier outline minus that region leaves more than one
-  piece, none of them a hole. Its intersection holds two wall runs, and only
-  one of them is used.
-- A modifier whose slice has a hole on a layer, found as a clockwise polygon in
-  the flattened slice, is skipped on that layer. The flattened slice no longer
-  records which hole belongs to which contour.
-- A perimeter that lies entirely inside a modifier is ignored by that modifier.
-
-The conditions are atomic flags shared by all layers and objects. After all
-objects are processed, `SeamPlacer::init()` issues at most one non-critical
-warning with the ID `SlicingPreciseSeamWarning`. The warning is a single line
-that lists every cause found, because the export warnings dialog shows only the
-first line of each warning. Repeated warning events replace this notification
-instead of appending text to it.
-
-## User interface
+### User interface
 
 - *Add Precise Seam* in the object menu creates a Center modifier from a
   primitive or a loaded mesh. Text and SVG volumes cannot become Precise Seam
-  modifiers: the menu does not offer them, and `ObjectList::set_volume_type()`
+  modifiers: the menu does not offer it, and `ObjectList::set_volume_type()`
   refuses the change.
 - *Change Type* has a single *Precise Seam* entry. It converts other volumes to
   Center and keeps the mode of volumes that are already Precise Seam. The
-  *Precise Seam Type* submenu appears only when every selected item is a
-  Precise Seam volume, including settings rows that resolve to one. It sets the
-  chosen mode on all selected volumes.
+  *Precise Seam Type* submenu appears only when every selected item is a Precise
+  Seam volume, including settings rows that resolve to one, and sets the chosen
+  mode on all of them.
 - Each mode has its own icon in the object list and its own color in the 3D
-  view, at 60% opacity: warm oranges for the strong modes, and green, red and
-  gray for Enforced, Blocked and Neutral.
-- Object list drops map visible rows to volume indices while skipping hidden
-  cut connectors, and they refresh the row-to-volume map of the object.
-- Precise Seam volumes have no filament, block pasting into SLA, and are exposed
-  to Python plugins as `ModelVolumeType` values plus the `is_precise_seam*()`
-  methods.
+  view, at 60% opacity: warm orange, gold and dark orange for Center, Left and
+  Right; green, red and gray for Enforced, Blocked and Neutral. The three strong
+  colors are close shades of one orange because all three mark strong
+  modifiers; the object list icons tell the modes apart.
+- Precise Seam volumes have no filament and cannot be pasted into SLA objects.
+  Python plugins see them as `ModelVolumeType` values and through the
+  `is_precise_seam*()` methods.
 
 ## Implementation and verification
 
-- [PreciseSeam.cpp](../../src/libslic3r/GCode/PreciseSeam.cpp) implements segment
-  detection, point insertion, weak-zone resolution and position restoration.
-  [SeamPlacer.cpp](../../src/libslic3r/GCode/SeamPlacer.cpp) integrates it into
-  candidate gathering and issues the warning.
+- [PreciseSeam.cpp](../../src/libslic3r/GCode/PreciseSeam.cpp) implements the
+  modifier cache, perimeter preparation, segment extraction and binding, strong
+  selection and insertion, weak-zone preparation and application, and position
+  restoration. [PreciseSeam.hpp](../../src/libslic3r/GCode/PreciseSeam.hpp)
+  declares the contracts; [PreciseSeamInternal.hpp](../../src/libslic3r/GCode/PreciseSeamInternal.hpp)
+  exposes the binding internals to tests.
+- [SeamPlacer.cpp](../../src/libslic3r/GCode/SeamPlacer.cpp) fills the cache,
+  normalizes perimeters, calls both consumers while gathering candidates,
+  restores strong positions after alignment and prepares the warning text, which
+  [GCode.cpp](../../src/libslic3r/GCode.cpp) issues during G-code export.
 - [Model.hpp](../../src/libslic3r/Model.hpp) defines the types and their order,
   [PrintApply.cpp](../../src/libslic3r/PrintApply.cpp) handles invalidation, and
-  [PrintObjectSlice.cpp](../../src/libslic3r/PrintObjectSlice.cpp) slices the
-  modifiers. [bbs_3mf.cpp](../../src/libslic3r/Format/bbs_3mf.cpp) and
-  [3mf.cpp](../../src/libslic3r/Format/3mf.cpp) store them.
+  [PrintObjectSlice.cpp](../../src/libslic3r/PrintObjectSlice.cpp) slices single
+  volumes into structured regions. [bbs_3mf.cpp](../../src/libslic3r/Format/bbs_3mf.cpp)
+  and [3mf.cpp](../../src/libslic3r/Format/3mf.cpp) store them.
 - [GUI_Factories.cpp](../../src/slic3r/GUI/GUI_Factories.cpp) and
   [GUI_ObjectList.cpp](../../src/slic3r/GUI/GUI_ObjectList.cpp) provide the menus,
-  type changes and ordering.
+  type changes and ordering; [3DScene.cpp](../../src/slic3r/GUI/3DScene.cpp)
+  defines the colors.
+- [Segment extraction tests](../../tests/libslic3r/test_precise_seam.cpp) cover
+  clipping and binding: holes and components, contour origin and reversal,
+  repeated coordinates, collinear vertices and rounding, rollback and the
+  diagnostic limits, the rounding fallback on synthetic and real Clipper
+  fragments, contacts, and full containment including touches and sub-micron
+  gaps on inclined edges and around vertices.
 - [Precise Seam tests](../../tests/fff_print/test_precise_seam.cpp) cover the
-  strong positions, including a midpoint on an existing vertex or the closing
-  edge. They also cover shared and coincident weak boundaries, every warning,
-  and the priority order.
+  consumers: strong targets in every mode, including a midpoint on an existing
+  vertex or the closing edge, longest-arc selection and tie order in bed axes,
+  priorities, weak boundaries that coincide or share an edge, enforced
+  subdivision, whole-perimeter weak zones with painting and priorities, weak
+  zones over painting's oversampled candidates, the warning type masks, usage
+  tracking for the "had no effect" warning, volume sorting of strong and weak
+  groups, restoration of strong points after alignment, raft layer indexing and
+  structured slices. End-to-end tests slice a real object with Precise Seam
+  volumes and check the outer wall starts in the exported G-code: every strong
+  mode under several seam positions and with a raft, Enforced and Blocked zones,
+  a modifier with a hole, and the user warning.
 - [Seam placer tests](../../tests/fff_print/test_seam_placer.cpp) cover
   enforced-patch selection independent of the contour start, fully painted
-  contours, duplicate removal, and `Print::apply()` synchronization through
-  type changes and restored model snapshots.
+  contours, duplicate removal, and `Print::apply()` synchronization through type
+  changes and restored model snapshots. The duplicate-removal test also checks
+  the "had no effect" warning text prepared by `init()` for a helper that never
+  reaches the loop. Further tests check that adding, moving, retyping or
+  removing a Precise Seam volume invalidates only G-code export, and that seam
+  painting acts only from model parts and negative volumes, including after a
+  type change back to part.
 - [3MF tests](../../tests/libslic3r/test_precise_seam_3mf.cpp) cover the round
-  trip of every mode and of inactive settings, attribute escaping, and which
-  metadata combinations restore a seam mode.
+  trip of every mode and of inactive settings, attribute escaping, and the
+  metadata combinations that restore a seam mode.
   [Plugin tests](../../tests/slic3rutils/test_precise_seam_plugin.cpp) cover the
   Python bindings.

docs/HLSD/prusa-indx-profiles.md

@@ -0,0 +1,54 @@
+# Prusa CORE One INDX profiles
+
+The Prusa bundle provides separate four-tool and eight-tool CORE One INDX models
+with 0.4 mm high-flow nozzles and a 248 x 205 x 270 mm printable volume. These are
+independent-tool printers, not single-extruder MMU3 machines. Both inherit
+`fdm_machine_common_coreone_indx`, which inherits the ordinary CORE One HF
+printer; the concrete printer presets supply their tool-count-dependent arrays. The bed and wizard resources come from Prusa.
+
+The source configuration is PrusaResearch 2.5.10 from
+[Prusa's profile repository](https://github.com/prusa3d/PrusaSlicer-settings-prusa-fff/blob/65c5c8f1e1c3836f306119c49d717759cbc368db/PrusaResearch/2.5.10.ini).
+Its printer, process and filament settings are translated to Orca option names.
+The supplied process presets cover 0.10, 0.15, 0.20 and 0.25 mm layers. Their
+shared `fdm_process_coreone_indx` base inherits the ordinary CORE One HF SPEED
+process, with explicit INDX differences and layer-specific child settings.
+Material presets are shared with the ordinary CORE One family.
+
+## Tool changes and extrusion state
+
+The start script initializes a persistent `tool_init` vector, counts the tools
+used by the job, homes and probes using a loaded tool, calibrates the used tools,
+and primes the initial tool at the cleaning station. The change script preserves
+Prusa's `G27`, `P0`, `T`, `G12`, `G750` and `M906` sequences. It updates
+`e_retracted` so Orca's subsequent unretraction agrees with the script's extrusion.
+Per-tool temperature commands are guarded by `is_extruder_used`.
+
+The off-bed purge station is the default. With a prime tower enabled, a newly
+used tool still receives its initial station purge, while an initialized tool
+uses the source's wipe-tower preparation path. `tool_init` persists across these
+changes; treating every tool selection as first use would change the purge and
+deretraction sequence.
+
+Purge volume uses the filament's minimal purge setting. Orca's optional flush
+volumetric speed is divided by filament cross-sectional area before it is used
+as a linear extrusion-speed override. Prusa's separate `filament_flush_volume`
+override is not available in these profiles. The source's `EXCLUDE_E_START` and
+`EXCLUDE_E_END` internal markers become comments rather than printer commands.
+
+Pressure-advance restoration and automatic pressure-advance emission use the
+selected filament preset's settings. These profiles do not impose machine-owned
+filament overrides. Dock-fan control retains the source's material and layer
+conditions; shutdown parks the tool and turns off the used heaters and dock fan.
+
+## Configuration boundaries
+
+The scripts use Orca's temperature, retraction, fan and speed option names. The
+nozzle-check high-flow flag is fixed because these presets describe HF nozzles;
+the abrasive-material flag is derived from the filament's required nozzle HRC.
+An unset idle temperature uses Orca's zero sentinel. ABS's source XY shrinkage
+compensation is represented using Orca's retained-size percentage.
+
+Prusa's consistent-surface cooling strategy and filament-specific infill crossing
+speed limits have no direct Orca profile equivalent. These presets use Orca's
+native layer-time cooling and material volumetric limits. They do not add slicer
+features or change existing Prusa printer profiles.

docs/HLSD/scene-benchmark.md

@@ -0,0 +1,93 @@
+# 3D Scene Benchmark: High Level Design
+
+## Why it exists
+
+Rendering changes, such as the realistic view, shadows or SSAO, need a number to compare
+before and after, and user reports of a slow viewport need a way to say how slow. The FPS
+overlay and the render timings overlay show live values while someone drags the camera,
+which varies from run to run with the model, the path of the mouse and the view.
+
+The benchmark renders a fixed model along a fixed camera path in both 3D views, so two
+runs on the same machine differ only by the code or the settings, and prints a report that
+can be pasted into an issue.
+
+## What it does
+
+`run_scene_benchmark()` in `src/slic3r/GUI/SceneBenchmark.cpp` is reached from Help >
+Benchmark 3D Scene, the command palette and Preferences > Graphics. After a confirmation
+it starts a new project, which asks to save the current one if needed, loads the
+OrcaSliced Combo handy model and arranges it. A small dialog in a corner of the 3D view
+then shows the progress; every other window is disabled until the run ends, so a click
+cannot change the scene being measured. Cancel or Esc stops the run.
+
+The run goes through these stages, driven by a timer while it waits and by idle events
+while it renders:
+
+1. Loading: waits until the UI job worker is idle, so the arrange job has moved the
+   objects. The orbit target is the center of the objects on the current plate, and the
+   base zoom fits their bounding box in the viewport.
+2. Prepare: renders the scene in the Prepare view.
+3. Slicing: slices the plate and switches to Preview, then waits for the G-code preview
+   to load. If slicing fails, the report holds Prepare alone.
+4. Preview: renders the scene in the Preview view, with the slicing progress notification
+   hidden.
+5. Layers: renders the Preview view again while the layer slider moves, which is what
+   makes dragging it feel slow on large prints.
+
+The dialog then shows the report, with a button to copy it. A scene cut short, because its
+view was hidden, is left out of the report.
+
+## Rendering a scene
+
+Each scene renders 30 warm-up frames, then the camera path twice, 360 frames each time.
+
+- The first pass times the frames. A frame's time is the interval between the starts of
+  consecutive benchmark frames, so it includes the event loop between them.
+- The second pass averages the render timings. The frame profiler flushes the GL command
+  queue after each section, which slows a frame down, so it only runs in this pass.
+  `FrameProfiler::start_averaging()` flags every frame begun afterwards, and
+  `finish_averaging()` waits for the flagged frames still on the GPU and returns the mean
+  CPU and GPU time of each section per profiled frame.
+- A section's GPU time is taken between a timestamp before its commands and one after
+  them. The first is only sent along with those commands, so when the GPU finishes a
+  section before the CPU has issued the next one, the wait counts in neither.
+
+The dialog renders one frame per idle event by calling `GLCanvas3D::render()`, which
+redraws the whole scene. While `GLCanvas3D::set_benchmarking()` is on, the canvas does not
+render from its own idle handler, so no other frame is drawn in between, and it skips the
+picking pass and the FPS and render timings overlays, which depend on the mouse and on
+preferences. The FPS cap does not apply, since it only paces idle redraws.
+
+VSync is turned off for the scene through `wxGLCanvas::SetSwapInterval(0)`, so the frame
+rate is what the GPU and CPU can reach rather than the display's refresh rate, and the
+previous interval is restored afterwards. When the platform cannot report the current
+interval (EGL), it is left as it is and the report says so.
+
+The camera path makes two turns around the target while the view rises three times from
+25 degrees below the plate to 85 degrees above it and the zoom goes twice between 0.6 and
+1.4 times the base zoom. The camera stays at the default distance, so the perspective is
+the same in every run. The camera the scene started with is restored at its end.
+
+The Layers scene holds the camera at the start of that path and moves the top of the layer
+slider instead, from the last layer down to the first and back up in each pass. It goes
+through `IMSlider::SetHigherValue()`, as a drag does, so every frame applies a new layer
+range to the toolpaths and the objects before drawing them, including a new shadow map when
+the shadows are static. Its warm-up frames lead into the start of the path, so the slider
+moves in every frame. The slider position it started from is restored at its end.
+
+## The report
+
+The report is plain English text, so it reads the same in every language:
+
+- The version and build commit, the GPU and OpenGL version, the viewport size and camera
+  type, and the graphics settings that change the cost of a frame: MSAA samples as read
+  from the framebuffer, FXAA, the scene cache, VSync and the realistic view options.
+- The printer and process presets the model was sliced with, marked when they have
+  unsaved changes, and the toolpath vertices and layers they produced, since the Preview
+  scenes cost more with more toolpaths.
+- For each scene, the average FPS and the average, median, 95th percentile, 99th
+  percentile and maximum frame time. Percentiles are nearest-rank, so each is a measured
+  frame (`frame_time_stats()`).
+- For each scene, the render timings table: the CPU and GPU milliseconds of each section
+  of a frame, and their total. Without timer queries (OpenGL 3.3 or `ARB_timer_query`) the
+  table says that the driver does not support them.

docs/HLSD/section-view.md

@@ -0,0 +1,105 @@
+# Section view — High Level Design
+
+## Purpose and scope
+
+Section view hides whatever lies between the camera and a plane, so the user can look inside
+objects in Prepare and in the assembly view, and inside the toolpaths in Preview. It is a view
+setting: it changes nothing in the model, the slice or the project file, and it does not reach
+plate thumbnails.
+
+The user controls it from the section button of the canvas toolbar in the bottom left corner of
+the 3D view. The button opens a panel above it with a slider for the depth of the cut, a "Set
+viewing angle" button that turns the plane to face the camera at the same depth, and a button that
+resets the depth to zero. The panel is an ordinary overlay window, not a popup, so the scene keeps
+taking clicks and drags while it is open; the button or Esc closes it again. Esc closes the panel
+before it closes a gizmo or clears the selection. The button is highlighted
+while a section cuts the scene and has shortcuts of its own: the mouse wheel over it moves the
+plane, a right click switches the section off and back on, and a middle click sets the viewing
+angle. Alt + mouse wheel moves the plane anywhere in the 3D view, with or without a gizmo open.
+
+## State
+
+Prepare and Preview share one section view, so a cut made in either tab is the same cut in the
+other. The assembly view, whose objects sit apart from their places on the plate, and the Design
+tab keep their own. The section itself is two values.
+
+- **Ratio**, from 0 to 1. At 0 the section is off. As the ratio grows, the plane sweeps the
+  sphere around the objects, from its side facing the camera to the opposite side, so at 1
+  everything is cut away.
+- **Normal**, taken from the camera direction the first time the section is switched on, and
+  again whenever the user sets the viewing angle. The plane keeps that orientation while the
+  camera orbits and while the section is off, so the cut face can be seen from any side and
+  bringing the depth back to 0 does not lose the angle.
+
+The ratio in use when the section is switched off is kept, and the right click on the button
+brings the section back at that ratio, which restores the same cut. Whether the panel is open is
+shared along with the section.
+
+The sphere is recomputed every frame from the volumes of the canvas the section view belongs to:
+the objects on the current plate, or every object when that plate is empty. Preview holds no
+objects of its own, so it places the plane across the volumes of Prepare, which makes it cut the
+toolpaths exactly where Prepare cuts the objects. Only G-code opened on its own, without objects,
+is measured by its toolpaths. In the assembly view the sphere is around the whole assembly. The
+ratio therefore keeps its meaning when objects move or the user switches plates. It is not a
+fixed position in world space.
+
+Only the tab on screen can change the section, and switching tabs redraws the whole scene and
+closes the open gizmo, so neither tab ever shows a stale cut.
+
+## Where the plane applies
+
+`GLCanvas3D::_get_section_view_plane()` turns the state into a plane in the convention of
+`ClippingPlane::is_point_clipped()`. Everything that draws or picks the scene reads that plane.
+
+- **Volumes.** The plane goes to the `clipping_plane` uniform of the volume shaders. The same
+  uniform serves the gouraud, phong and X-ray passes and the colour picking pass.
+- **Cut faces.** Clipping only discards fragments, which would leave the cut volumes hollow.
+  `_render_section_view_caps()` draws their cut faces with one `MeshClipper` per model part the
+  plane passes through. A clipper recomputes its face only when the plane or the volume moves.
+  Modifiers, the wipe tower and SLA auxiliaries get no face.
+- **Toolpaths.** libvgcode takes the plane through `Viewer::set_clipping_plane()`. It draws each
+  extrusion as only the faces of a diamond-section prism that turn towards the camera, so
+  discarding the fragments on the clipped side would leave open shells. Instead, the segment
+  shader follows the view ray from a fragment that is cut away to the plane. When the
+  extrusion's diamond section still holds that point, the fragment is shaded as the cut face, lit
+  as the plane faces; otherwise it is discarded. The cut face keeps the depth of the fragment it
+  replaces, which is safe: along that ray everything else still shown lies behind the plane. The
+  shader writes no `gl_FragDepth`, so early depth testing survives. Option markers are cut away
+  whole, by their centres. The shadow casters draw with a program of their own, which takes the
+  plane and discards the fragments on the clipped side, so what is cut away casts no shadow either.
+  Their cut faces are not drawn, since the part left behind casts the shadow of its own section.
+  Preview shells are drawn by another shader and are not clipped.
+- **Picking.** `get_raycaster_clipping_plane()` returns the same plane, so hover, selection and
+  the perspective pan anchor ignore what the user cannot see.
+
+## Gizmos
+
+A gizmo that clips its object itself owns the gizmo data pool's `ObjectClipper`, and its plane
+replaces the canvas section while the gizmo is open. `GLGizmosManager::get_clipping_plane()`
+reports that plane, or nothing when no open gizmo has a clipper. There are two cases.
+
+- **Painting tools and brim ears** show the canvas section on the object they edit.
+  `GLGizmosManager::update_section_view()` copies the ratio and normal into their clipper
+  whenever the pool is updated or the section changes. The clipper then places the plane across
+  the edited instance, which is the only object shown. The painting tools keep clipping their
+  own triangles, raycasts and cut face through it. Brim ears always cut horizontally from the
+  top, because the ears sit on the plate. At ratio 0 the clipper holds no plane at all, so the
+  raycasts are not clipped.
+- **Cut and mesh boolean** use the clipper for their own purposes, so the canvas section is
+  suspended while they are open.
+
+Every other gizmo, including move, rotate and scale, leaves the canvas section in place.
+
+## Alt + mouse wheel
+
+The canvas handles Alt + wheel after the gizmos had their turn, so it works the same in every
+tab and with any gizmo open. On Windows, releasing Alt when no key was pressed since it went down
+opens the window menu, and a wheel turn does not count as a key. Under the custom title bar that
+menu is invisible, yet it takes the keyboard and the next click, which looks like a frozen 3D
+view. After Alt + wheel the canvas therefore consumes the Alt release instead of passing it on.
+
+## Redraw
+
+The button and the panel are part of the ImGui overlay, which is built after the frame's scene is
+drawn. A change to the section therefore marks the scene dirty and asks for one more frame. The
+cached scene is never reused across a change.

localization/i18n/OrcaSlicer.pot

@@ -22855,3 +22855,28 @@ msgstr ""
 #: resources/data/hints.ini: [hint:Avoid warping]
 msgid "Avoid warping\nDid you know that when printing materials that are prone to warping such as ABS, appropriately increasing the heatbed temperature can reduce the probability of warping?"
 msgstr ""
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "failed to process some intersections (%1%)"
+msgstr ""
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "multiple intersections with a perimeter, only one was used (%1%)"
+msgstr ""
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "a perimeter is fully inside a modifier, the modifier was not applied to it (%1%)"
+msgstr ""
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "modifier \"%1%\" of \"%2%\" had no effect on the seam (it might not reach the centerline of the printed perimeter)"
+msgstr ""
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "modifier \"%1%\" of \"%2%\" (%3% in total) had no effect on the seam (it might not reach the centerline of the printed perimeter)"
+msgstr ""

localization/i18n/list.txt

@@ -74,11 +74,8 @@ src/slic3r/GUI/Gizmos/GizmoObjectManipulation.cpp
 src/slic3r/GUI/Gizmos/GLGizmoCut.cpp
 src/slic3r/GUI/Gizmos/GLGizmoCut.hpp
 src/slic3r/GUI/Gizmos/GLGizmoSimplify.cpp
-src/slic3r/GUI/Gizmos/GLGizmoFaceDetector.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSeam.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSeam.hpp
-src/slic3r/GUI/Gizmos/GLGizmoText.cpp
-src/slic3r/GUI/Gizmos/GLGizmoText.hpp
 src/slic3r/GUI/Gizmos/GLGizmoEmboss.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSVG.cpp
 src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
@@ -177,9 +174,9 @@ src/slic3r/GUI/PresetHints.cpp
 src/slic3r/GUI/ProgressStatusBar.cpp
 src/slic3r/GUI/PlateSettingsDialog.cpp
 src/slic3r/GUI/PrivacyUpdateDialog.cpp
-src/slic3r/GUI/PublishDialog.cpp
 src/slic3r/GUI/PublishSettingsDialog.cpp
 src/slic3r/GUI/SavePresetDialog.cpp
+src/slic3r/GUI/SceneBenchmark.cpp
 src/slic3r/GUI/Search.cpp
 src/slic3r/GUI/SettingsIndex.cpp
 src/slic3r/GUI/SpeedDialDialog.cpp
@@ -195,7 +192,6 @@ src/slic3r/GUI/Tab.hpp
 src/slic3r/GUI/UnsavedChangesDialog.cpp
 src/slic3r/GUI/Auxiliary.cpp
 src/slic3r/GUI/UpdateDialogs.cpp
-src/slic3r/GUI/ObjColorDialog.cpp
 src/slic3r/GUI/SyncAmsInfoDialog.cpp
 src/slic3r/GUI/WipeTowerDialog.cpp
 src/slic3r/GUI/wxExtensions.cpp
@@ -257,7 +253,6 @@ src/slic3r/Utils/MKS.cpp
 src/slic3r/Utils/Moonraker.cpp
 src/slic3r/Utils/OctoPrint.cpp
 src/slic3r/Utils/Repetier.cpp
-src/slic3r/Utils/ProfileDescription.hpp
 src/slic3r/GUI/SendMultiMachinePage.cpp
 src/slic3r/GUI/MultiMachinePage.cpp
 src/slic3r/GUI/MultiMachineManagerPage.cpp
@@ -298,7 +293,10 @@ src/slic3r/GUI/AMSDryControl.cpp
 src/slic3r/GUI/AMSDryControl.hpp
 src/libslic3r/PresetBundle.cpp
 src/slic3r/GUI/CAD/DesignPanel.cpp
+src/slic3r/GUI/CAD/DesignSketchTool.cpp
 src/slic3r/GUI/CAD/SketchInlineEditor.cpp
+src/slic3r/GUI/CAD/DesignOffer.hpp
+src/slic3r/GUI/CAD/DesignTextDialog.cpp
 src/slic3r/GUI/Gizmos/GLGizmoPrimitive.cpp
 src/slic3r/GUI/Gizmos/GLGizmoSketch.cpp
 src/slic3r/GUI/KeyChord.cpp

localization/i18n/ru/OrcaSlicer_ru.po

@@ -27362,17 +27362,30 @@ msgstr ""
 msgid "Precise Seam"
 msgstr "Точный шов"
 
-msgid "multiple intersections with a perimeter detected"
-msgstr "обнаружены множественные пересечения с периметром"
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "failed to process some intersections (%1%)"
+msgstr "не удалось обработать некоторые пересечения (%1%)"
 
-msgid "modifier fully crosses the printable perimeter"
-msgstr "модификатор пересекает печатаемый периметр насквозь"
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "multiple intersections with a perimeter, only one was used (%1%)"
+msgstr "несколько пересечений с периметром, использовано только одно (%1%)"
 
-msgid "modifier shape is not solid (has holes inside) and was ignored"
-msgstr "форма модификатора не сплошная (имеет отверстия) и была проигнорирована"
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "a perimeter is fully inside a modifier, the modifier was not applied to it (%1%)"
+msgstr "периметр целиком внутри модификатора, модификатор для него не применён (%1%)"
 
-msgid "perimeter is fully contained inside modifier and was ignored"
-msgstr "периметр полностью содержится внутри модификатора и был проигнорирован"
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "modifier \"%1%\" of \"%2%\" had no effect on the seam (it might not reach the centerline of the printed perimeter)"
+msgstr "модификатор «%1%» модели «%2%» не повлиял на шов (возможно, он не достигает осевой линии печатаемого периметра)"
+
+#: src/libslic3r/GCode/SeamPlacer.cpp
+#, possible-boost-format
+msgid "modifier \"%1%\" of \"%2%\" (%3% in total) had no effect on the seam (it might not reach the centerline of the printed perimeter)"
+msgstr "модификатор «%1%» модели «%2%» (всего: %3%) не повлиял на шов (возможно, он не достигает осевой линии печатаемого периметра)"
 
 msgid "Seam placement may differ from expected."
 msgstr "Размещение шва может отличаться от ожидаемого."

resources/hms/hms_action_26A.json

@@ -1,323 +1,323 @@
 {
-    "result": 0,
-    "t": 1765968095,
-    "ver": 202511162200,
-    "data": [
-        {
-            "ecode": "03008041",
-            "image": "",
-            "actions": [
-                4,
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "03008060",
-            "image": "",
-            "actions": [
-                22
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "12008010",
-            "image": "c31daf51b36e446698f14c6df879ea21.png",
-            "actions": [
-                6,
-                4
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "12FF8010",
-            "image": "f87557495f2f2163a44bde8f4ddd9b8c.png",
-            "actions": [
-                4,
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "18008016",
-            "image": "",
-            "actions": [
-                4,
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "07008016",
-            "image": "",
-            "actions": [
-                4,
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "07018016",
-            "image": "",
-            "actions": [
-                4,
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "03002E0000030001",
-            "image": "",
-            "actions": [
-                52
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "03004016",
-            "image": "",
-            "actions": [
-                6
-            ],
-            "device": "26A"
-        },
-        {
-            "ecode": "03008019",
-            "image": "",
-            "actions": [
-                4
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0502C026",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004003",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004040",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004042",
-            "image": "",
-            "actions": [
-                36,
-                37
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "03008000",
-            "image": "",
-            "actions": [
-                2
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0C00402D",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004037",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004015",
-            "image": "",
-            "actions": [
-                14
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004007",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0502C014",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0300800C",
-            "image": "",
-            "actions": [
-                2
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004004",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0500402E",
-            "image": "",
-            "actions": [
-                14
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05024001",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0502C012",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0502C010",
-            "image": "",
-            "actions": [
-                35
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05008092",
-            "image": "",
-            "actions": [
-                27,
-                5
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004014",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0300800D",
-            "image": "",
-            "actions": [
-                2,
-                6
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0500402F",
-            "image": "",
-            "actions": [
-                14
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004041",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0500400E",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "05004043",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "0C00402C",
-            "image": "",
-            "actions": [
-                11
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "03008017",
-            "image": "",
-            "actions": [
-                4
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "03008013",
-            "image": "",
-            "actions": [
-                2
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "03008007",
-            "image": "",
-            "actions": [
-                2,
-                5
-            ],
-            "device": "default"
-        },
-        {
-            "ecode": "03008016",
-            "image": "",
-            "actions": [
-                4,
-                5,
-                6
-            ],
-            "device": "default"
-        }
-    ]
+	"result": 0,
+	"t": 1765968095,
+	"ver": 202511162200,
+	"data": [
+		{
+			"ecode": "03008041",
+			"image": "",
+			"actions": [
+				4,
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "03008060",
+			"image": "",
+			"actions": [
+				22
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "12008010",
+			"image": "c31daf51b36e446698f14c6df879ea21.png",
+			"actions": [
+				6,
+				4
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "12FF8010",
+			"image": "f87557495f2f2163a44bde8f4ddd9b8c.png",
+			"actions": [
+				4,
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "18008016",
+			"image": "",
+			"actions": [
+				4,
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "07008016",
+			"image": "",
+			"actions": [
+				4,
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "07018016",
+			"image": "",
+			"actions": [
+				4,
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "03002E0000030001",
+			"image": "",
+			"actions": [
+				52
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "03004016",
+			"image": "",
+			"actions": [
+				6
+			],
+			"device": "26A"
+		},
+		{
+			"ecode": "03008019",
+			"image": "",
+			"actions": [
+				4
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0502C026",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004003",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004040",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004042",
+			"image": "",
+			"actions": [
+				36,
+				37
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "03008000",
+			"image": "",
+			"actions": [
+				2
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0C00402D",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004037",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004015",
+			"image": "",
+			"actions": [
+				14
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004007",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0502C014",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0300800C",
+			"image": "",
+			"actions": [
+				2
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004004",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0500402E",
+			"image": "",
+			"actions": [
+				14
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05024001",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0502C012",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0502C010",
+			"image": "",
+			"actions": [
+				35
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05008092",
+			"image": "",
+			"actions": [
+				27,
+				5
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004014",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0300800D",
+			"image": "",
+			"actions": [
+				2,
+				6
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0500402F",
+			"image": "",
+			"actions": [
+				14
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004041",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0500400E",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "05004043",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "0C00402C",
+			"image": "",
+			"actions": [
+				11
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "03008017",
+			"image": "",
+			"actions": [
+				4
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "03008013",
+			"image": "",
+			"actions": [
+				2
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "03008007",
+			"image": "",
+			"actions": [
+				2,
+				5
+			],
+			"device": "default"
+		},
+		{
+			"ecode": "03008016",
+			"image": "",
+			"actions": [
+				4,
+				5,
+				6
+			],
+			"device": "default"
+		}
+	]
 }