@reekon-tools/boldr-utils 1.9.0 → 1.9.1

package/dist/calculator/validate.js

@@ -321,6 +321,10 @@ export const validateCalculatorDefinition = (input) => {
                 push('variable-unit-dimension-mismatch', unitPath, `Unit "${unit}" is not a ${dim} unit (variable ${variable} maps to "${mapped.name}")`);
             }
         }
+        // The unit the EXPRESSION produces, which is what `resultUnit` claims to
+        // be. Hoisted out of the `target` branch because the number-target check
+        // further down needs it too.
+        const inferred = inferExpressionUnit(def.fields, eq);
         if (target) {
             const dim = fieldDimension(target);
             if (eq.resultUnit != null) {
@@ -331,11 +335,16 @@ export const validateCalculatorDefinition = (input) => {
                     push('result-unit-dimension-mismatch', `${path}.resultUnit`, `Result unit "${eq.resultUnit}" is not a ${dim} unit (target "${target.name}")`);
                 }
             }
-            // The unit the EXPRESSION produces, which is what `resultUnit` claims to
-            // be. Dimension checks against the target field can't see a same-
-            // dimension scale error: three inch variables multiplied are in³, so
-            // `cu_ft` passes every check above while reporting 1728× the truth.
-            const inferred = inferExpressionUnit(def.fields, eq);
+            // Dimension checks against the target field can't see a same-dimension
+            // scale error: three inch variables multiplied are in³, so `cu_ft`
+            // passes every check above while reporting 1728× the truth.
+            //
+            // Deliberately NOT applied to a dimensionless target. Literals carry no
+            // units here, so `area / 33` infers as an area whether the area arrives
+            // in µm² or ft² — the inference cannot tell a broken count from a
+            // correct one, and every legitimate count written as
+            // `area_in_ft² / 33_ft²` would be flagged. The canonical-leak check
+            // below is the one that separates them.
             if (inferred.ok && dim !== 'none') {
                 if (inferred.dimension !== dim) {
                     push('expression-dimension-mismatch', `${path}.expression`, `Expression produces ${describeDimension(inferred.dimension)} but "${target.name}" is ${describeDimension(dim)} — check the variable units and the expression`);
@@ -365,14 +374,30 @@ export const validateCalculatorDefinition = (input) => {
             }
         }
         // The canonical-leak trap: a number target consuming a unit-carrying
-        // field without a variable unit receives raw µm-scale values.
-        if (target?.kind === ColumnType.Number) {
+        // field without a variable unit receives raw µm-scale values. Reported
+        // per variable, because the fix is per variable ("pick a unit for A").
+        //
+        // Gated on the inference: unit-carrying variables are fine as long as
+        // their dimensions CANCEL, which is the common shape for a count —
+        // `ceil(area / area)` sheets, `(12 * rise) / run` pitch. Flagging those
+        // put a permanent warning on two correct calculators, and a check that
+        // cries wolf on correct authoring is one authors learn to scroll past.
+        //
+        // An ERROR, not a warning. It was a warning so that pre-annotation docs
+        // kept validating, but "keeps validating" is how the roofing estimator
+        // shipped `Bundles = A / 33` over a canonical µm² area and showed
+        // 184,990,000,000 — the right answer times µm²-per-ft². There is no
+        // authoring where a µm-scale value in a unitless field is intended, and
+        // nothing gates on `ok`: mobile only console.warns in __DEV__, and the
+        // web editor shows the banner without blocking save.
+        if (target?.kind === ColumnType.Number &&
+            (!inferred.ok || inferred.dimension !== 'none')) {
             for (const [variable, fieldId] of Object.entries(eq.variableToFieldId)) {
                 const mapped = fieldById.get(fieldId);
                 if (!mapped || fieldDimension(mapped) === 'none')
                     continue;
                 if (eq.variableUnits?.[variable] == null) {
-                    push('canonical-value-into-number-target', `${path}.variableToFieldId.${variable}`, `"${target.name}" is a number field but variable ${variable} ("${mapped.name}") has no display unit — its canonical (µm-scale) value will be used. Pick a unit for ${variable}.`, 'warning');
+                    push('canonical-value-into-number-target', `${path}.variableToFieldId.${variable}`, `"${target.name}" is a number field, so it shows the raw result — but variable ${variable} ("${mapped.name}") has no display unit, so it arrives as a canonical µm-scale value and the result will be off by a large factor. Pick a unit for ${variable}.`);
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reekon-tools/boldr-utils",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "Shared utilities for formulas and measurement conversion used in Reekon apps",
   "author": "REEKON Tools",
   "license": "MIT",