three-slicer 0.2.4 → 0.3.0

package/engine/src/slicer.worker.js

@@ -28,17 +28,22 @@ const paramsText = (params) => (typeof params === 'string' ? params : JSON.strin
 let quiet = false
 const say = (level, ...args) => { if (!quiet) console[level](...args) }
 
+// Which variant loaded is also REPORTED (the 'warm' reply carries `kernel`), not just logged: mt vs st is a
+//  measured 9.8x on a 3M-facet model, and the viewer sizes its plate-parallel worker pool by it.
+let kernelKind = null
 const loadCore = async () => {
   const isolated = typeof crossOriginIsolated !== 'undefined' && crossOriginIsolated
   if (isolated) {
     try {
       const M = await (await import('./slicer_core.mt.js')).default()
       say('info', '[slicer.worker] core: mt (threads)')
+      kernelKind = 'mt'
       return M
     } catch (e) { say('warn', '[slicer.worker] mt load failed — falling back to st:', e) }
   }
   const M = await (await import('./slicer_core.js')).default()
   say('info', '[slicer.worker] core: st')
+  kernelKind = 'st'
   return M
 }
 
@@ -213,7 +218,7 @@ self.onmessage = async (e) => {
     if (!modPromise) modPromise = loadCore()
     const Module = await modPromise
     // 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 }
+    if (d.cmd === 'warmup') { self.postMessage({ type: 'warm', kernel: kernelKind }); return }
     // Stage 20: manual support painting — selector state persists in this worker Module (slicing uses the same Module).
     // `keepPaint` says the mesh is the same model in a new place, so the marks carry over — the reply reports whether
     //  they actually did, since a face-count change makes the kernel fall back to a clean registration.

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.4",
+  "version": "0.3.0",
   "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",
@@ -93,6 +99,8 @@
     "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",
@@ -127,6 +135,8 @@
     "3d",
     "mesh",
     "clipping"
-  ]
+  ],
+  "dependencies": {
+    "three-slicer-viewer": "0.3.0"
+  }
 }
-

package/types/client.d.ts

