ignitefuse 0.1.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "ignitefuse",
+  "version": "0.1.0",
+  "description": "CLI and local studio host for programmable IgniteFuse 3D-print toolpaths.",
+  "type": "module",
+  "bin": {
+    "ignitefuse": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "THIRD_PARTY_NOTICES.md",
+    "skills",
+    "web"
+  ],
+  "keywords": [
+    "3d-printing",
+    "gcode",
+    "manufacturing",
+    "slicer",
+    "toolpath"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tokoshie3d/IgniteFuse.git",
+    "directory": "apps/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/tokoshie3d/IgniteFuse/issues"
+  },
+  "homepage": "https://github.com/tokoshie3d/IgniteFuse#readme",
+  "scripts": {
+    "build": "node ../../scripts/build-cli.mjs",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "dev": "node --import tsx src/index.ts",
+    "prepack": "pnpm -w build:cli"
+  },
+  "dependencies": {
+    "clipper2-wasm": "^0.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "tsx": "^4.20.6",
+    "typescript": "~5.6.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0"
+}

package/skills/ignitefuse/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: ignitefuse
+description: Use for general IgniteFuse concepts, .fuse.js API orientation, runtime stages, coordinates, toolpath roles, and when no narrower IgniteFuse skill applies. For active project editing use ignitefuse-make-toolpath and ignitefuse-studio-mcp when available.
+---
+
+# IgniteFuse Core
+
+IgniteFuse is a code-first manufacturing studio for programmable 3D-print toolpaths. Treat `.fuse.js` as the source of truth: printer, scene, toolpath, and G-code export are code-defined artifacts.
+
+## Core Rules
+
+- Use `printer(...)`, `exportScene(...)`, lazy `exportToolpath(async () => graph)`, and `onExportGcode(...)`.
+- Read the Core API group in the Source Map before authoring unfamiliar `.fuse.js` code.
+- Use generated params (`Param.number`, `Param.boolean`, `Param.select`, `Param.text`) instead of GUI-owned slicer settings.
+- Use `buildArea { x, y, z }` and top-level `machineFrame`.
+- Keep `ToolpathGraph` coordinates in Build Coordinates. Apply `machineFrame` only during G-code lowering and G-code preview parsing.
+- Use semantic roles only: `outerWall`, `innerWall`, `infill`, `solidInfill`, `top`, `bottom`, `support`, `travel`.
+- For normal `.fuse.js` programs, prefer `pathLayer()`, `pathRegion()`, `perimeters()`, `fillLayer()`, `fillRegion()`, or `fillRegionLayer()` over raw `ToolpathPath` objects.
+
+## Source Map
+
+Load references top-to-bottom, stopping when you have what the task needs.
+
+### 1. Core API (always read first for `.fuse.js` authoring)
+
+Execution model, three phases, canonical API shape, coordinates, direct paths, regions, STL slicing, and G-code export.
+
+- `references/full-api-and-architecture.md`
+- `../ignitefuse-make-toolpath/references/api-shape.md`
+
+### 2. Active Studio MCP workflow
+
+Use when the user refers to the currently open IgniteFuse project, wants Studio to run, wants tabs switched, or asks for toolpath summaries.
+
+- `../ignitefuse-studio-mcp/references/mcp-tools.md`
+
+### 3. Printer, build area, scene, and placements
+
+Use for printer profiles, `buildArea`, `machineFrame`, belt-like frames, placement blocks, and `exportScene(...)`.
+
+- `../ignitefuse-printer-scene/references/canonical-printer-scene.md`
+
+### 4. Generated parameters
+
+Use when defining user-editable dimensions, layer settings, walls, density, patterns, or fill angles.
+
+- `../ignitefuse-params/references/param-patterns.md`
+
+### 5. Direct path and direct region toolpaths
+
+Use for model-less procedural toolpaths, direct solid bottom/top fill, holes, and code-defined regions.
+
+- `../ignitefuse-make-toolpath/references/direct-region-fill.md`
+- `../ignitefuse-make-toolpath/references/direct-open-case-solid-bottom.md`
+
+### 6. STL slicing
+
+Use for imported STL models, `model(...).mesh()`, plane stacks, perimeters, `fillLayer(...)`, and `parallelLayers(...)`.
+
+- `../ignitefuse-make-toolpath/references/stl-standard-fdm.md`
+
+### 7. Helper function implementation
+
+Use when writing `.fuse.js` helper functions, geometry builders, fill option builders, or G-code callbacks.
+
+- `../ignitefuse-make-toolpath/references/function-implementation.md`
+
+## References
+
+- For full API and architecture background, read `references/full-api-and-architecture.md`.
+- For printer profile and scene definitions, prefer the `ignitefuse-printer-scene` skill.
+- For generated UI parameters, prefer the `ignitefuse-params` skill.
+- For creating or editing active `.fuse.js` projects, prefer the `ignitefuse-make-toolpath` skill.
+- For Studio MCP workflows, prefer the `ignitefuse-studio-mcp` skill.
+- For repository implementation work, prefer the `ignitefuse-dev` skill.

