tracks: new /tracks generator for IKEA Lillabo / Brio train tracks

Wraps torwanbukaj/ikea-brio-others-compatible-train-tracks-generator
( https://github.com/torwanbukaj/... ) as a third generator alongside
holder and the universal scad playground.

Approach
--------
The upstream .scad ships as "library + one active example call". Used
include<> (rather than use<>) so the library's top-level globals
(track_width, plug/nest dimensions, $fn = 150, etc.) are available
to the modules — `use<>` does NOT propagate variables. Commented out
the upstream `track_tester();` call so include<> doesn't also emit
the tester geometry every time.

Per-render the backend builds a tiny wrapper SCAD on the fly:

    include <scad/train_tracks.scad>
    track(length=100, end1="plug", end2="nest", cutout=true, ...);

and hands it to holder.render_source().

Part types exposed (9)
----------------------
- tester        Calibration block (15-60mm)
- track         Straight (length + chamfers + grooves + plug/nest ends)
- arc           Curved (radius + angle, IKEA/Brio/J'adore radii in help text)
- dogbone       Nest-nest connector
- intersection  Crossing (angle + 2 lengths + 4 ends)
- switch        Turnout (left/right radius+angle, straight branch, common end)
- snake         S-curve (raised default target_length to 200 — the upstream
                modules's natural curvy-span at angle=45/radius=86 is ~150
                and the assert fires below that)
- adapter       BRIO <-> IKEA system adapter (plug + nest side)
- bridge        Multi-part (overview/ground/slope/pillar — value_map
                translates the UI labels to the int 0..3 the SCAD wants)

Files
-----
- scad/train_tracks.scad      Downloaded upstream (57 999 bytes), only
                              modification is the // before the top-level
                              track_tester() call.
- tracks.py                   PART_SCHEMAS dict, build_wrapper_scad,
                              render() that delegates to render_source.
- app.py                      GET /api/tracks/params, POST /api/tracks/render,
                              GET /tracks page route.
- static/tracks.html          Page with part selector + dynamic param form +
                              shared viewer markup. Reuses holder.css.
- static/js/tracks-app.js     Controller. Switching the part select redraws
                              the form (each part has its own schema).
                              Ctrl+Enter renders, Cancel uses AbortController.

Nav
---
Tracks link added to topbar on holder / index / scad.

Smoke test
----------
All 9 parts render with default params on the Manifold backend in
under 0.5s each (output sizes 440 KB - 1.8 MB).

app.py

@@ -20,6 +20,7 @@ from flask import Flask, Response, jsonify, request, send_from_directory
 from busbar_export import WRITERS
 import storage
 import holder
+import tracks
 
 APP_DIR = os.path.dirname(os.path.abspath(__file__))
 STATIC_DIR = os.path.join(APP_DIR, "static")
@@ -50,6 +51,12 @@ def scad_page():
     return send_from_directory(STATIC_DIR, "scad.html")
 
 
+@app.get("/tracks")
+def tracks_page():
+    """Wooden-train track generator (IKEA Lillabo / Brio compatible)."""
+    return send_from_directory(STATIC_DIR, "tracks.html")
+
+
 @app.get("/api/health")
 def health():
     return jsonify({"status": "ok", "openscad": holder.openscad_available()})
@@ -104,6 +111,25 @@ def holder_source():
         return jsonify({"error": str(e)}), 500
 
 
+@app.get("/api/tracks/params")
+def tracks_params():
+    return jsonify(tracks.schema_dict())
+
+
+@app.post("/api/tracks/render")
+def tracks_render():
+    body = request.get_json(silent=True) or {}
+    part = body.get("part")
+    params = body.get("params") or {}
+    try:
+        data, dims = tracks.render(part, params)
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 400
+    except (FileNotFoundError, RuntimeError) as e:
+        return jsonify({"error": str(e)}), 500
+    return _stl_response(data, dims, f"track_{part or 'part'}.stl")
+
+
 @app.post("/api/scad/render")
 def scad_render():
     """Render arbitrary user-supplied OpenSCAD source (no holder schema).

static/holder.css

@@ -166,6 +166,13 @@
 #fit-verdict.fit-ok    { color: #4ad97a; font-weight: 600; }
 #fit-verdict.fit-bad   { color: var(--danger, #d94a4a); font-weight: 600; }
 
+/* Tracks page: part-type selector (single big dropdown) */
+.part-select {
+  width: 100%;
+  font-size: 13px;
+  padding: 5px 8px;
+}
+
 /* SCAD editor — slides up from the bottom of the viewport */
 .scad-toggle {
   position: absolute;

static/holder.html

@@ -26,6 +26,7 @@
   <nav class="topbar-nav">
     <a href="/holder" class="active">Holder</a>
     <a href="/">Busbars</a>
+    <a href="/tracks">Tracks</a>
     <a href="/scad">SCAD</a>
   </nav>
 

static/index.html

@@ -13,6 +13,7 @@
   <nav class="topbar-nav">
     <a href="/holder">Holder</a>
     <a href="/" class="active">Busbars</a>
+    <a href="/tracks">Tracks</a>
     <a href="/scad">SCAD</a>
   </nav>
 

static/js/tracks-app.js

@@ -0,0 +1,216 @@
+/* tracks-app.js — controller for the /tracks (train tracks generator) page.
+ *
+ * - GET /api/tracks/params — schema for all parts.
+ * - Switching the part selector rebuilds the param form for that part.
+ * - POST /api/tracks/render with {part, params} → STL → Three.js viewer.
+ * - Re-uses holder-viewer.js (Three.js scene) and the same status / progress
+ *   markup the holder uses, styled via holder.css.
+ */
+
+const $ = (id) => document.getElementById(id);
+
+const state = {
+  schema: null,        // {parts: [{key, label, module, params, defaults}, ...]}
+  partsByKey: {},      // shortcut: key -> spec
+  currentPart: null,   // key
+  params: {},          // per-part current values (replaced on part change)
+  rendering: false,
+  abortCtrl: null,
+  elapsedTimer: null,
+  lastBlob: null,
+  rendererReady: false,
+};
+
+function _whenViewerReady(cb) {
+  if (window.HolderViewer) { cb(); return; }
+  let tries = 0;
+  const t = setInterval(() => {
+    if (window.HolderViewer) { clearInterval(t); cb(); }
+    else if (++tries > 50)   { clearInterval(t); console.error("HolderViewer never loaded"); }
+  }, 60);
+}
+
+// ----- form rendering -------------------------------------------------------
+
+function _renderForm() {
+  const spec = state.partsByKey[state.currentPart];
+  const root = $("param-form");
+  root.innerHTML = "";
+  if (!spec) return;
+
+  for (const p of spec.params) {
+    const row = document.createElement("div");
+    row.className = "param-row";
+
+    const label = document.createElement("label");
+    label.textContent = p.label || p.name;
+    row.appendChild(label);
+
+    let inp;
+    if (p.kind === "select") {
+      inp = document.createElement("select");
+      for (const opt of p.options || []) {
+        const o = document.createElement("option");
+        o.value = opt; o.textContent = opt;
+        if (opt === state.params[p.name]) o.selected = true;
+        inp.appendChild(o);
+      }
+    } else if (p.kind === "bool") {
+      inp = document.createElement("input");
+      inp.type = "checkbox";
+      inp.checked = !!state.params[p.name];
+    } else {
+      inp = document.createElement("input");
+      inp.type = "number";
+      if (p.min  != null) inp.min  = p.min;
+      if (p.max  != null) inp.max  = p.max;
+      if (p.step != null) inp.step = p.step;
+      inp.value = state.params[p.name] ?? p.default;
+    }
+    inp.name = p.name;
+    inp.dataset.kind = p.kind;
+    inp.addEventListener("change", _onParamChange);
+    inp.addEventListener("input",  _onParamChange);
+    row.appendChild(inp);
+
+    if (p.help) {
+      const h = document.createElement("div");
+      h.className = "param-help";
+      h.textContent = p.help;
+      row.appendChild(h);
+    }
+    root.appendChild(row);
+  }
+
+  $("status").textContent = spec.label;
+}
+
+function _onParamChange(e) {
+  const el = e.target;
+  const k = el.name;
+  let v;
+  if (el.dataset.kind === "bool") v = el.checked;
+  else if (el.dataset.kind === "number") v = el.value === "" ? null : Number(el.value);
+  else v = el.value;
+  state.params[k] = v;
+}
+
+function _switchPart(key) {
+  const spec = state.partsByKey[key];
+  if (!spec) return;
+  state.currentPart = key;
+  state.params = { ...spec.defaults };
+  $("part-help").textContent = spec.module ? `module: ${spec.module}()` : "";
+  _renderForm();
+}
+
+// ----- render orchestration -------------------------------------------------
+
+function _showProgress(show) {
+  $("render-progress").hidden = !show;
+  $("btn-render").hidden = show;
+  $("btn-cancel").hidden = !show;
+}
+
+async function _doRender() {
+  if (state.rendering || !state.currentPart) return;
+  state.rendering = true;
+  state.abortCtrl = new AbortController();
+  $("render-status").textContent = "rendering…";
+  $("warning").textContent = "";
+  _showProgress(true);
+
+  const t0 = performance.now();
+  state.elapsedTimer = setInterval(() => {
+    $("render-elapsed").textContent = ((performance.now() - t0) / 1000).toFixed(1) + "s";
+  }, 100);
+
+  try {
+    const res = await fetch("/api/tracks/render", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ part: state.currentPart, params: state.params }),
+      signal: state.abortCtrl.signal,
+    });
+    if (!res.ok) {
+      let msg = res.statusText;
+      try { msg = (await res.json()).error || msg; } catch {}
+      throw new Error(msg);
+    }
+    state.lastBlob = await res.blob();
+    const buf = await state.lastBlob.arrayBuffer();
+    window.HolderViewer.loadSTL(buf);
+    const dt = ((performance.now() - t0) / 1000).toFixed(1);
+    $("render-status").textContent =
+      `✓ rendered in ${dt}s · ${(state.lastBlob.size/1024).toFixed(0)} kB`;
+  } catch (e) {
+    if (e.name === "AbortError") $("render-status").textContent = "✗ cancelled";
+    else                          $("render-status").textContent = `✗ ${e.message}`;
+  } finally {
+    state.rendering = false;
+    state.abortCtrl = null;
+    clearInterval(state.elapsedTimer);
+    _showProgress(false);
+  }
+}
+
+// ----- wiring ---------------------------------------------------------------
+
+$("btn-render").addEventListener("click", _doRender);
+$("btn-cancel").addEventListener("click", () => state.abortCtrl?.abort());
+
+$("part-select").addEventListener("change", (e) => _switchPart(e.target.value));
+
+$("btn-download-stl").addEventListener("click", () => {
+  if (!state.lastBlob) { alert("Nothing rendered yet."); return; }
+  const url = URL.createObjectURL(state.lastBlob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = `track_${state.currentPart}.stl`;
+  document.body.appendChild(a); a.click();
+  setTimeout(() => { URL.revokeObjectURL(url); a.remove(); }, 100);
+});
+
+// Ctrl+Enter triggers Render.
+document.addEventListener("keydown", (e) => {
+  if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
+    e.preventDefault();
+    _doRender();
+  }
+});
+
+// ----- bootstrap ------------------------------------------------------------
+
+async function init() {
+  try {
+    const r = await fetch("/api/tracks/params");
+    if (!r.ok) throw new Error(r.statusText);
+    state.schema = await r.json();
+    state.partsByKey = Object.fromEntries(state.schema.parts.map((p) => [p.key, p]));
+
+    // Populate the part selector.
+    const sel = $("part-select");
+    sel.innerHTML = "";
+    for (const p of state.schema.parts) {
+      const o = document.createElement("option");
+      o.value = p.key; o.textContent = p.label;
+      sel.appendChild(o);
+    }
+    // Pick "track" (straight) by default — most useful first impression.
+    const defaultKey = state.partsByKey.track ? "track" : state.schema.parts[0].key;
+    sel.value = defaultKey;
+    _switchPart(defaultKey);
+  } catch (e) {
+    $("param-form").innerHTML =
+      `<div class="step-preview-err">Couldn't load schema: ${e.message}</div>`;
+    return;
+  }
+
+  _whenViewerReady(() => {
+    window.HolderViewer.init($("viewer3d"));
+    state.rendererReady = true;
+    _doRender();   // initial render so the user sees something
+  });
+}
+
+init();

static/scad.html

@@ -26,6 +26,7 @@
   <nav class="topbar-nav">
     <a href="/holder">Holder</a>
     <a href="/">Busbars</a>
+    <a href="/tracks">Tracks</a>
     <a href="/scad" class="active">SCAD</a>
   </nav>
 

static/tracks.html

@@ -0,0 +1,76 @@
+<!doctype html>
+<html lang="ru">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Train Tracks Generator</title>
+<link rel="stylesheet" href="styles.css" />
+<link rel="stylesheet" href="holder.css" />
+
+<script type="importmap">
+{
+  "imports": {
+    "three": "https://cdn.jsdelivr.net/npm/three@0.165.0/build/three.module.js",
+    "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.165.0/examples/jsm/"
+  }
+}
+</script>
+</head>
+<body>
+<header class="topbar">
+  <h1>Train Tracks</h1>
+
+  <nav class="topbar-nav">
+    <a href="/holder">Holder</a>
+    <a href="/">Busbars</a>
+    <a href="/tracks" class="active">Tracks</a>
+    <a href="/scad">SCAD</a>
+  </nav>
+
+  <span id="status" class="topbar-status">choose a part →</span>
+
+  <div class="actions">
+    <button id="btn-render" class="primary" title="Render STL with current parameters">Render</button>
+    <button id="btn-cancel" title="Cancel running render" hidden>Cancel</button>
+    <button id="btn-download-stl" title="Download the rendered STL">Download STL</button>
+  </div>
+</header>
+
+<main>
+  <aside class="left holder-left">
+    <section class="panel">
+      <h2>Part</h2>
+      <select id="part-select" class="part-select"></select>
+      <p class="hint" id="part-help"></p>
+    </section>
+
+    <section class="panel">
+      <h2>Parameters</h2>
+      <div id="param-form" class="param-form">
+        <div class="hint">Loading…</div>
+      </div>
+    </section>
+
+    <section class="panel">
+      <h2>Status</h2>
+      <p class="hint" id="render-status">idle</p>
+      <div id="render-progress" class="render-progress" hidden>
+        <div class="render-progress-bar"><div class="render-progress-fill"></div></div>
+        <span id="render-elapsed" class="render-elapsed">0.0s</span>
+      </div>
+      <p class="hint" id="warning"></p>
+    </section>
+  </aside>
+
+  <section class="right">
+    <div id="viewer3d" class="viewer3d"></div>
+    <div class="viewport-overlay">
+      <div id="hint-controls">left-drag: rotate · right-drag: pan · wheel: zoom</div>
+    </div>
+  </section>
+</main>
+
+<script type="module" src="js/holder-viewer.js"></script>
+<script type="module" src="js/tracks-app.js"></script>
+</body>
+</html>

tracks.py

@@ -0,0 +1,274 @@
+"""Wooden-train track generator (IKEA Lillabo / Brio / J'adore compatible).
+
+Wraps the train_tracks.scad library from
+  https://github.com/torwanbukaj/ikea-brio-others-compatible-train-tracks-generator
+
+The .scad ships as a "library + a single active example call". We comment
+the example out locally and dynamically build a tiny wrapper SCAD per
+render request:
+
+    include <scad/train_tracks.scad>
+    track(length=100, end1="plug", end2="nest", cutout=true, ...);
+
+Each "part" the user can generate has its own parameter schema (PART_SCHEMAS).
+The frontend renders a form per selected part; the backend builds the call
+and reuses holder.render_source() for the actual openscad invocation.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import holder  # for render_source() and _to_scad_literal()
+
+APP_DIR = Path(__file__).resolve().parent
+SCAD_LIBRARY = APP_DIR / "scad" / "train_tracks.scad"
+
+
+# ---------------------------------------------------------------------------
+# Part schemas.
+#   "module"  — the SCAD module to invoke.
+#   "params"  — UI-driven inputs; each entry is the same shape the /holder
+#               schema uses (name/label/kind/default/min/max/step/options/help).
+#   "value_map" — optional name -> {ui_value: scad_value} translation for
+#                 select params whose label isn't what the SCAD wants
+#                 (e.g. bridge "ground" -> int 1).
+# ---------------------------------------------------------------------------
+
+PART_SCHEMAS: dict[str, dict] = {
+
+    # ---------- Calibration -------------------------------------------------
+    "tester": {
+        "label": "Track tester (calibration)",
+        "module": "track_tester",
+        "params": [
+            {"name": "tester_length", "label": "Tester length (mm)",
+             "kind": "number", "default": 25, "min": 15, "max": 60, "step": 1,
+             "help": "Small block — print first to verify plug/nest fit."},
+        ],
+    },
+
+    # ---------- Straight ----------------------------------------------------
+    "track": {
+        "label": "Straight track",
+        "module": "track",
+        "params": [
+            {"name": "length",        "label": "Length (mm)", "kind": "number",
+             "default": 100, "min": 20, "max": 500, "step": 5,
+             "help": "IKEA standards: 50 / 100 / 146 / 205 / 240. Brio: 145."},
+            {"name": "end1",          "label": "End 1",       "kind": "select",
+             "default": "plug", "options": ["plug", "nest", "none"]},
+            {"name": "end2",          "label": "End 2",       "kind": "select",
+             "default": "nest", "options": ["plug", "nest", "none"]},
+            {"name": "cutout",        "label": "Wheel cutout","kind": "bool", "default": True},
+            {"name": "grooves",       "label": "Side grooves","kind": "bool", "default": True},
+            {"name": "part_chamfers", "label": "Corner chamfers", "kind": "bool", "default": True},
+            {"name": "both_sides",    "label": "Both sides grooves", "kind": "bool", "default": False},
+        ],
+    },
+
+    # ---------- Arc ---------------------------------------------------------
+    "arc": {
+        "label": "Arc / curved track",
+        "module": "track_arc",
+        "params": [
+            {"name": "radius",        "label": "Radius (mm)",  "kind": "number",
+             "default": 185, "min": 50, "max": 500, "step": 1,
+             "help": "IKEA Lillabo: 180–185. J'adore: 86. Brio U-turn: 86."},
+            {"name": "angle",         "label": "Angle (deg)",  "kind": "number",
+             "default": 45, "min": -180, "max": 180, "step": 1,
+             "help": "Negative angle curves the other direction. IKEA: 22.5 or 45."},
+            {"name": "end1",          "label": "End 1",        "kind": "select",
+             "default": "plug", "options": ["plug", "nest", "none"]},
+            {"name": "end2",          "label": "End 2",        "kind": "select",
+             "default": "nest", "options": ["plug", "nest", "none"]},
+            {"name": "grooves",       "kind": "bool", "default": True},
+            {"name": "cutout",        "kind": "bool", "default": True},
+            {"name": "both_sides",    "kind": "bool", "default": False},
+            {"name": "part_chamfers", "kind": "bool", "default": True},
+        ],
+    },
+
+    # ---------- Dog-bone connector -----------------------------------------
+    "dogbone": {
+        "label": "Dog-bone (nest–nest connector)",
+        "module": "track_dogbone",
+        "params": [
+            {"name": "radius",        "label": "Plug radius (mm)", "kind": "number",
+             "default": 6.5, "min": 5.5, "max": 7.5, "step": 0.05,
+             "help": "IKEA Lillabo / Brio: 6.5 (slightly oversized for springy fit)."},
+        ],
+    },
+
+    # ---------- Intersection -----------------------------------------------
+    "intersection": {
+        "label": "Intersection (crossing)",
+        "module": "intersection",
+        "params": [
+            {"name": "angle",      "label": "Crossing angle (deg)", "kind": "number",
+             "default": 90, "min": 30, "max": 150, "step": 1},
+            {"name": "lengthA",    "label": "Length A (mm)",        "kind": "number",
+             "default": 100, "min": 50, "max": 300, "step": 5},
+            {"name": "lengthB",    "label": "Length B (mm)",        "kind": "number",
+             "default": 100, "min": 50, "max": 300, "step": 5},
+            {"name": "end1A",      "kind": "select", "default": "nest", "options": ["plug", "nest", "none"]},
+            {"name": "end2A",      "kind": "select", "default": "plug", "options": ["plug", "nest", "none"]},
+            {"name": "end1B",      "kind": "select", "default": "nest", "options": ["plug", "nest", "none"]},
+            {"name": "end2B",      "kind": "select", "default": "plug", "options": ["plug", "nest", "none"]},
+            {"name": "both_sides", "kind": "bool", "default": True},
+        ],
+    },
+
+    # ---------- Switch / turnout -------------------------------------------
+    "switch": {
+        "label": "Switch (turnout)",
+        "module": "switch",
+        "params": [
+            {"name": "angleR",  "label": "Right angle (deg)",  "kind": "number",
+             "default": 45, "min": 10, "max": 90, "step": 1},
+            {"name": "radiusR", "label": "Right radius (mm)",  "kind": "number",
+             "default": 86, "min": 50, "max": 300, "step": 1},
+            {"name": "endR",    "label": "Right end",          "kind": "select",
+             "default": "nest", "options": ["plug", "nest"]},
+            {"name": "angleL",  "label": "Left angle (deg)",   "kind": "number",
+             "default": 45, "min": 10, "max": 90, "step": 1},
+            {"name": "radiusL", "label": "Left radius (mm)",   "kind": "number",
+             "default": 86, "min": 50, "max": 300, "step": 1},
+            {"name": "endL",    "label": "Left end",           "kind": "select",
+             "default": "plug", "options": ["plug", "nest"]},
+            {"name": "lengthS", "label": "Straight length (mm)", "kind": "number",
+             "default": 146, "min": 50, "max": 300, "step": 1},
+            {"name": "endS",    "label": "Straight end",       "kind": "select",
+             "default": "nest", "options": ["plug", "nest"]},
+            {"name": "endCommon", "label": "Common (junction) end", "kind": "select",
+             "default": "nest", "options": ["plug", "nest"]},
+            {"name": "both_sides", "kind": "bool", "default": True},
+        ],
+    },
+
+    # ---------- Snake track ------------------------------------------------
+    "snake": {
+        "label": "Snake (S-curve)",
+        "module": "snake_track",
+        "params": [
+            {"name": "angle",         "kind": "number", "default": 45, "min": 10, "max": 90, "step": 1},
+            {"name": "radius",        "kind": "number", "default": 86, "min": 50, "max": 300, "step": 1},
+            {"name": "target_length", "label": "Target length (mm)", "kind": "number",
+             "default": 200, "min": 50, "max": 400, "step": 5,
+             "help": "Must be larger than the S-curve's natural Y-span (about 150mm for angle=45, radius=86)."},
+            {"name": "end1",          "kind": "select", "default": "plug", "options": ["plug", "nest", "none"]},
+            {"name": "end2",          "kind": "select", "default": "nest", "options": ["plug", "nest", "none"]},
+            {"name": "cutout",        "kind": "bool", "default": True},
+            {"name": "both_sides",    "kind": "bool", "default": True},
+        ],
+    },
+
+    # ---------- Adapter (BRIO <-> IKEA) ------------------------------------
+    "adapter": {
+        "label": "Adapter (BRIO ↔ IKEA)",
+        "module": "tracks_adapter",
+        "params": [
+            {"name": "length", "kind": "number", "default": 30, "min": 20, "max": 80, "step": 1},
+            {"name": "nest",   "label": "Nest side system", "kind": "select",
+             "default": "B", "options": ["I", "B"],
+             "help": "I = IKEA Lillabo, B = Brio."},
+            {"name": "plug",   "label": "Plug side system", "kind": "select",
+             "default": "I", "options": ["I", "B"]},
+        ],
+    },
+
+    # ---------- Bridge -----------------------------------------------------
+    "bridge": {
+        "label": "Bridge (multi-part)",
+        "module": "generate_bridge",
+        "params": [
+            {"name": "what_to_generate", "label": "Part", "kind": "select",
+             "default": "ground",
+             "options": ["overview", "ground", "slope", "pillar"],
+             "help": "Print each part separately; overview shows them together for sizing."},
+            {"name": "bridge_angle",    "label": "Slope angle (deg)", "kind": "number",
+             "default": 14, "min": 5,  "max": 30,  "step": 1},
+            {"name": "slope_radius",    "label": "Slope radius (mm)", "kind": "number",
+             "default": 100, "min": 50, "max": 300, "step": 5},
+            {"name": "straight_part_l", "label": "Straight part (mm)", "kind": "number",
+             "default": 205, "min": 50, "max": 400, "step": 5},
+            {"name": "pillar_l",        "label": "Pillar length (mm)", "kind": "number",
+             "default": 50, "min": 20, "max": 200, "step": 5},
+            {"name": "cutout",          "kind": "bool", "default": True},
+        ],
+        "value_map": {
+            # SCAD takes int 0..3; UI uses labels.
+            "what_to_generate": {"overview": 0, "ground": 1, "slope": 2, "pillar": 3},
+        },
+    },
+}
+
+
+def schema_dict() -> dict:
+    """Public API shape returned by /api/tracks/params."""
+    parts = []
+    for key, spec in PART_SCHEMAS.items():
+        defaults = {p["name"]: p["default"] for p in spec["params"]}
+        parts.append({
+            "key":      key,
+            "label":    spec["label"],
+            "module":   spec["module"],
+            "params":   spec["params"],
+            "defaults": defaults,
+        })
+    return {"parts": parts}
+
+
+# ---------------------------------------------------------------------------
+# Wrapper-SCAD builder
+# ---------------------------------------------------------------------------
+
+def _to_scad_literal(v: Any) -> str:
+    # Defer to holder's literal formatter for consistency (bools lowercased,
+    # ints stay int-like, strings get JSON-quoted).
+    return holder._to_scad_literal(v)
+
+
+def build_wrapper_scad(part: str, params: dict | None) -> str:
+    spec = PART_SCHEMAS.get(part)
+    if not spec:
+        raise ValueError(f"unknown track part: {part!r}")
+    value_map = spec.get("value_map", {})
+    schema_by_name = {p["name"]: p for p in spec["params"]}
+
+    args: list[str] = []
+    incoming = params or {}
+    for p in spec["params"]:
+        name = p["name"]
+        if name in incoming and incoming[name] is not None:
+            v = incoming[name]
+        else:
+            v = p["default"]
+        # Coerce
+        if p["kind"] == "number":
+            v = float(v)
+            if v.is_integer():
+                v = int(v)
+        elif p["kind"] == "bool":
+            v = bool(v)
+        elif p["kind"] == "select":
+            v = str(v)
+        # Apply optional label -> SCAD value translation
+        if name in value_map and v in value_map[name]:
+            v = value_map[name][v]
+        args.append(f"{name} = {_to_scad_literal(v)}")
+
+    # Path relative to the temp file holder.render_source writes — it puts
+    # the file in a fresh tempdir, so resolve absolute path for `include`.
+    return (
+        f'include <{SCAD_LIBRARY.as_posix()}>\n'
+        f'{spec["module"]}({", ".join(args)});\n'
+    )
+
+
+def render(part: str, params: dict | None = None) -> tuple[bytes, dict]:
+    """Render the chosen track part with the supplied params."""
+    src = build_wrapper_scad(part, params)
+    return holder.render_source(src)