three-slicer 0.1.1 → 0.1.3

package/engine/examples/headless.mjs

@@ -1,7 +1,7 @@
 // three-slicer headless SDK example + independence proof: drive the engine from Node using ONLY the
 // public API (no UI, no viewer). Generates a 20mm cube STL, slices it, prints stats + G-code length.
 //   run: node packages/engine/examples/headless.mjs
-import { createSlicer } from 'three-slicer'   // 워크스페이스 심링크로 해석 — 외부 소비자와 동일한 경로
+import { createSlicer } from 'three-slicer'   // resolved via the workspace symlink — same path an external consumer takes
 
 // minimal binary-STL writer for a box (public API takes a binary-STL ArrayBuffer)
 function boxTris(ox, oy, oz, sx, sy, sz) {
@@ -27,7 +27,7 @@ const slicer = await createSlicer()
 const r = slicer.slice(cube, params)
 console.log(`batch : layers=${r.stats.layers} segments=${r.stats.path_segments} filament=${r.stats.filament_mm.toFixed(1)}mm gcode=${r.gcode.length} chars`)
 
-// (b) streaming slice via onLayer (30단계) — assemble G-code from per-layer chunks
+// (b) streaming slice via onLayer (stage 30) — assemble G-code from per-layer chunks
 let chunks = 0, gbytes = 0
 const rs = slicer.slice(cube, params, { onLayer: ({ gcode }) => { chunks++; gbytes += gcode.length } })
 console.log(`stream: layers=${chunks} streamed=${rs.stats.streamed} assembled-gcode=${gbytes} chars`)

package/engine/index.js

@@ -7,7 +7,7 @@ import createModule from './src/slicer_core.js'
 const u8 = (b) => (b instanceof Uint8Array ? b : new Uint8Array(b))
 
 // Off-main-thread worker URL for the browser: `new Worker(engineWorkerURL(), { type: 'module' })`.
-// The worker speaks the 30단계 streaming protocol ({type:'layer'|'done'|'error'|'progress'}).
+// The worker speaks the stage-30 streaming protocol ({type:'layer'|'done'|'error'|'progress'}).
 export const engineWorkerURL = () => new URL('./src/slicer.worker.js', import.meta.url)
 
 // createSlicer(): load the WASM kernel and return a handle. Works in Node and the browser main thread.
@@ -15,7 +15,7 @@ export const engineWorkerURL = () => new URL('./src/slicer.worker.js', import.me
 //    - stl: ArrayBuffer|Uint8Array (binary STL)
 //    - params: kernel-params object OR JSON string (see web/GUIDE.md; use deriveKernelParams to build from UI settings)
 //    - onProgress(done,total): per-layer progress
-//    - onLayer({z,idx,gcode,paths,widths}): 30단계 streaming — emits + frees each layer; when set, the
+//    - onLayer({z,idx,gcode,paths,widths}): stage-30 streaming — emits + frees each layer; when set, the
 //      returned result carries stats only (assemble gcode/layers from the callbacks). When omitted, the
 //      result carries the whole { gcode, stats, layers }.
 //  paintPrepare/paint/paintClear/overlay: manual support enforcer/blocker painting (TriangleSelector).

package/engine/src/data.js

@@ -1,12 +1,18 @@
-// 추출 JSON 4종의 유일한 import 지점.
+// The single import site for the extracted JSON files.
 //
-// 왜 한 군데로 모으는가: JSON 은 Node 22+ ESM 에서 `with { type: 'json' }` 이 필수인데,
-// Vite/esbuild 는 번들 출력에서 이 attribute 를 떼어낸다(build.target·importAttributesKey 로
-// 막을 수 없음 — 실측). 그래서 같은 JSON 을 "attribute 있는 원본(engine/src/*.js)" 과
-// "attribute 없는 번들(components/dist)" 이 동시에 가리키면 소비자 번들러가
-// "inconsistent import attributes" 로 경고한다. 여기 한 곳만 JSON 을 잡고 나머지는
-// 이 모듈을 external 로 import → 번들에 JSON import 자체가 남지 않아 불일치가 성립하지 않는다.
+// Why funnel them through one module: JSON requires `with { type: 'json' }` in Node 22+ ESM, but
+// Vite/esbuild strip that attribute from bundle output (neither build.target nor importAttributesKey
+// prevents it — measured). So if the same JSON is pointed at by both "the original with the attribute
+// (engine/src/*.js)" and "the bundle without it (components/dist)", the consumer's bundler warns with
+// "inconsistent import attributes". Only this file holds the JSON; everything else imports this module
+// as external -> no JSON import survives in the bundle, so the mismatch cannot arise.
 export { default as schema } from 'three-slicer/data/config-schema.json' with { type: 'json' }
 export { default as uiTree } from 'three-slicer/data/ui-tree.json' with { type: 'json' }
 export { default as toggleRules } from 'three-slicer/data/toggle-rules.json' with { type: 'json' }
 export { default as invalidationMap } from 'three-slicer/data/invalidation-map.json' with { type: 'json' }
+export { default as printers } from 'three-slicer/data/printers.json' with { type: 'json' }
+// processes is the largest artifact (~800 KB) and is only needed once a printer is picked, so it stays a dynamic
+// import. It is generated as a JS module rather than JSON precisely because of the attribute problem above, in its
+// other direction: a dynamic JSON import needs the attribute in Node, and that same attribute makes browsers
+// reject the text/javascript response a dev server gives for .json.
+export const loadProcesses = () => import('three-slicer/data/processes.js').then(m => m.default)

package/engine/src/settings.js

@@ -1,40 +1,116 @@
-// 우측 설정 패널(편집 가능)의 실제 값 → 커널 슬라이스 파라미터 매핑.
-//  - 설정 상태는 sparse 맵(key→value): 편집한 키만 저장, 없으면 config-schema default.
-//  - 벡터형(coFloats/coInts 등)은 첫 원소만 사용/편집(단순화).
-import { schema } from './data.js'
+// Maps the actual values of the (editable) right-hand settings panel -> kernel slice parameters.
+//  - Settings state is a sparse map (key->value): only edited keys are stored, otherwise the config-schema default.
+//  - For vector types (coFloats/coInts, …) only the first element is used/edited (simplification).
+import { schema, printers, loadProcesses } from './data.js'
 
 export function schemaDefault(key) { return schema[key]?.default }
 export function settingRaw(settings, key) { return (settings && key in settings) ? settings[key] : schemaDefault(key) }
-// 스칼라(벡터면 [0]) 로 정규화
+// Normalize to a scalar ([0] for vectors)
 export function settingScalar(settings, key) { const v = settingRaw(settings, key); return Array.isArray(v) ? v[0] : v }
 
-// 8단계: 이식된 실제 Fill 패턴(gyroid TPMS/honeycomb/3dhoneycomb/crosshatch/concentric) + 기존 근사 패턴
+// Stage 8: real ported Fill patterns (gyroid TPMS/honeycomb/3dhoneycomb/crosshatch/concentric) + the older approximations
 const KERNEL_PATTERNS = ['rectilinear', 'grid', 'triangles', 'zigzag', 'gyroid', 'gyroid_approx',
   'honeycomb', '3dhoneycomb', 'crosshatch', 'concentric']
 const KERNEL_SEAMS = ['nearest', 'aligned', 'back', 'random']
 
-// 우측 패널 설정값 → 커널 파라미터 (스키마 키에서 유도)
+// Machine limits (the "Motion ability" printer page) -> kernel time-estimate parameters.
+//  Declarative on purpose: the kernel collapses X/Y into one axis, so the mapping cannot be a plain pass-through,
+//  but adding a limit stays a data row instead of code. The fallback is the kernel's own default, so an unedited
+//  profile produces exactly the previous estimate. Upstream leaves machine_max_*_x/y/z/e without a schema default
+//  (they only ever come from a printer preset), hence the explicit fallbacks here.
+const MACHINE_LIMITS = {
+  machine_max_speed_xy: ['machine_max_speed_x', 500],
+  machine_max_speed_z:  ['machine_max_speed_z', 12],
+  machine_max_speed_e:  ['machine_max_speed_e', 30],
+  machine_max_accel_xy: ['machine_max_acceleration_x', 5000],
+  machine_max_accel_z:  ['machine_max_acceleration_z', 500],
+  machine_max_accel_e:  ['machine_max_acceleration_e', 5000],
+  machine_jerk_xy:      ['machine_max_jerk_x', 9],
+  machine_jerk_z:       ['machine_max_jerk_z', 0.4],
+  machine_jerk_e:       ['machine_max_jerk_e', 2.5],
+  machine_accel_print:  ['default_acceleration', 5000],
+  machine_accel_travel: ['travel_acceleration', 5000],
+  machine_accel_retract: ['machine_max_acceleration_retracting', 5000],
+}
+// The schema keys the machine limits are read from — for UI that has to show "which printer characteristics are in play"
+// without hardcoding key strings of its own.
+export const machineLimitKeys = Object.values(MACHINE_LIMITS).map(([key]) => key)
+
+// ---- Printer profiles -------------------------------------------------------
+// printers.json is stored column-oriented (see its .d.ts). These two hide that layout so no consumer decodes it.
+
+/** Every option key a printer profile can set — what to clear before applying a different printer. */
+export const printerKeys = printers.keys
+
+/** Vendor -> profile name -> `[nozzle, setIndex, model]`, straight from the data (for building a picker). */
+export const printersByVendor = printers.byVendor
+
+// 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
+export function processPresets() {
+  processesPromise ??= loadProcesses().then(data => ({
+    /** Every key a process preset can set — clear these before applying a different one */
+    keys: data.keys,
+    /** Preset names compatible with a printer profile, in upstream order */
+    listFor: (printerProfileName) =>
+      (data.byPrinter[printerProfileName] ?? []).map(i => data.presets[i][0]),
+    /** The settings a preset applies, ready to merge. `null` when unknown. */
+    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 processesPromise
+}
+
+function printerEntry(profileName) {
+  for (const models of Object.values(printers.byVendor)) {
+    const entry = models[profileName]
+    if (entry) return entry
+  }
+  return 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
+}
+
+/** The vendor's recommended process preset for a printer, or '' when the profile names none. */
+export function printerDefaultPreset(profileName) { return printerEntry(profileName)?.[3] ?? '' }
+
+
+// Right-panel settings values -> kernel parameters (derived from schema keys)
 export function deriveKernelParams(settings) {
   const S = k => settingScalar(settings, k)
   const num = (k, d) => { const v = Number(S(k)); return Number.isFinite(v) ? v : d }
   const bool = (k, d) => { const v = settingRaw(settings, k); return typeof v === 'boolean' ? v : (Array.isArray(v) ? !!v[0] : (v == null ? d : !!v)) }
 
-  let line_width = num('line_width', 0); if (!line_width) line_width = 0.42   // 0=auto → 기본 0.42
+  let line_width = num('line_width', 0); if (!line_width) line_width = 0.42   // 0=auto -> default 0.42
 
   let pat = String(S('sparse_infill_pattern') ?? 'rectilinear')
-  if (!KERNEL_PATTERNS.includes(pat)) pat = 'rectilinear'                     // 커널 미지원 패턴 → rectilinear
+  if (!KERNEL_PATTERNS.includes(pat)) pat = 'rectilinear'                     // pattern unsupported by the kernel -> rectilinear
 
   let seam = String(S('seam_position') ?? 'back')
   if (seam === 'aligned_back') seam = 'back'
   if (!KERNEL_SEAMS.includes(seam)) seam = 'back'
 
-  // 서포트 스타일: 스키마 enum(default/grid/snug/organic/tree_slim/tree_strong/tree_hybrid)
-  //  → 커널 grid|tree|tree_lite. 18단계부터 tree/organic 계열은 실 오가닉 TreeSupport('tree',
-  //  generate_tree_support_3D → 실 type5 브랜치 툴패스)로 매핑, 그 외 grid.
+  // Support style: schema enum (default/grid/snug/organic/tree_slim/tree_strong/tree_hybrid)
+  //  -> kernel grid|tree|tree_lite. Since stage 18 the tree/organic family maps to the real organic TreeSupport ('tree',
+  //  generate_tree_support_3D -> real type5 branch toolpaths); everything else maps to grid.
   const styleRaw = String(S('support_style') ?? 'default')
   const support_style = /tree|organic/i.test(styleRaw) ? 'tree' : 'grid'
 
-  // 베드: printable_area 첫 사각형의 바운딩박스
+  // Bed: bounding box of the first rectangle in printable_area
   const pa = settingRaw(settings, 'printable_area')
   let bed_width = 256, bed_depth = 256
   if (Array.isArray(pa) && pa.length) {
@@ -42,15 +118,19 @@ export function deriveKernelParams(settings) {
     bed_width = Math.max(...xs) - Math.min(...xs); bed_depth = Math.max(...ys) - Math.min(...ys)
   }
 
-  // 21단계: 피처별 폭 — 원본(문자열 "120%" 포함) 그대로 커널로 전달. 미편집 키는 생략 → 커널이 auto(=line_width) 유도.
-  //  0=자동 시맨틱은 커널 resolve_lw(원본 Flow 산식)이 처리. 기본값 불변(모든 피처 미설정 → line_width).
+  // 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).
   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']) {
     const v = S(k); if (v != null && v !== '') widths[k] = v
   }
+  const machine = {}
+  for (const [param, [key, fallback]] of Object.entries(MACHINE_LIMITS)) machine[param] = num(key, fallback)
+
   return {
     ...widths,
+    ...machine,
     layer_height: num('layer_height', 0.2),
     first_layer_height: num('initial_layer_print_height', 0.2),
     line_width,
@@ -63,12 +143,12 @@ export function deriveKernelParams(settings) {
     seam_position: seam,
     skirt_loops: num('skirt_loops', 1),
     skirt_distance: num('skirt_distance', 2),
-    skirt_height: num('skirt_height', 1),                       // 33단계: 커널이 첫 레이어 고정이었음
+    skirt_height: num('skirt_height', 1),                       // stage 33: the kernel used to hardcode the first layer
     brim_width: num('brim_width', 0),
-    brim_object_gap: num('brim_object_gap', 0),                 // 33단계: 커널이 w*0.5 고정이었음
-    retract_length: num('retraction_length', 0.8),              // 벡터[0]
-    retraction_minimum_travel: num('retraction_minimum_travel', 2),  // 33단계: 커널 상수 2.0 이었음
-    gcode_resolution: num('resolution', 0.01),                  // 33단계: 트리 서포트 경로 단순화 허용오차
+    brim_object_gap: num('brim_object_gap', 0),                 // stage 33: the kernel used to hardcode w*0.5
+    retract_length: num('retraction_length', 0.8),              // vector[0]
+    retraction_minimum_travel: num('retraction_minimum_travel', 2),  // stage 33: used to be the kernel constant 2.0
+    gcode_resolution: num('resolution', 0.01),                  // stage 33: tree-support path simplification tolerance
     retract_speed: num('retraction_speed', 30),
     z_hop: num('z_hop', 0.4),
     travel_speed: num('travel_speed', 120),
@@ -78,15 +158,20 @@ export function deriveKernelParams(settings) {
     filament_diameter: num('filament_diameter', 1.75),
     flow_ratio: num('filament_flow_ratio', 1.0),
     nozzle_temp: num('nozzle_temperature', 200),
-    bed_temp: num('hot_plate_temp', 45),                        // bed_temperature 키 없음 → hot_plate_temp
+    bed_temp: num('hot_plate_temp', 45),                        // no bed_temperature key -> hot_plate_temp
     bed_width, bed_depth,
+    bed_height: num('printable_height', 0),                    // 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 ?? ''),
     enable_support: bool('enable_support', false),
     support_threshold_angle: num('support_threshold_angle', 30),
     support_top_z_distance: num('support_top_z_distance', 0.2),
-    support_bottom_z_distance: num('support_bottom_z_distance', 0.2),   // 32단계: 서포트 바닥 z-gap(기본 0.2=현행 등가)
+    support_bottom_z_distance: num('support_bottom_z_distance', 0.2),   // stage 32: support bottom z-gap (default 0.2 = equivalent to current behavior)
     support_xy_distance: num('support_object_xy_distance', 0.35),
     support_interface_top_layers: num('support_interface_top_layers', 2),
-    // 33단계: 커널 하드코딩 제거로 신설된 서포트 키 배선(원본 스키마 키 그대로)
+    // Stage 33: support keys added when the kernel hardcoding was removed (upstream schema key names kept)
     support_angle: num('support_angle', 0),
     support_base_pattern: String(S('support_base_pattern') ?? 'default'),
     support_interface_pattern: String(S('support_interface_pattern') ?? 'auto'),
@@ -97,34 +182,34 @@ export function deriveKernelParams(settings) {
     support_expansion: num('support_expansion', 0),
     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 (압출폭 비율)
+      const n = Number(v); return Number.isFinite(n) ? n : 0.5 })(),   // "50%" -> 0.5 (ratio of extrusion width)
     support_on_build_plate_only: bool('support_on_build_plate_only', false),
     support_interface_bottom_layers: num('support_interface_bottom_layers', 0),
     raft_layers: num('raft_layers', 0),
-    raft_expansion: num('raft_expansion', 1.5),                 // 33단계: 커널이 +3.0 고정이었음
-    raft_contact_distance: num('raft_contact_distance', 0.1),   // 33단계: 커널에 미반영이었음
-    fan_speed: num('fan_max_speed', 100),                       // fan_speed 키 없음 → fan_max_speed
+    raft_expansion: num('raft_expansion', 1.5),                 // stage 33: the kernel used to hardcode +3.0
+    raft_contact_distance: num('raft_contact_distance', 0.1),   // stage 33: previously ignored by the kernel
+    fan_speed: num('fan_max_speed', 100),                       // no fan_speed key -> fan_max_speed
     close_fan_the_first_x_layers: num('close_fan_the_first_x_layers', 1),
     full_fan_speed_layer: num('full_fan_speed_layer', 0),
     slow_down_layer_time: num('slow_down_layer_time', 5),
     enable_arc_fitting: bool('enable_arc_fitting', false),
     spiral_mode: bool('spiral_mode', false),
-    // 5단계 신규 (스키마 대응 키에서 유도)
-    seam_slope_type: String(S('seam_slope_type') ?? 'none'),      // none|external|all → scarf 심
+    // New in stage 5 (derived from the matching schema keys)
+    seam_slope_type: String(S('seam_slope_type') ?? 'none'),      // none|external|all -> scarf seam
     enable_pressure_advance: bool('enable_pressure_advance', false),
     pressure_advance: num('pressure_advance', 0.02),
-    support_style,                                                 // grid|tree_lite (위에서 매핑)
+    support_style,                                                 // grid|tree_lite (mapped above)
     bridge_speed: num('bridge_speed', 25),
-    // 6단계 신규 (스키마 대응 키에서 유도). MM 파라미터(extruder_count/mm_group_split)는
-    //  뷰어 오브젝트별 익스트루더 지정에서 onSlice 시 주입(여기선 미포함).
-    ironing_type: String(S('ironing_type') ?? 'no ironing'),       // no ironing|top|topmost|solid (top류=on)
+    // New in stage 6 (derived from the matching schema keys). The MM parameters (extruder_count/mm_group_split) are
+    //  injected at onSlice time from the viewer's per-object extruder assignment (not included here).
+    ironing_type: String(S('ironing_type') ?? 'no ironing'),       // no ironing|top|topmost|solid (the top family = on)
     ironing_spacing: num('ironing_spacing', 0.1),
     ironing_flow: num('ironing_flow', 10),
     ironing_speed: num('ironing_speed', 20),
     reduce_crossing_wall: bool('reduce_crossing_wall', false),
     max_volumetric_extrusion_rate_slope: num('max_volumetric_extrusion_rate_slope', 0),
-    // 7단계: 벽 생성기 classic|arachne (arachne = 이식된 실제 OrcaSlicer WallToolPaths, 가변폭)
+    // Stage 7: wall generator classic|arachne (arachne = the real ported OrcaSlicer WallToolPaths, variable width)
     wall_generator: (String(S('wall_generator') ?? 'classic') === 'arachne') ? 'arachne' : 'classic',
-    // support_density 는 스키마에 대응 키가 없어 커널 기본(0.15), scarf_length 도 커널 기본(10mm) 사용
+    // support_density has no matching schema key, so the kernel default (0.15) is used; scarf_length likewise uses the kernel default (10mm)
   }
 }

package/engine/src/slicer.worker.js

@@ -1,14 +1,16 @@
-// 슬라이스를 메인 스레드 밖에서 실행 (UI 논블록) + 30단계 레이어 스트리밍.
+// 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 이라 slicer_core.js 안에 wasm 이 인라인 → worker 에서도 외부 fetch 없음.
+// SINGLE_FILE means the wasm is inlined into slicer_core.js -> no external fetch from the worker either.
 //
-// 30단계(OOM 내성): set_layer_sink 로 커널이 레이어를 만드는 대로 방출받아 즉시 메인으로 transfer 하고
-//  (Float32Array 버퍼 이전 → worker 사본 즉시 해제) 커널은 그 레이어 버퍼를 힙에서 해제한다. 결과 상주
-//  (전체 gw.s + 전체 layersArr)가 사라져 WASM 힙 피크가 급감 → 대형 모델 OOM 회피. 최종 'done' 은 stats 만.
-//  절약 모드(params.economy)면 툴패스 없이 g-code 청크만 방출(프리뷰 없이 완주). MM/실PE 경로는 배치 폴백.
-// 멀티스레드 커널 자동 선택: crossOriginIsolated(COOP/COEP 제공 사이트)면 mt(-pthread, PASS1 레이어
-//  병렬 — 실측 2.2×), 아니면 st(zero-config). 동적 import 라 번들러는 둘 다 청크로 내지만 런타임엔
-//  하나만 로드. mt 초기화 실패(SAB 차단 등) 시 st 폴백.
+// 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
+//  from the heap. The resident result (the full gw.s + the full layersArr) disappears, so the WASM heap peak drops sharply
+//  -> large models avoid OOM. The final 'done' carries stats only.
+//  In economy mode (params.economy) only G-code chunks are emitted, without toolpaths (finishes without a preview).
+//  The MM / real-PE paths fall back to batch mode.
+// 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.
 const loadCore = async () => {
   const isolated = typeof crossOriginIsolated !== 'undefined' && crossOriginIsolated
   if (isolated) {
@@ -16,7 +18,7 @@ const loadCore = async () => {
       const M = await (await import('./slicer_core.mt.js')).default()
       console.info('[slicer.worker] core: mt (threads)')
       return M
-    } catch (e) { console.warn('[slicer.worker] mt 로드 실패 — st 폴백:', e) }
+    } catch (e) { console.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')
@@ -30,34 +32,34 @@ self.onmessage = async (e) => {
   try {
     if (!modPromise) modPromise = loadCore()
     const Module = await modPromise
-    // 워밍업: 커널 로드(+mt pthread 풀 스폰)만 미리 수행 — 첫 슬라이스의 체감 로딩 제거
+    // Warmup: only load the kernel (+ spawn the mt pthread pool) ahead of time — removes the perceived load on the first slice
     if (d.cmd === 'warmup') { self.postMessage({ type: 'warm' }); return }
-    // 20단계: 수동 서포트 페인팅 — selector 상태는 이 worker Module 에 지속(슬라이스도 같은 Module).
+    // Stage 20: manual support painting — selector state persists in this worker Module (slicing uses the same Module).
     if (d.cmd === 'prepare') { Module.selector_prepare(new Uint8Array(d.stl)); self.postMessage({ type: 'prepared', facets: Module.selector_facet_count() }); return }
     if (d.cmd === 'paint')   { Module.selector_paint(d.facet, d.hx, d.hy, d.hz, d.cx, d.cy, d.cz, d.radius, d.enforcer);
                                self.postMessage({ type: 'painted', enf: Module.selector_painted_count(true), blk: Module.selector_painted_count(false) }); return }
     if (d.cmd === 'clear')   { Module.selector_clear(); self.postMessage({ type: 'painted', enf: 0, blk: 0 }); return }
     if (d.cmd === 'overlay')  { self.postMessage({ type: 'overlay', enf: Array.from(Module.selector_overlay(true)), blk: Array.from(Module.selector_overlay(false)) }); return }
 
-    if (d.stall) return   // 30단계 테스트 훅: 무응답(행) 시뮬 → 메인 워치독 발동 검증(프로덕션 미설정)
-    // mt(SAB): 서포트 실진행 카운터(u32) 주소를 메인에 1회 공유 — 커널이 C++ 안에 블록된 동안에도
-    //  UI 스레드가 SAB 를 직접 폴링해 서포트 진행률을 표시한다. st(비공유 버퍼)는 미지원 → 미전송.
+    if (d.stall) return   // stage-30 test hook: simulate a hang -> verifies the main-thread watchdog fires (not set in production)
+    // mt (SAB): share the address of the real support progress counter (u32) with main once — even while the kernel is
+    //  blocked inside C++, the UI thread polls the SAB directly to show support progress. st (non-shared buffer) is unsupported -> not sent.
     if (!self.__supSabSent) {
       self.__supSabSent = true
       try {
-        // Module.HEAPU8 은 emscripten 6.x 글루가 노출하지 않음 — embind typed_memory_view 로 버퍼 획득
+        // Module.HEAPU8 is not exposed by the emscripten 6.x glue — obtain the buffer via embind typed_memory_view
         const v = Module.sup_progress_view && Module.sup_progress_view()
         const c = Module.cancel_flag_view && Module.cancel_flag_view()
         if (v && v.buffer instanceof SharedArrayBuffer)
           self.postMessage({ type: 'supsab', buf: v.buffer, ptr: v.byteOffset, cancelPtr: c ? c.byteOffset : 0 })
       } catch {}
     }
-    // 기본: 슬라이스. 레이어 싱크 등록 → 커널이 레이어마다 콜백(z, idx, gcodeChunk, pathsF32, widthsF32).
-    //  각 레이어를 즉시 메인으로 transfer(툴패스 버퍼 이전) → worker 사본 해제 → 다음 레이어 전 힙 여유.
+    // Default: slice. Register the layer sink -> the kernel calls back per layer (z, idx, gcodeChunk, pathsF32, widthsF32).
+    //  Each layer is transferred to main immediately (toolpath buffers moved) -> the worker copy is freed -> heap headroom before the next layer.
     const onProgress = (done, total) => self.postMessage({ type: 'progress', done, total })
     Module.set_layer_sink((z, idx, gcode, paths, widths) => {
       const transfer = []
-      if (paths && paths.buffer) transfer.push(paths.buffer)     // 절약 모드는 빈 배열(.buffer 없음) → 미이전
+      if (paths && paths.buffer) transfer.push(paths.buffer)     // economy mode yields empty arrays (no .buffer) -> nothing to transfer
       if (widths && widths.buffer) transfer.push(widths.buffer)
       self.postMessage({ type: 'layer', z, idx, gcode, paths, widths }, transfer)
     })
@@ -65,10 +67,10 @@ self.onmessage = async (e) => {
     try { r = Module.slice(new Uint8Array(d.stl), d.params, onProgress) }
     finally { Module.clear_layer_sink() }
     if (r && r.error) { self.postMessage({ type: 'error', error: String(r.error) }); return }
-    // streamed=true → g-code/layers 는 'layer' 로 이미 방출됨(result 엔 stats 만). batch/MM 는 result 에 그대로.
+    // streamed=true -> g-code/layers were already emitted as 'layer' (result holds stats only). batch/MM keep them in result.
     self.postMessage({ type: 'done', result: r })
   } catch (err) {
-    // WASM abort("memory access out of bounds") 포함 — 메인의 OOM 사다리가 재생성/절약 재시도 판정.
+    // 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) })
   }
 }

package/engine/src/toggle_eval.js

@@ -1,10 +1,10 @@
-// 25단계 S5.1: toggle-rules 부분 번역 — 원본 C++ toggle_options 조건식(enable_if) → JS.
-//  범위: 뷰어가 다루는 키에 관련된 규칙 중, 아래 하드코딩 로컬로 "완전히" 번역 가능한 것만 적용.
-//  번역 불가(모르는 로컬/enum 비교 등)는 fail-open(활성 유지) — 잘못된 비활성 방지(정직한 부분 구현).
-//  전체 907키·231규칙 완역은 범위 외(README 기록). 참조: toggle-rules.json 의 toggle_print_fff_options.locals.
+// Stage 25 S5.1: partial translation of toggle-rules — upstream C++ toggle_options conditions (enable_if) -> JS.
+//  Scope: among the rules touching keys the viewer handles, only those "fully" translatable with the hardcoded locals below.
+//  Untranslatable ones (unknown locals, enum comparisons, …) fail open (stay enabled) — avoids wrongly disabling (honest partial implementation).
+//  Translating all 907 keys / 231 rules is out of scope (noted in the README). Reference: toggle_print_fff_options.locals in toggle-rules.json.
 import { toggleRules as toggles, schema } from './data.js'
 
-// 설정값 접근기 (settings 맵 우선, 없으면 스키마 default). 퍼센트("15%")는 숫자로.
+// Settings value accessor (settings map first, schema default otherwise). Percentages ("15%") become numbers.
 export function makeCfg(settings) {
   const val = k => {
     let v = settings ? settings[k] : undefined
@@ -20,7 +20,7 @@ export function makeCfg(settings) {
   }
 }
 
-// 원본 locals 를 인라인 번역(뷰어 관련 조건만). 각 값은 boolean.
+// Upstream locals translated inline (viewer-related conditions only). Each value is a boolean.
 function makeLocals(cfg) {
   const have_raft = cfg.int('raft_layers') > 0
   const has_spiral_vase = cfg.bool('spiral_mode')
@@ -41,24 +41,24 @@ function makeLocals(cfg) {
   }
 }
 
-// enable_if(첫 콤마부) 를 boolean 으로 평가. 완전 번역 불가하면 null(=활성 유지).
+// Evaluates enable_if (up to the first comma) to a boolean. Returns null (= stays enabled) when not fully translatable.
 export function evalEnableIf(expr, locals, cfg) {
   let s = String(expr).split(',')[0].trim()
   if (!s) return null
-  // 직접 config 접근 패턴 → 값 치환
+  // Direct config access pattern -> value substitution
   s = s.replace(/config->opt_bool\(\s*"([^"]+)"\s*\)/g, (_, k) => cfg.bool(k) ? 'true' : 'false')
   s = s.replace(/config->opt_int\(\s*"([^"]+)"\s*\)/g, (_, k) => String(cfg.int(k)))
   s = s.replace(/config->opt_float\(\s*"([^"]+)"\s*\)/g, (_, k) => String(cfg.float(k)))
-  // 알려진 로컬 치환(긴 이름 먼저 — 부분매칭 방지)
+  // Substitute known locals (longest name first — prevents partial matches)
   for (const name of Object.keys(locals).sort((a, b) => b.length - a.length))
     s = s.replace(new RegExp('\\b' + name + '\\b', 'g'), locals[name] ? 'true' : 'false')
-  // 남은 문자열이 안전한 boolean 식인지(true/false/숫자/연산자/괄호만) — 아니면 미지 → null
+  // Check the remaining string is a safe boolean expression (only true/false/numbers/operators/parens) — otherwise unknown -> null
   const stripped = s.replace(/\btrue\b|\bfalse\b/g, '1')
   if (!/^[\s()!<>=&|0-9.]*$/.test(stripped)) return null
   try { return !!Function('"use strict";return (' + s + ')')() } catch { return null }
 }
 
-// 현재 설정에서 비활성 키 맵 { key: 조건식 }. 조건이 명확히 false 인 규칙만.
+// Map of keys disabled under the current settings { key: condition }. Only rules that are unambiguously false.
 export function disabledKeys(cfg) {
   const locals = makeLocals(cfg)
   const groups = ['toggle_print_fff_options', 'toggle_filament_options', 'toggle_printer_options',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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.",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -78,6 +78,8 @@
     "data/ui-tree.json",
     "data/toggle-rules.json",
     "data/invalidation-map.json",
+    "data/printers.json",
+    "data/processes.js",
     "README.md",
     "LICENSE.txt"
   ],
@@ -86,7 +88,7 @@
     "url": "git+https://github.com/kimgh06/Web_Three_Slicer.git",
     "directory": "packages"
   },
-  "homepage": "https://github.com/kimgh06/Web_Three_Slicer#readme",
+  "homepage": "https://slicer.kimgh06.com",
   "keywords": [
     "3d-printing",
     "slicer",

package/types/components.d.ts

@@ -3,15 +3,15 @@ import type * as React from 'react'
 import type { SlicerSettings } from './settings-keys.d.ts'
 
 export interface SettingsPanelProps {
-  /** sparse 맵 — 편집한 키만. 없는 키는 config-schema default 가 쓰인다. */
+  /** Sparse map — only edited keys. Missing keys fall back to the config-schema default. */
   settings: SlicerSettings
-  /** React setState 형태. 상태가 컴포넌트 밖으로 나가는 유일한 통로. */
+  /** React setState shape. The only channel through which state leaves the component. */
   setSettings: React.Dispatch<React.SetStateAction<SlicerSettings>>
-  /** 라벨 클릭 — 딥링크/상세용. 생략하면 평범한 라벨(라우터 결합 0). */
+  /** Label click — for deep links / detail views. Omit for a plain label (zero router coupling). */
   onOptionOpen?: (optKey: string) => void
-  /** 다른 패널 안에 끼워 넣을 때 */
+  /** When embedding inside another panel */
   embedded?: boolean
-  /** 스키마 구동 위젯을 키 단위로 교체 (예: `{ printable_area: MyBedEditor }`) */
+  /** Replace schema-driven widgets per key (e.g. `{ printable_area: MyBedEditor }`) */
   customWidgets?: Record<string, React.ComponentType<any>>
 }
 

package/types/data/config-schema.json.d.ts

@@ -1,8 +1,8 @@
-// three-slicer/data/config-schema.json — OrcaSlicer 원본에서 추출한 907개 옵션 정의.
-// ponytail: 값을 리터럴로 좁히지 않는다. 907키 × 33필드를 리터럴로 추론시키면 소비자 tsc 가 기어간다.
-//   키 단위 정확도가 필요하면 SlicerSettings(three-slicer/settings) 쪽을 쓸 것.
+// three-slicer/data/config-schema.json — the 907 option definitions extracted from upstream OrcaSlicer.
+// ponytail: values are not narrowed to literals. Inferring 907 keys x 33 fields as literals crawls in consumer tsc.
+//   Use SlicerSettings (three-slicer/settings) when you need per-key accuracy.
 
-/** 원본 ConfigOptionDef 의 coXxx 타입 태그 */
+/** The coXxx type tag from the upstream ConfigOptionDef */
 export type ConfigOptionType =
   | 'coBool' | 'coBools'
   | 'coInt' | 'coInts'
@@ -13,10 +13,10 @@ export type ConfigOptionType =
   | 'coEnum' | 'coEnums'
   | 'coPoint' | 'coPoints' | 'coPointsGroups'
 
-/** 907키 중 `type` 과 `defined_in` 만 전부 존재한다. 나머지는 전부 optional. */
+/** Of the 907 keys, only `type` and `defined_in` always exist. Everything else is optional. */
 export interface ConfigOption {
   type: ConfigOptionType
-  /** 추출된 원본 함수명 (예: 'init_common_params') */
+  /** Name of the source function it was extracted from (e.g. 'init_common_params') */
   defined_in: string
   line?: number
   mode?: string

package/types/data/invalidation-map.json.d.ts

@@ -1,12 +1,12 @@
-// three-slicer/data/invalidation-map.json — 설정 키 변경 → 무효화되는 슬라이스 단계.
-// 최상위 키 = 무효화 대상 종류(print/object/filament 등).
+// three-slicer/data/invalidation-map.json — setting key change -> invalidated slice steps.
+// Top-level key = the kind of invalidation target (print/object/filament, etc.).
 
 export interface InvalidationRule {
-  /** 이 규칙이 반응하는 config-schema 키들 */
+  /** The config-schema keys this rule reacts to */
   keys: string[]
-  /** 무효화되는 단계 (예: 'psSkirtBrim', 'posSlice') */
+  /** The invalidated steps (e.g. 'psSkirtBrim', 'posSlice') */
   steps: string[]
-  /** 단계로 표현 안 되는 특수 처리 */
+  /** Special handling that cannot be expressed as a step */
   special: string[]
   line?: number
 }

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

@@ -0,0 +1,23 @@
+// printers.json — per-printer settings extracted from OrcaSlicer's resources/profiles/<Vendor>/machine/.
+// Column layout: `keys` names the columns once and each entry in `sets` is a positional row, because
+// repeating the key names per printer costs more than all the values together. Rows are deduplicated —
+// a printer's nozzle variants usually share one row — so a printer holds an index rather than its own copy.
+// Prefer `printerSettings()` from three-slicer/settings over decoding this by hand.
+
+/** 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]
+
+export interface PrinterData {
+  /** Option keys, in column order — the same keys the settings panel edits */
+  keys: string[]
+  /** Deduplicated value rows */
+  sets: PrinterRow[]
+  /** Vendor -> printer profile name -> entry */
+  byVendor: Record<string, Record<string, PrinterEntry>>
+}
+
+declare const printers: PrinterData
+export default printers