partforge 0.105.2 → 0.106.1

package/README.md

@@ -15,7 +15,7 @@ use can drive to author, test, and measure a part, then ship it as a browser app
 
 ## See it
 
-- **Live showcase** — https://scottsykora.github.io/partforge/ — example forges (Faceted
+- **Live showcase** — https://pixiteapps.github.io/partforge/ — example forges (Faceted
   Planter, Spacer, Filleted Box) you can open, adjust, and export.
 - **A real forge** — https://scottsykora.github.io/Drum-Machine/ — a parametric capstan
   drum built with partforge for a robotics project.
@@ -25,7 +25,7 @@ use can drive to author, test, and measure a part, then ship it as a browser app
 You don't write CAD by hand. Point a tool-using AI agent (Claude Code, or the Claude /
 ChatGPT desktop apps with file access) at this repo and describe what you want:
 
-> Using the partforge framework at https://github.com/scottsykora/partforge, build me a
+> Using the partforge framework at https://github.com/pixiteapps/partforge, build me a
 > _\<your part\>_ — _\<the dimensions, fits, and features that matter\>_.
 
 Expect a few turns. The first attempt is often rough, but you refine it in plain language

package/docs/AUTHORING-PARTS.md

@@ -736,7 +736,15 @@ Every control accepts `key`, `type`, `label`, `description`, `hidden`, `when` an
 | `"vector"` | a drop target showing the artwork — no catalog exists | `sourceField` |
 
 Numeric controls always show the number box: drag the slider *or* type an exact
-value. Typed values may be finer than `step` and clamp to `[min, max]` on commit.
+value. Typed values may be finer than `step` and may sit **outside `[min, max]`**:
+the range bounds the slider track, not the parameter. An out-of-range value commits
+as typed and the build runs with it — the box turns red while the value is outside
+the range, the thumb pins at the nearer end of the track, and a build that can't
+take the value fails in the status line while the viewer keeps the last good
+geometry. A build that *succeeds into nothing* (a boolean that empties a sub-part)
+is reported there too — "empty: body produced no geometry at these values". Author
+`min`/`max` as the span the track should cover, not as a guard the build relies
+on; a build that needs a floor clamps it itself.
 Text fields write `params` on every keystroke, so the rebuild loop previews the new
 string immediately; give every text key a string default (empty strings are valid,
 and the build decides whether its geometry tolerates one).
@@ -826,18 +834,21 @@ for when a raw linear slider misrepresents the parameter.
   must sit inside `[min, max]`. Add **`snap: true`** to quantize *slider drags* to the
   nearest tick; the number box stays free, so an off-tick value is always still
   typeable. Use it for stock sizes: M3/M4/M5, 3 mm / 6 mm plate.
-- **`recommended: [lo, hi]`** — tints that span of the track and puts a warning border
-  on the number box when the value sits outside it. This is the **visual companion to
-  the DFM checks**: the band is where the process the part targets is comfortable
-  (minimum wall, nozzle multiples, sane clearances), and `verify`'s `minWall` /
-  process checks are the same judgement enforced at measure time. It is advisory —
-  outside values remain selectable, because a user who knows their printer should not
-  be blocked by a default profile.
+- **`recommended: [lo, hi]`** — tints that span of the track. This is the **visual
+  companion to the DFM checks**: the band is where the process the part targets is
+  comfortable (minimum wall, nozzle multiples, sane clearances), and `verify`'s
+  `minWall` / process checks are the same judgement enforced at measure time. It is
+  purely advisory — it never colours the number box (red is reserved for values
+  outside `[min, max]`), and outside values remain selectable, because a user who
+  knows their printer should not be blocked by a default profile. Say **why** the
+  band sits where it does in the control's `description` ("below 1.2 mm a 0.4 mm
+  nozzle prints walls poorly"); the band alone is a hint, the description is the
+  reason.
 
 `ticks`, `snap` and `recommended` render on a **linear track only**; combined with
 `scale: "log"` they are ignored, and `slider-refinement-invalid` warns. On a
-`"number"` control there is no track at all: `recommended` still tints the box on an
-out-of-band value, while `scale`, `ticks` and `snap` do nothing.
+`"number"` control there is no track at all, so `recommended`, `scale`, `ticks` and
+`snap` do nothing.
 
 ### Conditions: `when` and `whenFalse`
 
@@ -1101,6 +1112,17 @@ defaulting everything to a slider:
 - **A continuous dimension** → `"slider"`. Add `recommended` when there's a
   manufacturable band, `ticks` + `snap` when real-world stock sizes exist, and
   `scale: "log"` when the range spans decades.
