three-slicer 0.3.2 → 0.3.4

package/engine/src/settings.js

@@ -32,6 +32,19 @@ export function resinSettingsFor(name) {
   return out
 }
 
+// One row of a preset table -> the settings it applies. Multi-line text (custom G-code, notes) is stored once in
+//  `text` and a row holds its index, for the columns listed in `textKeys` (web/extract_all.py _intern_text).
+function rowSettings(data, row) {
+  const textKeys = new Set(data.textKeys ?? [])
+  const out = {}
+  data.keys.forEach((key, i) => {
+    if (row[i] == null) return
+    if (textKeys.has(key)) { out[key] = data.text[row[i]]; return }
+    out[key] = row[i]
+  })
+  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
@@ -46,9 +59,7 @@ export function processPresets() {
     settingsFor: (presetName) => {
       const preset = data.presets.find(([name]) => name === presetName)
       if (!preset) return null
-      const row = data.sets[preset[1]], out = {}
-      data.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-      return out
+      return rowSettings(data, data.sets[preset[1]])
     },
   }))
   return processesPromise
@@ -84,40 +95,41 @@ export function filamentPresets() {
       settingsFor: (presetName) => {
         const preset = data.presets.find(([name]) => name === presetName)
         if (!preset) return null
-        const row = data.sets[preset[1]], out = {}
-        data.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-        return out
+        return rowSettings(data, data.sets[preset[1]])
       },
     }
   })
   return filamentsPromise
 }
 
+// `parents` holds the abstract machine presets (`instantiation: false`): never offered by the picker, but a user
+//  preset file names one as its `inherits`, so printerSettings has to resolve it by name.
 function printerEntry(profileName) {
   for (const models of Object.values(printers.byVendor)) {
     const entry = models[profileName]
     if (entry) return entry
   }
-  return null
+  return printers.parents?.[profileName] ?? null
 }
 
 /** The settings a printer profile applies, ready to merge into the settings map. `null` when unknown. */
 export function printerSettings(profileName) {
   const entry = printerEntry(profileName)
   if (!entry) return null
-  const row = printers.sets[entry[1]]
-  const out = {}
-  printers.keys.forEach((key, i) => { if (row[i] != null) out[key] = row[i] })
-  return out
+  return rowSettings(printers, printers.sets[entry[1]])
 }
 
 /** The vendor's recommended process preset for a printer, or '' when the profile names none. */
 export function printerDefaultPreset(profileName) { return printerEntry(profileName)?.[3] ?? '' }
 
+/** The bed type the printer's model defaults to ("Textured PEI Plate"), or '' when the model names none. Upstream
+ *  writes it to curr_bed_type when the printer is picked; the first-layer bed temperature follows it. */
+export function printerDefaultBedType(profileName) { return printerEntry(profileName)?.[4] ?? '' }
+
 // ---- The catalog as one object -------------------------------------------------------------------------------
-// What `three-slicer-viewer`'s `<Viewport catalog>` takes: the nine lookups above, bundled. The permissive package
+// What `three-slicer-viewer`'s `<Viewport catalog>` takes: the ten lookups above, bundled. The permissive package
 //  ships no catalog (these are OrcaSlicer's profile bundles); `three-slicer/viewer` passes this one by default.
 export const bundledCatalog = Object.freeze({
-  printerKeys, printerSettings, printersByVendor, printerTechByVendor, printerDefaultPreset,
+  printerKeys, printerSettings, printersByVendor, printerTechByVendor, printerDefaultPreset, printerDefaultBedType,
   processPresets, filamentPresets, resinCatalog, resinSettingsFor,
 })

package/engine/src/slicer.worker.js

@@ -1,6 +1,7 @@
 // Runs slicing off the main thread (non-blocking UI) plus stage-30 layer streaming.
 // Vite module worker: new Worker(new URL('./slicer.worker.js', import.meta.url), { type: 'module' }).