package/skills/ignitefuse/references/full-api-and-architecture.md

@@ -0,0 +1,93 @@
+# IgniteFuse Current API And Architecture
+
+This reference is current-only. Use it for general orientation when a narrower skill does not apply.
+
+## Manufacturing Document Shape
+
+Every complete `.fuse.js` manufacturing document should be structured in three explicit phases:
+
+1. Scene: declare `printer(...)`, optional `model(...)` placement block, and `exportScene(...)`.
+2. Toolpath: build and return `ToolpathGraph` inside lazy `exportToolpath(async () => graph)`.
+3. G-code export: register `onExportGcode(...)`; do not generate G-code during scene or toolpath preview.
+
+Top-level code should stay lightweight. Mesh loading, slicing, region stacks, fill, offsets, path planning, and G-code-specific work belong inside lazy callbacks.
+
+## Printer And Scene
+
+Use canonical printer definitions from `ignitefuse-printer-scene`.
+
+```js
+const machine = printer({
+  name: "Generic FDM 220",
+  buildArea: { x: [0, 220], y: [0, 220], z: [0, 250] },
+  machineFrame: {
+    origin: [0, 0, 0],
+    xAxis: [1, 0, 0],
+    yAxis: [0, 1, 0],
+    zAxis: [0, 0, 1],
+    bounds: { x: [0, 220], y: [0, 220], z: [0, 250] },
+  },
+  nozzle: 0.4,
+  filament: 1.75,
+  gcodeFlavor: "marlin",
+})
+```
+
+`exportScene(...)` describes the printer and scene items. It should not execute slicing or heavy toolpath work.
+
+## Coordinates And Layers
+
+Toolpath generation operates in Build Coordinates. G-code text is lowered into Machine Coordinates by `machineFrame`, and G-code preview maps parsed machine XYZ back into Build Coordinates.
+
+Layers are identified by their Build-space plane, not by Z alone. `ToolpathLayer.z` is compatibility metadata for horizontal views. IgniteFuse G-code includes `;LAYER:<index>` and `;IF_LAYER_PLANE ...` comments so preview parsing can reconstruct arbitrary layer frames after machine-coordinate parsing.
+
+For direct paths, use a plane plus plane-local paths:
+
+```js
+const z = 0.2
+const plane = Plane.z(z)
+const layer = pathLayer(0, { layerIndex: 0, layerHeight: z, lineWidth: 0.44 })
+
+layer.polygon("outerWall", [[20, 20], [80, 20], [80, 80], [20, 80]])
+
+graph.addLayer({ plane, distance: z, layerIndex: 0, paths: layer.paths })
+```
+
+## Direct Paths And Regions
+
+Use `pathLayer()` for explicit paths and `pathRegion()` for code-defined fill regions.
+
+For a direct-path stack that needs standard bottom/top/sparse classification, build one `pathRegion()` per relevant layer and call `fillRegionLayer(regions, layerIndex, options)`.
+
+Use `fillRegion(region, options)` for a deliberately single-region fill role and pattern.
+
+## STL Slicing
+
+For STL-backed programs:
+
+- Declare `model(...)` in `exportScene(...)`.
+- Call `part.mesh()` inside `exportToolpath(async () => ...)`.
+- Generate planes with `Plane.zStack(...)` or `Plane.stack(...)`.
+- Slice with `sliceStackParallel(mesh, planes, { workerPool: true })`.
+- Use `perimeters(section, ...)` for walls.
+- Use `fillLayer(sections, layerIndex, ...)` for bottom/top/sparse fill.
+- Use `parallelLayers(...)` for heavy per-layer work.
+
+When combining multiple placed STL models or mixing STL and direct paths, assemble one job-level graph. Use shared planes for STL meshes in the same job and merge generated paths by identical Build-space plane (`origin`, `normal`, `xAxis`, `yAxis`), not by horizontal `z` alone. Default templates expose `Merge Coplanar Layers`; turning it off intentionally keeps same-plane layers separate.
+
+## G-code
+
+Register G-code generation with `onExportGcode(fn)`. Toolpath preview should not generate G-code.
+
+```js
+onExportGcode(({ graph, generateGcode, editGcode }) => {
+  return editGcode(generateGcode(graph, {
+    filament: { nozzleTemp: 210, bedTemp: 60 },
+    output: { flavor: "marlin", style: "orca" },
+    start: { mode: "standard" },
+    end: { mode: "standard" },
+  }))
+    .insertBeforeEnd("M107")
+    .toString()
+})
+```

