three-slicer 0.3.1 → 0.3.3

package/engine/src/settings.js

@@ -32,6 +32,19 @@ export function resinSettingsFor(name) {
   return out
 }
 
+// One row of a preset table -> the settings it applies. Multi-line text (custom G-code, notes) is stored once in
+//  `text` and a row holds its index, for the columns listed in `textKeys` (web/extract_all.py _intern_text).
+function rowSettings(data, row) {
+  const textKeys = new Set(data.textKeys ?? [])
+  const out = {}
+  data.keys.forEach((key, i) => {
+    if (row[i] == null) return
+    if (textKeys.has(key)) { out[key] = data.text[row[i]]; return }
+    out[key] = row[i]
+  })
+  return out
+}
+
 // Process (print) presets live in the ~800 KB processes.json, so they load on demand — the first call fetches,
 //  later ones reuse the same promise. Returns a small facade so no caller has to know the column layout.
 let processesPromise = null
@@ -46,9 +59,7 @@ export function processPresets() {
     settingsFor: (presetName) => {
       const preset = data.presets.find(([name]) => name === presetName)
       if (!preset) return null
-      const row = data.sets[preset[1]], out = {}
-      data.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-      return out
+      return rowSettings(data, data.sets[preset[1]])
     },
   }))
   return processesPromise
@@ -84,9 +95,7 @@ export function filamentPresets() {
       settingsFor: (presetName) => {
         const preset = data.presets.find(([name]) => name === presetName)
         if (!preset) return null
-        const row = data.sets[preset[1]], out = {}
-        data.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-        return out
+        return rowSettings(data, data.sets[preset[1]])
       },
     }
   })