+
+  **Make the range generous.** `min`/`max` bound the slider track, not the
+  parameter — a user can type past either end and the build runs with it — so the
+  range is the whole span the build can turn into sensible geometry, not the
+  neighbourhood of the default. As a floor, reach at least ¼× and 4× the default,
+  and much further for an open-ended dimension (a length, a height, a count).
+  Where one value must stay below another (a fillet radius against a half-width),
+  clamp it in `build` or `derive` rather than narrowing the range: a narrow range
+  is a limit the user hits immediately, a clamp is one they never notice. Typical
+  values belong in the `description`; a process limit belongs in `recommended`,
+  with the reason in the description.
 - **A precise or very wide number** (a count, a tolerance, a coordinate) →
   `"number"`, so the user types rather than hunts.
 - **A discrete choice** → `"select"` when the values are a list, or `"radio"` when

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "partforge",
-  "version": "0.105.2",
+  "version": "0.106.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/scottsykora/partforge.git"
+    "url": "git+https://github.com/pixiteapps/partforge.git"
   },
-  "homepage": "https://github.com/scottsykora/partforge#readme",
-  "bugs": "https://github.com/scottsykora/partforge/issues",
+  "homepage": "https://github.com/pixiteapps/partforge#readme",
+  "bugs": "https://github.com/pixiteapps/partforge/issues",
   "engines": {
     "node": ">=24"
   },

package/src/framework/mount.js

@@ -794,6 +794,9 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
       }
     }
 