package/skills/ignitefuse-dev/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: ignitefuse-dev
+description: Use when modifying the IgniteFuse repository implementation itself: runtime APIs, Svelte Studio UI, Tauri MCP bridge, toolpath kernel, infill, sectioning, geometry, G-code exporter, viewer, tests, or docs.
+---
+
+# IgniteFuse Dev
+
+Use this for repository implementation work, not for ordinary active-project `.fuse.js` generation.
+
+## Workflow
+
+- Repository implementation tasks may confirm the repo root with `pwd` or `git rev-parse --show-toplevel`; active Studio project edits should use the MCP skills instead.
+- Read the smallest relevant implementation files first using `references/implementation-map.md`.
+- Follow task-specific touch points in `references/task-recipes.md`.
+- Keep core slicing/toolpath logic in the SlicerQuery-style library layer, not in Tauri or UI.
+- Preserve `.fuse.js` as source of truth.
+- Validate with focused tests first, then `npm run check`, `cargo check` in `src-tauri`, and `npm run build` when UI/runtime behavior changed.
+
+## References
+
+- `references/implementation-map.md`
+- `references/task-recipes.md`

package/skills/ignitefuse-dev/references/implementation-map.md

@@ -0,0 +1,18 @@
+# Implementation Map
+
+Use this map before broad repository searches. Read the smallest relevant file set first; use `rg` only when the map is stale or the task crosses boundaries.
+
+- Studio shell and UI state: `src/routes/+page.svelte`
+- Tauri project API types and commands: `src/app/projectApi.ts`
+- Rust/Tauri project file I/O and MCP bridge: `src-tauri/src/lib.rs`
+- Runtime execution and `.fuse.js` API surface: `src/runtime/fuseScriptRuntime.ts`, `src/runtime/fuseRunner.ts`, `src/runtime/types.ts`
+- Worker-side mirrored runtime helpers: `src/runtime/layerToolpath.worker.ts`, `src/runtime/fuseRuntime.worker.ts`
+- Toolpath graph and path builders: `src/toolpath/types.ts`, `src/toolpath/builder.ts`
+- Direct regions and infill/fill helpers: `src/toolpath/infill.ts`, `src/toolpath/validate.ts`
+- Perimeters, section conversion, planning, modifiers: `src/toolpath/perimeters.ts`, `src/toolpath/fromSection.ts`, `src/toolpath/planning.ts`, `src/toolpath/modifiers.ts`
+- Section planes, slicing, connection, classification: `src/section/plane.ts`, `src/section/slice.ts`, `src/section/connect.ts`, `src/section/classify.ts`, `src/section/types.ts`
+- Polygon kernel operations: `src/geometry/kernel/clipper.ts`, `src/geometry/kernel/lineClip.ts`, `src/geometry/kernel/offset.ts`, `src/geometry/kernel/boolean.ts`, `src/geometry/kernel/validate.ts`
+- G-code lowering, parser preview, text edits: `src/gcode/exporter.ts`, `src/gcode/parser.ts`, `src/gcode/editor.ts`
+- Generated parameter controls: `src/ui/GeneratedParams.svelte`
+- Toolpath and scene preview: `src/viewer/ToolpathGraphViewer.svelte`, `src/viewer/ToolpathLayer.svelte`, `src/viewer/SceneModelMesh.svelte`
+- User-facing MCP docs: `README.md`, `AGENTS.md`, `skills/*/SKILL.md`

