ignitefuse 0.1.0

package/skills/ignitefuse-make-toolpath/references/direct-open-case-solid-bottom.md

@@ -0,0 +1,193 @@
+# Direct Open Case With Solid Bottom
+
+Use this pattern for prompts such as "100x100mm, height 50mm case, bottom is solid fill" when no STL model is involved.
+
+Key points:
+
+- Direct walls use `pathLayer().polygon("outerWall" | "innerWall", ...)`.
+- `exportScene.items` is only for STL/model placements; direct path geometry appears in the toolpath stage.
+- Bottom floor uses a stack of `pathRegion()` entries only for the solid bottom layers.
+- Standard bottom solid is generated by `fillRegionLayer()`, not a custom raster loop.
+- Solid line fill defaults to alternating `45` / `-45` degrees, but expose the angle as a parameter when customization is useful.
+- Add layers with `graph.addLayer({ plane, distance, layerIndex, paths })`.
+
+```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",
+})
+
+const nozzle = Param.number("Nozzle Diameter", 0.4, {
+  group: "Printer",
+  description: "Nominal nozzle diameter used by toolpath defaults.",
+  min: 0.2,
+  max: 1.2,
+  step: 0.05,
+  unit: "mm",
+})
+
+const sizeX = Param.number("Width", 100, {
+  group: "Case",
+  description: "Outer case width.",
+  min: 20,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+
+const sizeY = Param.number("Depth", 100, {
+  group: "Case",
+  description: "Outer case depth.",
+  min: 20,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+
+const height = Param.number("Height", 50, {
+  group: "Case",
+  description: "Case height.",
+  min: 5,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+
+const layerHeight = Param.number("Layer Height", 0.2, {
+  group: "Slicing",
+  description: "Distance between generated layers.",
+  min: 0.08,
+  max: 0.4,
+  step: 0.02,
+  unit: "mm",
+})
+
+const lineWidth = Param.number("Line Width", nozzle * 1.1, {
+  group: "Toolpath",
+  description: "Extrusion path width used for walls and generated paths.",
+  min: nozzle * 0.8,
+  max: nozzle * 1.6,
+  step: 0.02,
+  unit: "mm",
+})
+
+const wallCount = Param.number("Wall Count", 3, {
+  group: "Toolpath",
+  description: "Number of inset outline loops per layer.",
+  min: 1,
+  max: 6,
+  step: 1,
+})
+
+const bottomLayers = Param.number("Bottom Layers", 6, {
+  group: "Toolpath",
+  description: "Number of solid bottom layers.",
+  min: 1,
+  max: 12,
+  step: 1,
+})
+
+const solidFillAngle = Param.number("Solid Fill Angle", 45, {
+  group: "Infill",
+  description: "Base angle for solid bottom fill lines. Adjacent layers use the opposite angle.",
+  min: -90,
+  max: 90,
+  step: 5,
+  unit: "deg",
+})
+
+const center = [110, 110]
+
+const rectangle = (inset = 0) => {
+  const minX = center[0] - sizeX / 2 + inset
+  const maxX = center[0] + sizeX / 2 - inset
+  const minY = center[1] - sizeY / 2 + inset
+  const maxY = center[1] + sizeY / 2 - inset
+  return [[minX, minY], [maxX, minY], [maxX, maxY], [minX, maxY]]
+}
+
+// ignite-fuse:placements:start
+const igniteFusePlacedItems = [
+]
+// ignite-fuse:placements:end
+
+exportScene({
+  printer: machine,
+  items: igniteFusePlacedItems,
+})
+
+exportToolpath(async () => {
+  const graph = toolpath({ printer: machine, layerHeight })
+  const layerCount = Math.max(1, Math.ceil(height / layerHeight))
+  const walls = Math.max(1, Math.round(wallCount))
+  const solidBottomLayers = Math.min(layerCount, Math.max(1, Math.round(bottomLayers)))
+  const fillInset = walls * lineWidth + lineWidth * 0.5
+
+  const bottomRegions = Array.from({ length: solidBottomLayers }, (_, index) => {
+    const z = Number(((index + 1) * layerHeight).toFixed(3))
+    return pathRegion(z).polygon(rectangle(fillInset))
+  })
+
+  for (let layerIndex = 0; layerIndex < layerCount; layerIndex += 1) {
+    const z = Number(((layerIndex + 1) * layerHeight).toFixed(3))
+    const plane = Plane.z(z)
+    const layer = pathLayer(0, { layerIndex, layerHeight, lineWidth })
+
+    for (let wall = 0; wall < walls; wall += 1) {
+      const role = wall === 0 ? "outerWall" : "innerWall"
+      layer.polygon(role, rectangle(wall * lineWidth))
+    }
+
+    const layerPathGroups = [layer.paths]
+
+    if (layerIndex < bottomRegions.length) {
+      const bottomFill = fillRegionLayer(bottomRegions, layerIndex, {
+        solidLayers: bottomRegions.length,
+        bottomAngle: layerIndex % 2 === 0 ? solidFillAngle : -solidFillAngle,
+        bottomPattern: "monotonic",
+        topAngle: layerIndex % 2 === 0 ? solidFillAngle : -solidFillAngle,
+        topPattern: "monotonicLine",
+        sparsePattern: "rectilinear",
+        density: 0,
+        lineWidth,
+        layerHeight,
+      })
+
+      layerPathGroups.push(bottomFill.bottom, bottomFill.top)
+    }
+
+    graph.addLayer({
+      plane,
+      distance: z,
+      layerIndex,
+      paths: planLayerPaths(layerPathGroups, {
+        roleOrder: ["outerWall", "innerWall", "bottom", "top"],
+        travel: true,
+      }),
+    })
+  }
+
+  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()
+})
+```

