three-slicer-viewer 0.3.4 → 0.4.0

package/COMPONENTS.md

@@ -1,7 +1,8 @@
 # three-slicer-viewer/components — the settings form
 
-(Published as `three-slicer-viewer/components`, MIT. `three-slicer/components` is the same component with upstream's
-schema, tab tree and toggle rules plugged in; everything below applies to both.)
+(Published as `three-slicer-viewer/components`, MIT. Upstream's labels, tab tree and toggle rules come from
+`three-slicer` through the `schema`, `uiTree` and `toggle` props, as below; without them every field is labelled by
+its key and nothing is disabled.)
 
 Reusable React components for the browser slicer. Props-driven — no global state, no React context, no router coupling (proven standalone by the tarball consumer gate `packages/pack_check.sh`).
 
@@ -12,16 +13,20 @@ An OrcaSlicer-style settings form generated from `three-slicer/data` (schema + U
 The tab set follows the printer profile's technology: a settings map whose `printer_technology` says SLA swaps the FFF tabs for the SLA ones (print/material/printer builders carry the technology in their upstream builder name, which is what the filter reads). No prop needed — change the profile in the shared settings map and the panel follows.
 
 ```bash
-npm i three-slicer react react-dom     # react is an OPTIONAL peer — npm does not install it for you
+npm i three-slicer three-slicer-viewer react react-dom   # same version for the two; react is an OPTIONAL peer — npm does not install it for you
 ```
 
 ```jsx
 import { useState } from 'react'
-import SettingsPanel from 'three-slicer/components'
+import SettingsPanel from 'three-slicer-viewer/components'
+import { schema, uiTree } from 'three-slicer/data'                 // upstream's labels, tooltips and tab tree (AGPL)
+import { makeCfg, disabledKeys } from 'three-slicer/toggle'         // the evaluator bound to upstream's rules (AGPL)
+
+const toggle = { makeCfg, disabledKeys }
 
 function App() {
   const [settings, setSettings] = useState({})   // sparse map: edited keys only; missing = schema default
-  return <SettingsPanel settings={settings} setSettings={setSettings} />
+  return <SettingsPanel schema={schema} uiTree={uiTree} toggle={toggle} settings={settings} setSettings={setSettings} />
 }
 ```
 
@@ -36,11 +41,11 @@ Props:
 | `customWidgets` | `{ [schemaKey]: Component }` (optional) | Replace schema-driven widgets per key (e.g. `{ printable_area: MyBedEditor }`) |
 | `only` | `{ builder, page? }` (optional) | Pins the panel to one builder/page and drops the search/page/mode chrome — how `<Viewport/>`'s `motionPanel` slot is meant to be filled |
 
-The same `settings` object feeds `deriveKernelParams()` in `three-slicer` and the `<Viewport/>` in `three-slicer/viewer` — one state connects all three.
+The same `settings` object feeds `deriveKernelParams()` in `three-slicer` and `three-slicer-viewer`'s `<Viewport/>` — one state connects all three.
 
 Ships transpiled ESM (`dist/`); react is an optional peer dependency. The panel arrives fully styled: its stylesheet is inlined into the bundle and injected into a Shadow DOM root, so host CSS neither styles it nor collides with it.
 
-The 3D viewport lives in its own package: `three-slicer/viewer`.
+The 3D viewport is the package's main entry, `three-slicer-viewer` ([VIEWER.md](VIEWER.md)).
 
 ## License
 

package/README.md

@@ -6,7 +6,7 @@ commercial products.
 
 This is [`three-slicer`](https://www.npmjs.com/package/three-slicer) with the kernel taken out. It displays and
 exports; it does not slice. Slicing is plugged in through two props — `slicer` (a hook driving a kernel) and
-`catalog` (vendor presets) — which `three-slicer/viewer` supplies. Install `three-slicer` for that, and note that
+`catalog` (vendor presets) — which `three-slicer` supplies (below). Install `three-slicer` for that, and note that
 doing so puts your application under AGPL.
 
 Developed in the [`Three_Slicer`](https://github.com/kimgh06/Three_Slicer) monorepo (`viewer-package/`), where it
@@ -41,7 +41,7 @@ const slicer = (deps) => useSlicer({ ...deps, makeWorker: makeSlicerWorker })
 import SettingsPanel from 'three-slicer-viewer/components'
 
 // Bare: fields labelled by key, nothing disabled. Pass `schema`, `uiTree` and `toggle` for labels, tabs and
-// enable/disable rules — three-slicer/components does that with OrcaSlicer's data; a host may pass its own.
+// enable/disable rules — three-slicer/data and /toggle carry OrcaSlicer's; a host may pass its own.
 <SettingsPanel settings={settings} setSettings={setSettings} />
 ```
 

package/VIEWER.md

@@ -1,26 +1,30 @@
 # three-slicer-viewer — the viewer
 
-(Published as `three-slicer-viewer`, MIT. `three-slicer/viewer` is the same component with the WASM kernel and the
-vendor catalog plugged in; everything below applies to both.)
+(Published as `three-slicer-viewer`, MIT. Slicing and the vendor presets come from `three-slicer` through the
+`slicer` and `catalog` props, as below; without them the viewer loads, displays and exports, but never slices.)
 
 3D slicer viewer as a React component: three.js viewport (orbit/transform gizmos), model import (STL/OBJ/3MF/AMF/PLY + pluggable formats such as STEP, multi-object, drag & drop), Web Worker slicing via `three-slicer`, support and material painting, per-extruder filament presets, multi-plate, and a GPU-instanced volumetric toolpath preview ported from OrcaSlicer's libvgcode (millions of segments in a single draw path, per-feature colors, layer range slider, G-code export).
 
 ![The Prepare tab — drag-and-drop viewport with the printer, filament and process cards in the right sidebar](../../slice-sidebar.png)
 
 ```bash
-npm i three-slicer react react-dom three     # the three are optional peers; the viewer needs all of them
+npm i three-slicer three-slicer-viewer react react-dom three   # same version for the two; the last three are optional peers the viewer needs
 ```
 
 ```jsx
 import { useState } from 'react'
-import Viewport from 'three-slicer/viewer'
+import Viewport, { useSlicer } from 'three-slicer-viewer'
+import { makeSlicerWorker } from 'three-slicer/client'     // the WASM kernel's worker (AGPL)
+import { bundledCatalog } from 'three-slicer/settings'     // OrcaSlicer's vendor presets (AGPL)
+
+const slicer = (deps) => useSlicer({ ...deps, makeWorker: makeSlicerWorker })   // module-level: it is a hook
 
 function App() {
   const [settings, setSettings] = useState({})   // OrcaSlicer schema keys; sparse — defaults fill the rest
   // The container matters — see Layout below.
   return (
     <div style={{ position: 'relative', width: '100%', height: '100vh' }}>
-      <Viewport settings={settings} setSettings={setSettings} />
+      <Viewport slicer={slicer} catalog={bundledCatalog} settings={settings} setSettings={setSettings} />
     </div>
   )
 }
@@ -37,7 +41,7 @@ the initial containing block instead, which usually looks like the viewer coveri
 
 There is no width or height prop: the component always fills that container, and resizes with it.
 
-Slice parameters are derived from `settings` via `three-slicer`'s schema mapping — pair it with `three-slicer/components`' `<SettingsPanel/>` sharing the same state for a full slicer UI.
+Slice parameters are derived from `settings` via `three-slicer`'s schema mapping — pair it with `three-slicer-viewer/components`' `<SettingsPanel/>` ([COMPONENTS.md](COMPONENTS.md)) sharing the same state for a full slicer UI.
 
 A `.3mf` written by a slicer (OrcaSlicer/BambuStudio save, MakerWorld download) imports as a **project**: plate layout, project settings, and support/material painting are restored, not just the meshes. Where a facet carries both paint kinds, material paint wins and the dropped support paint is reported.
 
@@ -47,9 +51,9 @@ next to the material picker) takes a **function** `(settings, setSettings) => Re
 card binds each extruder's per-extruder values.
 
 Subpath exports for custom UIs (framework-free, no React):
-- `three-slicer/viewer/toolpath` — GPU toolpath renderer (`buildSegmentData`, `makeToolpath`, view-type colorers)
-- `three-slicer/viewer/loaders` — model loaders returning unified triangle soup
-- `three-slicer/viewer/gcode` — `parseGcode(text)`, G-code back into the layer stream the renderer consumes
+- `three-slicer-viewer/toolpath` — GPU toolpath renderer (`buildSegmentData`, `makeToolpath`, view-type colorers)
+- `three-slicer-viewer/loaders` — model loaders returning unified triangle soup
+- `three-slicer-viewer/gcode` — `parseGcode(text)`, G-code back into the layer stream the renderer consumes
 
 ## Embedding it without the panels
 
@@ -233,7 +237,7 @@ Two limits to expect while using it:
 - Painting a region onto a second extruder only takes effect with **support turned off**. The painted multi-material path emits no support, so a support-enabled slice deliberately stays on the single-material path (where painted support keeps working as before).
 - On a machine with two or more extruders, a support *blocker* paint and an *Extruder 2* paint are the same mark and cannot be told apart.
 
-If you consume `three-slicer/viewer/toolpath` directly, note that the stride-8 role field `paths[k+3]` now carries the printing extruder alongside the role as `role + tool * 16`. Mask it — `& 15` for the role, `>>> 4` for the tool. Streams produced before this encoding are entirely below 16 and decode to their own role with tool 0, so older data still reads correctly.
+If you consume `three-slicer-viewer/toolpath` directly, note that the stride-8 role field `paths[k+3]` now carries the printing extruder alongside the role as `role + tool * 16`. Mask it — `& 15` for the role, `>>> 4` for the tool. Streams produced before this encoding are entirely below 16 and decode to their own role with tool 0, so older data still reads correctly.
 
 ## Turning behaviour off
 
@@ -336,7 +340,7 @@ The component owns its scene, and the props are the whole interface — there is
 - Everything else the component owns — camera, selection, plate count, paint state — is reported through `onEvent`
   and settable only by the user.
 
-If you need programmatic control over the scene, build on the subpath exports (`three-slicer/viewer/toolpath`,
+If you need programmatic control over the scene, build on the subpath exports (`three-slicer-viewer/toolpath`,
 `/loaders`, `/gcode`) and `three-slicer/client` rather than on `<Viewport/>`.
 
 ## Multithreaded slicing (automatic)

package/dist/index.js

@@ -4864,7 +4864,7 @@ function Dp({ error: e }) {
   return /* @__PURE__ */ i.createElement("div", { className: "slice-err side-warn", "data-testid": "slice-err" }, t, r && /* @__PURE__ */ i.createElement("pre", { className: "slice-err-detail" }, r));
 }
 function Gp() {
-  return "0.3.4";
+  return "0.4.0";
 }
 const Br = Gp();
 function Up({ on: e = !0 }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer-viewer",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "The three-slicer viewer without the slicer — model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
   "license": "MIT",
   "type": "module",

package/src/settings/settings_core.js

@@ -14,7 +14,10 @@ import { leanSchema as schema } from './data.js'
 import { FFF_FALLBACKS, AUTO_LINE_WIDTH, SLA_FALLBACKS, MACHINE_LIMITS, BED_FALLBACK } from './kernel_defaults.js'
 
 export function schemaDefault(key) { return schema[key]?.default }
-export function settingRaw(settings, key) { return (settings && key in settings) ? settings[key] : schemaDefault(key) }
+export function settingRaw(settings, key) {
+  if (settings && key in settings) return settings[key]
+  return schemaDefault(key)
+}
 // Normalize to a scalar ([0] for vectors)
 // 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
@@ -143,7 +146,8 @@ function coerceScalar(type, value) {
       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)
+      if (value.trim().endsWith('%')) return value
+      return asNumber(value)
     case 'coPoint': case 'coPoints':
       return parsePoint(value) ?? value
     case 'coPointsGroups':
@@ -161,25 +165,34 @@ function coerceScalar(type, value) {
 //  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(',')
+  let pair = split
+  if (split.length !== 2) pair = 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
+  if (Number.isFinite(x) && Number.isFinite(y)) return [x, y]
+  return 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
+    if (Number.isFinite(x) && Number.isFinite(y)) return [x, y]
+    return null
   })
-  return points.length && points.every(Boolean) ? points : null
+  if (points.length && points.every(Boolean)) return points
+  return 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
+  return finiteOr(Number(value), value)
+}
+// The number when it is finite, otherwise the fallback. The fallback is evaluated by the caller, so it is only
+//  used for values that are already at hand.
+function finiteOr(number, fallback) {
+  if (Number.isFinite(number)) return number
+  return fallback
 }
 
 /**
@@ -193,7 +206,8 @@ export function normalizeProjectSettings(raw) {
   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)
+    if (Array.isArray(value)) settings[key] = value.map(entry => coerceScalar(type, entry))
+    else settings[key] = coerceScalar(type, value)
     applied++
   }
   return { settings, applied, skipped }
@@ -204,17 +218,22 @@ export function normalizeProjectSettings(raw) {
 //  slicer's reader — and normalizeProjectSettings above — expects to coerce FROM. Writing the JS types raw would
 //  hand OrcaSlicer a bool it reads with its own string parser and this package a round-trip that only works here.
 //  Keys the schema does not define are dropped for the same reason normalize drops them: they could not be typed.
-const pointToText = (point) => (Array.isArray(point) ? `${point[0]}x${point[1]}` : String(point))
+const pointToText = (point) => {
+  if (Array.isArray(point)) return `${point[0]}x${point[1]}`
+  return String(point)
+}
 
 function serializeScalar(type, value) {
   if (value == null) return ''
   switch (type) {
     case 'coBool': case 'coBools':
-      return value ? '1' : '0'
+      if (value) return '1'
+      return '0'
     case 'coPoint': case 'coPoints':
       return pointToText(value)
     case 'coPointsGroups':
-      return Array.isArray(value) ? value.map(pointToText).join(',') : String(value)
+      if (Array.isArray(value)) return value.map(pointToText).join(',')
+      return String(value)
     default:
       return String(value)   // numbers, percents, strings, enums — String() is upstream's own spelling for all of them
   }
@@ -227,9 +246,8 @@ export function serializeProjectSettings(settings) {
     const type = schema[key]?.type
     if (!type) continue
     // A coPoint's value IS an array ([x, y]) — the generic array path would serialize its two numbers separately.
-    out[key] = (type !== 'coPoint' && Array.isArray(value))
-      ? value.map(entry => serializeScalar(type, entry))
-      : serializeScalar(type, value)
+    if (type !== 'coPoint' && Array.isArray(value)) out[key] = value.map(entry => serializeScalar(type, entry))
+    else out[key] = serializeScalar(type, value)
   }
   return out
 }
@@ -300,6 +318,22 @@ const BED_TEMP_KEYS = {
   'Engineering Plate': 'eng_plate_temp', 'High Temp Plate': 'hot_plate_temp', 'Textured PEI Plate': 'textured_plate_temp',
 }
 
+// A per-extruder column's first entry; a scalar is its own first entry.
+function firstEntryOf(value) {
+  if (Array.isArray(value)) return value[0]
+  return value
+}
+// A per-extruder column as a list; a scalar becomes a one-entry list.
+function asList(value) {
+  if (Array.isArray(value)) return value
+  return [value]
+}
+// The value when it is one of the accepted ones, otherwise the fallback.
+function allowedOr(value, accepted, fallback) {
+  if (accepted.includes(value)) return value
+  return fallback
+}
+
 // Right-panel settings values -> kernel parameters (derived from schema keys)
 //  opts.plate: which plate's entry to take from per-plate array options (wipe_tower_x/y — upstream coFloats,
 //  one entry per plate). Defaults to 0, so every existing caller reads exactly what it always did.
@@ -313,16 +347,23 @@ export function deriveKernelParams(settings, opts) {
   const presentOrTemplate = (key) => followsTemplate || (settings != null && key in settings && settings[key] != null && settings[key] !== '')
   const S = k => settingScalar(settings, k)
   const str = k => String(S(k) ?? FFF_FALLBACKS[k])
-  const num = (k, d = FFF_FALLBACKS[k]) => { const v = Number(S(k)); return Number.isFinite(v) ? v : d }
-  const bool = (k, d = FFF_FALLBACKS[k]) => { const v = settingRaw(settings, k); return typeof v === 'boolean' ? v : (Array.isArray(v) ? !!v[0] : (v == null ? d : !!v)) }
+  const num = (k, d = FFF_FALLBACKS[k]) => finiteOr(Number(S(k)), d)
+  const bool = (k, d = FFF_FALLBACKS[k]) => {
+    const v = settingRaw(settings, k)
+    if (typeof v === 'boolean') return v
+    if (Array.isArray(v)) return !!v[0]
+    if (v == null) return d
+    return !!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 = FFF_FALLBACKS[machineKey]) => {
     const raw = settings?.[filamentKey]
-    const value = Number(Array.isArray(raw) ? raw[0] : raw)
-    return Number.isFinite(value) ? value : num(machineKey, fallback)
+    const value = Number(firstEntryOf(raw))
+    if (Number.isFinite(value)) return value
+    return num(machineKey, fallback)
   }
 
   let line_width = num('line_width'); if (!line_width) line_width = AUTO_LINE_WIDTH   // 0 = auto
@@ -364,7 +405,7 @@ export function deriveKernelParams(settings, opts) {
   }
 
   // Stage 21: per-feature widths — passed to the kernel verbatim (including strings like "120%"). Unedited keys are omitted -> the kernel derives auto(=line_width).
-  //  The 0=auto semantics are handled by the kernel's resolve_lw (upstream Flow formula). Defaults unchanged (no feature set -> line_width).
+  //  The 0=auto semantics are handled by the kernel's resolve_line_width (upstream Flow formula). Defaults unchanged (no feature set -> line_width).
   const widths = {}
   for (const k of ['outer_wall_line_width','inner_wall_line_width','top_surface_line_width',
                    'sparse_infill_line_width','internal_solid_infill_line_width','initial_layer_line_width']) {
@@ -402,9 +443,11 @@ export function deriveKernelParams(settings, opts) {
     //  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 raw = settings?.[key]
-      const v = Array.isArray(raw) ? raw[plate] : raw
+      let v = raw
+      if (Array.isArray(raw)) v = raw[plate]
       const n = Number(v)
-      return (v != null && v !== '' && Number.isFinite(n)) ? n : null }
+      if (v != null && v !== '' && Number.isFinite(n)) return n
+      return 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
@@ -442,20 +485,22 @@ export function deriveKernelParams(settings, opts) {
     for (const key of PASSTHROUGH_NUM_VECTOR) {
       if (!present(key)) continue
       const raw = settings[key]
-      passthrough[key] = (Array.isArray(raw) ? raw : [raw]).map(entry => { const n = Number(entry); return Number.isFinite(n) ? n : 0 })
+      passthrough[key] = asList(raw).map(entry => finiteOr(Number(entry), 0))
     }
     for (const key of PASSTHROUGH_STR_VECTOR) {
       if (!present(key)) continue
       const raw = settings[key]
-      passthrough[key] = (Array.isArray(raw) ? raw : [raw]).map(entry => String(entry ?? ''))
+      passthrough[key] = asList(raw).map(entry => String(entry ?? ''))
     }
     // support_line_width is coFloatOrPercent, but the kernel reads it with the plain number reader rather than the
-    //  percent-aware jwidth_raw the per-feature widths get. A "120%" would reach strtod as a quoted string and
+    //  percent-aware json_width_raw the per-feature widths get. A "120%" would reach strtod as a quoted string and
     //  parse to 0 == auto — the setting silently ignored. Resolved here against the nozzle, which is the same
-    //  thing jwidth_raw does for the widths that do get the percent-aware reader.
+    //  thing json_width_raw does for the widths that do get the percent-aware reader.
     if (present('support_line_width')) {
       const text = String(settingScalar(settings, 'support_line_width')).trim()
-      const width = text.endsWith('%') ? (parseFloat(text) / 100) * num('nozzle_diameter') : Number(text)
+      let width
+      if (text.endsWith('%')) width = (parseFloat(text) / 100) * num('nozzle_diameter')
+      else width = Number(text)
       if (Number.isFinite(width) && width > 0) passthrough.support_line_width = width
     }
   }
@@ -524,8 +569,7 @@ export function deriveKernelParams(settings, opts) {
     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 finiteOr(Number(firstEntryOf(v)), scalar)
     })
   }
 
@@ -595,7 +639,7 @@ export function deriveKernelParams(settings, opts) {
     support_expansion: num('support_expansion'),
     support_threshold_overlap: (() => { const v = settingRaw(settings, 'support_threshold_overlap')
       if (typeof v === 'string' && v.trim().endsWith('%')) return parseFloat(v) / 100
-      const n = Number(v); return Number.isFinite(n) ? n : 0.5 })(),   // "50%" -> 0.5 (ratio of extrusion width)
+      return finiteOr(Number(v), 0.5) })(),   // "50%" -> 0.5 (ratio of extrusion width)
     support_on_build_plate_only: bool('support_on_build_plate_only'),
     support_interface_bottom_layers: num('support_interface_bottom_layers'),
     ...supportTools,                                            // present only when a support extruder is mapped (see above)
@@ -623,7 +667,7 @@ export function deriveKernelParams(settings, opts) {
     reduce_crossing_wall: bool('reduce_crossing_wall'),
     max_volumetric_extrusion_rate_slope: num('max_volumetric_extrusion_rate_slope'),
     // Stage 7: wall generator classic|arachne (arachne = the real ported OrcaSlicer WallToolPaths, variable width)
-    wall_generator: (str('wall_generator') === 'arachne') ? 'arachne' : 'classic',
+    wall_generator: allowedOr(str('wall_generator'), ['arachne'], 'classic'),
     // support_density has no matching schema key, so the kernel default (0.15) is used; scarf_length likewise uses the kernel default (10mm)
   }
 }
@@ -634,7 +678,8 @@ export function deriveKernelParams(settings, opts) {
 //  path runs. The schema already carries the key (inherited from the upstream lineage), so an imported preset
 //  that names a resin printer routes itself.
 export function printerTechnology(settings) {
-  return String(settingRaw(settings, 'printer_technology') ?? 'FFF').toUpperCase() === 'SLA' ? 'SLA' : 'FFF'
+  if (String(settingRaw(settings, 'printer_technology') ?? 'FFF').toUpperCase() === 'SLA') return 'SLA'
+  return 'FFF'
 }
 
 // SLA settings provenance table. Rows come from the schema's `defined_in` marker so a new resin option cannot
@@ -649,13 +694,12 @@ const SLA_SETTING_OVERRIDES = {
 
 const SLA_SCHEMA_ROWS = Object.fromEntries(Object.entries(schema)
   .filter(([key, meta]) => key === 'printer_technology' || String(meta.defined_in ?? '').includes('sla_'))
-  .map(([key, meta]) => [key, {
-    source: 'config-schema.json',
-    omission: 'schema-default',
-    default: meta.default,
-    ...(meta.enum_values ? { enum: [...meta.enum_values] } : {}),
-    provenance: `${meta.defined_in}:${meta.line}`,
-  }]))
+  .map(([key, meta]) => {
+    const row = { source: 'config-schema.json', omission: 'schema-default', default: meta.default }
+    if (meta.enum_values) row.enum = [...meta.enum_values]
+    row.provenance = `${meta.defined_in}:${meta.line}`
+    return [key, row]
+  }))
 
 export const SLA_SETTING_CONTRACT = Object.freeze(Object.fromEntries(
   Object.entries({ ...SLA_SCHEMA_ROWS, ...SLA_SETTING_OVERRIDES }).map(([key, row]) => [key, Object.freeze({
@@ -671,27 +715,40 @@ export const slaSettingKeys = Object.freeze(Object.keys(SLA_SETTING_CONTRACT))
 //  and its empty-map key count is a pinned invariant — this one feeds the JS contour slicer and owes bytes to
 //  nobody yet. Keys the schema does not define (the resin display's pixel grid, the per-layer height override)
 //  are read from the map directly, so they follow the same omission-friendly rule: absent means the default.
+// The number when it is finite and above zero, otherwise the fallback.
+function positiveOr(number, fallback) {
+  if (Number.isFinite(number) && number > 0) return number
+  return fallback
+}
+// The number when it is finite and not negative (zero is legal), otherwise the fallback.
+function nonNegativeOr(number, fallback) {
+  if (Number.isFinite(number) && number >= 0) return number
+  return fallback
+}
+// A flag whose absence means on.
+function trueUnlessSet(value) {
+  if (value === undefined) return true
+  return !!value
+}
 export function deriveSlaParams(settings) {
   const S = k => settingScalar(settings, k)
-  const num = (k, d = SLA_FALLBACKS[k]) => { const v = Number(S(k)); return Number.isFinite(v) && v > 0 ? v : d }
+  const num = (k, d = SLA_FALLBACKS[k]) => positiveOr(Number(S(k)), d)
 
   // Read from the MAP, not through the schema fallback: the key is shared with FFF and its schema default is that
   //  technology's opinion (0.2mm) — four resin layers thick. Absent means the resin default here.
   const rawLayerHeight = settings?.layer_height
-  const mapLayerHeight = Number(Array.isArray(rawLayerHeight) ? rawLayerHeight[0] : rawLayerHeight)
-  const layer_height = Number.isFinite(mapLayerHeight) && mapLayerHeight > 0 ? mapLayerHeight : SLA_FALLBACKS.layer_height
+  const mapLayerHeight = Number(firstEntryOf(rawLayerHeight))
+  const layer_height = positiveOr(mapLayerHeight, SLA_FALLBACKS.layer_height)
   // Zero is a legal fade count (no fade band), so this one cannot go through the positives-only reader.
   const fadedRaw = Number(S('faded_layers'))
   const requestedSupportTree = String(S('support_tree_type') ?? 'default').toLowerCase()
-  const support_tree_type = ['default', 'branching', 'organic'].includes(requestedSupportTree)
-    ? requestedSupportTree
-    : 'default'
+  const support_tree_type = allowedOr(requestedSupportTree, ['default', 'branching', 'organic'], 'default')
   return {
     layer_height,
     initial_layer_height: num('initial_layer_height', layer_height),
     exposure_time: num('exposure_time'),
     initial_exposure_time: num('initial_exposure_time'),
-    faded_layers: Number.isFinite(fadedRaw) && fadedRaw >= 0 ? fadedRaw : 10,
+    faded_layers: nonNegativeOr(fadedRaw, 10),
     // The physical display and its pixel grid — what turns millimetres into raster pixels at export time.
     //  Fallbacks are the SL1's own panel, the reference machine of the format this exports to.
     display_width: num('display_width'),
@@ -700,8 +757,8 @@ export function deriveSlaParams(settings) {
     display_pixels_y: num('display_pixels_y'),
     // Panel mounting: the whole SL1 family is portrait with X mirrored (projection through the vat floor);
     //  the raster writer swaps the image axes for portrait exactly like upstream SL1.cpp create_raster.
-    display_orientation: String(S('display_orientation') ?? 'portrait') === 'landscape' ? 'landscape' : 'portrait',
-    display_mirror_x: settingRaw(settings, 'display_mirror_x') === undefined ? true : !!settingRaw(settings, 'display_mirror_x'),
+    display_orientation: allowedOr(String(S('display_orientation') ?? 'portrait'), ['landscape'], 'portrait'),
+    display_mirror_x: trueUnlessSet(settingRaw(settings, 'display_mirror_x')),
     display_mirror_y: !!settingRaw(settings, 'display_mirror_y'),
     // SL1 archive identity fields (config.ini): written as-is, empty when the host never set a named
     //  profile — the same thing upstream produces then. material_print_speed defaults to 'fast', the value
@@ -742,23 +799,23 @@ export function deriveSlaParams(settings) {
     //  percent sign is stripped here; widening factor and base safety distance are legally ZERO (zero safety
     //  falls back to the kernel's own safety_distance), so neither can go through the positives-only reader.
     support_small_pillar_diameter_percent:
-      (() => { const v = Number(String(S('support_small_pillar_diameter_percent') ?? '').replace('%', '')); return Number.isFinite(v) && v > 0 ? v : 50 })(),
+      positiveOr(Number(String(S('support_small_pillar_diameter_percent') ?? '').replace('%', '')), 50),
     support_pillar_widening_factor:
-      (() => { const v = Number(S('support_pillar_widening_factor')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+      nonNegativeOr(Number(S('support_pillar_widening_factor')), 0),
     support_base_safety_distance:
-      (() => { const v = Number(S('support_base_safety_distance')); return Number.isFinite(v) && v >= 0 ? v : 1 })(),
+      nonNegativeOr(Number(S('support_base_safety_distance')), 1),
     support_max_bridges_on_pillar: num('support_max_bridges_on_pillar'),
     support_max_weight_on_model: num('support_max_weight_on_model'),
     // The generator's input slices are gap-closed with this radius, exactly like upstream slice_mesh_ex.
     slice_closing_radius: num('slice_closing_radius'),
-    support_object_elevation: (() => { const v = Number(S('support_object_elevation')); return Number.isFinite(v) && v >= 0 ? v : 5 })(),
+    support_object_elevation: nonNegativeOr(Number(S('support_object_elevation')), 5),
     support_pillar_connection_mode: String(S('support_pillar_connection_mode') ?? 'dynamic'),
     // The pad (upstream make_pad_cfg): wall height is legally ZERO (flat pad, no cavity), so it cannot go
     //  through the positives-only reader.
     pad_brim_size: num('pad_brim_size'),
     pad_wall_thickness: num('pad_wall_thickness'),
     pad_wall_height:
-      (() => { const v = Number(S('pad_wall_height')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+      nonNegativeOr(Number(S('pad_wall_height')), 0),
     pad_wall_slope: num('pad_wall_slope'),
     pad_max_merge_distance: num('pad_max_merge_distance'),
     pad_around_object: !!settingRaw(settings, 'pad_around_object'),

package/types/components.d.ts

@@ -1,12 +1,12 @@
-// three-slicer/components
+// three-slicer-viewer/components
 import type * as React from 'react'
 import type { SlicerSettings } from './settings-keys.d.ts'
 
 export interface SettingsPanelProps {
   /**
    * The config schema to render from. Defaults to this package's reduced schema — types, defaults, enum values,
-   * layout flags and units, but no label or tooltip, so a field is labelled by its key. `three-slicer/components`
-   * passes the full schema; a host may pass its own (a translation, its own vocabulary).
+   * layout flags and units, but no label or tooltip, so a field is labelled by its key. Pass
+   * three-slicer/data's full schema for upstream's labels; a host may pass its own (a translation, its own vocabulary).
    */
   schema?: Record<string, Record<string, unknown>>
   /** The tab/page/group tree. Defaults to one flat page per builder over this package's ui-tree keys. */

package/types/gcode.d.ts

@@ -1,5 +1,5 @@
-// three-slicer/viewer/gcode — G-code text -> kernel-shaped layer stream (renderable without slicing).
-// Feed the returned layers straight into buildSegmentData (three-slicer/viewer/toolpath).
+// three-slicer-viewer/gcode — G-code text -> kernel-shaped layer stream (renderable without slicing).
+// Feed the returned layers straight into buildSegmentData (three-slicer-viewer/toolpath).
 
 export interface GcodeLayer {
   z: number

package/types/toolpath.d.ts

@@ -1,5 +1,4 @@
 // three-slicer-viewer — kernel layers -> GPU-instanced toolpath.
-// Also published as three-slicer/viewer/toolpath, which re-exports this package.
 // Does not import three: makeToolpath takes the THREE namespace as an argument (guaranteeing a single instance).
 
 /** The 24 triangle indices of the 8-vertex diamond cross-section (from SegmentTemplate.cpp:18) */

package/types/viewer.d.ts

@@ -1,4 +1,4 @@
-// three-slicer/viewer
+// three-slicer-viewer
 import type * as React from 'react'
 import type { SlicerSettings } from './settings-keys.d.ts'
 import type { ProcessPresetsApi, FilamentPresetsApi } from './settings.d.ts'
@@ -114,8 +114,8 @@ export interface ViewportProps {
    */
   slicer?: (deps: Record<string, unknown>) => SlicerHandle
   /**
-   * The vendor preset catalog. This package ships none — nothing passed means empty pickers. `three-slicer/viewer`
-   * passes its bundled OrcaSlicer extraction; a host with its own fleet passes its own (a partial object is
+   * The vendor preset catalog. This package ships none — nothing passed means empty pickers. `three-slicer/settings`'
+   * `bundledCatalog` is the OrcaSlicer extraction; a host with its own fleet passes its own (a partial object is
    * merged over the empty catalog).
    */
   catalog?: Catalog | null
@@ -254,5 +254,5 @@ export function resolveCatalog(catalog?: Partial<Catalog> | null): Catalog
 export function useNoopSlicer(): SlicerHandle
 
 /** The slicing hook, unbound. `deps.makeWorker` must return a Worker speaking this package's slice protocol —
- *  three-slicer/viewer supplies its WASM kernel worker and re-exports the bound hook. */
+ *  three-slicer/client's makeSlicerWorker is the WASM kernel's. */
 export function useSlicer(deps: Record<string, unknown> & { makeWorker: () => Worker }): SlicerHandle