package/skills/ignitefuse-dev/references/task-recipes.md

@@ -0,0 +1,32 @@
+# Task Recipes
+
+## MCP Or Studio-Agent Workflow Changes
+
+- Start with `src-tauri/src/lib.rs`: update `mcp_tools()` schema and `mcp_call_tool()` dispatch.
+- Then update `src/app/projectApi.ts` event payload types.
+- Then update `src/routes/+page.svelte` listeners and UI state reflection.
+- Sync `README.md`, `AGENTS.md`, and relevant skills.
+- Validate with `npm run check`, `cargo check` in `src-tauri`, and `npm run build` when UI/runtime behavior changed.
+
+## `.fuse.js` Public API Changes
+
+- Start with `src/runtime/fuseScriptRuntime.ts`.
+- Mirror worker-callable helpers in `src/runtime/layerToolpath.worker.ts` when parallel layer execution should support the API.
+- Add or update core implementation in `src/toolpath/*`, `src/section/*`, or `src/geometry/kernel/*` depending on the layer.
+- Update examples or docs only after the runtime surface is stable.
+- Validate with focused fixtures such as `src/toolpath/validate.ts`, then `npm run check` and `npm run build`.
+
+## Direct Path, Region, Fill, Or Infill Behavior
+
+- Start with `src/toolpath/infill.ts` and `src/toolpath/builder.ts`.
+- Keep direct-path helpers backed by shared region/fill code where possible.
+- Prefer shared `fillRegion()` or `fillRegionLayer()` behavior over one-off raster or concentric examples.
+- Keep hole semantics explicit through `pathRegion().hole(...)` or `{ hole: true }` and validate both winding directions.
+- Update runtime exposure in `src/runtime/fuseScriptRuntime.ts` and worker exposure in `src/runtime/layerToolpath.worker.ts`.
+
+## Coordinate, Plane, Or G-code Behavior
+
+- Start with `src/toolpath/coordinates.ts`, `src/gcode/exporter.ts`, and `src/gcode/parser.ts`.
+- Keep `ToolpathGraph` in Build Coordinates.
+- Apply `machineFrame` only during G-code lowering and G-code preview parsing.
+- For arbitrary planes, check `src/section/plane.ts`, `src/runtime/fuseScriptRuntime.ts`, and graph layer materialization together.

