three-slicer 0.1.6 → 0.2.0

package/engine/src/slicer.worker.js

@@ -11,17 +11,26 @@
 // Automatic multithreaded kernel selection: with crossOriginIsolated (sites serving COOP/COEP) it uses mt (-pthread, PASS1
 //  layers in parallel — measured 2.2x), otherwise st (zero-config). The dynamic import makes bundlers emit both as chunks,
 //  but only one is loaded at runtime. On mt init failure (SAB blocked, …) it falls back to st.
+// Which kernel loaded is worth saying once — mt vs st is a 2x difference and the fallback is silent otherwise.
+//  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) }
+
 const loadCore = async () => {
   const isolated = typeof crossOriginIsolated !== 'undefined' && crossOriginIsolated
   if (isolated) {
     try {
       const M = await (await import('./slicer_core.mt.js')).default()
-      console.info('[slicer.worker] core: mt (threads)')
+      say('info', '[slicer.worker] core: mt (threads)')
       return M
-    } catch (e) { console.warn('[slicer.worker] mt load failed — falling back to st:', e) }
+    } catch (e) { say('warn', '[slicer.worker] mt load failed — falling back to st:', e) }
   }
   const M = await (await import('./slicer_core.js')).default()
-  console.info('[slicer.worker] core: st')
+  say('info', '[slicer.worker] core: st')
   return M
 }
 
@@ -108,6 +117,9 @@ const paintedReply = (Module, message, paintedState) => {
 
 self.onmessage = async (e) => {
   const d = e.data
+  // Read before the kernel loads: loadCore() below is what prints, so a `quiet` arriving with the first message
+  //  (the warmup) has to take effect before that call, not after it.
+  if (d.quiet !== undefined) quiet = !!d.quiet
   try {
     // Asking for the painting must not be what LOADS the kernel. Every other command needs it, but if this worker
     //  has never loaded it then selector_prepare has never run either, so there is no painting to report — and
@@ -115,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
@@ -237,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 } : {}) })
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-slicer",
-  "version": "0.1.6",
-  "description": "Browser/WASM 3D-printing slicer reverse-engineered from OrcaSlicer: slicing engine (Arachne walls, tree/grid supports, multi-material), React viewer with GPU toolpath preview, and schema-driven settings UI.",
+  "version": "0.2.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",
   "exports": {
@@ -21,6 +21,10 @@
       "types": "./types/worker.d.ts",
       "default": "./engine/src/slicer.worker.js"
     },