@@ -35,8 +35,8 @@ export interface SlicerClient {
   /** The worker being driven — for a host that also wants to listen in. */
   worker: Worker
 
-  /** Load the kernel ahead of the first slice. */
-  warmup(): Promise<void>
+  /** Load the kernel ahead of the first slice. Resolves with which variant loaded ('mt' threads / 'st'). */
+  warmup(): Promise<{ kernel: 'mt' | 'st' | null }>
 
   /** `params` may be an object; it is stringified for you, which the raw protocol does not do. */
   slice(stl: ArrayBuffer | Uint8Array, params: object | string, cb?: ClientSliceCallbacks): Promise<SliceResult>
@@ -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

@@ -201,3 +201,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'

package/types/viewer.d.ts

@@ -1,175 +1,7 @@
-// three-slicer/viewer
-import type * as React from 'react'
-import type { SlicerSettings } from './settings-keys.d.ts'
-
-export interface ViewportProps {
-  /** Sparse settings map. Defaults to `{}`. */
-  settings?: SlicerSettings
-  /** React setState shape. Defaults to a no-op. */
-  setSettings?: React.Dispatch<React.SetStateAction<SlicerSettings>>
-  /** Left process-panel slot — usually `<SettingsPanel embedded/>`. Defaults to null. */
-  processPanel?: React.ReactNode
-  /** Motion-limits editor, folded into the printer card — usually `<SettingsPanel only={{builder:'TabPrinter::build_kinematics_page'}}/>`. */
-  motionPanel?: React.ReactNode
-  /**
-   * Filament editor, folded into the filament card. Pass a function rather than a node: with more than one
-   * extruder loaded the card projects that extruder's slice of the per-extruder columns and writes the form's
-   * edits back at its index, so the panel must bind to the pair it is given.
-   */
-  filamentPanel?: React.ReactNode
-    | ((settings: SlicerSettings, setSettings: React.Dispatch<React.SetStateAction<SlicerSettings>>) => React.ReactNode)
-  /**
-   * Per-panel visibility. Every panel is visible unless its key is explicitly `false`, so a host only opts out —
-   * and a panel added in a later version does not disappear for hosts that listed the ones they wanted.
-   *
-   * A {@link LockablePanel} also accepts `'readonly'`: the panel is drawn but nothing inside it can be clicked,
-   * typed into or tabbed to — including any node the host passed into it. That is the shape a host wants when it
-   * presets the printer, process and filament itself and does not want the user changing them.
-   *
-   * Note what it locks: the UI path, not the value. `settings` is still the host's own prop, and other paths
-   * inside the viewer still write it — importing a 3mf project applies that project's settings either way.
-   */
-  panels?: Partial<Record<ViewportPanel, boolean>> & Partial<Record<LockablePanel, boolean | 'readonly'>>
-  /**
-   * Behaviour switches, following the same opt-out rule as {@link ViewportProps.panels}: everything is on unless
-   * its key is explicitly `false`. These are the things the component does *outside* its own box — take the page's
-   * keyboard, load the WASM kernel, write to the console — which a host embedding it in a larger app may already
-   * be doing itself. See {@link ViewportFeature}.
-   */
-  features?: Partial<Record<ViewportFeature, boolean>>
-  /**
-   * Intercepts every file the viewer would otherwise hand to the browser as a download — the 3mf project, the STL,
-   * and each plate's G-code. Return anything truthy to say it is handled and suppress the download; return nothing
-   * to let it proceed as well. This is the only way in: the save buttons live inside the component.
-   *
-   * ```jsx
-   * <Viewport onExport={(blob, filename) => { upload(blob, filename); return true }} />
-   * ```
-   */
-  onExport?: (file: Blob, filename: string) => boolean | void
-  /**
-   * G-code text to render instead of a slice result. Parsed into the same layer stream the kernel produces and
-   * shown on the selected plate; the kernel is never started. While it is set, auto re-slice leaves that plate alone.
-   */
-  gcode?: string | null
-  /**
-   * An `.sl1` archive rendered as a raster preview — the SLA half of {@link ViewportProps.gcode}'s contract: it
-   * lands on the selected plate and the kernel is never started. Set both and the G-code wins; one plate holds
-   * one artifact.
-   *
-   * Two things it does that `gcode` does not. It writes to your `settings` — the archive's own job description,
-   * `printer_technology` included, because an .sl1 opened in an FFF session has to switch it. And it reconstructs
-   * a surface from the masks in the background, so the preview fills in a moment after the layers appear.
-   *
-   * Re-injects whenever the value's IDENTITY changes, so hold the File/buffer in state rather than building it
-   * during render — a fresh `new Uint8Array(...)` each render re-imports each render. `{name, data}` exists
-   * because the name is the import notice's subject and the filename a re-export hands back.
-   */
-  sl1?: File | Blob | ArrayBuffer | Uint8Array | { name?: string, data: ArrayBuffer | Uint8Array } | null
-  /**
-   * Content imported once on mount, through the same extension dispatch as a drop: models (STL/OBJ/3MF/AMF/PLY —
-   * a 3mf project applies its settings, plates and painting), `.sl1` raster archives, and preset files
-   * (`.json` / `.orca_printer` / `.orca_bundle` / `.orca_filament` / `.zip`). The `{name, data}` form exists
-   * because the dispatch runs on the file NAME's extension. Deliberately mount-only — recreating the array on a
-   * later render does not re-import; runtime loading is the picker, drop, or a remount.
-   */
-  files?: Array<File | { name: string, data: ArrayBuffer | Uint8Array }>
-  /**
-   * A token whose identity CHANGE requests one slice of the current plate — the host's Slice button:
-   * keep a counter in state and bump it. The mount value is inert (0 and null both slice nothing), so is
-   * setting it back to `null`. Ignored while a `gcode`/`sl1` injection holds the plate or the scene is
-   * empty — the same conditions under which the built-in slice bar is not pressable. A change while a
-   * slice is running cancels it and re-slices: the last request wins.
-   */
-  sliceRequest?: number | string | object | null
-
-  /** Initial filament colours (hex), one per extruder. Defaults to the built-in T1/T2 pair. */
-  defaultExtruderColors?: string[] | null
-  /**
-   * Start with auto re-slice on. Unlike the in-app toggle's original behaviour this also performs the FIRST slice,
-   * which is what makes a panel-less embed able to slice at all.
-   */
-  defaultAutoSlice?: boolean
-  /** Every value change in one channel. See {@link ViewportEvent}. */
-  onEvent?: (event: ViewportEvent) => void
-  /** A finished slice, fired where the result is cached — switching plate tabs does not re-fire it. */
-  /** `throughput` is how fast the slice ran — see `SliceThroughput` in the engine entry. Absent on a kernel
-   *  result that carried none (a cached plate re-announced from before the field existed). */
-  onSliced?: (result: {
-    plate: number; stats: Record<string, unknown>; gcode: string
-    throughput?: { ms: number; kernelMs: number | null; layersPerSecond: number; msPerMsegment: number | null }
-  }) => void
-}
-
-/**
- * Behaviour keys accepted by {@link ViewportProps.features}. All default to enabled.
- *
- * - `shortcuts` — the keyboard bindings. They are installed on `window`, so while the viewer is mounted they fire
- *   wherever focus is (except inside inputs) and `Ctrl+C` in particular preventDefaults. Turn them off when the
- *   host page has its own.
- * - `warmup` — loading the WASM kernel on mount, ahead of the first slice. Off, nothing is downloaded or compiled
- *   until something actually slices — which for a `gcode`-only viewer is never.
- * - `drop` — drag and drop onto the canvas.
- * - `filePicker` — the file dialog, from every button that opens it.
- * - `contextMenu` — the right-click menu. Note that the browser's own menu stays suppressed over the canvas either
- *   way: OrbitControls preventDefaults `contextmenu` itself.
- * - `logs` — console diagnostics, from the component and from the slice worker.
- */
-export type ViewportFeature = 'shortcuts' | 'warmup' | 'drop' | 'filePicker' | 'contextMenu' | 'logs'
-
-/**
- * The panels that accept `'readonly'` as well as `true`/`false` — the right column and the cards in it. Everything
- * else takes a boolean only: locking the gizmo rail or the plate tabs is what `features` and `panels: false` are
- * for, and pretending otherwise would mean a `'readonly'` that silently does nothing on half the keys.
- *
- * `sidebar: 'readonly'` locks the whole column in one go, so the per-card keys are for mixing — a locked printer
- * card above a live object list, say.
- */
-export type LockablePanel =
-  | 'sidebar' | 'printerCard' | 'filamentCard' | 'objectList' | 'towerCard'
-  | 'previewControls' | 'processCard' | 'sliceBar'
-
-/** Panel keys accepted by {@link ViewportProps.panels}. `sidebar: false` hides the whole right column at once. */
-export type ViewportPanel =
-  | 'topBar' | 'gizmoRail' | 'objectToolbar' | 'paintPanel' | 'statsCard' | 'plateBar' | 'emptyHint' | 'status'
-  | 'sidebar' | 'printerCard' | 'filamentCard' | 'objectList' | 'previewControls' | 'processCard' | 'sliceBar'
-  /** The horizontal move scrub under the canvas — how far into the top shown layer the print has got. Preview
-   *  and FFF only: a resin layer is cured in one exposure and has no intra-layer order to walk. */
-  | 'moveBar'
-  /** The over-the-bed warning, shown in Prepare when something leaves the printable area. */
-  | 'bedWarn'
-  /** The prime tower card. Only rendered anyway once a second filament exists. */
-  | 'towerCard'
-  /** The resin (SLA) card. Takes the filament card's place when the printer profile declares SLA. */
-  | 'resinCard'
-
-/** Value changes reported through {@link ViewportProps.onEvent}. Not fired for the initial values. */
-export type ViewportEvent =
-  | { type: 'canvasMode'; value: 'prepare' | 'preview' }
-  | { type: 'objects'; value: Array<{ id: number; name: string; extruder: number; visible: boolean }> }
-  | { type: 'selectedPlate'; value: number }
-  | { type: 'plateCount'; value: number }
-  | { type: 'extruderColors'; value: string[] }
-  | { type: 'autoSlice'; value: boolean }
-  | { type: 'slicing'; value: boolean }
-  /** 0..1. Fires several times a second while slicing — throttle on the host side if that matters. */
-  | { type: 'progress'; value: number }
-  /**
-   * Live throughput: layers finished per second over a 250ms window, `0` between slices. An SLA slice reports it
-   * throughout. An FFF slice reports it only once the emission pass begins streaming layers — the earlier passes
-   * publish no per-layer progress, so nothing is measured there and none is invented. For the whole-slice figure
-   * use `throughput` from `onSliced`.
-   */
-  | { type: 'sliceRate'; value: number }
-  | { type: 'viewType'; value: 'feature' | 'speed' | 'height' | 'width' | 'fan' | 'temp' | 'filament' }
-  | { type: 'paintMode'; value: 'off' | 'enforcer' | 'blocker' | 'material' }
-  | { type: 'layerCount'; value: number }
-  | { type: 'layerRange'; value: { lo: number; hi: number } }
-  /** The move scrub's position within the top shown layer; `max` is that layer's move count, extrusions and
-   *  travels together. Not fired while the whole layer is shown. */
-  | { type: 'moveScrub'; value: { at: number; max: number } }
-  | { type: 'error'; value: string }
-  | { type: 'notice'; value: string }
-
-declare const Viewport: React.FC<ViewportProps>
+// three-slicer/viewer — the permissive viewer (three-slicer-viewer, MIT) with the kernel plugged in.
+export * from 'three-slicer-viewer'
+import type { ViewportProps, SlicerHandle } from 'three-slicer-viewer'
+/** The permissive `useSlicer` bound to the WASM kernel worker (three-slicer/client's makeSlicerWorker). */
+export function useSlicer(deps: Record<string, unknown>): SlicerHandle
+declare function Viewport(props: ViewportProps): JSX.Element
 export default Viewport