Belt printer: sync with main, plus the fixes the merge needs (#16145)

Brings `belt-printer` up to date with `main` (4b4a261787) so that #14394
merges cleanly again, and adds the follow-up fixes the merge needs. This
PR targets `belt-printer`, not `main`.

## Commits

1. **GCode: hold the writer by value again.**
- Belt printing had turned `GCode::m_writer` into a `unique_ptr`, so
that `BeltGCode` could swap in a new writer carrying the belt
kinematics.
- Nothing subclasses `GCodeWriter`, and `set_kinematics()` can install
the belt mapping on the existing writer. This commit removes the swap.
- About 190 `m_writer->` edits revert, which takes `GCode.cpp` from 29
conflict hunks with main down to 3.
- The G-code is identical to the current `belt-printer` head on two
BabyBelt projects (see Verification).
2. **Merge upstream/main.** The resolutions are listed in the merge
commit. The ones that needed a decision:
- `write_belt_header()` follows main's relocated header block (#15897,
#15915).
- First-layer acceleration keeps the per-path first-layer plane test,
now with main's cached nozzle index (#16028).
- The arc-to-polyline fallback moves into the out-param
`extrude_arc_to_xy`, which is the overload `GCode` now calls (#16108).
   - The belt fields join `GCodeProcessorResult`'s forwarding assign.
   - The Clipper2 renames (#15969).
   - Belt printers still reserve no CLI wipe tower (#15837).
- The new sparse-layer tower options are hidden for belt printers
(#15841).
3. **Belt: register the raw G-code toggle as a Preview shortcut.**
- Main's assignable shortcuts (#15706) replaced the key switch that
carried **B**.
- The toggle is now `ToggleBeltRawGcode`, bound to B in the Preview,
where B was free. It is listed in the shortcuts dialog and can be
rebound, and the legend shows whichever key is bound.
4. **Precise Seam: slice modifiers in the belt slicing frame.**
- The new `slice_single_volume_regions()` (#16072) sliced modifiers with
`trafo_centered()`, so on belt prints the modifier regions landed in the
unrotated frame.
- It now uses `trafo_sliced()`, as the seam enforcers and support
volumes already do. On non-belt printers the two transforms are the
same.
   - A regression test is included.
5. **Belt profiles: inherit what they repeat and pass main's profile
checks.**
- The BabyBelt Pro and IR3 V2 filaments name their single extruder
variant, as the library-based filaments of other vendors do, and drop
overrides that repeat the library value.
- The Custom belt base inherits `printer_extruder_id` from its parent.
- `normalize` drops the obsolete keys. `fix-variant` gives the machine
limits their silent-mode entry, which they previously read from the
single value.
   - All three vendor versions are bumped.
- Printcepts and IdeaFormer keep their own machine and process bases,
because only filaments can inherit across vendor bundles.
6. **Profile validator: accept a belt printer's tool change without a
tower.**
- The slice sweep (185cfe4323) forces a prime tower and requires its `CP
TOOLCHANGE START` block.
- Belt printers have no wipe tower: they purge into a prism object.
Their filament change is the plain `T` command, which they emit
throughout the slice.
- On belt printers the validator now looks for that `T1` line instead.

## Verification

All on Linux.

- **`m_writer` equivalence.** The current `belt-printer` head
(b22384a559) and commit 1 were each built and used to CLI-slice two
BabyBelt benchy projects (389k and 804k lines of G-code). The output is
identical apart from the per-run object ids in the `printing object …
id:` comments.
- **Merged branch, belt-specific checks.**
- The belt header is written, no `;_BELT_BAND` markers leak, and the
belt axis never steps back.
- Against the Oct 3 belt + main merge, the only G-code differences are
fill ordering on a few layers and time estimates. Both come from main's
changes since then.
- Against the pre-merge output the differences are much larger. That is
expected: main's CLI now refreshes a project's settings from its system
presets (#15953, #16038), so for example `z_hop` follows the belt
profiles' 0.
- **Tests.**
- `fff_print_tests`: 345/345 test cases pass, including 30 `[belt]`
cases.
  - `libslic3r_tests`: 1081 passed, 2 skipped.
- The new Precise Seam test fails 266 of its 284 assertions with the fix
reverted.
- **Profiles.**
  - `scripts/orca_profile_tool.py check` passes for all 69 vendors.
- `OrcaSlicer_profile_validator -s -l 2`: all 1271 slices succeed.
Before commit 6, the six belt printers failed.
- A flattened before/after snapshot of every belt preset shows no value
a belt printer reads has changed.
- **GUI** (BabyBelt Pro, clean datadir):
- B switches the Preview between the designed and the raw machine-frame
G-code, and pressing it again restores the view exactly.
  - The legend reads "Show raw G-code (belt only) [B]".
- The shortcuts dialog lists the toggle under Preview → Display as
rebindable.
- The sparse-layer tower options stay hidden in Advanced and Expert
modes.

Main has since gained one CI-only commit (f3d0b8a553), which merges
cleanly on top.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

https://claude.ai/code/session_01AJzy1xeQV3FePh5HfahDyn

.clang-tidy

@@ -0,0 +1,65 @@
+# clang-tidy configuration. 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.
+Checks: '-*,misc-include-cleaner'
+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
 
@@ -529,6 +531,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
 

.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

.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/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

.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_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
@@ -276,6 +259,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/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

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/libnest2d/include/libnest2d/placers/nfpplacer.hpp

@@ -1111,7 +1111,27 @@ private:
         default: ; // DONT_ALIGN
         }
 
-        auto d = cb - ci;       
+        auto d = cb - ci;
+
+        // Keep the pile on the bin. A target near an edge (a belt printer starts its parts
+        // at the leading end of the belt) would otherwise centre a pile that is larger than
+        // the room around that point on it and push part of the pile off the bed. The pile
+        // stops at the edge instead; the items' boxes carry their inflation, which is the
+        // margin left there. A pile that does not fit along an axis is centred on it.
+        {
+            auto on_bin = [](Coord lo, Coord hi, Coord bin_lo, Coord bin_hi, Coord shift) {
+                if (hi - lo >= bin_hi - bin_lo)
+                    return (bin_lo + bin_hi) / 2 - (lo + hi) / 2;
+                if (lo + shift < bin_lo)
+                    shift = bin_lo - lo;
+                if (hi + shift > bin_hi)
+                    shift = bin_hi - hi;
+                return shift;
+            };
+            setX(d, on_bin(getX(bb.minCorner()), getX(bb.maxCorner()), getX(bbin.minCorner()), getX(bbin.maxCorner()), getX(d)));
+            setY(d, on_bin(getY(bb.minCorner()), getY(bb.maxCorner()), getY(bbin.minCorner()), getY(bbin.maxCorner()), getY(d)));
+            cb = ci + d;
+        }
 
         // BBS make sure the item won't clash with excluded regions
         // do we have wipe tower after arranging?

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/design-tab.md

@@ -51,14 +51,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 +116,8 @@ 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.
 
 ## The interaction 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

@@ -180,6 +180,7 @@ 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

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/calib/temperature_tower/gen_belt_temp_tower.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Belt temperature-tower asset generator (discrete-provini design).
+
+A vertical temperature tower cannot be sliced on a belt printer, so lay a row of
+DISCRETE provini (one per temperature) along the belt (designed Y) with a fixed
+surface gap. Each provino is the chevron+arc unit (belt_temp_provino_unit.stl,
+keel-first); its temperature is ENGRAVED upright into the 50 mm face — a raised
+number would be an unsupported overhang on the belt. The C++ calib_temp belt branch
+(Plater.cpp) injects one M104 per zone 70 layers INTO provino i:
+  print_z[i] = i * PITCH * cos(theta) + 70 * layer_height   (theta = 45)
+inside the body, not in the empty inter-provino gap (which has no sliced layers for
+the event to attach to). PITCH below is the shared geometry contract with that code —
+keep them in sync.
+
+Generates one STL per filament temp range used by Temp_Calibration_Dlg.
+"""
+import numpy as np, trimesh, os
+from matplotlib.textpath import TextPath
+from matplotlib.font_manager import FontProperties
+from shapely.geometry import Polygon as ShPoly
+from shapely.ops import unary_union
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+UNIT = os.path.join(HERE, 'belt_temp_provino_unit.stl')   # single provino, keel-first
+SURF_GAP = 25.0            # surface-to-surface gap between provini (mm) — user spec
+TEXT_H = 9.0
+TEXT_DEPTH = 0.8           # engraving depth (numbers are CUT into the face, not raised:
+                          # a raised number is an unsupported Y-overhang on the belt)
+TEXT_OVERSHOOT = 0.6       # extra height poking out of the face for a clean boolean cut
+
+# Temperature ranges (start, end) per filament family, 5 C step. File name encodes them.
+RANGES = [(230,190),(270,230),(250,230),(280,240),(240,210),(320,280)]
+
+unit = trimesh.load(UNIT)
+dY = unit.bounds[1,1] - unit.bounds[0,1]
+PITCH = dY + SURF_GAP                       # designed-Y pitch == C++ contract constant
+print(f"unit dY={dY:.2f}  PITCH={PITCH:.3f}  (C++ contract: print_z[i]=i*{PITCH:.3f}*cos45)")
+
+# 50 mm face normal (0,-1,1)/sqrt2 ; UPRIGHT basis u=+X det(+1) (verified non-mirrored)
+n = np.array([0,-1,1.])/np.sqrt(2)
+u = np.array([1,0,0.]); v = np.array([0,1,1.])/np.sqrt(2)
+R = np.column_stack([u,v,n])
+fn = unit.face_normals; fc = unit.triangles_center; fa = unit.area_faces
+sel = (fn@n) > 0.9
+face_c = (fc[sel]*fa[sel,None]).sum(0)/fa[sel].sum()
+
+def text_mesh(s):
+    tp = TextPath((0,0), s, size=TEXT_H, prop=FontProperties(family='DejaVu Sans'))
+    rings = [ShPoly(p) for p in tp.to_polygons() if len(p)>=3]
+    rings.sort(key=lambda r:r.area, reverse=True)
+    used=[False]*len(rings); parts=[]
+    for i,o in enumerate(rings):
+        if used[i]: continue
+        holes=[]
+        for j in range(i+1,len(rings)):
+            if not used[j] and o.contains(rings[j]): holes.append(rings[j].exterior.coords); used[j]=True
+        parts.append(ShPoly(o.exterior.coords,holes)); used[i]=True
+    poly = unary_union(parts)
+    geoms = list(poly.geoms) if poly.geom_type=='MultiPolygon' else [poly]
+    m = trimesh.util.concatenate([trimesh.creation.extrude_polygon(g,height=TEXT_DEPTH+TEXT_OVERSHOOT) for g in geoms])
+    c = m.bounds.mean(axis=0); m.apply_translation([-c[0],-c[1],0]); return m
+
+for t_start, t_end in RANGES:
+    temps = list(range(t_start, t_end-1, -5))
+    parts=[]
+    for i,T in enumerate(temps):
+        c = unit.copy(); c.apply_translation([0, i*PITCH, 0])
+        t = text_mesh(str(T)); M=np.eye(4); M[:3,:3]=R; t.apply_transform(M)
+        # place the text spanning from TEXT_DEPTH inside the face to TEXT_OVERSHOOT outside,
+        # then CUT it out of the provino (engrave) — no raised material, no Y-overhang.
+        t.apply_translation(face_c - n*TEXT_DEPTH + np.array([0,i*PITCH,0]))
+        c = trimesh.boolean.difference([c, t], engine='manifold')
+        parts.append(c)
+    asset = trimesh.util.concatenate(parts)
+    out = os.path.join(HERE, f"belt_temp_tower_{t_start}_{t_end}.stl")
+    asset.export(out)
+    dims = np.round(asset.bounds[1]-asset.bounds[0],1)
+    wt = all(p.is_watertight for p in parts)
+    print(f"  {t_start}->{t_end}: {len(temps)} zones  bbox={dims}  watertight={wt}  -> {os.path.basename(out)}")

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"
+		}
+	]
 }