three-slicer 0.1.7 → 0.2.0

package/engine/src/settings.js

@@ -91,6 +91,26 @@ export const printerKeys = printers.keys
 /** Vendor -> profile name -> `[nozzle, setIndex, model]`, straight from the data (for building a picker). */
 export const printersByVendor = printers.byVendor
 
+/** Vendor -> slicing technology. Absent means FFF — only the resin vendor bundles are marked, so a printer
+ *  picker can keep FFF machines and SLA machines apart with one lookup. */
+export const printerTechByVendor = printers.techByVendor ?? {}
+
+/** The resin material catalog (SLA vendor bundles, inherits flattened): {name, bundle, type, vendor, colour,
+ *  exposure_time, initial_exposure_time, initial_layer_height, layerHeight}. layerHeight is the preset's
+ *  compatibility condition reduced to a number — the picker filters on it without an expression engine. */
+export const resinCatalog = printers.resins ?? []
+
+/** The settings a resin material applies, ready to merge — the exposure family plus the remembered pick.
+ *  `null` when unknown. The material never touches support/pad keys (upstream keeps those in sla_print). */
+export function resinSettingsFor(name) {
+  const entry = resinCatalog.find(r => r.name === name)
+  if (!entry) return null
+  const out = { sla_material_settings_id: name }
+  for (const key of ['exposure_time', 'initial_exposure_time', 'initial_layer_height'])
+    if (Number.isFinite(entry[key])) out[key] = entry[key]
+  return out
+}
+
 // Process (print) presets live in the ~800 KB processes.json, so they load on demand — the first call fetches,
 //  later ones reuse the same promise. Returns a small facade so no caller has to know the column layout.
 let processesPromise = null
@@ -534,6 +554,143 @@ export function deriveKernelParams(settings, opts) {
   }
 }
 
