three-slicer 0.2.5 → 0.3.1

package/engine/src/sla_core.js

@@ -10,7 +10,13 @@
 // Determinism: iteration order is the STL's own triangle order, stitching maps insert in encounter order, and
 //  vertices on a slicing plane are pushed up by a fixed epsilon — same input bytes, same output bytes.
 
-const ROLE_CONTOUR = 1          // rendered as 'wall' by the preview's feature colouring
+// The toolpath stream and binary STL layouts. This worker is standalone (no imports), so it keeps its own copy of
+//  numbers the viewer holds in core/toolpath_encoding.js and core/stl_format.js; TOOLPATH_SPEC.md is the contract.
+const STRIDE = 8                // floats per segment: [x0,y0,z0,enc, x1,y1,z1,enc]
+const ROLE_CONTOUR = 1          // ROLE.WALL — rendered as 'wall' by the preview's feature colouring
+const STL_HEADER_BYTES = 80
+const STL_DATA_OFFSET = 84      // header + the uint32 triangle count
+const STL_TRIANGLE_BYTES = 50
 const CONTOUR_WIDTH = 0.2       // display width of a contour segment (SLA has no bead width)
 const PLANE_EPS = 1e-9          // a vertex exactly on a plane counts as above it — deterministic tie-break
 const KEY_SCALE = 1e4           // endpoint welding: 0.1 micrometre grid
