sysml-diagram 0.15.6 → 0.15.7

package/out/main.js

@@ -161072,6 +161072,377 @@ function evaluateVerificationCase(caseNode, resolveRequirement, resolvePart) {
   return { status, verifies };
 }
 
+// ../language-server/out/src/services/geometry-transform.js
+var IDENTITY_TRANSFORM = Object.freeze({
+  r: Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]),
+  t: Object.freeze([0, 0, 0])
+});
+function translationTransform(v) {
+  return { r: IDENTITY_TRANSFORM.r, t: [v[0], v[1], v[2]] };
+}
+function rotationTransform(axis, angleDeg) {
+  const len = Math.hypot(axis[0], axis[1], axis[2]);
+  if (!(len > 0) || !Number.isFinite(angleDeg))
+    return void 0;
+  const [x, y, z2] = [axis[0] / len, axis[1] / len, axis[2] / len];
+  const a2 = angleDeg * Math.PI / 180;
+  const c = Math.cos(a2);
+  const s = Math.sin(a2);
+  const k = 1 - c;
+  return {
+    r: [
+      c + x * x * k,
+      x * y * k - z2 * s,
+      x * z2 * k + y * s,
+      y * x * k + z2 * s,
+      c + y * y * k,
+      y * z2 * k - x * s,
+      z2 * x * k - y * s,
+      z2 * y * k + x * s,
+      c + z2 * z2 * k
+    ],
+    t: [0, 0, 0]
+  };
+}
+function composeTransforms(a2, b) {
+  const r = new Array(9).fill(0);
+  for (let i = 0; i < 3; i++) {
+    for (let j = 0; j < 3; j++) {
+      let sum = 0;
+      for (let k = 0; k < 3; k++)
+        sum += a2.r[i * 3 + k] * b.r[k * 3 + j];
+      r[i * 3 + j] = sum;
+    }
+  }
+  return { r, t: applyTransform(a2, b.t) };
+}
+function applyTransform(m, p) {
+  return [
+    m.r[0] * p[0] + m.r[1] * p[1] + m.r[2] * p[2] + m.t[0],
+    m.r[3] * p[0] + m.r[4] * p[1] + m.r[5] * p[2] + m.t[1],
+    m.r[6] * p[0] + m.r[7] * p[1] + m.r[8] * p[2] + m.t[2]
+  ];
+}
+function yawOf(m) {
+  if (Math.abs(m.r[2]) > 1e-6 || Math.abs(m.r[5]) > 1e-6)
+    return void 0;
+  if (Math.abs(m.r[6]) > 1e-6 || Math.abs(m.r[7]) > 1e-6)
+    return void 0;
+  if (Math.abs(m.r[8] - 1) > 1e-6)
+    return void 0;
+  const deg = Math.atan2(m.r[3], m.r[0]) * 180 / Math.PI;
+  const norm = (deg % 360 + 360) % 360;
+  return Math.abs(norm) < 1e-6 || Math.abs(norm - 360) < 1e-6 ? 0 : Number(norm.toFixed(6));
+}
+function affineTransform(rotation, translation) {
+  if (!rotation || rotation.length !== 9 || rotation.some((v) => !Number.isFinite(v)))
+    return void 0;
+  if (!translation || translation.length !== 3 || translation.some((v) => !Number.isFinite(v)))
+    return void 0;
+  return { r: [...rotation], t: [translation[0], translation[1], translation[2]] };
+}
+function tokenize2(src) {
+  const out = [];
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (/\s/.test(c)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(c) || c === "." && /[0-9]/.test(src[i + 1] ?? "")) {
+      const m = /^[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?/.exec(src.slice(i));
+      if (!m)
+        return void 0;
+      out.push({ k: "num", v: Number(m[0]) });
+      i += m[0].length;
+      continue;
+    }
+    if (c === "'") {
+      const end = src.indexOf("'", i + 1);
+      if (end < 0)
+        return void 0;
+      out.push({ k: "id", v: src.slice(i + 1, end) });
+      i = end + 1;
+      continue;
+    }
+    if (/[A-Za-z_]/.test(c)) {
+      const m = /^[A-Za-z_][A-Za-z_0-9]*/.exec(src.slice(i));
+      out.push({ k: "id", v: m[0] });
+      i += m[0].length;
+      continue;
+    }
+    if (src.startsWith("::", i)) {
+      out.push({ k: "op", v: "::" });
+      i += 2;
+      continue;
+    }
+    if ("+-*/(),.[]".includes(c)) {
+      out.push({ k: "op", v: c });
+      i++;
+      continue;
+    }
+    return void 0;
+  }
+  return out;
+}
+var isScalar = (v) => typeof v === "number";
+var ExprParser = class {
+  toks;
+  resolve;
+  pos = 0;
+  constructor(toks, resolve8) {
+    this.toks = toks;
+    this.resolve = resolve8;
+  }
+  parse() {
+    const v = this.expr();
+    return this.pos === this.toks.length ? v : void 0;
+  }
+  peek() {
+    return this.toks[this.pos];
+  }
+  isOp(v) {
+    const t = this.peek();
+    return t?.k === "op" && t.v === v;
+  }
+  eat(v) {
+    if (this.isOp(v)) {
+      this.pos++;
+      return true;
+    }
+    return false;
+  }
+  expr() {
+    let left = this.term();
+    for (; ; ) {
+      const plus2 = this.isOp("+");
+      if (!plus2 && !this.isOp("-"))
+        return left;
+      this.pos++;
+      const right = this.term();
+      if (!isScalar(left) || !isScalar(right))
+        return void 0;
+      left = plus2 ? left + right : left - right;
+    }
+  }
+  term() {
+    let left = this.unary();
+    for (; ; ) {
+      const mul = this.isOp("*");
+      if (!mul && !this.isOp("/"))
+        return left;
+      this.pos++;
+      const right = this.unary();
+      if (!isScalar(left) || !isScalar(right))
+        return void 0;
+      if (!mul && right === 0)
+        return void 0;
+      left = mul ? left * right : left / right;
+    }
+  }
+  unary() {
+    if (this.eat("-")) {
+      const v = this.unary();
+      if (isScalar(v))
+        return -v;
+      return Array.isArray(v) ? v.map((n2) => -n2) : void 0;
+    }
+    if (this.eat("+"))
+      return this.unary();
+    return this.postfix(this.primary());
+  }
+  // `[mm]` / `[datum]` / `['°']` — a unit or coordinate-frame suffix carries no
+  // arithmetic; `as Box` is a cast. Both are consumed and ignored. A `.name`
+  // after a parenthesized value continues the feature path of what it wraps,
+  // which only a resolver can decide, so it is refused.
+  postfix(value) {
+    for (; ; ) {
+      if (this.isOp("[")) {
+        let depth = 0;
+        do {
+          const t2 = this.peek();
+          if (!t2)
+            return void 0;
+          if (t2.k === "op" && t2.v === "[")
+            depth++;
+          if (t2.k === "op" && t2.v === "]")
+            depth--;
+          this.pos++;
+        } while (depth > 0);
+        continue;
+      }
+      const t = this.peek();
+      if (t?.k === "id" && t.v === "as") {
+        this.pos++;
+        const type = this.peek();
+        if (type?.k !== "id")
+          return void 0;
+        this.pos++;
+        while (this.eat("::")) {
+          if (this.peek()?.k !== "id")
+            return void 0;
+          this.pos++;
+        }
+        continue;
+      }
+      return value;
+    }
+  }
+  primary() {
+    const t = this.peek();
+    if (!t)
+      return void 0;
+    if (t.k === "num") {
+      this.pos++;
+      return t.v;
+    }
+    if (this.isOp("(")) {
+      this.pos++;
+      const items = [this.expr()];
+      while (this.eat(","))
+        items.push(this.expr());
+      if (!this.eat(")"))
+        return void 0;
+      if (items.length === 1)
+        return items[0];
+      if (items.every(isScalar))
+        return items;
+      return void 0;
+    }
+    if (t.k === "id")
+      return this.path();
+    return void 0;
+  }
+  // A dotted / qualified feature path. A leading `(expr as T).name` is handled
+  // by the caller rewriting the cast away, so a path always starts with a name.
+  path() {
+    const segs = [];
+    for (; ; ) {
+      const t = this.peek();
+      if (t?.k !== "id")
+        return void 0;
+      segs.push(t.v);
+      this.pos++;
+      if (this.isOp(".") && this.toks[this.pos + 1]?.k === "id") {
+        this.pos++;
+        continue;
+      }
+      if (this.isOp("::") && this.toks[this.pos + 1]?.k === "id") {
+        this.pos++;
+        continue;
+      }
+      break;
+    }
+    if (this.isOp("("))
+      return void 0;
+    return this.resolve(segs);
+  }
+};
+function unwrapCasts(src) {
+  const re = /\(\s*([A-Za-z_'][^()]*?)\s+as\s+[A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*\s*\)/g;
+  let out = src;
+  for (let pass = 0; pass < 4; pass++) {
+    const next = out.replace(re, "$1");
+    if (next === out)
+      break;
+    out = next;
+  }
+  return out;
+}
+function evalValueExpr(text, resolve8 = () => void 0) {
+  if (!text)
+    return void 0;
+  const trimmed = unwrapCasts(text.trim());
+  if (!trimmed || trimmed.length > 2e3)
+    return void 0;
+  const toks = tokenize2(trimmed);
+  if (!toks || toks.length === 0)
+    return void 0;
+  const v = new ExprParser(toks, resolve8).parse();
+  if (isScalar(v))
+    return Number.isFinite(v) ? v : void 0;
+  if (Array.isArray(v))
+    return v.every((n2) => Number.isFinite(n2)) ? v : void 0;
+  return void 0;
+}
+function evalScalarExpr(text, resolve8) {
+  const v = evalValueExpr(text, resolve8);
+  return typeof v === "number" ? v : void 0;
+}
+function evalVector3Expr(text, resolve8) {
+  const v = evalValueExpr(text, resolve8);
+  if (Array.isArray(v) && v.length === 3)
+    return [v[0], v[1], v[2]];
+  return void 0;
+}
+function splitTopLevel(src) {
+  if (!src.trim())
+    return [];
+  const out = [];
+  let depth = 0;
+  let start2 = 0;
+  let quoted = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (quoted) {
+      if (c === "'")
+        quoted = false;
+      continue;
+    }
+    if (c === "'") {
+      quoted = true;
+      continue;
+    }
+    if (c === "(" || c === "[")
+      depth++;
+    else if (c === ")" || c === "]") {
+      depth--;
+      if (depth < 0)
+        return void 0;
+    } else if (c === "," && depth === 0) {
+      out.push(src.slice(start2, i));
+      start2 = i + 1;
+    }
+  }
+  if (depth !== 0 || quoted)
+    return void 0;
+  out.push(src.slice(start2));
+  return out.map((s) => s.trim());
+}
+function parseConstructions(text) {
+  if (!text)
+    return [];
+  const out = [];
+  const re = /\bnew\s+([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)\s*\(/g;
+  let m;
+  while (m = re.exec(text)) {
+    let depth = 1;
+    let i = re.lastIndex;
+    let quoted = false;
+    while (i < text.length && depth > 0) {
+      const c = text[i];
+      if (quoted) {
+        if (c === "'")
+          quoted = false;
+      } else if (c === "'")
+        quoted = true;
+      else if (c === "(" || c === "[")
+        depth++;
+      else if (c === ")" || c === "]")
+        depth--;
+      i++;
+    }
+    if (depth !== 0)
+      break;
+    const inner = text.slice(re.lastIndex, i - 1);
+    const type = m[1].includes("::") ? m[1].slice(m[1].lastIndexOf("::") + 2) : m[1];
+    out.push({ type, args: splitTopLevel(inner) ?? [] });
+    re.lastIndex = i;
+  }
+  return out;
+}
+
 // ../language-server/out/src/services/comment-body.js
 function sourceOf(node) {
   return node.$cstNode?.root.fullText;
@@ -161593,6 +161964,23 @@ var lastSeg = (name) => {
   const i = Math.max(name.lastIndexOf("::"), name.lastIndexOf("."));
   return i >= 0 ? name.slice(i + (name[i] === ":" ? 2 : 1)) : name;
 };
+var redefinitionTargetsOf = (m) => {
+  const rels = [...m.preRelationships ?? [], ...m.relationships ?? []];
+  const out = [];
+  for (const rel2 of rels) {
+    if (rel2.kind === ":>>" || rel2.kind === "redefines" || rel2.kind === ":>" || rel2.kind === "subsets") {
+      for (const t of rel2.targets ?? [])
+        out.push(lastSeg(t));
+    }
+  }
+  return out;
+};
+var valueTextOf = (node) => node ? node.value?.$cstNode?.text : void 0;
+var firstSymbol = (text) => text?.match(/[A-Za-z_µ°][A-Za-z_0-9µ°]*/)?.[0];
+var roundGeo = (v) => {
+  const r = Number(v.toFixed(6));
+  return Object.is(r, -0) ? 0 : r;
+};
 var notePreview = (body) => {
   if (!body)
     return void 0;
@@ -162430,10 +162818,12 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
   }
   // REQ-205 — the Geometry View shows ONLY geometry objects, so a node anchors
-  // (or contributes to) a gev only when one of its part usages carries a spatial
-  // placement (a position and/or a library shape).
+  // (or contributes to) a gev only when its spatial tree yields one: a part
+  // carrying a position (flat x/y/z or a coordinate-frame transformation,
+  // issue #107) and/or a library shape. Asked of the same walk that builds the
+  // view, so availability and content cannot disagree.
   hasGeometryObject(node, index2) {
-    return this.nestedUsages(node, isPartDecl).some((n2) => this.geoOf(n2, index2) !== void 0 || this.shapeOf(n2, index2) !== void 0);
+    return this.collectGeometry(node, index2).length > 0;
   }
   hasRenderablePorts(node, index2) {
     const hasOwnPort = membersOf(node).some((m) => isPortDecl(m) && m.isDef !== true);
@@ -165620,12 +166010,41 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     planarsurface: "plane",
     triangle: "plane"
   };
+  // issue #107 — the positional argument order of the ShapeItems constructors
+  // whose declaration order is unambiguous, so `item :>> shape = new Box(4800
+  // [mm], 1840 [mm], 1350 [mm])` yields real extents. `RectangularCuboid`
+  // declares length/width/height in that order and `Sphere` declares radius;
+  // the elliptical solids interleave inherited semi-axes, so their positional
+  // form is deliberately not guessed at.
+  static SHAPE_CTOR_ARGS = {
+    box: ["length", "width", "height"],
+    rectangularcuboid: ["length", "width", "height"],
+    cuboid: ["length", "width", "height"],
+    sphere: ["radius"]
+  };
+  // issue #107 — bounds on the recursive spatial walk. A Geometry View is a
+  // picture, not a model dump: depth stops the walk from descending through an
+  // entire product tree, and the node cap keeps one pathological model from
+  // stalling the provider.
+  static GEO_MAX_DEPTH = 5;
+  static GEO_MAX_NODES = 250;
   // ── gev — Geometry View (REQ-205): the anchor's parts placed on a spatial
   // frame at the positions and shapes declared in the model. A part is placed
-  // explicitly when it carries placement attributes (model units):
+  // either by flat placement attributes (model units):
   //   • `x`, `y`, `z`       — centre position (x →, y depth, z up)
-  //   • shape from its type — a ShapeItems Box/Sphere/Cylinder/Cone/Wedge/…
   //   • `length`/`width`/`height`, `radius` — the shape's extents
+  // or — issue #107 — by the Geometry domain library's own spatial model: a
+  // `SpatialItems::SpatialItem`'s `coordinateFrame` carries a
+  // `MeasurementReferences` transformation (a `TranslationRotationSequence` of
+  // `Translation`/`Rotation`, an `AffineTransformationMatrix3d`, or a
+  // `CoordinateFramePlacement`) locating that frame in its parent's. Those
+  // transforms COMPOSE down the containment chain, so a nested SpatialItem is
+  // placed relative to the frame of the item it sits in.
+  //
+  // Its shape comes from its type — a ShapeItems Box/Sphere/Cylinder/Cone/… —
+  // or from the `shape` feature the Geometry library gives every SpatialItem
+  // (`item :>> shape : Cylinder { :>> radius = …; }`).
+  //
   // When any part is a 3D shape (or carries a z), the webview renders an
   // isometric 3D scene; a flat x/y-only set renders as a top-view plan. The
   // Geometry View shows ONLY geometry objects — a part is included only when it
@@ -165635,66 +166054,501 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   buildGeometryView(ctx) {
     const { uri, index: index2 } = ctx;
     const anchor = ctx.anchor;
-    const candidates = this.nestedUsages(anchor, isPartDecl).map((p) => ({ p, geo: this.geoOf(p, index2), hasShape: this.shapeOf(p, index2) !== void 0 })).filter((x) => x.geo !== void 0 || x.hasShape);
-    const placed = candidates.filter((x) => x.geo !== void 0);
-    const usedY = placed.some((x) => x.geo.axisY);
-    const unit = placed.find((x) => x.geo.unit)?.geo.unit;
-    const nodes = candidates.map(({ p, geo }) => ({
-      id: qnameOf(p) || nameOf2(p),
-      name: nameOf2(p),
-      keyword: keywordFor(p),
+    const candidates = this.collectGeometry(anchor, index2);
+    const usedY = candidates.some((c) => c.axisY);
+    const unit = candidates.find((c) => c.unit)?.unit;
+    const nodes = candidates.map((c) => ({
+      id: c.id,
+      name: c.name,
+      keyword: keywordFor(c.node),
       isDef: false,
       shape: "box",
-      type: typeText(p),
-      geo: geo?.geo,
-      source: sourceOf2(p, uri)
+      type: typeText(c.node),
+      geo: c.geo,
+      source: sourceOf2(c.node, uri)
     }));
     const is3d = nodes.some((n2) => n2.geo?.shape !== void 0 || n2.geo?.z !== void 0);
     const model = this.model("gev", anchor, nodes, []);
     model.meta = { geoAxes: { h: "x", v: usedY ? "y" : "z", unit: unit ?? "mm" }, geoMode: is3d ? "3d" : "plan" };
+    const notes = [];
     if (!nodes.length) {
-      model.notes = ["No geometry objects yet \u2014 type a part by a Geometry-library shape (Box, Sphere, Cylinder, \u2026) and give it x / y / z and dimension attributes to place it on the frame."];
+      notes.push("No geometry objects yet \u2014 type a part by a Geometry-library shape (Box, Sphere, Cylinder, \u2026) and give it x / y / z or a coordinateFrame transformation to place it on the frame.");
     } else if (nodes.every((n2) => n2.geo === void 0)) {
-      model.notes = ["No geometry positions found \u2014 add x / y / z attributes to place these shape-typed parts on the frame."];
+      notes.push("No geometry positions found \u2014 add x / y / z attributes to place these shape-typed parts on the frame.");
+    }
+    const approx = nodes.filter((n2) => n2.geo?.approx).map((n2) => n2.name);
+    if (approx.length) {
+      notes.push(`Approximate placement for ${approx.slice(0, 6).join(", ")}${approx.length > 6 ? `, +${approx.length - 6} more` : ""} \u2014 part of the coordinate-frame transformation could not be evaluated. Hover the object for the reason.`);
     }
+    if (notes.length)
+      model.notes = notes;
     return model;
   }
-  // REQ-205 — read a part's spatial placement: its library shape (from the type),
-  // 3D centre position, and shape dimensions. Returns the IR `geo` plus whether a
-  // `y` coordinate was used (axis label) and the detected unit (`mm`/`m`/…).
-  geoOf(node, index2) {
-    const shape = this.shapeOf(node, index2);
-    const x = this.numAttr(node, ["x", "posx", "positionx"]);
-    const y = this.numAttr(node, ["y", "posy", "positiony", "lateral"]);
-    const z2 = this.numAttr(node, ["z", "posz", "positionz", "vertical", "elevation"]);
-    if (x === void 0 && y === void 0 && z2 === void 0)
+  // issue #107 — walk the anchor's spatial containment tree, composing each
+  // SpatialItem's own coordinate-frame transform with the frames above it, and
+  // emit one candidate per drawable object.
+  //
+  // Depth-1 members keep the historical rule: a shape-typed part with no
+  // position at all is still a geometry object (it lands in the webview's
+  // inventory strip, and the view's note tells the user to position it). Deeper
+  // members are emitted only once something above them is placed, so descending
+  // into a placed assembly adds its components rather than flooding the strip
+  // with every unpositioned part in the tree.
+  collectGeometry(anchor, index2) {
+    const out = [];
+    const base = qnameOf(anchor) || nameOf2(anchor) || "";
+    const frames = /* @__PURE__ */ new Map();
+    const anchorFrame = this.ownFrameOf(anchor, index2);
+    if (anchorFrame)
+      frames.set(anchorFrame, IDENTITY_TRANSFORM);
+    const anchorUnit = anchorFrame ? this.frameUnitOf(anchorFrame, anchor, index2) : void 0;
+    const visit = (owner, parent, path10, seen) => {
+      if (path10.length >= _SysmlDiagramModelProvider.GEO_MAX_DEPTH)
+        return;
+      for (const child of membersOf(owner)) {
+        if (out.length >= _SysmlDiagramModelProvider.GEO_MAX_NODES)
+          return;
+        if (child.isDef === true || seen.has(child))
+          continue;
+        if (!isPartDecl(child) && !isItemDecl(child))
+          continue;
+        const name = nameOf2(child);
+        if (!name)
+          continue;
+        const local = this.localPlacementOf(child, index2);
+        const from = this.sourceFrameOf(child, local.sourcePath, frames, index2);
+        const unresolvedSource = local.sourcePath !== void 0 && from === void 0 && path10.length > 0;
+        const world = from ?? parent.world;
+        const state = {
+          world: local.transform ? composeTransforms(world, local.transform) : world,
+          placed: parent.placed || local.placed,
+          hasZ: parent.hasZ || local.hasZ,
+          fromFrame: parent.fromFrame || local.fromFrame,
+          approx: parent.approx ?? local.approx ?? (unresolvedSource ? `its frame is measured from \`${local.sourcePath}\`, which this workspace cannot resolve; it is placed against its enclosing item instead` : void 0),
+          // A frame that does not restate `mRefs` measures in the units
+          // of the frame above it.
+          unit: local.unit ?? parent.unit
+        };
+        const childFrame = this.ownFrameOf(child, index2);
+        if (childFrame)
+          frames.set(childFrame, state.world);
+        const shape = this.shapeInfoOf(child, index2);
+        if (local.placed || shape !== void 0) {
+          out.push({
+            node: child,
+            id: base ? [base, ...path10, name].join("::") : [...path10, name].join("::"),
+            name: path10.length ? [...path10, name].join(".") : name,
+            geo: state.placed ? this.geoFrom(state, local, shape) : void 0,
+            axisY: local.axisY,
+            unit: state.unit
+          });
+        }
+        visit(child, state, [...path10, name], /* @__PURE__ */ new Set([...seen, child]));
+      }
+    };
+    visit(anchor, { world: IDENTITY_TRANSFORM, placed: false, hasZ: false, fromFrame: false, unit: anchorUnit }, [], /* @__PURE__ */ new Set([anchor]));
+    return out;
+  }
+  // issue #107 — the world transform of the frame a transformation declares as
+  // its `source`, when that frame is one the walk has already resolved.
+  // `undefined` means "not stated, or not resolvable here" and the caller falls
+  // back to the containment parent.
+  sourceFrameOf(node, sourcePath, frames, index2) {
+    if (!sourcePath)
       return void 0;
-    const length2 = this.numAttr(node, ["length", "sizex", "dx", "extentx"]);
-    const widthV = this.numAttr(node, ["width", "sizey", "dy", "extenty"]);
-    const height = this.numAttr(node, ["height", "sizez", "dz", "depth", "extentz"]);
-    const radius = this.numAttr(node, ["radius"]);
-    const baseLen = this.numAttr(node, ["baselength"]);
-    const baseWid = this.numAttr(node, ["basewidth"]);
-    const geo = { x: x ?? 0, y: y ?? 0 };
-    if (z2 !== void 0)
+    const segs = sourcePath.split(/::|\./).filter(Boolean);
+    if (!segs.length)
+      return void 0;
+    for (let cur = node; cur; cur = cur.$container) {
+      const found = this.lookupFeature(cur, segs, index2, /* @__PURE__ */ new Set());
+      if (found)
+        return frames.get(found);
+    }
+    return void 0;
+  }
+  // issue #107 — the unit a coordinate frame measures in, from its `mRefs`.
+  // Written either as a tuple of unit symbols (`(mm, mm, mm)`) or as a
+  // reference to another frame's (`datum.mRefs`), which is followed rather than
+  // read literally — taking its first identifier would label the axes with a
+  // FRAME name. A frame that states no `mRefs` at all inherits, which the walk
+  // handles by carrying the enclosing frame's unit down.
+  frameUnitOf(frame2, scope, index2, depth = 0) {
+    if (depth > 4)
+      return void 0;
+    const text = valueTextOf(this.ownMemberNamed(frame2, "mRefs"))?.trim();
+    if (!text)
+      return void 0;
+    if (text.startsWith("("))
+      return firstSymbol(text);
+    const segs = text.split(/::|\./).filter(Boolean);
+    if (!segs.length || !/^[A-Za-z_'][\w'.:]*$/.test(text))
+      return void 0;
+    const target = segs[segs.length - 1].toLowerCase() === "mrefs" ? segs.slice(0, -1) : segs;
+    if (!target.length)
+      return void 0;
+    for (let cur = scope; cur; cur = cur.$container) {
+      const found = this.lookupFeature(cur, target, index2, /* @__PURE__ */ new Set());
+      if (found && found !== frame2)
+        return this.frameUnitOf(found, cur, index2, depth + 1);
+    }
+    return void 0;
+  }
+  // issue #107 — the IR placement of one composed frame state.
+  geoFrom(state, local, shape) {
+    const [x, y, z2] = applyTransform(state.world, [0, 0, 0]).map(roundGeo);
+    const geo = { x, y };
+    if (state.hasZ)
       geo.z = z2;
-    if (shape)
-      geo.shape = shape;
-    const sx = length2 ?? baseLen;
-    const sy = widthV ?? baseWid;
-    if (sx !== void 0)
-      geo.sizeX = Math.abs(sx);
-    if (sy !== void 0)
-      geo.sizeY = Math.abs(sy);
-    if (height !== void 0)
-      geo.sizeZ = Math.abs(height);
+    if (shape?.kind)
+      geo.shape = shape.kind;
+    const sizeX = local.sizeX ?? shape?.sizeX;
+    const sizeY = local.sizeY ?? shape?.sizeY;
+    const sizeZ = local.sizeZ ?? shape?.sizeZ;
+    const radius = local.radius ?? shape?.radius;
+    if (sizeX !== void 0)
+      geo.sizeX = Math.abs(sizeX);
+    if (sizeY !== void 0)
+      geo.sizeY = Math.abs(sizeY);
+    if (sizeZ !== void 0)
+      geo.sizeZ = Math.abs(sizeZ);
     if (radius !== void 0)
       geo.radius = Math.abs(radius);
-    const rot = this.numAttr(node, ["rotation", "yaw", "heading", "rotz"]);
-    if (rot !== void 0)
-      geo.rot = rot;
-    const unit = this.unitAttr(node, ["x", "y", "z", "length", "width", "height", "radius"]);
-    return { geo, axisY: y !== void 0, unit };
+    const yaw = state.fromFrame ? yawOf(state.world) : 0;
+    if (local.rot !== void 0)
+      geo.rot = local.rot;
+    else if (yaw !== void 0 && yaw !== 0)
+      geo.rot = yaw;
+    let approx = state.approx;
+    if (yaw === void 0)
+      approx ??= "the composed frame rotates this object out of the upright axis; its position is exact, its orientation is not depicted";
+    if (state.fromFrame)
+      geo.frame = true;
+    if (approx)
+      geo.approx = approx;
+    return geo;
+  }
+  // issue #107 — a node's OWN placement relative to its parent frame: the
+  // Geometry-library coordinate-frame transformation if it declares one, else
+  // the flat x/y/z attributes, else nothing.
+  localPlacementOf(node, index2) {
+    const rot = this.numAttr(node, ["rotation", "yaw", "heading", "rotz"], index2);
+    const dims = {
+      placed: false,
+      hasZ: false,
+      fromFrame: false,
+      axisY: false,
+      rot,
+      sizeX: this.numAttr(node, ["length", "sizex", "dx", "extentx"], index2) ?? this.numAttr(node, ["baselength"], index2),
+      sizeY: this.numAttr(node, ["width", "sizey", "dy", "extenty"], index2) ?? this.numAttr(node, ["basewidth"], index2),
+      sizeZ: this.numAttr(node, ["height", "sizez", "dz", "depth", "extentz"], index2),
+      radius: this.numAttr(node, ["radius"], index2),
+      unit: this.unitAttr(node, ["x", "y", "z", "length", "width", "height", "radius"])
+    };
+    const frame2 = this.frameTransformOf(node, index2);
+    if (frame2.present) {
+      return {
+        ...dims,
+        placed: true,
+        hasZ: true,
+        fromFrame: true,
+        transform: frame2.transform,
+        approx: frame2.approx,
+        unit: dims.unit ?? frame2.unit,
+        sourcePath: frame2.sourcePath
+      };
+    }
+    const x = this.numAttr(node, ["x", "posx", "positionx"], index2);
+    const y = this.numAttr(node, ["y", "posy", "positiony", "lateral"], index2);
+    const z2 = this.numAttr(node, ["z", "posz", "positionz", "vertical", "elevation"], index2);
+    if (x === void 0 && y === void 0 && z2 === void 0)
+      return dims;
+    return {
+      ...dims,
+      placed: true,
+      hasZ: z2 !== void 0,
+      axisY: y !== void 0,
+      transform: translationTransform([x ?? 0, y ?? 0, z2 ?? 0])
+    };
+  }
+  // issue #107 — evaluate a SpatialItem's `coordinateFrame.transformation` into
+  // a rigid transform from the parent frame. `present` says the node declares
+  // its own frame at all — a frame WITHOUT a transformation is the identity
+  // (the library's own default), which is a placement, not a failure. A
+  // transformation the workspace cannot decide numerically returns no transform
+  // and a reason, and the caller places the object at the parent origin and
+  // marks it rather than dropping or misplacing it.
+  frameTransformOf(node, index2) {
+    const frame2 = this.ownFrameOf(node, index2);
+    if (!frame2)
+      return { present: false };
+    const unit = this.frameUnitOf(frame2, node, index2);
+    const trans = this.ownMemberNamed(frame2, "transformation");
+    if (!trans)
+      return { present: true, transform: IDENTITY_TRANSFORM, unit };
+    const sourceText = valueTextOf(this.ownMemberNamed(trans, "source"))?.trim();
+    const sourcePath = sourceText && /^[A-Za-z_'][\w'.:]*$/.test(sourceText) ? sourceText : void 0;
+    const resolve8 = this.geoResolver(node, index2);
+    const typeName = lastSeg(typeText(trans) ?? "").toLowerCase();
+    if (typeName === "nulltransformation")
+      return { present: true, transform: IDENTITY_TRANSFORM, unit, sourcePath };
+    const elementsText = valueTextOf(this.ownMemberNamed(trans, "elements")) ?? valueTextOf(trans);
+    const steps = parseConstructions(elementsText);
+    if (steps.length) {
+      let m = IDENTITY_TRANSFORM;
+      for (const step of steps) {
+        const t = this.constructionTransform(step, resolve8);
+        if (!t)
+          return { present: true, approx: `a \`${step.type}\` step of its frame transformation is not numerically decidable`, unit, sourcePath };
+        m = composeTransforms(m, t);
+      }
+      return { present: true, transform: m, unit, sourcePath };
+    }
+    const rotationMatrix = this.ownMemberNamed(trans, "rotationMatrix");
+    const rotElems = rotationMatrix ? evalValueExpr(valueTextOf(this.ownMemberNamed(rotationMatrix, "elements")) ?? valueTextOf(rotationMatrix), resolve8) : void 0;
+    const translationVector = this.ownMemberNamed(trans, "translationVector");
+    const transElems = translationVector ? evalValueExpr(valueTextOf(translationVector) ?? valueTextOf(this.ownMemberNamed(translationVector, "elements")), resolve8) : void 0;
+    const affine = affineTransform(Array.isArray(rotElems) ? rotElems : void 0, Array.isArray(transElems) ? transElems : void 0);
+    if (affine)
+      return { present: true, transform: affine, unit, sourcePath };
+    const origin = evalVector3Expr(valueTextOf(this.ownMemberNamed(trans, "origin")), resolve8);
+    if (origin) {
+      const basis2 = valueTextOf(this.ownMemberNamed(trans, "basisDirections"));
+      const reoriented = basis2 !== void 0 && basis2.trim() !== "()" && basis2.trim() !== "";
+      return {
+        present: true,
+        transform: translationTransform(origin),
+        approx: reoriented ? "its frame declares basisDirections; the position is exact, the re-orientation is not depicted" : void 0,
+        unit,
+        sourcePath
+      };
+    }
+    return { present: true, approx: "its coordinateFrame declares a transformation this workspace cannot evaluate", unit, sourcePath };
+  }
+  // issue #107 — one `new Translation(…)` / `new Rotation(…)` element.
+  constructionTransform(step, resolve8) {
+    const kind = step.type.toLowerCase();
+    if (kind === "translation") {
+      const v = evalVector3Expr(step.args[0], resolve8);
+      return v ? translationTransform(v) : void 0;
+    }
+    if (kind === "rotation") {
+      const intrinsic = step.args[2]?.trim();
+      if (intrinsic !== void 0 && intrinsic !== "" && intrinsic !== "true")
+        return void 0;
+      const axis = evalVector3Expr(step.args[0], resolve8);
+      const angle = evalScalarExpr(step.args[1], resolve8);
+      return axis && angle !== void 0 ? rotationTransform(axis, angle) : void 0;
+    }
+    return void 0;
+  }
+  // issue #107 — resolve a dotted feature path written inside `node`'s body
+  // (`xStrut.num`, `shape.width`, `(shape as Box).length`) to a number or a
+  // numeric vector. Names are searched from `node` outward through its
+  // containers, and at each level through the node's own members AND the
+  // members its type contributes, which is how an inherited library feature
+  // such as `shape` is found on a usage that never redeclares it.
+  geoResolver(node, index2, visiting = /* @__PURE__ */ new Set()) {
+    return (path10) => {
+      const segs = path10.length > 1 && path10[path10.length - 1].toLowerCase() === "num" ? path10.slice(0, -1) : [...path10];
+      if (!segs.length)
+        return void 0;
+      for (let cur = node; cur; cur = cur.$container) {
+        const found = this.lookupFeature(cur, segs, index2, /* @__PURE__ */ new Set());
+        if (found)
+          return this.featureValueOf(found, index2, visiting);
+        if (segs.length > 1) {
+          const owner = this.lookupFeature(cur, segs.slice(0, -1), index2, /* @__PURE__ */ new Set());
+          const arg = owner ? this.ctorArgValue(owner, segs[segs.length - 1], index2, visiting) : void 0;
+          if (arg !== void 0)
+            return arg;
+        }
+      }
+      return void 0;
+    };
+  }
+  // issue #107 — the value a positional shape construction gives to one named
+  // parameter (`new Box(l, w, h)` → `length` / `width` / `height`).
+  ctorArgValue(node, param, index2, visiting) {
+    const ctor = this.shapeCtorOf(node);
+    if (!ctor)
+      return void 0;
+    const at = ctor.params.indexOf(param.toLowerCase());
+    if (at < 0 || at >= ctor.args.length)
+      return void 0;
+    return evalValueExpr(ctor.args[at], this.geoResolver(node.$container ?? node, index2, visiting));
+  }
+  // issue #107 — a feature's value as a number or numeric vector: its own value
+  // expression, or the `elements` of a vector/array feature written as a body
+  // (`attribute plusXAxis : Array { :>> elements = (1, 0, 0); }`), or the
+  // positional arguments of a `new <Shape>(…)` construction.
+  featureValueOf(node, index2, visiting) {
+    if (visiting.has(node))
+      return void 0;
+    visiting.add(node);
+    try {
+      const text = valueTextOf(node);
+      const scope = node.$container ?? node;
+      if (text) {
+        const direct = evalValueExpr(text, this.geoResolver(scope, index2, visiting));
+        if (direct !== void 0)
+          return direct;
+      }
+      const elements = this.ownMemberNamed(node, "elements");
+      if (elements)
+        return this.featureValueOf(elements, index2, visiting);
+      return void 0;
+    } finally {
+      visiting.delete(node);
+    }
+  }
+  // issue #107 — the member reached by a dotted path from `scope`, following
+  // both owned members and the members contributed by the scope's type chain.
+  lookupFeature(scope, segs, index2, seen, skip) {
+    if (!segs.length || seen.has(scope) || seen.size > 24)
+      return void 0;
+    seen.add(scope);
+    const want = /* @__PURE__ */ new Set([segs[0].toLowerCase()]);
+    for (const owner of [scope, ...this.typeChainOf(scope, index2)]) {
+      for (const m of membersOf(owner)) {
+        if (m.isDef === true || skip?.has(m) || !this.attrMatches(m, want))
+          continue;
+        if (segs.length === 1)
+          return m;
+        const deeper = this.lookupFeature(m, segs.slice(1), index2, seen, skip);
+        if (deeper)
+          return deeper;
+      }
+    }
+    return void 0;
+  }
+  // The node's type definition and that definition's in-document supertypes.
+  typeChainOf(node, index2) {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let def = this.resolveType(node, index2);
+    while (def && !seen.has(def) && chain.length < 8) {
+      seen.add(def);
+      chain.push(def);
+      def = specializationTargets(def).map((s) => index2.get(s) ?? index2.get(lastSeg(s))).find((d) => !!d);
+    }
+    return chain;
+  }
+  // The first DIRECT member whose effective name (own name, or its `:>>`/`:>`
+  // target) is `name`. Deliberately not type-inherited: a SpatialItem inherits
+  // a default `coordinateFrame` from the library, and inheriting it here would
+  // read every SpatialItem as declaring its own frame.
+  ownMemberNamed(node, name) {
+    if (!node)
+      return void 0;
+    const want = /* @__PURE__ */ new Set([name.toLowerCase()]);
+    return membersOf(node).find((m) => m.isDef !== true && this.attrMatches(m, want));
+  }
+  // issue #107 — the node's own coordinate frame, allowing for the INDIRECTION
+  // the OMG car example uses: `Engine` names its frame
+  // `attribute <ecf> engineCoordinateFrame :>> coordinateFrame`, and a part
+  // typed by Engine then refines it as `:>> ecf { … }`. That member redefines
+  // `ecf`, not `coordinateFrame`, so the direct lookup misses it; the
+  // redefinition target is resolved and followed instead. Bounded, and it never
+  // reaches past a declaration that is not itself a frame.
+  ownFrameOf(node, index2) {
+    const direct = this.ownMemberNamed(node, "coordinateFrame");
+    if (direct)
+      return direct;
+    for (const m of membersOf(node)) {
+      if (m.isDef === true)
+        continue;
+      for (const target of redefinitionTargetsOf(m)) {
+        if (this.namesACoordinateFrame(node, target, index2, 0, /* @__PURE__ */ new Set([m])))
+          return m;
+      }
+    }
+    return void 0;
+  }
+  // Whether `name`, resolved from `scope`, denotes a declaration that is (or
+  // transitively redefines) the library's `coordinateFrame`.
+  namesACoordinateFrame(scope, name, index2, depth, skip) {
+    if (depth > 3)
+      return false;
+    if (name.toLowerCase() === "coordinateframe")
+      return true;
+    for (let cur = scope; cur; cur = cur.$container) {
+      const found = this.lookupFeature(cur, [name], index2, /* @__PURE__ */ new Set(), skip);
+      if (!found)
+        continue;
+      const next = /* @__PURE__ */ new Set([...skip, found]);
+      return redefinitionTargetsOf(found).some((t) => this.namesACoordinateFrame(cur, t, index2, depth + 1, next));
+    }
+    return false;
+  }
+  // REQ-205 / issue #107 — the part's drawable shape and its extents. The shape
+  // comes from the part's own type (a ShapeItems name or alias, directly or
+  // through the in-document specialization chain), else from the `shape` feature
+  // the Geometry library gives every SpatialItem — `item :>> shape : Cylinder {
+  // :>> radius = 18 [mm]; }` or `item :>> shape = new Box(4800, 1840, 1350)`.
+  shapeInfoOf(node, index2) {
+    const byType = this.shapeOf(node, index2);
+    const member = this.shapeMemberOf(node, index2, /* @__PURE__ */ new Set());
+    if (!member)
+      return byType ? { kind: byType } : void 0;
+    const kind = byType ?? this.shapeOf(member, index2) ?? this.shapeCtorOf(member)?.kind;
+    const info = { kind };
+    info.sizeX = this.numAttr(member, ["length", "sizex", "dx", "extentx"], index2) ?? this.numAttr(member, ["baselength"], index2);
+    info.sizeY = this.numAttr(member, ["width", "sizey", "dy", "extenty"], index2) ?? this.numAttr(member, ["basewidth"], index2);
+    info.sizeZ = this.numAttr(member, ["height", "sizez", "dz", "depth", "extentz"], index2);
+    info.radius = this.numAttr(member, ["radius"], index2);
+    const ctor = this.shapeCtorOf(member);
+    if (ctor) {
+      const resolve8 = this.geoResolver(member, index2);
+      for (const [i, param] of ctor.params.entries()) {
+        const v = evalScalarExpr(ctor.args[i], resolve8);
+        if (v === void 0)
+          continue;
+        if (param === "length")
+          info.sizeX ??= v;
+        else if (param === "width")
+          info.sizeY ??= v;
+        else if (param === "height")
+          info.sizeZ ??= v;
+        else if (param === "radius")
+          info.radius ??= v;
+      }
+    }
+    return info.kind !== void 0 || info.radius !== void 0 || info.sizeX !== void 0 ? info : void 0;
+  }
+  // The `shape` feature of a SpatialItem — declared on the usage, contributed by
+  // its type, or aliased to another part's shape (`item :>> shape = motorShape.shape`).
+  shapeMemberOf(node, index2, seen) {
+    if (seen.has(node) || seen.size > 8)
+      return void 0;
+    seen.add(node);
+    for (const owner of [node, ...this.typeChainOf(node, index2)]) {
+      const own = this.ownMemberNamed(owner, "shape");
+      if (!own)
+        continue;
+      const text = valueTextOf(own);
+      if (text && !parseConstructions(text).length && /^[A-Za-z_'][\w'.:]*$/.test(text.trim())) {
+        const segs = text.trim().split(/::|\./).filter(Boolean);
+        for (let cur = node; cur; cur = cur.$container) {
+          const target = this.lookupFeature(cur, segs, index2, /* @__PURE__ */ new Set());
+          if (target && target !== own)
+            return this.shapeMemberOf(target, index2, seen) ?? target;
+        }
+      }
+      return own;
+    }
+    return void 0;
+  }
+  // A `new <Shape>(…)` shape construction with a known positional signature.
+  shapeCtorOf(member) {
+    const ctor = parseConstructions(valueTextOf(member))[0];
+    if (!ctor)
+      return void 0;
+    const key = ctor.type.toLowerCase();
+    return {
+      kind: _SysmlDiagramModelProvider.SHAPE_TYPES[key],
+      params: _SysmlDiagramModelProvider.SHAPE_CTOR_ARGS[key] ?? [],
+      args: ctor.args
+    };
   }
   // REQ-205 — the part's shape from its type: a direct ShapeItems type name (or
   // alias), else the nearest in-document supertype that is a shape (the library
@@ -165730,22 +166584,42 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     return void 0;
   }
   // First attribute (case-insensitive name OR redefinition/subset target) on the
-  // node, with its numeric value parsed. Redefinition-aware because library-shape
-  // dimensions are usually set as `attribute :>> length = …` (anonymous), so the
-  // name is the `:>>` target, not the node name. Tolerates a `[unit]` suffix.
-  numAttr(node, names) {
+  // node, with its numeric value EVALUATED. Redefinition-aware because
+  // library-shape dimensions are usually set as `attribute :>> length = …`
+  // (anonymous), so the name is the `:>>` target, not the node name. Tolerates a
+  // `[unit]` suffix.
+  //
+  // The value is a full expression, not a literal — the OMG Geometry examples
+  // write `:>> radius = 22/2*25.4 + 110 [mm]`. Scanning for the first number in
+  // the text read that as `22`, off by more than an order of magnitude, and read
+  // every other arithmetic dimension just as wrongly. `evalScalarExpr` evaluates
+  // the supported arithmetic subset and returns `undefined` for
+  // anything it cannot decide (a function call, an unresolvable name), so an
+  // undecidable dimension falls back to the view's default extent instead of
+  // being drawn at a wrong one.
+  // issue #107 — the member is matched by its effective NAME and the presence of
+  // a value, not by its declared kind: the Geometry library writes a shape's
+  // dimensions as the bare redefinition shorthand `:>> radius = 18 [mm]`, which
+  // parses as a FeatureRedefinitionShorthand rather than an AttributeDecl, and
+  // requiring the `attribute` keyword read every library-style shape as
+  // dimensionless.
+  //
+  // With an `index`, a value that is not self-contained is retried against the
+  // surrounding model — `:>> radius = cylinder1.shape.radius` in the OMG engine
+  // example names a sibling's dimension rather than restating the number.
+  numAttr(node, names, index2) {
     const want = new Set(names.map((n2) => n2.toLowerCase()));
     for (const m of membersOf(node)) {
-      if (!isAttributeDecl(m) || m.isDef === true)
+      if (m.isDef === true)
         continue;
       if (!this.attrMatches(m, want))
         continue;
-      const text = m.value?.$cstNode?.text;
+      const text = valueTextOf(m);
       if (!text)
         continue;
-      const match = text.replace(/\s+/g, "").match(/-?\d+(?:\.\d+)?/);
-      if (match)
-        return Number(match[0]);
+      const v = evalScalarExpr(text) ?? (index2 ? evalScalarExpr(text, this.geoResolver(node, index2)) : void 0);
+      if (v !== void 0)
+        return v;
     }
     return void 0;
   }
@@ -165770,6 +166644,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const nm = nameOf2(m);
     if (nm && want.has(nm.toLowerCase()))
       return true;
+    const short = m.shortName?.name;
+    if (short && want.has(short.toLowerCase()))
+      return true;
     const rels = [...m.preRelationships ?? [], ...m.relationships ?? []];
     for (const rel2 of rels) {
       if (rel2.kind === ":>>" || rel2.kind === "redefines" || rel2.kind === ":>" || rel2.kind === "subsets") {
@@ -192057,6 +192934,14 @@ body {
 .dgeo3d-node.selected .dgeo3d-face { stroke: var(--accent); }
 .dgeo3d-node.selected .dgeo3d-face.top { fill: var(--accent); fill-opacity: 0.34; }
 .dgeo3d-name { fill: var(--fg-0); font-family: var(--font-mono); font-size: 10px; }
+/* REQ-205 \u2014 an object whose coordinate-frame transformation could not be fully
+   decided is DRAWN and MARKED, never silently misplaced: its outline goes dashed
+   and it carries a warning glyph whose tooltip names the reason. (The issue
+   number is left out of this comment on purpose \u2014 the theme gate reads a hash
+   followed by hex digits as a hardcoded colour.) */
+.dgeo-approx .dgeo3d-face, .dgeo-approx .dgeo3d-edge { stroke-dasharray: 4 3; }
+.dgeo-approx .dnode-rect { stroke-dasharray: 4 3; }
+.dgeo-approx-mark { fill: var(--yellow); font-family: var(--font-mono); font-size: 11px; cursor: help; }
 /* REQ-205 \u2014 React Flow Geometry View: the synthetic coordinate-frame node is
    background chrome \u2014 never a pointer target (pane clicks/box-select pass
    through); the placed shape nodes are click-to-reveal targets. */
@@ -193798,23 +194683,30 @@ function GeoShapeNode({ id: id2, data, selected: selected2 }) {
   const dim = useInteraction(ctx.store, (s) => s.matchedIds ? !s.matchedIds.has(id2) : false);
   const origin = data.origin;
   const iso = data.geo3d && node.geo && origin;
+  const approx = node.geo?.approx;
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
     "div",
     {
-      className: `rf-node rf-geo${selected2 ? " selected" : ""}`,
+      className: `rf-node rf-geo${selected2 ? " selected" : ""}${approx ? " dgeo-approx" : ""}`,
       style: { width: w, height: h, opacity: dim ? 0.18 : 1 },
       onContextMenu: (e) => {
         e.preventDefault();
         e.stopPropagation();
         ctx.onContextNode(id2, e.clientX, e.clientY);
       },
-      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { className: "rf-node-svg", width: w, height: h, style: { overflow: "visible" }, children: iso ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("g", { className: `dgeo3d-node${selected2 ? " selected" : ""}`, transform: `translate(${-origin.x},${-origin.y})`, children: geoShapeBody(node, data.geo3d) }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dgeo3d-name", x: w / 2, y: -3, textAnchor: "middle", children: node.name })
-      ] }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { className: `dnode-rect${selected2 ? " selected" : ""}`, x: 0, y: 0, width: w, height: h, rx: node.isDef ? 0 : 12 }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dnode-label", x: w / 2, y: h / 2 + 3, textAnchor: "middle", children: node.name })
-      ] }) })
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("svg", { className: "rf-node-svg", width: w, height: h, style: { overflow: "visible" }, children: [
+        iso ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("g", { className: `dgeo3d-node${selected2 ? " selected" : ""}`, transform: `translate(${-origin.x},${-origin.y})`, children: geoShapeBody(node, data.geo3d) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dgeo3d-name", x: w / 2, y: -3, textAnchor: "middle", children: node.name })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("rect", { className: `dnode-rect${selected2 ? " selected" : ""}`, x: 0, y: 0, width: w, height: h, rx: node.isDef ? 0 : 12 }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("text", { className: "dnode-label", x: w / 2, y: h / 2 + 3, textAnchor: "middle", children: node.name })
+        ] }),
+        approx ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("text", { className: "dgeo-approx-mark", x: w - 2, y: -3, textAnchor: "end", children: [
+          "\u26A0",
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("title", { children: `${node.name}: ${approx}` })
+        ] }) : null
+      ] })
     }
   );
 }
@@ -195473,7 +196365,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.6" : "dev";
+var VERSION2 = true ? "0.15.7" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;