scanruler-mcp 0.4.0 → 0.4.5

package/src/commands.json

@@ -1,14 +1,22 @@
 {
-  "app": "0.6.3",
-  "saved": "2026-10-23T08:23:00.150Z",
+  "app": "0.8.0",
+  "saved": "2026-10-26T07:21:55.736Z",
   "commands": [
     {
       "name": "align.auto",
       "title": "Auto-align the part",
-      "description": "Read a coordinate system off the scan and apply it, as Auto-align then Confirm alignment do: the directions most faces are square to and the axis round walls run along, the part standing on its base, its long side along X. Returns what the pose was read from, the transform and how many elements moved with it. One undo step.",
+      "description": "Read a coordinate system off the scan and apply it, as Auto-align then Confirm alignment do: the directions most faces are square to and the axis round walls run along, the part standing on its base, its long side along X. level: settled (the default) lays all the faces on the axes at once, by area — a flange a degree off square shares its error with the base; largest squares the axis nearest the largest flat face exactly onto its normal and turns the other two about it onto the faces square to them. Returns what the pose was read from, the transform, how many elements moved with it, and square — how square it came out: largest (the largest flat face: the axis it is square to, its area in mm², tiltDeg — the angle between its fitted plane’s normal and that axis) and per axis the faces square to it (tiltDeg weighted by area, their area, the largest three each with area, tiltDeg and centre in the new frame). A drafted wall reads as its draft. One undo step.",
       "input": {
         "type": "object",
         "properties": {
+          "level": {
+            "type": "string",
+            "enum": [
+              "settled",
+              "largest"
+            ],
+            "description": "settled (the default): the best fit of all the faces square to the axes. largest: square to the largest flat face exactly, the others settled about its normal."
+          },
           "detail": {
             "type": "string",
             "enum": [
@@ -375,7 +383,7 @@
     {
       "name": "deviation.hotspots",
       "title": "Where the deviation lies over tolerance",
-      "description": "The deviation map read as patches: the scan vertices whose deviation lies past the tolerance (the map’s own, under deviation.settings, unless tolerance says otherwise) gathered into connected regions, the largest and farthest first — where the part is off, how large each place is and by how much, instead of one number over the whole part. Each patch: its centre and box in mm (in the frame the scan is measured in — what scan.query { box } and element.fit take), its area, how many vertices, the mean and the extreme deviation and which side (outside the reference or inside), the point of the extreme and the scan vertex there, and a few of its vertices (what element.fit_marked takes). With a map against the reference part the patch’s centre and extreme are given on the reference too (onReference — what the Deviation workspace shows and view.render { frame } takes there). grain is how close two vertices over tolerance have to be to be one patch, three point spacings by default. found and over say how many patches and vertices over tolerance there were in all — within the search distance, the vertices the map draws as a measurement. Then far, the vertices past the search distance, which the map draws bare: read it every time — far.inside is the scan deeper inside the reference than the search distance, where the reference has material the part has not (a hole, a pocket or a slot the model lacks), far.outside the scan further off it, where the part has what the model has not, or scan spray; each with its count and its patches, the largest first, and far.count both together; unmeasured says how many vertices the facing limit left without a reading. Needs a deviation map (deviation.align, or deviation.set_target). on: \"reference\" reads the map on the reference instead (deviation.settings { on }, measured if it is not yet): the patches are of the reference, in its frame, outside where the reference stands proud of the scan (material the part has not) and inside where it is short of it; far is the reference past the search distance from the scan, by side; and noScan, the reference with no scan behind it, in patches the largest first — surface the model has on no evidence: inferred, unscanned, or not on the part. Changes nothing.",
+      "description": "The deviation map read as patches: the scan vertices whose deviation lies past the tolerance (the map’s own, under deviation.settings, unless tolerance says otherwise) gathered into connected regions, the largest and farthest first — where the part is off, how large each place is and by how much, instead of one number over the whole part. Each patch: its centre and box in mm (in the frame the scan is measured in — what scan.query { box } and element.fit take), its area, how many vertices, the mean and the extreme deviation, depth, the median |deviation| over the patch; volume, mm³ past the tolerance (the ranking key); kind, \"feature\" when the patch is at least 4 mm² and 25 point spacings² across and its depth at least 2× the tolerance — material missing or misplaced, to model or to name — else \"texture\", the surface's own roughness poking past the tolerance, small or shallow, and which side (outside the reference or inside), the point of the extreme and the scan vertex there, and a few of its vertices (what element.fit_marked takes). With a map against the reference part the patch’s centre and extreme are given on the reference too (onReference — what the Deviation workspace shows and view.render { frame } takes there). grain is how close two vertices over tolerance have to be to be one patch, three point spacings by default. features says how many of all the patches found are features and their share of everything past the tolerance (shareOfExcess, 0–1), with what a feature patch asks: a patch over a tolerance well above the scan’s noise is never noise, so read each by its kind — a feature is modelled or named, never put down to scatter. found and over say how many patches and vertices over tolerance there were in all — within the search distance, the vertices the map draws as a measurement. Then far, the vertices past the search distance, which the map draws bare: read it every time — far.inside is the scan deeper inside the reference than the search distance, where the reference has material the part has not (a hole, a pocket or a slot the model lacks), far.outside the scan further off it, where the part has what the model has not, or scan spray; each with its count and its patches, the largest first, and far.count both together; unmeasured says how many vertices the facing limit left without a reading. Needs a deviation map (deviation.align, or deviation.set_target). on: \"reference\" reads the map on the reference instead (deviation.settings { on }, measured if it is not yet): the patches are of the reference, in its frame, outside where the reference stands proud of the scan (material the part has not) and inside where it is short of it; far is the reference past the search distance from the scan, by side; and noScan, the reference with no scan behind it, in patches the largest first — surface the model has on no evidence: inferred, unscanned, or not on the part. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -527,7 +535,7 @@
     {
       "name": "deviation.settings",
       "title": "Set how the deviation is read",
-      "description": "The deviation map’s reading: range, the colour scale ± mm; maxDistance, how far from the reference a point may be to count, mm; bands, a stepped scale of that many colours or null for smooth; tolerance, ± mm, the share within which the statistics give; facingDeg, how far the reference surface a point is measured against may turn from facing it, degrees, or null for the nearest surface whatever it faces — a change of it measures the map again; colormap, the colour map every deviation map and the live map of the bodies are drawn in — the person’s own choice, kept in the browser and outside the undo, so set it only to read a render by its colours and read settings.colormap for what the ramp shows at −range, 0 and +range and the caps past either end before judging a picture; on, which surface a map against the reference part is painted on — \"scan\" (the scan by its distance to the reference, the default) or \"reference\" (the reference by its distance to the scan, measured the first time it is asked for: positive where the reference stands outside the scan — material the part has not, a boss or a wall the model has and the scan does not — negative where it is short of it, grey where no scan stands behind it, a reading past the search distance in the cap of its end). Read both: the scan’s side finds what the model lacks, the reference’s what the model has that the part has not, and how much of the model no scan supports (onReference.noScanPct in the state). show, the map switch (the view bar’s Map key): false leaves the surface bare to look at its shape, the map still measured and read — the figures, hotspots and pins go on; true paints it again; a project keeps it, so read settings.show in the state when a render comes out uncoloured. view.render pictures the side on screen, and says which map it painted (map) or why none (mapWhy). Returns the deviation state. One undo step.",
+      "description": "The deviation map’s reading: range, the colour scale ± mm; maxDistance, how far from the reference a point may be to count, mm; bands, a stepped scale of that many colours or null for smooth; tolerance, ± mm, the share within which the statistics give; facingDeg, how far the reference surface a point is measured against may turn from facing it, degrees, or null for the nearest surface whatever it faces — a change of it measures the map again; colormap, the colour map every deviation map and the live map of the bodies are drawn in — the person’s own choice, kept in the browser and outside the undo, so set it only to read a render by its colours and read settings.colormap for what the ramp shows at −range, 0 and +range and the caps past either end before judging a picture; on, which surface a map against the reference part is painted on — \"scan\" (the scan by its distance to the reference, the default) or \"reference\" (the reference by its distance to the scan, measured the first time it is asked for: positive where the reference stands outside the scan — material the part has not, a boss or a wall the model has and the scan does not — negative where it is short of it, grey where no scan stands behind it, a reading past the search distance in the cap of its end). Read both: the scan’s side finds what the model lacks, the reference’s what the model has that the part has not, and how much of the model no scan supports (onReference.noScanPct in the state). show, the map switch (the view bar’s Map key): false leaves the surface bare to look at its shape, the map still measured and read — the figures, hotspots and pins go on; true paints it again; a project keeps it, so read settings.show in the state when a render comes out uncoloured. The map paints in the Deviation workspace only — a command of another workspace puts that one on screen, and workspace.set deviation brings the map back; view.render pictures the side on screen there and says which map it painted (map) or why none (mapWhy), elsewhere that the Deviation workspace is not on screen. Returns the deviation state. One undo step.",
       "input": {
         "type": "object",
         "properties": {
@@ -607,6 +615,79 @@
       "returnsFile": false,
       "returnsImage": false
     },
+    {
+      "name": "deviation.volume",
+      "title": "Volume error",
+      "description": "The scan and the reference part compared as solids, on a grid of small cells: each cell inside one and not the other is an error, touching cells a region. Read it before the surface patches — it tells how much material is wrong and where, which the nearest-point map cannot. excess is material the reference has and the part has not (a boss modelled where there is air, a hole not cut), missing material the part has and the reference has not (a boss not modelled, a pocket cut where the part is solid), wherever it is: behind a wall, inside a cavity, past the search distance. Where the scan has a hole the reference stands in for it; what the scan still does not say is unsure, never an error. Within the tolerance of the scan’s surface a difference is noise; nothing thinner than smallestSeen (two cells) is seen — the surface map stays the tool for fine offsets. Answers totals (mm³ and share of the reference’s volume, %) and the regions largest first, each with its kind, volume (mm³), maxDepth (mm from the scan’s surface), thickness (volume over the area it shares with a surface), shape — layer (a face standing off, about thickness thick) or lump (material there or not) —, centroid, deepest point and box in the reference’s frame (what view.render { frame } takes in the Deviation workspace), evidence (the share of its scan side that is real scan rather than reference standing in) and confidence. Needs the scan aligned to the reference (deviation.align). Shows the regions in the Deviation workspace, the colour plot put away. About 15 s on a 1.5M-triangle scan; within a box, less. Changes nothing kept.",
+      "input": {
+        "type": "object",
+        "properties": {
+          "tolerance": {
+            "type": "number",
+            "description": "± mm; the map’s tolerance (deviation.settings) by default.",
+            "exclusiveMinimum": 0
+          },
+          "cell": {
+            "type": "number",
+            "description": "The cell, mm; by default half the tolerance or a 250th of the reference’s longest side, the larger — and coarser if the grid would pass 16M cells.",
+            "exclusiveMinimum": 0
+          },
+          "regions": {
+            "type": "integer",
+            "description": "How many regions to name; 8 by default, 50 at most.",
+            "minimum": 1,
+            "maximum": 50
+          },
+          "within": {
+            "type": "object",
+            "properties": {
+              "min": {
+                "type": "array",
+                "items": {
+                  "type": "number"
+                },
+                "description": "The lowest corner, mm.",
+                "minItems": 3,
+                "maxItems": 3
+              },
+              "max": {
+                "type": "array",
+                "items": {
+                  "type": "number"
+                },
+                "description": "The highest corner, mm.",
+                "minItems": 3,
+                "maxItems": 3
+              }
+            },
+            "required": [
+              "min",
+              "max"
+            ],
+            "additionalProperties": false,
+            "description": "Only this box is looked at, in the frame the reference is measured in."
+          },
+          "kinds": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": [
+                "excess",
+                "missing",
+                "unsure"
+              ],
+              "description": "A kind of region."
+            },
+            "description": "Only regions of these kinds named; all by default. The totals are of all."
+          }
+        },
+        "additionalProperties": false
+      },
+      "readOnly": true,
+      "returnsFile": false,
+      "returnsImage": false,
+      "long": true
+    },
     {
       "name": "dimension.add",
       "title": "Add a dimension",
@@ -909,7 +990,7 @@
     {
       "name": "element.construct",
       "title": "Construct an element",
-      "description": "Construct an element from others and typed-in numbers, as the panel’s creation methods do — by kind: point (point-coords, point-centroid, point-midpoint, point-line-plane), line (line-two-points, line-axis, line-plane-plane), plane (plane-three-points, plane-offset, plane-midplane, plane-coords, plane-symmetry), circle (circle-plane-cylinder, circle-plane-sphere, circle-coords). refs fill the method’s slots in order, by element id or name; params are its numbers in order (or by key: x, y, z; offset; nx, ny, nz, px, py, pz; d, cx, cy, cz). point-centroid and plane-symmetry measure the scan themselves: vertices confines them to a marked surface, seed starts the symmetry search from a plane. plane-symmetry finds the scan’s own mirror plane as an element, the alignment left as it is (align.symmetry re-poses the part on it instead), and answers with the search’s residual: symmetry { rms, matched, sampled } and a note. Returns the element. One undo step.",
+      "description": "Construct an element from others and typed-in numbers, as the panel’s creation methods do — by kind: point (point-coords, point-centroid, point-midpoint, point-line-plane), line (line-two-points, line-axis, line-plane-plane), plane (plane-three-points, plane-offset, plane-midplane, plane-coords, plane-symmetry), circle (circle-plane-cylinder, circle-plane-sphere, circle-coords). refs fill the method’s slots in order, by element id or name — a coordinate plane \"XY\", \"YZ\" or \"XZ\" in a plane’s slot is made a plane element through the origin first (one made so before is taken again) and listed under made; params are its numbers in order (or by key: x, y, z; offset; nx, ny, nz, px, py, pz; d, cx, cy, cz). point-centroid and plane-symmetry measure the scan themselves: vertices confines them to a marked surface, seed starts the symmetry search from a plane. plane-symmetry finds the scan’s own mirror plane as an element, the alignment left as it is (align.symmetry re-poses the part on it instead), and answers with the search’s residual: symmetry { rms, matched, sampled } and a note. Returns the element. One undo step.",
       "input": {
         "type": "object",
         "properties": {
@@ -947,7 +1028,7 @@
                   "minLength": 1
                 }
               ],
-              "description": "A source element."
+              "description": "A source element — or, in a plane’s slot, a coordinate plane \"XY\", \"YZ\", \"XZ\"."
             },
             "description": "The method’s source elements, slot by slot."
           },
@@ -981,7 +1062,7 @@
                 "minLength": 1
               }
             ],
-            "description": "plane-symmetry: the plane the search starts from — a plane element or \"XY\", \"YZ\", \"ZX\"."
+            "description": "plane-symmetry: the plane the search starts from — a plane element or \"XY\", \"YZ\", \"XZ\"."
           },
           "vertices": {
             "type": "array",
@@ -1013,7 +1094,7 @@
                     "minLength": 1
                   }
                 ],
-                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"ZX\"."
+                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"XZ\"."
               },
               "relation": {
                 "type": "string",
@@ -1049,7 +1130,7 @@
     {
       "name": "element.fit",
       "title": "Fit an element",
-      "description": "Fit an element on the scan where the panel would take a click: a plane, sphere, cylinder, cone or torus grows its surface from the place given and is best-fitted to it; a point is the place itself; a circle goes through three or more places. `at` is one place, or a list — a feature seen in patches can be seeded on each. A place is { vertex } (a scan vertex), { point: [x, y, z] } (the nearest scan vertex to a point, mm, in the current frame), or { screen } / { candidate } (not available yet). A seed near an edge can land on the wrong surface (a cup’s underside for its inside): say what is sought — side, radius, axis, within — and surfaces that do not match are passed over; a fit that finds none is refused with the radii it saw — a round turned down for its axis with that axis, a point on it, how far off it lay and its points, to give as axis or to drop axis for. Returns the element with its fit and the seed actually used (vertex and point), so a recipe can be replayed on another scan; a surface also the region it grew to — region { area (mm²), box } and, a plane’s, normalSpreadDeg (95 % of its normals lie within it) — and a plane or a cylinder a warning when its points look like two surfaces, with region.second naming where the other lies (a cylinder’s: its share, band along the axis from the centre, axis angle, radius and how far each part’s normals lean off square to the axis). mark: true leaves the region’s points marked for element.fit_marked { marked: true }. A circle may come off an open rim of the scan instead — rim: its number from scan.qa, in place of at: fitted through the rim’s whole loop, the answer giving rim { index, points, rms }. One undo step.",
+      "description": "Fit an element on the scan where the panel would take a click: a plane, sphere, cylinder, cone or torus grows its surface from the place given and is best-fitted to it; a point is the place itself; a circle goes through three or more places. `at` is one place, or a list — a feature seen in patches can be seeded on each. A place is { vertex } (a scan vertex), { point: [x, y, z] } (the nearest scan vertex to a point, mm, in the current frame), or { screen } / { candidate } (not available yet). A seed near an edge can land on the wrong surface (a cup’s underside for its inside): say what is sought — side, radius, axis, within — and surfaces that do not match are passed over; a fit that finds none is refused with the radii it saw — a round turned down for its axis with that axis, a point on it, how far off it lay and its points, to give as axis or to drop axis for. Returns the element with its fit and the seed actually used (vertex and point), so a recipe can be replayed on another scan — several seeds each with inRegion (whether the surface grew from it: one surface grows, from the seeds on it), offMm (how far it lies off the fitted surface along its normal, a round one’s outward) and deg (how far its normal turns from the surface’s there), and a seed left out warns where it lies: on another surface (fit each, or mark both and fit the marked), or on this one outside the region; a surface also the region it grew to — region { area (mm²), box } and, a plane’s, normalSpreadDeg (95 % of its normals lie within it) — and a plane or a cylinder a warning when its points look like two surfaces, with region.second naming where the other lies (a cylinder’s: its share, band along the axis from the centre, axis angle, radius and how far each part’s normals lean off square to the axis). A cylinder whose region grew over two surfaces one after the other along the axis — a bore stepping wider below a flange — is parted where two cylinders fit it best and the part the seed is on answered, with note and second { radius, band (mm along the axis from the centre), share }; a refusal lists the radii it turned down and why (σ over its length, arc). A bore whose axis meets the scan at an end answers closed { from, to (mm along the axis from the centre, where the axis meets the scan and leaves it), at } with a warning — a floor, or a wrap bridging a hole. A plane warns, with region.fill (the share of the rectangle it spans that it fills) and region.sagitta (how far a quadric over the region curves across it, mm), when it fills under 15 %, or its normals spread past 10° and the region is curved — the sagitta over three times what the quadric leaves: the crown of a bead or round, not a face. Relief on a flat face (lettering) spreads the normals as wide and does not warn. mark: true leaves the region’s points marked for element.fit_marked { marked: true }. A circle may come off an open rim of the scan instead — rim: its number from scan.qa, in place of at: fitted through the rim’s whole loop, the answer giving rim { index, points, rms }. One undo step.",
       "input": {
         "type": "object",
         "properties": {
@@ -1296,6 +1377,11 @@
             ],
             "description": "The outlier cut-off: residuals beyond this many sigma are left out of the fit — 3 (the default the panel starts on), 2, 1, or 0 for all points."
           },
+          "knownDiameter": {
+            "type": "number",
+            "description": "Sphere: the ball’s known diameter, mm — a gauge ball, a ballbar’s balls. The fit holds it and places the centre alone, which keeps the centre right on a ball scanned only partly; fit.held then gives the diameter the same points fit freely (freeDiameter — it should be close: a scan reading off moves a held centre by about as much) and how far holding it moved the centre (shift). Refused when the surface fits a sphere more than 1 mm or 10 % off it.",
+            "exclusiveMinimum": 0
+          },
           "assumed": {
             "type": "number",
             "description": "The diameter the feature was designed at, mm — a sphere, cylinder or circle is then drawn and exported at it, and still reported as measured.",
@@ -1317,7 +1403,7 @@
                     "minLength": 1
                   }
                 ],
-                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"ZX\"."
+                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"XZ\"."
               },
               "relation": {
                 "type": "string",
@@ -1475,6 +1561,11 @@
             ],
             "description": "The outlier cut-off: residuals beyond this many sigma are left out of the fit — 3 (the default the panel starts on), 2, 1, or 0 for all points."
           },
+          "knownDiameter": {
+            "type": "number",
+            "description": "Sphere: the ball’s known diameter, mm — a gauge ball, a ballbar’s balls. The fit holds it and places the centre alone, which keeps the centre right on a ball scanned only partly; fit.held then gives the diameter the same points fit freely (freeDiameter — it should be close: a scan reading off moves a held centre by about as much) and how far holding it moved the centre (shift). Refused when the surface fits a sphere more than 1 mm or 10 % off it.",
+            "exclusiveMinimum": 0
+          },
           "assumed": {
             "type": "number",
             "description": "The diameter the feature was designed at, mm — a sphere, cylinder or circle is then drawn and exported at it, and still reported as measured.",
@@ -1496,7 +1587,7 @@
                     "minLength": 1
                   }
                 ],
