three-slicer 0.1.3 → 0.1.5

package/data/ui-tree.json

@@ -670,14 +670,33 @@
      "group": "Retraction",
      "line": 4000,
      "options": [
-      "<custom-widget line:4033>"
+      "filament_retraction_length",
+      "filament_z_hop",
+      "filament_z_hop_types",
+      "filament_retract_lift_above",
+      "filament_retract_lift_below",
+      "filament_retract_lift_enforce",
+      "filament_retraction_speed",
+      "filament_deretraction_speed",
+      "filament_retract_restart_extra",
+      "filament_retraction_minimum_travel",
+      "filament_retract_when_changing_layer",
+      "filament_wipe",
+      "filament_wipe_distance",
+      "filament_retract_before_wipe",
+      "filament_retract_after_wipe",
+      "filament_long_retractions_when_cut",
+      "filament_retraction_distances_when_cut"
      ]
     },
     {
      "group": "Ironing",
      "line": 4061,
      "options": [
-      "<custom-widget line:4138>"
+      "filament_ironing_flow",
+      "filament_ironing_spacing",
+      "filament_ironing_inset",
+      "filament_ironing_speed"
      ]
     }
    ]

package/engine/README.md

@@ -17,7 +17,7 @@ npm i three-slicer
 ```js
 import { createSlicer } from 'three-slicer'
 
-const slicer = await createSlicer()               // loads the WASM kernel (~3.4 MB, base64-inlined)
+const slicer = await createSlicer()               // loads the WASM kernel (~3.3 MB, base64-inlined)
 
 // Batch: full result at once
 const r = slicer.slice(stlArrayBuffer, { layer_height: 0.2, wall_loops: 2 })
@@ -37,15 +37,67 @@ Off-main-thread (browser): `new Worker(engineWorkerURL(), { type: 'module' })`
 
 Two levels — use whichever fits:
 
-1. **Kernel params (this package's native contract)** — a flat JSON object of ~50 keys (`layer_height`, `wall_loops`, `infill_density` 0–1, `sparse_infill_pattern`, `enable_support`, `wall_generator: 'classic' | 'arachne'`, …). See `src/settings.js` for the full shape.
-2. **OrcaSlicer settings map** — a sparse `{schemaKey: value}` map using original OrcaSlicer option keys (907 defined in `@three-slicer/data`); unset keys fall back to schema defaults:
+1. **Kernel params (this package's native contract)** — a flat JSON object of ~90 keys (`layer_height`, `wall_loops`, `infill_density` 0–1, `sparse_infill_pattern`, `enable_support`, `wall_generator: 'classic' | 'arachne'`, …). See `src/settings.js` for the full shape.
+2. **OrcaSlicer settings map** — a sparse `{schemaKey: value}` map using original OrcaSlicer option keys (923 defined in `@three-slicer/data`); unset keys fall back to schema defaults:
 
 ```js
 import { deriveKernelParams } from 'three-slicer/settings'
 slicer.slice(stl, deriveKernelParams({ layer_height: 0.25, sparse_infill_density: 15 }))
 ```
 
-**Known limit:** `deriveKernelParams` maps a curated whitelist of ~50 schema keys to kernel params. Editing other schema keys has no slicing effect (they exist for UI/metadata). Vector options use their first element only.
+**Known limit:** `deriveKernelParams` maps a curated whitelist of 92 schema keys to kernel params. Editing other schema keys has no slicing effect (they exist for UI/metadata). Scalar options use their first element only; the filament options listed under *Materials* below are the exception — those keep every extruder's entry.
+
+## Materials and multi-material
+
+A material is a **filament preset**: a set of schema values (temperatures, flow, diameter, cooling, retraction/z-hop overrides) that a printer profile declares itself compatible with. Read the catalog through the facade, never by decoding `three-slicer/data/filaments.js` by hand:
+
+```js
+import { filamentPresets, deriveKernelParams } from 'three-slicer/settings'
+
+const filaments = await filamentPresets()               // lazy — the artifact loads on first call
+filaments.listFor('Bambu Lab X1 Carbon 0.4 nozzle')     // [{name, type, vendor}, …]
+filaments.recommendedFor('Bambu Lab X1 Carbon 0.4 nozzle')  // the vendor's shortlist, filtered to the compatible set
+Object.assign(settings, filaments.settingsFor('Bambu PLA Basic @BBL X1C'))
+```
+
+**One material per extruder.** Upstream stores every filament option as one entry per extruder, so a multi-material settings map writes each extruder's material at its own index:
+
+```js
+const params = {
+  ...deriveKernelParams({
+    nozzle_temperature: [255, 220],      // T0 ABS, T1 PLA
+    filament_flow_ratio: [0.95, 1.0],
+  }),
+  // -> { extruder_nozzle_temp: [255, 220], extruder_flow_ratio: [0.95, 1.0], … }
+  extruder_count: 2,                     // not a derived key — set it on the params directly
+}
+```
+
+The kernel reads those arrays **positionally** and reloads the whole loaded-filament set — diameter, flow, retraction length/speed, z-hop, plus an `M109` when the temperatures actually disagree — at every `T` change. A single-element (or absent) option produces **no** `extruder_*` array at all, and the kernel then reads its scalars exactly as before, so a single-material slice is byte-identical to what it was before this feature existed.
+
+`support_filament` / `support_interface_filament` are 1-based filament indices (`0` = "Default", keep the loaded tool) selecting which extruder prints the support base/raft and the support interface. `0` is omitted from the params rather than sent, so it emits no `T` command anywhere and leaves the support G-code byte-identical.
+
+### Painting a region onto another extruder
+
+Painting is the only way a **single** object can print in two materials — there is no triangle boundary to split on, only painted facets. The painted facets of each state are projected per layer and the sliced polygon is partitioned against them; where two extruders claim the same area the higher-numbered one wins (a total order on a small integer, so the result never depends on paint or clipper ordering).
+
+Painting states are upstream's `EnforcerBlockerType`, one enum serving two jobs: `1` = ENFORCER = **Extruder1**, `2` = BLOCKER = **Extruder2**, `3..16` = Extruder3..16. The state-addressed protocol lives on the worker (`three-slicer/worker`); the direct handle's `slice.paint({enforcer})` is the original boolean pair only.
+
+```js
+worker.postMessage({ cmd: 'prepare', stl })                          // -> {type:'prepared', facets}
+worker.postMessage({ cmd: 'paint', state: 3, facet, hx, hy, hz, cx, cy, cz, radius, states: [1,2,3] })
+//   -> {type:'painted', enf, blk, counts: {1: n, 2: n, 3: n}}
+worker.postMessage({ cmd: 'erase', facet, hx, hy, hz, cx, cy, cz, radius })   // back to the default extruder
+```
+
+`erase` is its **own command**, not `{cmd:'paint', state: 0}`: embind coerces a JS `false` to the int `0` == NONE, and the legacy blocker brush sends exactly that `false` — so the state path rejects `0` outright and only `erase`, which takes no state argument, can clear anything. A message without `state`/`states` gets the original reply verbatim, so existing listeners are unaffected.
+
+Two consequences worth knowing before you build on this:
+
+- Because one selector serves both jobs, **a support BLOCKER paint and an Extruder2 paint are the same mark**, and a facet can hold only one of them. The two brushes are therefore mutually exclusive, which is a data constraint, not a UI simplification.
+- The painted multi-material path is taken only when support is **off** — it emits no support at all. **Paint and support cannot currently produce two materials together.**
+
+Results carry the split: `stats.filament_mm_by_tool` (indexed by tool number, one slot per extruder, sums to `filament_mm`) and `stats.filament_mm_purge` (the prime/wipe tower share, already included in the per-tool figures). In the streamed toolpath, `paths[k+3]` encodes `role + tool * 16` — mask with `& 15` for the role and `>>> 4` for the tool.
 
 ## License
 

package/engine/src/data.js

@@ -16,3 +16,5 @@ export { default as printers } from 'three-slicer/data/printers.json' with { typ
 // other direction: a dynamic JSON import needs the attribute in Node, and that same attribute makes browsers
 // reject the text/javascript response a dev server gives for .json.
 export const loadProcesses = () => import('three-slicer/data/processes.js').then(m => m.default)
+// Same story for the filament presets (~540 KB, only needed once a material picker opens).
+export const loadFilaments = () => import('three-slicer/data/filaments.js').then(m => m.default)

package/engine/src/settings.js

@@ -1,12 +1,21 @@
 // Maps the actual values of the (editable) right-hand settings panel -> kernel slice parameters.
 //  - Settings state is a sparse map (key->value): only edited keys are stored, otherwise the config-schema default.
 //  - For vector types (coFloats/coInts, …) only the first element is used/edited (simplification).
-import { schema, printers, loadProcesses } from './data.js'
+import { schema, printers, loadProcesses, loadFilaments } from './data.js'
 
 export function schemaDefault(key) { return schema[key]?.default }
 export function settingRaw(settings, key) { return (settings && key in settings) ? settings[key] : schemaDefault(key) }
 // Normalize to a scalar ([0] for vectors)
-export function settingScalar(settings, key) { const v = settingRaw(settings, key); return Array.isArray(v) ? v[0] : v }
+// A per-extruder column reduced to the single value the kernel's scalar reader wants. The FIRST SET entry, not
+//  literally index 0: the filament card writes one column per extruder and leaves a null wherever that extruder has
+//  no preset, so an assignment that starts at T2 puts a null at index 0. Taking that null made filament_diameter 0,
+//  which divides into the extrusion maths and turned the whole slice into NaN — measured as
+//  "; filament used [mm] = nan, nan" from a print whose T1 had no material picked.
+export function settingScalar(settings, key) {
+  const v = settingRaw(settings, key)
+  if (!Array.isArray(v)) return v
+  return v.find(entry => entry != null && entry !== '') ?? v[0]
+}
 
 // Stage 8: real ported Fill patterns (gyroid TPMS/honeycomb/3dhoneycomb/crosshatch/concentric) + the older approximations
 const KERNEL_PATTERNS = ['rectilinear', 'grid', 'triangles', 'zigzag', 'gyroid', 'gyroid_approx',
@@ -67,6 +76,45 @@ export function processPresets() {
   return processesPromise
 }
 
+// Filament (material) presets — same lazy facade as the process presets above, over the ~540 KB filaments.js.
+//  Entries come out as objects rather than bare names because a material picker groups by type, and the type
+//  label only exists in this file. Both lists are in upstream order: byPrinter is the compatible set,
+//  defaultsByModel the vendor's recommendation (a subset, so the two overlap by design).
+let filamentsPromise = null
+export function filamentPresets() {
+  filamentsPromise ??= loadFilaments().then(data => {
+    // type/vendor are empty strings when the profile chain declares neither — the picker buckets those itself
+    const view = i => { const [name, , type, vendor] = data.presets[i]; return { name, type, vendor } }
+    return {
+      /** Every key a filament preset can set — clear these before applying a different material */
+      keys: data.keys,
+      /** Every material in the catalog — for a picker shown before any printer is chosen */
+      all: () => data.presets.map((_, i) => view(i)),
+      /** Materials compatible with a printer profile, as `{name, type, vendor}` */
+      listFor: (printerProfileName) => (data.byPrinter[printerProfileName] ?? []).map(view),
+      /** The vendor's recommended materials for that printer's model, same shape as listFor.
+       *  Filtered to the compatible set, which is not redundant: the recommendation is declared on the machine
+       *  *model* and so is nozzle-agnostic, while its entries name nozzle-specific presets ("… @Kobra 3 0.4 nozzle").
+       *  On a 0.2 nozzle profile 41% of the raw entries (1749 of 4259 across all printers) name a material whose
+       *  own compatible list excludes it — offering those would apply a preset upstream considers incompatible. */
+      recommendedFor: (printerProfileName) => {
+        const compatible = new Set(data.byPrinter[printerProfileName] ?? [])
+        return (data.defaultsByModel[printerEntry(printerProfileName)?.[2] ?? ''] ?? [])
+          .filter(i => compatible.has(i)).map(view)
+      },
+      /** The settings a material applies, ready to merge. `null` when unknown. */
+      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 filamentsPromise
+}
+
 function printerEntry(profileName) {
   for (const models of Object.values(printers.byVendor)) {
     const entry = models[profileName]
@@ -88,12 +136,102 @@ export function printerSettings(profileName) {
 /** The vendor's recommended process preset for a printer, or '' when the profile names none. */
 export function printerDefaultPreset(profileName) { return printerEntry(profileName)?.[3] ?? '' }
 
+// ---- Imported project settings (a slicer-written 3mf's Metadata/project_settings.config) --------------------
+// Upstream serializes every option as a STRING (or an array of them, one per extruder) — a bool is "0"/"1" and a
+//  float is "0.2". This settings map holds real JS types, and the difference is not cosmetic: `bool()` below reads
+//  a value with `!!v`, and `!!"0"` is TRUE — importing raw would turn every disabled option on. So each value is
+//  coerced by its schema type, and anything the schema does not know (inherits_group, *_settings_id, version, the
+//  whole preset-bookkeeping half of that file) is dropped rather than carried into a map keyed by schema keys.
+// The `inherits` / `different_settings_to_system` machinery upstream applies on top of this (Preset.cpp:2577) is
+//  deliberately NOT reproduced: it exists to reconcile a stored preset against a LOCAL vendor preset database of a
+//  possibly different version. project_settings.config is already flattened, so taking its values as written is
+//  both simpler and closer to what the project author actually sliced.
+const FALSE_STRINGS = new Set(['0', 'false', 'no', 'off', ''])
+
+function coerceScalar(type, value) {
+  if (typeof value !== 'string') return value
+  switch (type) {
+    case 'coBool': case 'coBools':
+      return !FALSE_STRINGS.has(value.trim().toLowerCase())
+    case 'coFloat': case 'coFloats': case 'coInt': case 'coInts':
+      return asNumber(value)
+    case 'coPercent': case 'coPercents':
+      // A percent option's value is the bare number (the schema default of sparse_infill_density is 20, not "20%")
+      //  and upstream serializes it that way — but the '%' does show up in hand-edited configs, so strip it.
+      return asNumber(value.trim().replace(/%$/, ''))
+    case 'coFloatOrPercent': case 'coFloatsOrPercents':
+      // "50%" must stay a string — the percent IS the value, and Number('50%') is NaN anyway.
+      return value.trim().endsWith('%') ? value : asNumber(value)
+    case 'coPoint': case 'coPoints':
+      return parsePoint(value) ?? value
+    case 'coPointsGroups':
+      return parsePointGroup(value) ?? value
+    default:
+      return value   // strings and enums — the kernel and the panel both read these as written
+  }
+}
+
+// Points are the other shape trap, and a quiet one: upstream writes a point as the STRING "XxY", while every
+//  consumer here indexes it as a [x, y] pair — so `printable_area[1][0]` on a raw import is the CHARACTER '2' of
+//  "256x0", and the bed comes out 2mm wide (measured on a real MakerWorld project: 2 x NaN).
+// Two separators exist in the wild: ConfigOptionPoint::serialize writes 'x', while some Orca options
+//  (best_object_pos) write "X,Y". A points GROUP is one string holding a comma-separated LIST of "XxY" points,
+//  so there the comma cannot also separate a point's own coordinates — hence two parsers rather than one regex.
+function parsePoint(text) {
+  const split = String(text).split('x')
+  const pair = split.length === 2 ? split : String(text).split(',')
+  if (pair.length !== 2) return null
+  const x = Number(pair[0]), y = Number(pair[1])
+  return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null
+}
+function parsePointGroup(text) {
+  const points = String(text).split(',').map(entry => {
+    const [a, b] = entry.split('x')
+    const x = Number(a), y = Number(b)
+    return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null
+  })
+  return points.length && points.every(Boolean) ? points : null
+}
+// Number('') is 0 and Number('  ') is 0, neither of which means "the option was set to zero" — an unparsable
+//  value is handed back untouched so the schema default keeps applying instead of a fabricated 0.
+function asNumber(value) {
+  if (value.trim() === '') return value
+  const n = Number(value)
+  return Number.isFinite(n) ? n : value
+}
+
+/**
+ * A 3mf project's raw `project_settings.config` object -> a settings map this package's own API accepts.
+ * Keys the config schema does not define are dropped. Returns `{settings, applied, skipped}`.
+ */
+export function normalizeProjectSettings(raw) {
+  const settings = {}
+  let applied = 0
+  const skipped = []
+  for (const [key, value] of Object.entries(raw || {})) {
+    const type = schema[key]?.type
+    if (!type) { skipped.push(key); continue }
+    settings[key] = Array.isArray(value) ? value.map(entry => coerceScalar(type, entry)) : coerceScalar(type, value)
+    applied++
+  }
+  return { settings, applied, skipped }
+}
+
 
 // Right-panel settings values -> kernel parameters (derived from schema keys)
 export function deriveKernelParams(settings) {
   const S = k => settingScalar(settings, k)
   const num = (k, d) => { const v = Number(S(k)); return Number.isFinite(v) ? v : d }
   const bool = (k, d) => { const v = settingRaw(settings, k); return typeof v === 'boolean' ? v : (Array.isArray(v) ? !!v[0] : (v == null ? d : !!v)) }
+  // Filament retraction overrides: upstream lets a material override the machine's retraction (TPU wants a
+  //  different pull-back than PLA on the same printer). These schema keys are nullable and carry no default of
+  //  their own — "unset" means keep the machine value — so this reads the settings map directly rather than
+  //  through settingScalar, whose schema fallback would not distinguish the two.
+  const override = (filamentKey, machineKey, fallback) => {
+    const raw = settings?.[filamentKey]
+    const value = Number(Array.isArray(raw) ? raw[0] : raw)
+    return Number.isFinite(value) ? value : num(machineKey, fallback)
+  }
 
   let line_width = num('line_width', 0); if (!line_width) line_width = 0.42   // 0=auto -> default 0.42
 
@@ -128,6 +266,69 @@ export function deriveKernelParams(settings) {
   const machine = {}
   for (const [param, [key, fallback]] of Object.entries(MACHINE_LIMITS)) machine[param] = num(key, fallback)
 
+  // Support filament mapping: which extruder prints the support base/raft, and which prints the support interface.
+  //  Upstream's "Default" is the value 0 = keep whatever tool is current, and an absent key means the same thing to
+  //  the kernel (its JSON reader falls back to its own 0 default). Unmapped supports are therefore omitted rather
+  //  than sent as 0, so a settings map that maps neither produces byte-for-byte the parameters it produced before
+  //  these keys existed — same reason the per-feature widths above are omitted when unedited.
+  const supportTools = {}
+  for (const key of ['support_filament', 'support_interface_filament']) {
+    const extruderIndex = num(key, 0)
+    if (extruderIndex > 0) supportTools[key] = extruderIndex
+  }
+
+  // Multi-material: upstream stores every filament option as one entry per extruder (coFloats), and the material
+  //  picker writes each extruder's material at its own index. Only a second entry makes these arrays appear, so a
+  //  single-material slice sends exactly the keys it always did — the kernel then reads its scalars as before.
+  //  A hole (a material that overrides nothing) is filled with the value tool 0 resolved to, because the kernel
+  //  reads the array positionally and cannot tell "absent" from "0".
+  // Prime tower keys, omitted when unset so the kernel/viewer defaults stay in charge (same rule as supportTools).
+  //  wipe_tower_x/y are coFloats upstream — one entry per plate — so the scalar reduction takes the first set one.
+  const towerSettings = {}
+  {
+    const width = num('prime_tower_width', 0)
+    if (width > 0) towerSettings.prime_tower_width = width
+    // Read the map itself, NOT settingRaw: wipe_tower_x/y carry an upstream schema default of (15, 220), which is
+    //  a coordinate off the front of a 200mm bed. Taking it as "the user chose a position" put the tower outside
+    //  the plate and disabled the automatic placement entirely — measured as a tower at z=-127.5 on a 200mm bed.
+    //  Absent from the map means nobody chose one, and the placement beside the model stands.
+    const chosen = (key) => { const v = settings?.[key]; const n = Number(Array.isArray(v) ? v[0] : v)
+      return (v != null && v !== '' && Number.isFinite(n)) ? n : null }
+    const towerX = chosen('wipe_tower_x'), towerY = chosen('wipe_tower_y')
+    if (towerX != null) towerSettings.prime_tower_x = towerX
+    if (towerY != null) towerSettings.prime_tower_y = towerY
+    // The purging volumes table (flat N×N, mm³) and its scalars. Sent verbatim — the kernel indexes it [from*N+to].
+    const matrix = settingRaw(settings, 'flush_volumes_matrix')
+    if (Array.isArray(matrix) && matrix.length >= 4) towerSettings.flush_volumes_matrix = matrix.map(Number)
+    // Upstream defaults enable_prime_tower to false and relies on flushing into the model; the kernel defaults it
+    //  to true because that was the only destination it had. Both are sent only when the map carries them, so an
+    //  untouched project keeps whatever the kernel decides.
+    if ('enable_prime_tower' in (settings ?? {})) towerSettings.enable_prime_tower = !!settings.enable_prime_tower
+    if ('flush_into_infill' in (settings ?? {})) towerSettings.flush_into_infill = !!settings.flush_into_infill
+    const multiplier = num('flush_multiplier', 0)
+    if (multiplier > 0) towerSettings.flush_multiplier = multiplier
+    const prime = num('prime_volume', 0)
+    if (prime > 0) towerSettings.prime_volume = prime
+  }
+
+  const perExtruder = {}
+  for (const [param, key, scalar] of [
+    ['extruder_nozzle_temp', 'nozzle_temperature', num('nozzle_temperature', 200)],
+    ['extruder_filament_diameter', 'filament_diameter', num('filament_diameter', 1.75)],
+    ['extruder_flow_ratio', 'filament_flow_ratio', num('filament_flow_ratio', 1.0)],
+    ['extruder_retract_length', 'filament_retraction_length', override('filament_retraction_length', 'retraction_length', 0.8)],
+    ['extruder_retract_speed', 'filament_retraction_speed', override('filament_retraction_speed', 'retraction_speed', 30)],
+    ['extruder_z_hop', 'filament_z_hop', override('filament_z_hop', 'z_hop', 0.4)],
+  ]) {
+    const raw = settings?.[key]
+    if (!Array.isArray(raw) || raw.length < 2) continue
+    perExtruder[param] = raw.map(v => {
+      if (v == null || v === '') return scalar        // null survives a JSON round-trip; Number(null) would be 0
+      const n = Number(Array.isArray(v) ? v[0] : v)
+      return Number.isFinite(n) ? n : scalar
+    })
+  }
+
   return {
     ...widths,
     ...machine,
@@ -146,11 +347,17 @@ export function deriveKernelParams(settings) {
     skirt_height: num('skirt_height', 1),                       // stage 33: the kernel used to hardcode the first layer
     brim_width: num('brim_width', 0),
     brim_object_gap: num('brim_object_gap', 0),                 // stage 33: the kernel used to hardcode w*0.5
-    retract_length: num('retraction_length', 0.8),              // vector[0]
-    retraction_minimum_travel: num('retraction_minimum_travel', 2),  // stage 33: used to be the kernel constant 2.0
+    ...perExtruder,
+    // Prime tower. These were the one part of multi-material the settings map could not reach: the kernel read its
+    //  own prime_tower_* parameters and nothing mapped the upstream keys onto them, so the tower's size and place
+    //  were whatever the viewer decided. Only sent when the user actually set them — an unset width keeps the
+    //  kernel's own default, and an unset position lets the viewer's auto-placement stand.
+    ...towerSettings,
+    retract_length: override('filament_retraction_length', 'retraction_length', 0.8),   // vector[0]
+    retraction_minimum_travel: override('filament_retraction_minimum_travel', 'retraction_minimum_travel', 2),  // stage 33: used to be the kernel constant 2.0
     gcode_resolution: num('resolution', 0.01),                  // stage 33: tree-support path simplification tolerance
-    retract_speed: num('retraction_speed', 30),
-    z_hop: num('z_hop', 0.4),
+    retract_speed: override('filament_retraction_speed', 'retraction_speed', 30),
+    z_hop: override('filament_z_hop', 'z_hop', 0.4),
     travel_speed: num('travel_speed', 120),
     first_layer_speed: num('initial_layer_speed', 30),
     print_speed: num('outer_wall_speed', 60),
@@ -185,6 +392,7 @@ export function deriveKernelParams(settings) {
       const n = Number(v); return Number.isFinite(n) ? n : 0.5 })(),   // "50%" -> 0.5 (ratio of extrusion width)
     support_on_build_plate_only: bool('support_on_build_plate_only', false),
     support_interface_bottom_layers: num('support_interface_bottom_layers', 0),
+    ...supportTools,                                            // present only when a support extruder is mapped (see above)
     raft_layers: num('raft_layers', 0),
     raft_expansion: num('raft_expansion', 1.5),                 // stage 33: the kernel used to hardcode +3.0
     raft_contact_distance: num('raft_contact_distance', 0.1),   // stage 33: previously ignored by the kernel

package/engine/src/slicer.worker.js

@@ -27,6 +27,85 @@ const loadCore = async () => {
 
 let modPromise = null
 
+// 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);
+//  the boolean wrappers are NOT redundant, they are what maps false -> BLOCKER(2) on the C++ side.
+const PAINT_STATE_ENFORCER = 1
+const PAINT_STATE_BLOCKER = 2
+const PAINT_STATE_MAX = 16
+
+// A state is only a state when it is literally an integer in [1,16]. This predicate is the hazard guard: embind
+//  coerces a JS `false` to the int 0 == NONE, so a boolean that leaked into the state path would paint nothing and
+//  silently turn blocker painting into a no-op. `Number.isInteger(false)` is false, so a boolean can never pass here
+//  and never reaches the *_state entry points — it stays on the boolean binding that means BLOCKER.
+const isPaintState = (value) => Number.isInteger(value) && value >= PAINT_STATE_ENFORCER && value <= PAINT_STATE_MAX
+
+// Stands in for an overlay the request did not ask for. Shared and never transferred (the transfer list drops
+//  zero-length buffers), so the one instance stays valid for every reply that needs a placeholder.
+const EMPTY_OVERLAY = new Float32Array(0)
+
+// Throws (-> the catch below posts {type:'error'}) rather than clamping: a bad state is a caller bug, and silently
+//  substituting one would paint the wrong extruder, which is far harder to notice than an error banner.
+const validatedPaintStates = (states) => {
+  for (const state of states)
+    if (!isPaintState(state)) throw new Error(`paint state must be an integer 1..${PAINT_STATE_MAX} (got ${JSON.stringify(state)})`)
+  return states
+}
+
+// Which states a message wants reported per-state. null == a legacy message (no `state`/`states` field) -> the reply
+//  must stay exactly {enf, blk} / {enf, blk} as it was before the protocol was widened, because the in-app support
+//  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]
+}
+
+// The state a paint message asks for: an explicit `state` wins, otherwise null meaning "use the legacy boolean path".
+//  Note the check is on presence-and-integerness, never on truthiness — see isPaintState above.
+const explicitPaintState = (message) => {
+  if (message.state === undefined || message.state === null) return null
+  validatedPaintStates([message.state])
+  return message.state
+}
+
+// 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)
+
+// 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
+//  a radius or a camera: what they select comes from the mesh's own topology, which is why they are a branch rather
+//  than more optional fields on the brush call. `state === null` means erase (the entry points with no state
+//  argument), matching how the brush splits paint from erase.
+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') {
+    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)
+    return
+  }
+  // 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
+  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)
+}
+
+// paint and erase both mutate the same selector, so both have to re-read every count the caller asked about: an
+//  erase over a T3 region lowers T3 exactly the way overpainting it with T2 would, and a reply carrying only the
+//  state that was written would leave the other chips showing stale numbers. `enf`/`blk` stay unconditional so a
+//  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 states = reportedPaintStates(message, paintedState)
+  if (states) reply.counts = Object.fromEntries(states.map(state => [state, Module.selector_painted_count_state(state)]))
+  return reply
+}
+
 self.onmessage = async (e) => {
   const d = e.data
   try {
@@ -35,11 +114,81 @@ self.onmessage = async (e) => {
     // 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' }); return }
     // Stage 20: manual support painting — selector state persists in this worker Module (slicing uses the same Module).
-    if (d.cmd === 'prepare') { Module.selector_prepare(new Uint8Array(d.stl)); self.postMessage({ type: 'prepared', facets: Module.selector_facet_count() }); return }
-    if (d.cmd === 'paint')   { Module.selector_paint(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, d.enforcer);
-                               self.postMessage({ type: 'painted', enf: Module.selector_painted_count(true), blk: Module.selector_painted_count(false) }); return }
-    if (d.cmd === 'clear')   { Module.selector_clear(); self.postMessage({ type: 'painted', enf: 0, blk: 0 }); return }
-    if (d.cmd === 'overlay')  { self.postMessage({ type: 'overlay', enf: Array.from(Module.selector_overlay(true)), blk: Array.from(Module.selector_overlay(false)) }); return }
+    // `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 })
+      return
+    }
+    // paint: legacy {enforcer:boolean} stays on the boolean binding (false == BLOCKER); {state:1..16} reaches any
+    //  extruder through the state binding. `enf`/`blk` are always reported so an old listener keeps working, and the
+    //  per-state `counts` map is added ONLY when the message asked for states (keeps the legacy reply byte-identical).
+    if (d.cmd === 'paint')   {
+      const paintedState = explicitPaintState(d)
+      if (FILL_TOOLS.has(d.tool)) {
+        // The fills are newer than the boolean protocol, so there is no legacy reading to fall back to — a fill
+        //  without an explicit integer state is a malformed message, not an enforcer stroke.
+        if (paintedState === null) throw new Error(`a '${d.tool}' fill needs an explicit integer state`)
+        applyFill(Module, d, paintedState)
+      }
+      else if (paintedState === null) Module.selector_paint(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, d.enforcer)
+      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
+    }
+    // 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:
+    //  embind coerces a JS `false` to 0 == NONE, so widening isPaintState to admit 0 would let a stray boolean on
+    //  the state path erase silently — the exact failure that guard was written to stop (see isPaintState above).
+    //  A boolean cannot forge the string 'erase', and the kernel binding it reaches takes no state argument at all,
+    //  so there is nothing left for a coercion to slip through. The reply is a normal 'painted' one: an erase is a
+    //  change to the same counts, and the viewer's listeners must not need to know which brush produced it.
+    if (d.cmd === 'erase')   {
+      if (FILL_TOOLS.has(d.tool)) applyFill(Module, d, null)
+      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
+    }
+    // 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.
+    //  It REPLACES every mark (the kernel's deserialize resets first), so it belongs immediately after a 'prepare'
+    //  and nowhere else — an import in the middle of a session would silently discard what the user had painted.
+    //  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
+      const reply = paintedReply(Module, d, null)
+      reply.applied = applied
+      self.postMessage(reply); 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 states = reportedPaintStates(d, null)
+      if (states) reply.counts = Object.fromEntries(states.map(state => [state, 0]))
+      self.postMessage(reply); 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.
+    //  The kernel already hands back a detached Float32Array (bindings.cpp to_f32 does typed_memory_view().slice()),
+    //  so the arrays are posted as they are and their buffers TRANSFERRED. The previous Array.from() turned each one
+    //  into a plain JS Array, which the structured clone then had to copy element by element — measured at 1.1 ms of
+    //  a 3.6 ms stroke sample on a 40k-triangle mesh, and growing with the painted area because the whole overlay is
+    //  resent every sample. Transferring costs nothing and the arrays are this worker's own copies, so nothing here
+    //  can observe them being neutered.
+    if (d.cmd === 'overlay')  {
+      const states = reportedPaintStates(d, null)
+      // 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',
+        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 ?? {})]
+        .filter(a => a?.buffer && a.byteLength > 0).map(a => a.buffer)
+      self.postMessage(reply, transfer); return
+    }
 
     if (d.stall) return   // stage-30 test hook: simulate a hang -> verifies the main-thread watchdog fires (not set in production)
     // mt (SAB): share the address of the real support progress counter (u32) with main once — even while the kernel is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Browser/WASM 3D-printing slicer reverse-engineered from OrcaSlicer: slicing engine (Arachne walls, tree/grid supports, multi-material), React viewer with GPU toolpath preview, and schema-driven settings UI.",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -41,6 +41,10 @@
       "types": "./types/viewer-loaders.d.ts",
       "default": "./viewer/dist/model_loaders.js"
     },
+    "./viewer/gcode": {
+      "types": "./types/viewer-gcode.d.ts",
+      "default": "./viewer/dist/gcode_parse.js"
+    },
     "./components": {
       "types": "./types/components.d.ts",
       "default": "./components/dist/SettingsPanel.js"
@@ -69,6 +73,7 @@
   },
   "files": [
     "engine",
+    "!engine/**/.omc",
     "types",
     "components/dist",
     "viewer/dist",
@@ -80,6 +85,7 @@
     "data/invalidation-map.json",
     "data/printers.json",
     "data/processes.js",
+    "data/filaments.js",
     "README.md",
     "LICENSE.txt"
   ],
@@ -97,8 +103,15 @@
     "wasm",
     "orcaslicer",
     "three",
+    "three.js",
     "react",
     "arachne",
-    "tree-support"
+    "tree-support",
+    "three-slicer",
+    "slicer",
+    "3d",
+    "mesh",
+    "clipping"
   ]
 }
+