three-slicer 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,102 @@
 # Changelog
 
+## 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/engine/PARAMS.md

@@ -8,8 +8,8 @@ cannot drift from what `slice()` actually honours. Regenerate with `node types/g
 
 <!-- KERNEL-PARAMS:BEGIN — generated by types/gen_kernel_params.mjs, do not edit by hand -->
 
-The kernel accepts **159 parameters**. `deriveKernelParams()` produces 131 of them from the
-OrcaSlicer settings map; the remaining 28 have no schema key behind them and can only be set by writing
+The kernel accepts **160 parameters**. `deriveKernelParams()` produces 131 of them from the
+OrcaSlicer settings map; the remaining 29 have no schema key behind them and can only be set by writing
 the params object directly — those rows show `—` in the *From setting* column.
 
 A parameter left out of the object keeps the default listed here, so sending a partial object is normal and is
@@ -205,6 +205,7 @@ same unit — `first_layer_height` comes from `initial_layer_print_height`, and
 | `flush_multiplier` | `number` | `1.0` | `flush_multiplier` | upstream scales the whole table by this |
 | `flush_volumes_matrix` | `number[]` | `[]` | `flush_volumes_matrix` |  |
 | `gcode_config_block` | `boolean` | `false` | — | ; CONFIG_BLOCK_START … the parameters this slice ran with … END |
+| `gcode_role_tags` | `boolean` | `false` | — | ;TYPE:<role> on every role change (upstream GCodeProcessor tag) |
 | `gcode_stats_block` | `boolean` | `false` | — | ; filament used [mm]/[cm3]/[g], cost, total filament change |
 | `independent_support_layer_height` | `boolean` | `false` | `independent_support_layer_height` | false by default because of the kernel z grid constraint (gap quantized to layers) |
 | `keep_stages` | `boolean` | `false` | — | keep the stages cached after slicing (skips the early release — a memory trade-off) |
@@ -231,7 +232,7 @@ A `—` in *From setting* means there is no OrcaSlicer option behind that parame
 in the params object yourself. They are not one kind of thing, and the difference matters before you reach for one:
 
 - **Host runtime flags** — `economy`, `keep_stages`, `reuse_stages`, `time_engine`, `wipe_tower_real`,
-  `gcode_stats_block`, `gcode_config_block`. Decisions the *caller* makes about a particular run, not properties of
+  `gcode_stats_block`, `gcode_config_block`, `gcode_role_tags`. Decisions the *caller* makes about a particular run, not properties of
   the print. `economy` is the last rung of an out-of-memory retry: it streams G-code and skips the preview
   toolpaths and the time estimate, so a model that cannot finish any other way still finishes.
 - **Values the viewer computes** — `extruder_count`, `mm_group_split`, `mm_group_splits`, `mm_group_tools`,

package/engine/src/slicer.worker.js

@@ -132,14 +132,21 @@ const applyFill = (Module, message, state) => {
 //  listener predating the per-state map keeps working; `counts` appears only when the message asked for states,
 //  which is what keeps a legacy paint reply byte-identical to what it was before the protocol was widened.
 const paintedReply = (Module, message, paintedState) => {
-  const reply = { type: 'painted', enf: Module.selector_painted_count(true), blk: Module.selector_painted_count(false) }
+  const answer = { type: 'painted', enf: Module.selector_painted_count(true), blk: Module.selector_painted_count(false) }
   const states = reportedPaintStates(message, paintedState)
-  if (states) reply.counts = Object.fromEntries(states.map(state => [state, Module.selector_painted_count_state(state)]))
-  return reply
+  if (states) answer.counts = Object.fromEntries(states.map(state => [state, Module.selector_painted_count_state(state)]))
+  return answer
 }
 
 self.onmessage = async (e) => {
   const d = e.data
+  // Every reply to a request that carried a `requestId` carries it back, the error reply included — so a caller
+  //  waiting on one request cannot take another request's answer (or another command's error) for its own. A
+  //  request without one gets exactly the replies it always got.
+  const reply = (message, transfer) => {
+    if (d?.requestId === undefined) { self.postMessage(message, transfer); return }
+    self.postMessage({ ...message, requestId: d.requestId }, transfer)
+  }
   // Read before the kernel loads: loadCore() below is what prints, so a `quiet` arriving with the first message
   //  (the warmup) has to take effect before that call, not after it.
   if (d.quiet !== undefined) quiet = !!d.quiet
@@ -148,28 +155,28 @@ self.onmessage = async (e) => {
     //  has never loaded it then selector_prepare has never run either, so there is no painting to report — and
     //  making a save wait on a 4MB WASM load before the first slice is seconds of nothing, for an empty answer.
     if (d.cmd === 'exportPaint' && !modPromise) {
-      self.postMessage({ type: 'paintExport', supported: false, facets: [], hex: '' }); return
+      reply({ type: 'paintExport', supported: false, facets: [], hex: '' }); return
     }
     if (d.cmd === 'slaJob') {
       const job = parseSlaJob(d.job)
       if (!modPromise) modPromise = loadCore()
       const Kernel = await modPromise
-      const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
+      const onProgress = (done, total) => reply({ type: 'progress', done, total })
       if (Kernel.slice_sla_job) {
         Kernel.set_layer_sink((z, idx, gcode, paths, widths) => {
           const transfer = []
           if (paths?.buffer) transfer.push(paths.buffer)
           if (widths?.buffer) transfer.push(widths.buffer)
-          self.postMessage({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
+          reply({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
         })
         let r
         const started = performance.now()
         try { r = Kernel.slice_sla_job(job, onProgress) }
         finally { Kernel.clear_layer_sink() }
-        if (r?.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
-        self.postMessage({ type: 'done', result: withSliceThroughput(r, performance.now() - started) }); return
+        if (r?.error) { reply({ type: 'error', error: String(r.error) }); return }
+        reply({ type: 'done', result: withSliceThroughput(r, performance.now() - started) }); return
       }
-      self.postMessage({ type: 'error', code: 'SLA_UNSUPPORTED_OBJECT_AWARE',
+      reply({ type: 'error', code: 'SLA_UNSUPPORTED_OBJECT_AWARE',
                         error: 'Object-aware SLA slicing requires WASM kernel support' })
       return
     }
@@ -180,20 +187,20 @@ self.onmessage = async (e) => {
       const params = paramsText(d.params)
       if (!modPromise) modPromise = loadCore()
       const Kernel = await modPromise
-      const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
+      const onProgress = (done, total) => reply({ type: 'progress', done, total })
       if (Kernel.slice_sla) {
         Kernel.set_layer_sink((z, idx, gcode, paths, widths) => {
           const transfer = []
           if (paths && paths.buffer) transfer.push(paths.buffer)
           if (widths && widths.buffer) transfer.push(widths.buffer)
-          self.postMessage({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
+          reply({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
         })
         let r
         const started = performance.now()
         try { r = Kernel.slice_sla(new Uint8Array(d.stl), params, onProgress) }
         finally { Kernel.clear_layer_sink() }
-        if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
-        self.postMessage({ type: 'done', result: withSliceThroughput(r, performance.now() - started) })
+        if (r && r.error) { reply({ type: 'error', error: String(r.error) }); return }
+        reply({ type: 'done', result: withSliceThroughput(r, performance.now() - started) })
         return
       }
       const { sliceSla } = await import('./sla_core.js')
@@ -208,23 +215,23 @@ self.onmessage = async (e) => {
           const transfer = []
           if (L.paths?.buffer) transfer.push(L.paths.buffer)
           if (L.widths?.buffer) transfer.push(L.widths.buffer)
-          self.postMessage({ type: 'layer', z: L.z, idx: L.idx, gcode: '', paths: L.paths, widths: L.widths }, transfer)
+          reply({ type: 'layer', z: L.z, idx: L.idx, gcode: '', paths: L.paths, widths: L.widths }, transfer)
         },
       })
-      if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
-      self.postMessage({ type: 'done', result: withSliceThroughput(r, performance.now() - startedFallback) })
+      if (r && r.error) { reply({ type: 'error', error: String(r.error) }); return }
+      reply({ type: 'done', result: withSliceThroughput(r, performance.now() - startedFallback) })
       return
     }
     if (!modPromise) modPromise = loadCore()
     const Module = await modPromise
     // Warmup: only load the kernel (+ spawn the mt pthread pool) ahead of time — removes the perceived load on the first slice
-    if (d.cmd === 'warmup') { self.postMessage({ type: 'warm', kernel: kernelKind }); return }
+    if (d.cmd === 'warmup') { reply({ type: 'warm', kernel: kernelKind }); return }
     // Stage 20: manual support painting — selector state persists in this worker Module (slicing uses the same Module).
     // `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)