+    "./client": {
+      "types": "./types/client.d.ts",
+      "default": "./engine/src/client.js"
+    },
     "./wasm": {
       "types": "./types/wasm.d.ts",
       "default": "./engine/src/slicer_core.js"
@@ -56,10 +60,12 @@
     "./data/*": {
       "types": "./types/data/*.d.ts",
       "default": "./data/*"
-    }
+    },
+    "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "scripts": {
-    "build": "node types/gen_settings_types.mjs && vite build --config components/vite.config.js && vite build --config viewer/vite.config.js && cp viewer/src/make_worker.js viewer/dist/make_worker.js",
+    "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 && cp viewer/src/make_worker.js viewer/dist/make_worker.js",
     "check": "bash pack_check.sh"
   },
   "peerDependencies": {
@@ -67,6 +73,11 @@
     "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"
@@ -75,18 +86,18 @@
     "engine",
     "!engine/**/.omc",
     "types",
+    "!**/test_*.mjs",
+    "!types/gen_*.mjs",
     "components/dist",
     "viewer/dist",
     "viewer/styles.css",
     "components/styles.css",
-    "data/config-schema.json",
-    "data/ui-tree.json",
-    "data/toggle-rules.json",
-    "data/invalidation-map.json",
-    "data/printers.json",
-    "data/processes.js",
-    "data/filaments.js",
+    "data",
+    "!data/config-schema-builddump.json",
+    "!data/**/.omc",
     "README.md",
+    "CHANGELOG.md",
+    "THIRD-PARTY-NOTICES.md",
     "LICENSE.txt"
   ],
   "repository": {
@@ -99,6 +110,10 @@
     "3d-printing",
     "slicer",
     "gcode",
+    "sla",
+    "resin",
+    "sl1",
+    "msla",
     "stl",
     "wasm",
     "orcaslicer",

package/types/client.d.ts

@@ -0,0 +1,88 @@
+// three-slicer/client — promise wrapper over the worker protocol in three-slicer/worker.
+import type { SliceLayer, SliceResult } from '../engine/index.d.ts'
+import type { BrushArgs, PaintState, PaintTool } from './worker.d.ts'
+import type { SlaJob } from './sla.d.ts'
+
+export type { BrushArgs, PaintState, PaintTool }
+// Value re-exports must not name the .d.ts directly (TS2846) — the .js specifier resolves to sla.d.ts.
+export { SLA_CAPABILITIES, SLA_JOB_VERSION, SlaRequestError } from './sla.js'
+export type * from './sla.d.ts'
+
+export interface ClientSliceCallbacks {
+  onProgress?: (done: number, total: number) => void
+  /** Takes the layers yourself. With it set, the result carries stats only and nothing is buffered here. */
+  onLayer?: (layer: SliceLayer) => void
+}
+
+/** Painted facet counts. `counts` is present only when the call named states. */
+export interface PaintCounts {
+  /** State 1 — the support enforcer, and Extruder 1 */
+  enforcer: number
+  /** State 2 — the support blocker, and Extruder 2 */
+  blocker: number
+  counts?: Record<number, number>
+  /** Facets an importPaint actually applied */
+  applied?: number
+}
+
+export interface PaintOverlays {
+  enforcer: Float32Array
+  blocker: Float32Array
+  overlays?: Record<number, Float32Array>
+}
+
+export interface SlicerClient {
+  /** The worker being driven — for a host that also wants to listen in. */
+  worker: Worker
+
+  /** Load the kernel ahead of the first slice. */
+  warmup(): Promise<void>
+
+  /** `params` may be an object; it is stringified for you, which the raw protocol does not do. */
+  slice(stl: ArrayBuffer | Uint8Array, params: object | string, cb?: ClientSliceCallbacks): Promise<SliceResult>
+
+  /**
+   * Legacy single-object SLA (resin) slice. The JS fallback is contour-only and returns a typed error instead of
+   * silently dropping requested supports or pads. Stats carry `sla: true`, `resin_ml` and `time_estimate` instead of
+   * filament/G-code figures, and no G-code is produced.
+   */
+  sliceSla(stl: ArrayBuffer | Uint8Array, params: object | string, cb?: ClientSliceCallbacks): Promise<SliceResult>
+
+  /** Object-aware SLA job. Objects retain their order, instances and support context for the WASM job bridge. */
+  sliceSlaJob(job: SlaJob, cb?: ClientSliceCallbacks): Promise<SliceResult>
+
+  /** Register a mesh for painting. `keepPaint` carries existing marks across a move; `kept` says whether they survived. */
+  prepare(stl: ArrayBuffer | Uint8Array, opts?: { keepPaint?: boolean }): Promise<{ facets: number; kept: boolean }>
+
+  paint(args: BrushArgs & {
+    state?: PaintState; enforcer?: boolean; tool?: PaintTool
+    angle?: number; cursor?: 'sphere' | 'circle'; states?: PaintState[]
+  }): Promise<PaintCounts>
+
+  /** Back to the default extruder. A separate call, not `paint` with state 0 — see three-slicer/worker. */
+  erase(args: BrushArgs & { tool?: PaintTool; angle?: number; states?: PaintState[] }): Promise<PaintCounts>
+
+  clear(states?: PaintState[]): Promise<PaintCounts>
+  overlay(states?: PaintState[]): Promise<PaintOverlays>
+
+  /** Load a 3mf's painting. Replaces every mark, so run it directly after `prepare`. */
+  importPaint(facets: Int32Array | number[], hex: string, states?: PaintState[]): Promise<PaintCounts>
+  exportPaint(): Promise<{ supported: boolean; facets: number[]; hex: string }>
+
+  /**
+   * Stop the running slice. Works while the worker is blocked in WASM, but the flag lives in a SharedArrayBuffer,
+   * so it exists only on the multithreaded kernel — a cross-origin-isolated page. Returns false when there is no
+   * flag to write; terminate the worker instead.
+   */
+  cancel(): boolean
+
+  /** Kill the worker and reject everything still in flight. */
+  terminate(): void
+}
+
+/**
+ * @param worker an existing worker to drive. Omitted, one is created — browser only, since Node has no global
+ *   `Worker`; in Node use `createSlicer()` from the root entry instead.
+ */
+export function createSlicerClient(worker?: Worker): SlicerClient
+export default createSlicerClient

package/types/components.d.ts

@@ -13,6 +13,16 @@ export interface SettingsPanelProps {
   embedded?: boolean
   /** Replace schema-driven widgets per key (e.g. `{ printable_area: MyBedEditor }`) */
   customWidgets?: Record<string, React.ComponentType<any>>
+  /**
+   * Pins the panel to one builder (optionally one page) and drops the search/group/page/mode chrome, so the form
+   * can be folded into another card. This is how `<Viewport/>`'s `motionPanel` slot is meant to be filled:
+   *
+   * ```jsx
+   * <SettingsPanel settings={settings} setSettings={setSettings} embedded
+   *                only={{ builder: 'TabPrinter::build_kinematics_page' }} />
+   * ```
+   */
+  only?: { builder: string; page?: string }
 }
 
 declare const SettingsPanel: React.FC<SettingsPanelProps>

package/types/data/preset-keys.json.d.ts

@@ -0,0 +1,20 @@
+// preset-keys.json — which option keys belong to which preset type, extracted from upstream's Preset.cpp
+// (`s_Preset_print_options`, `s_Preset_filament_options`, and printer_options() = printer + machine limits +
+// the per-extruder keys from PrintConfig.cpp).
+//
+// Distinct from printers.json's `keys`, which is the 21 columns the kernel reads: that is what a picker needs,
+// this is what writing a preset FILE another slicer will accept needs. Keys the config schema does not define are
+// dropped at extraction — every consumer coerces by schema type, so an untyped key could not be handled anyway.
+// Read it through `presetOptionKeys()` in three-slicer/settings rather than indexing this by hand.
+
+export interface PresetKeyLists {
+  /** Machine preset options — upstream's `Preset::printer_options()` */
+  printer: string[]
+  /** Print (process) preset options */
+  process: string[]
+  /** Filament preset options */
+  filament: string[]
+}
+
+declare const presetKeys: PresetKeyLists
+export default presetKeys

package/types/data/printers.json.d.ts

@@ -7,8 +7,8 @@
 /** A positional row aligned to `keys`; `null` where the profile chain never set that option. */
 export type PrinterRow = (unknown | null)[]
 
-/** `[nozzle diameter, index into sets, model name without the nozzle suffix]` */
-export type PrinterEntry = [string, number, string]
+/** `[nozzle diameter, index into sets, model name without the nozzle suffix, default process preset]` */
+export type PrinterEntry = [string, number, string, string]
 
 export interface PrinterData {
   /** Option keys, in column order — the same keys the settings panel edits */

package/types/data.d.ts

@@ -5,10 +5,12 @@ import type { UIPage } from './data/ui-tree.json.d.ts'
 import type { ToggleGroup } from './data/toggle-rules.json.d.ts'
 import type { InvalidationRule } from './data/invalidation-map.json.d.ts'
 import type { PrinterData, PrinterRow, PrinterEntry } from './data/printers.json.d.ts'
+import type { PresetKeyLists } from './data/preset-keys.json.d.ts'
 import type { ProcessData } from './data/processes.js.d.ts'
 import type { FilamentData, FilamentRow, FilamentEntry } from './data/filaments.js.d.ts'
 
 export type { ConfigOption, UIPage, ToggleGroup, InvalidationRule, PrinterData, PrinterRow, PrinterEntry }
+export type { PresetKeyLists }
 export type { ProcessData, FilamentData, FilamentRow, FilamentEntry }
 
 /** The 907 option definitions */
@@ -21,6 +23,8 @@ export const toggleRules: Record<string, ToggleGroup>
 export const invalidationMap: Record<string, InvalidationRule[]>
 /** Machine limits per printer, from the upstream vendor profiles */
 export const printers: PrinterData
+/** Which option keys belong to which preset type — read it through `presetOptionKeys()` */
+export const presetKeys: PresetKeyLists
 // The two large artifacts load on demand — read them through processPresets()/filamentPresets()
 // in three-slicer/settings rather than decoding the column layout here.
 export function loadProcesses(): Promise<ProcessData>

package/types/settings-keys.d.ts

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by types/gen_settings_types.mjs — DO NOT EDIT.
-// Source: data/config-schema.json (923 keys)
+// Source: data/config-schema.json (976 keys)
 
  /** [x, y] — coPoint family */
 export type Point = [number, number]
@@ -96,6 +96,40 @@ export interface SlicerSettings {
   bottom_surface_fill_order?: 'default' | 'outward' | 'inward'
   /** Bottom surface pattern — This is the line pattern of bottom surface infill, not including bridge infill. */
   bottom_surface_pattern?: 'monotonic' | 'monotonicline' | 'rectilinear' | 'alignedrectilinear' | 'concentric' | 'hilbertcurve' | 'archimedeanchords' | 'octagramspiral'
+  /** Support base diameter — (mm) — Diameter in mm of the pillar base */
+  branchingsupport_base_diameter?: number
+  /** Support base height — (mm) — The height of the pillar base cone */
+  branchingsupport_base_height?: number
+  /** Support base safety distance — (mm) — The minimum distance of the pillar base from the model in mm. Makes sense in zero elevation mode where a gap according to this parameter is inserted between the model and the pad. */
+  branchingsupport_base_safety_distance?: number
+  /** Support on build plate only — Only create support if it lies on a build plate. Don't create support on a print. */
+  branchingsupport_buildplate_only?: boolean
+  /** Critical angle — (°) — The default angle for connecting support sticks and junctions. */
+  branchingsupport_critical_angle?: number
+  /** Pinhead front diameter — (mm) — Diameter of the pointing side of the head */
+  branchingsupport_head_front_diameter?: number
+  /** Head penetration — (mm) — How much the pinhead has to penetrate the model surface */
+  branchingsupport_head_penetration?: number
+  /** Pinhead width — (mm) — Width from the back sphere center to the front sphere center */
+  branchingsupport_head_width?: number
+  /** Max bridge length — (mm) — The max length of a bridge */
+  branchingsupport_max_bridge_length?: number
+  /** Max bridges on a pillar — Maximum number of bridges that can be placed on a pillar. Bridges hold support point pinheads and connect to pillars as small branches. */
+  branchingsupport_max_bridges_on_pillar?: number
+  /** Max pillar linking distance — (mm) — The max distance of two pillars to get linked with each other. A zero value will prohibit pillar cascading. */
+  branchingsupport_max_pillar_link_distance?: number
+  /** Max weight on model — (mm) — Maximum weight of sub-trees that terminate on the model instead of the print bed. The weight is the sum of the lenghts of all branches emanating from the endpoint. */
+  branchingsupport_max_weight_on_model?: number
+  /** Object elevation — (mm) — How much the supports should lift up the supported object. If "Pad around object" is enabled, this value is ignored. */
+  branchingsupport_object_elevation?: number
+  /** Pillar connection mode — Controls the bridge type between two neighboring pillars. Can be zig-zag, cross (double zig-zag) or dynamic which will automatically switch between the first two depending on the distance of the two pillars. */
+  branchingsupport_pillar_connection_mode?: string
+  /** Pillar diameter — (mm) — Diameter in mm of the support pillars */
+  branchingsupport_pillar_diameter?: number
+  /** Pillar widening factor — Merging bridges or pillars into another pillars can increase the radius. Zero means no increase, one means full increase. The exact amount of increase is unspecified and can change in the future. */
+  branchingsupport_pillar_widening_factor?: number
+  /** Small pillar diameter percent — (%) — The percentage of smaller pillars compared to the normal pillar diameter which are used in problematic areas where a normal pilla cannot fit. */
+  branchingsupport_small_pillar_diameter_percent?: number
   /** Bridge — (mm/s² or %) — Acceleration of bridges. If the value is expressed as a percentage (e.g. 50%), it will be calculated based on the outer wall acceleration. */
   bridge_acceleration?: (number | string)[] | (number | string)
   /** External bridge infill direction — (°) — External Bridging angle override. If left to zero, the bridging angle will be calculated automatically for each specific bridge. Otherwise the provided angle will be used according to: - The absolute coordinates - The absolute coordinates + Model rotation: If Align directions to model is enabled - The optimal automatic angle + this value: If 'Relative Bridge Angle' is enabled Use 180° for zero absolute angle. */
@@ -201,6 +235,12 @@ export interface SlicerSettings {
   default_print_profile?: string
   default_sla_material_profile?: string
   default_sla_print_profile?: string
+  /** (s) — Delay after exposure before layer separation. */
+  delay_after_exposure?: number[] | number
+  /** (s) — Sets a fixed pause before an exposure of the new layer starts. This setting is ignored if 'Dynamic delay before exposure' is enabled. */
+  delay_before_exposure?: number[] | number
+  /** (s) — Defines the pause between the separation movement (tilt down, Z-hop) and the return movement (tilt up). Increasing this time allows the resin more time to fully reflood the peeled-off layer. */
+  delay_to_reflood?: number[] | number
   /** Deretraction speed (extruder change) — (mm/s) — Speed for reloading filament into the nozzle when switching extruder. */
   deretract_speed_extruder_change?: number[] | number
   /** Deretraction speed — (mm/s) — Speed for reloading filament into the nozzle. Zero means same speed of retraction. */
@@ -235,6 +275,14 @@ export interface SlicerSettings {
   draft_shield?: 'disabled' | 'enabled'
   /** Fan speed — (%) */
   during_print_exhaust_fan_speed?: number[] | number
+  /** Switches between predefined algorithms that influence how the dynamic delay before exposure function behaves. */
+  dynamic_delay_before_profile?: string[] | string
+  /** Sets the maximum allowed time for waiting for the pressure sensors to stabilize during dynamic delay before exposure. Once this timeout expires, the printer starts exposing the next layer regardless of resin pressure stabilization. */
+  dynamic_delay_before_timeout?: number[] | number
+  /** Switches between predefined algorithms that influence how the dynamic tilt down function behaves. */
+  dynamic_tilt_down_profile?: string[] | string
+  /** Switches between predefined algorithms that influence how the dynamic tilt up function behaves. */
+  dynamic_tilt_up_profile?: string[] | string
   /** Absolute E position — Current position of the extruder axis. Only used with absolute extruder addressing. */
   e_position?: number[] | number
   /** Extra de-retraction — Currently planned extra extruder priming after de-retraction. */
@@ -651,6 +699,8 @@ export interface SlicerSettings {
   help?: boolean
   /** High extruder current on filament swap — It may be beneficial to increase the extruder motor current during the filament exchange sequence to allow for rapid ramming feed rates and to overcome resistance when loading a filament with an ugly shaped tip. */
   high_current_on_filament_swap?: boolean
+  /** High viscosity — (s) — Time of the super slow tilt */
+  high_viscosity_tilt_time?: number
   /** Convert holes to polyholes — Search for almost-circular holes that span more than one layer and convert the geometry to polyholes. Use the nozzle size and the (biggest) diameter to compute the polyhole. See http://hydraraptor.blogspot.com/2011/02/polyholes.html */
   hole_to_polyhole?: boolean
   /** Maximum Polyhole edge count — Maximum number of polyhole edges This setting limits the amount of edges a polyhole can have */
@@ -934,8 +984,12 @@ export interface SlicerSettings {
   material_correction_y?: number
   material_correction_z?: number
   material_density?: number
+  /** SLA print material notes — You can put your notes regarding the SLA print material here. */
+  material_notes?: string
   material_print_speed?: 'slow' | 'fast'
   material_type?: string
+  /** Material UUID (FOR DEBUGGING ONLY) */
+  material_uuid?: string
   material_vendor?: string
   /** Max bridge length — (mm) — This is the maximum length of bridges that don\'t need support. Set it to 0 if you want all bridges to be supported, and set it to a very large value if you don\'t want any bridges to be supported. */
   max_bridge_length?: number
@@ -1206,6 +1260,8 @@ export interface SlicerSettings {
   printhost_user?: string
   /** Between Object G-code — Insert G-code between objects. This parameter will only come into effect when you print your models object by object. */
   printing_by_object_gcode?: string
+  /** Printing temperature — (°C) — This value sets the target printing temperature. The printer will wait for the resin to reach this stable temperature before starting and will maintain it throughout the print. When disabled, the printer ignores the resin's current temperature and begins printing immediately. */
+  printing_temperature?: number
   /** Change extrusion role G-code (process) — This G-code is inserted when the extrusion role is changed. It runs after the machine and filament extrusion role G-code. */
   process_change_extrusion_role_gcode?: string
   /** Purge in prime tower — Purge remaining filament into prime tower. */
@@ -1348,7 +1404,11 @@ export interface SlicerSettings {
   skirt_start_angle?: number
   /** Skirt type — Combined - single skirt for all objects, Per object - individual object skirt. */
   skirt_type?: 'combined' | 'perobject'
+  /** Format of the output SLA archive */
+  sla_archive_format?: string
   sla_material_settings_id?: string
+  /** it_opt->second.label — (it_opt->second.sidetext) — it_opt->second.tooltip */
+  sla_output_precision?: number
   sla_print_settings_id?: string
   /** Slice — Slice the plates: 0-all plates, i-plate i, others-invalid */
   slice?: number
@@ -1441,6 +1501,8 @@ export interface SlicerSettings {
   support_critical_angle?: number
   /** Support critical regions only — Only create support for critical regions including sharp tail, cantilever, etc. */
   support_critical_regions_only?: boolean
+  /** Support only in enforced regions — Only create support if it lies in a support enforcer. */
+  support_enforcers_only?: boolean
   /** Normal support expansion — (mm) — Expand (+) or shrink (-) the horizontal span of normal support. */
   support_expansion?: number
   /** Support fast purge mode — Whether this printer supports fast purge mode with optimized temperature and multiplier. */
@@ -1485,6 +1547,8 @@ export interface SlicerSettings {
   support_max_bridge_length?: number
   support_max_bridges_on_pillar?: number
   support_max_pillar_link_distance?: number
+  /** Max weight on model — (mm) — Maximum weight of sub-trees that terminate on the model instead of the print bed. The weight is the sum of the lenghts of all branches emanating from the endpoint. */
+  support_max_weight_on_model?: number
   /** Support multi bed types — Enable this option if you want to use multiple bed types. */
   support_multi_bed_types?: boolean
   support_object_elevation?: number
@@ -1516,6 +1580,8 @@ export interface SlicerSettings {
   support_threshold_overlap?: number | string
   /** Top Z distance — (mm) — Z gap between the support\'s top and object. */
   support_top_z_distance?: number
+  /** Support tree type — Support tree building strategy */
+  support_tree_type?: string
   /** Type — Normal (auto) and Tree (auto) are used to generate support automatically. If Normal (manual) or Tree (manual) is selected, only support enforcers are generated. */
   support_type?: 'normal(auto)' | 'tree(auto)' | 'normal(manual)' | 'tree(manual)'
   supports_enable?: boolean
@@ -1541,6 +1607,38 @@ export interface SlicerSettings {
   thumbnails?: string
   /** Format of G-code thumbnails — Format of G-code thumbnails: PNG for best quality, JPG for smallest size, QOI for low memory firmware. */
   thumbnails_format?: 'PNG' | 'JPG' | 'QOI' | 'BTT_TFT' | 'COLPIC'
+  /** Number of cycles to split the rest of the tilt down move. */
+  tilt_down_cycles?: number[] | number
+  /** (s) — The delay between tilt-down cycles. */
+  tilt_down_delay?: number[] | number
+  /** (μ-steps/s) — Sets the final speed for the tilt-down separation move. Too high a speed, especially with less viscous resins, can cause resin to splash out of the tank. */
+  tilt_down_finish_speed?: string[] | string
+  /** (μ-steps/s) — Tilt speed used for the rest of the tilt down move. */
+  tilt_down_finish_speed_slx?: string[] | string
+  /** (μ-steps/s) — Sets the initial speed for the tilt-down separation move. A high speed may negatively affect print quality or success, especially with certain resins or delicate geometries, but it speeds up the overall print time. */
+  tilt_down_initial_speed?: string[] | string
+  /** (μ-steps/s) — Tilt speed used for an initial portion of tilt down move. */
+  tilt_down_initial_speed_slx?: string[] | string
+  /** (s) — Delay after the tilt reaches 'tilt_down_offset_steps' position. */
+  tilt_down_offset_delay?: number[] | number
+  /** (μ-steps) — Defines the distance (steps) over which the 'Tilt down initial speed' is applied. Once this distance is covered, the tilt moves at the 'Tilt down finish speed'. Setting to 0 immediately applies the finish speed. Maximum distance varies by printer, typically around 12,000 steps. */
+  tilt_down_offset_steps?: number[] | number
+  /** Number of cycles to split the rest of the tilt-up. */
+  tilt_up_cycles?: number[] | number
+  /** (s) — The delay between tilt-up cycles. */
+  tilt_up_delay?: number[] | number
+  /** (μ-steps/s) — Sets the final speed for the tilt-up return movement. Excessive speed, especially with highly viscous resins, can lead to a loss of print quality, or in extreme cases, tilt motor skipping or damage to the print display. */
+  tilt_up_finish_speed?: string[] | string
+  /** (μ-steps/s) — Tilt speed used for the rest of the tilt-up. */
+  tilt_up_finish_speed_slx?: string[] | string
+  /** (μ-steps/s) — Sets the initial speed for the tilt-up return movement. */
+  tilt_up_initial_speed?: string[] | string
+  /** (μ-steps/s) — Tilt speed used for an initial portion of tilt up move. */
+  tilt_up_initial_speed_slx?: string[] | string
+  /** (s) — Delay after the tilt reaches 'tilt_up_offset_steps' position. */
+  tilt_up_offset_delay?: number[] | number
+  /** (μ-steps) — Defines the distance over which the 'Tilt up initial speed' is applied. After this distance, the tilt moves at the 'Tilt up finish speed'. Setting to 0 immediately applies the finish speed. */
+  tilt_up_offset_steps?: number[] | number
   /** Time cost — (money/h) — The printer cost per hour. */
   time_cost?: number
   /** Timelapse G-code */
@@ -1597,6 +1695,10 @@ export interface SlicerSettings {
   total_wipe_tower_cost?: number
   /** Wipe tower volume — Total filament volume extruded on the wipe tower. */
   total_wipe_tower_filament?: number
+  /** (mm) — An alternative separation move to tilting. After layer exposure, the platform lifts by this distance. A minimum of 5mm is recommended if tilting is disabled. If you use tilting, we suggest 0mm, although a combination of both is possible. */
+  tower_hop_height?: number[] | number
+  /** (mm/s) — Tower speed used for tower raise. */
+  tower_speed?: string[] | string
   /** Travel — (mm/s²) — Acceleration of travel moves. */
   travel_acceleration?: number[] | number
   /** Travel — (mm/s) — Jerk for travel. */
@@ -1649,6 +1751,8 @@ export interface SlicerSettings {
   use_firmware_retraction?: boolean
   /** Use relative E distances — Relative extrusion is recommended when using "label_objects" option. Some extruders work better with this option unchecked (absolute extrusion mode). Wipe tower is only compatible with relative mode. It is recommended on most printers. Default is checked. */
   use_relative_e_distances?: boolean
+  /** Enables or disables the tilting function. If disabled, the layer separation is performed using the 'Tower hop height' parameter. */
+  use_tilt?: boolean[] | boolean
   /** Used filament — Total length of filament used in the print. */
   used_filament?: number
   /** Filament length (meters) — Total filament length used in meters. Replaced with actual value during post-processing. */
@@ -1741,6 +1845,8 @@ export interface SlicerSettings {
   zaa_min_z?: number
   /** Minimize wall height angle — (°) — Reduce the height of top-surface perimeters to match the model edge height. Affects perimeters with a slope less than this angle (degrees). A reasonable value is 35. Set to 0 to disable. */
   zaa_minimize_perimeter_height?: number
+  /** Z compensation — Number of layers to Z correct to avoid cross layer bleed */
+  zcorrection_layers?: number
   /** Current Z-hop — Contains Z-hop present at the beginning of the custom G-code block. */
   zhop?: number
 }