package/skills/ignitefuse-make-toolpath/references/direct-region-fill.md

@@ -0,0 +1,34 @@
+# Direct Region Fill Rules
+
+Use `pathRegion()` when the geometry is code-defined rather than sliced from an STL.
+
+Preferred APIs:
+
+- `fillRegion(region, options)`: one explicit region fill, with a deliberate role and pattern.
+- `fillRegionLayer(regionStack, layerIndex, options)`: standard layered bottom/top/sparse classification for direct regions.
+
+For standard solid bottom/top behavior, delegate to `fillRegionLayer()` so holes, margins, field anchoring, and role semantics stay shared with normal fill.
+
+Valid fill patterns are `rectilinear`, `lines`, `monotonicLine`, `monotonic`, `grid`, `triangles`, and `concentric`. Sparse infill defaults to `rectilinear`: one optimized line direction per layer, rotated 90 degrees across adjacent layers. `grid` means two directions in the same layer. Bottom solid fill defaults to `monotonic`, which connects adjacent scan lines into as few strokes as possible to reduce travel. Top solid fill defaults to `monotonicLine`, the ordered independent-line solid pattern.
+
+Valid roles are:
+
+```txt
+outerWall, innerWall, infill, solidInfill, top, bottom, support, travel
+```
+
+Prefer builders over raw path objects for normal programs, and keep roles in the IgniteFuse semantic role set.
+
+Hole semantics:
+
+```js
+const region = pathRegion(z)
+  .polygon(outer)
+  .hole(hole)
+
+const equivalent = pathRegion(z)
+  .polygon(outer)
+  .polygon(hole, { hole: true })
+```
+
+Explicit holes are winding-independent.

package/skills/ignitefuse-make-toolpath/references/function-implementation.md