-                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"ZX\"."
+                "description": "The reference plane: a plane element, or a coordinate plane \"XY\", \"YZ\" or \"XZ\"."
               },
               "relation": {
                 "type": "string",
@@ -2585,7 +2676,7 @@
     {
       "name": "guide.read",
       "title": "Read a guide",
-      "description": "How to do a task with ScanRuler: the workflow, the judgement and the traps the tools’ own descriptions do not carry, written for this build — read the guide for your task, whole, before its first step, and a section again when you need it. The guides: measure — measuring a 3D scan: fitting elements, dimensions and GD&T-like checks, sections and the 2D sheet, deviation against a reference part, wall thickness, the report — by hand or as an automatic run over many scans; measure-reference — the measuring tools’ shapes with examples, what each answer costs, what each refusal means — a section at a time, as the measure guide sends you. topic: a guide, or several read in order (a guide and the ones it is read with, in one call). section: one section of one guide, by its heading — the index lists them. With no topic, the index: each guide with its sections and what each costs in tokens. Changes nothing.",
+      "description": "How to do a task with ScanRuler: the workflow, the judgement and the traps the tools’ own descriptions do not carry, written for this build — read the guide for your task, whole, before its first step, and a section again when you need it. The guides: measure — measuring a 3D scan: fitting elements, dimensions and GD&T-like checks, sections and the 2D sheet, deviation against a reference part, wall thickness, the report — by hand or as an automatic run over many scans; measure-reference — the measuring tools’ shapes with examples, what each answer costs, what each refusal means — a section at a time, as the measure guide sends you. topic: a guide, or several read in order (a guide and the ones it is read with, in one call) — as many as fit in about 80 k characters, the rest named in next, to read in the next call. section: one section of one guide, by its heading — the index lists them. A long section with ### parts under it — a reference’s list of command shapes — is best read by those parts: section takes a ### heading too, the one part you need. With no topic, the index: each guide with its sections and what each costs in tokens. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -2603,11 +2694,11 @@
                 "maxItems": 8
               }
             ],
