sysml-diagram 0.28.1 → 0.29.0

package/out/main.js

@@ -162052,8 +162052,8 @@ var FeaturePathResolver = class {
       }
     }
     for (let owner = node.$container; owner; owner = owner.$container) {
-      const declaredName2 = owner.name;
-      if (typeof declaredName2 === "string" && canonicalEscapedName(declaredName2) === name && !isSelfReference(owner, node)) {
+      const declaredName3 = owner.name;
+      if (typeof declaredName3 === "string" && canonicalEscapedName(declaredName3) === name && !isSelfReference(owner, node)) {
         return this.targetForNode(owner, this.memberInventoryKnown(owner, snapshot));
       }
       if (boundVariableName(owner) === name)
@@ -162433,6 +162433,377 @@ function memberSeparator(owner) {
   return isDocument(owner) || isNamespaceOnlyDecl(owner) ? "::" : ".";
 }
 
+// ../language-server/out/src/services/name-lookup.js
+function unquoteName(name) {
+  return name.replace(/^'(.*)'$/u, "$1");
+}
+function pathSegments(path10) {
+  const segments = [];
+  let current2 = "";
+  let quoted = false;
+  for (let index2 = 0; index2 < path10.length; index2++) {
+    const char = path10[index2];
+    if (char === "'") {
+      quoted = !quoted;
+      current2 += char;
+      continue;
+    }
+    if (!quoted && char === ":" && path10[index2 + 1] === ":") {
+      segments.push(current2);
+      current2 = "";
+      index2++;
+      continue;
+    }
+    if (!quoted && char === ".") {
+      segments.push(current2);
+      current2 = "";
+      continue;
+    }
+    current2 += char;
+  }
+  segments.push(current2);
+  return segments;
+}
+function simpleNameOf(name) {
+  return pathSegments(name).at(-1) ?? name;
+}
+var ELEMENT_SEPARATOR = "\0";
+function elementKey(description) {
+  return `${description.documentUri.toString()}${ELEMENT_SEPARATOR}${description.path}`;
+}
+function isDeclaredSpelling(description) {
+  const kind = description.derivedKind;
+  if (kind === "reexport" || kind === "inherited")
+    return false;
+  return pathSegments(description.name).length === 1;
+}
+var SysmlNameLookup = class {
+  shared;
+  byName;
+  /** Element key → the declared spellings the index holds for that element. */
+  spellings;
+  constructor(shared) {
+    this.shared = shared;
+    this.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.byName = void 0;
+      this.spellings = void 0;
+    });
+  }
+  /** Every description indexed under `name`, in either spelling of an escaped name. */
+  descriptions(name) {
+    return this.index().get(name) ?? [];
+  }
+  /**
+   * The ONE element `name` names, or `undefined` when the answer is not
+   * certain: no element, or more than one. `accept` narrows the candidates
+   * before ambiguity is judged, so "the only CALLABLE called `f`" is a
+   * decidable question even where a part shares the name.
+   */
+  unique(name, accept) {
+    const candidates = this.descriptions(name).filter((candidate) => !accept || accept(candidate));
+    let found;
+    let key;
+    for (const candidate of candidates) {
+      const candidateKey = elementKey(candidate);
+      if (found === void 0) {
+        found = candidate;
+        key = candidateKey;
+        continue;
+      }
+      if (candidateKey !== key)
+        return void 0;
+    }
+    return found;
+  }
+  /**
+   * Resolve a written path: the spelling the index holds verbatim first, then
+   * its final segment. Both readings must name exactly one element.
+   */
+  uniqueForPath(path10, accept) {
+    return this.unique(path10, accept) ?? this.unique(simpleNameOf(path10), accept);
+  }
+  /**
+   * The declared spellings of the element `description` names — its regular
+   * name and its `<short>` name — minus `written`.
+   */
+  otherNames(description, written) {
+    const all = this.spellingIndex().get(elementKey(description)) ?? [];
+    const seen = unquoteName(written);
+    return all.filter((name) => unquoteName(name) !== seen);
+  }
+  index() {
+    if (!this.byName)
+      this.build();
+    return this.byName;
+  }
+  spellingIndex() {
+    if (!this.spellings)
+      this.build();
+    return this.spellings;
+  }
+  /** One pass over the index feeds both maps; neither is worth a second. */
+  build() {
+    const byName = /* @__PURE__ */ new Map();
+    const spellings = /* @__PURE__ */ new Map();
+    const add = (key, description) => {
+      const bucket = byName.get(key);
+      if (bucket)
+        bucket.push(description);
+      else
+        byName.set(key, [description]);
+    };
+    for (const description of this.shared.workspace.IndexManager.allElements()) {
+      add(description.name, description);
+      const unquoted = unquoteName(description.name);
+      if (unquoted !== description.name)
+        add(unquoted, description);
+      if (!isDeclaredSpelling(description))
+        continue;
+      const key = elementKey(description);
+      const names = spellings.get(key);
+      if (names) {
+        if (!names.includes(description.name))
+          names.push(description.name);
+      } else {
+        spellings.set(key, [description.name]);
+      }
+    }
+    this.byName = byName;
+    this.spellings = spellings;
+  }
+};
+var lookups = /* @__PURE__ */ new WeakMap();
+function nameLookupFor(shared) {
+  if (!shared)
+    return void 0;
+  const existing = lookups.get(shared);
+  if (existing)
+    return existing;
+  const created = new SysmlNameLookup(shared);
+  lookups.set(shared, created);
+  return created;
+}
+
+// ../language-server/out/src/services/effective-name.js
+var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var NO_CANDIDATES = [];
+var NO_RESOLVER = () => NO_CANDIDATES;
+var nameable = /* @__PURE__ */ new Map();
+function canBeNamed(node) {
+  const known2 = nameable.get(node.$type);
+  if (known2 !== void 0)
+    return known2;
+  let answer = false;
+  try {
+    answer = reflection2.getTypeMetaData(node.$type).properties.some((property3) => property3.name === "name");
+  } catch {
+    answer = false;
+  }
+  nameable.set(node.$type, answer);
+  return answer;
+}
+function declaredName(node) {
+  const value = node.name;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function declaredShortName(node) {
+  const value = node.shortName?.name;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function firstRedefinitionPath(node) {
+  const decl = node;
+  const groups = [decl.preRelationships, decl.relationships];
+  for (const group of groups) {
+    if (!Array.isArray(group))
+      continue;
+    for (const relationship of group) {
+      if (typeof relationship?.kind !== "string")
+        continue;
+      if (!REDEFINITION_KINDS.has(relationship.kind))
+        continue;
+      const targets = relationship.targets;
+      if (!Array.isArray(targets))
+        continue;
+      for (const target of targets) {
+        if (typeof target === "string" && target.length > 0)
+          return target;
+      }
+    }
+  }
+  return void 0;
+}
+function writtenNameOf(path10) {
+  const segment = simpleNameOf(path10).replace(/\s*\[[^\]]*\]\s*$/u, "").trim();
+  return segment.length > 0 ? segment : void 0;
+}
+var memos = /* @__PURE__ */ new WeakMap();
+function memoFor(resolver) {
+  const existing = memos.get(resolver);
+  if (existing)
+    return existing;
+  const created = /* @__PURE__ */ new WeakMap();
+  memos.set(resolver, created);
+  return created;
+}
+function effectiveNamesOf(node, resolver = NO_RESOLVER) {
+  const memo3 = memoFor(resolver);
+  const cached = memo3.get(node);
+  if (cached)
+    return cached;
+  const computed = derive(node, resolver, /* @__PURE__ */ new Set());
+  memo3.set(node, computed);
+  return computed;
+}
+function derive(node, resolver, seen) {
+  const name = declaredName(node);
+  const shortName = declaredShortName(node);
+  if (name !== void 0 || shortName !== void 0) {
+    return { name, shortName, origin: "declared" };
+  }
+  const path10 = canBeNamed(node) ? firstRedefinitionPath(node) : void 0;
+  if (path10 === void 0)
+    return { origin: "none" };
+  if (seen.has(node))
+    return { origin: "none", redefines: path10, problem: "cycle" };
+  seen.add(node);
+  try {
+    const inherited = resolveNames(path10, node, resolver, seen);
+    if (inherited?.problem) {
+      return { origin: "none", redefines: path10, problem: inherited.problem };
+    }
+    if (inherited?.name !== void 0 || inherited?.shortName !== void 0) {
+      return {
+        name: inherited.name,
+        shortName: inherited.shortName,
+        origin: "derived",
+        redefines: path10
+      };
+    }
+    const written = writtenNameOf(path10);
+    return written === void 0 ? { origin: "none", redefines: path10 } : { name: written, origin: "written", redefines: path10 };
+  } finally {
+    seen.delete(node);
+  }
+}
+function resolveNames(path10, from, resolver, seen) {
+  const candidates = resolver(path10, from);
+  if (candidates.length === 0)
+    return void 0;
+  let names;
+  for (const candidate of candidates) {
+    const resolved = candidate.node ? derive(candidate.node, resolver, seen) : { name: candidate.name, shortName: candidate.shortName, origin: "declared" };
+    if (resolved.problem)
+      return resolved;
+    if (resolved.name === void 0 && resolved.shortName === void 0)
+      continue;
+    if (!names) {
+      names = resolved;
+      continue;
+    }
+    if (differ(names.name, resolved.name) || differ(names.shortName, resolved.shortName)) {
+      return { origin: "none", problem: "ambiguous" };
+    }
+    names = {
+      name: names.name ?? resolved.name,
+      shortName: names.shortName ?? resolved.shortName,
+      origin: names.origin
+    };
+  }
+  return names;
+}
+function differ(left, right) {
+  return left !== void 0 && right !== void 0 && left !== right;
+}
+var localResolvers = /* @__PURE__ */ new WeakMap();
+function documentLocalResolver(root4) {
+  const existing = localResolvers.get(root4);
+  if (existing)
+    return existing;
+  let index2;
+  const resolver = (path10, from) => {
+    index2 ??= buildLocalNameIndex(root4);
+    const simple = writtenNameOf(path10) ?? path10;
+    const declared = index2.declared.qualified.get(path10) ?? index2.declared.simple.get(simple);
+    const found = declared?.filter((candidate) => candidate !== from) ?? [];
+    if (found.length > 0)
+      return found.map((node) => ({ node }));
+    if (path10 === simple)
+      return NO_CANDIDATES;
+    const nested = index2.effective.qualified.get(path10)?.filter((candidate) => candidate !== from);
+    return nested && nested.length > 0 ? nested.map((node) => ({ node })) : NO_CANDIDATES;
+  };
+  localResolvers.set(root4, resolver);
+  return resolver;
+}
+function localResolverFor(node) {
+  return documentLocalResolver(ast_utils_exports.findRootNode(node));
+}
+function emptyTier() {
+  return { qualified: /* @__PURE__ */ new Map(), simple: /* @__PURE__ */ new Map() };
+}
+function buildLocalNameIndex(root4) {
+  const index2 = { declared: emptyTier(), effective: emptyTier() };
+  const add = (map3, key, node) => {
+    const bucket = map3.get(key);
+    if (bucket) {
+      if (!bucket.includes(node))
+        bucket.push(node);
+    } else {
+      map3.set(key, [node]);
+    }
+  };
+  for (const node of ast_utils_exports.streamAllContents(root4)) {
+    if (node.$type === "ShortName" || node.$type === "ImportSeg")
+      continue;
+    const declared = [declaredName(node), declaredShortName(node)].filter((value) => value !== void 0);
+    const written = declared.length === 0 && canBeNamed(node) ? writtenNameOf(firstRedefinitionPath(node) ?? "") : void 0;
+    const tier = declared.length > 0 ? index2.declared : index2.effective;
+    for (const name of declared.length > 0 ? declared : [written].filter((v) => v !== void 0)) {
+      add(tier.simple, name, node);
+      for (const path10 of qualifiedPathsOf(node, name))
+        add(tier.qualified, path10, node);
+    }
+  }
+  return index2;
+}
+function qualifiedPathsOf(node, name) {
+  const owners = [];
+  for (let owner = node.$container; owner; owner = owner.$container) {
+    const ownerName = declaredName(owner) ?? declaredShortName(owner);
+    if (ownerName !== void 0)
+      owners.unshift(ownerName);
+  }
+  const paths = [];
+  for (let start2 = 0; start2 < owners.length; start2++) {
+    paths.push([...owners.slice(start2), name].join("::"));
+  }
+  return paths;
+}
+function indexResolver(lookup, astNode) {
+  if (!lookup)
+    return void 0;
+  return (path10) => {
+    const description = lookup.uniqueForPath(path10);
+    if (!description)
+      return NO_CANDIDATES;
+    const node = description.node ?? astNode?.(description);
+    return node ? [{ node }] : NO_CANDIDATES;
+  };
+}
+function chainResolvers(...resolvers) {
+  const active = resolvers.filter((resolver) => !!resolver);
+  if (active.length === 1)
+    return active[0];
+  return (path10, from) => {
+    for (const resolver of active) {
+      const found = resolver(path10, from);
+      if (found.length > 0)
+        return found;
+    }
+    return NO_CANDIDATES;
+  };
+}
+
 // ../language-server/out/src/services/diagram-model-provider.js
 var lastSeg = (name) => {
   const i = Math.max(name.lastIndexOf("::"), name.lastIndexOf("."));
@@ -162820,18 +163191,11 @@ var portionKindOf = (node) => modifiersOf(node).find((m) => m === "timeslice" ||
 var isIndividualOccurrence = (node) => modifiersOf(node).includes("individual");
 var isOccurrenceModified = (node) => portionKindOf(node) !== void 0 || isIndividualOccurrence(node);
 var redefinedNameOf = (node) => {
-  const n2 = node;
-  for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind === ":>>" || rel2.kind === "redefines") {
-      const target = (rel2.targets ?? [])[0];
-      if (target)
-        return lastSeg(target);
-    }
-  }
-  return void 0;
+  const names = effectiveNamesOf(node, localResolverFor(node));
+  return names.origin === "derived" || names.origin === "written" ? names.name ?? names.shortName : void 0;
 };
 var effectiveNameOf = (node) => nameOf2(node) ?? redefinedNameOf(node);
-var portionLabelOf = (node) => nameOf2(node) ?? (isOccurrenceModified(node) ? redefinedNameOf(node) : void 0);
+var portionLabelOf = (node) => effectiveNameOf(node);
 function diagramNodeId(node) {
   const name = nameOf2(node);
   if (name)
@@ -166878,10 +167242,10 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     };
     const emitFlowNode = (m, frameId, executionContext, occurrence, laneParts) => {
       const info = flowNodeInfo(m);
-      const declaredName2 = localFlowName(m);
+      const declaredName3 = localFlowName(m);
       const id2 = occurrence;
       idByNode.set(m, id2);
-      registerStep(occurrence, id2, [declaredName2]);
+      registerStep(occurrence, id2, [declaredName3]);
       if (info.shape === "action" || info.shape === "send" || info.shape === "accept")
         actionCount++;
       const pins = actionPinsOf(m, id2);
@@ -166913,9 +167277,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         source: sourceOf2(m, uri),
         meta: {
           ...occurrenceEditMeta(occurrence),
-          ...declaredName2 ? {
-            declarationId: qnameOf(m) || declaredName2,
-            declarationName: declaredName2,
+          ...declaredName3 ? {
+            declarationId: qnameOf(m) || declaredName3,
+            declarationName: declaredName3,
             declarationSource: sourceOf2(m, uri)
           } : {},
           ...isPromotablePerform(m) ? { promotablePerform: true } : {},
@@ -167027,9 +167391,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         return;
       }
       const id2 = occurrence;
-      const declaredName2 = localFlowName(action);
+      const declaredName3 = localFlowName(action);
       idByNode.set(action, id2);
-      registerStep(occurrence, id2, [declaredName2]);
+      registerStep(occurrence, id2, [declaredName3]);
       if (content !== action) {
         idByNode.set(content, id2);
         if (isPartDecl(this.declaringOwnerOf(action)) && nameOf2(content)) {
@@ -167044,7 +167408,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       registerPins(action, id2, pins, false);
       frames.push({
         id: id2,
-        label: declaredName2 ?? (action.$type === "PerformStmt" ? performLabel(action) : lastSeg(id2)),
+        label: declaredName3 ?? (action.$type === "PerformStmt" ? performLabel(action) : lastSeg(id2)),
         keyword: keywordFor(action),
         parent: parentFrameId,
         isDef: action.isDef === true,
@@ -167056,9 +167420,9 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         meta: {
           compositeAction: true,
           ...isPromotablePerform(action) ? { promotablePerform: true } : {},
-          ...declaredName2 ? {
-            declarationId: qnameOf(action) || declaredName2,
-            declarationName: declaredName2,
+          ...declaredName3 ? {
+            declarationId: qnameOf(action) || declaredName3,
+            declarationName: declaredName3,
             declarationSource: sourceOf2(action, uri)
           } : {},
           // REQ-196 — the body a lane added here writes its `perform` against.
@@ -171174,7 +171538,7 @@ function outlineGroupForType(astType) {
 
 // ../language-server/out/src/services/document-symbol-provider.js
 var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", "specializes"]);
-var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
   "AttributeDecl",
@@ -171215,7 +171579,10 @@ function symbolNameFor(node) {
     return "rep";
   }
   const redefined = redefinitionTargets(node)[0];
-  return redefined ? `:>> ${lastNameSegment(redefined)}` : void 0;
+  if (!redefined)
+    return void 0;
+  const effective = effectiveNamesOf(node, localResolverFor(node));
+  return `:>> ${effective.name ?? effective.shortName ?? lastNameSegment(redefined)}`;
 }
 function isDefinitionNode2(node) {
   return node.isDef === true;
@@ -171251,7 +171618,7 @@ function redefinitionTargets(node) {
   const n2 = node;
   const out = [];
   for (const rel2 of [...n2.preRelationships ?? [], ...n2.relationships ?? []]) {
-    if (rel2.kind && REDEFINITION_KINDS.has(rel2.kind))
+    if (rel2.kind && REDEFINITION_KINDS2.has(rel2.kind))
       out.push(...rel2.targets ?? []);
   }
   return out;
@@ -171343,6 +171710,11 @@ function locallyDeclaredOrRedefinedFeatureNames(node) {
     for (const target of redefinitionTargets(child)) {
       names.add(lastNameSegment(target));
     }
+    const effective = effectiveNamesOf(child, localResolverFor(child));
+    if (effective.name)
+      names.add(effective.name);
+    if (effective.shortName)
+      names.add(effective.shortName);
   }
   return names;
 }
@@ -171560,11 +171932,22 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
 // ../language-server/out/src/services/name-provider.js
 var SysmlNameProvider = class extends DefaultNameProvider {
   getName(node) {
-    return super.getName(node) ?? this.shortNameOf(node);
+    return super.getName(node) ?? this.shortNameOf(node) ?? this.effectiveNameOf(node);
   }
+  /**
+   * REQ-404 — deliberately NOT extended to the effective name. There is no
+   * text to select, and a rename that reported one would offer to edit a name
+   * the declaration never writes.
+   */
   getNameNode(node) {
     return super.getNameNode(node) ?? this.shortNameNodeOf(node);
   }
+  // REQ-404 — one shared derivation (effective-name.ts), resolved against this
+  // document's declarations; the same answer scope computation indexes.
+  effectiveNameOf(node) {
+    const names = effectiveNamesOf(node, localResolverFor(node));
+    return names.origin === "derived" || names.origin === "written" ? names.name ?? names.shortName : void 0;
+  }
   shortNameOf(node) {
     const value = node.shortName?.name;
     return typeof value === "string" && value.length > 0 ? value : void 0;
@@ -171590,21 +171973,21 @@ function getDimensionTable() {
 function isDimensionTableLoaded() {
   return table !== void 0;
 }
-function unquoteName(name) {
+function unquoteName2(name) {
   return name.replace(/^'(.*)'$/, "$1");
 }
 function lastSegment2(name) {
   const idx = name.lastIndexOf("::");
-  return unquoteName(idx >= 0 ? name.slice(idx + 2) : name);
+  return unquoteName2(idx >= 0 ? name.slice(idx + 2) : name);
 }
 function directUnitDimension(symbol) {
   if (!table)
     return void 0;
-  const unquoted = unquoteName(symbol);
+  const unquoted = unquoteName2(symbol);
   return table.unitDims[unquoted] ?? table.unitDims[lastSegment2(unquoted)];
 }
 function isDirectKnownUnit(symbol) {
-  const unquoted = unquoteName(symbol);
+  const unquoted = unquoteName2(symbol);
   return unitSymbolSet.has(unquoted) || unitSymbolSet.has(lastSegment2(unquoted));
 }
 function unitDimension(symbol) {
@@ -171625,7 +172008,7 @@ function unitQuantityKind(symbol) {
 function unitQuantityKinds(symbol) {
   if (!table)
     return [];
-  const unquoted = unquoteName(symbol);
+  const unquoted = unquoteName2(symbol);
   const kinds = table.unitKind[unquoted] ?? table.unitKind[lastSegment2(unquoted)];
   if (Array.isArray(kinds))
     return kinds;
@@ -171692,7 +172075,7 @@ function superscript(n2) {
   return String(n2).split("").map((c) => SUPERSCRIPT[c] ?? c).join("");
 }
 function compoundUnitDimension(symbol) {
-  const factors = splitUnitFactors(unquoteName(symbol));
+  const factors = splitUnitFactors(unquoteName2(symbol));
   if (!factors)
     return void 0;
   const parsed = factors.map((factor) => ({ op: factor.op, factor: parseUnitFactor(factor.text) }));
@@ -171828,7 +172211,7 @@ function contextUnitDimension(symbol, ctx) {
   const directLocal = ctx.unitDim?.(lastSegment2(symbol));
   if (directLocal)
     return resultDimension(directLocal);
-  const factors = splitUnitFactors(unquoteName(symbol));
+  const factors = splitUnitFactors(unquoteName2(symbol));
   if (!factors || factors.length === 0)
     return void 0;
   let result = {};
@@ -171849,7 +172232,7 @@ function contextUnitDimension(symbol, ctx) {
 function isKnownUnitInContext(symbol, ctx) {
   if (ctx.unitDim?.(lastSegment2(symbol)))
     return true;
-  const factors = splitUnitFactors(unquoteName(symbol));
+  const factors = splitUnitFactors(unquoteName2(symbol));
   return !!factors && factors.length > 0 && factors.every((token) => {
     const factor = parseUnitFactor(token.text);
     return !!factor && (!!ctx.unitDim?.(lastSegment2(factor.name)) || isDirectKnownUnit(factor.name));
@@ -172061,7 +172444,7 @@ function isComparison(op) {
   return op === "==" || op === "!=" || op === "===" || op === "!==" || op === "<" || op === ">" || op === "<=" || op === ">=";
 }
 function reportUnknownUnit(node, property3, symbol, ctx) {
-  const display2 = unquoteName(symbol);
+  const display2 = unquoteName2(symbol);
   const suggestions = nearestUnits(display2, 3);
   const hint = suggestions.length > 0 ? ` Did you mean ${suggestions.map((s) => `'${s}'`).join(", ")}?` : "";
   ctx.issues.push({
@@ -172308,6 +172691,16 @@ var DIAGNOSTIC_MESSAGES = {
   // there, and rewriting it is mechanical — the import keeps working exactly
   // as it did, since a root import was never re-exported to begin with.
   RES021_ROOT_IMPORT_VISIBILITY: (visibility) => `An import in a file's root namespace must be 'private' \u2014 nothing can import the root namespace, so '${visibility}' re-exports to no one.`,
+  // REQ-404 — issue #155. OMG SysML v2 Part 1 §7.6.5 (Usage Names) derives the
+  // names of an unnamed redefining usage from the feature it redefines. Two
+  // things stop that derivation dead: a chain that comes back to the usage
+  // itself, and a target answered by elements that do not agree on the name.
+  // Neither may be settled by picking one, because the name decides what the
+  // feature IS - what it shadows, what resolves to it, what the diagram draws.
+  // The fix is in the source: give the usage a name of its own, or write the
+  // redefinition target so it names one feature.
+  RES022_EFFECTIVE_NAME_CYCLE: (target) => `This usage declares no name, and the redefinition of '${target}' leads back to it, so it has no name to take. Name the usage, or redefine a feature outside the cycle.`,
+  RES022_EFFECTIVE_NAME_AMBIGUOUS: (target) => `This usage declares no name, and '${target}' is answered by elements with different names, so which name it takes is undecided. Name the usage, or qualify the redefinition target.`,
   // issue #153 — OMG SysML v2 Part 1 §7.5.4 (Filtered Packages) puts an element
   // filter in a package, where it restricts that package's imported memberships;
   // a view body is the one other place it is defined for (it restricts what the
@@ -172620,6 +173013,15 @@ function identificationLabel(node) {
     return `<${shortName}>`;
   return node.name;
 }
+function effectiveIdentificationLabel(node) {
+  const names = effectiveNamesOf(node, localResolverFor(node));
+  if (names.problem)
+    return void 0;
+  const name = names.name ?? names.shortName;
+  if (!name)
+    return void 0;
+  return names.shortName && names.shortName !== name ? `<${names.shortName}> ${name}` : name;
+}
 function typingLabel(typing) {
   if (!typing)
     return "";
@@ -172695,7 +173097,7 @@ function declarationLine(node) {
   const named2 = node;
   const dir = directionLabel(node);
   const kind = kindLabel(node);
-  const name = identificationLabel(named2) ?? "(anonymous)";
+  const name = identificationLabel(named2) ?? effectiveIdentificationLabel(named2) ?? "(anonymous)";
   const typing = typingLabel(named2.typing);
   const mult = multiplicityLabel(node);
   const rels = relationshipLabel(allRelationships(named2));
@@ -172952,7 +173354,7 @@ function buildHoverMarkdown(node, relationshipDetails, documentation) {
   const named2 = node;
   const dir = directionLabel(node);
   const kind = kindLabel(node);
-  const name = identificationLabel(named2) ?? "(anonymous)";
+  const name = identificationLabel(named2) ?? effectiveIdentificationLabel(named2) ?? "(anonymous)";
   const typing = typingLabel(named2.typing);
   const mult = multiplicityLabel(node);
   const multHint = multiplicityPlainEnglish(node);
@@ -174295,7 +174697,7 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   qualifiedNameFor(desc) {
     if (desc.name.includes("::"))
       return desc.name;
-    const candidates = this.qualifiedNamesByElement().get(elementKey(desc));
+    const candidates = this.qualifiedNamesByElement().get(elementKey2(desc));
     return candidates?.find((name) => simpleName(name) === desc.name);
   }
   // REQ-245, REQ-268 — An element's qualified names, shortest first, keyed by
@@ -174311,7 +174713,7 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
       for (const desc of this.indexManager.allElements()) {
         if (!desc.name.includes("::"))
           continue;
-        const key = elementKey(desc);
+        const key = elementKey2(desc);
         const names = byElement.get(key);
         if (names)
           names.push(desc.name);
@@ -174556,7 +174958,7 @@ function isPackageBody(prefix) {
     return true;
   return /\bpackage\s+(?:<[^>]+>\s*)?[\p{L}_'][^;{}]*$/u.test(prefix.slice(Math.max(0, open - 160), open));
 }
-function elementKey(desc) {
+function elementKey2(desc) {
   return `${desc.documentUri.toString()}#${desc.path}#${desc.type}`;
 }
 function isArrowInvocableName(name) {
@@ -174614,7 +175016,7 @@ function isDefined(value) {
 }
 function nodeName(node) {
   const value = node?.name;
-  return typeof value === "string" && value.length > 0 ? unquoteName2(value) : void 0;
+  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
 }
 function nodeMembers(node) {
   const members = node?.members;
@@ -174633,7 +175035,7 @@ function receiverSteps(receiver) {
   let match;
   while ((match = pattern.exec(receiver)) !== null) {
     steps.push({
-      text: unquoteName2(match[2]),
+      text: unquoteName3(match[2]),
       separator: steps.length === 0 ? void 0 : match[1]
     });
   }
@@ -174690,7 +175092,7 @@ function simpleName(name) {
   if (!name)
     return void 0;
   const parts = name.split(/::|\./u);
-  return unquoteName2(parts.at(-1) ?? name);
+  return unquoteName3(parts.at(-1) ?? name);
 }
 function importCovers(text, importPath) {
   const packagePath = importPath.split("::").slice(0, -1).join("::");
@@ -174805,7 +175207,7 @@ function importSortKey(line2) {
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function unquoteName2(name) {
+function unquoteName3(name) {
   return name.replace(/^'(.*)'$/u, "$1");
 }
 function unitInsertText(symbol) {
@@ -175410,7 +175812,7 @@ function selectMemberships(path10, form, globalDescriptions) {
   const index2 = GlobalDescriptionIndex.from(globalDescriptions);
   const entries = [];
   if (form.includesSelf) {
-    const simple = simpleNameOf(path10);
+    const simple = simpleNameOf2(path10);
     const self2 = index2.named(path10).find((desc) => form.importAll || !isPrivateDescription(desc));
     if (self2)
       entries.push({ name: simple, targetName: self2.name, description: self2 });
@@ -175429,7 +175831,7 @@ function selectMemberships(path10, form, globalDescriptions) {
   }
   return entries;
 }
-function simpleNameOf(path10) {
+function simpleNameOf2(path10) {
   return path10.includes("::") ? path10.slice(path10.lastIndexOf("::") + 2) : path10;
 }
 function isOwnedMembership(desc) {
@@ -176063,7 +176465,7 @@ var ConformanceModel = class {
 };
 
 // ../language-server/out/src/services/validator.js
-var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([
+var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([
   ":>>",
   "redefines",
   ":>",
@@ -176301,7 +176703,7 @@ var SysmlValidator = class _SysmlValidator {
   // inventory completely. A later segment depends on the KerML semantic model
   // this resolver does not evaluate.
   checkRelationshipTargets(node, accept) {
-    if (!node.kind || !REDEFINITION_KINDS2.has(node.kind))
+    if (!node.kind || !REDEFINITION_KINDS3.has(node.kind))
       return;
     for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
       const resolution = this.featurePaths.resolvePropertyPath(node, "targets", ordinal);
@@ -177702,6 +178104,7 @@ ${baseIndent}}`;
     for (const decl of decls) {
       this.checkCyclicSpecialization(decl, index2, accept);
       this.checkSelfContainment(decl, accept);
+      this.checkEffectiveName(decl, accept);
     }
     for (const stmt of verifyStmts)
       this.checkRelationshipTargetKind(stmt, stmt.target, "verify", index2, aliasMap, accept);
@@ -178336,6 +178739,30 @@ ${baseIndent}}`;
     "PrefixMetadataMember",
     "MetadataAnnotation"
   ]);
+  /**
+   * REQ-404 — RES022: an unnamed redefining usage whose effective name cannot
+   * be derived (issue #155).
+   *
+   * OMG SysML v2 Part 1 §7.6.5 gives such a usage the names of the feature its
+   * first owned redefinition names. Two shapes leave it nameless: a chain that
+   * returns to the usage, and a target answered by elements that disagree
+   * about the name. Both are reported rather than settled, because a name
+   * decides what the feature shadows, what resolves to it and what a diagram
+   * draws it as - a picked one would read as authoritative and be wrong.
+   *
+   * A usage that writes any name of its own is not in question, and a target
+   * that simply does not resolve is not either: the written spelling stands,
+   * and an unresolvable path is RES001's to report.
+   */
+  checkEffectiveName(decl, accept) {
+    if (declName(decl) !== void 0 || shortNameOf(decl) !== void 0)
+      return;
+    const names = effectiveNamesOf(decl, localResolverFor(decl));
+    if (!names.problem)
+      return;
+    const target = names.redefines ?? "";
+    accept(severity("RES022", "error"), names.problem === "cycle" ? DIAGNOSTIC_MESSAGES.RES022_EFFECTIVE_NAME_CYCLE(target) : DIAGNOSTIC_MESSAGES.RES022_EFFECTIVE_NAME_AMBIGUOUS(target), { node: decl, code: "RES022" });
+  }
   // REQ-378 — RES017: indistinguishable members within a namespace (issue #183).
   //
   // KerML's validateNamespaceDistinguishability (Pilot KerMLValidator.checkNamespace)
@@ -180053,7 +180480,10 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
           result.push({
             ...ownAliases[0],
             name,
-            derived: start2 > 0 || separator === "." || void 0
+            derived: start2 > 0 || separator === "." || void 0,
+            // REQ-404 — a path THROUGH an effective name is itself
+            // derived from a redefinition, however it is spelled.
+            effective: suffix.some((segment) => segment.aliases.every((alias) => alias.effective)) || void 0
           });
         }
       }
@@ -180073,13 +180503,18 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
     this.addAlias(aliases, seen, node.name, this.nameNodeOf(node));
     const shortName = node.shortName;
     this.addAlias(aliases, seen, shortName?.name, grammar_utils_exports.findNodeForProperty(shortName?.$cstNode, "name"));
+    const effective = effectiveNamesOf(node, localResolverFor(node));
+    if (effective.origin !== "declared" && effective.origin !== "none") {
+      this.addAlias(aliases, seen, effective.name, void 0, true);
+      this.addAlias(aliases, seen, effective.shortName, void 0, true);
+    }
     return aliases;
   }
-  addAlias(aliases, seen, value, cstNode) {
+  addAlias(aliases, seen, value, cstNode, effective = false) {
     if (typeof value !== "string" || value.length === 0 || seen.has(value))
       return;
     seen.add(value);
-    aliases.push({ name: value, cstNode });
+    aliases.push({ name: value, cstNode, ...effective ? { effective: true } : {} });
   }
   nameNodeOf(node) {
     return grammar_utils_exports.findNodeForProperty(node.$cstNode, "name");
@@ -180091,6 +180526,10 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
       ...visibility ? { visibility } : {},
       ...visibility === "private" ? { isPrivate: true } : {},
       ...alias.derived ? { isDerivedAlias: true, derivedKind: "relative" } : {},
+      // REQ-404 — issue #155: the name is the model's, not the text's, so
+      // auto-import must not offer it as a written spelling. It still names
+      // an OWNED member, so a recursive import descends through it.
+      ...alias.effective ? { isDerivedAlias: true, derivedKind: "effective" } : {},
       // REQ-242 — issue #103 — mirrors what the precomputed library index
       // records, so consumers read def-ness the same way for workspace and
       // library symbols.
@@ -180327,7 +180766,7 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
   // comparison is against `oldName` directly.
   *writtenPathSegments(root4, oldName) {
     const matching = (segments) => segments.filter((segment) => segment.text === oldName);
-    const spellsName = (path10) => !!path10 && pathSegments(path10).some((step) => canonicalEscapedName(step) === oldName);
+    const spellsName = (path10) => !!path10 && pathSegments2(path10).some((step) => canonicalEscapedName(step) === oldName);
     for (const node of [root4, ...ast_utils_exports.streamAllContents(root4)]) {
       if (isPathExpr(node)) {
         if (!spellsName(node.path))
@@ -180402,7 +180841,7 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     return this.references.findDeclaration(leafNode);
   }
 };
-function pathSegments(path10) {
+function pathSegments2(path10) {
   const out = [];
   let current2 = "";
   let quoted = false;
@@ -181857,157 +182296,6 @@ var SysmlSemanticTokenProvider = class extends AbstractSemanticTokenProvider {
 // ../language-server/out/src/services/inlay-hint-provider.js
 var import_vscode_languageserver20 = __toESM(require_main4(), 1);
 
-// ../language-server/out/src/services/name-lookup.js
-function unquoteName3(name) {
-  return name.replace(/^'(.*)'$/u, "$1");
-}
-function pathSegments2(path10) {
-  const segments = [];
-  let current2 = "";
-  let quoted = false;
-  for (let index2 = 0; index2 < path10.length; index2++) {
-    const char = path10[index2];
-    if (char === "'") {
-      quoted = !quoted;
-      current2 += char;
-      continue;
-    }
-    if (!quoted && char === ":" && path10[index2 + 1] === ":") {
-      segments.push(current2);
-      current2 = "";
-      index2++;
-      continue;
-    }
-    if (!quoted && char === ".") {
-      segments.push(current2);
-      current2 = "";
-      continue;
-    }
-    current2 += char;
-  }
-  segments.push(current2);
-  return segments;
-}
-function simpleNameOf2(name) {
-  return pathSegments2(name).at(-1) ?? name;
-}
-var ELEMENT_SEPARATOR = "\0";
-function elementKey2(description) {
-  return `${description.documentUri.toString()}${ELEMENT_SEPARATOR}${description.path}`;
-}
-function isDeclaredSpelling(description) {
-  const kind = description.derivedKind;
-  if (kind === "reexport" || kind === "inherited")
-    return false;
-  return pathSegments2(description.name).length === 1;
-}
-var SysmlNameLookup = class {
-  shared;
-  byName;
-  /** Element key → the declared spellings the index holds for that element. */
-  spellings;
-  constructor(shared) {
-    this.shared = shared;
-    this.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
-      this.byName = void 0;
-      this.spellings = void 0;
-    });
-  }
-  /** Every description indexed under `name`, in either spelling of an escaped name. */
-  descriptions(name) {
-    return this.index().get(name) ?? [];
-  }
-  /**
-   * The ONE element `name` names, or `undefined` when the answer is not
-   * certain: no element, or more than one. `accept` narrows the candidates
-   * before ambiguity is judged, so "the only CALLABLE called `f`" is a
-   * decidable question even where a part shares the name.
-   */
-  unique(name, accept) {
-    const candidates = this.descriptions(name).filter((candidate) => !accept || accept(candidate));
-    let found;
-    let key;
-    for (const candidate of candidates) {
-      const candidateKey = elementKey2(candidate);
-      if (found === void 0) {
-        found = candidate;
-        key = candidateKey;
-        continue;
-      }
-      if (candidateKey !== key)
-        return void 0;
-    }
-    return found;
-  }
-  /**
-   * Resolve a written path: the spelling the index holds verbatim first, then
-   * its final segment. Both readings must name exactly one element.
-   */
-  uniqueForPath(path10, accept) {
-    return this.unique(path10, accept) ?? this.unique(simpleNameOf2(path10), accept);
-  }
-  /**
-   * The declared spellings of the element `description` names — its regular
-   * name and its `<short>` name — minus `written`.
-   */
-  otherNames(description, written) {
-    const all = this.spellingIndex().get(elementKey2(description)) ?? [];
-    const seen = unquoteName3(written);
-    return all.filter((name) => unquoteName3(name) !== seen);
-  }
-  index() {
-    if (!this.byName)
-      this.build();
-    return this.byName;
-  }
-  spellingIndex() {
-    if (!this.spellings)
-      this.build();
-    return this.spellings;
-  }
-  /** One pass over the index feeds both maps; neither is worth a second. */
-  build() {
-    const byName = /* @__PURE__ */ new Map();
-    const spellings = /* @__PURE__ */ new Map();
-    const add = (key, description) => {
-      const bucket = byName.get(key);
-      if (bucket)
-        bucket.push(description);
-      else
-        byName.set(key, [description]);
-    };
-    for (const description of this.shared.workspace.IndexManager.allElements()) {
-      add(description.name, description);
-      const unquoted = unquoteName3(description.name);
-      if (unquoted !== description.name)
-        add(unquoted, description);
-      if (!isDeclaredSpelling(description))
-        continue;
-      const key = elementKey2(description);
-      const names = spellings.get(key);
-      if (names) {
-        if (!names.includes(description.name))
-          names.push(description.name);
-      } else {
-        spellings.set(key, [description.name]);
-      }
-    }
-    this.byName = byName;
-    this.spellings = spellings;
-  }
-};
-var lookups = /* @__PURE__ */ new WeakMap();
-function nameLookupFor(shared) {
-  if (!shared)
-    return void 0;
-  const existing = lookups.get(shared);
-  if (existing)
-    return existing;
-  const created = new SysmlNameLookup(shared);
-  lookups.set(shared, created);
-  return created;
-}
-
 // ../language-server/out/src/services/callable-resolver.js
 var CALLABLE_TYPES = /* @__PURE__ */ new Set([
   "CalcDecl",
@@ -182034,7 +182322,7 @@ var CallableResolver = class {
    * candidate only when it is the ONLY element with that name.
    */
   candidates(name) {
-    const simple = simpleNameOf2(name);
+    const simple = simpleNameOf(name);
     return (this.lookup?.descriptions(simple) ?? []).filter((description) => CALLABLE_TYPES.has(description.type));
   }
   /**
@@ -182050,7 +182338,7 @@ var CallableResolver = class {
     const root4 = document2.parseResult?.value;
     if (!root4)
       return void 0;
-    return collectCallables([root4, ...ast_utils_exports.streamAllContents(root4).toArray()]).get(unquoteName3(simpleNameOf2(name)));
+    return collectCallables([root4, ...ast_utils_exports.streamAllContents(root4).toArray()]).get(unquoteName(simpleNameOf(name)));
   }
   /**
    * SYNCHRONOUS resolution: a qualified spelling the index holds verbatim,
@@ -182066,7 +182354,7 @@ var CallableResolver = class {
       if (node)
         return node;
     }
-    const found = local ? local(unquoteName3(simpleNameOf2(name))) : this.findLocal(document2, name);
+    const found = local ? local(unquoteName(simpleNameOf(name))) : this.findLocal(document2, name);
     if (found)
       return found;
     const candidate = this.uniqueCandidate(name);
@@ -182163,11 +182451,11 @@ function isAstNode3(value) {
 }
 function nodeName2(node) {
   const value = node?.name;
-  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+  return typeof value === "string" && value.length > 0 ? unquoteName(value) : void 0;
 }
 function shortNameOf2(node) {
   const value = node?.shortName?.name;
-  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+  return typeof value === "string" && value.length > 0 ? unquoteName(value) : void 0;
 }
 function typingText(node) {
   const text = node?.typing?.type?.$refText;
@@ -182236,7 +182524,7 @@ var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   "crosses",
   "conjugates"
 ]);
-var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
@@ -182471,6 +182759,15 @@ var SysmlInlayHintProvider = class {
    * the index is rebuilt.
    */
   declaredNameCache = /* @__PURE__ */ new Map();
+  /**
+   * REQ-404 — issue #155: the effective-name resolver for one document, built
+   * once so the shared derivation memoizes across the whole request instead of
+   * once per hint. It reads the document's own declarations first and the
+   * workspace index second, which is what lets a redefinition of a feature in
+   * ANOTHER file, written by that feature's `<short>` name, still print the
+   * regular name. Dropped with the other index-generation caches.
+   */
+  effectiveNameResolvers = /* @__PURE__ */ new WeakMap();
   constructor(services) {
     this.services = services;
     this.lookup = nameLookupFor(services?.shared);
@@ -182480,8 +182777,18 @@ var SysmlInlayHintProvider = class {
       this.baseCache.clear();
       this.constantCache.clear();
       this.declaredNameCache.clear();
+      this.effectiveNameResolvers = /* @__PURE__ */ new WeakMap();
     });
   }
+  /** REQ-404 — issue #155: the shared effective-name derivation for `root`. */
+  effectiveNameResolver(root4) {
+    const existing = this.effectiveNameResolvers.get(root4);
+    if (existing)
+      return existing;
+    const created = chainResolvers(documentLocalResolver(root4), indexResolver(this.lookup, (description) => this.linker?.resolveIndexedNode?.(description)));
+    this.effectiveNameResolvers.set(root4, created);
+    return created;
+  }
   getInlayHints(document2, _params) {
     const root4 = document2.parseResult?.value;
     if (!root4 || !sysmlInlayHintSettings.enabled)
@@ -182564,7 +182871,7 @@ var SysmlInlayHintProvider = class {
       if (settings.redefinition)
         hints.push(...this.parameterRedefinitionHints(decl));
       if (settings.effectiveNames) {
-        const effective = effectiveNameHint(decl);
+        const effective = effectiveNameHint(decl, this.effectiveNameResolver(root4));
         if (effective)
           hints.push(effective);
       }
@@ -182631,7 +182938,7 @@ var SysmlInlayHintProvider = class {
       const parameter = mine[index2].node;
       if (!parameter.name || !parameter.$cstNode)
         continue;
-      if (allRelationships2(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS3.has(rel2.kind)))
+      if (allRelationships2(parameter).some((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind)))
         continue;
       const target = theirs[index2].node;
       if (!target.name || target.name === parameter.name)
@@ -182693,7 +183000,7 @@ var SysmlInlayHintProvider = class {
    * has more than one name, and memoized until the index is rebuilt.
    */
   declaredNames(description) {
-    const key = elementKey2(description);
+    const key = elementKey(description);
     const cached = this.declaredNameCache.get(key);
     if (cached)
       return cached;
@@ -182860,7 +183167,7 @@ var SysmlInlayHintProvider = class {
     const description = this.lookup.uniqueForPath(target);
     if (!description)
       return false;
-    const key = elementKey2(description);
+    const key = elementKey(description);
     const cached = this.constantCache.get(key);
     if (cached !== void 0)
       return cached;
@@ -182901,25 +183208,26 @@ var SysmlInlayHintProvider = class {
     return fallback;
   }
 };
-function effectiveNameHint(node) {
+function effectiveNameHint(node, resolver) {
   if (node.name || node.shortName?.name || !node.$cstNode)
     return void 0;
-  const redefinition = allRelationships2(node).find((rel2) => rel2.kind && REDEFINITION_KINDS3.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
-  const target = redefinition?.targets?.[0];
-  if (!target)
+  const redefinition = allRelationships2(node).find((rel2) => rel2.kind && REDEFINITION_KINDS4.has(rel2.kind) && (rel2.targets?.length ?? 0) > 0);
+  if (!redefinition?.targets?.[0])
     return void 0;
-  const effective = lastSegment3(target);
-  if (!effective)
+  const names = effectiveNamesOf(node, resolver);
+  const effective = names.name ?? names.shortName;
+  if (!effective || names.problem)
     return void 0;
-  const operator = cst_utils_exports.flattenCst(node.$cstNode).find((leaf) => !leaf.hidden && redefinition?.kind !== void 0 && leaf.text === redefinition.kind);
+  const operator = cst_utils_exports.flattenCst(node.$cstNode).find((leaf) => !leaf.hidden && redefinition.kind !== void 0 && leaf.text === redefinition.kind);
   if (!operator)
     return void 0;
+  const short = names.shortName && names.shortName !== effective ? ` It is also known by the short name \`<${names.shortName}>\`.` : "";
   return {
     position: operator.range.start,
     label: effective,
     kind: import_vscode_languageserver20.InlayHintKind.Parameter,
     paddingRight: true,
-    tooltip: markdown(`Effective name: \`${effective}\`, taken from the feature this one redefines.`)
+    tooltip: markdown(`Effective name: \`${effective}\`, taken from the feature this one redefines.${short}`)
   };
 }
 
@@ -184187,7 +184495,7 @@ function buildIdNameIndex(value, sourceName) {
     const id2 = stringValue(object["@id"]);
     if (!id2)
       return;
-    const declared = declaredName(object);
+    const declared = declaredName2(object);
     if (declared) {
       out.set(id2, safeName(declared));
     } else if (!out.has(id2)) {
@@ -184204,7 +184512,7 @@ function renderJsonElement(element, context, depth) {
   if (!spec)
     return [];
   const indent = "    ".repeat(depth);
-  const rawName = declaredName(element) ?? (element["@id"] ? fallbackNameFromId(String(element["@id"])) : void 0) ?? `${context.sourceName}_${context.seen.size}`;
+  const rawName = declaredName2(element) ?? (element["@id"] ? fallbackNameFromId(String(element["@id"])) : void 0) ?? `${context.sourceName}_${context.seen.size}`;
   const name = safeName(rawName);
   const children2 = ownedRenderableChildren(element);
   const tail = declarationTail(element, context);
@@ -184283,7 +184591,7 @@ function referenceName(value, context) {
     const id2 = stringValue(value["@id"]);
     if (id2 && context.idToName.has(id2))
       return context.idToName.get(id2);
-    const name = declaredName(value) ?? stringValue(value.qualifiedName);
+    const name = declaredName2(value) ?? stringValue(value.qualifiedName);
     if (name)
       return safeQualifiedName(name);
     return referenceName(value.target, context);
@@ -184351,7 +184659,7 @@ function dedupeJsonElements(elements) {
   }
   return out;
 }
-function declaredName(value) {
+function declaredName2(value) {
   return firstString(value.declaredName, value.name, value.effectiveName, value.qualifiedName);
 }
 function firstString(...values2) {
@@ -205479,7 +205787,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.28.1" : "dev";
+var VERSION2 = true ? "0.29.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;