@@ -0,0 +1,137 @@
+# `.fuse.js` Function Implementation Rules
+
+Use this reference when writing helper functions or deciding where code belongs in a `.fuse.js` file.
+
+## Stage Boundaries
+
+- Scene phase is declaration only: `printer(...)`, `model(...)`, placement block, and `exportScene(...)`.
+- Toolpath phase builds manufacturing paths inside `exportToolpath(async () => ...)`.
+- G-code export phase lowers an already-built graph inside `onExportGcode(...)`.
+- Do not slice, load meshes, build region stacks, create fill, or generate G-code at top level.
+- Do not put direct path geometry in `exportScene.items`; direct geometry belongs in the toolpath phase.
+
+## Top-Level Helpers
+
+Top-level helper functions are allowed and preferred when they make geometry readable.
+
+Good helper functions:
+
+```js
+const rectangle = (inset = 0) => {
+  const minX = center[0] - sizeX / 2 + inset
+  const maxX = center[0] + sizeX / 2 - inset
+  const minY = center[1] - sizeY / 2 + inset
+  const maxY = center[1] + sizeY / 2 - inset
+  return [[minX, minY], [maxX, minY], [maxX, maxY], [minX, maxY]]
+}
+```
+
+```js
+const makeSolidFillOptions = (layerIndex) => ({
+  bottomAngle: layerIndex % 2 === 0 ? solidFillAngle : -solidFillAngle,
+  bottomPattern: "monotonic",
+  topAngle: layerIndex % 2 === 0 ? solidFillAngle : -solidFillAngle,
+  topPattern: "monotonicLine",
+  sparsePattern: "rectilinear",
+  density: 0,
+  lineWidth,
+  layerHeight,
+})
+```
+
+Keep helpers deterministic. They may read top-level Params and constants, but they should not mutate global state, call `graph.addLayer(...)`, call `generateGcode(...)`, or perform stage registration.
+
+## Direct Path Helpers
+
+For direct paths, helpers should return points, regions, paths, or path groups.
+
+Preferred pattern:
+
+```js
+const makeWalls = (layerIndex) => {
+  const layer = pathLayer(0, { layerIndex, layerHeight, lineWidth })
+
+  for (let wall = 0; wall < wallCount; wall += 1) {
+    const role = wall === 0 ? "outerWall" : "innerWall"
+    layer.polygon(role, rectangle(wall * lineWidth))
+  }
+
+  return layer.paths
+}
+```
+
+Then add the result inside `exportToolpath(...)`:
+
+```js
+const layerPathGroups = [makeWalls(layerIndex)]
+graph.addLayer({ plane, distance: z, layerIndex, paths: planLayerPaths(layerPathGroups, options) })
+```
+
+Avoid helpers that return raw JSON path objects for normal toolpaths. Use `pathLayer()`, `pathRegion()`, `fillRegion()`, `fillRegionLayer()`, `perimeters()`, or `fillLayer()`.
+
+## Region And Fill Helpers
+
+Use `pathRegion(z)` for code-defined printable areas. Build a stack when the fill needs bottom/top/sparse classification:
+
+```js
+const regions = Array.from({ length: solidLayers }, (_, index) => {
+  const z = Number(((index + 1) * layerHeight).toFixed(3))
+  return pathRegion(z).polygon(rectangle(fillInset))
+})
+```
+
+Use explicit holes:
+
+```js
+pathRegion(z)
+  .polygon(outer)
+  .hole(inner)
+```
+
+or:
+
+```js
+pathRegion(z)
+  .polygon(outer)
+  .polygon(inner, { hole: true })
+```
+
+For standard solid bottom/top behavior, call `fillRegionLayer(...)`. Use custom internal fill only when the user explicitly wants a custom pattern or nonstandard path behavior.
+
+## `exportToolpath` Implementation
+
+`exportToolpath(async () => { ... })` should:
+
+- create `const graph = toolpath({ printer: machine, layerHeight })`
+- compute planes, sections, regions, and paths
+- add layers with `graph.addLayer({ plane, distance, layerIndex, paths })`
+- return `graph`
+
+Use `pathLayer(0, ...)` with an explicit `Plane` for direct paths. The layer paths are plane-local at insertion; the graph stores Build-space paths after insertion.
+
+For STL programs, call `modelItem.mesh()` only inside `exportToolpath(...)`, then slice with `Plane.zStack(...)` or `Plane.stack(...)`.
+
+For mixed programs or multiple placed STL models, do not call `graph.addLayer(...)` immediately for every part if those layers belong to the same job plane. Accumulate generated layer objects, merge by identical Build-space plane (`origin`, `normal`, `xAxis`, `yAxis`), and flush the merged layers to the graph in plane distance order. Keep a `Merge Coplanar Layers` boolean when users may need intentionally separate layers on the same plane.
+
+## `onExportGcode` Implementation
+
+`onExportGcode(fn)` should only register a function. It should not run during scene or toolpath preview.
+
+Canonical shape:
+
+```js
+function makeGcode({ 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()
+}
+
+onExportGcode(makeGcode)
+```
+
+Do not mutate `graph` into machine coordinates. G-code lowering applies `printer.machineFrame`.

