three-slicer 0.1.1 → 0.1.2

package/engine/src/settings.js

@@ -1,40 +1,40 @@
-// 우측 설정 패널(편집 가능)의 실제 값 → 커널 슬라이스 파라미터 매핑.
-//  - 설정 상태는 sparse 맵(key→value): 편집한 키만 저장, 없으면 config-schema default.
-//  - 벡터형(coFloats/coInts 등)은 첫 원소만 사용/편집(단순화).
+// 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 } 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']
 
-// 우측 패널 설정값 → 커널 파라미터 (스키마 키에서 유도)
+// 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,8 +42,8 @@ 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']) {
@@ -63,12 +63,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 +78,15 @@ 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,
     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 +97,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.2",
   "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",

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/toggle-rules.json.d.ts

@@ -1,16 +1,16 @@
-// three-slicer/data/toggle-rules.json — 원본 toggle_options() 의 enable_if 조건식 추출.
-// 최상위 키 = 그룹명(예: 'toggle_print_fff_options', 'TabPrinter::toggle_options').
+// three-slicer/data/toggle-rules.json — enable_if expressions extracted from upstream toggle_options().
+// Top-level key = group name (e.g. 'toggle_print_fff_options', 'TabPrinter::toggle_options').
 
 export interface ToggleRule {
-  /** 원본 C++ 조건식 문자열. 평가는 three-slicer/toggle 의 evalEnableIf. */
+  /** The raw C++ expression string. Evaluated by evalEnableIf in three-slicer/toggle. */
   enable_if?: string
-  /** 이 조건이 지배하는 config-schema 키들 */
+  /** The config-schema keys governed by this condition */
   fields?: string[]
   line?: number
 }
 
 export interface ToggleGroup {
-  /** 로컬 변수명 → 원본 C++ 표현식(문자열). 번역은 toggle_eval.js 가 하드코딩으로 한다. */
+  /** Local variable name -> the upstream C++ expression (string). Translation is hardcoded in toggle_eval.js. */
   locals: Record<string, string>
   rules: ToggleRule[]
   stats?: { toggle_calls_in_source: number; rules_extracted: number }

package/types/data/ui-tree.json.d.ts

@@ -1,10 +1,10 @@
-// three-slicer/data/ui-tree.json — 원본 Tab.cpp 의 페이지/그룹 트리.
-// 최상위 키 = 빌더명(예: 'TabPrint::build'), 값 = 그 빌더가 만드는 페이지들.
+// three-slicer/data/ui-tree.json — the page/group tree from upstream Tab.cpp.
+// Top-level key = builder name (e.g. 'TabPrint::build'), value = the pages that builder creates.
 
 export interface UIGroup {
   group: string
   line?: number
-  /** config-schema 의 옵션 키들 */
+  /** The config-schema option keys */
   options: string[]
 }
 

package/types/data.d.ts

@@ -1,5 +1,5 @@
-// three-slicer/data — 추출 JSON 4종. 원본 JSON 을 직접 import 하는 것보다 이쪽을 권한다:
-// import attribute(`with { type: 'json' }`)가 이미 붙어 있어 Node·번들러 양쪽에서 그대로 돌아간다.
+// three-slicer/data — the 4 extracted JSON files. Prefer this over importing the raw JSON:
+// the import attribute (`with { type: 'json' }`) is already applied, so it works in Node and bundlers alike.
 import type { ConfigOption } from './data/config-schema.json.d.ts'
 import type { UIPage } from './data/ui-tree.json.d.ts'
 import type { ToggleGroup } from './data/toggle-rules.json.d.ts'
@@ -7,11 +7,11 @@ import type { InvalidationRule } from './data/invalidation-map.json.d.ts'
 
 export type { ConfigOption, UIPage, ToggleGroup, InvalidationRule }
 
-/** 907개 옵션 정의 */
+/** The 907 option definitions */
 export const schema: Record<string, ConfigOption>
-/** 빌더명 → 페이지 트리 */
+/** Builder name -> page tree */
 export const uiTree: Record<string, UIPage[]>
-/** 그룹명 → enable_if 규칙 */
+/** Group name -> enable_if rules */
 export const toggleRules: Record<string, ToggleGroup>
-/** 설정 키 변경 → 무효화 단계 */
+/** Setting key change -> invalidated steps */
 export const invalidationMap: Record<string, InvalidationRule[]>

package/types/gen_settings_types.mjs

@@ -1,8 +1,8 @@
-// config-schema.json → types/settings-keys.d.ts (SlicerSettings 인터페이스, 907키).
-// 재생성: node types/gen_settings_types.mjs      (수동 편집 금지 — 이 스크립트만 고칠 것)
+// config-schema.json -> types/settings-keys.d.ts (the SlicerSettings interface, 907 keys).
+// Regenerate: node types/gen_settings_types.mjs      (do not hand-edit — fix this script instead)
 //
-// ponytail: 스키마의 coXxx 타입만 보고 매핑한다. min/max·nullable 은 타입에 반영하지 않음
-//   (런타임 검증이지 타입 검증이 아니고, 907키 × branded number 는 tsc 를 느리게 만든다).
+// ponytail: mapping is driven purely by the schema's coXxx type. min/max and nullable are not reflected in types
+//   (they are runtime validation, not type validation, and 907 keys x branded number slows tsc down).
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -11,12 +11,12 @@ const here = dirname(fileURLToPath(import.meta.url))
 const schema = JSON.parse(readFileSync(resolve(here, '../data/config-schema.json'), 'utf8'))
 
 const lit = (v) => "'" + String(v).replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'"
-// enum_values 가 없는 coEnum 도 있다(70/64 불일치) → string 으로 fail-open.
+// Some coEnum entries have no enum_values (70/64 mismatch) -> fail open to string.
 const enumOf = (o) => (Array.isArray(o.enum_values) && o.enum_values.length)
   ? o.enum_values.map(lit).join(' | ')
   : 'string'
 
-// 벡터형은 `T[] | T` — settingScalar() 가 둘 다 받고, UI 는 첫 원소만 편집한다(settings.js:9).
+// Vector types are `T[] | T` — settingScalar() accepts both, and the UI edits only the first element (settings.js:9).
 const vec = (t) => `${/\|/.test(t) ? `(${t})` : t}[] | ${/\|/.test(t) ? `(${t})` : t}`
 
 function tsType(o) {
@@ -53,18 +53,18 @@ for (const key of Object.keys(schema).sort()) {
 writeFileSync(resolve(here, 'settings-keys.d.ts'), `// AUTO-GENERATED by types/gen_settings_types.mjs — DO NOT EDIT.
 // Source: data/config-schema.json (${Object.keys(schema).length} keys)
 
-/** [x, y] — coPoint 계열 */
+ /** [x, y] — coPoint family */
 export type Point = [number, number]
 
 /**
- * 슬라이서 설정 맵. sparse — 편집한 키만 담고, 없는 키는 config-schema 의 default 가 쓰인다.
- * 임의 키 확장이 필요하면 \`SlicerSettings & Record<string, unknown>\` 로 넓혀서 쓸 것.
+  * Slicer settings map. Sparse — it holds only edited keys; missing keys use the config-schema default.
+  * If you need arbitrary key extension, widen it with \`SlicerSettings & Record<string, unknown>\`.
  */
 export interface SlicerSettings {
 ${lines.join('\n')}
 }
 
-/** config-schema 에 존재하는 설정 키 */
+ /** Setting keys that exist in config-schema */
 export type SettingKey = keyof SlicerSettings & string
 `)
 console.log(`settings-keys.d.ts written — ${Object.keys(schema).length} keys`)

package/types/settings-keys.d.ts

@@ -1,12 +1,12 @@
 // AUTO-GENERATED by types/gen_settings_types.mjs — DO NOT EDIT.
 // Source: data/config-schema.json (907 keys)
 
-/** [x, y] — coPoint 계열 */
+ /** [x, y] — coPoint family */
 export type Point = [number, number]
 
 /**
- * 슬라이서 설정 맵. sparse — 편집한 키만 담고, 없는 키는 config-schema 의 default 가 쓰인다.
- * 임의 키 확장이 필요하면 `SlicerSettings & Record<string, unknown>` 로 넓혀서 쓸 것.
+  * Slicer settings map. Sparse — it holds only edited keys; missing keys use the config-schema default.
+  * If you need arbitrary key extension, widen it with `SlicerSettings & Record<string, unknown>`.
  */
 export interface SlicerSettings {
   absolute_correction?: number
@@ -1700,5 +1700,5 @@ export interface SlicerSettings {
   zhop?: number
 }
 
-/** config-schema 에 존재하는 설정 키 */
+ /** Setting keys that exist in config-schema */
 export type SettingKey = keyof SlicerSettings & string

package/types/settings.d.ts

@@ -2,18 +2,18 @@
 import type { SlicerSettings, SettingKey, Point } from './settings-keys.d.ts'
 export type { SlicerSettings, SettingKey, Point }
 
-/** config-schema 의 default 값 (없는 키면 undefined) */
+/** The config-schema default value (undefined for unknown keys) */
 export function schemaDefault(key: string): unknown
 
-/** settings 맵 우선, 없으면 스키마 default. 벡터형은 벡터 그대로 돌려준다. */
+/** Settings map first, schema default otherwise. Vector types are returned as-is. */
 export function settingRaw(settings: SlicerSettings | null | undefined, key: string): unknown
 
-/** settingRaw 를 스칼라로 정규화 — 벡터면 [0]. */
+/** Normalizes settingRaw to a scalar — [0] for vectors. */
 export function settingScalar(settings: SlicerSettings | null | undefined, key: string): unknown
 
 /**
- * 설정 맵 → 커널 슬라이스 파라미터. 스키마 키에서 유도하며 누락 키는 내부 기본값으로 채운다.
- * ponytail: 반환 키가 53개라 개별 나열 대신 Record — 커널 파라미터는 slice() 에 그대로 넘기는 용도지
- * 소비자가 필드 단위로 읽는 API 가 아니다. 필드 접근이 필요해지면 그때 펼칠 것.
+ * Settings map -> kernel slice params. Derived from schema keys; missing keys are filled with internal defaults.
+ * 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): Record<string, unknown>

package/types/toggle.d.ts

@@ -1,22 +1,22 @@
-// three-slicer/toggle — toggle-rules.json 의 enable_if 조건식 부분 평가.
+// three-slicer/toggle — partial evaluation of the enable_if expressions in toggle-rules.json.
 import type { SlicerSettings } from './settings-keys.d.ts'
 
-/** 설정 접근기 — 값이 없으면 스키마 default, 벡터형은 [0]. */
+/** Settings accessor — schema default when a value is missing, [0] for vector types. */
 export interface ToggleCfg {
   bool(key: string): boolean
   int(key: string): number
   float(key: string): number
-  /** 키가 config-schema 에 존재하는가 */
+  /** Whether the key exists in config-schema */
   has(key: string): boolean
 }
 
 export function makeCfg(settings: SlicerSettings | null | undefined): ToggleCfg
 
 /**
- * enable_if 조건식 1개 평가. 번역 불가한 식은 `null`(= fail-open, 활성 유지) 을 돌려준다 —
- * `false` 와 반드시 구분해서 다룰 것.
+ * Evaluates a single enable_if expression. Untranslatable expressions return `null` (= fail-open, stays enabled) —
+ * make sure to treat that as distinct from `false`.
  */
 export function evalEnableIf(expr: string, locals: Record<string, unknown>, cfg: ToggleCfg): boolean | null
 
-/** 현재 설정에서 비활성이어야 하는 키 → 그렇게 만든 enable_if 조건식. 조건이 명확히 false 인 규칙만. */
+/** Keys that must be disabled under the current settings -> the enable_if expression that disabled them. Only rules that are unambiguously false. */
 export function disabledKeys(cfg: ToggleCfg): Record<string, string>