three-slicer-viewer 0.2.5

package/dist/toolpath.js

@@ -0,0 +1,408 @@
+const _ = {
+  0: [0.35, 0.38, 0.44],
+  // travel
+  1: [0.98, 0.45, 0.16],
+  // wall
+  2: [0.36, 0.72, 0.94],
+  // sparse infill
+  3: [0.2, 0.55, 0.86],
+  // solid infill
+  4: [0.62, 0.66, 0.72],
+  // skirt / brim
+  5: [0.5, 0.54, 0.6],
+  // support
+  6: [0.42, 0.46, 0.52],
+  // raft
+  7: [0.96, 0.76, 0.22],
+  // gap fill
+  8: [0.88, 0.55, 0.3],
+  // thin wall
+  9: [0.3, 0.8, 0.62],
+  // bridge
+  10: [0.8, 0.42, 0.72],
+  // ironing
+  11: [0.58, 0.5, 0.88]
+  // prime tower
+}, Mt = {
+  0: "Travel",
+  1: "Wall",
+  2: "Sparse",
+  3: "Solid",
+  4: "Skirt",
+  5: "Support",
+  6: "Raft",
+  7: "Gap",
+  8: "Thin",
+  9: "Bridge",
+  10: "Ironing",
+  11: "Prime"
+}, dt = [
+  [0.9, 0.26, 0.3],
+  [0.27, 0.6, 0.93],
+  [0.36, 0.78, 0.42],
+  [0.98, 0.72, 0.2],
+  [0.72, 0.42, 0.9],
+  [0.2, 0.78, 0.8],
+  [0.95, 0.5, 0.72],
+  [0.6, 0.6, 0.64]
+];
+function St(t) {
+  const e = /^#?([0-9a-f]{6})$/i.exec(String(t ?? "").trim());
+  if (!e) return [0.5, 0.5, 0.5];
+  const n = parseInt(e[1], 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function et(t) {
+  const e = (n) => Math.max(0, Math.min(255, Math.round((Number(n) || 0) * 255)));
+  return e(t?.[0]) * 65536 + e(t?.[1]) * 256 + e(t?.[2]);
+}
+const At = [
+  [0.043, 0.173, 0.478],
+  [0.055, 0.325, 0.639],
+  [0.067, 0.478, 0.8],
+  [0.078, 0.631, 0.961],
+  [0.118, 0.749, 0.804],
+  [0.157, 0.867, 0.647],
+  [0.376, 0.902, 0.4],
+  [0.667, 0.898, 0.157],
+  [0.988, 0.976, 0.012],
+  [0.988, 0.663, 0.012],
+  [0.58, 0.149, 0.086]
+];
+function Nt(t, e, n, r = At) {
+  const o = r.length - 1;
+  if (o < 0) return [0, 0, 0];
+  if (!Number.isFinite(t) || !Number.isFinite(e) || !Number.isFinite(n) || n <= e || t <= e) return r[0];
+  if (t >= n) return r[o];
+  const i = (t - e) / (n - e) * o, f = Math.min(o - 1, Math.floor(i)), u = i - f, l = r[f], h = r[f + 1];
+  return [l[0] + (h[0] - l[0]) * u, l[1] + (h[1] - l[1]) * u, l[2] + (h[2] - l[2]) * u];
+}
+const nt = 8, It = 0.2, bt = 15, kt = 4, ot = {};
+for (const t of Object.keys(_)) ot[t] = et(_[t]);
+function Pt(t) {
+  const e = new Float32Array(t.length);
+  for (let n = 0; n < t.length; n++) {
+    const r = Number(t[n]?.z) || 0, o = n > 0 && Number(t[n - 1]?.z) || 0, i = n > 0 ? r - o : r;
+    e[n] = i > 1e-6 ? i : It;
+  }
+  return e;
+}
+const rt = (t) => t?.paths?.length ? t.paths : null, gt = (t) => {
+  const e = rt(t);
+  return e ? Math.floor(e.length / nt) : 0;
+};
+function Vt(t, e) {
+  const n = Array.isArray(t) ? t : [], r = n.length, o = Number(e) > 0 ? Number(e) : 0.4, i = Pt(n), f = new Uint32Array(r + 1), u = new Uint32Array(r + 1), l = new Uint32Array(r + 1);
+  let h = 0, c = 0, m = 0;
+  for (let p = 0; p < r; p++) {
+    const U = rt(n[p]), w = gt(n[p]);
+    for (let G = 0; G < w; G++)
+      U[G * nt + 3] & bt ? h++ : c++;
+    m += w, f[p + 1] = h, u[p + 1] = c, l[p + 1] = m;
+  }
+  const s = h * 2, b = new Float32Array(s * 4), L = new Float32Array(s * 4), y = new Uint32Array(s * 2), O = new Uint8Array(s), M = new Uint8Array(s), z = new Float32Array(s), S = new Float32Array(s), B = new Int32Array(s), g = new Float32Array(c * 6), C = new Float32Array(m * 3), a = new Uint8Array(m), v = new Float64Array(16);
+  let A = !1, N = 0, I = 1 / 0, P = 1 / 0, V = 1 / 0, J = -1 / 0, Q = -1 / 0, R = -1 / 0, x = 0, st = 0, at = 0, W = 0;
+  for (let p = 0; p < r; p++) {
+    const U = n[p], w = rt(U), G = gt(U), lt = U?.widths, E = i[p], ct = E / 2;
+    for (let X = 0; X < G; X++) {
+      const k = X * nt, Z = w[k], q = w[k + 1], $ = w[k + 2], D = w[k + 4], Y = w[k + 5], H = w[k + 6], ft = w[k + 3] | 0, K = ft & bt, Lt = ft >>> kt;
+      if (Number.isFinite(Z + q + $ + D + Y + H) || (A = !0), a[W] = K === 0 ? 0 : 1, C[W * 3] = D, C[W * 3 + 1] = Y, C[W * 3 + 2] = H, W++, K === 0) {
+        const d = at * 6;
+        g[d] = Z, g[d + 1] = q, g[d + 2] = $, g[d + 3] = D, g[d + 4] = Y, g[d + 5] = H, at++;
+        continue;
+      }
+      const tt = lt ? Number(lt[X]) : NaN, ut = Number.isFinite(tt) && tt > 0 ? tt : o, ht = D - Z, mt = Y - q, Ct = Math.atan2(mt, ht), vt = Math.hypot(ht, mt, H - $);
+      Number.isFinite(vt) && (v[K] += vt);
+      const Ft = ot[K] ?? ot[1];
+      for (const [d, T, yt] of [[Z, q, $], [D, Y, H]]) {
+        const F = x * 4;
+        b[F] = d, b[F + 1] = T, b[F + 2] = yt - ct, b[F + 3] = 0, L[F] = E, L[F + 1] = ut, L[F + 2] = Ct, L[F + 3] = Ft, y[x * 2] = st, y[x * 2 + 1] = p, O[x] = K, M[x] = Lt, z[x] = ut, S[x] = E, B[x] = p, x++;
+        const j = yt - ct;
+        d < I && (I = d), d > J && (J = d), T < P && (P = T), T > Q && (Q = T), j < V && (V = j), j > R && (R = j);
+        const pt = Math.max(Math.abs(d), Math.abs(T), Math.abs(j));
+        pt > N && (N = pt);
+      }
+      st++;
+    }
+  }
+  const xt = s > 0 && Number.isFinite(I) ? { min: [I, P, V], max: [J, Q, R] } : null;
+  return {
+    position: b,
+    hwa: L,
+    segIndex: y,
+    nV: s,
+    nSeg: h,
+    layerSegPrefix: f,
+    travelPos: g,
+    travelPrefix: u,
+    nTrav: c,
+    movePos: C,
+    moveKind: a,
+    movePrefix: l,
+    layerCount: r,
+    maxAbs: N,
+    hasNaN: A,
+    typeLengths: v,
+    bbox: xt,
+    meta: { vType: O, vTool: M, vWidth: z, vHeight: S, vLayer: B }
+  };
+}
+function Wt(t) {
+  const e = t ?? [];
+  let n = 0;
+  for (let o = 0; o < 16; o++) n += Number(e[o]) || 0;
+  if (n <= 0) return [];
+  const r = [];
+  for (let o = 0; o < 16; o++) {
+    const i = Number(e[o]) || 0;
+    i <= 0 || r.push({ type: o, label: Mt[o] ?? String(o), pct: i / n * 100, color: _[o] ?? _[1] });
+  }
+  return r.sort((o, i) => i.pct - o.pct);
+}
+const it = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
+function Ut(t, e) {
+  return it(t, e);
+}
+function Gt(t, e, n) {
+  const r = Math.min(n, t.layerCount - 1);
+  for (let o = r; o >= e; o--) if (it(t, o) > 0) return o;
+  return e;
+}
+function Dt(t, e, n) {
+  const r = it(t, e), o = Math.max(0, Math.min(Number(n) || 0, r)), i = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
+  let f = 0, u = 0;
+  for (let h = 0; h < o; h++)
+    t.moveKind[i + h] === 0 ? u++ : f++;
+  if (o === 0) return { point: null, segCount: 0, travCount: 0, onTravel: !1 };
+  const l = i + o - 1;
+  return {
+    point: [t.movePos[l * 3], t.movePos[l * 3 + 1], t.movePos[l * 3 + 2]],
+    segCount: f,
+    travCount: u,
+    onTravel: t.moveKind[l] === 0
+  };
+}
+const wt = [
+  { key: "feature", label: "Feature type", cont: !1, unit: "" },
+  { key: "speed", label: "Speed", cont: !0, unit: "mm/s" },
+  { key: "height", label: "Layer Height", cont: !0, unit: "mm" },
+  { key: "width", label: "Line Width", cont: !0, unit: "mm" },
+  { key: "fan", label: "Fan Speed", cont: !0, unit: "%" },
+  { key: "temp", label: "Temperature", cont: !0, unit: "°C" },
+  // Last, like upstream's EViewType::Tool: it answers "did my painted regions come out on the extruder I assigned?",
+  //  which is a check you run after slicing, not a property you scrub through. Discrete like the feature view — an
+  //  extruder index is a label, and a heatmap over it would imply tool 2 sits "between" tools 1 and 3.
+  { key: "filament", label: "Filament", cont: !1, unit: "" }
+];
+function Tt(t, e, n, r) {
+  const o = e.vType[n], i = e.vLayer[n], f = i === 0;
+  switch (t) {
+    case "height":
+      return e.vHeight[n];
+    case "width":
+      return e.vWidth[n];
+    case "speed":
+      return f ? r.firstLayerSpeed : r.speedByType[o] ?? r.speedByType[1];
+    case "fan":
+      return i < r.closeFanLayers ? 0 : o === 9 ? 100 : r.fanNormal;
+    case "temp":
+      return f ? r.tempFirst : r.tempNormal;
+    default:
+      return 0;
+  }
+}
+function Yt(t, e, n) {
+  const { meta: r, nV: o } = t, i = new Float32Array(o * 4), f = wt.find((c) => c.key === e) || wt[0];
+  if (!f.cont) {
+    const c = (n?.toolColors ?? []).map(St), m = f.key === "filament" ? (s) => {
+      const b = r.vTool ? r.vTool[s] : 0;
+      return c[b] || dt[b % dt.length];
+    } : (s) => _[r.vType[s]] || _[1];
+    for (let s = 0; s < o; s++) i[s * 4] = et(m(s));
+    return { color: i, min: 0, max: 0, viewType: e, label: f.label, unit: f.unit, cont: !1 };
+  }
+  let u = 1 / 0, l = -1 / 0;
+  const h = new Float32Array(o);
+  for (let c = 0; c < o; c++) {
+    const m = Tt(e, r, c, n), s = Number.isFinite(m) ? m : 0;
+    h[c] = s, s < u && (u = s), s > l && (l = s);
+  }
+  Number.isFinite(u) || (u = 0, l = 1);
+  for (let c = 0; c < o; c++) {
+    const m = Nt(h[c], u, l, At);
+    i[c * 4] = et(m);
+  }
+  return { color: i, min: u, max: l, viewType: e, label: f.label, unit: f.unit, cont: !0 };
+}
+const _t = `
+precision highp float;
+
+uniform mat4 projectionMatrix;
+uniform mat4 modelViewMatrix;
+uniform float uLayerLo;
+uniform float uLayerHi;
+
+in vec2  tpl;       // [end 0|1, ring 0..3]
+in vec3  iStart;
+in vec3  iEnd;
+in vec2  iHW;       // [height, width]
+in float iColor;    // r<<16 | g<<8 | b
+in float iLayer;
+
+out vec3 vColor;
+out vec3 vNormal;
+
+// The colour rides in one float rather than three: it is swapped on every view-type change, and one
+// attribute upload beats three. Exact below 2^24, which 0xffffff is.
+vec3 unpackColor(float p) {
+  float r = floor(p / 65536.0);
+  float g = floor(mod(p / 256.0, 256.0));
+  float b = mod(p, 256.0);
+  return vec3(r, g, b) / 255.0;
+}
+
+void main() {
+  // Out of range: collapse the whole instance to one point so it rasterizes nothing. A uniform does this
+  //  without touching a buffer, which is what keeps dragging the layer slider smooth.
+  if (iLayer < uLayerLo - 0.5 || iLayer > uLayerHi + 0.5) {
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    vColor = vec3(0.0);
+    vNormal = vec3(0.0, 0.0, 1.0);
+    return;
+  }
+
+  vec3 axis = iEnd - iStart;
+  // A zero-length segment has no direction to orient against; pick one rather than emitting NaN.
+  vec2 flat2 = axis.xy;
+  vec2 dir = length(flat2) > 1e-9 ? normalize(flat2) : vec2(1.0, 0.0);
+  vec3 side = vec3(-dir.y, dir.x, 0.0);
+  vec3 up   = vec3(0.0, 0.0, 1.0);
+
+  float halfHeight = iHW.x * 0.5;
+  float halfWidth  = iHW.y * 0.5;
+
+  float ring = tpl.y;
+  vec3 offset;
+  if (ring < 0.5)      offset =  side * halfWidth;
+  else if (ring < 1.5) offset =  up   * halfHeight;
+  else if (ring < 2.5) offset = -side * halfWidth;
+  else                 offset = -up   * halfHeight;
+
+  vec3 world = mix(iStart, iEnd, tpl.x) + offset;
+
+  vNormal = normalize(mat3(modelViewMatrix) * normalize(offset));
+  vColor = unpackColor(iColor);
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(world, 1.0);
+}
+`, Ot = `
+precision highp float;
+
+in vec3 vColor;
+in vec3 vNormal;
+out vec4 fragColor;
+
+void main() {
+  // Two-sided: the layer slider cuts the plate open, so back faces are seen and must not go black.
+  vec3 n = normalize(vNormal);
+  if (!gl_FrontFacing) n = -n;
+  // A single head-on light plus a generous ambient. The point is to read the bead's ROUNDING — which
+  //  face is up, which is the side — not to look lit.
+  float lambert = max(dot(n, normalize(vec3(0.35, 0.35, 1.0))), 0.0);
+  fragColor = vec4(vColor * (0.55 + 0.45 * lambert), 1.0);
+}
+`, zt = new Float32Array([
+  0,
+  0,
+  0,
+  1,
+  0,
+  2,
+  0,
+  3,
+  // start ring
+  1,
+  0,
+  1,
+  1,
+  1,
+  2,
+  1,
+  3
+  // end ring
+]), Bt = (() => {
+  const t = [];
+  for (let e = 0; e < 4; e++) {
+    const n = e, r = (e + 1) % 4, o = 4 + (e + 1) % 4, i = 4 + e;
+    t.push(n, r, o, n, o, i);
+  }
+  return t;
+})();
+function Ht(t, e) {
+  const { nSeg: n, nV: r, position: o, hwa: i, travelPos: f, travelPrefix: u, layerCount: l, meta: h } = e, c = new Float32Array(n * 3), m = new Float32Array(n * 3), s = new Float32Array(n * 2), b = new Float32Array(n), L = new Float32Array(n);
+  for (let a = 0; a < n; a++) {
+    const v = a * 2 * 4, A = (a * 2 + 1) * 4;
+    c[a * 3] = o[v], c[a * 3 + 1] = o[v + 1], c[a * 3 + 2] = o[v + 2], m[a * 3] = o[A], m[a * 3 + 1] = o[A + 1], m[a * 3 + 2] = o[A + 2], s[a * 2] = i[v], s[a * 2 + 1] = i[v + 1], b[a] = i[v + 3], L[a] = h.vLayer[a * 2];
+  }
+  const y = new t.InstancedBufferGeometry();
+  y.setAttribute("tpl", new t.BufferAttribute(zt, 2)), y.setIndex(Bt), y.setAttribute("iStart", new t.InstancedBufferAttribute(c, 3)), y.setAttribute("iEnd", new t.InstancedBufferAttribute(m, 3)), y.setAttribute("iHW", new t.InstancedBufferAttribute(s, 2));
+  const O = new t.InstancedBufferAttribute(b, 1);
+  y.setAttribute("iColor", O), y.setAttribute("iLayer", new t.InstancedBufferAttribute(L, 1)), y.instanceCount = n, y.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
+  const M = new t.RawShaderMaterial({
+    vertexShader: _t,
+    fragmentShader: Ot,
+    glslVersion: t.GLSL3,
+    side: t.DoubleSide,
+    uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, l - 1) } }
+  }), z = new t.Mesh(y, M);
+  z.frustumCulled = !1;
+  const S = new t.BufferGeometry();
+  S.setAttribute("position", new t.BufferAttribute(f, 3));
+  const B = new t.LineBasicMaterial({ color: 5923440, transparent: !0, opacity: 0.6 }), g = new t.LineSegments(S, B);
+  g.visible = !1, g.frustumCulled = !1;
+  const C = (a, v) => {
+    const A = Math.max(0, l - 1), N = Math.max(0, Math.min(a | 0, A)), I = Math.max(N, Math.min(v | 0, A));
+    M.uniforms.uLayerLo.value = N, M.uniforms.uLayerHi.value = I;
+    const P = u[N] * 2, V = u[I + 1] * 2;
+    S.setDrawRange(P, Math.max(0, V - P));
+  };
+  return C(0, l - 1), {
+    mesh: z,
+    travLines: g,
+    setLayerRange: C,
+    setVisibleLayers: (a) => C(0, (a | 0) - 1),
+    setTravelVisible: (a) => {
+      g.visible = !!a;
+    },
+    /** color is Float32Array(nV*4) with the packed value in .r — computeColors' output shape. One instance
+     *  takes the colour of its first vertex; the two agree, since a segment is one colour. */
+    setColors: (a) => {
+      if (!(!a || a.length < r * 4)) {
+        for (let v = 0; v < n; v++) b[v] = a[v * 2 * 4];
+        O.needsUpdate = !0;
+      }
+    },
+    dispose: () => {
+      y.dispose(), M.dispose(), S.dispose(), B.dispose();
+    },
+    nSeg: n,
+    layerCount: l
+  };
+}
+export {
+  At as DEFAULT_RANGES_COLORS,
+  dt as TOOL_COLOR,
+  _ as TYPE_COLOR,
+  Mt as TYPE_LABEL,
+  Bt as VERTEX_DATA,
+  wt as VIEW_TYPES,
+  Vt as buildSegmentData,
+  Yt as computeColors,
+  St as hexToRgb,
+  Ut as layerMoveCount,
+  Ht as makeToolpath,
+  Dt as moveCursor,
+  et as packColor,
+  Nt as rangeColorAt,
+  Wt as roleRatios,
+  Gt as topMoveLayer
+};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "three-slicer-viewer",
+  "version": "0.2.5",
+  "description": "The three-slicer viewer without the slicer \u2014 model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./toolpath": {
+      "types": "./types/toolpath.d.ts",
+      "default": "./dist/toolpath.js"
+    },
+    "./gcode": {
+      "types": "./types/gcode.d.ts",
+      "default": "./dist/gcode_parse.js"
+    },
+    "./loaders": {
+      "types": "./types/loaders.d.ts",
+      "default": "./dist/model_loaders.js"
+    },
+    "./settings": {
+      "types": "./types/settings.d.ts",
+      "default": "./src/settings/index.js"
+    },
+    "./data": {
+      "types": "./types/data.d.ts",
+      "default": "./src/data.js"
+    },
+    "./package.json": "./package.json",
+    "./toggle": {
+      "types": "./types/toggle.d.ts",
+      "default": "./src/settings/toggle_eval.js"
+    },
+    "./components": {
+      "types": "./types/components.d.ts",
+      "default": "./dist/components.js"
+    }
+  },
+  "files": [
+    "COMPONENTS.md",
+    "LICENSE",
+    "README.md",
+    "THIRD-PARTY-NOTICES.md",
+    "TOOLPATH_SPEC.md",
+    "VIEWER.md",
+    "data",
+    "dist",
+    "src/data.js",
+    "src/settings",
+    "types"
+  ],
+  "keywords": [
+    "3d-printing",
+    "gcode",
+    "toolpath",
+    "three",
+    "viewer"
+  ],
+  "peerDependencies": {
+    "three": "^0.160.0",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "vite build && cp src/make_worker.js dist/make_worker.js",
+    "prepublishOnly": "npm run build && node test_version_lockstep.mjs && node test_toolpath_contract.mjs"
+  }
+}

