three-slicer 0.1.0 → 0.1.2

package/engine/src/settings.js

@@ -1,40 +1,40 @@
-// 우측 설정 패널(편집 가능)의 실제 값 → 커널 슬라이스 파라미터 매핑.
-//  - 설정 상태는 sparse 맵(key→value): 편집한 키만 저장, 없으면 config-schema default.
-//  - 벡터형(coFloats/coInts 등)은 첫 원소만 사용/편집(단순화).
-import schema from 'three-slicer/data/config-schema.json'
+// 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,33 +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 })
+          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)
     })
@@ -64,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,11 +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.
-import toggles from 'three-slicer/data/toggle-rules.json'
-import schema from 'three-slicer/data/config-schema.json'
+// 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
@@ -21,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')
@@ -42,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,55 +1,83 @@
 {
   "name": "three-slicer",
-  "version": "0.1.0",
+  "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",
   "exports": {
     ".": {
       "types": "./engine/index.d.ts",
-      "import": "./engine/index.js"
+      "default": "./engine/index.js"
     },
-    "./settings": "./engine/src/settings.js",
-    "./toggle": "./engine/src/toggle_eval.js",
-    "./worker": "./engine/src/slicer.worker.js",
-    "./wasm": "./engine/src/slicer_core.js",
-    "./wasm-mt": "./engine/src/slicer_core.mt.js",
-    "./viewer": "./viewer/dist/Viewport.js",
-    "./viewer/toolpath": "./viewer/dist/toolpath_gpu.js",
-    "./viewer/loaders": "./viewer/dist/model_loaders.js",
-    "./components": "./components/dist/SettingsPanel.js",
-    "./data/*": "./data/*"
+    "./settings": {
+      "types": "./types/settings.d.ts",
+      "default": "./engine/src/settings.js"
+    },
+    "./toggle": {
+      "types": "./types/toggle.d.ts",
+      "default": "./engine/src/toggle_eval.js"
+    },
+    "./worker": {
+      "types": "./types/worker.d.ts",
+      "default": "./engine/src/slicer.worker.js"
+    },
+    "./wasm": {
+      "types": "./types/wasm.d.ts",
+      "default": "./engine/src/slicer_core.js"
+    },
+    "./wasm-mt": {
+      "types": "./types/wasm.d.ts",
+      "default": "./engine/src/slicer_core.mt.js"
+    },
+    "./viewer": {
+      "types": "./types/viewer.d.ts",
+      "default": "./viewer/dist/Viewport.js"
+    },
+    "./viewer/toolpath": {
+      "types": "./types/viewer-toolpath.d.ts",
+      "default": "./viewer/dist/toolpath_gpu.js"
+    },
+    "./viewer/loaders": {
+      "types": "./types/viewer-loaders.d.ts",
+      "default": "./viewer/dist/model_loaders.js"
+    },
+    "./components": {
+      "types": "./types/components.d.ts",
+      "default": "./components/dist/SettingsPanel.js"
+    },
+    "./data": {
+      "types": "./types/data.d.ts",
+      "default": "./engine/src/data.js"
+    },
+    "./data/*": {
+      "types": "./types/data/*.d.ts",
+      "default": "./data/*"
+    }
   },
   "scripts": {
-    "build": "vite build --config components/vite.config.js && vite build --config viewer/vite.config.js && cp viewer/src/make_worker.js viewer/dist/make_worker.js"
+    "build": "node types/gen_settings_types.mjs && vite build --config components/vite.config.js && vite build --config viewer/vite.config.js && cp viewer/src/make_worker.js viewer/dist/make_worker.js",
+    "check": "bash pack_check.sh"
   },
   "peerDependencies": {
     "react": ">=18",
     "react-dom": ">=18",
     "three": "^0.160.0"
   },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    },
-    "react-dom": {
-      "optional": true
-    },
-    "three": {
-      "optional": true
-    }
-  },
   "devDependencies": {
+    "typescript": "^5.6.0",
     "vite": "^5.4.11"
   },
   "files": [
     "engine",
+    "types",
     "components/dist",
     "viewer/dist",
-    "viewer/src",
     "viewer/styles.css",
     "components/styles.css",
-    "data/*.json",
+    "data/config-schema.json",
+    "data/ui-tree.json",
+    "data/toggle-rules.json",
+    "data/invalidation-map.json",
     "README.md",
     "LICENSE.txt"
   ],

