three-slicer 0.3.4 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.4.0 — 2026-10-24
+
+### Removed (breaking)
+
+- `three-slicer/viewer`, `three-slicer/viewer/toolpath`, `three-slicer/viewer/loaders`, `three-slicer/viewer/gcode`
+  and `three-slicer/components`. They were wrappers over `three-slicer-viewer` kept for the pre-split import paths.
+  `three-slicer` now contains no React code and no longer declares `react`, `react-dom` or `three` as peers.
+  Migration: import the components from `three-slicer-viewer` (list it in your own dependencies at the same
+  version as `three-slicer`) and pass the kernel and upstream's data as props:
+
+  ```jsx
+  import Viewport, { useSlicer } from 'three-slicer-viewer'
+  import SettingsPanel from 'three-slicer-viewer/components'
+  import { makeSlicerWorker } from 'three-slicer/client'
+  import { bundledCatalog } from 'three-slicer/settings'
+  import { schema, uiTree } from 'three-slicer/data'
+  import { makeCfg, disabledKeys } from 'three-slicer/toggle'
+
+  const slicer = (deps) => useSlicer({ ...deps, makeWorker: makeSlicerWorker })   // module-level: it is a hook
+  const toggle = { makeCfg, disabledKeys }
+
+  <Viewport slicer={slicer} catalog={bundledCatalog} settings={settings} setSettings={setSettings} />
+  <SettingsPanel schema={schema} uiTree={uiTree} toggle={toggle} settings={settings} setSettings={setSettings} />
+  ```
+
+  The subpaths `/viewer/toolpath`, `/viewer/loaders` and `/viewer/gcode` are `three-slicer-viewer/toolpath`,
+  `/loaders` and `/gcode`, unchanged.
+
+## 0.3.5 — 2026-10-16
+
+### Fixed
+
+- The real wipe tower (`wipe_tower_real: true`) read past the end of its filament table on a tool change to or from
+  T2 or above (#69). The kernel registered filaments for tools 0 and 1 only, so the third tool's wipe moves took
+  their feedrate from whatever memory followed: `F0` or a value that changed from one slice to the next, and the
+  toolchange comment named no material. Every tool the change involves is now registered. On a three-extruder
+  slice the wipe moves went from 114 `F0` lines to none, and three runs give the same G-code. Each block now has the
+  shape the two-extruder tower always had. The default tower (the ring) and two-extruder slices are unchanged.
+  `wipe_tower_real` still defaults to `false`.
+
+### Changed
+
+- The kernel's own C++ and its tests were rewritten for readability: abbreviated names written out, one statement
+  per line, no ternaries, and one shared module for the test meshes. The kernel's output is unchanged, checked with
+  the golden G-code dump and a per-call hash of every kernel result in the test suite. Parameter keys, `stats`
+  fields and the worker protocol are unchanged.
+
 ## 0.3.4 — 2026-10-11
 
 ### Added

package/README.md

@@ -1,17 +1,16 @@
 # three-slicer
 
-Browser/WASM 3D-printing slicer package derived from [OrcaSlicer](https://github.com/OrcaSlicer/OrcaSlicer). It can slice binary STL files to G-code in Node or the browser, and it also ships React UI pieces for building a browser slicer: a three.js viewport, GPU toolpath preview, and a schema-driven settings panel. SLA (resin) printers are a second technology in the same kernel — supports and pad from PrusaSlicer's ported chain, previewed in the same viewer, exported as an `.sl1` archive.
+Browser/WASM 3D-printing slicer package derived from [OrcaSlicer](https://github.com/OrcaSlicer/OrcaSlicer). It can slice binary STL files to G-code in Node or the browser, and it supplies the kernel worker, OrcaSlicer's vendor presets and its settings schema to the React viewer and settings panel in [`three-slicer-viewer`](https://www.npmjs.com/package/three-slicer-viewer). SLA (resin) printers are a second technology in the same kernel — supports and pad from PrusaSlicer's ported chain, previewed in the same viewer, exported as an `.sl1` archive.
 
-The package is published as a single npm package, `three-slicer`, with subpath exports for the engine, viewer, components, worker, and extracted OrcaSlicer data.
+The package is published as a single npm package, `three-slicer`, with subpath exports for the engine, settings, worker, client, and extracted OrcaSlicer data.
 
 ![A sliced Benchy in the viewer's Preview tab — organic tree supports, per-feature toolpath colors, dual layer-range slider, filament and print-time estimates](https://raw.githubusercontent.com/kimgh06/Three_Slicer/main/web/viewer/public/usage.png)
 
 ## Links
 
 - Permissive viewer: [`three-slicer-viewer`](https://www.npmjs.com/package/three-slicer-viewer) (MIT) — the
-  viewer, the settings form, G-code parsing and toolpath rendering without the slicer. This package plugs the
-  kernel and OrcaSlicer's vendor presets into it; `three-slicer/viewer` and `three-slicer/components` are that
-  composition. Which code carries which licence, and why: [`PROVENANCE.md`](PROVENANCE.md).
+  viewer, the settings form, G-code parsing and toolpath rendering without the slicer. A host plugs this
+  package's kernel worker and OrcaSlicer's vendor presets into it (see the React quick starts below). Which code carries which licence, and why: [`PROVENANCE.md`](PROVENANCE.md).
 
 - Package: [npmjs.com/package/three-slicer](https://www.npmjs.com/package/three-slicer)
 - Source: [kimgh06/Three_Slicer](https://github.com/kimgh06/Three_Slicer)
@@ -26,7 +25,7 @@ reading whole; everything else is lookup.
 | --- | --- | --- | --- |
 | "Just the numbers" — quotes, farms, automation. No UI, no React | **Headless** | [Quick Start: Headless Slicing](#quick-start-headless-slicing) | [engine/README](engine/README.md) (134 lines), params via [PARAMS.md](engine/PARAMS.md) as lookup |
 | A slicer inside your existing page | **Embed** | [Quick Start: React Viewer](#quick-start-react-viewer) | [viewer/README](../viewer-package/VIEWER.md) (330 lines — the props contracts live there) |
-| The full slicer UI — viewport + settings panel | **Full UI** | [Full React Example](#full-react-example) | viewer/README + [components/README](components/README.md) |
+| The full slicer UI — viewport + settings panel | **Full UI** | [Full React Example](#full-react-example) | viewer/README + [COMPONENTS.md](../viewer-package/COMPONENTS.md) |
 
 Whichever path: read [Before You Ship](#before-you-ship) before deploying — those traps return plausible
 results instead of errors, and the first two never show up in `npm run dev`.
@@ -53,19 +52,21 @@ results instead of errors, and the first two never show up in `npm run dev`.
 npm i three-slicer
 ```
 
-`react`, `react-dom`, and `three` are **optional** peer dependencies. They stay peers rather than dependencies because React and three must be single instances — a duplicate copy breaks hooks and `instanceof` — and optional because only the UI half needs them: a headless consumer installs none of the three.
-
-Install them yourself when you use the viewer or the settings panel:
+Nothing in `three-slicer` needs React or three.js; a headless consumer installs neither. The React viewer and the
+settings panel are [`three-slicer-viewer`](https://www.npmjs.com/package/three-slicer-viewer), which `three-slicer`
+depends on at the same exact version. Import it by its own name, so list it in your own `package.json` at that
+version, together with its optional peers:
 
 ```bash
-npm i three-slicer react react-dom three
+npm i three-slicer three-slicer-viewer@<same version> react react-dom three
 ```
 
 | Import path | Needs react/three |
 | --- | --- |
-| `three-slicer`, `/settings`, `/toggle`, `/client`, `/worker`, `/wasm`, `/data`, `/viewer/gcode`, `/viewer/toolpath` | no — `makeToolpath(THREE, data)` takes `three` as an argument |
-| `three-slicer/viewer`, `/viewer/loaders` | yes |
-| `three-slicer/components` | react only |
+| `three-slicer`, `/settings`, `/toggle`, `/client`, `/worker`, `/wasm`, `/data` | no |
+| `three-slicer-viewer`, `/loaders` | yes |
+| `three-slicer-viewer/components` | react only |
+| `three-slicer-viewer/gcode`, `/toolpath` | no — `makeToolpath(THREE, data)` takes `three` as an argument |
 
 ## Quick Start: Headless Slicing
 
@@ -147,11 +148,19 @@ When `onLayer` is set, the returned result carries stats; assemble G-code from t
 
 ## Quick Start: React Viewer
 
-Use `three-slicer/viewer` when you want a ready-made browser slicer viewport.
+Use `three-slicer-viewer`'s `<Viewport/>` with this package's kernel worker and vendor presets plugged in when you
+want a ready-made browser slicer viewport. Without the `slicer` and `catalog` props it loads, displays and exports,
+but never starts a kernel and offers no presets.
 
 ```jsx
 import { useState } from 'react'
-import Viewport from 'three-slicer/viewer'
+import Viewport, { useSlicer } from 'three-slicer-viewer'
+import { makeSlicerWorker } from 'three-slicer/client'
+import { bundledCatalog } from 'three-slicer/settings'
+
+// The slicing hook bound to the WASM kernel's worker. Module-level: it is called as a hook, so its identity
+//  must not change between renders.
+const slicer = (deps) => useSlicer({ ...deps, makeWorker: makeSlicerWorker })
 
 export default function App() {
   const [settings, setSettings] = useState({})
@@ -159,6 +168,8 @@ export default function App() {
   return (
     <div style={{ position: 'relative', width: '100%', height: '100vh' }}>
       <Viewport
+        slicer={slicer}
+        catalog={bundledCatalog}
         settings={settings}
         setSettings={setSettings}
       />
@@ -176,11 +187,18 @@ The viewer handles model loading, drag and drop, transform controls, multi-plate
 
 ## Quick Start: Settings Panel
 
-Use `three-slicer/components` when you want the OrcaSlicer-style settings UI without building the form yourself.
+Use `three-slicer-viewer/components`' `<SettingsPanel/>` with this package's schema, tab tree and toggle rules
+plugged in when you want the OrcaSlicer-style settings UI without building the form yourself. Without them it labels
+every field by its key and disables nothing.
 
 ```jsx
 import { useState } from 'react'
-import SettingsPanel from 'three-slicer/components'
+import SettingsPanelCore from 'three-slicer-viewer/components'
+import { schema, uiTree } from 'three-slicer/data'
+import { makeCfg, disabledKeys } from 'three-slicer/toggle'
+
+const toggle = { makeCfg, disabledKeys }
+const SettingsPanel = (props) => <SettingsPanelCore schema={schema} uiTree={uiTree} toggle={toggle} {...props} />
 
 export default function App() {
   const [settings, setSettings] = useState({})
@@ -202,8 +220,19 @@ The viewer and settings panel are designed to share the same `settings` state.
 
 ```jsx
 import { useState } from 'react'
-import Viewport from 'three-slicer/viewer'
-import SettingsPanel from 'three-slicer/components'
+import Viewport, { useSlicer } from 'three-slicer-viewer'
+import { makeSlicerWorker } from 'three-slicer/client'
+import { bundledCatalog } from 'three-slicer/settings'
+
+// The slicing hook bound to the WASM kernel's worker. Module-level: it is called as a hook, so its identity
+//  must not change between renders.
+const slicer = (deps) => useSlicer({ ...deps, makeWorker: makeSlicerWorker })
+import SettingsPanelCore from 'three-slicer-viewer/components'
+import { schema, uiTree } from 'three-slicer/data'
+import { makeCfg, disabledKeys } from 'three-slicer/toggle'
+
+const toggle = { makeCfg, disabledKeys }
+const SettingsPanel = (props) => <SettingsPanelCore schema={schema} uiTree={uiTree} toggle={toggle} {...props} />
 
 export default function App() {
   const [settings, setSettings] = useState({})
@@ -211,6 +240,8 @@ export default function App() {
   return (
     <main style={{ display: 'flex', height: '100vh' }}>
       <Viewport
+        slicer={slicer}
+        catalog={bundledCatalog}
         settings={settings}
         setSettings={setSettings}
       />
@@ -231,8 +262,7 @@ The same sparse settings map can feed the settings panel, the viewer, and `deriv
 import { createSlicer, engineWorkerURL } from 'three-slicer'
 import { deriveKernelParams } from 'three-slicer/settings'
 import { disabledKeys, makeCfg } from 'three-slicer/toggle'
-import Viewport from 'three-slicer/viewer'
-import SettingsPanel from 'three-slicer/components'
+import { makeSlicerWorker } from 'three-slicer/client'
 import { schema, uiTree } from 'three-slicer/data'
 ```
 
@@ -247,40 +277,33 @@ Available subpaths:
 | `three-slicer/client` | `createSlicerClient()` — promises over that protocol |
 | `three-slicer/wasm` | Single-threaded Emscripten WASM glue |
 | `three-slicer/wasm-mt` | Multithreaded Emscripten WASM glue |
-| `three-slicer/viewer` | React `<Viewport/>` |
-| `three-slicer/viewer/toolpath` | GPU toolpath renderer utilities |
-| `three-slicer/viewer/loaders` | Model loaders |
-| `three-slicer/viewer/gcode` | `parseGcode(text)` — G-code back into the layer stream the renderer consumes |
-| `three-slicer/components` | React `<SettingsPanel/>` |
 | `three-slicer/data` | Named exports for extracted metadata |
 | `three-slicer/data/*.json` | Extracted OrcaSlicer metadata |
 
 ## Architecture: How the Pieces Connect
 
-One npm package, five modules. The dependency direction is one-way: `wasm-core` →(build)→ `engine`
-←(data)← `data`, with `components` and `viewer` consuming different surfaces of the engine, `types`
-generating and gating the contract from the side — and the glue at the top is always a single sparse
-settings map held by the host app.
+One npm package, four modules, beside the separately published React half (`three-slicer-viewer`). The dependency
+direction is one-way: `wasm-core` →(build)→ `engine` ←(data)← `data`, with `types` generating and gating the
+contract from the side. The host composes the React half with the kernel worker, the vendor catalog and the schema —
+and the glue at the top is always a single sparse settings map held by the host app.
 
 | Module | Role | Published as | Depends on | Consumed by |
 | --- | --- | --- | --- | --- |
 | `wasm-core` | C++ kernel sources + vendored third_party | not published | (ported upstream sources) | `engine` — as build output only |
-| `engine` | kernel SDK: direct handle, worker, client, settings derivation | `three-slicer` root + `/settings` `/toggle` `/client` `/worker` `/wasm(-mt)` `/data` | committed wasm-core output, `data`, the generated `kernel_setting_keys.js` | `components`, `viewer`, every consumer |
-| `data` | extracted schema + catalogs (config-schema, printers, processes, filaments…) | `/data` | `extract_all.py` ← upstream | `engine`'s settings, `components`, `viewer` |
+| `engine` | kernel SDK: direct handle, worker, client, the vendor catalog; re-exports the settings derivation and toggle evaluator from `three-slicer-viewer` | `three-slicer` root + `/settings` `/toggle` `/client` `/worker` `/wasm(-mt)` `/data` | committed wasm-core output, `data`, `three-slicer-viewer`'s `/settings` `/toggle` `/paint` | host apps, every consumer |
+| `data` | extracted schema + catalogs (config-schema, printers, processes, filaments…) | `/data` | `extract_all.py` ← upstream | `engine`'s settings, host apps (passed to the React half as props) |
 | `types` | every `.d.ts` + two generators | attached per subpath via the exports map's `types` fields | runs `engine` at generation time (probing), reads `data`'s schema | consumers' IDE/TS — no runtime dependency |
-| `components` | `<SettingsPanel/>` (Shadow DOM) | `/components` | `data` (schema + UI tree), `engine`'s `/toggle` | host apps |
-| `viewer` | `<Viewport/>` (three.js, Shadow DOM) | `/viewer` + `/viewer/toolpath` `/loaders` `/gcode` | `engine`'s `/settings`, the worker, `/data`; `three` (peer) | host apps |
 
 Some of the connections are not imports, and knowing which is which explains most of the layout:
 
 | Connection | Mechanism | Notes |
 | --- | --- | --- |
 | `wasm-core` → `engine` | `build.sh` (emscripten) commits its output into `engine/src/` | not an import — the golden byte-identical gate and the invariant suite verify kernel changes against the engine's output |
-| `data` → `engine`/`components`/`viewer` | `/data` subpath imports | the source of truth is `extract_all.py` over the upstream checkout |
+| `data` → `engine`, host apps | `/data` subpath imports | the source of truth is `extract_all.py` over the upstream checkout |
 | `types` → `engine` | the generator **executes** `deriveKernelParams` (probing) and writes `engine/PARAMS.md` + `../viewer-package/src/settings/kernel_setting_keys.js` back into the engine | `test_kernel_params.mjs` is the staleness gate |
 | `types` → `data` | `gen_settings_types.mjs` generates `settings-keys.d.ts` (976 keys) from the schema | run automatically by the build |
-| `viewer` ↔ `components` | **no direct link** | the host shares one settings map with both as props, and mounts `<SettingsPanel embedded/>` into the viewer's panel slots |
-| inside `viewer` | `core` (pure, node-runnable) ← `scene` (three/DOM) ← `actions` ← `ui` | `test_layers.mjs` enforces the boundary |
+| `engine` → `three-slicer-viewer` | the host passes `makeSlicerWorker` (as `useSlicer`'s `makeWorker`) and `bundledCatalog` to `<Viewport/>`, and `schema`/`uiTree`/the bound toggle to `<SettingsPanel/>` | props, not imports — the React half ships without the kernel or upstream's data |
+| `<Viewport/>` ↔ `<SettingsPanel/>` | **no direct link** | the host shares one settings map with both as props, and mounts `<SettingsPanel embedded/>` into the viewer's panel slots |
 
 ## TypeScript
 
@@ -331,7 +354,7 @@ const result = slicer.slice(stlArrayBuffer, params)
 
 A slicer-written `.3mf` is a project, not a mesh file: `Metadata/project_settings.config` holds the flattened
 preset its author sliced with. `<Viewport/>` reads all of it on import. The project parser/writer currently remain
-viewer internals; there is no `three-slicer/viewer/project` public export yet. Hosts can normalize or serialize a
+viewer internals; there is no `three-slicer-viewer/project` public export yet. Hosts can normalize or serialize a
 raw project settings object with the public settings helpers below, but should not import viewer source files.
 
 **Every value in that file is a string**, and reading it raw is not a cosmetic problem — a disabled option is the
@@ -758,7 +781,9 @@ the layout by hand.
 | `disabledKeys(cfg)` | Setting key → the `enable_if` expression that evaluated false |
 | `evalEnableIf(expr, locals, cfg)` | Evaluates a single rule; `null` when it cannot be resolved |
 
-### `three-slicer/viewer` and `three-slicer/components`
+### `three-slicer-viewer` (the React half)
+
+Published separately (MIT); listed here because a slicer UI uses both packages.
 
 | API | Description |
 | --- | --- |
@@ -789,7 +814,7 @@ the layout by hand.
 | Browser main thread | Headless slicing |
 | Browser worker | Off-main-thread slicing and streaming |
 | React | Viewer and settings panel |
-| three.js | Required by `three-slicer/viewer` |
+| three.js | Required by `three-slicer-viewer`'s `<Viewport/>` |
 
 ## Before You Ship
 
@@ -830,7 +855,7 @@ production while `npm run dev` passed. The no-argument form now emits a real wor
 
 - `slice()` currently takes binary STL input at the engine API boundary.
 - The viewer can import STL, OBJ, 3MF, AMF, and PLY, then converts them for slicing.
-- `registerLoader(exts, fn)` from `three-slicer/viewer/loaders` adds any other format. Formats needing a heavy dependency are kept out of the package so it stays runtime-dependency-free — see `web/viewer/src/step_loader.js` for a STEP loader built on `occt-import-js` (OCCT WASM).
+- `registerLoader(exts, fn)` from `three-slicer-viewer/loaders` adds any other format. Formats needing a heavy dependency are kept out of the package so it stays runtime-dependency-free — see `web/viewer/src/step_loader.js` for a STEP loader built on `occt-import-js` (OCCT WASM).
 - Not every OrcaSlicer schema key is wired into the WASM kernel yet.
 - Some vector settings are simplified to their first element.
 - One triangle selector serves both the support brush and the material brush (upstream's shared enum), so a support **blocker** paint and an Extruder 2 paint are the same mark — the two brushes cannot mark the same model independently.
@@ -839,7 +864,7 @@ production while `npm run dev` passed. The no-argument form now emits a real wor
 - The `.sl1` export lives in the viewer (its masks need a canvas); there is no headless `.sl1` writer export yet.
 - SLA mask edges are canvas anti-aliasing, not upstream's AGG rasterizer — same geometry, slightly different edge pixels.
 - Multithreaded WASM requires cross-origin isolation.
-- `three` is pinned as a peer dependency because viewer internals depend on the `TransformControls` API shape.
+- `three` is pinned as a peer dependency of `three-slicer-viewer` because viewer internals depend on the `TransformControls` API shape.
 
 ## License
 

package/THIRD-PARTY-NOTICES.md

@@ -25,8 +25,8 @@ live under `packages/wasm-core/third_party/deps_src/`.
 
 ## The viewer and the settings panel
 
-Since the split, `three-slicer/viewer` and `three-slicer/components` are re-exports of `three-slicer-viewer` (MIT), a
-separate package with its own `THIRD-PARTY-NOTICES.md`. This package bundles no viewer code of its own.
+The viewer and the settings panel are `three-slicer-viewer` (MIT), a separate package with its own
+`THIRD-PARTY-NOTICES.md`. This package bundles no viewer code of its own; since 0.4.0 it does not re-export it either.
 
 ## Bundled into the viewer/components builds (historical — see above)
 

package/data/README.md

@@ -1,6 +1,6 @@
 # three-slicer/data
 
-OrcaSlicer configuration metadata extracted from the original C++ sources, shipped inside the `three-slicer` package as its `/data` subpath. Used by `three-slicer` (defaults, settings mapping) and `three-slicer/components` (settings UI), and usable standalone for building slicer UIs.
+OrcaSlicer configuration metadata extracted from the original C++ sources, shipped inside the `three-slicer` package as its `/data` subpath. Used by `three-slicer` (defaults, settings mapping) and the settings UI (`three-slicer-viewer/components` takes the schema and UI tree as props), and usable standalone for building slicer UIs.
 
 | File | Contents |
 |---|---|

package/engine/PARAMS.md

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

package/engine/README.md

@@ -2,7 +2,7 @@
 
 Browser/WASM 3D-slicing kernel reverse-engineered from [OrcaSlicer](https://github.com/OrcaSlicer/OrcaSlicer). Slices binary STL to G-code entirely client-side (or in Node) — no server, no native binaries.
 
-**No three.js dependency.** This is a headless SDK with zero runtime dependencies; the config metadata it reads ships inside the same package (`three-slicer/data`). For a ready-made React viewer see `three-slicer/viewer`.
+**No three.js dependency.** This is a headless SDK with zero runtime dependencies; the config metadata it reads ships inside the same package (`three-slicer/data`). For a ready-made React viewer see [`three-slicer-viewer`](../../viewer-package/VIEWER.md), which takes this package's kernel worker as a prop.
 
 Ported from the original C++ sources: Clipper polygon ops, Arachne variable-width walls, real fill patterns (gyroid TPMS / honeycomb / 3D-honeycomb / crosshatch / concentric), tree supports, pressure equalizer, arc fitting (G2/G3), scarf seams, ironing, multi-material with prime tower. Kernel changes are gated by a 120+ invariant test suite and golden byte-identical G-code checks.
 

package/engine/src/client.js

@@ -41,8 +41,8 @@ const slaTransferables = (job) => job.objects.flatMap(object => [object, ...(obj
 //  keeps make_worker.js out of its own bundle. Do not factor this expression out.
 /**
  * The WASM kernel's worker, as a factory. This is the one thing a slicing viewer needs that the permissive
- * package cannot ship: `three-slicer-viewer`'s `useSlicer` takes it as `deps.makeWorker`, and
- * `three-slicer/viewer` binds it. Written as the full literal expression for the same reason as below.
+ * package cannot ship: `three-slicer-viewer`'s `useSlicer` takes it as `deps.makeWorker`, and a
+ * host binds it there. Written as the full literal expression for the same reason as below.
  */
 export function makeSlicerWorker() {
   return new Worker(new URL('./slicer.worker.js', import.meta.url), { type: 'module' })

package/engine/src/contour_front_gpu.js

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

package/engine/src/contour_front_shaders.js

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

package/engine/src/settings.js

@@ -128,7 +128,7 @@ export function printerDefaultBedType(profileName) { return printerEntry(profile
 
 // ---- The catalog as one object -------------------------------------------------------------------------------
 // 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.
+//  ships no catalog (these are OrcaSlicer's profile bundles); a host passes this one.
 export const bundledCatalog = Object.freeze({
   printerKeys, printerSettings, printersByVendor, printerTechByVendor, printerDefaultPreset, printerDefaultBedType,
   processPresets, filamentPresets, resinCatalog, resinSettingsFor,

package/engine/src/slicer.worker.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "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",
@@ -33,26 +33,6 @@
       "types": "./types/wasm.d.ts",
       "default": "./engine/src/slicer_core.mt.js"
     },
-    "./viewer": {
-      "types": "./types/viewer.d.ts",
-      "default": "./viewer/dist/Viewport.js"
-    },
-    "./viewer/toolpath": {
-      "types": "./types/viewer-toolpath.d.ts",
-      "default": "./viewer/dist/toolpath_reexport.js"
-    },
-    "./viewer/loaders": {
-      "types": "./types/viewer-loaders.d.ts",
-      "default": "./viewer/dist/loaders_reexport.js"
-    },
-    "./viewer/gcode": {
-      "types": "./types/viewer-gcode.d.ts",
-      "default": "./viewer/dist/gcode_reexport.js"
-    },
-    "./components": {
-      "types": "./types/components.d.ts",
-      "default": "./components/dist/SettingsPanel.js"
-    },
     "./data": {
       "types": "./types/data.d.ts",
       "default": "./engine/src/data.js"
@@ -65,25 +45,9 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "node types/gen_settings_types.mjs && node types/gen_kernel_params.mjs && vite build --config components/vite.config.js && vite build --config viewer/vite.config.js",
+    "build": "node types/gen_settings_types.mjs && node types/gen_kernel_params.mjs",
     "check": "bash pack_check.sh"
   },
-  "peerDependencies": {
-    "react": ">=18",
-    "react-dom": ">=18",
-    "three": "^0.160.0"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    },
-    "react-dom": {
-      "optional": true
-    },
-    "three": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "typescript": "^5.6.0",
     "vite": "^5.4.11"
@@ -93,8 +57,6 @@
     "types",
     "!**/tests/**",
     "!types/gen_*.mjs",
-    "components/dist",
-    "viewer/dist",
     "data",
     "data/ui-tree-keys.json",
     "data/config-schema-lean.json",
@@ -134,6 +96,6 @@
     "clipping"
   ],
   "dependencies": {
-    "three-slicer-viewer": "0.3.4"
+    "three-slicer-viewer": "0.4.0"
   }
 }

package/components/dist/SettingsPanel.js

@@ -1,15 +0,0 @@
-import r from "react";
-import t from "three-slicer-viewer/components";
-import { uiTree as o, schema as m } from "three-slicer/data";
-import { schema as d, uiTree as h } from "three-slicer/data";
-import { disabledKeys as a, makeCfg as i } from "three-slicer/toggle";
-const f = { makeCfg: i, disabledKeys: a };
-function l(e) {
-  return /* @__PURE__ */ r.createElement(t, { schema: m, uiTree: o, toggle: f, ...e });
-}
-export {
-  l as default,
-  d as schema,
-  f as toggle,
-  h as uiTree
-};

package/types/components.d.ts

@@ -1,3 +0,0 @@
-// three-slicer/components — the permissive settings panel with upstream's data plugged in. Same surface.
-export * from 'three-slicer-viewer/components'
-export { default } from 'three-slicer-viewer/components'

package/types/viewer-gcode.d.ts

@@ -1,2 +0,0 @@
-// Re-exported from the permissive package (MIT), where the implementation now lives.
-export * from 'three-slicer-viewer/gcode'

package/types/viewer-loaders.d.ts

@@ -1 +0,0 @@
-export * from 'three-slicer-viewer/loaders'

package/types/viewer-toolpath.d.ts

@@ -1,3 +0,0 @@
-// Re-exported from the permissive package (MIT), where the implementation now lives.
-// three-slicer/viewer/toolpath stays a valid entry point for every existing consumer.
-export * from 'three-slicer-viewer'

package/types/viewer.d.ts

@@ -1,7 +0,0 @@
-// three-slicer/viewer — the permissive viewer (three-slicer-viewer, MIT) with the kernel plugged in.
-export * from 'three-slicer-viewer'
-import type { ViewportProps, SlicerHandle } from 'three-slicer-viewer'
-/** The permissive `useSlicer` bound to the WASM kernel worker (three-slicer/client's makeSlicerWorker). */
-export function useSlicer(deps: Record<string, unknown>): SlicerHandle
-declare function Viewport(props: ViewportProps): JSX.Element
-export default Viewport

package/viewer/dist/Viewport.js

@@ -1,12 +0,0 @@
-import t from "react";
-import i, { useSlicer as m } from "three-slicer-viewer";
-import { makeSlicerWorker as a } from "three-slicer/client";
-import { bundledCatalog as c } from "three-slicer/settings";
-const l = (e) => m({ ...e, makeWorker: a });
-function p({ slicer: e, catalog: r, ...o }) {
-  return /* @__PURE__ */ t.createElement(i, { ...o, slicer: e ?? l, catalog: r === void 0 ? c : r });
-}
-export {
-  p as default,
-  l as useSlicer
-};

package/viewer/dist/gcode_reexport.js

@@ -1 +0,0 @@
-export * from "three-slicer-viewer/gcode";

package/viewer/dist/loaders_reexport.js

@@ -1 +0,0 @@
-export * from "three-slicer-viewer/loaders";

package/viewer/dist/toolpath_reexport.js

@@ -1 +0,0 @@
-export * from "three-slicer-viewer/toolpath";