three-slicer-viewer 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer-viewer",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "The three-slicer viewer without the slicer — model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
   "license": "MIT",
   "type": "module",

package/src/settings/bed_frame.js

@@ -0,0 +1,28 @@
+// Printer coordinates. Kept apart from settings_core.js because it needs no schema: core/plate_settings.js reads it
+// without loading the config schema behind it.
+//
+// The viewer and the kernel work in a plate frame centred on the bed; the printer's own coordinates start wherever
+//  printable_area does. The kernel adds the bed centre to every coordinate it writes (Params::bed_center_x/y), and
+//  every stored printer coordinate (wipe_tower_x/y, a 3mf object position, an imported G-code) converts through the
+//  same two functions. `params` is deriveKernelParams' output (bed_origin_x/y are present only when the corner is
+//  not (0,0)). Most beds start at (0,0), where the centre is half the bed; a delta bed is centred on (0,0) itself
+//  (Anycubic Predator: -185..185).
+import { BED_FALLBACK } from './kernel_defaults.js'
+
+export function bedOrigin(params) {
+  return { x: params?.bed_origin_x ?? 0, y: params?.bed_origin_y ?? 0 }
+}
+export function bedCenter(params) {
+  const origin = bedOrigin(params)
+  return { x: origin.x + (params?.bed_width ?? BED_FALLBACK.width) / 2, y: origin.y + (params?.bed_depth ?? BED_FALLBACK.depth) / 2 }
+}
+
+// A printable_area that is not an axis-aligned rectangle (a delta bed's circle as 72 points, a cut-corner bed), as
+//  plate-local points: printer coordinates minus the bed centre. null for a rectangle, which bed_width/bed_depth
+//  already describe exactly.
+export function bedShapeLocal(area, center) {
+  if (!Array.isArray(area) || area.length < 3) return null
+  const xs = new Set(area.map(point => point[0])), ys = new Set(area.map(point => point[1]))
+  if (area.length === 4 && xs.size === 2 && ys.size === 2) return null
+  return area.map(([x, y]) => [x - center.x, y - center.y])
+}

package/src/settings/index.js

@@ -1,4 +1,5 @@
 // three-slicer-viewer/settings — the catalog-free settings surface. See settings_core.js.
 export * from './settings_core.js'
+export { bedOrigin, bedCenter, bedShapeLocal } from './bed_frame.js'
 // The derivation's own fallbacks, for callers that need the same numbers (frozen; see kernel_defaults.js).
 export { FFF_FALLBACKS, SLA_FALLBACKS, AUTO_LINE_WIDTH, BED_FALLBACK, MACHINE_LIMITS } from './kernel_defaults.js'

package/src/settings/kernel_setting_keys.js