package/types/components.d.ts

@@ -0,0 +1,19 @@
+// three-slicer/components
+import type * as React from 'react'
+import type { SlicerSettings } from './settings-keys.d.ts'
+
+export interface SettingsPanelProps {
+  /** Sparse map — only edited keys. Missing keys fall back to the config-schema default. */
+  settings: SlicerSettings
+  /** React setState shape. The only channel through which state leaves the component. */
+  setSettings: React.Dispatch<React.SetStateAction<SlicerSettings>>
+  /** 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
+  /** Replace schema-driven widgets per key (e.g. `{ printable_area: MyBedEditor }`) */
+  customWidgets?: Record<string, React.ComponentType<any>>
+}
+
+declare const SettingsPanel: React.FC<SettingsPanelProps>
+export default SettingsPanel

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

@@ -0,0 +1,55 @@
+// 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.
+
+/** The coXxx type tag from the upstream ConfigOptionDef */
+export type ConfigOptionType =
+  | 'coBool' | 'coBools'
+  | 'coInt' | 'coInts'
+  | 'coFloat' | 'coFloats'
+  | 'coPercent' | 'coPercents'
+  | 'coFloatOrPercent' | 'coFloatsOrPercents'
+  | 'coString' | 'coStrings'
+  | 'coEnum' | 'coEnums'
+  | 'coPoint' | 'coPoints' | 'coPointsGroups'
+
+/** Of the 907 keys, only `type` and `defined_in` always exist. Everything else is optional. */
+export interface ConfigOption {
+  type: ConfigOptionType
+  /** Name of the source function it was extracted from (e.g. 'init_common_params') */
+  defined_in: string
+  line?: number
+  mode?: string
+  label?: string
+  full_label?: string
+  tooltip?: string
+  sidetext?: string
+  category?: string
+  default?: unknown
+  default_type?: string
+  default_raw?: string
+  enum_type?: string
+  enum_values?: string[]
+  enum_labels?: string[]
+  enum_values_copied_from?: string
+  enum_labels_copied_from?: string
+  min?: number
+  max?: number
+  max_literal?: unknown
+  gui_type?: string
+  gui_flags?: string
+  ratio_over?: string
+  nullable?: boolean
+  readonly?: boolean
+  multiline?: boolean
+  full_width?: boolean
+  height?: number
+  cli?: string
+  cli_params?: string
+  aliases?: string[]
+  plugin_type?: string
+  generated_by_loop?: unknown
+}
+
+declare const schema: Record<string, ConfigOption>
+export default schema

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

@@ -0,0 +1,15 @@
+// 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 {
+  /** The config-schema keys this rule reacts to */
+  keys: string[]
+  /** The invalidated steps (e.g. 'psSkirtBrim', 'posSlice') */
+  steps: string[]
+  /** Special handling that cannot be expressed as a step */
+  special: string[]
+  line?: number
+}
+
+declare const invalidationMap: Record<string, InvalidationRule[]>
+export default invalidationMap

package/types/data/toggle-rules.json.d.ts

@@ -0,0 +1,20 @@
+// 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 {
+  /** The raw C++ expression string. Evaluated by evalEnableIf in three-slicer/toggle. */
+  enable_if?: string
+  /** The config-schema keys governed by this condition */
+  fields?: string[]
+  line?: number
+}
+
+export interface ToggleGroup {
+  /** 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 }
+}
+
+declare const toggles: Record<string, ToggleGroup>
+export default toggles

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

@@ -0,0 +1,19 @@
+// 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
+  /** The config-schema option keys */
+  options: string[]
+}
+
+export interface UIPage {
+  page: string
+  icon?: string
+  line?: number
+  groups: UIGroup[]
+}
+
+declare const uiTree: Record<string, UIPage[]>
+export default uiTree

package/types/data.d.ts

@@ -0,0 +1,17 @@
+// 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'
+import type { InvalidationRule } from './data/invalidation-map.json.d.ts'
+
+export type { ConfigOption, UIPage, ToggleGroup, InvalidationRule }
+
+/** The 907 option definitions */
+export const schema: Record<string, ConfigOption>
+/** Builder name -> page tree */
+export const uiTree: Record<string, UIPage[]>
+/** Group name -> enable_if rules */
+export const toggleRules: Record<string, ToggleGroup>
+/** Setting key change -> invalidated steps */
+export const invalidationMap: Record<string, InvalidationRule[]>