@@ -18,13 +24,13 @@ const KEY_SCALE = 1e4           // endpoint welding: 0.1 micrometre grid
 /** Binary STL -> Float32Array of 9 floats per triangle (vertices only; normals are recomputed). */
 export function parseBinarySTL(bytes) {
   if (!(bytes instanceof Uint8Array)) bytes = new Uint8Array(bytes)
-  if (bytes.byteLength < 84) return { error: 'not a binary STL (shorter than its own header)' }
+  if (bytes.byteLength < STL_DATA_OFFSET) return { error: 'not a binary STL (shorter than its own header)' }
   const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-  const count = dv.getUint32(80, true)
-  if (84 + 50 * count !== bytes.byteLength) return { error: 'not a binary STL (triangle count does not match the byte length)' }
+  const count = dv.getUint32(STL_HEADER_BYTES, true)
+  if (STL_DATA_OFFSET + STL_TRIANGLE_BYTES * count !== bytes.byteLength) return { error: 'not a binary STL (triangle count does not match the byte length)' }
   const tris = new Float32Array(count * 9)
   for (let i = 0; i < count; i++) {
-    const base = 84 + 50 * i + 12          // skip the stored normal — recomputed from the winding below
+    const base = STL_DATA_OFFSET + STL_TRIANGLE_BYTES * i + 12   // skip the stored normal — recomputed from the winding below
     for (let f = 0; f < 9; f++) tris[i * 9 + f] = dv.getFloat32(base + 4 * f, true)
   }
   return { tris, count }
@@ -149,15 +155,15 @@ export function sliceSla(stlBytes, params = {}, hooks = {}) {
     for (const pts of loops) { area += loopArea(pts); segCount += pts.length / 2 }
     area = Math.max(0, area)
     volume += area * thickness
-    const paths = new Float32Array(segCount * 8)
+    const paths = new Float32Array(segCount * STRIDE)
     const widths = new Float32Array(segCount)
     let w = 0
     for (const pts of loops) {
       const n = pts.length / 2
       for (let p = 0; p < n; p++) {
         const q = (p + 1) % n
-        paths[w * 8] = pts[p * 2]; paths[w * 8 + 1] = pts[p * 2 + 1]; paths[w * 8 + 2] = top; paths[w * 8 + 3] = ROLE_CONTOUR
-        paths[w * 8 + 4] = pts[q * 2]; paths[w * 8 + 5] = pts[q * 2 + 1]; paths[w * 8 + 6] = top; paths[w * 8 + 7] = ROLE_CONTOUR
+        paths[w * STRIDE] = pts[p * 2]; paths[w * STRIDE + 1] = pts[p * 2 + 1]; paths[w * STRIDE + 2] = top; paths[w * STRIDE + 3] = ROLE_CONTOUR
+        paths[w * STRIDE + 4] = pts[q * 2]; paths[w * STRIDE + 5] = pts[q * 2 + 1]; paths[w * STRIDE + 6] = top; paths[w * STRIDE + 7] = ROLE_CONTOUR
         widths[w] = CONTOUR_WIDTH
         w++
       }

package/engine/src/toggle_eval.js

@@ -1,77 +1,9 @@
-// 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 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
-    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,
-  }
-}
-
-// 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')
-  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'),
-  }
-}
-
-// 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
-  // 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')
-  // 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 }
-}
-
-// 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',
-    '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
-}
+// three-slicer/toggle — the evaluator from the permissive package, bound to upstream's toggle rules.
+// The rules (toggle-rules.json, extracted from OrcaSlicer's toggle_options) and the full schema are this
+// package's data; the evaluator itself is three-slicer-viewer's. Same surface as before the split.
+import { makeToggle, evalEnableIf } from 'three-slicer-viewer/toggle'
+import { toggleRules, schema } from './data.js'
+const bound = makeToggle(toggleRules, schema)
+export const makeCfg = bound.makeCfg
+export const disabledKeys = bound.disabledKeys
+export { evalEnableIf }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-slicer",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "Browser/WASM 3D-printing slicer reverse-engineered from OrcaSlicer: slicing engine (Arachne walls, tree/grid supports, multi-material), SLA resin slicing with PrusaSlicer's ported support/pad chain and .sl1 export, React viewer with GPU toolpath preview, and schema-driven settings UI.",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -39,15 +39,15 @@
     },
     "./viewer/toolpath": {
       "types": "./types/viewer-toolpath.d.ts",
-      "default": "./viewer/dist/toolpath_gpu.js"
+      "default": "./viewer/dist/toolpath_reexport.js"
     },
     "./viewer/loaders": {
       "types": "./types/viewer-loaders.d.ts",
-      "default": "./viewer/dist/model_loaders.js"
+      "default": "./viewer/dist/loaders_reexport.js"
     },
     "./viewer/gcode": {
       "types": "./types/viewer-gcode.d.ts",
-      "default": "./viewer/dist/gcode_parse.js"
+      "default": "./viewer/dist/gcode_reexport.js"
     },
     "./components": {
       "types": "./types/components.d.ts",
@@ -65,7 +65,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "node types/gen_settings_types.mjs && node types/gen_kernel_params.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",
+    "build": "node types/gen_settings_types.mjs && node types/gen_kernel_params.mjs && vite build --config components/vite.config.js && vite build --config viewer/vite.config.js",
     "check": "bash pack_check.sh"
   },
   "peerDependencies": {
@@ -74,9 +74,15 @@
     "three": "^0.160.0"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true },
-    "react-dom": { "optional": true },
-    "three": { "optional": true }
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "three": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "typescript": "^5.6.0",
@@ -84,25 +90,24 @@
   },
   "files": [
     "engine",
-    "!engine/**/.omc",
     "types",
-    "!**/test_*.mjs",
+    "!**/tests/**",
     "!types/gen_*.mjs",
     "components/dist",
     "viewer/dist",
-    "viewer/styles.css",
-    "components/styles.css",
     "data",
+    "data/ui-tree-keys.json",
+    "data/config-schema-lean.json",
     "!data/config-schema-builddump.json",
-    "!data/**/.omc",
     "README.md",
     "CHANGELOG.md",
     "THIRD-PARTY-NOTICES.md",
-    "LICENSE.txt"
+    "LICENSE.txt",
+    "!**/.omc"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kimgh06/Web_Three_Slicer.git",
+    "url": "git+https://github.com/kimgh06/Three_Slicer.git",
     "directory": "packages"
   },
   "homepage": "https://slicer.kimgh06.com",