package/skills/ignitefuse-make-toolpath/references/stl-standard-fdm.md

@@ -0,0 +1,50 @@
+# STL Standard FDM Pattern
+
+For STL-backed programs:
+
+- Declare `model(...)` in the scene.
+- Call `part.mesh()` only inside `exportToolpath(async () => ...)`.
+- Generate planes with `Plane.zStack(...)`.
+- Slice with `sliceStackParallel(mesh, planes, { workerPool: true })`.
+- Use `perimeters(section, ...)` for walls.
+- Use `fillLayer(sections, layerIndex, ...)` for bottom/top/sparse fill.
+- Solid line fill defaults to `45` / `-45` degrees, but pass a named angle value when the program should expose customization.
+- Use `parallelLayers(...)` for heavy per-layer work.
+
+For multiple placed STL models in one G-code job, build one shared plane stack from the combined model bounds, slice each mesh with that same `Plane[]`, and merge generated paths by identical Build-space plane. Do not merge by `z` alone; tilted or non-horizontal stacks can share neither Z nor horizontal semantics. If the program intentionally needs separate layers on the same plane, expose a boolean parameter such as `Merge Coplanar Layers`.
+
+Minimal layer callback shape:
+
+```js
+const layers = await parallelLayers(
+  sections,
+  { lineWidth, layerHeight, wallCount, solidLayers, infillDensity, solidFillAngle },
+  ({ 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: "rectilinear",
+      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 },
+)
+```

package/skills/ignitefuse-params/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: ignitefuse-params
+description: Use when defining IgniteFuse Param.number, Param.boolean, Param.select, or Param.text controls for generated UI, slicer/toolpath settings, printer dimensions, case dimensions, layer settings, fill settings, or when converting hard-coded .fuse.js constants into user-editable parameters.
+---
+
+# IgniteFuse Params
+
+Use this skill for generated UI parameters in `.fuse.js`.
+
+## Rules
+
+- Manufacturing behavior belongs in `.fuse.js`; use `Param.*` for user-editable values instead of GUI-owned slicer settings.
+- Give every parameter a clear `group`.
+- Prefer `description`, `min`, `max`, `step`, and `unit` for numeric controls.
+- Use `Param.number` for dimensions, counts, density, angles, speeds, and widths.
+- Use `Param.select` for discrete pattern or mode choices.
+- Use `Param.boolean` for toggles.
+- Use `Param.text` only for user-facing names or simple string inputs.
+- Use integer steps for counts such as wall count, solid layers, and bottom layers.
+- Use dependent defaults for related manufacturing values, such as `lineWidth` derived from `nozzle`.
+
+## References
+
+- For canonical parameter snippets and ranges, read `references/param-patterns.md`.

package/skills/ignitefuse-params/references/param-patterns.md