-      self.postMessage({ type: 'prepared', facets: Module.selector_facet_count(), kept })
+      reply({ type: 'prepared', facets: Module.selector_facet_count(), kept })
       return
     }
     // paint: legacy {enforcer:boolean} stays on the boolean binding (false == BLOCKER); {state:1..16} reaches any
@@ -242,7 +249,7 @@ self.onmessage = async (e) => {
       else if (strokeFrom(d) && Module.selector_paint_stroke)
         Module.selector_paint_stroke(d.facet, d.px, d.py, d.pz, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, paintedState, cursorShapeOf(d))
       else Module.selector_paint_shape(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, paintedState, cursorShapeOf(d))
-      self.postMessage(paintedReply(Module, d, paintedState)); return
+      reply(paintedReply(Module, d, paintedState)); return
     }
     // erase: the brush writes NONE, returning the brushed facets to the default extruder (upstream's shift+drag).
     //  It is its OWN command and NOT `{cmd:'paint', state:0}`, because 0 is the one integer a boolean can become:
@@ -259,7 +266,7 @@ self.onmessage = async (e) => {
       //  the paint brush never touched. `selector_erase` (no shape) stays the fallback for an older kernel.
       else if (Module.selector_erase_shape) Module.selector_erase_shape(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, cursorShapeOf(d))
       else Module.selector_erase(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius)
-      self.postMessage(paintedReply(Module, d, null)); return
+      reply(paintedReply(Module, d, null)); return
     }
     // importPaint: load painting out of a 3mf. `facets` is an Int32Array of facet indices in the CURRENT selector's
     //  numbering and `hex` the newline-joined per-facet split-tree strings the 3mf carried, in the same order.