@@ -127,6 +132,8 @@
     "3d",
     "mesh",
     "clipping"
-  ]
+  ],
+  "dependencies": {
+    "three-slicer-viewer": "0.3.1"
+  }
 }
-

package/types/client.d.ts

@@ -86,3 +86,6 @@ export interface SlicerClient {
  */
 export function createSlicerClient(worker?: Worker): SlicerClient
 export default createSlicerClient
+
+/** The WASM kernel's worker, as a factory — what `three-slicer-viewer`'s `useSlicer` takes as `deps.makeWorker`. */
+export function makeSlicerWorker(): Worker

package/types/components.d.ts

@@ -1,29 +1,3 @@
-// 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>>
-  /**
-   * Pins the panel to one builder (optionally one page) and drops the search/group/page/mode chrome, so the form
-   * can be folded into another card. This is how `<Viewport/>`'s `motionPanel` slot is meant to be filled:
-   *
-   * ```jsx
-   * <SettingsPanel settings={settings} setSettings={setSettings} embedded
-   *                only={{ builder: 'TabPrinter::build_kinematics_page' }} />
-   * ```
-   */
-  only?: { builder: string; page?: string }
-}
-
-declare const SettingsPanel: React.FC<SettingsPanelProps>
-export default SettingsPanel
+// three-slicer/components — the permissive settings panel with upstream's data plugged in. Same surface.
+export * from 'three-slicer-viewer/components'
+export { default } from 'three-slicer-viewer/components'

package/types/settings.d.ts

@@ -172,6 +172,18 @@ export function printerDefaultPreset(profileName: string): string
 /** The schema keys the kernel's machine limits are read from — for UI that shows which ones are in play. */
 export const machineLimitKeys: string[]
 
+/** deriveKernelParams' fallbacks when neither the settings map nor the schema gives a usable value, keyed by schema
+ *  key. NOT the schema defaults — several differ on purpose. Frozen. */
+export const FFF_FALLBACKS: Readonly<Record<string, number | boolean | string>>
+/** deriveSlaParams' fallbacks (its reader treats non-positive values as absent). Frozen. */
+export const SLA_FALLBACKS: Readonly<Record<string, number>>
+/** What `line_width` 0 ("auto") resolves to. */
+export const AUTO_LINE_WIDTH: number
+/** The bed when `printable_area` is empty or malformed — the bbox of the schema's own default. */
+export const BED_FALLBACK: Readonly<{ width: number; depth: number }>
+/** Kernel machine-limit parameter -> [schema key, fallback]. Frozen. */
+export const MACHINE_LIMITS: Readonly<Record<string, readonly [string, number]>>
+
 // ---- Lazily loaded presets --------------------------------------------------
 // Both facades hide the column layout of the artifact they wrap; the promise is created once and reused.
 
@@ -201,3 +213,6 @@ export interface FilamentPresetsApi {
   settingsFor(presetName: string): SlicerSettings | null
 }
 export function filamentPresets(): Promise<FilamentPresetsApi>
+
+/** The nine catalog lookups above as one object — what `three-slicer-viewer`'s `<Viewport catalog>` takes. */
+export const bundledCatalog: import('three-slicer-viewer').Catalog

package/types/toggle.d.ts

