three-slicer 0.1.0

package/engine/README.md

@@ -0,0 +1,52 @@
+# three-slicer
+
+Browser/WASM 3D-slicing kernel reverse-engineered from [OrcaSlicer](https://github.com/OrcaSlicer/OrcaSlicer). Slices binary STL to G-code entirely client-side (or in Node) — no server, no native binaries.
+
+**No three.js dependency.** This is a headless SDK; the only dependency is `@three-slicer/data` (config metadata JSON). For a ready-made React viewer see `three-slicer/viewer`.
+
+Ported from the original C++ sources: Clipper polygon ops, Arachne variable-width walls, real fill patterns (gyroid TPMS / honeycomb / 3D-honeycomb / crosshatch / concentric), tree supports, pressure equalizer, arc fitting (G2/G3), scarf seams, ironing, multi-material with prime tower. Kernel changes are gated by a 120+ invariant test suite and golden byte-identical G-code checks.
+
+## Install
+
+```bash
+npm i three-slicer
+```
+
+## Usage
+
+```js
+import { createSlicer } from 'three-slicer'
+
+const slicer = await createSlicer()               // loads the WASM kernel (~3.4 MB, base64-inlined)
+
+// Batch: full result at once
+const r = slicer.slice(stlArrayBuffer, { layer_height: 0.2, wall_loops: 2 })
+console.log(r.stats.layers, r.gcode.length)
+
+// Streaming: per-layer callbacks, frees each layer (OOM-resilient); result carries stats only
+slicer.slice(stlArrayBuffer, params, {
+  onProgress: (done, total) => {},
+  onLayer: ({ z, idx, gcode, paths, widths }) => { /* accumulate */ },
+})
+slicer.dispose()
+```
+
+Off-main-thread (browser): `new Worker(engineWorkerURL(), { type: 'module' })` — the worker speaks a streaming protocol (`{type: 'layer' | 'done' | 'error' | 'progress'}`). Subpath `three-slicer/worker` exposes the worker entry for bundler-specific setups.
+
+## Parameters
+
+Two levels — use whichever fits:
+
+1. **Kernel params (this package's native contract)** — a flat JSON object of ~50 keys (`layer_height`, `wall_loops`, `infill_density` 0–1, `sparse_infill_pattern`, `enable_support`, `wall_generator: 'classic' | 'arachne'`, …). See `src/settings.js` for the full shape.
+2. **OrcaSlicer settings map** — a sparse `{schemaKey: value}` map using original OrcaSlicer option keys (907 defined in `@three-slicer/data`); unset keys fall back to schema defaults:
+
+```js
+import { deriveKernelParams } from 'three-slicer/settings'
+slicer.slice(stl, deriveKernelParams({ layer_height: 0.25, sparse_infill_density: 15 }))
+```
+
+**Known limit:** `deriveKernelParams` maps a curated whitelist of ~50 schema keys to kernel params. Editing other schema keys has no slicing effect (they exist for UI/metadata). Vector options use their first element only.
+
+## License
+
+AGPL-3.0-or-later (derived from OrcaSlicer). A web app embedding this package must comply with AGPL — including offering its source to network users.

package/engine/examples/headless.mjs

@@ -0,0 +1,37 @@
+// 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'   // 워크스페이스 심링크로 해석 — 외부 소비자와 동일한 경로
+
+// minimal binary-STL writer for a box (public API takes a binary-STL ArrayBuffer)
+function boxTris(ox, oy, oz, sx, sy, sz) {
+  const c = [[0,0,0],[sx,0,0],[sx,sy,0],[0,sy,0],[0,0,sz],[sx,0,sz],[sx,sy,sz],[0,sy,sz]].map(v => [v[0]+ox, v[1]+oy, v[2]+oz])
+  const q = (a,b,cc,d) => [[c[a],c[b],c[cc]],[c[a],c[cc],c[d]]]
+  return [...q(0,1,2,3), ...q(4,5,6,7), ...q(0,1,5,4), ...q(1,2,6,5), ...q(2,3,7,6), ...q(3,0,4,7)]
+}
+function trisToSTL(tris) {
+  const buf = Buffer.alloc(84 + tris.length*50); buf.writeUInt32LE(tris.length, 80); let off = 84
+  for (const t of tris) { off += 12; for (const p of t){ buf.writeFloatLE(p[0],off); buf.writeFloatLE(p[1],off+4); buf.writeFloatLE(p[2],off+8); off += 12 } buf.writeUInt16LE(0,off); off += 2 }
+  return buf
+}
+const cube = trisToSTL(boxTris(-10,-10,0, 20,20,20))
+const params = {
+  layer_height: 0.2, first_layer_height: 0.2, line_width: 0.42, wall_loops: 2, infill_density: 0.15,
+  nozzle_diameter: 0.4, filament_diameter: 1.75, print_speed: 60, first_layer_speed: 20, travel_speed: 150,
+  nozzle_temp: 210, bed_temp: 60, top_shell_layers: 3, bottom_shell_layers: 3, skirt_loops: 1,
+}
+
+const slicer = await createSlicer()
+
+// (a) batch slice
+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
+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`)
+
+if (r.gcode.length > 0 && chunks > 0) console.log('OK — three-slicer drives headlessly via the public API')
+else { console.error('FAIL'); process.exit(1) }
+slicer.dispose()

package/engine/index.d.ts

@@ -0,0 +1,29 @@
+// Type definitions for @three-slicer/engine
+export interface SliceLayer { z: number; idx: number; gcode: string; paths: Float32Array; widths: Float32Array }
+export interface SliceCallbacks {
+  onProgress?: (done: number, total: number) => void
+  onLayer?: (layer: SliceLayer) => void
+}
+export interface SliceStats {
+  layers: number; model_layers: number; raft_layers: number;
+  path_segments: number; filament_mm: number; time_estimate: number;
+  streamed?: boolean; economy?: boolean; [k: string]: unknown
+}
+export interface SliceResult { gcode?: string; stats: SliceStats; layers?: unknown[]; error?: string }
+export interface PaintArgs {
+  facet: number; hx: number; hy: number; hz: number;
+  cx: number; cy: number; cz: number; radius: number; enforcer: boolean
+}
+export interface Slicer {
+  slice(stl: ArrayBuffer | Uint8Array, params: object | string, cb?: SliceCallbacks): SliceResult
+  paintPrepare(stl: ArrayBuffer | Uint8Array): number
+  paint(args: PaintArgs): { enf: number; blk: number }
+  paintClear(): void
+  overlay(enforcer: boolean): number[]
+  heapSize(): number
+  module: unknown
+  dispose(): void
+}
+export function createSlicer(): Promise<Slicer>
+export function engineWorkerURL(): URL
+export default createSlicer

package/engine/index.js

@@ -0,0 +1,45 @@
+// three-slicer — browser/WASM 3D-slicing SDK (reverse-engineered from OrcaSlicer).
+// Public API. Node-safe (imports only the pure-JS WASM factory; no JSON so it loads in plain Node ESM).
+// Schema-driven helpers (deriveKernelParams etc.) live in the "three-slicer/settings" subpath because
+// they import JSON — use them in a bundler (vite) or with Node JSON import attributes.
+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'}).
+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.
+//  slice(stl, params, { onProgress, onLayer }):
+//    - 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
+//      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).
+//  heapSize(): current WASM heap bytes (peak, monotonic). module: escape hatch. dispose(): drop the module.
+export async function createSlicer() {
+  const M = await createModule()
+  return {
+    slice(stl, params, { onProgress, onLayer } = {}) {
+      const p = typeof params === 'string' ? params : JSON.stringify(params || {})
+      if (onLayer) M.set_layer_sink((z, idx, gcode, paths, widths) => onLayer({ z, idx, gcode, paths, widths }))
+      try { return M.slice(u8(stl), p, onProgress || (() => {})) }
+      finally { if (onLayer) M.clear_layer_sink() }
+    },
+    paintPrepare(stl) { M.selector_prepare(u8(stl)); return M.selector_facet_count() },
+    paint(a) {
+      M.selector_paint(a.facet, a.hx, a.hy, a.hz, a.cx, a.cy, a.cz, a.radius, a.enforcer)
+      return { enf: M.selector_painted_count(true), blk: M.selector_painted_count(false) }
+    },
+    paintClear() { M.selector_clear() },
+    overlay(enforcer) { return Array.from(M.selector_overlay(!!enforcer)) },
+    heapSize() { return M.heap_size() },
+    module: M,
+    dispose() { /* emscripten module is GC'd when dropped; no explicit teardown required */ },
+  }
+}
+
+export default createSlicer

package/engine/src/settings.js

@@ -0,0 +1,130 @@
+// 우측 설정 패널(편집 가능)의 실제 값 → 커널 슬라이스 파라미터 매핑.
+//  - 설정 상태는 sparse 맵(key→value): 편집한 키만 저장, 없으면 config-schema default.
+//  - 벡터형(coFloats/coInts 등)은 첫 원소만 사용/편집(단순화).
+import schema from 'three-slicer/data/config-schema.json'
+
+export function schemaDefault(key) { return schema[key]?.default }
+export function settingRaw(settings, key) { return (settings && key in settings) ? settings[key] : schemaDefault(key) }
+// 스칼라(벡터면 [0]) 로 정규화
+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) + 기존 근사 패턴
+const KERNEL_PATTERNS = ['rectilinear', 'grid', 'triangles', 'zigzag', 'gyroid', 'gyroid_approx',
+  'honeycomb', '3dhoneycomb', 'crosshatch', 'concentric']
+const KERNEL_SEAMS = ['nearest', 'aligned', 'back', 'random']
+
+// 우측 패널 설정값 → 커널 파라미터 (스키마 키에서 유도)
+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 pat = String(S('sparse_infill_pattern') ?? 'rectilinear')
+  if (!KERNEL_PATTERNS.includes(pat)) pat = 'rectilinear'                     // 커널 미지원 패턴 → 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.
+  const styleRaw = String(S('support_style') ?? 'default')
+  const support_style = /tree|organic/i.test(styleRaw) ? 'tree' : 'grid'
+
+  // 베드: printable_area 첫 사각형의 바운딩박스
+  const pa = settingRaw(settings, 'printable_area')
+  let bed_width = 256, bed_depth = 256
+  if (Array.isArray(pa) && pa.length) {
+    const xs = pa.map(p => p[0]), ys = pa.map(p => p[1])
+    bed_width = Math.max(...xs) - Math.min(...xs); bed_depth = Math.max(...ys) - Math.min(...ys)
+  }
+
+  // 21단계: 피처별 폭 — 원본(문자열 "120%" 포함) 그대로 커널로 전달. 미편집 키는 생략 → 커널이 auto(=line_width) 유도.
+  //  0=자동 시맨틱은 커널 resolve_lw(원본 Flow 산식)이 처리. 기본값 불변(모든 피처 미설정 → 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
+  }
+  return {
+    ...widths,
+    layer_height: num('layer_height', 0.2),
+    first_layer_height: num('initial_layer_print_height', 0.2),
+    line_width,
+    wall_loops: num('wall_loops', 2),
+    infill_density: num('sparse_infill_density', 20) / 100,      // % → 0~1
+    sparse_infill_pattern: pat,
+    infill_angle: num('infill_direction', 45),
+    top_shell_layers: num('top_shell_layers', 4),
+    bottom_shell_layers: num('bottom_shell_layers', 3),
+    seam_position: seam,
+    skirt_loops: num('skirt_loops', 1),
+    skirt_distance: num('skirt_distance', 2),
+    skirt_height: num('skirt_height', 1),                       // 33단계: 커널이 첫 레이어 고정이었음
+    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단계: 트리 서포트 경로 단순화 허용오차
+    retract_speed: num('retraction_speed', 30),
+    z_hop: num('z_hop', 0.4),
+    travel_speed: num('travel_speed', 120),
+    first_layer_speed: num('initial_layer_speed', 30),
+    print_speed: num('outer_wall_speed', 60),
+    nozzle_diameter: num('nozzle_diameter', 0.4),
+    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_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_xy_distance: num('support_object_xy_distance', 0.35),
+    support_interface_top_layers: num('support_interface_top_layers', 2),
+    // 33단계: 커널 하드코딩 제거로 신설된 서포트 키 배선(원본 스키마 키 그대로)
+    support_angle: num('support_angle', 0),
+    support_base_pattern: String(S('support_base_pattern') ?? 'default'),
+    support_interface_pattern: String(S('support_interface_pattern') ?? 'auto'),
+    support_interface_spacing: num('support_interface_spacing', 0.5),
+    support_base_pattern_spacing: num('support_base_pattern_spacing', 2.5),
+    support_remove_small_overhang: bool('support_remove_small_overhang', true),
+    bridge_no_support: bool('bridge_no_support', false),
+    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 (압출폭 비율)
+    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
+    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 심
+    enable_pressure_advance: bool('enable_pressure_advance', false),
+    pressure_advance: num('pressure_advance', 0.02),
+    support_style,                                                 // grid|tree_lite (위에서 매핑)
+    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)
+    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, 가변폭)
+    wall_generator: (String(S('wall_generator') ?? 'classic') === 'arachne') ? 'arachne' : 'classic',
+    // support_density 는 스키마에 대응 키가 없어 커널 기본(0.15), scarf_length 도 커널 기본(10mm) 사용
+  }
+}

package/engine/src/slicer.worker.js

@@ -0,0 +1,73 @@
+// 슬라이스를 메인 스레드 밖에서 실행 (UI 논블록) + 30단계 레이어 스트리밍.
+// Vite module worker: new Worker(new URL('./slicer.worker.js', import.meta.url), { type: 'module' }).
+// SINGLE_FILE 이라 slicer_core.js 안에 wasm 이 인라인 → worker 에서도 외부 fetch 없음.
+//
+// 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 폴백.
+const loadCore = async () => {
+  const isolated = typeof crossOriginIsolated !== 'undefined' && crossOriginIsolated
+  if (isolated) {
+    try {
+      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) }
+  }
+  const M = await (await import('./slicer_core.js')).default()
+  console.info('[slicer.worker] core: st')
+  return M
+}
+
+let modPromise = null
+
+self.onmessage = async (e) => {
+  const d = e.data
+  try {
+    if (!modPromise) modPromise = loadCore()
+    const Module = await modPromise
+    // 워밍업: 커널 로드(+mt pthread 풀 스폰)만 미리 수행 — 첫 슬라이스의 체감 로딩 제거
+    if (d.cmd === 'warmup') { self.postMessage({ type: 'warm' }); return }
+    // 20단계: 수동 서포트 페인팅 — selector 상태는 이 worker Module 에 지속(슬라이스도 같은 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 (!self.__supSabSent) {
+      self.__supSabSent = true
+      try {
+        // Module.HEAPU8 은 emscripten 6.x 글루가 노출하지 않음 — embind typed_memory_view 로 버퍼 획득
+        const v = Module.sup_progress_view && Module.sup_progress_view()
+        if (v && v.buffer instanceof SharedArrayBuffer)
+          self.postMessage({ type: 'supsab', buf: v.buffer, ptr: v.byteOffset })
+      } catch {}
+    }
+    // 기본: 슬라이스. 레이어 싱크 등록 → 커널이 레이어마다 콜백(z, idx, gcodeChunk, pathsF32, widthsF32).
+    //  각 레이어를 즉시 메인으로 transfer(툴패스 버퍼 이전) → worker 사본 해제 → 다음 레이어 전 힙 여유.
+    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 (widths && widths.buffer) transfer.push(widths.buffer)
+      self.postMessage({ type: 'layer', z, idx, gcode, paths, widths }, transfer)
+    })
+    let r
+    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 에 그대로.
+    self.postMessage({ type: 'done', result: r })
+  } catch (err) {
+    // WASM abort("memory access out of bounds") 포함 — 메인의 OOM 사다리가 재생성/절약 재시도 판정.
+    self.postMessage({ type: 'error', error: String((err && err.message) || err) })
+  }
+}

package/engine/src/toggle_eval.js

@@ -0,0 +1,78 @@
+// 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'
+
+// 설정값 접근기 (settings 맵 우선, 없으면 스키마 default). 퍼센트("15%")는 숫자로.
+export function makeCfg(settings) {
+  const val = k => {
+    let v = settings ? settings[k] : undefined
+    if (v === undefined || v === '') { const d = schema[k]?.default; v = Array.isArray(d) ? d[0] : d }
+    return v
+  }
+  const num = k => { const v = val(k); const n = parseFloat(v); return Number.isFinite(n) ? n : 0 }
+  return {
+    bool: k => { const v = val(k); return v === true || v === 1 || v === '1' || v === 'true' },
+    int: k => Math.trunc(num(k)),
+    float: k => num(k),
+    has: k => k in schema,
+  }
+}
+
+// 원본 locals 를 인라인 번역(뷰어 관련 조건만). 각 값은 boolean.
+function makeLocals(cfg) {
+  const have_raft = cfg.int('raft_layers') > 0
+  const has_spiral_vase = cfg.bool('spiral_mode')
+  const has_top_shell = cfg.int('top_shell_layers') > 0 || (has_spiral_vase && cfg.int('bottom_shell_layers') > 1)
+  const has_bottom_shell = cfg.int('bottom_shell_layers') > 0
+  return {
+    have_raft,
+    have_perimeters: cfg.int('wall_loops') > 0,
+    have_infill: cfg.float('sparse_infill_density') > 0,
+    has_spiral_vase,
+    has_top_shell,
+    has_bottom_shell,
+    has_solid_infill: has_top_shell || has_bottom_shell,
+    have_skirt: cfg.int('skirt_loops') > 0,
+    have_support_material: cfg.bool('enable_support') || have_raft,
+    have_support_interface: cfg.int('support_interface_top_layers') > 0 || cfg.int('support_interface_bottom_layers') > 0,
+    have_prime_tower: cfg.bool('enable_prime_tower'),
+  }
+}
+
+// enable_if(첫 콤마부) 를 boolean 으로 평가. 완전 번역 불가하면 null(=활성 유지).
+export function evalEnableIf(expr, locals, cfg) {
+  let s = String(expr).split(',')[0].trim()
+  if (!s) return null
+  // 직접 config 접근 패턴 → 값 치환
+  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)))
+  // 알려진 로컬 치환(긴 이름 먼저 — 부분매칭 방지)
+  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
+  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 인 규칙만.
+export function disabledKeys(cfg) {
+  const locals = makeLocals(cfg)
+  const groups = ['toggle_print_fff_options', 'toggle_filament_options', 'toggle_printer_options',
+    'TabFilament::toggle_options', 'TabPrinter::toggle_options']
+  const out = {}
+  for (const gname of groups) {
+    const g = toggles[gname]
+    if (!g || !Array.isArray(g.rules)) continue
+    for (const rule of g.rules) {
+      if (!rule.enable_if || !Array.isArray(rule.fields)) continue
+      const en = evalEnableIf(rule.enable_if, locals, cfg)
+      if (en === false) for (const k of rule.fields) if (!(k in out)) out[k] = rule.enable_if
+    }
+  }
+  return out
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "three-slicer",
+  "version": "0.1.0",
+  "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"
+    },
+    "./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/*"
+  },
+  "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"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18",
+    "three": "^0.160.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "three": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "vite": "^5.4.11"
+  },
+  "files": [
+    "engine",
+    "components/dist",
+    "viewer/dist",
+    "viewer/src",
+    "viewer/styles.css",
+    "components/styles.css",
+    "data/*.json",
+    "README.md",
+    "LICENSE.txt"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kimgh06/Web_Three_Slicer.git",
+    "directory": "packages"
+  },
+  "homepage": "https://github.com/kimgh06/Web_Three_Slicer#readme",
+  "keywords": [
+    "3d-printing",
+    "slicer",
+    "gcode",
+    "stl",
+    "wasm",
+    "orcaslicer",
+    "three",
+    "react",
+    "arachne",
+    "tree-support"
+  ]
+}

package/viewer/README.md

@@ -0,0 +1,68 @@
+# three-slicer/viewer
+
+3D slicer viewer as a React component: three.js viewport (orbit/transform gizmos), model import (STL/OBJ/3MF/AMF/PLY, multi-object, drag & drop), Web Worker slicing via `three-slicer`, support painting, multi-plate, and a GPU-instanced volumetric toolpath preview ported from OrcaSlicer's libvgcode (millions of segments in a single draw path, per-feature colors, layer range slider, G-code export).
+
+```bash
+npm i three-slicer/viewer react react-dom three@^0.160.0
+```
+
+```jsx
+import { useState } from 'react'
+import Viewport from 'three-slicer/viewer'
+import 'three-slicer/viewer/styles.css'
+
+function App() {
+  const [settings, setSettings] = useState({})   // OrcaSlicer schema keys; sparse — defaults fill the rest
+  return <Viewport settings={settings} setSettings={setSettings} />
+}
+```
+
+Slice parameters are derived from `settings` via `three-slicer`'s schema mapping — pair it with `three-slicer/components`' `<SettingsPanel/>` sharing the same state for a full slicer UI.
+
+Props: `settings`, `setSettings`, `processPanel` (optional React node rendered in the right sidebar).
+
+Subpath exports for custom UIs (framework-free, no React):
+- `three-slicer/viewer/toolpath` — GPU toolpath renderer (`buildSegmentData`, `makeToolpath`, view-type colorers)
+- `three-slicer/viewer/loaders` — model loaders returning unified triangle soup
+
+## Multithreaded slicing (automatic)
+
+The engine ships two WASM kernels: single-threaded (default) and `-pthread` multithreaded (~2× wall-clock on layer-parallel wall generation, measured 12× on the wall pass itself). The worker picks the mt kernel automatically when the page is [cross-origin isolated](https://developer.mozilla.org/en-US/docs/Web/API/Window/crossOriginIsolated) — i.e. served with:
+
+```
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
+```
+
+No headers → falls back to the single-threaded kernel. Nothing else to change.
+
+## Bundler notes
+
+- **Vite:** two config lines (worker code-splitting + top-level await in the mt glue; Chrome 89+/Safari 15+):
+
+```js
+// vite.config.js
+export default defineConfig({
+  worker: { format: 'es' },
+  build: { target: 'es2022' },
+})
+```
+
+- **Next.js / webpack:** render client-side (`dynamic(..., { ssr: false })`) and alias the emscripten glue's Node-only guards away:
+
+```js
+// next.config.js
+module.exports = {
+  webpack: (config) => {
+    for (const m of ['node:module', 'node:fs', 'node:path', 'node:url', 'node:crypto', 'node:worker_threads'])
+      config.resolve.alias[m] = false
+    return config
+  },
+}
+```
+
+`three` is a peer dependency pinned to `^0.160` (TransformControls API; r169+ changed its Object3D contract).
+
+## License
+
+AGPL-3.0-or-later (derived from OrcaSlicer). A web app embedding this package must comply with AGPL — including offering its source to network users.