+    // Sub-parts whose latest fresh delivery had zero triangles (see the `meshes` case).
+    const emptySubParts = new Set();
+
     function refreshView() {
       const needed = viewSubParts(part, view(), params);
       if (needed.every(isCurrent)) {
@@ -838,6 +841,13 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
             for (const m of data.meshes) {
               viewer.setSubGeometry(m.name, m); // disposes any previous mesh for this name
               cache.record(m.name);
+              // A sub-part that built into NOTHING. Manifold booleans return an
+              // empty solid rather than throwing (a bore wider than its body),
+              // and typed values may sit outside the authored range, so a
+              // "successful" build can deliver zero triangles — recorded here,
+              // reported below once the view is whole. Undefined counts (a
+              // host's synthetic reply) are not empty.
+              if (m.triangles === 0) emptySubParts.add(m.name); else emptySubParts.delete(m.name);
               // Stamp the fast path's pose baseline. Only here, inside the
               // non-stale branch: the stamp must describe the geometry actually
               // delivered, which buildDone() true guarantees is at the live params.
@@ -848,6 +858,12 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
             // still be running — often OCCT, the slow one).
             if (missingParts().length === 0) ui.hideBusy();
             refreshView();
+            // After refreshView, like the error case: its all-current branch
+            // clears the status line, and this message has to outlive that.
+            if (missingParts().length === 0) {
+              const empty = viewSubParts(part, view(), params).filter((n) => emptySubParts.has(n));
+              if (empty.length) ui.setStatus(`empty: ${empty.join(", ")} produced no geometry at these values`, true);
+            }
             if (data.ms && missingParts().length === 0) {
               const tris = viewSubParts(part, view(), params).reduce((s, n) => s + viewer.subTriangles(n), 0);
               console.debug(`partforge: built ${tris.toLocaleString()} triangles in ${(data.ms / 1000).toFixed(1)} s`);

package/src/framework/panel/widgets/numeric.js

@@ -1,11 +1,16 @@
 // slider + number: a range input (omitted for `number`) beside an editable value
-// box. The box accepts exact values finer than `step`; typed values clamp to
-// [min, max] on commit (blur/Enter).
+// box. The box accepts exact values finer than `step` AND values outside
+// [min, max]: the authored range bounds the slider track, not the parameter.
+// A typed out-of-range value commits as typed (the build gets to try it and
+// fails visibly if it can't), the thumb pins at the nearer end of the track,
+// and the box paints red until the value is back inside the range.
 import { attachInfo } from "../info.js";
 
 // Short numeric string without float noise (4 dp max) for the value box.
 const numStr = (v) => String(Math.round(v * 1e4) / 1e4);
 
+// Kept as a public helper (re-exported from controls.js) for hosts; the widget
+// itself no longer clamps typed input — see the header comment.
 export function clampToRange(raw, min, max) {
   const v = parseFloat(raw);
   if (!Number.isFinite(v)) return null;
@@ -31,7 +36,9 @@ export function makeNumeric(node, params, { onChange, onCommit, info }) {
   const box = document.createElement("input");
   box.type = "number";
   box.className = "num";
-  box.min = node.min; box.max = node.max; box.step = node.step;
+  // No native min/max on the box: the range is advisory for typed input, and
+  // the attributes would add browser validity styling and clamp the spinner.
+  box.step = node.step;
   box.value = numStr(params[node.key]);
   val.append(box);
   if (node.unit) val.append(el("span", "unit", node.unit));
@@ -55,6 +62,11 @@ export function makeNumeric(node, params, { onChange, onCommit, info }) {
     return Math.max(0, Math.min(LOG_STEPS, Number.isFinite(t) ? t : 0));
   };
 
+  // Where the thumb sits for a value: pinned at the nearer end when the value
+  // is outside [min, max] (a range input sanitises this itself, but jsdom and
+  // the log mapping don't, so be explicit).
+  const thumbFor = (v) => log ? toPosSafe(v) : Math.max(node.min, Math.min(node.max, v));
+
   let slider = null;
   if (!numeric) {
     slider = document.createElement("input");
@@ -91,8 +103,9 @@ export function makeNumeric(node, params, { onChange, onCommit, info }) {
     return node.ticks.reduce((best, t) => Math.abs(t - v) < Math.abs(best - v) ? t : best);
   };
 
-  // recommended: a tinted band of the track, and a warning on the value box
-  // when the current value sits outside it. Linear tracks only (like ticks).
+  // recommended: a tinted band of the track — purely visual; it never colours
+  // the value box (that is reserved for values outside [min, max] below).
+  // Linear tracks only (like ticks).
   const band = !log && Array.isArray(node.recommended) && node.recommended.length === 2
     ? node.recommended : null;
   if (band) {
@@ -104,25 +117,28 @@ export function makeNumeric(node, params, { onChange, onCommit, info }) {
     wrap.style.setProperty("--band-lo", pct(band[0]));
     wrap.style.setProperty("--band-hi", pct(band[1]));
   }
+  // The box goes red only when the value is outside the authored range — a
+  // typed overshoot, or a preset/host value the range never covered.
   const paintWarn = () => {
-    if (band) box.classList.toggle("warn", params[node.key] < band[0] || params[node.key] > band[1]);
+    const v = params[node.key];
+    box.classList.toggle("warn", v < node.min || v > node.max);
   };
 
-  // live preview while typing (unclamped); clamp + reformat on commit
+  // live preview while typing; reformat (never clamp) on commit
   box.addEventListener("input", () => {
     const v = parseFloat(box.value);
     if (!Number.isFinite(v)) return;
     params[node.key] = v;
-    if (slider) slider.value = log ? toPosSafe(v) : v;
+    if (slider) slider.value = thumbFor(v);
     paintWarn();
     onChange?.();
   });
   box.addEventListener("change", () => {
-    const v = clampToRange(box.value, node.min, node.max);
-    if (v == null) { box.value = numStr(params[node.key]); return; } // revert invalid input
+    const v = parseFloat(box.value);
+    if (!Number.isFinite(v)) { box.value = numStr(params[node.key]); return; } // revert invalid input
     params[node.key] = v;
     box.value = numStr(v);
-    if (slider) slider.value = log ? toPosSafe(v) : v;
+    if (slider) slider.value = thumbFor(v);
     paintWarn();
     onChange?.();
     onCommit?.();
@@ -130,7 +146,7 @@ export function makeNumeric(node, params, { onChange, onCommit, info }) {
 
   const sync = () => {
     box.value = numStr(params[node.key]);
-    if (slider) slider.value = log ? toPosSafe(params[node.key]) : params[node.key];
+    if (slider) slider.value = thumbFor(params[node.key]);
     paintWarn();
   };
   paintWarn();

package/src/parts/demo.js

@@ -13,7 +13,7 @@ export default {
       presets: { M3: { od: 8, bore: 3.4, h: 10 }, M5: { od: 12, bore: 5.4, h: 16 } },
       advanced: [
         { key: "od", label: "Outer diameter", unit: "mm", min: 4, max: 40, step: 0.5,
-          description: "Barrel outer diameter. Keep it comfortably larger than the bore so a wall remains. See the [authoring guide](https://github.com/scottsykora/partforge/blob/main/docs/AUTHORING-PARTS.md)." },
+          description: "Barrel outer diameter. Keep it comfortably larger than the bore so a wall remains. See the [authoring guide](https://github.com/pixiteapps/partforge/blob/main/docs/AUTHORING-PARTS.md)." },
         { key: "bore", label: "Bore", unit: "mm", min: 1, max: 30, step: 0.1, control: "number",
           description: "Nominal screw clearance hole. A fixed print clearance is added automatically (see `derive`), so enter the *nominal* size." },
         { key: "h", label: "Height", unit: "mm", min: 2, max: 60, step: 1,