-            "description": "A guide by its id, or several to read in order. Leave it out for the index."
+            "description": "A guide by its id, or several to read in order — as many as fit in one answer, the rest named in next. Leave it out for the index."
           },
           "section": {
             "type": "string",
-            "description": "One section of the guide, by its heading (without its number, or a part of it that names one section). Only with one topic.",
+            "description": "One section of the guide, by its heading — a ## section or a ### part of one (without its number, or a part of it that names one section). Only with one topic.",
             "minLength": 1
           }
         },
@@ -2778,7 +2869,7 @@
     {
       "name": "scan.draft",
       "title": "Read the draft against a pull",
-      "description": "The scan’s walls that run near a pull direction — the sides a mould opens along, a side core slides along — gathered into patches, each with the angle it leans off the pull: draftDeg, positive where the wall faces partly along the pull (it lets go as the tool moves that way), negative where it faces back (a back draft, an undercut to that pull); sigmaDeg its standard error, spreadDeg the points’ own spread (mostly the scan’s normal noise); with centroid, box, area (mm²), count, facing (which way the wall faces across the pull) and turnDeg (how far that turns across the patch). Neighbouring walls are parted where the way they face jumps, so a box’s four sides are four patches, and a thin wall’s two sides (a blade, a rib) two patches facing opposite ways; a point joins a patch only while it faces within 20° of the patch’s mean, so a smooth freeform wall comes in patches that turn 40° at most. A boss’s or a hole’s round side is one patch with round: true, its facing no one way. Read it early on a moulded or cast part, along each direction the tools open: walls that lean half a degree to a few explain fits that miss by the lean. pull: the direction, any length; box: only the scan inside it; nearDeg: how far off square to the pull a wall may lean and still count (10 by default); patches: how many, the largest first (12); minArea: smaller ones left out, mm² (1); split: no patch reaches across this plane — \"symmetry\" (the scan’s mirror plane: the last measured symmetry plane, else searched for), a plane element, \"XY\", \"YZ\", \"ZX\", or { point, normal } — each patch then says its side (1 along the plane’s normal, −1 against), and the answer the plane. Changes nothing.",
+      "description": "The scan’s walls that run near a pull direction — the sides a mould opens along, a side core slides along — gathered into patches, each with the angle it leans off the pull: draftDeg, positive where the wall faces partly along the pull (it lets go as the tool moves that way), negative where it faces back (a back draft, an undercut to that pull); sigmaDeg its standard error, spreadDeg the points’ own spread (mostly the scan’s normal noise); with centroid, box, area (mm²), count, facing (which way the wall faces across the pull) and turnDeg (how far that turns across the patch). Neighbouring walls are parted where the way they face jumps, so a box’s four sides are four patches, and a thin wall’s two sides (a blade, a rib) two patches facing opposite ways; a point joins a patch only while it faces within 20° of the patch’s mean, so a smooth freeform wall comes in patches that turn 40° at most. A boss’s or a hole’s round side is one patch with round: true, its facing no one way. Read it early on a moulded or cast part, along each direction the tools open: walls that lean half a degree to a few explain fits that miss by the lean. pull: the direction, any length; box: only the scan inside it; nearDeg: how far off square to the pull a wall may lean and still count (10 by default); patches: how many, the largest first (12); minArea: smaller ones left out, mm² (1); split: no patch reaches across this plane — \"symmetry\" (the scan’s mirror plane: the last measured symmetry plane, else searched for), a plane element, \"XY\", \"YZ\", \"XZ\", or { point, normal } — each patch then says its side (1 along the plane’s normal, −1 against), and the answer the plane. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -2841,7 +2932,7 @@
             "oneOf": [
               {
                 "type": "string",
-                "description": "\"symmetry\", a plane element’s name, or \"XY\", \"YZ\", \"ZX\".",
+                "description": "\"symmetry\", a plane element’s name, or \"XY\", \"YZ\", \"XZ\".",
                 "minLength": 1
               },
               {
@@ -2986,7 +3077,7 @@
     {
       "name": "scan.heightmap",
       "title": "Map the scan’s heights",
-      "description": "Where the scan is first met looking along an axis, or square onto a plane, over a grid of cells: pocket floors, ledges, a step's height, a face's tilt, a pad's tiers, an icon on a key in one call. axis is the way looked: -z (the default) looks down from above and gives the top surface's z; +z looks up from below and gives the underside's; ±x, ±y likewise. Cells lie on the two other axes in order — x, y for z; y, z for x; x, z for y — as u and v. plane, in place of axis: a plane element (id or name; its normal turned to the side the scan is not, so it looks at the face it was fitted on), a coordinate plane \"XY\", \"YZ\", \"ZX\", or any other — a face of a model, say — as { origin, normal, u? }; the map then looks down the normal onto it, height is the distance from the plane along the normal, and u, v are the plane's own, laid as a sketch on that plane has them (section.render { plane } draws the same sheet) — u seeds its direction; flip turns the plane over. The answer's plane gives its frame in world: a cell's point is origin + u·U + v·V + height·normal. box: the part looked at, the scan's box by default; rays start at its face and stop at the far one. With plane, box is in the plane's frame: min and max are [u, v, height], and by default it takes in the whole scan. of: height (the default); deviation — the scan's signed deviation where each ray lands (the map deviation.align or deviation.set_target measured, read off the triangle met), null where the map has no reading within its search distance; relief — the height less the surface round it (at each cell a plane fitted to its neighbours, weighed by a Gaussian smooth mm wide, three cells by default; make it about the width of what is looked for): icons, grooves, lettering and parting lines stand out of a face that curves or leans, positive proud and negative sunk. cell: mm (by default a round size that makes 40 cells on the longer side; widened to keep 1600 cells at most — and 160 and 25600 when the numbers are not returned). Returns along, across, cell, origin [u0, v0] (the grid's low corner), cols, rows and grid: rows of values (mm; heights to 0.01, deviation and relief to 0.001) from the low v up, null where there is none — grid[r][c] stands at u0 + (c + ½)·cell, v0 + (r + ½)·cell — with min, max, hit (cells met) and valued (cells with a value). levels: true returns, in place of the grid, the values gathered into levels — a pad's tiers, a pocket's floor, the face round them — the largest first (12 at most): each its height (the median), sigma, range, cells, area (mm²), sharePct of the cells counted, and box ([u, v] min and max). Of a height, the cells sloped more than slopeDeg (10° by default; 90 keeps every one) are left out first and counted as sloped — a fillet's ramp, a cone, a wall met at a glance — so two tiers a ramp joins stay two levels; a face that leans more is read by looking square onto it (plane). Two levels lie at least gap apart (mm; three times the cell-to-cell noise on the cells counted by default, 0.02 at least), and unassigned counts the cells counted that fall in none (walls, edges). grid: true keeps the grid as well, false leaves it out and returns the picture. picture: true adds the map coloured by its values with coordinates in the margins and a scale (a deviation in the workspace's colour map over its range); needs the browser. Changes nothing.",
+      "description": "Where the scan is first met looking along an axis, or square onto a plane, over a grid of cells: pocket floors, ledges, a step's height, a face's tilt, a pad's tiers, an icon on a key in one call. axis is the way looked: -z (the default) looks down from above and gives the top surface's z; +z looks up from below and gives the underside's; ±x, ±y likewise. Cells lie on the two other axes in order — x, y for z; y, z for x; x, z for y — as u and v. plane, in place of axis: a plane element (id or name; its normal turned to the side the scan is not, so it looks at the face it was fitted on), a coordinate plane \"XY\", \"YZ\", \"XZ\", or any other — a face of a model, say — as { origin, normal, u? }; the map then looks down the normal onto it, height is the distance from the plane along the normal, and u, v are the plane's own, laid as a sketch on that plane has them (section.render { plane } draws the same sheet) — u seeds its direction; flip turns the plane over. The answer's plane gives its frame in world: a cell's point is origin + u·U + v·V + height·normal — and, for an element or a plane given by its origin, center: where the element's centre (or that origin) lies in [u, v], for the frame's zero is the world origin's foot on the plane, not the element's centre. box: the part looked at, the scan's box by default; rays start at its face and stop at the far one. With plane, box is in the plane's frame: min and max are [u, v, height], and by default it takes in the whole scan; or box: { world: { min, max } } gives it in the world, [x, y, z] — the map takes the box round its corners in the plane's frame, so a box round a place on the part needs no working out. Where under a fifth of the cells meet the scan, scanLies says where the scan lies in the map's frame (min and max, [u, v, height] — or along the axis looked) beside the grid's span. of: height (the default); deviation — the scan's signed deviation where each ray lands (the map deviation.align or deviation.set_target measured, read off the triangle met), null where the map has no reading within its search distance; relief — the height less the surface round it (at each cell a plane fitted to its neighbours, weighed by a Gaussian smooth mm wide, three cells by default; make it about the width of what is looked for): icons, grooves, lettering and parting lines stand out of a face that curves or leans, positive proud and negative sunk. cell: mm (by default a round size that makes 40 cells on the longer side; widened to keep 1600 cells at most — and 160 and 25600 when the numbers are not returned). Returns along, across, cell, origin [u0, v0] (the grid's low corner), cols, rows and grid: rows of values (mm; heights to 0.01, deviation and relief to 0.001) from the low v up, null where there is none — grid[r][c] stands at u0 + (c + ½)·cell, v0 + (r + ½)·cell — with min, max, hit (cells met) and valued (cells with a value). levels: true returns, in place of the grid, the values gathered into levels — a pad's tiers, a pocket's floor, the face round them — the largest first (12 at most): each its height (the median), sigma, range, cells, area (mm²), sharePct of the cells counted, and box ([u, v] min and max). Of a height, the cells sloped more than slopeDeg (10° by default; 90 keeps every one) are left out first and counted as sloped — a fillet's ramp, a cone, a wall met at a glance — so two tiers a ramp joins stay two levels; a face that leans more is read by looking square onto it (plane). Two levels lie at least gap apart (mm; three times the cell-to-cell noise on the cells counted by default, 0.02 at least), and unassigned counts the cells counted that fall in none (walls, edges). Where the sloped cells are more than a fifth of those with a value, or one run of them borders a single level (a ramp off a tier that meets no other), ramps says so — \"ramps between tiers (sloped 34 %) — a section along them gives their profile\" — with the largest runs: cells, area, box and joins (the heights of the levels each borders). grid: true keeps the grid as well, false leaves it out and returns the picture. picture: true adds the map coloured by its values with coordinates in the margins and a scale (a deviation in the workspace's colour map over its range); needs the browser. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3010,14 +3101,39 @@
                 "description": "The highest corner, mm — [u, v, height] with plane.",
                 "minItems": 3,
                 "maxItems": 3
+              },
+              "world": {
+                "type": "object",
+                "properties": {
+                  "min": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The lowest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  },
+                  "max": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The highest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  }
+                },
+                "required": [
+                  "min",
+                  "max"
+                ],
+                "additionalProperties": false,
+                "description": "The box in the world, in place of min and max: with plane, the box round its corners in the plane’s frame."
               }
             },