@@ -269,9 +276,9 @@ self.onmessage = async (e) => {
     //  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
-      const reply = paintedReply(Module, d, null)
-      reply.applied = applied
-      self.postMessage(reply); return
+      const importedReply = paintedReply(Module, d, null)
+      importedReply.applied = applied
+      reply(importedReply); return
     }
     // exportPaint: the reverse of importPaint — every marked facet's split tree as {facets, hex} in the CURRENT
     //  selector's numbering, the same parallel-array pairing importPaint takes (hex is one newline-joined blob).
@@ -280,17 +287,17 @@ self.onmessage = async (e) => {
     //  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
-      self.postMessage({ type: 'paintExport', supported: !!Module.selector_export_paint,
+      reply({ type: 'paintExport', supported: !!Module.selector_export_paint,
                          facets: exported?.facets ?? [], hex: exported?.hex ?? '' })
       return
     }
     // clear wipes every state at once, so each requested count is 0 by construction — no need to ask the kernel back.
     if (d.cmd === 'clear')   {
       Module.selector_clear()
-      const reply = { type: 'painted', enf: 0, blk: 0 }
+      const clearedReply = { type: 'painted', enf: 0, blk: 0 }
       const states = reportedPaintStates(d, null)
-      if (states) reply.counts = Object.fromEntries(states.map(state => [state, 0]))
-      self.postMessage(reply); return
+      if (states) clearedReply.counts = Object.fromEntries(states.map(state => [state, 0]))
+      reply(clearedReply); return
     }
     // overlay: `enf`/`blk` (states 1/2) are always sent because the viewer's overlay rebuild consumes exactly those two;
     //  `overlays` adds the requested states, so an MMU caller can ask for 3..16 without losing the support overlays.
@@ -305,13 +312,13 @@ self.onmessage = 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 reply = { type: 'overlay',
+      const overlayReply = { type: 'overlay',
         enf: wanted ? EMPTY_OVERLAY : Module.selector_overlay(true),
         blk: wanted ? EMPTY_OVERLAY : Module.selector_overlay(false) }
-      if (states) reply.overlays = Object.fromEntries(states.map(state => [state, Module.selector_overlay_state(state)]))
-      const transfer = [reply.enf, reply.blk, ...Object.values(reply.overlays ?? {})]
+      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)
-      self.postMessage(reply, transfer); return
+      reply(overlayReply, transfer); return
     }
 
     // fillPreview: what a fill WOULD select, without applying it. Upstream runs this on every mouse move while a
@@ -319,14 +326,14 @@ self.onmessage = async (e) => {
     //  nothing, so it needs no state at all and there is no NONE for a stray boolean to become. `{clear:true}`
     //  drops the standing selection, which is what leaving the model under the pointer means.
     if (d.cmd === 'fillPreview') {
-      if (!Module.selector_fill_preview) { self.postMessage({ type: 'fillPreview', supported: false, tris: EMPTY_OVERLAY }); return }
-      if (d.clear) { Module.selector_fill_preview_clear(); self.postMessage({ type: 'fillPreview', supported: true, tris: EMPTY_OVERLAY }); return }
+      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)
-      self.postMessage({ type: 'fillPreview', supported: true, tris },
+      reply({ type: 'fillPreview', supported: true, tris },
                        tris?.buffer && tris.byteLength > 0 ? [tris.buffer] : [])
       return
     }
@@ -339,7 +346,7 @@ self.onmessage = async (e) => {
         if (plane) Module.selector_set_clip_plane(plane[0], plane[1], plane[2], plane[3], true)
         else if (d.clipPlane === null) Module.selector_set_clip_plane(0, 0, 1, 0, false)
       }
-      self.postMessage({ type: 'paintMode', ok: true }); return
+      reply({ type: 'paintMode', ok: true }); return
     }
 
     if (d.stall) return   // stage-30 test hook: simulate a hang -> verifies the main-thread watchdog fires (not set in production)
@@ -352,17 +359,17 @@ self.onmessage = async (e) => {
         const v = Module.sup_progress_view && Module.sup_progress_view()
         const c = Module.cancel_flag_view && Module.cancel_flag_view()
         if (v && v.buffer instanceof SharedArrayBuffer)
-          self.postMessage({ type: 'supsab', buf: v.buffer, ptr: v.byteOffset, cancelPtr: c ? c.byteOffset : 0 })
+          reply({ type: 'supsab', buf: v.buffer, ptr: v.byteOffset, cancelPtr: c?.byteOffset ?? 0 })
       } catch {}
     }
     // Default: slice. Register the layer sink -> the kernel calls back per layer (z, idx, gcodeChunk, pathsF32, widthsF32).
     //  Each layer is transferred to main immediately (toolpath buffers moved) -> the worker copy is freed -> heap headroom before the next layer.