@@ -1,22 +1,2 @@
-// three-slicer/toggle — partial evaluation of the enable_if expressions in toggle-rules.json.
-import type { SlicerSettings } from './settings-keys.d.ts'
-
-/** 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
-  /** Whether the key exists in config-schema */
-  has(key: string): boolean
-}
-
-export function makeCfg(settings: SlicerSettings | null | undefined): ToggleCfg
-
-/**
- * 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
-
-/** 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>
+// three-slicer/toggle — the permissive evaluator bound to upstream's toggle rules. Same surface.
+export * from 'three-slicer-viewer/toggle'

package/types/viewer-gcode.d.ts

@@ -1,29 +1,2 @@
-// three-slicer/viewer/gcode — G-code text -> kernel-shaped layer stream (renderable without slicing).
-// Feed the returned layers straight into buildSegmentData (three-slicer/viewer/toolpath).
-
-export interface GcodeLayer {
-  z: number
-  /** Stride 8: [x0,y0,z0,enc, x1,y1,z1,enc] per segment, enc = role + tool*16 (role 0 = travel). */
-  paths: Float32Array
-  /** One entry per segment; 0 means "use the default line width". */
-  widths: Float32Array
-}
-
-export interface ParseGcodeResult {
-  layers: GcodeLayer[]
-  stats: { layers: number; path_segments: number; travel_segments: number; tools: number[] }
-}
-
-export interface ParseGcodeOptions {
-  /** Used to derive bead width from E when the file has no ;WIDTH: comments. Default 1.75. */
-  filamentDiameter?: number
-  /** Bead-height fallback when a layer's height cannot be inferred from z steps. Default 0.2. */
-  defaultLayerHeight?: number
-}
-
-/**
- * Parses G0/G1/G2/G3 (I/J arcs), G90/G91, M82/M83, G92, T<n>, and the layer/role comment conventions of
- * OrcaSlicer/PrusaSlicer (;TYPE: ;WIDTH: ;LAYER_CHANGE ;Z:), Cura (;TYPE: ;LAYER:) and this kernel's own output.
- * Recovery is lossy where G-code carries no data: unknown roles become wall(1), widths are derived from E.
- */
-export function parseGcode(text: string, opts?: ParseGcodeOptions): ParseGcodeResult
+// Re-exported from the permissive package (MIT), where the implementation now lives.
+export * from 'three-slicer-viewer/gcode'

package/types/viewer-loaders.d.ts

@@ -1,33 +1 @@
-// three-slicer/viewer/loaders — pure loaders, independent of the kernel.
-
-/** The 5 built-ins plus any extension registered via `registerLoader()`, which pushes onto this array. */
-export const SUPPORTED_EXT: string[]
-
-/** Lowercased extension. Empty string when there is no dot. */
-export function fileExt(name: string): string
-
-export interface LoadedObject {
-  name: string
-  /** Triangle vertex coordinates (N*9, model z-up) */
-  modelPos: Float32Array
-}
-
-/** A single file may contain several objects (3mf/amf/step) -> always an array. */
-export function loadModel(name: string, buffer: ArrayBuffer): Promise<LoadedObject[]>
-
-/**
- * Registers an extra format. Formats needing heavy dependencies (STEP=OCCT WASM, etc.) are not bundled here,
- * so the app wires them up itself. The `<Viewport/>` file dialog and drag-and-drop filters pick them up automatically.
- *
- * ```js
- * import { registerLoader } from 'three-slicer/viewer/loaders'
- * registerLoader('step,stp', async (buffer, name) => [{ name, modelPos }])
- * ```
- */
-export function registerLoader(
-  exts: string | string[],
-  fn: (buffer: ArrayBuffer, name: string) => LoadedObject[] | Promise<LoadedObject[]>,
-): void
-
-/** Connected-component split. Returns `null` when there is only one component (cannot split) — not an empty array. */
-export function splitConnectedComponents(localPos: Float32Array): Float32Array[] | null
+export * from 'three-slicer-viewer/loaders'

package/types/viewer-toolpath.d.ts