-            "required": [
-              "min",
-              "max"
-            ],
             "additionalProperties": false,
-            "description": "The part looked at; the scan’s box by default. In the plane’s frame with plane."
+            "description": "The part looked at; the scan’s box by default. In the plane’s frame with plane — or world: { min, max } in the world."
           },
           "axis": {
             "type": "string",
@@ -3046,7 +3162,7 @@
                     "minLength": 1
                   }
                 ],
-                "description": "A plane element, or a coordinate plane \"XY\", \"YZ\", \"ZX\"."
+                "description": "A plane element, or a coordinate plane \"XY\", \"YZ\", \"XZ\"."
               },
               {
                 "type": "object",
@@ -3272,7 +3388,7 @@
     {
       "name": "scan.outline",
       "title": "Read the scan’s outline",
-      "description": "The scan’s outline seen along an axis, or square onto a plane, read as a sketch would draw it: a flange’s plan, a bezel’s opening, a gasket’s shape. Rays over a grid of cells (half the tolerance, widened to keep 250000 at most) find where the scan is and where it is not; the line between is traced round and each loop read as the fewest lines and arcs that follow it within tolerance (mm, 0.2 by default): straight sides are fitted as lines and met at sharp corners; an arc between two sides is that corner’s round (rounds: at, the corner’s index in points, radius and center); any other arc is a side of its own (arcs: from, the index of the point it starts at, running to the next, radius and center) — a slot’s ends; and a loop that is round all the way is one circle. axis, plane, flip and box as scan.heightmap takes them — the coordinates are u, v as it lays them (the two other axes in order, or the plane’s own). Returns loops, the largest first (loops: how many, 4 by default): each with hole (true for one inside another), area (mm²), box, points ([u, v] corners in order), rounds and arcs, or circle { center, radius, rms }, and worst — how far the traced outline strays from what is drawn, mm, with worstAt where, when it is past the tolerance. Changes nothing.",
+      "description": "The scan’s outline seen along an axis, or square onto a plane, read as a sketch would draw it: a flange’s plan, a bezel’s opening, a gasket’s shape. Rays over a grid of cells (half the tolerance, widened to keep 250000 at most) find where the scan is and where it is not; the line between is traced round and each loop read as the fewest lines and arcs that follow it within tolerance (mm, 0.2 by default): straight sides are fitted as lines and met at sharp corners; an arc between two sides is that corner’s round (rounds: at, the corner’s index in points, radius and center); any other arc is a side of its own (arcs: from, the index of the point it starts at, running to the next, radius and center) — a slot’s ends; and a loop that is round all the way is one circle. axis, plane, flip and box as scan.heightmap takes them, box: { world: { min, max } } too — the coordinates are u, v as it lays them (the two other axes in order, or the plane’s own; plane.center is the element’s centre in them). Returns loops, the largest first (loops: how many, 4 by default): each with hole (true for one inside another), area (mm²), box, points ([u, v] corners in order), rounds and arcs, or circle { center, radius, rms }, and worst — how far the traced outline strays from what is drawn, mm, with worstAt where, when it is past the tolerance. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3303,7 +3419,7 @@
                     "minLength": 1
                   }
                 ],
