three-slicer 0.1.7 → 0.2.1

package/data/ui-tree.json

@@ -1277,5 +1277,347 @@
     }
    ]
   }
+ ],
+ "TabPrinter::build_sla": [
+  {
+   "page": "General",
+   "icon": "printer",
+   "line": 3016,
+   "groups": [
+    {
+     "group": "Size and coordinates",
+     "line": 3017,
+     "options": [
+      "max_print_height"
+     ]
+    },
+    {
+     "group": "Display",
+     "line": 3024,
+     "options": [
+      "display_width",
+      "display_height",
+      "<custom-widget line:3032>",
+      "display_orientation",
+      "display_mirror_x",
+      "display_mirror_y"
+     ]
+    },
+    {
+     "group": "Tilt",
+     "line": 3039,
+     "options": [
+      "<custom-widget line:3044>"
+     ]
+    },
+    {
+     "group": "Corrections",
+     "line": 3046,
+     "options": [
+      "<custom-widget line:3053>",
+      "absolute_correction",
+      "elefant_foot_compensation",
+      "elefant_foot_min_width",
+      "gamma_correction"
+     ]
+    },
+    {
+     "group": "Exposure",
+     "line": 3059,
+     "options": [
+      "min_exposure_time",
+      "max_exposure_time",
+      "min_initial_exposure_time",
+      "max_initial_exposure_time"
+     ]
+    },
+    {
+     "group": "Output",
+     "line": 3066,
+     "options": [
+      "sla_archive_format",
+      "sla_output_precision"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Notes",
+   "icon": "note",
+   "line": 3074,
+   "groups": [
+    {
+     "group": "Notes",
+     "line": 3075,
+     "options": []
+    }
+   ]
+  },
+  {
+   "page": "Dependencies",
+   "icon": "wrench",
+   "line": 3081,
+   "groups": [
+    {
+     "group": "Profile dependencies",
+     "line": 3082,
+     "options": []
+    }
+   ]
+  }
+ ],
+ "TabSLAMaterial::build": [
+  {
+   "page": "Material",
+   "icon": "resin",
+   "line": 5437,
+   "groups": [
+    {
+     "group": "Material",
+     "line": 5439,
+     "options": [
+      "material_colour",
+      "bottle_cost",
+      "bottle_volume",
+      "bottle_weight",
+      "material_density"
+     ]
+    },
+    {
+     "group": "Layers",
+     "line": 5478,
+     "options": [
+      "initial_layer_height"
+     ]
+    },
+    {
+     "group": "Exposure",
+     "line": 5481,
+     "options": [
+      "exposure_time",
+      "initial_exposure_time"
+     ]
+    },
+    {
+     "group": "Corrections",
+     "line": 5485,
+     "options": [
+      "<custom-widget line:5492>",
+      "zcorrection_layers",
+      "<custom-widget line:5502>"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Notes",
+   "icon": "note",
+   "line": 5506,
+   "groups": [
+    {
+     "group": "Notes",
+     "line": 5507,
+     "options": []
+    }
+   ]
+  },
+  {
+   "page": "Dependencies",
+   "icon": "wrench",
+   "line": 5514,
+   "groups": [
+    {
+     "group": "Profile dependencies",
+     "line": 5515,
+     "options": []
+    }
+   ]
+  },
+  {
+   "page": "Material printing profile",
+   "icon": "note",
+   "line": 5535,
+   "groups": [
+    {
+     "group": "Material printing profile",
+     "line": 5537,
+     "options": [
+      "material_print_speed"
+     ]
+    },
+    {
+     "group": "Tilt",
+     "line": 5540,
+     "options": [
+      "area_fill"
+     ]
+    },
+    {
+     "group": "Temperature",
+     "line": 5543,
+     "options": [
+      "<custom-widget line:5560>",
+      "<custom-widget line:5590>"
+     ]
+    }
+   ]
+  }
+ ],
+ "TabSLAPrint::build": [
+  {
+   "page": "Layers and perimeters",
+   "icon": "layers",
+   "line": 6066,
+   "groups": [
+    {
+     "group": "Layers",
+     "line": 6068,
+     "options": [
+      "layer_height",
+      "faded_layers"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Supports",
+   "icon": "support",
+   "line": 6072,
+   "groups": [
+    {
+     "group": "Supports",
+     "line": 6074,
+     "options": [
+      "supports_enable",
+      "support_tree_type",
+      "support_enforcers_only"
+     ]
+    },
+    {
+     "group": "Automatic generation",
+     "line": 6081,
+     "options": [
+      "support_points_density_relative"
+     ]
+    },
+    {
+     "group": "Support head",
+     "line": 5864,
+     "options": [
+      "support_head_front_diameter",
+      "support_head_penetration",
+      "support_head_width"
+     ]
+    },
+    {
+     "group": "Support pillar",
+     "line": 5869,
+     "options": [
+      "support_pillar_diameter",
+      "support_small_pillar_diameter_percent",
+      "support_max_bridges_on_pillar",
+      "support_pillar_connection_mode",
+      "support_buildplate_only",
+      "support_pillar_widening_factor",
+      "support_max_weight_on_model",
+      "support_base_diameter",
+      "support_base_height",
+      "support_base_safety_distance",
+      "support_object_elevation",
+      "<custom-widget line:5890>"
+     ]
+    },
+    {
+     "group": "Connection of the support sticks and junctions",
+     "line": 5892,
+     "options": [
+      "support_critical_angle",
+      "support_max_bridge_length",
+      "support_max_pillar_link_distance"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Pad",
+   "icon": "pad",
+   "line": 6084,
+   "groups": [
+    {
+     "group": "Pad",
+     "line": 6085,
+     "options": [
+      "pad_enable",
+      "pad_wall_thickness",
+      "pad_wall_height",
+      "pad_brim_size",
+      "pad_max_merge_distance",
+      "pad_wall_slope",
+      "pad_around_object",
+      "pad_around_object_everywhere",
+      "pad_object_gap",
+      "pad_object_connector_stride",
+      "pad_object_connector_width",
+      "pad_object_connector_penetration"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Hollowing",
+   "icon": "hollowing",
+   "line": 6102,
+   "groups": [
+    {
+     "group": "Hollowing",
+     "line": 6103,
+     "options": [
+      "hollowing_enable",
+      "hollowing_min_thickness",
+      "hollowing_quality",
+      "hollowing_closing_distance"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Advanced",
+   "icon": "wrench",
+   "line": 6109,
+   "groups": [
+    {
+     "group": "Slicing",
+     "line": 6110,
+     "options": [
+      "slice_closing_radius",
+      "slicing_mode"
+     ]
+    }
+   ]
+  },
+  {
+   "page": "Output options",
+   "icon": "output+page_white",
+   "line": 6114,
+   "groups": [
+    {
+     "group": "Output file",
+     "line": 6115,
+     "options": []
+    }
+   ]
+  },
+  {
+   "page": "Dependencies",
+   "icon": "wrench",
+   "line": 6120,
+   "groups": [
+    {
+     "group": "Profile dependencies",
+     "line": 6121,
+     "options": []
+    }
+   ]
+  }
  ]
 }

package/engine/README.md

@@ -355,6 +355,26 @@ Two consequences worth knowing before you build on this:
 
 Results carry the split: `stats.filament_mm_by_tool` (indexed by tool number, one slot per extruder, sums to `filament_mm`) and `stats.filament_mm_purge` (the prime/wipe tower share, already included in the per-tool figures). In the streamed toolpath, `paths[k+3]` encodes `role + tool * 16` — mask with `& 15` for the role and `>>> 4` for the tool.
 
+## SLA parameters
+
+The table above is the FFF kernel's reader. The SLA entry (`slice_sla`) reads its own parameter set, produced
+by `deriveSlaParams(settings)` — unlike `deriveKernelParams` it always emits every key (54 today), filling
+schema/reference-machine defaults, because the SLA keys are not shared with another technology whose defaults
+could disagree. The groups:
+
+| Group | Keys |
+| --- | --- |
+| Layers and exposure | `layer_height`, `initial_layer_height`, `exposure_time`, `initial_exposure_time`, `faded_layers` |
+| Display (doubles as the bed) | `display_width/height`, `display_pixels_x/y`, `display_orientation` (portrait default), `display_mirror_x/y`, `bed_width/depth` |
+| Archive identity (config.ini) | `printer_model`, `printer_variant`, `printer_settings_id`, `sla_print_settings_id`, `sla_material_settings_id`, `material_print_speed` |
+| Supports (upstream `SupportTreeConfig`) | `supports_enable`, `support_tree_type`, `support_pillar_diameter`, `support_head_*`, `support_points_density_relative`, `support_critical_angle`, `support_max_bridge_length`, `support_max_pillar_link_distance`, `support_base_*`, `support_small_pillar_diameter_percent`, `support_pillar_widening_factor`, `support_max_bridges_on_pillar`, `support_max_weight_on_model`, `support_object_elevation`, `support_pillar_connection_mode`, `support_buildplate_only`, `slice_closing_radius` |
+| Pad (upstream `PadConfig`) | `pad_enable`, `pad_brim_size`, `pad_wall_thickness`, `pad_wall_height`, `pad_wall_slope`, `pad_max_merge_distance`, `pad_around_object` (embed — forces zero elevation), `pad_around_object_everywhere`, `pad_object_gap`, `pad_object_connector_width/stride/penetration` |
+| Capability gate | `hollowing_enable` — `true` is refused with `SLA_UNSUPPORTED_HOLLOWING`, never sliced solid |
+
+The result has no G-code: `stats.sla` is `true`, layers carry the same stride-8 segment stream, `support_mesh`
+and `pad_mesh` are triangle soups for the preview, and `stats.lift_layers` (pad + elevation) is what a preview
+must lift the model by.
+
 ## License
 
 AGPL-3.0-or-later (derived from OrcaSlicer). A web app embedding this package must comply with AGPL — including offering its source to network users.

package/engine/examples/sla_headless.mjs

@@ -0,0 +1,51 @@
+// three-slicer SLA (resin) headless example: slice a cube with supports + pad through the public API,
+// then show the typed capability refusal — an unsupported request errors, it never approximates.
+//   run: node packages/engine/examples/sla_headless.mjs
+import { createSlicer } from 'three-slicer'
+import { deriveSlaParams, printerTechnology } from 'three-slicer/settings'
+
+// minimal binary-STL writer for a 10mm cube. Winding matters here, unlike the FFF example: the SLA
+//  support generator reads facet normals to find downward faces, so every face is CCW seen from outside.
+function boxSTL() {
+  const vertices = [[-5,-5,0],[5,-5,0],[5,5,0],[-5,5,0],[-5,-5,10],[5,-5,10],[5,5,10],[-5,5,10]]
+  const faces = [[0,2,1],[0,3,2],[4,5,6],[4,6,7],[0,1,5],[0,5,4],[1,2,6],[1,6,5],[2,3,7],[2,7,6],[3,0,4],[3,4,7]]
+  const buf = Buffer.alloc(84 + faces.length * 50)
+  buf.writeUInt32LE(faces.length, 80)
+  faces.forEach((face, i) => {
+    let off = 84 + i * 50 + 12
+    for (const vi of face) for (const v of vertices[vi]) { buf.writeFloatLE(v, off); off += 4 }
+  })
+  return buf
+}
+const cube = boxSTL()
+
+// A sparse settings map, the same shape the UI holds. printer_technology is what routes to slice_sla.
+const settings = {
+  printer_technology: 'SLA',
+  layer_height: 0.05,
+  exposure_time: 7,
+  supports_enable: true,
+  support_object_elevation: 5,
+  pad_enable: true,
+}
+console.log(`technology: ${printerTechnology(settings)}`)
+
+const slicer = await createSlicer()
+const params = deriveSlaParams(settings)     // fills display/support/pad defaults (SL1 reference machine)
+
+// (a) SLA slice — no G-code; masks, meshes and resin stats instead.
+const r = slicer.sliceSla(cube, params)
+if (r.error) { console.error('FAIL', r.error); process.exit(1) }
+console.log(`sla   : layers=${r.stats.layers} (lift=${r.stats.lift_layers}) points=${r.stats.support_points}`
+  + ` pad_layers=${r.stats.pad_layers} resin=${r.stats.resin_ml.toFixed(2)}ml`)
+console.log(`meshes: support=${r.support_mesh.length / 9} tris, pad=${r.pad_mesh.length / 9} tris`)
+
+// (b) the capability gate: hollowing is not ported, so the request is REFUSED with a stable code —
+//     a solid slice answered to a hollow request would be a mislabeled print.
+const refused = slicer.sliceSla(cube, deriveSlaParams({ ...settings, hollowing_enable: true }))
+console.log(`gate  : ${refused.error}`)
+
+if (r.stats.support_points > 0 && r.stats.pad_layers > 0 && /^SLA_UNSUPPORTED_HOLLOWING/.test(refused.error ?? ''))
+  console.log('OK — SLA slices headlessly via the public API')
+else { console.error('FAIL'); process.exit(1) }
+slicer.dispose()

package/engine/index.d.ts

@@ -86,6 +86,9 @@ export interface PaintArgs {
 }
 export interface Slicer {
   slice(stl: ArrayBuffer | Uint8Array, params: object | string, cb?: SliceCallbacks): SliceResult
+  /** SLA (resin) slice — no G-code: mask segment streams per layer, support/pad meshes, resin stats.
+   *  Params from deriveSlaParams(); a refused capability (e.g. hollowing) sets `error` to its typed code. */
+  sliceSla(stl: ArrayBuffer | Uint8Array, params: object | string, onProgress?: (done: number, total: number) => void): SliceResult
   paintPrepare(stl: ArrayBuffer | Uint8Array): number
   paint(args: PaintArgs): { enf: number; blk: number }
   paintClear(): void

package/engine/index.js

@@ -31,6 +31,12 @@ export async function createSlicer() {
       try { return M.slice(u8(stl), p, onProgress || (() => {})) }
       finally { if (onLayer) M.clear_layer_sink() }
     },
+    // SLA (resin) slice: no G-code — layers carry the mask segment stream, support_mesh/pad_mesh the preview
+    //  soups, stats the resin figures and lift_layers. Same params-object-or-string contract as slice().
+    sliceSla(stl, params, onProgress) {
+      const p = typeof params === 'string' ? params : JSON.stringify(params || {})
+      return M.slice_sla(u8(stl), p, onProgress || (() => {}))
+    },
     paintPrepare(stl) { M.selector_prepare(u8(stl)); return M.selector_facet_count() },
     paint(a) {
       M.selector_paint(a.facet, a.hx, a.hy, a.hz, a.cx, a.cy, a.cz, a.radius, a.enforcer)

package/engine/src/client.js

@@ -14,14 +14,19 @@
 // replies exactly once, so a FIFO of pending requests is enough to match a reply to its caller — the protocol
 // carries no request ids and does not need them.
 import { engineWorkerURL } from '../index.js'
+import { parseSlaJob, SlaRequestError } from './sla_request.js'
+
+export { SLA_CAPABILITIES, SLA_JOB_VERSION, SlaRequestError } from './sla_request.js'
 
 // Which reply type ends which command. A slice has no cmd (that is what selects slicing) and ends on 'done'.
 const REPLY_OF = {
   warmup: 'warm', prepare: 'prepared', paint: 'painted', erase: 'painted', clear: 'painted',
-  importPaint: 'painted', exportPaint: 'paintExport', overlay: 'overlay', slice: 'done',
+  importPaint: 'painted', exportPaint: 'paintExport', overlay: 'overlay', slice: 'done', sla: 'done',
 }
 
 const asBuffer = (data) => (data instanceof ArrayBuffer ? data : data?.buffer ?? data)
+const slaTransferables = (job) => job.objects.flatMap(object => [object, ...(object.modifierVolumes ?? [])])
+  .map(record => asBuffer(record.stl)).filter(buffer => buffer instanceof ArrayBuffer)
 
 /**
  * @param {Worker} [worker] an existing worker to drive. Omit to create one — which only works in a browser,
@@ -49,7 +54,9 @@ export function createSlicerClient(worker = new Worker(engineWorkerURL(), { type
       return
     }
     pending.shift()
-    if (data.type === 'error') { head.reject(new Error(data.error)); return }
+    if (data.type === 'error') {
+      head.reject(data.code ? new SlaRequestError(data.code, data.error) : new Error(data.error)); return
+    }
     if (data.type !== head.expect) { head.reject(new Error(`expected '${head.expect}', got '${data.type}'`)); return }
     // What the layer messages accumulated, if this caller did not take them itself.
     if (data.type === 'done' && head.layers.length) data.assembled = { gcode: head.chunks.join(''), layers: head.layers }
@@ -92,6 +99,28 @@ export function createSlicerClient(worker = new Worker(engineWorkerURL(), { type
       return { ...result, gcode: reply.assembled.gcode, layers: reply.assembled.layers }
     },
 
+    /**
+     * Legacy single-object SLA slice: per-layer closed contours instead of toolpaths. It uses WASM when available;
+     * its contour-only JS fallback rejects requested supports and pads. Same streaming shape as slice(): `onLayer` hands you the layers and the result
+     * carries stats only; without it they are assembled onto the result.
+     */
+    async sliceSla(stl, params, { onProgress, onLayer } = {}) {
+      const buffer = asBuffer(stl)
+      const entry = { cmd: 'sla', stl: buffer, params: typeof params === 'string' ? params : JSON.stringify(params ?? {}) }
+      const reply = await send(entry, { transfer: [buffer], onProgress, onLayer })
+      const result = reply.result ?? {}
+      if (!reply.assembled) return result
+      return { ...result, layers: reply.assembled.layers }
+    },
+
+    async sliceSlaJob(job, { onProgress, onLayer } = {}) {
+      const parsed = parseSlaJob(job)
+      const reply = await send({ cmd: 'slaJob', job: parsed }, { transfer: slaTransferables(parsed), onProgress, onLayer })
+      const result = reply.result ?? {}
+      if (!reply.assembled) return result
+      return { ...result, layers: reply.assembled.layers }
+    },
+
     /** Register a mesh for painting. `keepPaint` carries existing marks across a move. */
     prepare: (stl, { keepPaint = false } = {}) => {
       const buffer = asBuffer(stl)