package/skills/ignitefuse-make-toolpath/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: ignitefuse-make-toolpath
+description: Use when creating or editing an IgniteFuse .fuse.js manufacturing program from a user prompt, especially active Studio projects, direct paths, procedural cases, solid bottom/top fill, STL slicing, toolpath generation, or G-code hooks. If Studio MCP is available, use read_source/write_source rather than editing the project file path directly.
+---
+
+# IgniteFuse Make Toolpath
+
+Use this skill to produce valid `.fuse.js` programs, not generic toolpath JSON.
+
+## Required Workflow
+
+- Load the `ignitefuse` core skill guidance first when authoring unfamiliar `.fuse.js`; read at minimum its Core API Source Map entries.
+- Structure complete `.fuse.js` programs in three explicit phases:
+  1. Scene: declare `printer(...)`, optional `model(...)` placement block, and `exportScene(...)`.
+  2. Toolpath: build and return `ToolpathGraph` inside lazy `exportToolpath(async () => ...)`.
+  3. G-code export: register `onExportGcode(...)`; do not generate G-code during scene or toolpath preview.
+- If the user refers to the currently open IgniteFuse project and MCP is available, use MCP `read_source` and `write_source`; do not use `get_project` only to obtain a path and bypass MCP.
+- For active Studio project edits, do not run shell commands to discover `pwd`, cwd, shell, or project file paths. Shell cwd checks are for repository implementation tasks, not MCP-mediated active project edits.
+- If the active source is empty or only boilerplate, replace it with a complete `.fuse.js` manufacturing document rather than returning a fragment.
+- Keep top-level code lightweight. Put slicing, region stacks, fill, offsets, and planning inside lazy `exportToolpath(async () => ...)`.
+- Always include `printer(...)`, `exportScene(...)`, `exportToolpath(...)`, and `onExportGcode(...)` unless the user explicitly asks for a partial snippet.
+- For multiple placed STL models or mixed STL + direct paths, assemble job layers first and merge by identical Build-space `plane`; do not use `z` alone as the merge key. Expose a `Merge Coplanar Layers` boolean when keeping same-plane layers separate is useful.
+- When API shape is uncertain, read `references/api-shape.md` before writing code.
+- When defining helper functions in `.fuse.js`, read `references/function-implementation.md`.
+- Do not write temporary `.fuse.js` programs that probe runtime globals such as `globalThis`, `Object.keys(...)`, or API discovery logs. Use `references/api-shape.md`, `ignitefuse://skill-guide`, and MCP resources instead.
+- Use canonical printer/scene definitions from `ignitefuse-printer-scene`: `buildArea` plus top-level `machineFrame`.
+- Use generated parameter patterns from `ignitefuse-params` for dimensions, layer settings, walls, and fill controls.
+- Use `pathLayer()` and `pathRegion()` for model-less direct geometry.
+- Use `fillRegionLayer()` for standard direct bottom/top solid and sparse classification across a stack.
+- Use `fillRegion()` only for a deliberately single-region fill with an explicit role/pattern.
+
+## Preferred Defaults
+
+- Prefer path builders (`pathLayer`, `pathRegion`, `perimeters`, `fillLayer`, `fillRegion`, `fillRegionLayer`) over raw path objects.
+- Prefer IgniteFuse semantic roles: `outerWall`, `innerWall`, `infill`, `solidInfill`, `top`, `bottom`, `support`, `travel`.
+- Prefer `fillRegionLayer()` for standard direct solid bottom/top behavior.
+- Prefer `toolpath({ printer, layerHeight })`.
+- Prefer canonical printer shapes from `ignitefuse-printer-scene`.
+- For standard solid line fill, default to alternating `45` / `-45` degree angles, but treat the angle as customizable. If the prompt implies shape-specific direction, load direction, surface quality, or user control, expose a Param and pass `bottomAngle`, `topAngle`, or `sparseAngle` explicitly.
+- For open-top cases, build the bottom floor region stack only for the bottom layers unless the user asks for top solid near the final layers.
+
+## References
+
+- For complete `.fuse.js` API shape and minimal examples, read `references/api-shape.md`.
+- For function implementation rules inside `.fuse.js`, read `references/function-implementation.md`.
+- For a canonical 100 x 100 x 50 mm open-top case with solid bottom, read `references/direct-open-case-solid-bottom.md`.
+- For direct region fill rules and invalid patterns, read `references/direct-region-fill.md`.
+- For STL slicing with walls and fill, read `references/stl-standard-fdm.md`.