+// ---- Printer technology (FFF vs SLA routing) ----------------------------------------------------------------
+// The technology is a property of the printer profile, exactly as upstream models it: one settings map, two
+//  disjoint key families, and the profile's technology key decides which family the UI shows and which slicing
+//  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'
+}
+
+// SLA settings provenance table. Rows come from the schema's `defined_in` marker so a new resin option cannot
+// silently leave the UI/bridge without a documented omission/default decision. Explicit rows cover upstream
+// expression defaults the extractor cannot evaluate (support_tree_type and branching's bridge limits).
+const SLA_SETTING_OVERRIDES = {
+  layer_height: { omission: 'resin-default', default: 0.05, provenance: 'shared key; FFF schema default is not used' },
+  support_tree_type: { default: 'default', enum: ['default', 'branching', 'organic'], provenance: 'upstream enum expression' },
+  branchingsupport_pillar_connection_mode: { default: 'dynamic', enum: ['zigzag', 'cross', 'dynamic'], provenance: 'upstream enum expression' },
+  sla_archive_format: { default: 'SL1', enum: ['SL1'], provenance: 'Original Prusa SL1 archive' },
+}
+
+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}`,
+  }]))
+
+export const SLA_SETTING_CONTRACT = Object.freeze(Object.fromEntries(
+  Object.entries({ ...SLA_SCHEMA_ROWS, ...SLA_SETTING_OVERRIDES }).map(([key, row]) => [key, Object.freeze({
+    ...row,
+    ...(SLA_SETTING_OVERRIDES[key] ?? {}),
+  })]),
+))
+export const slaSettingContract = SLA_SETTING_CONTRACT
+export const slaSettingKeys = Object.freeze(Object.keys(SLA_SETTING_CONTRACT))
+
+// Right-panel settings values -> SLA slice parameters (sla_core.js) + the raster/export geometry the viewer's
+//  SL1 writer needs. A separate function, NOT a branch inside deriveKernelParams: that one feeds the WASM kernel
+//  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.
+export function deriveSlaParams(settings) {
+  const S = k => settingScalar(settings, k)
+  const num = (k, d) => { const v = Number(S(k)); return Number.isFinite(v) && v > 0 ? v : 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 : 0.05
+  // 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'
+  return {
+    layer_height,
+    initial_layer_height: num('initial_layer_height', layer_height),
+    exposure_time: num('exposure_time', 7),
+    initial_exposure_time: num('initial_exposure_time', 35),
+    faded_layers: Number.isFinite(fadedRaw) && fadedRaw >= 0 ? 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', 120.96),
+    display_height: num('display_height', 68.04),
+    display_pixels_x: num('display_pixels_x', 2560),
+    display_pixels_y: num('display_pixels_y', 1440),
+    // 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_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
+    //  every Prusa vendor SL1 material carries (-> expUserProfile 0 in the archive).
+    material_print_speed: String(S('material_print_speed') ?? 'fast'),
+    printer_model: String(S('printer_model') ?? ''),
+    printer_variant: String(S('printer_variant') ?? ''),
+    printer_settings_id: String(S('printer_settings_id') ?? ''),
+    sla_print_settings_id: String(S('sla_print_settings_id') ?? ''),
+    sla_material_settings_id: String(S('sla_material_settings_id') ?? ''),
+    // The kernel's over-bed check and centring read bed dimensions; for a resin printer the printable area IS
+    //  the display, so the display doubles as the bed the shared parser sees.
+    bed_width: num('display_width', 120.96),
+    bed_depth: num('display_height', 68.04),
+    // Support generation (kernel slice_sla): the grid-pillar generator's shape parameters, all schema keys the
+    //  SLA extraction pass brought in — schema defaults rule, an edit wins.
+    supports_enable: !!settingRaw(settings, 'supports_enable'),
+    pad_enable: !!settingRaw(settings, 'pad_enable'),
+    // Passed through so a requested hollow is REFUSED (typed kernel error) instead of silently sliced solid —
+    //  the OpenVDB chain hollowing needs is not ported, and a solid print labeled hollowed is the worst outcome.
+    hollowing_enable: !!settingRaw(settings, 'hollowing_enable'),
+    support_buildplate_only: !!settingRaw(settings, 'support_buildplate_only'),
+    support_pillar_diameter: num('support_pillar_diameter', 1.0),
+    support_head_front_diameter: num('support_head_front_diameter', 0.4),
+    support_head_width: num('support_head_width', 1.0),
+    support_head_penetration: num('support_head_penetration', 0.2),
+    support_points_density_relative: num('support_points_density_relative', 100),
+    support_critical_angle: num('support_critical_angle', 45),
+    support_tree_type,
+    // The tree shape (upstream SupportTreeConfig): bridge reach, bracing distance, the base foot cone, the
+    //  pillar connection style, and how far the object is lifted onto its supports. Elevation may legally be
+    //  ZERO (print directly on the plate), so it cannot go through the positives-only reader.
+    support_max_bridge_length: num('support_max_bridge_length', 15),
+    support_max_pillar_link_distance: num('support_max_pillar_link_distance', 10),
+    support_base_diameter: num('support_base_diameter', 4),
+    support_base_height: num('support_base_height', 1),
+    // The rest of upstream make_support_cfg (SLAPrint.cpp:50) — small-pillar percent arrives as "50%" so the
+    //  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 })(),
+    support_pillar_widening_factor:
+      (() => { const v = Number(S('support_pillar_widening_factor')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+    support_base_safety_distance:
+      (() => { const v = Number(S('support_base_safety_distance')); return Number.isFinite(v) && v >= 0 ? v : 1 })(),
+    support_max_bridges_on_pillar: num('support_max_bridges_on_pillar', 3),
+    support_max_weight_on_model: num('support_max_weight_on_model', 10),
+    // The generator's input slices are gap-closed with this radius, exactly like upstream slice_mesh_ex.
+    slice_closing_radius: num('slice_closing_radius', 0.049),
+    support_object_elevation: (() => { const v = Number(S('support_object_elevation')); return Number.isFinite(v) && v >= 0 ? v : 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', 1.6),
+    pad_wall_thickness: num('pad_wall_thickness', 2),
+    pad_wall_height:
+      (() => { const v = Number(S('pad_wall_height')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+    pad_wall_slope: num('pad_wall_slope', 90),
+    pad_max_merge_distance: num('pad_max_merge_distance', 50),
+    pad_around_object: !!settingRaw(settings, 'pad_around_object'),
+  }
+}
+
 // ---- Preset files (the .json OrcaSlicer imports/exports) ----------------------------------------------------
 // Re-exported here rather than given their own subpath: they are settings-map transforms like the 3mf project
 //  codecs above, and a consumer that has one hand on `settings` should not need a second import path for them.

package/engine/src/sla_core.js

@@ -0,0 +1,188 @@
+// Pure-JS SLA (resin) slicer: binary STL -> per-layer closed contours, in the SAME layer-stream contract the
+//  FFF kernel emits ({z, paths stride 8 [x0,y0,z0,enc, x1,y1,z1,enc], widths one per segment, enc = role+tool*16})
+//  — so the viewer's GPU toolpath preview, layer slider and plate cache consume an SLA slice unmodified.
+//
+// Why JS and not the WASM kernel: an SLA slice is contours only — no walls, no infill, no G-code — and a
+//  plane/triangle sweep is deterministic in doubles, so nothing here needs the C++ side. The raster/export half
+//  (PNG per layer, SL1 zip) is DELIBERATELY not in this module: rasterization needs a canvas, which Node does not
+//  have, and the engine package keeps zero runtime dependencies. The viewer owns that half (sl1_write.js).
+//
+// Determinism: iteration order is the STL's own triangle order, stitching maps insert in encounter order, and
+//  vertices on a slicing plane are pushed up by a fixed epsilon — same input bytes, same output bytes.
+
+const ROLE_CONTOUR = 1          // rendered as 'wall' by the preview's feature colouring
+const CONTOUR_WIDTH = 0.2       // display width of a contour segment (SLA has no bead width)
+const PLANE_EPS = 1e-9          // a vertex exactly on a plane counts as above it — deterministic tie-break
+const KEY_SCALE = 1e4           // endpoint welding: 0.1 micrometre grid
+
+/** Binary STL -> Float32Array of 9 floats per triangle (vertices only; normals are recomputed). */
+export function parseBinarySTL(bytes) {
+  if (!(bytes instanceof Uint8Array)) bytes = new Uint8Array(bytes)
+  if (bytes.byteLength < 84) return { error: 'not a binary STL (shorter than its own header)' }
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  const count = dv.getUint32(80, true)
+  if (84 + 50 * count !== bytes.byteLength) return { error: 'not a binary STL (triangle count does not match the byte length)' }
+  const tris = new Float32Array(count * 9)
+  for (let i = 0; i < count; i++) {
+    const base = 84 + 50 * i + 12          // skip the stored normal — recomputed from the winding below
+    for (let f = 0; f < 9; f++) tris[i * 9 + f] = dv.getFloat32(base + 4 * f, true)
+  }
+  return { tris, count }
+}
+
+const ptKey = (x, y) => Math.round(x * KEY_SCALE) + ',' + Math.round(y * KEY_SCALE)
+
+// One plane through the triangle soup -> oriented segments. Direction is Z×N (N = winding normal), which walks
+//  outer boundaries counter-clockwise and holes clockwise — that orientation is what makes the summed shoelace
+//  area the NET cross-section (outer minus holes) without any containment test.
+function sliceAtPlane(tris, z) {
+  const segs = []                          // [x0,y0,x1,y1] oriented
+  const n = tris.length / 9
+  for (let t = 0; t < n; t++) {
+    const o = t * 9
+    const vx = [tris[o], tris[o + 3], tris[o + 6]]
+    const vy = [tris[o + 1], tris[o + 4], tris[o + 7]]
+    const vz = [tris[o + 2], tris[o + 5], tris[o + 8]]
+    for (let i = 0; i < 3; i++) if (Math.abs(vz[i] - z) < PLANE_EPS) vz[i] = z + PLANE_EPS
+    const below = [vz[0] < z, vz[1] < z, vz[2] < z]
+    const nb = (below[0] ? 1 : 0) + (below[1] ? 1 : 0) + (below[2] ? 1 : 0)
+    if (nb === 0 || nb === 3) continue
+    // The lone vertex (on the minority side) and its two crossing edges
+    const lone = nb === 1 ? below.indexOf(true) : below.indexOf(false)
+    const a = (lone + 1) % 3, b = (lone + 2) % 3
+    const ta = (z - vz[lone]) / (vz[a] - vz[lone])
+    const tb = (z - vz[lone]) / (vz[b] - vz[lone])
+    let px = vx[lone] + ta * (vx[a] - vx[lone]), py = vy[lone] + ta * (vy[a] - vy[lone])
+    let qx = vx[lone] + tb * (vx[b] - vx[lone]), qy = vy[lone] + tb * (vy[b] - vy[lone])
+    // Winding normal N = (B-A)×(C-A); in-plane direction Z×N = (-Ny, Nx)
+    const ux = vx[1] - vx[0], uy = vy[1] - vy[0], uz = vz[1] - vz[0]
+    const wx = vx[2] - vx[0], wy = vy[2] - vy[0], wz = vz[2] - vz[0]
+    const nx = uy * wz - uz * wy, ny = uz * wx - ux * wz
+    const dirx = -ny, diry = nx
+    if ((qx - px) * dirx + (qy - py) * diry < 0) { const sx = px, sy = py; px = qx; py = qy; qx = sx; qy = sy }
+    if (Math.abs(px - qx) > 1e-12 || Math.abs(py - qy) > 1e-12) segs.push(px, py, qx, qy)
+  }
+  return segs
+}
+
+// Oriented segments -> closed loops (walk start-key -> next segment). Open chains (non-manifold geometry) are
+//  dropped whole and counted, mirroring how the paint importer drops a malformed facet rather than guessing.
+function stitchLoops(segs) {
+  const byStart = new Map()
+  const segCount = segs.length / 4
+  for (let s = 0; s < segCount; s++) {
+    const k = ptKey(segs[s * 4], segs[s * 4 + 1])
+    let list = byStart.get(k)
+    if (!list) { list = []; byStart.set(k, list) }
+    list.push(s)
+  }
+  const used = new Uint8Array(segCount)
+  const loops = []
+  let dropped = 0
+  for (let s0 = 0; s0 < segCount; s0++) {
+    if (used[s0]) continue
+    const startKey = ptKey(segs[s0 * 4], segs[s0 * 4 + 1])
+    const pts = []
+    let cur = s0, closed = false
+    while (true) {
+      used[cur] = 1
+      pts.push(segs[cur * 4], segs[cur * 4 + 1])
+      const endKey = ptKey(segs[cur * 4 + 2], segs[cur * 4 + 3])
+      if (endKey === startKey) { closed = true; break }
+      const nexts = byStart.get(endKey)
+      let next = -1
+      if (nexts) for (const cand of nexts) if (!used[cand]) { next = cand; break }
+      if (next < 0) break
+      cur = next
+    }
+    if (closed && pts.length >= 6) loops.push(pts)
+    else dropped++
+  }
+  return { loops, dropped }
+}
+
+const loopArea = (pts) => {   // signed shoelace, CCW positive
+  let area = 0
+  for (let i = 0, n = pts.length / 2; i < n; i++) {
+    const j = (i + 1) % n
+    area += pts[i * 2] * pts[j * 2 + 1] - pts[j * 2] * pts[i * 2 + 1]
+  }
+  return area / 2
+}
+
+/**
+ * Slice a binary STL for a resin print.
+ * params: layer_height, initial_layer_height, exposure_time, initial_exposure_time, faded_layers,
+ *         sla_layer_overhead (per-layer tilt/lift seconds) — all optional.
+ * hooks: {onProgress(done,total), onLayer({z,idx,paths,widths,area})} — layer buffers belong to the callee.
+ * Returns {stats, layers} (layers omitted when onLayer took them, mirroring the kernel's streamed mode).
+ */
+export function sliceSla(stlBytes, params = {}, hooks = {}) {
+  const parsed = parseBinarySTL(stlBytes)
+  if (parsed.error) return { error: parsed.error }
+  const { tris, count } = parsed
+  if (!count) return { error: 'empty STL (no triangles)' }
+
+  const lh = Number(params.layer_height) > 0 ? Number(params.layer_height) : 0.05
+  const ilh = Number(params.initial_layer_height) > 0 ? Number(params.initial_layer_height) : lh
+  const exposure = Number(params.exposure_time) > 0 ? Number(params.exposure_time) : 7
+  const initialExposure = Number(params.initial_exposure_time) > 0 ? Number(params.initial_exposure_time) : 35
+  const faded = Number.isFinite(Number(params.faded_layers)) ? Math.max(0, Number(params.faded_layers)) : 10
+  const overhead = Number(params.sla_layer_overhead) >= 0 ? Number(params.sla_layer_overhead) : 6
+
+  let minZ = Infinity, maxZ = -Infinity
+  for (let i = 2; i < tris.length; i += 3) { const v = tris[i]; if (v < minZ) minZ = v; if (v > maxZ) maxZ = v }
+  const height = maxZ - minZ
+  if (!(height > 0)) return { error: 'model has no height to slice' }
+
+  const layerCount = height <= ilh ? 1 : 1 + Math.ceil((height - ilh) / lh)
+  const layers = hooks.onLayer ? null : []
+  let segTotal = 0, volume = 0, droppedTotal = 0
+
+  for (let i = 0; i < layerCount; i++) {
+    const thickness = i === 0 ? ilh : lh
+    const top = minZ + (i === 0 ? ilh : ilh + i * lh)
+    const mid = top - thickness / 2
+    const { loops, dropped } = stitchLoops(sliceAtPlane(tris, mid))
+    droppedTotal += dropped
+    let area = 0, segCount = 0
+    for (const pts of loops) { area += loopArea(pts); segCount += pts.length / 2 }
+    area = Math.max(0, area)
+    volume += area * thickness
+    const paths = new Float32Array(segCount * 8)
+    const widths = new Float32Array(segCount)
+    let w = 0
+    for (const pts of loops) {
+      const n = pts.length / 2
+      for (let p = 0; p < n; p++) {
+        const q = (p + 1) % n
+        paths[w * 8] = pts[p * 2]; paths[w * 8 + 1] = pts[p * 2 + 1]; paths[w * 8 + 2] = top; paths[w * 8 + 3] = ROLE_CONTOUR
+        paths[w * 8 + 4] = pts[q * 2]; paths[w * 8 + 5] = pts[q * 2 + 1]; paths[w * 8 + 6] = top; paths[w * 8 + 7] = ROLE_CONTOUR
+        widths[w] = CONTOUR_WIDTH
+        w++
+      }
+    }
+    segTotal += segCount
+    const layer = { z: top, idx: i, paths, widths, area }
+    if (hooks.onLayer) hooks.onLayer(layer)
+    else layers.push(layer)
+    if (hooks.onProgress && (i % 16 === 0 || i === layerCount - 1)) hooks.onProgress(i + 1, layerCount)
+  }
+
+  // Exposure fades linearly from the initial to the regular value over the faded band, upstream's model.
+  let time = layerCount * overhead
+  for (let i = 0; i < layerCount; i++) {
+    const blend = faded > 0 ? Math.min(1, i / faded) : 1
+    time += initialExposure + (exposure - initialExposure) * blend
+  }
+
+  const stats = {
+    sla: true, streamed: !!hooks.onLayer,
+    layers: layerCount, path_segments: segTotal, filament_mm: 0,
+    resin_ml: volume / 1000, volume_mm3: volume,
+    time_estimate: Math.round(time),
+    open_chains_dropped: droppedTotal,
+    layer_height: lh, initial_layer_height: ilh,
+  }
+  return layers ? { stats, layers } : { stats }
+}

package/engine/src/sla_request.js

@@ -0,0 +1,185 @@
+export const SLA_JOB_VERSION = 1
+
+export const SLA_CAPABILITIES = Object.freeze({
+  defaultSupport: 'wasm-required',
+  branchingSupport: 'wasm-required',
+  organicSupport: 'unsupported',
+  manualSupportPoints: 'wasm-required',
+  modifierVolumes: 'wasm-required',
+  pad: 'wasm-required',
+  correction: 'wasm-required',
+  hollowing: 'unsupported',
+  drainHoles: 'unsupported',
+  jsFallback: 'single-object-contours-only',
+})
+
+export class SlaRequestError extends Error {
+  constructor(code, message) {
+    super(message)
+    this.name = 'SlaRequestError'
+    this.code = code
+  }
+}
+
+const fail = (code, message) => { throw new SlaRequestError(code, message) }
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value)
+const isBinary = (value) => value instanceof ArrayBuffer || value instanceof Uint8Array
+const has = (value, key) => Object.prototype.hasOwnProperty.call(value, key)
+const finite = (value) => typeof value === 'number' && Number.isFinite(value)
+const nonEmptyText = (value) => typeof value === 'string' && value.length > 0
+const optionalRecord = (value, path) => {
+  if (value === undefined) return undefined
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  return value
+}
+
+const matrixOf = (value, path) => {
+  if (value === undefined) return undefined
+  if (!Array.isArray(value) || value.length !== 16 || value.some(v => !finite(v)))
+    fail('SLA_INVALID_REQUEST', `${path} must be 16 finite numbers`)
+  return value
+}
+
+const isIdentity = (matrix) => !matrix || matrix.every((value, index) => value === (index % 5 === 0 ? 1 : 0))
+
+const pointOf = (value, path) => {
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  if (!['manual', 'automatic', 'island', 'slope'].includes(value.type))
+    fail('SLA_INVALID_REQUEST', `${path}.type must be 'manual', 'automatic', 'island', or 'slope'`)
+  if (!Array.isArray(value.position) || value.position.length !== 3 || value.position.some(v => !finite(v)))
+    fail('SLA_INVALID_REQUEST', `${path}.position must be three finite numbers`)
+  for (const key of ['radius', 'elevation'])
+    if (has(value, key) && (!finite(value[key]) || value[key] < 0)) fail('SLA_INVALID_REQUEST', `${path}.${key} must be a non-negative finite number`)
+  for (const key of ['permanent', 'manual'])
+    if (has(value, key) && typeof value[key] !== 'boolean') fail('SLA_INVALID_REQUEST', `${path}.${key} must be boolean`)
+  return value
+}
+
+const drainHoleOf = (value, path) => {
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  for (const key of ['position', 'normal'])
+    if (!Array.isArray(value[key]) || value[key].length !== 3 || value[key].some(v => !finite(v)))
+      fail('SLA_INVALID_REQUEST', `${path}.${key} must be three finite numbers`)
+  for (const key of ['radius', 'height'])
+    if (!finite(value[key]) || value[key] < 0) fail('SLA_INVALID_REQUEST', `${path}.${key} must be a non-negative finite number`)
+  return value
+}
+
+const modifierOf = (value, path) => {
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  if (!nonEmptyText(value.id)) fail('SLA_INVALID_REQUEST', `${path}.id must be a non-empty string`)
+  if (value.kind !== 'blocker' && value.kind !== 'enforcer') fail('SLA_INVALID_REQUEST', `${path}.kind must be 'blocker' or 'enforcer'`)
+  if (!isBinary(value.stl)) fail('SLA_INVALID_REQUEST', `${path}.stl must be an ArrayBuffer or Uint8Array`)
+  matrixOf(value.transform, `${path}.transform`)
+  optionalRecord(value.settings, `${path}.settings`)
+  return value
+}
+
+const instanceOf = (value, path) => {
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  if (!nonEmptyText(value.id)) fail('SLA_INVALID_REQUEST', `${path}.id must be a non-empty string`)
+  matrixOf(value.transform, `${path}.transform`)
+  optionalRecord(value.settings, `${path}.settings`)
+  return value
+}
+
+const objectOf = (value, index, ids) => {
+  const path = `objects[${index}]`
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', `${path} must be an object`)
+  if (!nonEmptyText(value.id) || ids.has(value.id)) fail('SLA_INVALID_REQUEST', `${path}.id must be a unique non-empty string`)
+  if (!isBinary(value.stl)) fail('SLA_INVALID_REQUEST', `${path}.stl must be an ArrayBuffer or Uint8Array`)
+  ids.add(value.id)
+  matrixOf(value.transform, `${path}.transform`)
+  optionalRecord(value.settings, `${path}.settings`)
+  if (value.instances !== undefined) {
+    if (!Array.isArray(value.instances) || value.instances.length === 0) fail('SLA_INVALID_REQUEST', `${path}.instances must be a non-empty array when present`)
+    const instanceIds = new Set()
+    value.instances.forEach((instance, i) => {
+      instanceOf(instance, `${path}.instances[${i}]`)
+      if (instanceIds.has(instance.id)) fail('SLA_INVALID_REQUEST', `${path}.instances ids must be unique`)
+      instanceIds.add(instance.id)
+    })
+  }
+  if (value.supportPoints !== undefined) {
+    if (!Array.isArray(value.supportPoints)) fail('SLA_INVALID_REQUEST', `${path}.supportPoints must be an array`)
+    value.supportPoints.forEach((point, i) => pointOf(point, `${path}.supportPoints[${i}]`))
+  }
+  if (value.modifierVolumes !== undefined) {
+    if (!Array.isArray(value.modifierVolumes)) fail('SLA_INVALID_REQUEST', `${path}.modifierVolumes must be an array`)
+    value.modifierVolumes.forEach((modifier, i) => modifierOf(modifier, `${path}.modifierVolumes[${i}]`))
+  }
+  if (value.drainHoles !== undefined) {
+    if (!Array.isArray(value.drainHoles)) fail('SLA_INVALID_REQUEST', `${path}.drainHoles must be an array`)
+    value.drainHoles.forEach((hole, i) => drainHoleOf(hole, `${path}.drainHoles[${i}]`))
+  }
+  return value
+}
+
+const supportOf = (value) => {
+  const support = optionalRecord(value, 'support')
+  if (!support) return undefined
+  if (has(support, 'enabled') && typeof support.enabled !== 'boolean') fail('SLA_INVALID_REQUEST', 'support.enabled must be boolean')
+  if (has(support, 'enforcersOnly') && typeof support.enforcersOnly !== 'boolean') fail('SLA_INVALID_REQUEST', 'support.enforcersOnly must be boolean')
+  if (has(support, 'strategy') && !['default', 'branching', 'organic'].includes(support.strategy))
+    fail('SLA_INVALID_REQUEST', "support.strategy must be 'default', 'branching', or 'organic'")
+  if (support.strategy === 'organic') fail('SLA_UNSUPPORTED_ORGANIC', 'Organic SLA supports are not available')
+  return support
+}
+
+const hollowingOf = (value) => {
+  const hollowing = optionalRecord(value, 'hollowing')
+  if (!hollowing) return undefined
+  if (has(hollowing, 'enabled') && typeof hollowing.enabled !== 'boolean') fail('SLA_INVALID_REQUEST', 'hollowing.enabled must be boolean')
+  if (hollowing.enabled) fail('SLA_UNSUPPORTED_HOLLOWING', 'SLA hollowing is not available')
+  return hollowing
+}
+
+export function parseSlaJob(value) {
+  if (!isRecord(value)) fail('SLA_INVALID_REQUEST', 'SLA job must be an object')
+  if (has(value, 'version') && value.version !== SLA_JOB_VERSION) fail('SLA_INVALID_REQUEST', `SLA job version must be ${SLA_JOB_VERSION}`)
+  if (!Array.isArray(value.objects) || value.objects.length === 0) fail('SLA_INVALID_REQUEST', 'SLA job.objects must be a non-empty array')
+  const ids = new Set()
+  value.objects.forEach((object, index) => objectOf(object, index, ids))
+  if (value.objects.some(object => object.drainHoles?.length))
+    fail('SLA_UNSUPPORTED_HOLLOWING', 'SLA drain holes were preserved but require unsupported hollowing geometry')
+  optionalRecord(value.settings, 'settings')
+  const support = supportOf(value.support)
+  const pad = optionalRecord(value.pad, 'pad')
+  const correction = optionalRecord(value.correction, 'correction')
+  const hollowing = hollowingOf(value.hollowing)
+  if (value.drainHoles !== undefined) {
+    if (!Array.isArray(value.drainHoles)) fail('SLA_INVALID_REQUEST', 'drainHoles must be an array')
+    if (value.drainHoles.length) fail('SLA_UNSUPPORTED_HOLLOWING', 'SLA drain holes require unsupported hollowing geometry')
+  }
+  if (value.requiredCapabilities !== undefined) {
+    if (!Array.isArray(value.requiredCapabilities) || value.requiredCapabilities.some(key => !has(SLA_CAPABILITIES, key)))
+      fail('SLA_INVALID_REQUEST', 'requiredCapabilities must name known SLA capabilities')
+    if (value.requiredCapabilities.includes('organicSupport')) fail('SLA_UNSUPPORTED_ORGANIC', 'Organic SLA supports are not available')
+    if (value.requiredCapabilities.includes('hollowing') || value.requiredCapabilities.includes('drainHoles'))
+      fail('SLA_UNSUPPORTED_HOLLOWING', 'SLA hollowing is not available')
+  }
+  return { version: SLA_JOB_VERSION, ...value, support, pad, correction, hollowing }
+}
+
+const wantsSupports = (job, object) => job.support?.enabled === true || job.settings?.supports_enable === true || object.settings?.supports_enable === true
+const wantsPad = (job, object) => job.pad?.enabled === true || job.settings?.pad_enable === true || object.settings?.pad_enable === true
+
+export function slaFallbackParams(job) {
+  if (job.objects.length !== 1) fail('SLA_FALLBACK_MULTI_OBJECT', 'The JS SLA fallback accepts exactly one object; object-aware jobs require WASM support')
+  const object = job.objects[0]
+  if (!isIdentity(object.transform) || object.instances !== undefined || object.supportPoints?.length || object.modifierVolumes?.length || object.settings?.hollowing_enable === true)
+    fail('SLA_FALLBACK_OBJECT_CONTEXT', 'The JS SLA fallback cannot preserve object transforms, instances, points, modifiers, or hollowing')
+  if (wantsSupports(job, object)) fail('SLA_FALLBACK_SUPPORTS', 'The JS SLA fallback cannot generate requested supports')
+  if (wantsPad(job, object)) fail('SLA_FALLBACK_PAD', 'The JS SLA fallback cannot generate a requested pad')
+  if (job.correction || job.hollowing || job.drainHoles?.length)
+    fail('SLA_FALLBACK_OBJECT_CONTEXT', 'The JS SLA fallback cannot apply correction, hollowing, or drain-hole context')
+  return { stl: object.stl, params: { ...(job.settings ?? {}), ...(object.settings ?? {}) } }
+}
+
+export function assertLegacySlaFallback(params) {
+  if (!isRecord(params)) fail('SLA_INVALID_REQUEST', 'legacy SLA params must be an object')
+  if (params.support_tree_type === 'organic') fail('SLA_UNSUPPORTED_ORGANIC', 'Organic SLA supports are not available')
+  if (params.hollowing_enable === true) fail('SLA_UNSUPPORTED_HOLLOWING', 'SLA hollowing is not available')
+  if (params.supports_enable === true) fail('SLA_FALLBACK_SUPPORTS', 'The JS SLA fallback cannot generate requested supports')
+  if (params.pad_enable === true) fail('SLA_FALLBACK_PAD', 'The JS SLA fallback cannot generate a requested pad')
+}

package/engine/src/slicer.worker.js

@@ -15,6 +15,8 @@
 //  A host embedding the viewer in its own product can switch it off (`<Viewport features={{ logs: false }} />`,
 //  which sets `quiet` on the messages it sends): this is a separate module instance from the viewer's log.js and
 //  cannot read a flag set over there.
+import { assertLegacySlaFallback, parseSlaJob } from './sla_request.js'
+
 let quiet = false
 const say = (level, ...args) => { if (!quiet) console[level](...args) }
 
@@ -125,6 +127,66 @@ self.onmessage = async (e) => {
     if (d.cmd === 'exportPaint' && !modPromise) {
       self.postMessage({ type: 'paintExport', supported: false, facets: [], hex: '' }); return
     }
+    if (d.cmd === 'slaJob') {
+      const job = parseSlaJob(d.job)
+      if (!modPromise) modPromise = loadCore()
+      const Kernel = await modPromise
+      const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
+      if (Kernel.slice_sla_job) {
+        Kernel.set_layer_sink((z, idx, gcode, paths, widths) => {
+          const transfer = []
+          if (paths?.buffer) transfer.push(paths.buffer)
+          if (widths?.buffer) transfer.push(widths.buffer)
+          self.postMessage({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
+        })
+        let r
+        try { r = Kernel.slice_sla_job(job, onProgress) }
+        finally { Kernel.clear_layer_sink() }
+        if (r?.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
+        self.postMessage({ type: 'done', result: r }); return
+      }
+      self.postMessage({ type: 'error', code: 'SLA_UNSUPPORTED_OBJECT_AWARE',
+                        error: 'Object-aware SLA slicing requires WASM kernel support' })
+      return
+    }
+    // SLA slicing runs in the WASM kernel (slice_sla — contours + generated supports, C++ Clipper speed), through
+    //  the same layer-sink streaming a kernel slice uses. The pure-JS contour slicer (sla_core.js) stays as the
+    //  fallback for a loaded kernel that predates the binding — it produces the same stream, minus the supports.
+    if (d.cmd === 'sla') {
+      const params = typeof d.params === 'string' ? d.params : JSON.stringify(d.params ?? {})
+      if (!modPromise) modPromise = loadCore()
+      const Kernel = await modPromise
+      const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
+      if (Kernel.slice_sla) {
+        Kernel.set_layer_sink((z, idx, gcode, paths, widths) => {
+          const transfer = []
+          if (paths && paths.buffer) transfer.push(paths.buffer)
+          if (widths && widths.buffer) transfer.push(widths.buffer)
+          self.postMessage({ type: 'layer', z, idx, gcode: '', paths, widths }, transfer)
+        })
+        let r
+        try { r = Kernel.slice_sla(new Uint8Array(d.stl), params, onProgress) }
+        finally { Kernel.clear_layer_sink() }
+        if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
+        self.postMessage({ type: 'done', result: r })
+        return
+      }
+      const { sliceSla } = await import('./sla_core.js')
+      const fallbackParams = JSON.parse(params)
+      assertLegacySlaFallback(fallbackParams)
+      const r = sliceSla(new Uint8Array(d.stl), fallbackParams, {
+        onProgress,
+        onLayer: (L) => {
+          const transfer = []
+          if (L.paths?.buffer) transfer.push(L.paths.buffer)
+          if (L.widths?.buffer) transfer.push(L.widths.buffer)
+          self.postMessage({ type: 'layer', z: L.z, idx: L.idx, gcode: '', paths: L.paths, widths: L.widths }, transfer)
+        },
+      })
+      if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
+      self.postMessage({ type: 'done', result: r })
+      return
+    }
     if (!modPromise) modPromise = loadCore()
     const Module = await modPromise
     // Warmup: only load the kernel (+ spawn the mt pthread pool) ahead of time — removes the perceived load on the first slice
@@ -247,6 +309,6 @@ self.onmessage = async (e) => {
     self.postMessage({ type: 'done', result: r })
   } catch (err) {
     // Includes the WASM abort("memory access out of bounds") — the main thread's OOM ladder decides on re-creation / economy retry.
-    self.postMessage({ type: 'error', error: String((err && err.message) || err) })
+    self.postMessage({ type: 'error', error: String((err && err.message) || err), ...(err?.code ? { code: err.code } : {}) })
   }
 }