-                "description": "A plane element, or a coordinate plane \"XY\", \"YZ\", \"ZX\"."
+                "description": "A plane element, or a coordinate plane \"XY\", \"YZ\", \"XZ\"."
               },
               {
                 "type": "object",
@@ -3369,14 +3485,39 @@
                 "description": "The highest corner, mm — [u, v, height] with plane.",
                 "minItems": 3,
                 "maxItems": 3
+              },
+              "world": {
+                "type": "object",
+                "properties": {
+                  "min": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The lowest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  },
+                  "max": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The highest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  }
+                },
+                "required": [
+                  "min",
+                  "max"
+                ],
+                "additionalProperties": false,
+                "description": "The box in the world, in place of min and max: with plane, the box round its corners in the plane’s frame."
               }
             },
-            "required": [
-              "min",
-              "max"
-            ],
             "additionalProperties": false,
-            "description": "Only the scan inside it; the whole scan by default."
+            "description": "Only the scan inside it; the whole scan by default. In the plane’s frame with plane — or world: { min, max } in the world."
           },
           "tolerance": {
             "type": "number",
@@ -3399,7 +3540,7 @@
     {
       "name": "scan.pattern",
       "title": "Count the repeats round an axis",
-      "description": "Rotational repeats about an axis — a fan's blades, a flange's holes and pads, a wheel's spokes, a gear's teeth — counted from the scan. The scan is cut square to the axis at each height in at, and each cut (only what lies between radius.min and radius.max) is turned against itself: count, the number of copies whose outlines land on each other going round (up to maxCount, 60 by default); pitchDeg, 360/count; phaseDeg, where the first copy's middle lies (under one pitch), and betweenDeg midway to the next — angles about the axis as section.cut { across: { axis, angleDeg } } takes them: 0° the coordinate axis next round (X about Z), turning by the right hand. score, 0 to 1, is how well the copies' outlines land on each other; under 0.5 nothing is taken to repeat and count is 1 (tried gives the best count and its score). Each copy in instances: angleDeg and radius of its outline's middle, offDeg from where an even spacing puts it, rms and worst — how far its outline lies from the other copies' turned onto it (the median over them), mm — and share, its outline's length against the median copy's (well under 1: the scan misses part of it, or the copy is not there). rms, worst and worstInstance over all the copies. Round outlines about the axis — a bore, a hub, a rim — are not copies: they come back as rings, each its radius, off (how far its centre lies off the axis, mm), towardDeg (which way) and rms. axis: a cylinder, cone, line or circle element, by id or name, a coordinate axis \"X\", \"Y\" or \"Z\" through the origin, or { origin, dir }. at: heights along the axis, mm, counted from the world origin's foot on it (the coordinate itself on a coordinate axis); by default 6 spread over the scan, 12 at most. Features lie at different heights and radii: cut through each, and keep radius to the ring one lies in where two share a height — in one cut the feature with the most outline sets the count, and the other reads as what its copies miss (worst). instances: false leaves the copies out. Changes nothing.",
+      "description": "Rotational repeats about an axis — a fan's blades, a flange's holes and pads, a wheel's spokes, a gear's teeth — counted from the scan. The scan is cut square to the axis at each height in at, and each cut (only what lies between radius.min and radius.max) is turned against itself: count, the number of copies whose outlines land on each other going round (up to maxCount, 60 by default); pitchDeg, 360/count; phaseDeg, where the first copy's middle lies (under one pitch), and betweenDeg midway to the next — angles about the axis as section.cut { across: { axis, angleDeg } } takes them: 0° the coordinate axis next round (X about Z), turning by the right hand. score, 0 to 1, is how well the copies' outlines land on each other; under 0.5 nothing is taken to repeat and count is 1 (tried gives the best count and its score). Each copy in instances: angleDeg and radius of its outline's middle, offDeg from where an even spacing puts it, rms and worst — how far its outline lies from the other copies' turned onto it (the median over them), mm — and share, its outline's length against the median copy's (well under 1: the scan misses part of it, or the copy is not there). rms, worst and worstInstance over all the copies. Round outlines about the axis — a bore, a hub, a rim — are not copies: they come back as rings, each its radius, off (how far its centre lies off the axis, mm), towardDeg (which way) and rms. axis: a cylinder, cone, line or circle element, by id or name, a coordinate axis \"X\", \"Y\" or \"Z\" through the origin, or { origin, dir }. at: heights along the axis, mm, counted from the world origin's foot on it (the coordinate itself on a coordinate axis) — or points [x, y, z] in the world, each the height of its foot on the axis; by default 6 spread over the scan, 12 at most. Features lie at different heights and radii: cut through each, and keep radius to the ring one lies in where two share a height — in one cut the feature with the most outline sets the count, and the other reads as what its copies miss (worst). instances: false leaves the copies out. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3454,8 +3595,21 @@
           "at": {
             "type": "array",
             "items": {
-              "type": "number",
-              "description": "mm along the axis."
+              "oneOf": [
+                {
+                  "type": "number",
+                  "description": "mm along the axis."
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "number"
+                  },
+                  "description": "A point in the world, mm: the height of its foot on the axis.",
+                  "minItems": 3,
+                  "maxItems": 3
+                }
+              ]
             },
             "description": "Heights to cut at; 6 spread over the scan by default.",
             "minItems": 1,
@@ -3501,7 +3655,7 @@
     {
       "name": "scan.qa",
       "title": "Check the scan before modelling",
-      "description": "One call before modelling, to know what the scan will and will not give: rims — the open edges of its holes (count, total length, the longest few with their number rim, length, centre and size, mm; circles: other rims a circle fits — a hole the scan did not see into); a rim that lies on a circle has circle { center, axis, radius, rms } (rms its scatter off the circle, mm), and element.fit { kind: \"circle\", rim } makes it an element; noise — the median scatter of small plane fits round a sample of vertices (mm; near 0 is a CAD tessellation) and its 90th percentile; thickness through the part along axis (x, y, z or a direction; by default the alignment’s z when the part is aligned, else the way most of the surface faces — a plate’s faces) over a grid — p5, p50, p95 (mm), and on the cells near the median (the main faces) the thickness’s linear trend as tiltDeg, how far apart faces that should be parallel are, with the way it thickens and its run from end to end; faces gives each face’s own tilt off square to the axis (topDeg, bottomDeg), so a lean of the whole part shows apart from faces out of parallel. notes: what looks wrong, plainly. Changes nothing.",
+      "description": "One call before modelling, to know what the scan will and will not give: rims — the open edges of its holes (count, total length, the longest few with their number rim, length, centre and size, mm; circles: other rims a circle fits — a hole the scan did not see into); a rim that lies on a circle has circle { center, axis, radius, rms } (rms its scatter off the circle, mm), and element.fit { kind: \"circle\", rim } makes it an element; noise — the median scatter of small plane fits round a sample of vertices (mm; near 0 is a CAD tessellation) and its 90th percentile; thickness through the part along axis (x, y, z or a direction; by default the alignment’s z when the part is aligned, else the way most of the surface faces — a plate’s faces) over a grid — p5, p50, p95 (mm), and on the cells near the median (the main faces) the thickness’s linear trend as tiltDeg, how far apart faces that should be parallel are, with the way it thickens and its run from end to end; faces gives each face’s own tilt off square to the axis (topDeg, bottomDeg), so a lean of the whole part shows apart from faces out of parallel. notes: what looks wrong, plainly — a scanned skin with no rims at all among it, since a wrap bridges the holes it did not see through. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3650,7 +3804,7 @@
     {
       "name": "scan.segment",
       "title": "Find the scan’s flat regions",
-      "description": "The scan’s planar regions, found all at once: grown from the flattest places outward, a vertex joining while its normal lies within maxDeg of the region’s plane (15° by default) and it lies inside the region’s noise band; each vertex goes to one region; a region rougher than maxRms off its plane (mm, 0.05 by default) or smaller than minArea (mm², by default a square 2 % of the scan’s diagonal on a side) is given back. box: only the scan inside it. The largest first, at most limit (20); each with id (1 is the largest), normal (out of the part), point (its centroid, on the plane), sigma (RMS off the plane, mm), area (mm²), box, vertices (a count) and neighbours: the regions it meets across an edge or its rounding, each { id, deg } with the angle between their normals. symmetric: a plane element, or \"XY\", \"YZ\", \"ZX\" — each region gets mirror { id, deg, mm }: its twin across that plane (\"self\" when it straddles it), how far their planes differ in angle once mirrored and in place. mark: a region’s id leaves its points marked — element.fit_marked { marked: true } fits to them; with the same options it reuses the last run. Returns found (regions in all), considered and claimed (vertices looked at and held by regions). Changes nothing.",
+      "description": "The scan’s planar regions, found all at once: grown from the flattest places outward, a vertex joining while its normal lies within maxDeg of the region’s plane (15° by default) and it lies inside the region’s noise band; each vertex goes to one region; a region rougher than maxRms off its plane (mm, 0.05 by default) or smaller than minArea (mm², by default a square 2 % of the scan’s diagonal on a side) is given back. box: only the scan inside it. The largest first, at most limit (20); each with id (1 is the largest), normal (out of the part), point (its centroid, on the plane), sigma (RMS off the plane, mm), area (mm²), box, vertices (a count) and neighbours: the regions it meets across an edge or its rounding, each { id, deg } with the angle between their normals. symmetric: a plane element, or \"XY\", \"YZ\", \"XZ\" — each region gets mirror { id, deg, mm }: its twin across that plane (\"self\" when it straddles it), how far their planes differ in angle once mirrored and in place. mark: a region’s id, or several (their points together), leaves its points marked — element.fit_marked { marked: true } fits to them; with the same options it reuses the last run, and answers marked { points, from } and region, the marked region (a list of them for several), without the list of regions unless list: true. Returns found (regions in all), considered and claimed (vertices looked at and held by regions). Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3725,12 +3879,30 @@
                 "minLength": 1
               }
             ],
-            "description": "Pair regions mirrored across this plane: a plane element, or \"XY\", \"YZ\", \"ZX\"."
+            "description": "Pair regions mirrored across this plane: a plane element, or \"XY\", \"YZ\", \"XZ\"."
           },
           "mark": {
-            "type": "integer",
-            "description": "Leave this region’s points marked, by its id.",
-            "minimum": 1
+            "oneOf": [
+              {
+                "type": "integer",
+                "description": "A region’s id.",
+                "minimum": 1
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "integer",
+                  "minimum": 1
+                },
+                "description": "Several regions’ ids: their points together.",
+                "minItems": 1
+              }
+            ],
+            "description": "Leave this region’s points marked, by its id — or several regions’."
+          },
+          "list": {
+            "type": "boolean",
+            "description": "With mark: the list of regions too, as without it."
           }
         },
         "additionalProperties": false