package/src/data.js

@@ -0,0 +1,2 @@
+// three-slicer-viewer/data — the reduced schema, the ui-tree keys and the preset key lists.
+export * from './settings/data.js'

package/src/settings/data.js

@@ -0,0 +1,6 @@
+// The single import site for this package's JSON artifacts — the same funnel rule as three-slicer's
+// engine/src/data.js: Vite strips `with { type: 'json' }` from bundles, so JSON may only be imported from a
+// module that is shipped UNBUNDLED and that the viewer build treats as external. That module is this one.
+export { default as leanSchema } from '../../data/config-schema-lean.json' with { type: 'json' }
+export { default as uiTreeKeys } from '../../data/ui-tree-keys.json' with { type: 'json' }
+export { default as presetKeys } from '../../data/preset-keys.json' with { type: 'json' }

package/src/settings/index.js

@@ -0,0 +1,2 @@
+// three-slicer-viewer/settings — the catalog-free settings surface. See settings_core.js.
+export * from './settings_core.js'

package/src/settings/kernel_setting_keys.js

@@ -0,0 +1,132 @@
+// AUTO-GENERATED by types/gen_kernel_params.mjs — DO NOT EDIT.
+// The schema keys deriveKernelParams consumes (the distinct "From setting" column of engine/PARAMS.md).
+export const KERNEL_SETTING_KEYS = [
+  "bottom_shell_layers",
+  "bottom_surface_filament_id",
+  "bridge_no_support",
+  "bridge_speed",
+  "brim_object_gap",
+  "brim_width",
+  "close_fan_the_first_x_layers",
+  "default_acceleration",
+  "enable_arc_fitting",
+  "enable_pressure_advance",
+  "enable_prime_tower",
+  "enable_support",
+  "fan_max_speed",
+  "filament_cost",
+  "filament_density",
+  "filament_diameter",
+  "filament_flow_ratio",
+  "filament_map",
+  "filament_retraction_length",
+  "filament_retraction_minimum_travel",
+  "filament_retraction_speed",
+  "filament_settings_id",
+  "filament_type",
+  "filament_z_hop",
+  "flush_into_infill",
+  "flush_multiplier",
+  "flush_volumes_matrix",
+  "full_fan_speed_layer",
+  "hot_plate_temp",
+  "independent_support_layer_height",
+  "infill_direction",
+  "initial_layer_line_width",
+  "initial_layer_print_height",
+  "initial_layer_speed",
+  "inner_wall_filament_id",
+  "inner_wall_line_width",
+  "internal_solid_filament_id",
+  "internal_solid_infill_line_width",
+  "ironing_flow",
+  "ironing_spacing",
+  "ironing_speed",
+  "ironing_type",
+  "layer_height",
+  "line_width",
+  "machine_end_gcode",
+  "machine_max_acceleration_e",
+  "machine_max_acceleration_retracting",
+  "machine_max_acceleration_x",
+  "machine_max_acceleration_z",
+  "machine_max_jerk_e",
+  "machine_max_jerk_x",
+  "machine_max_jerk_z",
+  "machine_max_speed_e",
+  "machine_max_speed_x",
+  "machine_max_speed_z",
+  "machine_start_gcode",
+  "max_volumetric_extrusion_rate_slope",
+  "nozzle_diameter",
+  "nozzle_temperature",
+  "outer_wall_filament_id",
+  "outer_wall_line_width",
+  "outer_wall_speed",
+  "pressure_advance",
+  "prime_tower_width",
+  "prime_volume",
+  "printable_area",
+  "printable_height",
+  "raft_contact_distance",
+  "raft_expansion",
+  "raft_layers",
+  "reduce_crossing_wall",
+  "resolution",
+  "retraction_length",
+  "retraction_minimum_travel",
+  "retraction_speed",
+  "seam_position",
+  "seam_slope_type",
+  "skirt_distance",
+  "skirt_height",
+  "skirt_loops",
+  "slow_down_layer_time",
+  "sparse_infill_density",
+  "sparse_infill_filament_id",
+  "sparse_infill_line_width",
+  "sparse_infill_pattern",
+  "spiral_mode",
+  "support_angle",
+  "support_base_pattern",
+  "support_base_pattern_spacing",
+  "support_bottom_z_distance",
+  "support_expansion",
+  "support_filament",
+  "support_interface_bottom_layers",
+  "support_interface_filament",
+  "support_interface_pattern",
+  "support_interface_spacing",
+  "support_interface_top_layers",
+  "support_line_width",
+  "support_object_first_layer_gap",
+  "support_object_xy_distance",
+  "support_on_build_plate_only",
+  "support_remove_small_overhang",
+  "support_style",
+  "support_threshold_angle",
+  "support_threshold_overlap",
+  "support_top_z_distance",
+  "support_type",
+  "top_shell_layers",
+  "top_surface_filament_id",
+  "top_surface_line_width",
+  "travel_acceleration",
+  "travel_speed",
+  "tree_support_angle_slow",
+  "tree_support_branch_angle",
+  "tree_support_branch_angle_organic",
+  "tree_support_branch_diameter",
+  "tree_support_branch_diameter_angle",
+  "tree_support_branch_diameter_organic",
+  "tree_support_branch_distance",
+  "tree_support_branch_distance_organic",
+  "tree_support_tip_diameter",
+  "tree_support_top_rate",
+  "tree_support_wall_count",
+  "wall_generator",
+  "wall_loops",
+  "wipe_tower_x",
+  "wipe_tower_y",
+  "z_hop",
+]