three-slicer 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -1,5 +1,176 @@
 # Changelog
 
+## 0.3.3 — 2026-10-01
+
+### Added
+
+- The layer contours can be computed on the GPU. The viewer's slice bar has a GPU select (`gpu_acceleration`:
+  `auto`, `on`, `off`), and the worker's slice message takes `gpu: true`. `auto` uses it on the single-threaded
+  kernel only, where a 3M-facet slice went from 9.8 to 7.6 s; the threaded kernel gains nothing measurable. A GPU
+  slice's G-code differs from the CPU slice's in its vertices (same contour area), and the result's
+  `stats.contour_engine` says which engine ran.
+- On the single-threaded kernel the GPU also cuts the mesh into layers and chains the loops (`stats.contour_front`
+  `'gpu'`; the slice card reads "Contours cut and unioned on the GPU"). The kernel hands its mesh over instead of
+  cutting every layer itself: on a 3M-facet model that part went from 419-442 ms to 34-154 ms plus 64-153 ms on the
+  GPU. A layer the GPU cannot close is cut by the kernel as before.
+- `support_style` `tree_slim`, `tree_strong` and `tree_hybrid` reach the kernel as `tree_style`. They used to slice
+  as organic.
+
+### Changed
+
+- The threaded kernel ships its wasm as a file, `engine/src/slicer_core.mt.wasm`, instead of inlining it in
+  `slicer_core.mt.js` (6.4 MB -> 107 KB). Every pthread worker loads the glue, and the inlined bytes cost each of
+  them about 60 MB of V8 heap; Chrome holds every isolate of a tab in one 4 GB heap region, so slicing several plates
+  at once crashed the tab ("V8 javascript OOM"; 3 workers on a 6-plate project: 4 crashes in 6 runs). With the file,
+  3 to 8 workers ran without a crash and peaked at 1.2-1.9 GB. A bundler emits the file as an asset; see
+  "Multithreaded WASM" in the README for serving it.
+- Tree support (slim, strong, hybrid) runs four of its loops on every thread of the threaded kernel: a 1.13M-facet
+  hybrid plate went from 91 to 21 s, with the same G-code as the single-threaded kernel.
+- Tree support unions each layer's support circles per group of overlapping circles instead of all at once. On the
+  same plate the slice went from 21.2-21.6 to 18.9-19.0 s (threaded) and from 110.3 to 98.0 s (single-threaded).
+  The support area is unchanged; its G-code vertices come out in another order (support extrusion 4113.49 ->
+  4113.50 mm, every model path unchanged).
+- Tree support finds overhangs on every thread of the threaded kernel (it ran on one): on the same plate the slice
+  went from 18.6-18.9 to 17.6-17.7 s, with the same G-code.
+- Tree support no longer recomputes the same offsets while it drops branches and groups overhangs (a dilation per
+  node move, a whole-layer line clip per segment, a region offset per cluster tried): on the same plate the slice
+  went from 17.1-17.3 to 15.5-15.6 s, with the same G-code.
+- Tree support's threads no longer queue on two locks while they move branches (one over the line-cut cache, one
+  around every new node), the branch spanning trees are built in one pass per vertex and per part on threads, and the
+  layer outlines are prepared beside overhang detection instead of after it: on the same plate 15.6 -> 13.9-14.1 s,
+  then 10.2-10.3 -> 9.7-9.8 s, with the same G-code.
+- Tree support unions each group of overlapping circles as a tree of smaller unions, split by position: draw_circles
+  4.6 -> 2.3 s on the same plate (11.6-11.8 s slice). The support area is the same; the intermediate unions round
+  their crossings once more, so the support G-code moves slightly (support extrusion 4113.50 -> 4113.56 mm, the worst
+  layer 0.27 %, every model path unchanged). Clipper2's union measured slower and is not used.
+- Arachne walls are written by the threaded kernel's G-code writers like every other path (they were written on one
+  thread): on the same plate emit 3.2 -> 1.7 s (11.7 -> 10.2 s slice), with the same G-code, toolpaths and widths as
+  the single-threaded kernel.
+
+- The toolpath preview culls back faces and, far from the camera, draws every 2nd or 4th layer that many layers
+  thick (raft and skirt layers and a cut layer range keep full detail). Measured on a 6-plate project with 14.6M
+  segments: 67.8 -> 34.8 ms per frame, the overview 27.6 -> 9.6 ms.
+- Switching plates no longer recolours every plate or builds the focused plate's G-code Blob (332-574 ms -> no task
+  over 50 ms). "Export G-code" builds its plain `.gcode` on click and hands it to the host's `onExport` like the other
+  exports; it used to be a prefilled download link that bypassed `onExport`.
+- A 3mf loads with each part inflated by `DecompressionStream`, read from its bytes and baked (normals, bounds) in
+  the parse worker, with the build items spread over copies of that worker: 1338-1352 -> 367-372 ms on a 52 MB
+  project, with the same meshes. zip64 and encrypted archives keep the previous reader.
+
+### Fixed
+
+- A click on a plate in Preview did nothing; it now selects the plate.
+- Tree support could lose a whole support island's paths on a layer: reordering a layer's paths dropped any group of
+  paths whose first or last member was empty, with every path in it (a 3M-facet tree-slim model lost 64.6 mm of
+  support paths over three layers). Only the empty members are dropped now. Models where it did not happen slice to
+  the same G-code.
+- Tree slim, strong and hybrid crashed the kernel on any model.
+- The same tree slim or strong input could slice to different G-code from run to run (a tie in the minimum spanning
+  tree was broken by memory address).
+- A Bambu Lab X2D or H2D project failed every slice with `CUSTOM_GCODE_ERROR`: the start G-code reads
+  `first_filaments` and `first_non_support_filaments` per physical nozzle, which were missing or not mapped.
+- A plate whose objects are all on one filament other than the first printed with filament 1: the start G-code
+  loaded it (`M620 S0A` on a Bambu Lab printer) and its temperature, flow and retraction were used. The kernel
+  takes `single_tool`, which the viewer sends for such a plate, and prints with that filament's values; the
+  start and end G-code see it as `initial_extruder` / `current_extruder` and the footer reports its use.
+
+## 0.3.2 — 2026-09-21
+
+### Added
+
+- The prime tower is set per plate. The Prime tower card carries the same Global | Plate switch as the Process,
+  Printer and Filament cards: in plate scope its mode, width, purge destination and purging table become that
+  plate's override. The position was already per plate (`wipe_tower_x/y[plate]`) and stays in the global map.
+- A saved `.3mf` carries the per-plate overrides and the global map's non-schema keys (`wipe_tower_real`,
+  `sla_antialias`) in a member of its own, `Metadata/three_slicer_settings.json`, and an import restores them.
+  Upstream has no place for either and ignores the member, so OrcaSlicer still opens the file on the global preset.
+- The kernel can tag every extrusion run with upstream's `;TYPE:` (`gcode_role_tags`, opt-in; the viewer turns it
+  on), from the same role the preview draws. A saved G-code read back as text colours as the slice did.
+- "Export all" writes one `.gcode.3mf` (upstream's "Export all plate sliced file") instead of one `.gcode` download
+  per plate: each plate's G-code as `Metadata/plate_N.gcode` with its MD5, the estimate in `slice_info.config`, no
+  meshes. Opening one (drop, picker or `files`) puts every plate's G-code back on its plate and makes the viewer
+  preview-only until it is closed from the top bar or a model is loaded. The `gcode` prop also takes a
+  `{ plateIndex: text }` map. A resin plate still exports as its own `.sl1`.
+- The sidebar's Export G-code button saves every sliced plate in one `.gcode.3mf` (upstream's "Export all sliced
+  file"). Its ▾ menu holds the viewed plate alone as a `.gcode.3mf` and the plain `.gcode`. It also works on an
+  opened `.gcode.3mf`, so a print job can be saved again.
+
+- The Open button and the drop target take a plain `.gcode` / `.gco` / `.g`. It opens on the selected plate
+  through the same path a `.gcode.3mf` takes: the top bar names it and closes it. A file with no printable move is
+  refused before it opens. The demo app's own Open G-code button is gone.
+- An exported G-code states its filament colours (`; filament_colour` in the config block, where upstream reads
+  settings), so it opens in its colours here and in OrcaSlicer. A file that already states a palette keeps it; the
+  kernel's G-code itself is unchanged.
+
+### Changed
+
+- The ring / real tower choice is the settings key `wipe_tower_real` (a viewer knob, like `sla_antialias`) instead
+  of component state, so it follows plate overrides and survives a save. Absent means the ring, as before.
+- The tower stand-ins are decided per plate: a plate gets one only when it changes tools itself, and each plate
+  draws its own width and on/off. A dragged or typed tower position is kept on the bed.
+- The tower stand-in is selected alone and only translated. It no longer joins a multi-selection, takes a
+  rotate/scale gizmo, or adds an undo entry that undid nothing.
+
+### Fixed
+
+- An opened multi-material G-code drew its model as prime tower in the Feature view: the multi-material path wrote
+  no role marks, so everything after a tower's comment inherited it until the next layer.
+- A loaded G-code was drawn in the session's palette instead of its own. The Filament view reads each plate's
+  palette from its result (the file's, with the session's filling the holes), and every tool the result used gets
+  a colour, so a file with more tools than the session has filaments no longer shows T3 in three different colours
+  across the toolpath, the stats card and the legend. The G-code reader reports per-tool filament
+  (`filament_mm_by_tool`).
+- The drop overlay and the load-rejection message listed STL/OBJ/3MF/AMF/PLY by hand: neither named STEP, which the
+  demo registers, and the overlay named neither SL1 nor G-code. Both now read `SUPPORTED_EXT`.
+- The G-code reader dropped a `;TYPE:` written between a layer marker and the layer's first move (Cura's
+  `;LAYER:` files, this kernel's raft layers), reading that run as wall.
+- The drop highlight stayed on after a drop the host handled itself (the demo app's `.gcode` drop): the canvas's
+  own handler never ran and a drop fires no `dragleave`. The window's capture phase now clears it.
+- Injected G-code moved half a bed off its plate whenever the plate grid was re-laid out (adding a plate, editing
+  the bed): the re-layout set every display offset to the plate origin, dropping the bed-corner offset injected
+  G-code carries. Offsets now move by the origin's delta.
+- Two objects on the same spot sliced to nothing. The kernel slices the merge of every object as one mesh and filled
+  the layer loops even-odd, so coincident shells counted as "inside twice". Segments are now oriented by the facet
+  normal and filled NonZero, upstream's Regular slicing mode, in the FFF, multi-material and SLA paths. Measured: a
+  project imported twice printed 1,210 mm of a 42,984 mm model before, the full model now. Clean meshes slice the
+  same regions (0 area difference on the fixtures, under 0.0003 mm² per layer on the Benchy), but a loop can start
+  at a different vertex, so G-code of models other than the golden fixtures may differ in point order.
+- A saved `.3mf` with a tower position on some plates and automatic placement on others wrote `null` into
+  `wipe_tower_x/y`. OrcaSlicer's loader stops reading the whole file at an array entry that is not a string, which
+  dropped the 17 settings after it, `z_hop` and `z_offset` among them. The hole is now written as the schema default
+  for upstream and kept as a hole in `Metadata/three_slicer_settings.json`.
+- The GPU SL1 mask path (`sla_antialias`, `sl1_parity_gpu.js`) counted surfaces above the plane as a parity, so two
+  coincident objects came out empty in the masks while the slice and its supports treated them as solid. The count
+  is now signed by facing (NonZero), the kernel's fill rule.
+- Painting one plate and then another discarded the first plate's paint, and a copy placed where the original sits on
+  its own plate took the original's paint over (the original then sliced single-material, the copy printed both).
+  Paint now lives on each object (`core/paint_store.js`): the selector is written back to it before it switches
+  mesh and loaded from it after; slice-all pool workers load their plate's paint; a 3mf save writes every plate's
+  brush strokes (it used to save them only for a single-plate project); copy, duplicate and paste carry the paint,
+  and a split hands each part the marks on its own facets.
+- A brush stroke painted only the first object of the plate being painted: the hit facet was sent in the hit
+  object's own numbering, not the plate merge's. A stroke now also carries across plates — reaching an object on
+  another plate selects that plate and keeps painting there, and an object added to the plate while the brush is
+  open is painted too.
+- Dragging a painted object no longer drags the paint of the other objects on its plate along with it.
+- A paste pressed right after a copy pastes that copy; a double-pressed delete records one undo step; a drag
+  committed while a slice loads its plate's paint no longer reaches the worker before that slice.
+- A paint export the worker fails no longer discards the unsaved strokes (the swap stops instead), and Clear
+  pressed during a plate switch clears the plate it lands on instead of doing nothing. Strokes made right after
+  switching between the support and material brushes are no longer saved as the other kind of paint.
+- Switching between the support and material brushes with the section plane on no longer leaves the kernel a
+  shifted plane on plates past the first; support-only paint stays drawn after a drag on its plate; a slice that
+  leaves support paint out under material paint says so again.
+- Paint for a filament that is not configured (T3 painted, then the list cut to two) no longer widens the extruder
+  count on a slice-all pool worker only; every path leaves it out and the slice says so.
+  Every plate's paint stays drawn, not only the plate being painted.
+- Review fixes to the paint store, each reproduced before the fix: a slice-all pool worker printed the previous
+  plate's paint on an unpainted plate; opening the support brush filed another plate's material paint as support
+  paint; a 3mf save wrote every object under one paint attribute and let an empty support map hide material paint;
+  a worker replaced by the watchdog wiped the stored paint of the plate it held; and a save waiting on a worker
+  that was then terminated stayed on "Saving…" with the viewport blank. Worker replies now echo a `requestId`, so
+  an error reply ends only the request it belongs to.
+
 ## 0.3.1 — 2026-09-16
 
 ### Added

package/README.md

@@ -679,6 +679,11 @@ Cross-Origin-Embedder-Policy: require-corp
 
 Without those headers, the engine falls back to the single-threaded kernel.
 
+The multithreaded kernel's wasm is a file beside its glue, `engine/src/slicer_core.mt.wasm`, reached through
+`new URL('slicer_core.mt.wasm', import.meta.url)`; Vite and webpack emit it as an asset. Serve it as
+`application/wasm`, and from another origin (a CDN) with `Cross-Origin-Resource-Policy: cross-origin`, or the
+cross-origin isolated page cannot load it. The single-threaded kernel still inlines its wasm.
+
 ## Data Files
 
 The package includes extracted OrcaSlicer metadata for custom interfaces:
@@ -737,6 +742,7 @@ the layout by hand.
 | `printerSettings(name)` | Settings a vendor machine profile applies |
 | `printerKeys` | Every key a printer profile can set — clear these before applying another |
 | `printerDefaultPreset(name)` | The vendor's recommended process preset for that printer |
+| `printerDefaultBedType(name)` | The bed type the printer's model defaults to — the viewer writes it to `curr_bed_type` on a pick |
 | `machineLimitKeys` | The schema keys the kernel's machine limits are read from |
 | `processPresets()` | Lazy facade over the print (process) preset catalog |
 | `filamentPresets()` | Lazy facade over the material preset catalog |