@@ -0,0 +1,153 @@
+# IgniteFuse Parameter Patterns
+
+Use these patterns when creating complete `.fuse.js` programs from an empty source.
+
+## Printer And Slicing
+
+```js
+const nozzle = Param.number("Nozzle Diameter", 0.4, {
+  group: "Printer",
+  description: "Nominal nozzle diameter used by toolpath defaults.",
+  min: 0.2,
+  max: 1.2,
+  step: 0.05,
+  unit: "mm",
+})
+
+const layerHeight = Param.number("Layer Height", 0.2, {
+  group: "Slicing",
+  description: "Distance between generated layers.",
+  min: 0.08,
+  max: 0.4,
+  step: 0.02,
+  unit: "mm",
+})
+
+const lineWidth = Param.number("Line Width", nozzle * 1.1, {
+  group: "Toolpath",
+  description: "Extrusion path width used for walls and generated paths.",
+  min: nozzle * 0.8,
+  max: nozzle * 1.6,
+  step: 0.02,
+  unit: "mm",
+})
+```
+
+## Direct Case Dimensions
+
+```js
+const sizeX = Param.number("Width", 100, {
+  group: "Case",
+  description: "Outer case width.",
+  min: 20,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+
+const sizeY = Param.number("Depth", 100, {
+  group: "Case",
+  description: "Outer case depth.",
+  min: 20,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+
+const height = Param.number("Height", 50, {
+  group: "Case",
+  description: "Case height.",
+  min: 5,
+  max: 180,
+  step: 1,
+  unit: "mm",
+})
+```
+
+## Walls And Solid Layers
+
+```js
+const wallCount = Param.number("Wall Count", 3, {
+  group: "Toolpath",
+  description: "Number of inset outline loops per layer.",
+  min: 1,
+  max: 6,
+  step: 1,
+})
+
+const bottomLayers = Param.number("Bottom Layers", 6, {
+  group: "Toolpath",
+  description: "Number of solid bottom layers.",
+  min: 1,
+  max: 12,
+  step: 1,
+})
+
+const solidLayers = Param.number("Solid Layers", 3, {
+  group: "Toolpath",
+  description: "Number of top and bottom solid layers for sliced models.",
+  min: 1,
+  max: 8,
+  step: 1,
+})
+```
+
+## Fill And Pattern Controls
+
+```js
+const infillDensity = Param.number("Infill Density", 0.18, {
+  group: "Infill",
+  description: "Sparse infill density from 0 to 1.",
+  min: 0,
+  max: 1,
+  step: 0.02,
+})
+
+const sparsePattern = Param.select("Sparse Pattern", ["rectilinear", "lines", "grid", "triangles", "concentric"], "rectilinear", {
+  group: "Infill",
+  description: "Pattern used for sparse infill.",
+})
+
+const bottomPattern = Param.select("Bottom Pattern", ["monotonic", "monotonicLine", "rectilinear", "lines", "grid", "triangles", "concentric"], "monotonic", {
+  group: "Infill",
+  description: "Pattern used for solid bottom fill.",
+})
+
+const topPattern = Param.select("Top Pattern", ["monotonicLine", "rectilinear", "lines", "grid", "triangles", "concentric", "monotonic"], "monotonicLine", {
+  group: "Infill",
+  description: "Pattern used for solid top fill.",
+})
+
+const solidFillAngle = Param.number("Solid Fill Angle", 45, {
+  group: "Infill",
+  description: "Base angle for solid line fill. Adjacent layers can use the opposite angle.",
+  min: -90,
+  max: 90,
+  step: 5,
+  unit: "deg",
+})
+```
+
+## Path Effects
+
+Use effect parameters only when the program actually applies modifiers.
+
+```js
+const pathNoise = Param.number("Path Noise", 0.04, {
+  group: "Path Effects",
+  description: "Sine-wave perturbation applied to generated paths.",
+  min: 0,
+  max: 0.3,
+  step: 0.01,
+  unit: "mm",
+})
+```
+
+## Naming
+
+- Labels should be short and human-readable: `"Layer Height"`, `"Line Width"`, `"Wall Count"`.
+- Use `group: "Printer"` for nozzle and filament-related defaults.
+- Use `group: "Slicing"` for layer pitch/height.
+- Use `group: "Toolpath"` for wall and path construction values.
+- Use `group: "Infill"` for density and pattern controls.
+- Use a domain group such as `"Case"` for part dimensions.

package/skills/ignitefuse-printer-scene/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: ignitefuse-printer-scene
+description: Use when defining IgniteFuse printer profiles, build areas, machine frames, exportScene metadata, STL/model placements, or scene construction.
+---
+
+# IgniteFuse Printer And Scene
+
+Use this skill for canonical printer and scene definitions in `.fuse.js`.
+
+## Rules
+
+- New programs must define work area with `buildArea { x, y, z }`.
+- New programs must define machine coordinates with top-level `machineFrame`.
+- Put optional machine-space ranges under `machineFrame.bounds`.
+- Represent belt-like or skewed machines with `machineFrame` and optional `process`, not a printer `type`.
+- `exportScene(...)` declares the printer and model placement items; it does not own slicer settings.
+- `exportScene.items` should contain STL/model placement items from `model(...)` or `igniteFusePlacedItems`.
+- For model-less direct path programs, keep scene items empty or use the standard empty placement block.
+
+## Canonical Shape
+
+Keep work-area dimensions in `printer.buildArea`; `exportScene(...)` should reference the printer and placed model items.
+
+## References
+
+- For canonical printer and scene snippets, read `references/canonical-printer-scene.md`.