-    const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
+    const onProgress = (done, total) => reply({ type: 'progress', done, total })
     Module.set_layer_sink((z, idx, gcode, paths, widths) => {
       const transfer = []
       if (paths && paths.buffer) transfer.push(paths.buffer)     // economy mode yields empty arrays (no .buffer) -> nothing to transfer
       if (widths && widths.buffer) transfer.push(widths.buffer)
-      self.postMessage({ type: 'layer', z, idx, gcode, paths, widths }, transfer)
+      reply({ type: 'layer', z, idx, gcode, paths, widths }, transfer)
     })
     let r
     // Timed around the kernel call INCLUDING the layer sink, which posts each layer to the main thread from inside
@@ -370,14 +377,16 @@ self.onmessage = async (e) => {
     const started = performance.now()
     try { r = Module.slice(new Uint8Array(d.stl), paramsText(d.params), onProgress) }
     finally { Module.clear_layer_sink() }
-    if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
+    if (r && r.error) { reply({ type: 'error', error: String(r.error) }); return }
     // streamed=true -> g-code/layers were already emitted as 'layer' (result holds stats only). batch/MM keep them in result.
     // withSliceWarnings names what the slice got away with (an off-bed model) on the result itself, and
     //  withSliceThroughput how fast it ran — the raw protocol carries both, so createSlicerClient's callers get
     //  them without the client having to re-derive anything.
-    self.postMessage({ type: 'done', result: withSliceThroughput(withSliceWarnings(r), performance.now() - started) })
+    reply({ type: 'done', result: withSliceThroughput(withSliceWarnings(r), performance.now() - started) })
   } catch (err) {
     // Includes the WASM abort("memory access out of bounds") — the main thread's OOM ladder decides on re-creation / economy retry.
-    self.postMessage({ type: 'error', error: String((err && err.message) || err), ...(err?.code ? { code: err.code } : {}) })
+    const errorReply = { type: 'error', error: String((err && err.message) || err) }
+    if (err?.code) errorReply.code = err.code
+    reply(errorReply)
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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.1"
+    "three-slicer-viewer": "0.3.2"
   }
 }