@@ -3742,7 +3914,7 @@
     {
       "name": "section.cut",
       "title": "Cut a section",
-      "description": "Cut the scan with a plane and keep the cut as a section, measured in the 2D workspace (flat) — where it is put on the sheet. across is what the plane is taken across: an element with a direction (a plane, cylinder, cone, line or circle) by id or name, or a coordinate plane \"XY\", \"YZ\" or \"ZX\", which is laid through the part’s centre. Or { axis, angleDeg }: a plane through an axis — a cylinder’s, cone’s, line’s or circle’s, by id or name, or the coordinate axis \"X\", \"Y\" or \"Z\" through the origin — turned angleDeg about it: a half section of a turned part, u the distance out from the axis and v up it (towards the + end of the coordinate axis it lies nearest, whichever way the element points), normal u × v, at every angle. 0° is the coordinate axis next round (X about Z, Y about X, Z about Y) and the angle turns by the right hand about the axis — about Z, from +X towards +Y. offset slides the plane along its normal, mm — from the element, or for a coordinate plane the coordinate itself; through an axis, 0 by default. Returns the section: its plane and how many chains the cut has. One undo step.",
+      "description": "Cut the scan with a plane and keep the cut as a section, measured in the 2D workspace (flat) — where it is put on the sheet. across is what the plane is taken across: an element with a direction (a plane, cylinder, cone, line or circle) by id or name, or a coordinate plane \"XY\", \"YZ\" or \"XZ\" (also \"ZX\"), which is laid through the part’s centre. Or { axis, angleDeg }: a plane through an axis — a cylinder’s, cone’s, line’s or circle’s, by id or name, or the coordinate axis \"X\", \"Y\" or \"Z\" through the origin — turned angleDeg about it: a half section of a turned part, u the distance out from the axis and v up it (towards the + end of the coordinate axis it lies nearest, whichever way the element points), normal u × v, at every angle. 0° is the coordinate axis next round (X about Z, Y about X, Z about Y) and the angle turns by the right hand about the axis — about Z, from +X towards +Y. offset slides the plane along its normal, mm — from the element, or for a coordinate plane the coordinate itself; through an axis, 0 by default. Returns the section: its plane and how many chains the cut has. One undo step.",
       "input": {
         "type": "object",
         "properties": {
@@ -3755,7 +3927,7 @@
               },
               {
                 "type": "string",
-                "description": "An element’s name, or a coordinate plane \"XY\", \"YZ\", \"ZX\".",
+                "description": "An element’s name, or a coordinate plane \"XY\", \"YZ\", \"XZ\".",
                 "minLength": 1
               },
               {
@@ -3903,7 +4075,7 @@
     {
       "name": "section.render",
       "title": "Picture a section",
-      "description": "A picture of a section as a PNG, for checking a slice against what was built on it: the scan’s cut as points on the section’s sheet ([u, v] mm as section.get gives them, +u right, +v up), a grid ruled in millimetres with its values at the top and left margins — world coordinates where the sheet’s u or v runs along a world axis, sheet mm otherwise — the world direction across and up named in the margins (axes in the answer: per sheet axis the world axis it runs nearest, offDeg and, along it, at0, the world coordinate at the sheet’s 0), a scale bar, and over it what the workspaces’ layers draw — a model’s cut by the section’s plane as outlines, a sketch’s pieces with their ids where the sketch lies in that plane, whatever it was drawn on. Every scan point within ten tolerances of an outline is read against it: on it within ± tolerance (grey), or off it (red), outside the outline or inside it; points with no outline near are pale. The answer gives gap: points (the cut’s), read, over (red), outside and inside (of a closed outline — inside is scan within the model’s material, so the model stands proud there; outside, the model is short), max and rms (mm) and overBox (the sheet box round the red, to frame the next look); layers: each layer drawn by key, its outlines and pieces counted; map: picture pixel (column c, row r from the top) is the sheet place [left + c·unitsPerPx, top − r·unitsPerPx]. section names a section; or plane cuts the scan for the picture alone — no section is made, and the sheet is a sketch’s on that plane: zero at the world origin’s foot, u along the coordinate axis next round from the normal (YZ: u = Y, v = Z; ZX: u = Z, v = X; XY: u = X, v = Y), so on a coordinate plane [u, v] are world coordinates (the answer’s sheet gives them). plane is { origin, normal }, an element by id or name (the plane through its centre square to its direction — a plane element’s normal, a cylinder’s axis — on the sheet a sketch on it takes, not the fitter’s own axes), or { sketch } by id or name: the scan cut on that sketch’s plane, in its own frame, so [u, v] are its pieces’. A section’s own sheet counts from the part’s centre instead. up: \"x\", \"y\" or \"z\" turns the picture’s sheet in its plane so that world axis runs up it — a side view with Z up: v is that axis laid into the plane, u the direction square to it running + to the right, the plane seen from whichever side gives that (the ZX plane with up \"z\": u = X, v = Z, seen from −Y, as a front view; a section’s sheet keeps its zero) — and everything the picture says in [u, v] (frame, map, overBox, axes) is then on that turned sheet, which the answer gives as sheet. Without up the sheet lies as above. offsets: 2 to 9 cuts in one picture — the section’s or plane’s slid along its normal by each, mm — side by side, each tile labelled with its offset, all on one frame and scale (the square round every cut unless frame is given); the answer gives per tile its offset, origin and gap, and map.tile and map.cols (map holds for each tile from its own corner). frame { at: [u, v], size } looks at a square of the sheet; everything by default. tolerance: the Deviation workspace’s by default. layers: the keys to draw; every one by default, [] for the scan alone. 800 px on the long side by default, up to 2048. Needs the browser. Changes nothing.",
+      "description": "A picture of a section as a PNG, for checking a slice against what was built on it: the scan’s cut as points on the section’s sheet ([u, v] mm as section.get gives them, +u right, +v up), a grid ruled in millimetres with its values at the top and left margins — world coordinates where the sheet’s u or v runs along a world axis, sheet mm otherwise — the world direction across and up named in the margins (axes in the answer: per sheet axis the world axis it runs nearest, offDeg and, along it, at0, the world coordinate at the sheet’s 0), a scale bar, and over it what the workspaces’ layers draw — a model’s cut by the section’s plane as outlines, a sketch’s pieces with their ids where the sketch lies in that plane, whatever it was drawn on. Every scan point within ten tolerances of an outline is read against it: on it within ± tolerance (grey), or off it (red), outside the outline or inside it; points with no outline near are pale. The answer gives gap: points (the cut’s), read, over (red), outside and inside (of a closed outline — inside is scan within the model’s material, so the model stands proud there; outside, the model is short), max and rms (mm) and overBox (the sheet box round the red, to frame the next look); layers: each layer drawn by key, its outlines and pieces counted; map: picture pixel (column c, row r from the top) is the sheet place [left + c·unitsPerPx, top − r·unitsPerPx]. section names a section; or plane cuts the scan for the picture alone — no section is made, and the sheet is a sketch’s on that plane: zero at the world origin’s foot, u along the coordinate axis next round from the normal (YZ: u = Y, v = Z; XZ: u = Z, v = X; XY: u = X, v = Y), so on a coordinate plane [u, v] are world coordinates (the answer’s sheet gives them). plane is { origin, normal }, a coordinate plane \"XY\", \"YZ\" or \"XZ\" (also \"ZX\"; through the part’s centre, as section.cut lays it — the answer’s sheet gives its origin), an element by id or name (the plane through its centre square to its direction — a plane element’s normal, a cylinder’s axis — on the sheet a sketch on it takes, not the fitter’s own axes), or { sketch } by id or name: the scan cut on that sketch’s plane, in its own frame, so [u, v] are its pieces’. A section’s own sheet counts from the part’s centre instead (across an element or through its axis, from the element’s centre). up: \"x\", \"y\" or \"z\" turns the picture’s sheet in its plane so that world axis runs up it — a side view with Z up: v is that axis laid into the plane, u the direction square to it running + to the right, the plane seen from whichever side gives that (the XZ plane with up \"z\": u = X, v = Z, seen from −Y, as a front view; a section’s sheet keeps its zero) — and everything the picture says in [u, v] (frame, map, overBox, axes) is then on that turned sheet, which the answer gives as sheet. Without up the sheet lies as above. The answer’s sheet gives the sheet in the world every time — origin, normal, basisU and basisV: a sheet point [u, v] is origin + u·basisU + v·basisV. offsets: 2 to 9 cuts in one picture — the section’s or plane’s slid along its normal by each, mm — side by side, each tile labelled with its offset, all on one frame and scale (the square round every cut unless frame is given); the answer gives per tile its offset, origin and gap, and map.tile and map.cols (map holds for each tile from its own corner). frame { at, size } looks at a square of the sheet — at as [u, v] on the sheet, or as [x, y, z] in the world, laid square onto the sheet, so a place on the part needs no working out of where the sheet counts from (framed gives where it came out on the sheet, and offPlane how far off the plane the point lay, mm) — or frame { world: { min, max } } at the square round a box of the world laid onto the sheet, a tenth wider; everything by default. tolerance: the Deviation workspace’s by default. layers: the keys to draw; every one by default, [] for the scan alone. 800 px on the long side by default, up to 2048. Needs the browser. Changes nothing.",
       "input": {
         "type": "object",
         "properties": {
@@ -3959,7 +4131,7 @@
               },
               {
                 "type": "string",
-                "description": "An element’s name.",
+                "description": "A coordinate plane \"XY\", \"YZ\", \"XZ\", or an element’s name.",
                 "minLength": 1
               },
               {
@@ -3985,7 +4157,7 @@
                 "additionalProperties": false
               }
             ],
-            "description": "A plane to cut the scan by for the picture alone, in place of a section: { origin, normal }, an element, or { sketch }."
+            "description": "A plane to cut the scan by for the picture alone, in place of a section: { origin, normal }, a coordinate plane, an element, or { sketch }."
           },
           "offsets": {
             "type": "array",
@@ -4013,22 +4185,47 @@
                 "items": {
                   "type": "number"
                 },
-                "description": "The sheet place in the middle, [u, v] mm.",
+                "description": "The place in the middle: [u, v] mm on the sheet, or [x, y, z] mm in the world, laid square onto the sheet.",
                 "minItems": 2,
-                "maxItems": 2
+                "maxItems": 3
               },
               "size": {
                 "type": "number",
                 "description": "The side of the square looked at, mm.",
                 "exclusiveMinimum": 0
+              },
+              "world": {
+                "type": "object",
+                "properties": {
+                  "min": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The lowest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  },
+                  "max": {
+                    "type": "array",
+                    "items": {
+                      "type": "number"
+                    },
+                    "description": "The highest corner, [x, y, z] mm.",
+                    "minItems": 3,
+                    "maxItems": 3
+                  }
+                },
+                "required": [
+                  "min",
+                  "max"
+                ],
+                "additionalProperties": false,
+                "description": "A box in the world, in place of at and size: the square round it on the sheet."
               }
             },
-            "required": [
-              "at",
-              "size"
-            ],
             "additionalProperties": false,
-            "description": "Look at a square of the sheet."
+            "description": "Look at a square of the sheet: { at, size }, or { world: { min, max } }."
           },
           "tolerance": {
             "type": "number",
@@ -4253,7 +4450,7 @@
     {
       "name": "view.render",
       "title": "Picture the view",
-      "description": "A picture of the 3D view as a PNG — what the person sees in the viewport, without the HTML labels over it (dimension values, names), and lit from a little above and left of the camera with more fill than the screen, so a face square to the camera keeps its shading. Give view and/or fit to turn the view first, as view.set does, or frame to frame a box or a place. show puts the scan, the reference, the sections, the elements or the labels — or what a workspace adds — on screen or away for the picture alone, by key, and back as they were after it — { scan: false } pictures what was built on the scan on its own; view.set lists the keys. section cuts everything open for the picture alone, as view.set does. width and height in pixels: the viewport’s own shape at most 800 pixels on its long side by default, enough to check a step by — ask for more (up to 2048) for a picture to keep; one of them alone keeps the viewport’s shape. views: two to six standard views in one picture, side by side, each fitted and named in its corner — iso, top, bottom and a side as one picture to look at instead of four (width and height are then the whole sheet’s; 1200 px across by default); the view stays at the last. In the Deviation workspace the answer says which map the picture shows — map: { on: \"scan\" | \"reference\", colormap, range } — or map: null and mapWhy, why none is painted (the map switch off, no map measured, the surface it is on put away) and what puts it there. With the scan shown, a reference shown with it is drawn over it as a ghost and dulls the colours (mapNote says so): show: { reference: false } gives the clean map. Waits for the session to settle first — a map being measured, on the scan or on the reference, too. Needs the viewport.",
+      "description": "A picture of the 3D view as a PNG — what the person sees in the viewport, without the HTML labels over it (dimension values, names), and lit from a little above and left of the camera with more fill than the screen, so a face square to the camera keeps its shading. Give view and/or fit to turn the view first, as view.set does, or frame to frame a box or a place — a place’s size is the side of a square fitted in the picture, its shorter side, and the answer’s mmAcross: [width, height] says what the picture spans, mm. Only fit: true fits: a view alone turns and keeps the zoom, and a frame stays for the pictures after it — the answer says fitted, and framedEarlier: { box | at, size } while the camera still stands on an earlier frame (fit: true pictures it whole). show puts the scan, the reference, the sections, the elements or the labels — or what a workspace adds — on screen or away for the picture alone, by key, and back as they were after it — { scan: false } pictures what was built on the scan on its own; view.set lists the keys. section cuts everything open for the picture alone, as view.set does. width and height in pixels: the viewport’s own shape at most 800 pixels on its long side by default, enough to check a step by — ask for more (up to 2048) for a picture to keep; one of them alone keeps the viewport’s shape. views: two to six standard views in one picture, side by side, each fitted and named in its corner — iso, top, bottom and a side as one picture to look at instead of four (width and height are then the whole sheet’s; 1200 px across by default); the view stays at the last. In the Deviation workspace the answer says which map the picture shows — map: { on: \"scan\" | \"reference\", colormap, range } — or map: null and mapWhy, why none is painted (the map switch off, no map measured, the surface it is on put away) and what puts it there. With the scan shown, a reference shown with it is drawn over it as a ghost and dulls the colours (mapNote says so): show: { reference: false } gives the clean map. In another workspace, with a deviation map measured, map: null and mapWhy say it paints in the Deviation workspace alone (workspace.set deviation); a workspace that colours the part its own way answers map or mapWhy for its own. A workspace’s key that is off in the picture, and not put away by show, may say why and what shows it under <key>Why. Waits for the session to settle first — a map being measured, on the scan or on the reference, too. Pictures and view.set take the viewport one at a time: two asked for together come back as two, one after the other. Needs the viewport.",
       "input": {
         "type": "object",
         "properties": {
@@ -4371,7 +4568,7 @@
                   },
                   "size": {
                     "type": "number",
-                    "description": "How wide the picture is, mm — in any view, the iso too.",
+                    "description": "The side of the square the picture is fitted round, mm — its shorter side, in any view, the iso too: 40 in an 800 × 450 picture is 40 tall and 71 wide (mmAcross in the answer).",
                     "exclusiveMinimum": 0
                   }
                 },
@@ -4380,7 +4577,7 @@
                   "size"
                 ],
                 "additionalProperties": false,
-                "description": "A place in the middle of a view `size` mm across."
+                "description": "A place in the middle of a view, a square `size` mm on a side fitted in it."
               }
             ],
             "description": "Frame a box or a place instead of everything shown — a corner or a fillet looked at closely; the direction looked from stays, and fit is left alone."