-// SINGLE_FILE means the wasm is inlined into slicer_core.js -> no external fetch from the worker either.
+// SINGLE_FILE means the wasm is inlined into slicer_core.js -> no external fetch from the worker either. The mt glue
+//  loads slicer_core.mt.wasm from beside itself instead: its pthread workers each parse the glue (build.sh, mt link).
 //
 // Stage 30 (OOM tolerance): set_layer_sink lets the kernel emit layers as it produces them; each is transferred to main
 //  immediately (Float32Array buffers moved -> the worker copy is released at once) and the kernel frees that layer buffer
@@ -18,6 +19,9 @@
 import { assertLegacySlaFallback, parseSlaJob } from './sla_request.js'
 import { withSliceWarnings } from './warnings.js'
 import { withSliceThroughput } from './throughput.js'
+import { acquireContourDevice, makeContourGpu } from './contour_gpu.js'
+import { kernelHasContourPhase, sliceWithContourGpu } from './contour_slice.js'
+import { FILL_TOOLS } from 'three-slicer-viewer/paint'
 
 // The kernel parses `params` as JSON text, so the raw protocol used to require a string — while the direct handle
 //  and createSlicerClient both take an object and stringify it for you. One object, two shapes, and the difference
@@ -49,6 +53,42 @@ const loadCore = async () => {
 
 let modPromise = null
 
+// The contour union on the GPU (contour_gpu.js), made on the first slice that asks for it. `false` once this worker
+//  found no usable device, so the next slice does not ask again; a lost device is asked for again.
+let contourGpu = null
+const contourGpuOf = async () => {
+  if (contourGpu !== null) return contourGpu
+  try {
+    const device = await acquireContourDevice(self.navigator?.gpu)
+    if (!device) { contourGpu = false; return contourGpu }
+    contourGpu = await makeContourGpu(device)
+    device.lost.then(() => { contourGpu = null })
+  } catch (error) {
+    say('warn', '[slicer.worker] contour GPU unavailable:', error)
+    contourGpu = false
+  }
+  return contourGpu
+}
+// A slice's kernel call, through the GPU when the host asked for it (`gpu: true`) and this worker can.
+const runSlice = async (Module, d, onProgress) => {
+  const stl = new Uint8Array(d.stl), text = paramsText(d.params)
+  if (!d.gpu) return Module.slice(stl, text, onProgress)
+  const cpu = (reason) => {
+    const result = Module.slice(stl, text, onProgress)
+    if (result?.stats) { result.stats.contour_engine = 'cpu'; result.stats.contour_engine_reason = reason }
+    return result
+  }
+  if (!kernelHasContourPhase(Module)) return cpu('this kernel build has no contour phase')
+  const gpu = await contourGpuOf()
+  if (!gpu) return cpu('no WebGPU device')
+  const canceled = () => { const flag = Module.cancel_flag_view?.(); return !!flag && flag[0] !== 0 }
+  // The mesh route (the GPU cuts and chains the layers too) only on the single-threaded kernel. Measured on a 3M-facet
+  //  model (node, Dawn): st's own cut and chain is 419-442 ms against 34-154 ms of mesh hand-over + 64-153 ms on the GPU;
+  //  mt's is 64-77 ms on its threads, and the mesh route came out 20 ms slower in the front and 0.02-0.18 s in the slice.
+  const meshRoute = kernelKind === 'st'
+  return sliceWithContourGpu({ kernel: Module, contourGpu: gpu, stl, paramsText: text, onProgress, canceled, meshRoute })
+}
+
 // Stage 20 painting states = upstream's EnforcerBlockerType (see packages/wasm-core/selector_bridge.h):
 //  0=NONE, 1=ENFORCER(==Extruder1), 2=BLOCKER(==Extruder2), 3..16=Extruder3..Extruder16.
 // The kernel exposes both a boolean pair (selector_paint/…_count/…_overlay) and integer-state twins (…_state);
@@ -110,7 +150,6 @@ const strokeFrom = (message) =>
 // The fill modes the kernel's fill_preview takes (selector_bridge.h FILL_*), by the tool name the protocol uses.
 const FILL_PREVIEW_MODE = { smart: 0, bucket: 1, triangle: 2 }
 
-const FILL_TOOLS = new Set(['smart', 'bucket', 'triangle'])
 const applyFill = (Module, message, state) => {
   const angle = Number.isFinite(message.angle) ? message.angle : 30
   if (message.tool === 'smart') {
@@ -138,7 +177,14 @@ const paintedReply = (Module, message, paintedState) => {
   return answer
 }
 
-self.onmessage = async (e) => {
+// One message at a time. A GPU slice awaits the device between its two kernel calls, and a message handled in that
+//  gap would reach a kernel that is holding another slice's loops.
+let messageChain = Promise.resolve()
+self.onmessage = (e) => {
+  messageChain = messageChain.then(() => handleMessage(e)).catch((error) => say('warn', '[slicer.worker] message failed:', error))
+  return messageChain   // a caller that drives the handler directly (tests) can await its message
+}
+const handleMessage = async (e) => {
   const d = e.data
   // Every reply to a request that carried a `requestId` carries it back, the error reply included — so a caller
   //  waiting on one request cannot take another request's answer (or another command's error) for its own. A
@@ -375,7 +421,7 @@ self.onmessage = async (e) => {
     // Timed around the kernel call INCLUDING the layer sink, which posts each layer to the main thread from inside
     //  it — that transfer is part of what a streamed slice costs and leaving it out would flatter the number.
     const started = performance.now()
-    try { r = Module.slice(new Uint8Array(d.stl), paramsText(d.params), onProgress) }
+    try { r = await runSlice(Module, d, onProgress) }
     finally { Module.clear_layer_sink() }
     if (r && r.error) { reply({ type: 'error', error: String(r.error) }); return }
     // streamed=true -> g-code/layers were already emitted as 'layer' (result holds stats only). batch/MM keep them in result.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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",
@@ -134,6 +134,6 @@
     "clipping"
   ],
   "dependencies": {
-    "three-slicer-viewer": "0.3.2"
+    "three-slicer-viewer": "0.3.4"
   }
 }

package/types/data/filaments.js.d.ts

@@ -11,10 +11,15 @@ export type FilamentRow = (unknown | null)[]
 export type FilamentEntry = [string, number, string, string]
 
 export interface FilamentData {
-  /** Option keys, in column order — the kernel keys that at least one filament profile sets */
+  /** Option keys, in column order — the kernel keys and custom-G-code keys that at least one filament profile sets */
   keys: string[]
   /** Deduplicated value rows */
   sets: FilamentRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** Preset entries, indexed by the numbers in `byPrinter` / `defaultsByModel` */
   presets: FilamentEntry[]
   /** Printer profile name (as keyed in printers.json) -> indices into `presets` — the compatible materials */

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

@@ -7,16 +7,26 @@
 /** 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, default process preset]` */
-export type PrinterEntry = [string, number, string, string]
+/** `[nozzle diameter, index into sets, model name without the nozzle suffix, default process preset,
+ *  the model's default bed type ('' when none)]` — SLA entries carry the first four */
+export type PrinterEntry = [string, number, string, string, string?]
 
 export interface PrinterData {
-  /** Option keys, in column order — the same keys the settings panel edits */
+  /** Option keys, in column order — the same keys the settings panel edits, including the custom G-code and the
+   *  options it reads (issue 63) */
   keys: string[]
   /** Deduplicated value rows */
   sets: PrinterRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** Vendor -> printer profile name -> entry */
   byVendor: Record<string, Record<string, PrinterEntry>>
+  /** The abstract machine presets (`instantiation: false`) by name: not offered for picking, but resolvable as
+   *  the parent a user preset file `inherits` */
+  parents?: Record<string, PrinterEntry>
 }
 
 declare const printers: PrinterData

package/types/data/processes.js.d.ts

@@ -7,10 +7,15 @@
 export type ProcessRow = (unknown | null)[]
 
 export interface ProcessData {
-  /** Option keys, in column order — the keys the kernel consumes, read out of engine/src/settings.js */
+  /** Option keys, in column order — the keys the kernel consumes plus the ones its custom G-code reads (extract_all.py _preset_keys) */
   keys: string[]
   /** Deduplicated value rows */
   sets: ProcessRow[]
+  /** Columns whose cells are indices into `text` rather than values: the multi-line options (custom G-code, notes),
+   *  stored once because many rows share one. Absent when the table has none. */
+  textKeys?: string[]
+  /** The multi-line values the `textKeys` columns index */
+  text?: unknown[]
   /** `[preset name, index into sets]`, indexed by the numbers in `byPrinter` */
   presets: [string, number][]
   /** Printer profile name -> indices into `presets` */

package/types/settings.d.ts

@@ -17,7 +17,20 @@ export function settingScalar(settings: SlicerSettings | null | undefined, key:
  * ponytail: 53 returned keys, so Record instead of listing each — kernel params are passed straight to slice(),
  * not an API consumers read field by field. Expand it when field access is actually needed.
  */
-export function deriveKernelParams(settings: SlicerSettings | null | undefined, opts?: { plate?: number }): Record<string, unknown>
+export function deriveKernelParams(settings: SlicerSettings | null | undefined, opts?: { plate?: number; objectNames?: string[] }): Record<string, unknown>
+/**
+ * The printable area's lower-left corner and its centre in printer coordinates, from deriveKernelParams' output.
+ * The kernel slices in a plate frame centred on the bed and adds the centre on output, so a stored printer
+ * coordinate (wipe_tower_x/y, a 3mf position, G-code) converts to that frame by subtracting `bedCenter`.
+ */
+export function bedOrigin(params: Record<string, unknown> | null | undefined): { x: number; y: number }
+/** Code of a printer profile setting the template path reads but does not do yet. */
+export const PARTIAL_SUPPORT_CODE: 'PROFILE_PARTIAL_SUPPORT'
+/** The tool change settings a profile sets that the template path does not apply (empty off the template path or
+ *  with one tool), each with what happens instead. */
+export function partialSupport(settings: SlicerSettings | null | undefined, opts?: { toolCount?: number }):
+  { code: 'PROFILE_PARTIAL_SUPPORT'; key: string; effect: string }[]
+export function bedCenter(params: Record<string, unknown> | null | undefined): { x: number; y: number }
 
 /**
  * Clear-then-merge preset application: deletes `keys` (the catalog's own key set) from `settings`, then
@@ -168,6 +181,8 @@ export function printerSettings(profileName: string): SlicerSettings | null
 
 /** The vendor's recommended process preset for that printer, or `''` when the profile names none. */
 export function printerDefaultPreset(profileName: string): string
+/** The bed type the printer's model defaults to, `''` when the model names none — written to `curr_bed_type` on a pick. */
+export function printerDefaultBedType(profileName: string): string
 
 /** The schema keys the kernel's machine limits are read from — for UI that shows which ones are in play. */
 export const machineLimitKeys: string[]

package/types/worker.d.ts

@@ -94,8 +94,11 @@ export type SlicerRequest =
    * stringified for you (it was string-only through 0.2.2, which made this the one call path with a different
    * contract from `createSlicer().slice()` and `createSlicerClient().slice()`).
    * Replies: `progress` and `layer` while it runs, then `done` — or `error`.
+   * `gpu: true` asks the worker to compute the layer contours with WebGPU (src/contour_gpu.js). The worker uses it
+   * when it has a device and the slice reaches the contour union; `done`'s `stats.contour_engine` says what ran
+   * ('gpu', 'cpu' with `contour_engine_reason`, or 'reused' for layers from the stage cache).
    */
-  | { stl: ArrayBuffer; params: string | object }
+  | { stl: ArrayBuffer; params: string | object; gpu?: boolean }
 
 export type SlicerResponse =
   /** `kernel` says which variant loaded: 'mt' under crossOriginIsolated, 'st' otherwise (or after an mt load failure). */