@@ -1,113 +1,3 @@
-// three-slicer/viewer/toolpath — kernel layers -> GPU-instanced toolpath.
-// Does not import three: makeToolpath takes the THREE namespace as an argument (guaranteeing a single instance).
-
-/** The 24 triangle indices of the 8-vertex diamond cross-section (from SegmentTemplate.cpp:18) */
-export const VERTEX_DATA: number[]
-
-/** Toolpath type -> color. 0=travel, 1=wall … 11=prime */
-export const TYPE_COLOR: Record<number, number[]>
-export const TYPE_LABEL: Record<number, string>
-
-/**
- * Per-extruder colors for the Filament view. Categorical, not semantic — the toolpath stream carries a tool index and
- * nothing about the material, and a machine may have more extruders than entries, so index it modulo its length.
- */
-export const TOOL_COLOR: number[][]
-
-/** Blue-to-red 11-color heatmap (libvgcode ColorRange.hpp:14) */
-export const DEFAULT_RANGES_COLORS: number[][]
-
-export interface ViewTypeDef {
-  key: 'feature' | 'speed' | 'height' | 'width' | 'fan' | 'temp' | 'filament'
-  label: string
-  /** Whether values are continuous (heatmap). False means a fixed color. */
-  cont: boolean
-  unit: string
-}
-export const VIEW_TYPES: ViewTypeDef[]
-
-/** Per-vertex extra data */
-export interface SegmentMeta {
-  vType: Uint8Array
-  /** Printing extruder, decoded out of the role field's high bits. Untooled output decodes to 0, i.e. single material. */
-  vTool: Uint8Array
-  vWidth: Float32Array
-  vHeight: Float32Array
-  vLayer: Int32Array
-}
-
-export interface SegmentData {
-  position: Float32Array
-  hwa: Float32Array
-  segIndex: Uint32Array
-  nV: number
-  nSeg: number
-  layerSegPrefix: Uint32Array
-  travelPos: Float32Array
-  travelPrefix: Uint32Array
-  nTrav: number
-  layerCount: number
-  maxAbs: number
-  hasNaN: boolean
-  meta: SegmentMeta
-  /** Total extruded length per type (index = toolpath type, length 16) */
-  typeLengths: Float64Array
-  /** Null when there is not a single vertex */
-  bbox: { min: [number, number, number]; max: [number, number, number] } | null
-}
-
-/** Kernel layers[{z, paths(stride8), widths[]}] -> GPU stream. */
-export function buildSegmentData(layers: unknown[], defaultLineWidth: number): SegmentData
-
-/** Length share per type (%), descending by pct. The kernel does not expose time per role, so length is used as an approximation. */
-export function roleRatios(typeLengths: Float64Array | number[]): Array<{
-  type: number
-  label: string
-  pct: number
-  color: number[]
-}>
-
-/**
- * speed/fan/temp are absent from the kernel toolpath and derived from settings — these are the values used for that.
- */
-export interface ColorContext {
-  speedByType?: Record<number, number>
-  firstLayerSpeed?: number
-  fanByType?: Record<number, number>
-  fanFirstLayers?: number
-  tempNormal?: number
-  tempFirst?: number
-  closeFanLayers?: number
-}
-
-export interface ColorResult {
-  /** Per-vertex RGBA (nV*4). The color is packed into `.r`. */
-  color: Float32Array
-  min: number
-  max: number
-  viewType: ViewTypeDef['key']
-  label: string
-  unit: string
-  /** False means fixed colors — min/max are 0 and no legend should be drawn. */
-  cont: boolean
-}
-
-export function computeColors(data: SegmentData, viewType: ViewTypeDef['key'], ctx: ColorContext): ColorResult
-
-export interface ToolpathHandle {
-  /** THREE.Mesh — typed by the THREE namespace passed in */
-  mesh: any
-  /** THREE.LineSegments (travel) */
-  travLines: any
-  setLayerRange(lo: number, hi: number): void
-  /** Backwards compatible — same as setLayerRange(0, n-1). */
-  setVisibleLayers(n: number): void
-  setTravelVisible(visible: boolean): void
-  setColors(color: Float32Array): void
-  dispose(): void
-  nSeg: number
-  layerCount: number
-}
-
-/** @param THREE - the `import * as THREE from 'three'` namespace. The consumer's instance is used as-is. */
-export function makeToolpath(THREE: any, data: SegmentData): ToolpathHandle
+// Re-exported from the permissive package (MIT), where the implementation now lives.
+// three-slicer/viewer/toolpath stays a valid entry point for every existing consumer.
+export * from 'three-slicer-viewer'