three-slicer-viewer 0.3.3 → 0.3.5

package/src/settings/settings_core.js

@@ -14,7 +14,10 @@ import { leanSchema as schema } from './data.js'
 import { FFF_FALLBACKS, AUTO_LINE_WIDTH, SLA_FALLBACKS, MACHINE_LIMITS, BED_FALLBACK } from './kernel_defaults.js'
 
 export function schemaDefault(key) { return schema[key]?.default }
-export function settingRaw(settings, key) { return (settings && key in settings) ? settings[key] : schemaDefault(key) }
+export function settingRaw(settings, key) {
+  if (settings && key in settings) return settings[key]
+  return schemaDefault(key)
+}
 // Normalize to a scalar ([0] for vectors)
 // A per-extruder column reduced to the single value the kernel's scalar reader wants. The FIRST SET entry, not
 //  literally index 0: the filament card writes one column per extruder and leaves a null wherever that extruder has
@@ -66,8 +69,12 @@ const PASSTHROUGH_NUM = [
   'scarf_joint_flow_ratio', 'outer_wall_flow_ratio', 'inner_wall_flow_ratio', 'sparse_infill_flow_ratio',
   'internal_solid_infill_flow_ratio', 'gap_fill_flow_ratio', 'support_flow_ratio', 'support_interface_flow_ratio',
   'first_layer_flow_ratio',
+  // Added to every Z the G-code writes (upstream's GCodeWriter).
+  'z_offset',
 ]
 const PASSTHROUGH_BOOL = ['independent_support_layer_height',
+  // The machine's E mode and firmware retraction (upstream GCodeWriter), each a printer profile option.
+  'use_relative_e_distances', 'use_firmware_retraction',
   'detect_thin_wall', 'precise_outer_wall', 'only_one_wall_first_layer', 'alternate_extra_wall',
   // thick_bridges picks upstream's round bridge thread; set_other_flow_ratios turns the per-role ratios on.
   'thick_bridges', 'set_other_flow_ratios']
@@ -82,6 +89,28 @@ const PASSTHROUGH_STR = ['wall_sequence', 'wall_direction']
 //  kernel reads its first entry, the wall filament's on the single-material path. filament_max_volumetric_speed caps
 //  every extrusion's speed as upstream does (GCode.cpp:7492).
 const PASSTHROUGH_NUM_VECTOR = ['filament_map', 'filament_density', 'filament_cost', 'gap_infill_speed', 'filament_max_volumetric_speed']
+// Per-role speed, acceleration and jerk, upstream's GCode::_extrude and travel_to (GCode.cpp:7292-7342, :7393-7473,
+//  :8289-8333). Sent under the upstream names, only when the map holds the key (or the map carries a custom G-code,
+//  see followsTemplate). A percent option is resolved against the option upstream takes it as a ratio over
+//  (PrintConfig ratio_over), the second entry. The kernel keeps print_speed for every role it gets no speed for, and
+//  writes no acceleration or jerk at all without default_acceleration / default_jerk.
+const MOTION_KEYS = [
+  ['inner_wall_speed'], ['sparse_infill_speed'], ['internal_solid_infill_speed'], ['top_surface_speed'],
+  ['support_speed'], ['support_interface_speed'], ['initial_layer_infill_speed'], ['skirt_speed'], ['slow_down_layers'],
+  ['small_perimeter_speed', 'outer_wall_speed'], ['small_perimeter_threshold'],
+  ['initial_layer_travel_speed', 'travel_speed'],
+  ['default_acceleration'], ['outer_wall_acceleration'], ['inner_wall_acceleration'], ['top_surface_acceleration'],
+  ['sparse_infill_acceleration', 'default_acceleration'], ['internal_solid_infill_acceleration', 'default_acceleration'],
+  ['bridge_acceleration', 'outer_wall_acceleration'], ['initial_layer_acceleration'], ['travel_acceleration'],
+  ['initial_layer_travel_acceleration', 'travel_acceleration'],
+  ['default_jerk'], ['outer_wall_jerk'], ['inner_wall_jerk'], ['top_surface_jerk'], ['infill_jerk'], ['initial_layer_jerk'],
+  ['travel_jerk'], ['initial_layer_travel_jerk', 'travel_jerk'],
+  // The writer's clamps (GCodeWriter::apply_print_config) and Klipper's ACCEL_TO_DECEL.
+  ['machine_max_acceleration_extruding'], ['machine_max_acceleration_travel'], ['machine_max_acceleration_y'], ['machine_max_jerk_y'],
+  ['accel_to_decel_factor'],
+]
+const MOTION_BOOLS = ['accel_to_decel_enable']
+
 // Material identity. The kernel needs the type for the two decisions upstream makes by material name (PETG's
 //  extra unretract, TPU on the first layer) and the settings id for the footer.
 const PASSTHROUGH_STR_VECTOR = ['filament_type', 'filament_settings_id']