@@ -1,19 +1,28 @@
 // AUTO-GENERATED by types/gen_kernel_params.mjs — DO NOT EDIT.
 // The schema keys deriveKernelParams consumes (the distinct "From setting" column of engine/PARAMS.md).
 export const KERNEL_SETTING_KEYS = [
+  "accel_to_decel_enable",
+  "accel_to_decel_factor",
   "alternate_extra_wall",
+  "before_layer_change_gcode",
   "bottom_shell_layers",
   "bottom_solid_infill_flow_ratio",
   "bottom_surface_filament_id",
+  "bridge_acceleration",
   "bridge_flow",
   "bridge_no_support",
   "bridge_speed",
   "brim_flow_ratio",
   "brim_object_gap",
   "brim_width",
+  "change_filament_gcode",
   "close_fan_the_first_x_layers",
+  "curr_bed_type",
   "default_acceleration",
+  "default_jerk",
   "detect_thin_wall",
+  "disable_m73",
+  "emit_machine_limits_to_gcode",
   "enable_arc_fitting",
   "enable_pressure_advance",
   "enable_prime_tower",
@@ -30,8 +39,10 @@ export const KERNEL_SETTING_KEYS = [
   "filament_retraction_minimum_travel",
   "filament_retraction_speed",
   "filament_settings_id",
+  "filament_start_gcode",
   "filament_type",
   "filament_z_hop",
+  "file_start_gcode",
   "filter_out_gap_fill",
   "first_layer_flow_ratio",
   "flush_into_infill",
@@ -40,32 +51,51 @@ export const KERNEL_SETTING_KEYS = [
   "full_fan_speed_layer",
   "gap_fill_flow_ratio",
   "gap_infill_speed",
+  "gcode_flavor",
   "hot_plate_temp",
+  "hot_plate_temp_initial_layer",
   "independent_support_layer_height",
   "infill_direction",
+  "infill_jerk",
   "infill_wall_overlap",
+  "initial_layer_acceleration",
+  "initial_layer_infill_speed",
+  "initial_layer_jerk",
   "initial_layer_line_width",
   "initial_layer_print_height",
   "initial_layer_speed",
+  "initial_layer_travel_acceleration",
+  "initial_layer_travel_jerk",
+  "initial_layer_travel_speed",
+  "inner_wall_acceleration",
   "inner_wall_filament_id",
   "inner_wall_flow_ratio",
+  "inner_wall_jerk",
   "inner_wall_line_width",
+  "inner_wall_speed",
   "internal_solid_filament_id",
+  "internal_solid_infill_acceleration",
   "internal_solid_infill_flow_ratio",
   "internal_solid_infill_line_width",
+  "internal_solid_infill_speed",
   "ironing_flow",
   "ironing_spacing",
   "ironing_speed",
   "ironing_type",
+  "layer_change_gcode",
   "layer_height",
   "line_width",
   "machine_end_gcode",
   "machine_max_acceleration_e",
+  "machine_max_acceleration_extruding",
   "machine_max_acceleration_retracting",
+  "machine_max_acceleration_travel",
   "machine_max_acceleration_x",
+  "machine_max_acceleration_y",
   "machine_max_acceleration_z",
   "machine_max_jerk_e",
   "machine_max_jerk_x",
+  "machine_max_jerk_y",
   "machine_max_jerk_z",
   "machine_max_speed_e",
   "machine_max_speed_x",
@@ -74,9 +104,12 @@ export const KERNEL_SETTING_KEYS = [
   "max_volumetric_extrusion_rate_slope",
   "nozzle_diameter",
   "nozzle_temperature",
+  "nozzle_temperature_initial_layer",
   "only_one_wall_first_layer",
+  "outer_wall_acceleration",
   "outer_wall_filament_id",
   "outer_wall_flow_ratio",
+  "outer_wall_jerk",
   "outer_wall_line_width",
   "outer_wall_speed",
   "precise_outer_wall",
@@ -90,6 +123,7 @@ export const KERNEL_SETTING_KEYS = [
   "raft_expansion",
   "raft_layers",
   "reduce_crossing_wall",
+  "reduce_infill_retraction",
   "resolution",
   "retraction_length",
   "retraction_minimum_travel",
@@ -98,15 +132,22 @@ export const KERNEL_SETTING_KEYS = [
   "seam_position",
   "seam_slope_type",
   "set_other_flow_ratios",
+  "single_extruder_multi_material",
   "skirt_distance",
   "skirt_height",
   "skirt_loops",
+  "skirt_speed",
   "slow_down_layer_time",
+  "slow_down_layers",
+  "small_perimeter_speed",
+  "small_perimeter_threshold",
+  "sparse_infill_acceleration",
   "sparse_infill_density",
   "sparse_infill_filament_id",
   "sparse_infill_flow_ratio",
   "sparse_infill_line_width",
   "sparse_infill_pattern",
+  "sparse_infill_speed",
   "spiral_mode",
   "support_angle",
   "support_base_pattern",
@@ -120,24 +161,31 @@ export const KERNEL_SETTING_KEYS = [
   "support_interface_flow_ratio",
   "support_interface_pattern",
   "support_interface_spacing",
+  "support_interface_speed",
   "support_interface_top_layers",
   "support_line_width",
   "support_object_first_layer_gap",
   "support_object_xy_distance",
   "support_on_build_plate_only",
   "support_remove_small_overhang",
+  "support_speed",
   "support_style",
   "support_threshold_angle",
   "support_threshold_overlap",
   "support_top_z_distance",
   "support_type",
   "thick_bridges",
+  "time_lapse_gcode",
   "top_bottom_infill_wall_overlap",
   "top_shell_layers",
   "top_solid_infill_flow_ratio",
+  "top_surface_acceleration",
   "top_surface_filament_id",
+  "top_surface_jerk",
   "top_surface_line_width",
+  "top_surface_speed",
   "travel_acceleration",
+  "travel_jerk",
   "travel_speed",
   "tree_support_angle_slow",
   "tree_support_branch_angle",
@@ -150,6 +198,8 @@ export const KERNEL_SETTING_KEYS = [
   "tree_support_tip_diameter",
   "tree_support_top_rate",
   "tree_support_wall_count",
+  "use_firmware_retraction",
+  "use_relative_e_distances",
   "wall_direction",
   "wall_generator",
   "wall_loops",
@@ -157,4 +207,5 @@ export const KERNEL_SETTING_KEYS = [
   "wipe_tower_x",
   "wipe_tower_y",
   "z_hop",
+  "z_offset",
 ]

package/src/settings/settings_core.js

@@ -66,8 +66,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 +86,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']
@@ -215,21 +241,76 @@ 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',
 }
 
 // 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 }
@@ -269,12 +350,17 @@ 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).
@@ -374,13 +460,60 @@ export function deriveKernelParams(settings, opts) {
     }
   }
 
+  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')],
@@ -401,6 +534,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 +569,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'),

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