package/skills/ignitefuse-make-toolpath/references/api-shape.md

@@ -0,0 +1,211 @@
+# IgniteFuse `.fuse.js` API Shape
+
+Use this reference when local API shape is uncertain. A complete `.fuse.js` manufacturing document has three explicit phases.
+
+## Complete File Order
+
+```txt
+1. Printer and scene declarations
+   printer(...)
+   // ignite-fuse:placements:start
+   const igniteFusePlacedItems = [...]
+   // ignite-fuse:placements:end
+   exportScene({ printer: machine, items: igniteFusePlacedItems })
+
+2. Generated UI parameters
+   Param.number(...)
+   Param.boolean(...)
+   Param.select(...)
+   Param.text(...)
+
+3. Pure helper functions
+   geometry point builders, bounds helpers, role helpers
+
+4. Toolpath phase
+   exportToolpath(async () => {
+     const graph = toolpath({ printer: machine, layerHeight })
+     ...
+     graph.addLayer({ plane, distance, layerIndex, paths })
+     return graph
+   })
+
+5. G-code export phase
+   onExportGcode(({ graph, generateGcode, editGcode }) => string)
+```
+
+Do not replace this with raw `ToolpathPath` JSON. Normal programs should use IgniteFuse builders.
+
+## Core API Map
+
+- `printer(profile)`: defines build area, machine frame, nozzle, filament, and output flavor.
+- `model(path, placement)`: declares an STL/model scene item.
+- `exportScene({ printer, items })`: scene metadata only. `items` should be `model(...)` placements, not direct path previews.
+- `Param.number(...)`, `Param.select(...)`, `Param.boolean(...)`, `Param.text(...)`: declare generated controls. Parameters are normal JS values when used later.
+- `toolpath({ printer, layerHeight })`: creates a graph builder.
+- `Plane.z(z)`, `Plane.zStack(...)`, `Plane.stack(...)`: create layer/section planes.
+- `pathLayer(0, options)`: creates plane-local direct paths for a graph layer.
+- `pathRegion(z)`: creates code-defined fill regions.
+- `fillRegion(region, options)`: fills one explicit region with a deliberate role/pattern.
+- `fillRegionLayer(regions, layerIndex, options)`: classifies direct region stacks into bottom/top/sparse fill.
+- `perimeters(section, options)`: creates walls from sliced STL sections.
+- `fillLayer(sections, layerIndex, options)`: creates bottom/top/sparse fill from sliced STL sections.
+- `planLayerPaths(groups, options)`: orders path groups and can insert travel.
+- `graph.addLayer({ plane, distance, layerIndex, paths })`: adds one layer; paths are plane-local at insertion.
+- `onExportGcode(fn)`: registers G-code generation for the export phase only.
+
+## Job Layer Assembly
+
+When a program combines multiple placed STL models, or mixes STL slicing with direct paths, collect generated layer results before calling `graph.addLayer(...)`.
+
+- Use a shared `Plane[]` stack for all placed STL meshes in the same G-code job.
+- Merge paths by identical Build-space `plane`, not by `z` alone.
+- Plane identity is `origin`, `normal`, `xAxis`, and `yAxis` after normalization/rounding.
+- Expose a generated control such as `Param.boolean("Merge Coplanar Layers", true, ...)` when users may want to keep layers separate for ordering, diagnostics, or custom post-processing.
+- Apply G-code options such as `align` only once at job export, not per placed model.
+- G-code preview is layer-first as well: exported G-code should preserve `;LAYER:<index>` and `;IF_LAYER_PLANE ...` comments so parsed machine moves can be assigned back to Build-space layer frames.
+
+## Minimal Model-Less Direct Program
+
+```js
+const machine = printer({
+  name: "Generic FDM 220",
+  buildArea: { x: [0, 220], y: [0, 220], z: [0, 250] },
+  machineFrame: {
+    origin: [0, 0, 0],
+    xAxis: [1, 0, 0],
+    yAxis: [0, 1, 0],
+    zAxis: [0, 0, 1],
+    bounds: { x: [0, 220], y: [0, 220], z: [0, 250] },
+  },
+  nozzle: 0.4,
+  filament: 1.75,
+  gcodeFlavor: "marlin",
+})
+
+// ignite-fuse:placements:start
+const igniteFusePlacedItems = [
+]
+// ignite-fuse:placements:end
+
+exportScene({
+  printer: machine,
+  items: igniteFusePlacedItems,
+})
+
+const layerHeight = Param.number("Layer Height", 0.2, {
+  group: "Slicing",
+  min: 0.08,
+  max: 0.4,
+  step: 0.02,
+  unit: "mm",
+})
+
+const lineWidth = Param.number("Line Width", 0.44, {
+  group: "Toolpath",
+  min: 0.3,
+  max: 0.8,
+  step: 0.01,
+  unit: "mm",
+})
+
+exportToolpath(async () => {
+  const z = layerHeight
+  const plane = Plane.z(z)
+  const graph = toolpath({ printer: machine, layerHeight })
+  const layer = pathLayer(0, { layerIndex: 0, layerHeight, lineWidth })
+
+  layer.polygon("outerWall", [[20, 20], [80, 20], [80, 80], [20, 80]])
+
+  graph.addLayer({
+    plane,
+    distance: z,
+    layerIndex: 0,
+    paths: layer.paths,
+  })
+
+  return graph
+})
+
+onExportGcode(({ graph, generateGcode, editGcode }) => {
+  return editGcode(generateGcode(graph, {
+    filament: { nozzleTemp: 210, bedTemp: 60 },
+    output: { flavor: "marlin", style: "orca" },
+    start: { mode: "standard" },
+    end: { mode: "standard" },
+  }))
+    .insertBeforeEnd("M107")
+    .toString()
+})
+```
+
+## STL-Backed Program Shape
+
+```js
+const part = model("part.stl", {
+  id: "placed_part_1",
+  name: "part 1",
+  position: [20, 20, 0],
+  rotation: [0, 0, 0],
+  scale: [1, 1, 1],
+})
+
+const igniteFusePlacedItems = [
+  part,
+]
+
+exportScene({
+  printer: machine,
+  items: igniteFusePlacedItems,
+})
+
+exportToolpath(async () => {
+  const mesh = part.mesh()
+  const bounds = mesh.bounds()
+  const planes = Plane.zStack({ min: bounds.min.z, max: bounds.max.z, pitch: layerHeight })
+  const sections = await sliceStackParallel(mesh, planes, { workerPool: true })
+  const layers = await parallelLayers(
+    sections,
+    {
+      infillDensity,
+      layerHeight,
+      lineWidth,
+      solidFillAngle,
+      solidLayers,
+      sparsePattern,
+      wallCount,
+    },
+    ({ section, sections, layerIndex, plane, distance, z }) => {
+      const walls = perimeters(section, { count: wallCount, lineWidth, layerHeight })
+      const fill = fillLayer(sections, layerIndex, {
+        bottomAngle: solidFillAngle,
+        bottomPattern: "monotonic",
+        topAngle: -solidFillAngle,
+        topPattern: "monotonicLine",
+        sparseAngle: solidFillAngle,
+        sparsePattern,
+        density: infillDensity,
+        lineWidth,
+        layerHeight,
+        margin: wallCount * lineWidth,
+        solidLayers,
+      })
+
+      return {
+        plane,
+        distance,
+        z,
+        paths: planLayerPaths([walls, fill.bottom, fill.top, fill.sparse], {
+          roleOrder: ["outerWall", "innerWall", "bottom", "top", "infill"],
+          travel: true,
+        }),
+      }
+    },
+    { sectionWindow: solidLayers, workerPool: true },
+  )
+
+  const graph = toolpath({ printer: machine, layerHeight })
+  for (const layer of layers) graph.addLayer(layer)
+
+  return graph
+})
+```