@@ -4407,7 +4604,7 @@
                         "minLength": 1
                       }
                     ],
-                    "description": "A coordinate plane \"XY\", \"YZ\", \"ZX\", or an element with a direction."
+                    "description": "A coordinate plane \"XY\", \"YZ\", \"XZ\", or an element with a direction."
                   },
                   "offset": {
                     "type": "number",
@@ -4436,7 +4633,7 @@
     {
       "name": "view.set",
       "title": "Turn the view",
-      "description": "Turn the 3D view to a standard view and/or fit everything shown into the frame — with neither given, it fits — or frame a box or a place (frame). show puts the scan, the reference, the sections, the elements or the labels on screen or away, by key, and leaves them so — { scan: false } to look at what was built on the scan without it. section cuts everything open at a plane to look inside, and leaves it so. It waits for the session to settle first (a fit, a map, a rebuild), so what was just made is in the frame. Not a step of the history. Needs the viewport. Returns the view, the section view (null when off) and, under shown, every key that can be shown now and whether it is.",
+      "description": "Turn the 3D view to a standard view and/or fit everything shown into the frame — with neither given, it fits — or frame a box or a place (frame); the zoom a frame leaves stays for what comes after it, a standard view without fit included. show puts the scan, the reference, the sections, the elements or the labels on screen or away, by key, and leaves them so — { scan: false } to look at what was built on the scan without it. section cuts everything open at a plane to look inside, and leaves it so. It waits for the session to settle first (a fit, a map, a rebuild), so what was just made is in the frame. Not a step of the history. Needs the viewport. Returns the view, fitted (whether it fitted), framed (the frame asked), framedEarlier (the frame of an earlier call the camera still stands on, not fitted since), mmAcross ([width, height], mm the viewport spans), the section view (null when off) and, under shown, every key that can be shown now and whether it is — a workspace’s key that is off, and not put away by show, may say why and what shows it under <key>Why.",
       "input": {
         "type": "object",
         "properties": {
@@ -4523,7 +4720,7 @@
                   },
                   "size": {
                     "type": "number",
-                    "description": "How wide the picture is, mm — in any view, the iso too.",
+                    "description": "The side of the square the picture is fitted round, mm — its shorter side, in any view, the iso too: 40 in an 800 × 450 picture is 40 tall and 71 wide (mmAcross in the answer).",
                     "exclusiveMinimum": 0
                   }
                 },
@@ -4532,7 +4729,7 @@
                   "size"
                 ],
                 "additionalProperties": false,
-                "description": "A place in the middle of a view `size` mm across."
+                "description": "A place in the middle of a view, a square `size` mm on a side fitted in it."
               }
             ],
             "description": "Frame a box or a place instead of everything shown — a corner or a fillet looked at closely; the direction looked from stays, and fit is left alone."
@@ -4559,7 +4756,7 @@
                         "minLength": 1
                       }
                     ],
-                    "description": "A coordinate plane \"XY\", \"YZ\", \"ZX\", or an element with a direction."
+                    "description": "A coordinate plane \"XY\", \"YZ\", \"XZ\", or an element with a direction."
                   },
                   "offset": {
                     "type": "number",