@@ -105,19 +114,20 @@ function printerEntry(profileName) {
 export function printerSettings(profileName) {
   const entry = printerEntry(profileName)
   if (!entry) return null
-  const row = printers.sets[entry[1]]
-  const out = {}
-  printers.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-  return out
+  return rowSettings(printers, printers.sets[entry[1]])
 }
 
 /** The vendor's recommended process preset for a printer, or '' when the profile names none. */
 export function printerDefaultPreset(profileName) { return printerEntry(profileName)?.[3] ?? '' }
 
+/** The bed type the printer's model defaults to ("Textured PEI Plate"), or '' when the model names none. Upstream
+ *  writes it to curr_bed_type when the printer is picked; the first-layer bed temperature follows it. */
+export function printerDefaultBedType(profileName) { return printerEntry(profileName)?.[4] ?? '' }
+
 // ---- The catalog as one object -------------------------------------------------------------------------------
-// What `three-slicer-viewer`'s `<Viewport catalog>` takes: the nine lookups above, bundled. The permissive package
+// What `three-slicer-viewer`'s `<Viewport catalog>` takes: the ten lookups above, bundled. The permissive package
 //  ships no catalog (these are OrcaSlicer's profile bundles); `three-slicer/viewer` passes this one by default.
 export const bundledCatalog = Object.freeze({
-  printerKeys, printerSettings, printersByVendor, printerTechByVendor, printerDefaultPreset,
+  printerKeys, printerSettings, printersByVendor, printerTechByVendor, printerDefaultPreset, printerDefaultBedType,
   processPresets, filamentPresets, resinCatalog, resinSettingsFor,
 })

package/engine/src/slicer.worker.js

@@ -1,6 +1,7 @@
 // Runs slicing off the main thread (non-blocking UI) plus stage-30 layer streaming.
 // Vite module worker: new Worker(new URL('./slicer.worker.js', import.meta.url), { type: 'module' }).
-// SINGLE_FILE means the wasm is inlined into slicer_core.js -> no external fetch from the worker either.
+// SINGLE_FILE means the wasm is inlined into slicer_core.js -> no external fetch from the worker either. The mt glue
+//  loads slicer_core.mt.wasm from beside itself instead: its pthread workers each parse the glue (build.sh, mt link).
 //
 // 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
@@ -18,6 +19,9 @@
 import { assertLegacySlaFallback, parseSlaJob } from './sla_request.js'
 import { withSliceWarnings } from './warnings.js'
 import { withSliceThroughput } from './throughput.js'
+import { acquireContourDevice, makeContourGpu } from './contour_gpu.js'
+import { kernelHasContourPhase, sliceWithContourGpu } from './contour_slice.js'
+import { FILL_TOOLS } from 'three-slicer-viewer/paint'
 
 // The kernel parses `params` as JSON text, so the raw protocol used to require a string — while the direct handle
 //  and createSlicerClient both take an object and stringify it for you. One object, two shapes, and the difference
@@ -49,6 +53,42 @@ const loadCore = async () => {
 
 let modPromise = null
 
+// The contour union on the GPU (contour_gpu.js), made on the first slice that asks for it. `false` once this worker
+//  found no usable device, so the next slice does not ask again; a lost device is asked for again.
+let contourGpu = null
+const contourGpuOf = async () => {
+  if (contourGpu !== null) return contourGpu
+  try {
+    const device = await acquireContourDevice(self.navigator?.gpu)
+    if (!device) { contourGpu = false; return contourGpu }
+    contourGpu = await makeContourGpu(device)
+    device.lost.then(() => { contourGpu = null })
+  } catch (error) {
+    say('warn', '[slicer.worker] contour GPU unavailable:', error)
+    contourGpu = false
+  }
+  return contourGpu
+}
+// A slice's kernel call, through the GPU when the host asked for it (`gpu: true`) and this worker can.
+const runSlice = async (Module, d, onProgress) => {
+  const stl = new Uint8Array(d.stl), text = paramsText(d.params)
+  if (!d.gpu) return Module.slice(stl, text, onProgress)
+  const cpu = (reason) => {
+    const result = Module.slice(stl, text, onProgress)
+    if (result?.stats) { result.stats.contour_engine = 'cpu'; result.stats.contour_engine_reason = reason }
+    return result
+  }
+  if (!kernelHasContourPhase(Module)) return cpu('this kernel build has no contour phase')
+  const gpu = await contourGpuOf()
+  if (!gpu) return cpu('no WebGPU device')
+  const canceled = () => { const flag = Module.cancel_flag_view?.(); return !!flag && flag[0] !== 0 }
+  // The mesh route (the GPU cuts and chains the layers too) only on the single-threaded kernel. Measured on a 3M-facet
+  //  model (node, Dawn): st's own cut and chain is 419-442 ms against 34-154 ms of mesh hand-over + 64-153 ms on the GPU;
+  //  mt's is 64-77 ms on its threads, and the mesh route came out 20 ms slower in the front and 0.02-0.18 s in the slice.
+  const meshRoute = kernelKind === 'st'
+  return sliceWithContourGpu({ kernel: Module, contourGpu: gpu, stl, paramsText: text, onProgress, canceled, meshRoute })
+}
+
 // Stage 20 painting states = upstream's EnforcerBlockerType (see packages/wasm-core/selector_bridge.h):
 //  0=NONE, 1=ENFORCER(==Extruder1), 2=BLOCKER(==Extruder2), 3..16=Extruder3..Extruder16.
 // The kernel exposes both a boolean pair (selector_paint/…_count/…_overlay) and integer-state twins (…_state);
@@ -110,7 +150,6 @@ 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 }
 
-const FILL_TOOLS = new Set(['smart', 'bucket', 'triangle'])
 const applyFill = (Module, message, state) => {
   const angle = Number.isFinite(message.angle) ? message.angle : 30
   if (message.tool === 'smart') {
@@ -132,14 +171,28 @@ 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) => {
+// One message at a time. A GPU slice awaits the device between its two kernel calls, and a message handled in that
+//  gap would reach a kernel that is holding another slice's loops.
+let messageChain = Promise.resolve()
+self.onmessage = (e) => {
+  messageChain = messageChain.then(() => handleMessage(e)).catch((error) => say('warn', '[slicer.worker] message failed:', error))
+  return messageChain   // a caller that drives the handler directly (tests) can await its message
+}
+const handleMessage = 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 +201,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 +233,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 +261,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 +295,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 +312,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 +322,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 +333,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 +358,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 +372,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 +392,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,32 +405,34 @@ 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
     //  it — that transfer is part of what a streamed slice costs and leaving it out would flatter the number.
     const started = performance.now()
-    try { r = Module.slice(new Uint8Array(d.stl), paramsText(d.params), onProgress) }
+    try { r = await runSlice(Module, d, 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.3",
   "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.3"
   }
 }

package/types/data/filaments.js.d.ts

@@ -11,10 +11,15 @@ export type FilamentRow = (unknown | null)[]
 export type FilamentEntry = [string, number, string, string]
 
 export interface FilamentData {
-  /** Option keys, in column order — the kernel keys that at least one filament profile sets */
+  /** Option keys, in column order — the kernel keys and custom-G-code keys that at least one filament profile sets */
   keys: string[]
   /** Deduplicated value rows */
   sets: FilamentRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** Preset entries, indexed by the numbers in `byPrinter` / `defaultsByModel` */
   presets: FilamentEntry[]
   /** Printer profile name (as keyed in printers.json) -> indices into `presets` — the compatible materials */

package/types/data/printers.json.d.ts

@@ -7,14 +7,21 @@
 /** A positional row aligned to `keys`; `null` where the profile chain never set that option. */
 export type PrinterRow = (unknown | null)[]
 
-/** `[nozzle diameter, index into sets, model name without the nozzle suffix, default process preset]` */
-export type PrinterEntry = [string, number, string, string]
+/** `[nozzle diameter, index into sets, model name without the nozzle suffix, default process preset,
+ *  the model's default bed type ('' when none)]` — SLA entries carry the first four */
+export type PrinterEntry = [string, number, string, string, string?]
 
 export interface PrinterData {
-  /** Option keys, in column order — the same keys the settings panel edits */
+  /** Option keys, in column order — the same keys the settings panel edits, including the custom G-code and the
+   *  options it reads (issue 63) */
   keys: string[]
   /** Deduplicated value rows */
   sets: PrinterRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** Vendor -> printer profile name -> entry */
   byVendor: Record<string, Record<string, PrinterEntry>>
 }

package/types/data/processes.js.d.ts

@@ -7,10 +7,15 @@
 export type ProcessRow = (unknown | null)[]
 
 export interface ProcessData {
-  /** Option keys, in column order — the keys the kernel consumes, read out of engine/src/settings.js */
+  /** Option keys, in column order — the keys the kernel consumes plus the ones its custom G-code reads (extract_all.py _preset_keys) */
   keys: string[]
   /** Deduplicated value rows */
   sets: ProcessRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** `[preset name, index into sets]`, indexed by the numbers in `byPrinter` */
   presets: [string, number][]
   /** Printer profile name -> indices into `presets` */

package/types/settings.d.ts

@@ -168,6 +168,8 @@ export function printerSettings(profileName: string): SlicerSettings | null
 
 /** The vendor's recommended process preset for that printer, or `''` when the profile names none. */
 export function printerDefaultPreset(profileName: string): string
+/** The bed type the printer's model defaults to, `''` when the model names none — written to `curr_bed_type` on a pick. */
+export function printerDefaultBedType(profileName: string): string
 
 /** The schema keys the kernel's machine limits are read from — for UI that shows which ones are in play. */
 export const machineLimitKeys: string[]

package/types/worker.d.ts

@@ -94,8 +94,11 @@ export type SlicerRequest =
    * stringified for you (it was string-only through 0.2.2, which made this the one call path with a different
    * contract from `createSlicer().slice()` and `createSlicerClient().slice()`).
    * Replies: `progress` and `layer` while it runs, then `done` — or `error`.
+   * `gpu: true` asks the worker to compute the layer contours with WebGPU (src/contour_gpu.js). The worker uses it
+   * when it has a device and the slice reaches the contour union; `done`'s `stats.contour_engine` says what ran
+   * ('gpu', 'cpu' with `contour_engine_reason`, or 'reused' for layers from the stage cache).
    */
-  | { stl: ArrayBuffer; params: string | object }
+  | { stl: ArrayBuffer; params: string | object; gpu?: boolean }
 
 export type SlicerResponse =
   /** `kernel` says which variant loaded: 'mt' under crossOriginIsolated, 'st' otherwise (or after an mt load failure). */