@@ -117,7 +146,8 @@ function coerceScalar(type, value) {
       return asNumber(value.trim().replace(/%$/, ''))
     case 'coFloatOrPercent': case 'coFloatsOrPercents':
       // "50%" must stay a string — the percent IS the value, and Number('50%') is NaN anyway.
-      return value.trim().endsWith('%') ? value : asNumber(value)
+      if (value.trim().endsWith('%')) return value
+      return asNumber(value)
     case 'coPoint': case 'coPoints':
       return parsePoint(value) ?? value
     case 'coPointsGroups':
@@ -135,25 +165,34 @@ function coerceScalar(type, value) {
 //  so there the comma cannot also separate a point's own coordinates — hence two parsers rather than one regex.
 function parsePoint(text) {
   const split = String(text).split('x')
-  const pair = split.length === 2 ? split : String(text).split(',')
+  let pair = split
+  if (split.length !== 2) pair = String(text).split(',')
   if (pair.length !== 2) return null
   const x = Number(pair[0]), y = Number(pair[1])
-  return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null
+  if (Number.isFinite(x) && Number.isFinite(y)) return [x, y]
+  return null
 }
 function parsePointGroup(text) {
   const points = String(text).split(',').map(entry => {
     const [a, b] = entry.split('x')
     const x = Number(a), y = Number(b)
-    return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null
+    if (Number.isFinite(x) && Number.isFinite(y)) return [x, y]
+    return null
   })
-  return points.length && points.every(Boolean) ? points : null
+  if (points.length && points.every(Boolean)) return points
+  return null
 }
 // Number('') is 0 and Number('  ') is 0, neither of which means "the option was set to zero" — an unparsable
 //  value is handed back untouched so the schema default keeps applying instead of a fabricated 0.
 function asNumber(value) {
   if (value.trim() === '') return value
-  const n = Number(value)
-  return Number.isFinite(n) ? n : value
+  return finiteOr(Number(value), value)
+}
+// The number when it is finite, otherwise the fallback. The fallback is evaluated by the caller, so it is only
+//  used for values that are already at hand.
+function finiteOr(number, fallback) {
+  if (Number.isFinite(number)) return number
+  return fallback
 }
 
 /**
@@ -167,7 +206,8 @@ export function normalizeProjectSettings(raw) {
   for (const [key, value] of Object.entries(raw || {})) {
     const type = schema[key]?.type
     if (!type) { skipped.push(key); continue }
-    settings[key] = Array.isArray(value) ? value.map(entry => coerceScalar(type, entry)) : coerceScalar(type, value)
+    if (Array.isArray(value)) settings[key] = value.map(entry => coerceScalar(type, entry))
+    else settings[key] = coerceScalar(type, value)
     applied++
   }
   return { settings, applied, skipped }
@@ -178,17 +218,22 @@ export function normalizeProjectSettings(raw) {
 //  slicer's reader — and normalizeProjectSettings above — expects to coerce FROM. Writing the JS types raw would
 //  hand OrcaSlicer a bool it reads with its own string parser and this package a round-trip that only works here.
 //  Keys the schema does not define are dropped for the same reason normalize drops them: they could not be typed.
-const pointToText = (point) => (Array.isArray(point) ? `${point[0]}x${point[1]}` : String(point))
+const pointToText = (point) => {
+  if (Array.isArray(point)) return `${point[0]}x${point[1]}`
+  return String(point)
+}
 
 function serializeScalar(type, value) {
   if (value == null) return ''
   switch (type) {
     case 'coBool': case 'coBools':
-      return value ? '1' : '0'
+      if (value) return '1'
+      return '0'
     case 'coPoint': case 'coPoints':
       return pointToText(value)
     case 'coPointsGroups':
-      return Array.isArray(value) ? value.map(pointToText).join(',') : String(value)
+      if (Array.isArray(value)) return value.map(pointToText).join(',')
+      return String(value)
     default:
       return String(value)   // numbers, percents, strings, enums — String() is upstream's own spelling for all of them
   }
@@ -201,9 +246,8 @@ export function serializeProjectSettings(settings) {
     const type = schema[key]?.type
     if (!type) continue
     // A coPoint's value IS an array ([x, y]) — the generic array path would serialize its two numbers separately.
-    out[key] = (type !== 'coPoint' && Array.isArray(value))
-      ? value.map(entry => serializeScalar(type, entry))
-      : serializeScalar(type, value)
+    if (type !== 'coPoint' && Array.isArray(value)) out[key] = value.map(entry => serializeScalar(type, entry))
+    else out[key] = serializeScalar(type, value)
   }
   return out
 }
@@ -215,33 +259,111 @@ export function serializeProjectSettings(settings) {
 //  project_settings.config stores (serializeProjectSettings), as one JSON string: the kernel's flat key search
 //  never looks inside a string value, so no key in it can be taken for a kernel parameter the map omits.
 //  The kernel names the same templates in custom_gcode.cpp; test_custom_gcode.mjs checks each key here is expanded there.
-export const CUSTOM_GCODE_KEYS = ['machine_start_gcode', 'machine_end_gcode', 'filament_end_gcode']
+export const CUSTOM_GCODE_KEYS = ['machine_start_gcode', 'machine_end_gcode', 'filament_end_gcode', 'filament_start_gcode',
+  'before_layer_change_gcode', 'layer_change_gcode', 'time_lapse_gcode', 'file_start_gcode', 'change_filament_gcode']
 
-function placeholderConfig(settings, plate) {
+// Whether the map carries a printer's custom G-code — the switch between the kernel's own raw path and upstream's
+//  full semantics, in which every option exists with its schema default (custom_gcode_bridge reads them that way).
+function hasCustomGcode(settings) {
   const hasText = key => [settings?.[key]].flat().some(value => String(value ?? '').trim() !== '')
-  if (!CUSTOM_GCODE_KEYS.some(hasText)) return {}
+  return CUSTOM_GCODE_KEYS.some(hasText)
+}
+
+// What a printer profile asks of a tool change that the template path does not do yet. The slice is not refused —
+//  that would stop every multi-material print — but each key whose value would change the output is named
+//  (PROFILE_PARTIAL_SUPPORT), so the setting is not ignored silently. A key the map omits reads as upstream's schema
+//  default, as the template path does (custom_gcode_bridge).
+// ponytail: tool changes only, the gaps listed in custom_gcode.h. Overhang speeds (no ExtrusionQualityEstimator) are
+//  on in every profile, so a notice for them would show on every slice; add them when the notice has a better home.
+export const PARTIAL_SUPPORT_CODE = 'PROFILE_PARTIAL_SUPPORT'
+const TOOL_CHANGE_GAPS = [
+  { key: 'retract_length_toolchange', isSet: values => values.some(value => parseFloat(value) > 0),
+    effect: 'the retraction before a tool change uses retraction_length' },
+  { key: 'ooze_prevention', isSet: values => values.some(value => value === true || value === 1 || value === '1' || value === 'true'),
+    effect: 'idle tools are not parked at a standby temperature' },
+]
+export function partialSupport(settings, { toolCount = 1 } = {}) {
+  if (!hasCustomGcode(settings) || toolCount < 2) return []
+  const gaps = []
+  for (const gap of TOOL_CHANGE_GAPS) {
+    let value = settings?.[gap.key]
+    if (value == null || value === '') value = schemaDefault(gap.key)
+    if (gap.isSet([value].flat())) gaps.push({ code: PARTIAL_SUPPORT_CODE, key: gap.key, effect: gap.effect })
+  }
+  return gaps
+}
+
+function placeholderConfig(settings, plate, objectNames) {
+  if (!hasCustomGcode(settings)) return {}
   // upstream's Print::get_plate_number_formatted: the 1-based plate, zero-padded to two digits
   const plateNumber = String(plate + 1).padStart(2, '0')
-  return { placeholder_config: JSON.stringify({ ...serializeProjectSettings(settings), $plate_number: plateNumber }) }
+  // $object_names: the printable objects in merge order, from which the kernel derives upstream's object
+  //  placeholders (input_filename_base, first_object_name, num_objects — PrintBase::update_object_placeholders).
+  const objects = {}
+  if (objectNames?.length) objects.$object_names = objectNames.map(name => String(name ?? ''))
+  // The plate type the kernel's own temperatures follow (deriveKernelParams), so the template's bed temperature and
+  //  the second layer's agree about what the bed was heated to.
+  const bedType = { curr_bed_type: settings?.curr_bed_type ?? DEFAULT_BED_TYPE }
+  return { placeholder_config: JSON.stringify({ ...serializeProjectSettings({ ...settings, ...bedType }), $plate_number: plateNumber, ...objects }) }
+}
+
+// The bed temperature option of each plate type, upstream's get_bed_temp_key (PrintConfig.hpp:573). The first-layer
+//  option is the same key with `_initial_layer` (get_bed_temp_1st_layer_key).
+// The plate type a printer gets when it names none: upstream's Plater writes Preset::get_default_bed_type to
+//  curr_bed_type on every printer change, and that falls back to btPEI (Preset.cpp:993). The schema's own default
+//  ("Cool Plate") is never what a sliced printer runs with. hot_plate_temp is also the option this kernel always read.
+export const DEFAULT_BED_TYPE = 'High Temp Plate'
+const BED_TEMP_KEYS = {
+  'Supertack Plate': 'supertack_plate_temp', 'Cool Plate': 'cool_plate_temp', 'Textured Cool Plate': 'textured_cool_plate_temp',
+  'Engineering Plate': 'eng_plate_temp', 'High Temp Plate': 'hot_plate_temp', 'Textured PEI Plate': 'textured_plate_temp',
+}
+
+// A per-extruder column's first entry; a scalar is its own first entry.
+function firstEntryOf(value) {
+  if (Array.isArray(value)) return value[0]
+  return value
+}
+// A per-extruder column as a list; a scalar becomes a one-entry list.
+function asList(value) {
+  if (Array.isArray(value)) return value
+  return [value]
+}
+// The value when it is one of the accepted ones, otherwise the fallback.
+function allowedOr(value, accepted, fallback) {
+  if (accepted.includes(value)) return value
+  return fallback
 }
 
 // Right-panel settings values -> kernel parameters (derived from schema keys)
 //  opts.plate: which plate's entry to take from per-plate array options (wipe_tower_x/y — upstream coFloats,
 //  one entry per plate). Defaults to 0, so every existing caller reads exactly what it always did.
+//  opts.objectNames: the merged objects' names, for the custom G-code's object placeholders (see placeholderConfig).
 export function deriveKernelParams(settings, opts) {
   const plate = opts?.plate ?? 0
+  // With a printer's custom G-code the kernel expands it against every option at its default (custom_gcode_bridge),
+  //  so the machine options it reads itself take their defaults too — otherwise the two halves of one G-code would
+  //  disagree. Without one, the omission rule: only keys the map holds are sent.
+  const followsTemplate = hasCustomGcode(settings)
+  const presentOrTemplate = (key) => followsTemplate || (settings != null && key in settings && settings[key] != null && settings[key] !== '')
   const S = k => settingScalar(settings, k)
   const str = k => String(S(k) ?? FFF_FALLBACKS[k])
-  const num = (k, d = FFF_FALLBACKS[k]) => { const v = Number(S(k)); return Number.isFinite(v) ? v : d }
-  const bool = (k, d = FFF_FALLBACKS[k]) => { const v = settingRaw(settings, k); return typeof v === 'boolean' ? v : (Array.isArray(v) ? !!v[0] : (v == null ? d : !!v)) }
+  const num = (k, d = FFF_FALLBACKS[k]) => finiteOr(Number(S(k)), d)
+  const bool = (k, d = FFF_FALLBACKS[k]) => {
+    const v = settingRaw(settings, k)
+    if (typeof v === 'boolean') return v
+    if (Array.isArray(v)) return !!v[0]
+    if (v == null) return d
+    return !!v
+  }
   // Filament retraction overrides: upstream lets a material override the machine's retraction (TPU wants a
   //  different pull-back than PLA on the same printer). These schema keys are nullable and carry no default of
   //  their own — "unset" means keep the machine value — so this reads the settings map directly rather than
   //  through settingScalar, whose schema fallback would not distinguish the two.
   const override = (filamentKey, machineKey, fallback = FFF_FALLBACKS[machineKey]) => {
     const raw = settings?.[filamentKey]
-    const value = Number(Array.isArray(raw) ? raw[0] : raw)
-    return Number.isFinite(value) ? value : num(machineKey, fallback)
+    const value = Number(firstEntryOf(raw))
+    if (Number.isFinite(value)) return value
+    return num(machineKey, fallback)
   }
 
   let line_width = num('line_width'); if (!line_width) line_width = AUTO_LINE_WIDTH   // 0 = auto
@@ -269,16 +391,21 @@ export function deriveKernelParams(settings, opts) {
   //  style never reached the kernel and every tree style sliced organic.
   const tree_style = { tree_slim: 'slim', tree_strong: 'strong', tree_hybrid: 'hybrid' }[styleRaw]
 
-  // Bed: bounding box of the first rectangle in printable_area
+  // Bed: bounding box of the first rectangle in printable_area. Its lower-left corner is sent only when it is not
+  //  (0,0) — a delta bed centred on the origin, or an offset cartesian one — so every bed that starts at the corner
+  //  keeps exactly the parameters it had (see bedCenter below for what the kernel does with it).
   const pa = settingRaw(settings, 'printable_area')
   let bed_width = BED_FALLBACK.width, bed_depth = BED_FALLBACK.depth
+  const bedOriginParams = {}   // read back through bedOrigin/bedCenter (bed_frame.js)
   if (Array.isArray(pa) && pa.length) {
     const xs = pa.map(p => p[0]), ys = pa.map(p => p[1])
     bed_width = Math.max(...xs) - Math.min(...xs); bed_depth = Math.max(...ys) - Math.min(...ys)
+    if (Math.min(...xs) !== 0) bedOriginParams.bed_origin_x = Math.min(...xs)
+    if (Math.min(...ys) !== 0) bedOriginParams.bed_origin_y = Math.min(...ys)
   }
 
   // Stage 21: per-feature widths — passed to the kernel verbatim (including strings like "120%"). Unedited keys are omitted -> the kernel derives auto(=line_width).
-  //  The 0=auto semantics are handled by the kernel's resolve_lw (upstream Flow formula). Defaults unchanged (no feature set -> line_width).
+  //  The 0=auto semantics are handled by the kernel's resolve_line_width (upstream Flow formula). Defaults unchanged (no feature set -> line_width).
   const widths = {}
   for (const k of ['outer_wall_line_width','inner_wall_line_width','top_surface_line_width',
                    'sparse_infill_line_width','internal_solid_infill_line_width','initial_layer_line_width']) {
@@ -316,9 +443,11 @@ export function deriveKernelParams(settings, opts) {
     //  the plate and disabled the automatic placement entirely — measured as a tower at z=-127.5 on a 200mm bed.
     //  Absent from the map means nobody chose one, and the placement beside the model stands.
     const chosen = (key) => { const raw = settings?.[key]
-      const v = Array.isArray(raw) ? raw[plate] : raw
+      let v = raw
+      if (Array.isArray(raw)) v = raw[plate]
       const n = Number(v)
-      return (v != null && v !== '' && Number.isFinite(n)) ? n : null }
+      if (v != null && v !== '' && Number.isFinite(n)) return n
+      return null }
     const towerX = chosen('wipe_tower_x'), towerY = chosen('wipe_tower_y')
     if (towerX != null) towerSettings.prime_tower_x = towerX
     if (towerY != null) towerSettings.prime_tower_y = towerY
@@ -356,31 +485,80 @@ export function deriveKernelParams(settings, opts) {
     for (const key of PASSTHROUGH_NUM_VECTOR) {
       if (!present(key)) continue
       const raw = settings[key]
-      passthrough[key] = (Array.isArray(raw) ? raw : [raw]).map(entry => { const n = Number(entry); return Number.isFinite(n) ? n : 0 })
+      passthrough[key] = asList(raw).map(entry => finiteOr(Number(entry), 0))
     }
     for (const key of PASSTHROUGH_STR_VECTOR) {
       if (!present(key)) continue
       const raw = settings[key]
-      passthrough[key] = (Array.isArray(raw) ? raw : [raw]).map(entry => String(entry ?? ''))
+      passthrough[key] = asList(raw).map(entry => String(entry ?? ''))
     }
     // support_line_width is coFloatOrPercent, but the kernel reads it with the plain number reader rather than the
-    //  percent-aware jwidth_raw the per-feature widths get. A "120%" would reach strtod as a quoted string and
+    //  percent-aware json_width_raw the per-feature widths get. A "120%" would reach strtod as a quoted string and
     //  parse to 0 == auto — the setting silently ignored. Resolved here against the nozzle, which is the same
-    //  thing jwidth_raw does for the widths that do get the percent-aware reader.
+    //  thing json_width_raw does for the widths that do get the percent-aware reader.
     if (present('support_line_width')) {
       const text = String(settingScalar(settings, 'support_line_width')).trim()
-      const width = text.endsWith('%') ? (parseFloat(text) / 100) * num('nozzle_diameter') : Number(text)
+      let width
+      if (text.endsWith('%')) width = (parseFloat(text) / 100) * num('nozzle_diameter')
+      else width = Number(text)
       if (Number.isFinite(width) && width > 0) passthrough.support_line_width = width
     }
   }
 
+  const motion = {}
+  for (const [key, ratioOver] of MOTION_KEYS) {
+    if (!presentOrTemplate(key)) continue
+    const raw = settingScalar(settings, key)
+    let value = Number(raw)
+    // A percent of another option (ratio_over) resolves against it; a plain coPercent (accel_to_decel_factor "50%")
+    //  is the number itself.
+    if (typeof raw === 'string' && raw.trim().endsWith('%')) {
+      value = parseFloat(raw)
+      if (ratioOver) value = value / 100 * num(ratioOver, 0)
+    }
+    if (Number.isFinite(value)) motion[key] = value
+  }
+  for (const key of MOTION_BOOLS) if (presentOrTemplate(key)) motion[key] = bool(key, false)
+
+  // emit_machine_limits_to_gcode: the machine's limits written into the G-code (upstream print_machine_envelope),
+  //  as the 16 numbers machine_writer.h reads in this order. Sent only when the profile turns it on.
+  const envelope = {}
+  if (presentOrTemplate('emit_machine_limits_to_gcode') && bool('emit_machine_limits_to_gcode', false)) {
+    envelope.machine_envelope = ['machine_max_acceleration_x', 'machine_max_acceleration_y', 'machine_max_acceleration_z',
+      'machine_max_acceleration_e', 'machine_max_speed_x', 'machine_max_speed_y', 'machine_max_speed_z', 'machine_max_speed_e',
+      'machine_max_acceleration_extruding', 'machine_max_acceleration_retracting', 'machine_max_acceleration_travel',
+      'machine_max_jerk_x', 'machine_max_jerk_y', 'machine_max_jerk_z', 'machine_max_jerk_e', 'machine_max_junction_deviation',
+    ].map(key => num(key, 0))
+  }
+
   // Sent only for the three non-organic styles (see tree_style above), so an empty map still derives the same keys.
   const treeStyle = {}
   if (tree_style) treeStyle.tree_style = tree_style
 
+  // Temperatures. The bed's option follows the plate type upstream does (get_bed_temp_key). The first layer's own
+  //  temperatures (nozzle_temperature_initial_layer, <plate>_temp_initial_layer) start the print and the kernel
+  //  switches at the second layer, as upstream's process_layer does (GCode.cpp:5631). With a printer's custom
+  //  G-code the start block's temperatures come from custom_gcode_bridge, which reads every option with its default,
+  //  so the kernel takes the first-layer ones the same way or the two would disagree about what the print started
+  //  at. Without one, only keys the map holds are sent. A map without curr_bed_type is on DEFAULT_BED_TYPE.
+  const bedTempKey = BED_TEMP_KEYS[settings?.curr_bed_type ?? DEFAULT_BED_TYPE] ?? 'hot_plate_temp'
+  const printerCommands = { bed_temp: num(bedTempKey, FFF_FALLBACKS.hot_plate_temp) }
+  if (presentOrTemplate('nozzle_temperature_initial_layer')) printerCommands.first_layer_nozzle_temp = num('nozzle_temperature_initial_layer')
+  if (presentOrTemplate(`${bedTempKey}_initial_layer`)) printerCommands.first_layer_bed_temp = num(`${bedTempKey}_initial_layer`, FFF_FALLBACKS.hot_plate_temp)
+  // Whether one nozzle carries every filament (upstream single_extruder_multi_material): the second-layer switch
+  //  then names no tool and sets only the loaded one.
+  if (presentOrTemplate('single_extruder_multi_material')) printerCommands.single_extruder_multi_material = bool('single_extruder_multi_material', true)
+  // No retraction for a travel inside the infill (upstream GCode::needs_retraction); upstream's default is on.
+  if (presentOrTemplate('reduce_infill_retraction')) printerCommands.reduce_infill_retraction = bool('reduce_infill_retraction', true)
+  // The firmware flavor formats the machine commands (machine_writer.h); upstream's default is "marlin".
+  if (presentOrTemplate('gcode_flavor')) printerCommands.gcode_flavor = str('gcode_flavor')
+  // disable_m73 false: the G-code carries upstream's M73 progress placeholders (finalizeGcode fills them).
+  if (presentOrTemplate('disable_m73')) printerCommands.disable_m73 = bool('disable_m73', false)
+
   const perExtruder = {}
   for (const [param, key, scalar] of [
     ['extruder_nozzle_temp', 'nozzle_temperature', num('nozzle_temperature')],
+    ['extruder_first_layer_temp', 'nozzle_temperature_initial_layer', num('nozzle_temperature_initial_layer')],
     ['extruder_filament_diameter', 'filament_diameter', num('filament_diameter')],
     ['extruder_flow_ratio', 'filament_flow_ratio', num('filament_flow_ratio')],
     ['extruder_retract_length', 'filament_retraction_length', override('filament_retraction_length', 'retraction_length')],
@@ -391,8 +569,7 @@ export function deriveKernelParams(settings, opts) {
     if (!Array.isArray(raw) || raw.length < 2) continue
     perExtruder[param] = raw.map(v => {
       if (v == null || v === '') return scalar        // null survives a JSON round-trip; Number(null) would be 0
-      const n = Number(Array.isArray(v) ? v[0] : v)
-      return Number.isFinite(n) ? n : scalar
+      return finiteOr(Number(firstEntryOf(v)), scalar)
     })
   }
 
@@ -401,6 +578,8 @@ export function deriveKernelParams(settings, opts) {
     ...machine,
     ...passthrough,     // present only for keys the settings map actually holds (see PASSTHROUGH_* above)
     ...treeStyle,
+    ...envelope,
+    ...motion,
     layer_height: num('layer_height'),
     first_layer_height: num('initial_layer_print_height'),
     line_width,
@@ -434,14 +613,15 @@ export function deriveKernelParams(settings, opts) {
     filament_diameter: num('filament_diameter'),
     flow_ratio: num('filament_flow_ratio'),
     nozzle_temp: num('nozzle_temperature'),
-    bed_temp: num('hot_plate_temp'),                        // no bed_temperature key -> hot_plate_temp
+    ...printerCommands,                                       // temperatures (bed by plate type, the first layer's own) and the flavor
     bed_width, bed_depth,
+    ...bedOriginParams,
     bed_height: num('printable_height'),                    // 0 = profile states no ceiling -> kernel skips the check
     // Explicitly-set only: the schema default here is upstream's generic "G28 / G1 Z5" preamble, and falling back
     //  to it would rewrite the emitted G-code for every caller. The kernel keeps its own preamble when these are empty.
     machine_start_gcode: String(settings?.machine_start_gcode ?? ''),
     machine_end_gcode: String(settings?.machine_end_gcode ?? ''),
-    ...placeholderConfig(settings, plate),
+    ...placeholderConfig(settings, plate, opts?.objectNames),
     enable_support: bool('enable_support'),
     support_threshold_angle: num('support_threshold_angle'),
     support_top_z_distance: num('support_top_z_distance'),
@@ -459,7 +639,7 @@ export function deriveKernelParams(settings, opts) {
     support_expansion: num('support_expansion'),
     support_threshold_overlap: (() => { const v = settingRaw(settings, 'support_threshold_overlap')
       if (typeof v === 'string' && v.trim().endsWith('%')) return parseFloat(v) / 100
-      const n = Number(v); return Number.isFinite(n) ? n : 0.5 })(),   // "50%" -> 0.5 (ratio of extrusion width)
+      return finiteOr(Number(v), 0.5) })(),   // "50%" -> 0.5 (ratio of extrusion width)
     support_on_build_plate_only: bool('support_on_build_plate_only'),
     support_interface_bottom_layers: num('support_interface_bottom_layers'),
     ...supportTools,                                            // present only when a support extruder is mapped (see above)
@@ -487,7 +667,7 @@ export function deriveKernelParams(settings, opts) {
     reduce_crossing_wall: bool('reduce_crossing_wall'),
     max_volumetric_extrusion_rate_slope: num('max_volumetric_extrusion_rate_slope'),
     // Stage 7: wall generator classic|arachne (arachne = the real ported OrcaSlicer WallToolPaths, variable width)
-    wall_generator: (str('wall_generator') === 'arachne') ? 'arachne' : 'classic',
+    wall_generator: allowedOr(str('wall_generator'), ['arachne'], 'classic'),
     // support_density has no matching schema key, so the kernel default (0.15) is used; scarf_length likewise uses the kernel default (10mm)
   }
 }
@@ -498,7 +678,8 @@ export function deriveKernelParams(settings, opts) {
 //  path runs. The schema already carries the key (inherited from the upstream lineage), so an imported preset
 //  that names a resin printer routes itself.
 export function printerTechnology(settings) {
-  return String(settingRaw(settings, 'printer_technology') ?? 'FFF').toUpperCase() === 'SLA' ? 'SLA' : 'FFF'
+  if (String(settingRaw(settings, 'printer_technology') ?? 'FFF').toUpperCase() === 'SLA') return 'SLA'
+  return 'FFF'
 }
 
 // SLA settings provenance table. Rows come from the schema's `defined_in` marker so a new resin option cannot
@@ -513,13 +694,12 @@ const SLA_SETTING_OVERRIDES = {
 
 const SLA_SCHEMA_ROWS = Object.fromEntries(Object.entries(schema)
   .filter(([key, meta]) => key === 'printer_technology' || String(meta.defined_in ?? '').includes('sla_'))
-  .map(([key, meta]) => [key, {
-    source: 'config-schema.json',
-    omission: 'schema-default',
-    default: meta.default,
-    ...(meta.enum_values ? { enum: [...meta.enum_values] } : {}),
-    provenance: `${meta.defined_in}:${meta.line}`,
-  }]))
+  .map(([key, meta]) => {
+    const row = { source: 'config-schema.json', omission: 'schema-default', default: meta.default }
+    if (meta.enum_values) row.enum = [...meta.enum_values]
+    row.provenance = `${meta.defined_in}:${meta.line}`
+    return [key, row]
+  }))
 
 export const SLA_SETTING_CONTRACT = Object.freeze(Object.fromEntries(
   Object.entries({ ...SLA_SCHEMA_ROWS, ...SLA_SETTING_OVERRIDES }).map(([key, row]) => [key, Object.freeze({
@@ -535,27 +715,40 @@ export const slaSettingKeys = Object.freeze(Object.keys(SLA_SETTING_CONTRACT))
 //  and its empty-map key count is a pinned invariant — this one feeds the JS contour slicer and owes bytes to
 //  nobody yet. Keys the schema does not define (the resin display's pixel grid, the per-layer height override)
 //  are read from the map directly, so they follow the same omission-friendly rule: absent means the default.
+// The number when it is finite and above zero, otherwise the fallback.
+function positiveOr(number, fallback) {
+  if (Number.isFinite(number) && number > 0) return number
+  return fallback
+}
+// The number when it is finite and not negative (zero is legal), otherwise the fallback.
+function nonNegativeOr(number, fallback) {
+  if (Number.isFinite(number) && number >= 0) return number
+  return fallback
+}
+// A flag whose absence means on.
+function trueUnlessSet(value) {
+  if (value === undefined) return true
+  return !!value
+}
 export function deriveSlaParams(settings) {
   const S = k => settingScalar(settings, k)
-  const num = (k, d = SLA_FALLBACKS[k]) => { const v = Number(S(k)); return Number.isFinite(v) && v > 0 ? v : d }
+  const num = (k, d = SLA_FALLBACKS[k]) => positiveOr(Number(S(k)), d)
 
   // Read from the MAP, not through the schema fallback: the key is shared with FFF and its schema default is that
   //  technology's opinion (0.2mm) — four resin layers thick. Absent means the resin default here.
   const rawLayerHeight = settings?.layer_height
-  const mapLayerHeight = Number(Array.isArray(rawLayerHeight) ? rawLayerHeight[0] : rawLayerHeight)
-  const layer_height = Number.isFinite(mapLayerHeight) && mapLayerHeight > 0 ? mapLayerHeight : SLA_FALLBACKS.layer_height
+  const mapLayerHeight = Number(firstEntryOf(rawLayerHeight))
+  const layer_height = positiveOr(mapLayerHeight, SLA_FALLBACKS.layer_height)
   // Zero is a legal fade count (no fade band), so this one cannot go through the positives-only reader.
   const fadedRaw = Number(S('faded_layers'))
   const requestedSupportTree = String(S('support_tree_type') ?? 'default').toLowerCase()
-  const support_tree_type = ['default', 'branching', 'organic'].includes(requestedSupportTree)
-    ? requestedSupportTree
-    : 'default'
+  const support_tree_type = allowedOr(requestedSupportTree, ['default', 'branching', 'organic'], 'default')
   return {
     layer_height,
     initial_layer_height: num('initial_layer_height', layer_height),
     exposure_time: num('exposure_time'),
     initial_exposure_time: num('initial_exposure_time'),
-    faded_layers: Number.isFinite(fadedRaw) && fadedRaw >= 0 ? fadedRaw : 10,
+    faded_layers: nonNegativeOr(fadedRaw, 10),
     // The physical display and its pixel grid — what turns millimetres into raster pixels at export time.
     //  Fallbacks are the SL1's own panel, the reference machine of the format this exports to.
     display_width: num('display_width'),
@@ -564,8 +757,8 @@ export function deriveSlaParams(settings) {
     display_pixels_y: num('display_pixels_y'),
     // Panel mounting: the whole SL1 family is portrait with X mirrored (projection through the vat floor);
     //  the raster writer swaps the image axes for portrait exactly like upstream SL1.cpp create_raster.
-    display_orientation: String(S('display_orientation') ?? 'portrait') === 'landscape' ? 'landscape' : 'portrait',
-    display_mirror_x: settingRaw(settings, 'display_mirror_x') === undefined ? true : !!settingRaw(settings, 'display_mirror_x'),
+    display_orientation: allowedOr(String(S('display_orientation') ?? 'portrait'), ['landscape'], 'portrait'),
+    display_mirror_x: trueUnlessSet(settingRaw(settings, 'display_mirror_x')),
     display_mirror_y: !!settingRaw(settings, 'display_mirror_y'),
     // SL1 archive identity fields (config.ini): written as-is, empty when the host never set a named
     //  profile — the same thing upstream produces then. material_print_speed defaults to 'fast', the value
@@ -606,23 +799,23 @@ export function deriveSlaParams(settings) {
     //  percent sign is stripped here; widening factor and base safety distance are legally ZERO (zero safety
     //  falls back to the kernel's own safety_distance), so neither can go through the positives-only reader.
     support_small_pillar_diameter_percent:
-      (() => { const v = Number(String(S('support_small_pillar_diameter_percent') ?? '').replace('%', '')); return Number.isFinite(v) && v > 0 ? v : 50 })(),
+      positiveOr(Number(String(S('support_small_pillar_diameter_percent') ?? '').replace('%', '')), 50),
     support_pillar_widening_factor:
-      (() => { const v = Number(S('support_pillar_widening_factor')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+      nonNegativeOr(Number(S('support_pillar_widening_factor')), 0),
     support_base_safety_distance:
-      (() => { const v = Number(S('support_base_safety_distance')); return Number.isFinite(v) && v >= 0 ? v : 1 })(),
+      nonNegativeOr(Number(S('support_base_safety_distance')), 1),
     support_max_bridges_on_pillar: num('support_max_bridges_on_pillar'),
     support_max_weight_on_model: num('support_max_weight_on_model'),
     // The generator's input slices are gap-closed with this radius, exactly like upstream slice_mesh_ex.
     slice_closing_radius: num('slice_closing_radius'),
-    support_object_elevation: (() => { const v = Number(S('support_object_elevation')); return Number.isFinite(v) && v >= 0 ? v : 5 })(),
+    support_object_elevation: nonNegativeOr(Number(S('support_object_elevation')), 5),
     support_pillar_connection_mode: String(S('support_pillar_connection_mode') ?? 'dynamic'),
     // The pad (upstream make_pad_cfg): wall height is legally ZERO (flat pad, no cavity), so it cannot go
     //  through the positives-only reader.
     pad_brim_size: num('pad_brim_size'),
     pad_wall_thickness: num('pad_wall_thickness'),
     pad_wall_height:
-      (() => { const v = Number(S('pad_wall_height')); return Number.isFinite(v) && v >= 0 ? v : 0 })(),
+      nonNegativeOr(Number(S('pad_wall_height')), 0),
     pad_wall_slope: num('pad_wall_slope'),
     pad_max_merge_distance: num('pad_max_merge_distance'),
     pad_around_object: !!settingRaw(settings, 'pad_around_object'),

package/types/gcode.d.ts

@@ -9,6 +9,13 @@ export interface GcodeLayer {
   widths: Float32Array
 }
 
+/**
+ * Fills the placeholders a slice leaves for its finished estimate, as upstream's GCodeProcessor post-process does:
+ * the M73 progress lines (`;_GP_FIRST_LINE_M73_PLACEHOLDER` / `;_GP_LAST_LINE_M73_PLACEHOLDER`, one M73 per layer
+ * start) and file_start_gcode's `@PRINT_TIME_SEC@` / `@USED_FILAMENT_LENGTH@`. A G-code without them is returned as is.
+ */
+export function finalizeGcode(gcode: string, stats: { time_estimate?: number; filament_mm?: number; layer_times?: number[] } | null | undefined): string
+
 export interface ParseGcodeResult {
   layers: GcodeLayer[]
   stats: {
@@ -53,3 +60,9 @@ export interface ParseGcodeOptions {
  * Recovery is lossy where G-code carries no data: unknown roles become wall(1), widths are derived from E.
  */
 export function parseGcode(text: string, opts?: ParseGcodeOptions): ParseGcodeResult
+
+/**
+ * A slice as it is shown: its exported G-code parsed back (start and end G-code extrusions included),
+ * moved from printer coordinates into the slice's plate-local frame by taking the bed centre off.
+ */
+export function previewFromGcode(gcode: string, opts?: { center?: { x: number; y: number }; filamentDiameter?: number; layerHeight?: number }): ParseGcodeResult

package/types/settings.d.ts

@@ -16,7 +16,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

package/types/toolpath.d.ts

@@ -39,6 +39,7 @@ export interface SegmentMeta {
 
 export interface SegmentData {
   position: Float32Array
+  /** vec4 per vertex: [height, width, heading of the extrusion joined at this endpoint (its own when none), packed colour] */
   hwa: Float32Array
   segIndex: Uint32Array
   nV: number
@@ -110,6 +111,11 @@ export interface ToolpathHandle {
   setVisibleLayers(n: number): void
   setTravelVisible(visible: boolean): void
   setColors(color: Float32Array): void
+  /** Draws the top shown layer up to its move `at`, extrusions and travels in print order; null draws the whole
+   *  range again. Returns where the nozzle is (moveCursor) and the layer walked, or null. */
+  setMoveRange(at: number | null): { point: number[] | null; segCount: number; travCount: number; onTravel: boolean; layer: number } | null
+  /** The SegmentData the handle was built from. */
+  data: SegmentData
   dispose(): void
   nSeg: number
   layerCount: number