three-slicer 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.5 — 2026-10-16
+
+### Fixed
+
+- The real wipe tower (`wipe_tower_real: true`) read past the end of its filament table on a tool change to or from
+  T2 or above (#69). The kernel registered filaments for tools 0 and 1 only, so the third tool's wipe moves took
+  their feedrate from whatever memory followed: `F0` or a value that changed from one slice to the next, and the
+  toolchange comment named no material. Every tool the change involves is now registered. On a three-extruder
+  slice the wipe moves went from 114 `F0` lines to none, and three runs give the same G-code. Each block now has the
+  shape the two-extruder tower always had. The default tower (the ring) and two-extruder slices are unchanged.
+  `wipe_tower_real` still defaults to `false`.
+
+### Changed
+
+- The kernel's own C++ and its tests were rewritten for readability: abbreviated names written out, one statement
+  per line, no ternaries, and one shared module for the test meshes. The kernel's output is unchanged, checked with
+  the golden G-code dump and a per-call hash of every kernel result in the test suite. Parameter keys, `stats`
+  fields and the worker protocol are unchanged.
+
 ## 0.3.4 — 2026-10-11
 
 ### Added

package/engine/PARAMS.md

@@ -230,7 +230,7 @@ same unit — `first_layer_height` comes from `initial_layer_print_height`, and
 | `extruder_retract_speed` | `?` | `[]` | `filament_retraction_speed` | undefined |
 | `extruder_z_hop` | `?` | `[]` | `filament_z_hop` | undefined |
 | `extrusion_rate_slope_segment_length` | `number` | `1.0` | — | segment split length for the real PE (mm) |
-| `filament_max_volumetric_speed` | `number[]` | `[]` | `filament_max_volumetric_speed` | mm³/s, per filament; empty = no cap (GW::capped_feed) |
+| `filament_max_volumetric_speed` | `number[]` | `[]` | `filament_max_volumetric_speed` | mm³/s, per filament; empty = no cap (GcodeWriter::capped_feed) |
 | `filter_out_gap_fill` | `number` | `0.0` | `filter_out_gap_fill` | filter_out_gap_fill (mm): gap fill shorter than this is dropped |
 | `first_layer_bed_temp` | `number` | `-1.0` | `before_layer_change_gcode`, `change_filament_gcode`, `filament_end_gcode`, `filament_start_gcode`, `file_start_gcode`, `hot_plate_temp_initial_layer`, `layer_change_gcode`, `machine_end_gcode`, `machine_start_gcode`, `time_lapse_gcode` | the plate type's _initial_layer bed option (<0 = none sent) |
 | `first_layer_flow_ratio` | `?` | — | `first_layer_flow_ratio` | undefined |

package/engine/src/contour_front_gpu.js

@@ -3,11 +3,11 @@
 //  between the cut and the union.
 //
 // What runs here (WGSL: contour_front_shaders.js), every layer at once:
-//   cut      per triangle, the layers it spans (exact z compares), each crossing in double-float, oriented as tri_plane
+//   cut      per triangle, the layers it spans (exact z compares), each crossing in double-float, oriented as intersect_triangle_with_plane
 //   cancel   segments coinciding exactly in opposite directions removed in pairs (cancel_coincident), by a hash on place
-//   chain    each end continues into the smallest unused segment starting at its 1e-3 mm key (chain_polys' greedy rule)
+//   chain    each end continues into the smallest unused segment starting at its 1e-3 mm key (chain_polygons' greedy rule)
 //   loops    pointer jumping for each loop's head and each segment's rank; tails that lead into a cycle stay out
-//   layout   loops sorted by (layer, head), laid out as chain_polys' n + 1 points, write_polygon's duplicates dropped
+//   layout   loops sorted by (layer, head), laid out as chain_polygons' n + 1 points, write_polygon's duplicates dropped
 //   tables   layer origins and grids, polygon ranges, the cell-list size
 //
 // Measured (design report gpu-full-port-trial-2026-10-01.md section 3): 3.0M triangles, 420 layers in 30 ms (the kernel's
@@ -205,10 +205,10 @@ export async function makeContourFront(device) {
     clear(loopStart, (headCount + 1) * 4)
     run(LOOPS_SHADER, 'lengths', 'urrrrwwwwwr', bound(uniform([segmentCount, padded, layerCount, headCount])), headCount)
     scan(loopStart, headCount + 1)
-    const [slotCount] = await readWords(loopStart, 1, headCount)      // points of the closed loops, chain_polys' n + 1 each
+    const [slotCount] = await readWords(loopStart, 1, headCount)      // points of the closed loops, chain_polygons' n + 1 each
     run(LOOPS_SHADER, 'place', 'urrrrwwwwwr', bound(uniform([segmentCount, padded, layerCount, headCount])), segmentCount)
 
-    // the points write_polygon keeps, the polygons chain_polys keeps, the layer boxes
+    // the points write_polygon keeps, the polygons chain_polygons keeps, the layer boxes
     const kept = buffer('kept', (slotCount + 1) * 4), polygonKept = buffer('polygonKept', (headCount + 1) * 4)
     const layerBox = buffer('layerBox', layerCount * 32), slotPolygon = buffer('slotPolygon', slotCount * 4)
     const boxStart = new Int32Array(layerCount * 8)

package/engine/src/contour_front_shaders.js

@@ -1,4 +1,4 @@
-// WGSL of the GPU front of PASS1 (contour_front_gpu.js): tri_plane -> chain_polys -> cancel_coincident ->
+// WGSL of the GPU front of PASS1 (contour_front_gpu.js): intersect_triangle_with_plane -> chain_polygons -> cancel_coincident ->
 //  build_gpu_input, every layer at once. Ported from the measured experiment (.omc/plans/gpu-work/fullport/gpu_slice.mjs,
 //  design report gpu-full-port-trial-2026-10-01.md section 3); edited only with a measurement beside it, as
 //  contour_gpu_shaders.js.

package/engine/src/slicer.worker.js

@@ -5,7 +5,7 @@
 //
 // Stage 30 (OOM tolerance): set_layer_sink lets the kernel emit layers as it produces them; each is transferred to main
 //  immediately (Float32Array buffers moved -> the worker copy is released at once) and the kernel frees that layer buffer
-//  from the heap. The resident result (the full gw.s + the full layersArr) disappears, so the WASM heap peak drops sharply
+//  from the heap. The resident result (the full GcodeWriter::gcode + the full layersArray) disappears, so the WASM heap peak drops sharply
 //  -> large models avoid OOM. The final 'done' carries stats only.
 //  In economy mode (params.economy) only G-code chunks are emitted, without toolpaths (finishes without a preview).
 //  The MM / real-PE paths fall back to batch mode.
@@ -27,7 +27,10 @@ import { FILL_TOOLS } from 'three-slicer-viewer/paint'
 //  and createSlicerClient both take an object and stringify it for you. One object, two shapes, and the difference
 //  showed up only at the boundary. The worker now accepts either; the SLA branch always did, which is what made
 //  the split arbitrary rather than principled.
-const paramsText = (params) => (typeof params === 'string' ? params : JSON.stringify(params ?? {}))
+const paramsText = (params) => {
+  if (typeof params === 'string') return params
+  return JSON.stringify(params ?? {})
+}
 
 let quiet = false
 const say = (level, ...args) => { if (!quiet) console[level](...args) }
@@ -120,7 +123,8 @@ const validatedPaintStates = (states) => {
 //  flow (viewer use_slicer.js) reads those two fields and nothing else.
 const reportedPaintStates = (message, paintedState) => {
   if (Array.isArray(message.states)) return validatedPaintStates(message.states)
-  return paintedState === null ? null : [paintedState]
+  if (paintedState === null) return null
+  return [paintedState]
 }
 
 // The state a paint message asks for: an explicit `state` wins, otherwise null meaning "use the legacy boolean path".
@@ -133,7 +137,10 @@ const explicitPaintState = (message) => {
 
 // Brush cursor shape (selector_bridge.h CURSOR_*). Sent as a name because the message is a protocol a host writes
 //  by hand; the integer stays on this side of it. Anything unknown is the sphere the brush has always used.
-const cursorShapeOf = (message) => (message.cursor === 'circle' ? 1 : 0)
+const cursorShapeOf = (message) => {
+  if (message.cursor === 'circle') return 1
+  return 0
+}
 
 // The tools that are not the radius brush: upstream's Smart fill and Bucket fill, plus its single-triangle POINTER
 //  cursor — which is literally bucket fill with propagation off, so the three share one dispatch. None of them takes
@@ -150,8 +157,15 @@ const strokeFrom = (message) =>
 // The fill modes the kernel's fill_preview takes (selector_bridge.h FILL_*), by the tool name the protocol uses.
 const FILL_PREVIEW_MODE = { smart: 0, bucket: 1, triangle: 2 }
 
+// A fill's angle limit in degrees, 30 when the message does not carry one. applyFill and the fill preview both
+//  read it here, so the preview selects what the fill will.
+const fillAngleOf = (message) => {
+  if (Number.isFinite(message.angle)) return message.angle
+  return 30
+}
+
 const applyFill = (Module, message, state) => {
-  const angle = Number.isFinite(message.angle) ? message.angle : 30
+  const angle = fillAngleOf(message)
   if (message.tool === 'smart') {
     if (state === null) Module.selector_seed_fill_erase(message.facet, message.hx, message.hy, message.hz, angle)
     else Module.selector_seed_fill(message.facet, message.hx, message.hy, message.hz, angle, state)
@@ -160,7 +174,8 @@ const applyFill = (Module, message, state) => {
   // Upstream passes -1 as the angle when it is not propagating (GLGizmoPainterBase.cpp ~861): with a single facet
   //  there is no neighbour to measure an angle against, and -1 is how that call says "no angle limit".
   const propagate = message.tool === 'bucket'
-  const bucketAngle = propagate ? angle : -1
+  let bucketAngle = -1
+  if (propagate) bucketAngle = angle
   if (state === null) Module.selector_bucket_fill_erase(message.facet, message.hx, message.hy, message.hz, bucketAngle, propagate)
   else Module.selector_bucket_fill(message.facet, message.hx, message.hy, message.hz, bucketAngle, propagate, state)
 }
@@ -276,7 +291,9 @@ const handleMessage = async (e) => {
     // `keepPaint` says the mesh is the same model in a new place, so the marks carry over — the reply reports whether
     //  they actually did, since a face-count change makes the kernel fall back to a clean registration.
     if (d.cmd === 'prepare') {
-      const kept = d.keepPaint ? Module.selector_reprepare(new Uint8Array(d.stl)) : (Module.selector_prepare(new Uint8Array(d.stl)), false)
+      let kept = false
+      if (d.keepPaint) kept = Module.selector_reprepare(new Uint8Array(d.stl))
+      else Module.selector_prepare(new Uint8Array(d.stl))
       reply({ type: 'prepared', facets: Module.selector_facet_count(), kept })
       return
     }
@@ -321,7 +338,8 @@ const handleMessage = async (e) => {
     //  A kernel built before this binding existed simply has no selector_import_paint; the reply says applied:0
     //  rather than throwing, because losing a 3mf's paint must not also lose its geometry.
     if (d.cmd === 'importPaint') {
-      const applied = Module.selector_import_paint ? Module.selector_import_paint(d.facets, d.hex ?? '') : 0
+      let applied = 0
+      if (Module.selector_import_paint) applied = Module.selector_import_paint(d.facets, d.hex ?? '')
       const importedReply = paintedReply(Module, d, null)
       importedReply.applied = applied
       reply(importedReply); return
@@ -332,7 +350,8 @@ const handleMessage = async (e) => {
     //  which objects were merged in what order is the viewer's knowledge. A kernel built before the binding existed
     //  reports supported:false rather than throwing — the save then falls back to the paint it imported.
     if (d.cmd === 'exportPaint') {
-      const exported = Module.selector_export_paint ? Module.selector_export_paint() : null
+      let exported = null
+      if (Module.selector_export_paint) exported = Module.selector_export_paint()
       reply({ type: 'paintExport', supported: !!Module.selector_export_paint,
                          facets: exported?.facets ?? [], hex: exported?.hex ?? '' })
       return
@@ -358,9 +377,11 @@ const handleMessage = async (e) => {
       // enf/blk stay unconditional for the listener that predates the per-state map. When the request names states,
       //  they are the ONLY ones read, so building the other two would be pure waste on the hot path.
       const wanted = states && !states.includes(PAINT_STATE_ENFORCER) && !states.includes(PAINT_STATE_BLOCKER)
-      const overlayReply = { type: 'overlay',
-        enf: wanted ? EMPTY_OVERLAY : Module.selector_overlay(true),
-        blk: wanted ? EMPTY_OVERLAY : Module.selector_overlay(false) }
+      const overlayReply = { type: 'overlay', enf: EMPTY_OVERLAY, blk: EMPTY_OVERLAY }
+      if (!wanted) {
+        overlayReply.enf = Module.selector_overlay(true)
+        overlayReply.blk = Module.selector_overlay(false)
+      }
       if (states) overlayReply.overlays = Object.fromEntries(states.map(state => [state, Module.selector_overlay_state(state)]))
       const transfer = [overlayReply.enf, overlayReply.blk, ...Object.values(overlayReply.overlays ?? {})]
         .filter(a => a?.buffer && a.byteLength > 0).map(a => a.buffer)
@@ -374,13 +395,15 @@ const handleMessage = async (e) => {
     if (d.cmd === 'fillPreview') {
       if (!Module.selector_fill_preview) { reply({ type: 'fillPreview', supported: false, tris: EMPTY_OVERLAY }); return }
       if (d.clear) { Module.selector_fill_preview_clear(); reply({ type: 'fillPreview', supported: true, tris: EMPTY_OVERLAY }); return }
-      const angle = Number.isFinite(d.angle) ? d.angle : 30
       const mode = FILL_PREVIEW_MODE[d.tool] ?? FILL_PREVIEW_MODE.smart
       // Upstream's -1 for the non-propagating case, the same value applyFill sends: one facet has no neighbour to
       //  measure an angle against.
-      const tris = Module.selector_fill_preview(d.facet, d.hx, d.hy, d.hz, mode === FILL_PREVIEW_MODE.triangle ? -1 : angle, mode)
-      reply({ type: 'fillPreview', supported: true, tris },
-                       tris?.buffer && tris.byteLength > 0 ? [tris.buffer] : [])
+      let previewAngle = fillAngleOf(d)
+      if (mode === FILL_PREVIEW_MODE.triangle) previewAngle = -1
+      const previewTriangles = Module.selector_fill_preview(d.facet, d.hx, d.hy, d.hz, previewAngle, mode)
+      const transfer = []
+      if (previewTriangles?.buffer && previewTriangles.byteLength > 0) transfer.push(previewTriangles.buffer)
+      reply({ type: 'fillPreview', supported: true, tris: previewTriangles }, transfer)
       return
     }
     // paintMode: the brush-wide options upstream keeps on the gizmo — the overhang restriction and the section

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Browser/WASM 3D-printing slicer reverse-engineered from OrcaSlicer: slicing engine (Arachne walls, tree/grid supports, multi-material), SLA resin slicing with PrusaSlicer's ported support/pad chain and .sl1 export, React viewer with GPU toolpath preview, and schema-driven settings UI.",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -134,6 +134,6 @@
     "clipping"
   ],
   "dependencies": {
-    "three-slicer-viewer": "0.3.4"
+    "three-slicer-viewer": "0.3.5"
   }
 }