sysml-diagram 0.28.0 → 0.29.0

package/out/main.js

@@ -161786,6 +161786,14 @@ function directNamedChildren(node) {
   }
   return result;
 }
+function boundVariableName(node) {
+  if (!node || node.$type !== "ForLoopNode" && node.$type !== "AcceptNode")
+    return void 0;
+  const binding = node;
+  if (binding.varSegs?.length)
+    return void 0;
+  return typeof binding.varName === "string" && binding.varName.length > 0 ? canonicalEscapedName(binding.varName) : void 0;
+}
 function isAncestor(candidate, node) {
   if (!candidate)
     return false;
@@ -161798,7 +161806,25 @@ function isAncestor(candidate, node) {
 function isSelfReference(candidate, node) {
   if (!candidate || !isAncestor(candidate, node))
     return false;
-  return !isPackage(candidate) && candidate.$type !== "NamespaceDecl";
+  if (candidate === node)
+    return true;
+  if (isPackage(candidate) || candidate.$type === "NamespaceDecl")
+    return false;
+  const initializer = candidate.value;
+  if (initializer && isAncestor(initializer, node))
+    return true;
+  const header = candidate;
+  if (typeof header.name === "string" && header.name.length > 0)
+    return false;
+  for (const part of [
+    ...header.preRelationships ?? [],
+    ...header.relationships ?? [],
+    ...header.typing ? [header.typing] : []
+  ]) {
+    if (isAncestor(part, node))
+      return true;
+  }
+  return false;
 }
 function lastSegment(path10) {
   return path10.split(/::|\./u).pop() ?? path10;
@@ -161872,7 +161898,8 @@ var FeaturePathResolver = class {
     let current2 = this.resolveRoot(node, segments[0].text, snapshot);
     this.applyTarget(segments[0], current2);
     if (!current2.node && !current2.description) {
-      return { segments, indeterminateIndex: 0 };
+      const under = node.$type === "Relationship" || node.$type === "LeadingRelationship" ? node : void 0;
+      return this.lexicalInventoryComplete(node, snapshot, under) ? { segments, unresolvedIndex: 0 } : { segments, indeterminateIndex: 0 };
     }
     for (let index2 = 1; index2 < segments.length; index2 += 1) {
       const segment = segments[index2];
@@ -162025,12 +162052,77 @@ var FeaturePathResolver = class {
       }
     }
     for (let owner = node.$container; owner; owner = owner.$container) {
+      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)
+        return this.targetForNode(owner, true);
       const local = directNamedChildren(owner).find((candidate) => nameOf(candidate) === name && !isSelfReference(candidate, node));
       if (local)
         return this.targetForNode(local, this.memberInventoryKnown(local, snapshot));
+      for (const inheritedOwner of this.typedAndSpecializedOwners(owner, snapshot)) {
+        const inherited = directNamedChildren(inheritedOwner).find((candidate) => nameOf(candidate) === name && !isSelfReference(candidate, node));
+        if (inherited) {
+          return this.targetForNode(inherited, this.memberInventoryKnown(inherited, snapshot));
+        }
+      }
     }
     return this.targetFromDescriptions(snapshot.byName.get(name), node);
   }
+  // REQ-317 — issue #259. Whether the scope chain around `node` has a member
+  // inventory this resolver can enumerate COMPLETELY. A type or supertype it
+  // could not resolve carries members it cannot list, so a name missing from
+  // what it can see is then no proof the name is absent, and reporting it
+  // would be a false positive rather than a diagnosis.
+  //
+  // `under` is the relationship whose own target is being resolved. It is the
+  // claim under test, so it must not also count as evidence that the scope is
+  // unknowable — otherwise every unresolved target would silence the very
+  // check that should report it.
+  lexicalInventoryComplete(node, snapshot, under) {
+    for (let owner = node.$container; owner; owner = owner.$container) {
+      if (this.inheritsImplicitly(owner, snapshot, under))
+        return false;
+      if (!this.declaredTypesResolve(owner, snapshot, under))
+        return false;
+      for (const inheritedOwner of this.typedAndSpecializedOwners(owner, snapshot)) {
+        if (!this.declaredTypesResolve(inheritedOwner, snapshot, under))
+          return false;
+      }
+    }
+    return true;
+  }
+  // issue #259 — OMG SysML gives a case its single `objective` and `subject`,
+  // so a usage of a typed case IMPLICITLY redefines the one its definition
+  // declares, whatever either is named, and inherits that one's members
+  // (`verify vehicleMassRequirement :>> massRequirement` reaches
+  // `massRequirement` through exactly that). This resolver does not evaluate
+  // implicit redefinition, so where one applies it cannot enumerate the scope
+  // and must not call a name absent.
+  inheritsImplicitly(node, snapshot, under) {
+    if (node.$type !== "ObjectiveDecl" && node.$type !== "SubjectDecl")
+      return false;
+    if (this.typedAndSpecializedOwners(node, snapshot).length > 0)
+      return false;
+    const owner = node.$container;
+    return !!owner && (this.typedAndSpecializedOwners(owner, snapshot).length > 0 || !this.declaredTypesResolve(owner, snapshot, under));
+  }
+  // Every type and specialization target this element WRITES resolves to a node
+  // whose own members are readable. An unresolved one is an unknown inventory.
+  declaredTypesResolve(node, snapshot, under) {
+    const record = node;
+    if (record.typing?.type?.$refText && !this.typingTarget(node, snapshot))
+      return false;
+    const declared = [
+      ...record.preRelationships ?? [],
+      ...record.relationships ?? []
+    ].filter((relation) => relation !== under && relation.kind && SPECIALIZATION_KINDS.has(relation.kind));
+    if (declared.length === 0)
+      return true;
+    const written = declared.reduce((total, relation) => total + (relation.targets?.length ?? 0), 0);
+    return this.specializationTargets(node, snapshot).length >= written;
+  }
   resolveChild(current2, name, segments, index2, snapshot) {
     const owner = this.followAlias(current2, snapshot);
     if (owner.node) {
@@ -162341,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("."));
@@ -162728,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)
@@ -165304,16 +165760,16 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       };
       const performedActions = depth < 8 && !(typeQ !== void 0 && seenTypes.has(typeQ)) ? effectiveMembersOf(part).filter((m) => m.$type === "PerformStmt" && !!nameOf2(m)).map((act) => {
         const pinSource = this.performTargetOf(act, index2) ?? act;
-        const pathSegments2 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
+        const pathSegments3 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
         return {
           act,
           pinSource,
-          pathSegments: pathSegments2,
-          name: pathSegments2.at(-1) ?? nameOf2(act),
+          pathSegments: pathSegments3,
+          name: pathSegments3.at(-1) ?? nameOf2(act),
           key: concretePerformPath(act, pinSource)
         };
       }).filter((entry, i, list) => list.findIndex((other) => other.key === entry.key) === i) : [];
-      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments2, name, key }) => {
+      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments3, name, key }) => {
         const id2 = `${instanceId}::__perform_${key}`;
         const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
         const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
@@ -165321,7 +165777,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           act,
           name,
           id: id2,
-          pathSegments: pathSegments2,
+          pathSegments: pathSegments3,
           pins: this.actionPinPorts(pinSource, id2, index2, uri),
           meta: {
             ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
@@ -166786,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);
@@ -166821,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 } : {},
@@ -166935,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)) {
@@ -166952,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,
@@ -166964,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.
@@ -171082,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",
@@ -171123,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;
@@ -171159,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;
@@ -171251,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;
 }
@@ -171433,7 +171897,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
         continue;
       }
       let groupStart = -1;
-      let groupEnd = -1;
       let startLine = -1;
       let endLine = -1;
       const flushGroup = () => {
@@ -171445,7 +171908,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
           });
         }
         groupStart = -1;
-        groupEnd = -1;
         startLine = -1;
         endLine = -1;
       };
@@ -171457,7 +171919,6 @@ var SysmlFoldingRangeProvider = class extends DefaultFoldingRangeProvider {
             groupStart = i;
             startLine = range.start.line;
           }
-          groupEnd = i;
           endLine = range.end.line;
         } else {
           flushGroup();
@@ -171471,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;
@@ -171501,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) {
@@ -171536,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;
@@ -171603,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) }));
@@ -171739,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 = {};
@@ -171760,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));
@@ -171972,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({
@@ -172219,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
@@ -172531,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 "";
@@ -172606,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));
@@ -172863,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);
@@ -174206,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
@@ -174222,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);
@@ -174467,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) {
@@ -174525,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;
@@ -174544,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]
     });
   }
@@ -174601,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("::");
@@ -174716,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) {
@@ -174812,7 +175303,7 @@ function evaluateFilterCondition(condition, element, options) {
   return value.kind === "boolean" ? value.value : void 0;
 }
 function extensionFor(ctx) {
-  const ext = (node, evaluate2) => {
+  const ext = (node, _evaluate) => {
     switch (node.$type) {
       case "SelfClassifyExpr":
         return classify(node, ctx);
@@ -175321,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 });
@@ -175340,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) {
@@ -175974,6 +176465,22 @@ var ConformanceModel = class {
 };
 
 // ../language-server/out/src/services/validator.js
+var REDEFINITION_KINDS3 = /* @__PURE__ */ new Set([
+  ":>>",
+  "redefines",
+  ":>",
+  "subsets",
+  "specializes"
+]);
+function isBoundReferencePart(node) {
+  let declaration = node.$container;
+  while (declaration && !isPartDecl(declaration))
+    declaration = declaration.$container;
+  if (!declaration)
+    return false;
+  const modifiers2 = declaration.modifiers ?? [];
+  return modifiers2.includes("ref");
+}
 var severityOverrides = {};
 function severity(code, defaultSeverity) {
   return severityOverrides[code] ?? defaultSeverity;
@@ -176172,15 +176679,11 @@ var SysmlValidator = class _SysmlValidator {
   // dispatches `checkPathExpr`, so without a shared decision the two would drift
   // and a body would quietly escape a diagnostic the surrounding model receives.
   featurePathFault(node) {
-    let declaration = node.$container;
-    while (declaration && !isPartDecl(declaration))
-      declaration = declaration.$container;
-    const modifiers2 = declaration?.modifiers ?? [];
-    if (!declaration || !modifiers2.includes("ref"))
-      return void 0;
     const resolution = this.featurePaths.resolve(node);
     if (resolution.unresolvedIndex === void 0)
       return void 0;
+    if (resolution.unresolvedIndex > 0 && !isBoundReferencePart(node))
+      return void 0;
     const invalid = resolution.segments[resolution.unresolvedIndex];
     return {
       segment: invalid.text,
@@ -176188,6 +176691,28 @@ var SysmlValidator = class _SysmlValidator {
       range: invalid.cst.range
     };
   }
+  // REQ-317 — issue #259. A redefinition or subsetting target is a written path
+  // too (`attribute :>> maxMass`, `attribute other :> maxMass`), and the grammar
+  // stores it as a plain `RelationPath` STRING rather than a Langium
+  // cross-reference, so nothing else can diagnose it either: a target that names
+  // nothing linked silently, and the model kept a relationship to an element that
+  // does not exist.
+  //
+  // Only the ROOT segment is judged, on the same terms `checkPathExpr` uses: the
+  // resolver reports an absent root only when it could enumerate the surrounding
+  // inventory completely. A later segment depends on the KerML semantic model
+  // this resolver does not evaluate.
+  checkRelationshipTargets(node, accept) {
+    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);
+      if (resolution.unresolvedIndex !== 0)
+        continue;
+      const invalid = resolution.segments[0];
+      accept(severity("RES001", "error"), DIAGNOSTIC_MESSAGES.RES001_FEATURE_PATH_SEGMENT(invalid.text, "the current scope"), { node, range: invalid.cst.range, code: "RES001", data: { featurePathSegment: true } });
+    }
+  }
   // REQ-389 — Namespace qualification versus feature chaining in every written path
   // issue #213 — RES019: `::` binds tighter than `.`. Each dot-separated link of
   // a KerML FeatureChain is a complete QualifiedName, and an
@@ -177579,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);
@@ -178213,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)
@@ -178753,6 +179303,10 @@ ${baseIndent}}`;
       Document: this.checkDocument.bind(this),
       PartDecl: this.checkPartDecl.bind(this),
       PathExpr: this.checkPathExpr.bind(this),
+      // issue #259 — the same absent-name rule on a redefinition or
+      // subsetting target, which is a written path string as well.
+      Relationship: this.checkRelationshipTargets.bind(this),
+      LeadingRelationship: this.checkRelationshipTargets.bind(this),
       // issue #213 — RES019: the `::` vs `.` rule on the reference-form
       // declarations that reach their target through OwnedReferenceSubsetting.
       PerformStmt: this.checkChainSeparators.bind(this),
@@ -179926,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
           });
         }
       }
@@ -179946,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");
@@ -179964,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.
@@ -180110,9 +180676,13 @@ var SysmlLinker = class extends DefaultLinker {
 // ../language-server/out/src/services/rename-provider.js
 var SysmlRenameProvider = class extends DefaultRenameProvider {
   langiumDocuments;
+  locator;
+  featurePaths;
   constructor(services) {
     super(services);
     this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    this.locator = services.workspace.AstNodeLocator;
+    this.featurePaths = new FeaturePathResolver(services);
   }
   // REQ-261 — reject a rename request whose cursor resolves to a library
   // declaration: such a symbol has no meaningful "prepare rename" range
@@ -180131,7 +180701,8 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     const target = this.resolveDeclarationAt(document2, params.position);
     if (target && isLibraryDocument(ast_utils_exports.getDocument(target)))
       return void 0;
-    const edit = await super.rename(document2, { ...params, newName: encodeUnrestrictedName(params.newName) }, cancelToken);
+    const newName = encodeUnrestrictedName(params.newName);
+    const edit = await super.rename(document2, { ...params, newName }, cancelToken);
     if (!edit?.changes)
       return edit;
     const changes = {};
@@ -180141,8 +180712,121 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
         continue;
       changes[uri] = textEdits;
     }
+    if (target)
+      this.addWrittenPathEdits(changes, target, newName);
     return { ...edit, changes };
   }
+  // issue #255 — the references Langium cannot see. An expression operand
+  // (`require constraint { maxMass > 0 }`) and a redefinition or subsetting
+  // target (`attribute :>> maxMass`) are written as PLAIN PATH STRINGS in the
+  // grammar (PathExpr / RelationPath), not as Langium cross-references, so
+  // `findReferences` reports none of them and a rename left every one of them
+  // spelling the old name.
+  //
+  // They are resolved here the same way go-to-definition resolves them
+  // (`FeaturePathResolver`, the one path-resolution rule in the server), and a
+  // segment is edited ONLY when it resolves to this exact declaration. Matching
+  // by resolution rather than by spelling is what keeps a same-named feature of
+  // another element untouched.
+  // REQ-262 — Rename: workspace edit, library not renamable
+  addWrittenPathEdits(changes, declaration, newName) {
+    const oldName = canonicalEscapedName(declaration.name ?? "");
+    if (!oldName)
+      return;
+    const spelledVerbatim = encodeUnrestrictedName(oldName) === oldName;
+    for (const doc of this.langiumDocuments.all) {
+      if (isLibraryDocument(doc))
+        continue;
+      const root4 = doc.parseResult?.value;
+      if (!root4)
+        continue;
+      if (spelledVerbatim && !doc.textDocument.getText().includes(oldName))
+        continue;
+      const uri = doc.uri.toString();
+      const edits = changes[uri] ?? [];
+      const claimed = new Set(edits.map((edit) => `${edit.range.start.line}:${edit.range.start.character}`));
+      const added = [];
+      for (const segment of this.writtenPathSegments(root4, oldName)) {
+        const resolved = this.resolvedNodeOf(segment);
+        if (!resolved || !this.denotes(resolved, declaration))
+          continue;
+        const key = `${segment.cst.range.start.line}:${segment.cst.range.start.character}`;
+        if (claimed.has(key))
+          continue;
+        claimed.add(key);
+        added.push({ range: segment.cst.range, newText: newName });
+      }
+      if (added.length)
+        changes[uri] = [...edits, ...added];
+    }
+  }
+  // Every written-path segment of one document that SPELLS the old name. The
+  // spelling test comes first because resolving a path is the expensive half.
+  // `FeaturePathResolver` already canonicalises each segment it returns, so the
+  // comparison is against `oldName` directly.
+  *writtenPathSegments(root4, oldName) {
+    const matching = (segments) => segments.filter((segment) => segment.text === 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))
+          continue;
+        yield* matching(this.featurePaths.resolve(node).segments);
+        continue;
+      }
+      if (!isRelationship(node) && !isLeadingRelationship(node))
+        continue;
+      for (let ordinal = 0; ordinal < node.targets.length; ordinal += 1) {
+        if (!spellsName(node.targets[ordinal]))
+          continue;
+        yield* matching(this.featurePaths.resolvePropertyPath(node, "targets", ordinal).segments);
+      }
+    }
+  }
+  // An anonymous redefinition (`attribute :>> maxMass = 1500.0;`) declares NO
+  // name of its own — it carries the name of what it redefines. A later
+  // `other :> maxMass` in the same body therefore resolves to that redefinition
+  // rather than to the original declaration, yet it still spells the renamed
+  // name and still has to be rewritten. Follow the redefinition chain, which is
+  // exactly the chain the name itself travels.
+  denotes(node, declaration, seen = /* @__PURE__ */ new Set()) {
+    if (node === declaration)
+      return true;
+    if (seen.has(node))
+      return false;
+    seen.add(node);
+    const own = node.name;
+    if (typeof own === "string" && own.length > 0)
+      return false;
+    const relational = node;
+    for (const relationship of [
+      ...relational.preRelationships ?? [],
+      ...relational.relationships ?? []
+    ]) {
+      if (relationship.kind !== ":>>" && relationship.kind !== "redefines")
+        continue;
+      const targets = relationship.targets ?? [];
+      for (let ordinal = 0; ordinal < targets.length; ordinal += 1) {
+        const segments = this.featurePaths.resolvePropertyPath(relationship, "targets", ordinal).segments;
+        const last2 = segments[segments.length - 1];
+        const resolved = last2 ? this.resolvedNodeOf(last2) : void 0;
+        if (resolved && this.denotes(resolved, declaration, seen))
+          return true;
+      }
+    }
+    return false;
+  }
+  resolvedNodeOf(segment) {
+    if (segment.target)
+      return segment.target;
+    const description = segment.description;
+    if (!description)
+      return void 0;
+    if (description.node)
+      return description.node;
+    const root4 = this.langiumDocuments.getDocument(description.documentUri)?.parseResult.value;
+    return root4 ? this.locator.getAstNode(root4, description.path) : void 0;
+  }
   // Mirrors DefaultRenameProvider's own leaf-node → declaration resolution
   // (langium/src/lsp/rename-provider.ts) so the library check runs against
   // the SAME target prepareRename/rename would otherwise act on.
@@ -180157,6 +180841,39 @@ var SysmlRenameProvider = class extends DefaultRenameProvider {
     return this.references.findDeclaration(leafNode);
   }
 };
+function pathSegments2(path10) {
+  const out = [];
+  let current2 = "";
+  let quoted = false;
+  for (let at = 0; at < path10.length; at += 1) {
+    const ch = path10[at];
+    if (quoted) {
+      current2 += ch;
+      if (ch === "\\" && at + 1 < path10.length) {
+        current2 += path10[at + 1];
+        at += 1;
+      } else if (ch === "'") {
+        quoted = false;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      quoted = true;
+      current2 += ch;
+    } else if (ch === ":" && path10[at + 1] === ":") {
+      out.push(current2);
+      current2 = "";
+      at += 1;
+    } else if (ch === ".") {
+      out.push(current2);
+      current2 = "";
+    } else {
+      current2 += ch;
+    }
+  }
+  out.push(current2);
+  return out;
+}
 
 // ../language-server/out/src/services/code-action-provider.js
 var import_vscode_languageserver18 = __toESM(require_main4(), 1);
@@ -181579,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 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 simpleNameOf2(name) {
-  return pathSegments(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 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 = 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",
@@ -181756,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));
   }
   /**
@@ -181772,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,
@@ -181788,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);
@@ -181885,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;
@@ -181958,7 +182524,7 @@ var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   "crosses",
   "conjugates"
 ]);
-var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var REDEFINITION_KINDS4 = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
   ":>",
   "subsets",
@@ -182193,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);
@@ -182202,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)
@@ -182286,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);
       }
@@ -182353,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_KINDS2.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)
@@ -182415,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;
@@ -182582,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;
@@ -182623,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_KINDS2.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}`)
   };
 }
 
@@ -183909,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)) {
@@ -183926,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);
@@ -184005,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);
@@ -184073,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) {
@@ -185248,7 +185834,26 @@ function compartmentWidth(node) {
   }
   return w;
 }
+var RELATIONSHIP_COMPARTMENTS = /* @__PURE__ */ new Set([
+  "connections",
+  "interfaces",
+  "flows",
+  "state transition",
+  "successions"
+]);
+function withoutRelationshipCompartments(carrier) {
+  const comps = carrier.compartments;
+  if (!comps?.some((compartment) => RELATIONSHIP_COMPARTMENTS.has(compartment.title))) return carrier;
+  const kept = comps.filter((compartment) => !RELATIONSHIP_COMPARTMENTS.has(compartment.title));
+  return { ...carrier, compartments: kept.length ? kept : void 0 };
+}
+function frameForCanvas(frame2) {
+  return withoutRelationshipCompartments(frame2);
+}
 function nodeForCanvas(node) {
+  return withoutRelationshipCompartments(nodeBlockForCanvas(node));
+}
+function nodeBlockForCanvas(node) {
   if (node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true) {
     const compartments2 = node.compartments?.filter((compartment) => compartment.title === "doc" || compartment.title === "flows");
     return {
@@ -185782,7 +186387,7 @@ function hideExplicitRelationshipBoxes(model, relationship) {
     bindings: explicitRelationshipBindings(usage, model),
     endCount: usage.ports?.length ?? 0
   }));
-  const blocksCompaction = ({ usage, endCount }) => (nodeForCanvas(usage).compartments ?? []).some((compartment) => endCount !== 2 || compartment.title !== "flows");
+  const blocksCompaction = ({ usage, endCount }) => (nodeBlockForCanvas(usage).compartments ?? []).some((compartment) => endCount !== 2 || compartment.title !== "flows");
   const retainedIds = new Set(projections.filter((projection2) => blocksCompaction(projection2) || annotatedUsageIds.has(projection2.usage.id) || projection2.endCount < 2 || projection2.bindings.length !== projection2.endCount).map(({ usage }) => usage.id));
   const hiddenIds = /* @__PURE__ */ new Set();
   for (const { usage } of projections) {
@@ -186365,10 +186970,11 @@ function modelToFlow(model, opts) {
   const visualDepth = (frame2) => frameDepth(frame2.id) + (visualPerformerParent.has(frame2.id) ? 1 : 0);
   const orderedFrames = [...frames].sort((a2, b) => visualDepth(a2) - visualDepth(b));
   for (const f of orderedFrames) {
-    const natural = frameMinSize(f);
-    const featureH = frameFeatureCompartmentHeight(f);
-    const frameHeaderHeight = isBehaviorPartitionLane(f) ? performerLaneHeaderHeight(f) : structuredControlHeaderHeight(f);
-    const frameBottomHeight = frameBottomCompartmentHeight(f);
+    const canvasFrame = frameForCanvas(f);
+    const natural = frameMinSize(canvasFrame);
+    const featureH = frameFeatureCompartmentHeight(canvasFrame);
+    const frameHeaderHeight = isBehaviorPartitionLane(canvasFrame) ? performerLaneHeaderHeight(canvasFrame) : structuredControlHeaderHeight(canvasFrame);
+    const frameBottomHeight = frameBottomCompartmentHeight(canvasFrame);
     const size = sizeWithOverride(
       natural,
       ov[f.layoutKey ?? f.id],
@@ -186380,7 +186986,7 @@ function modelToFlow(model, opts) {
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
-        frame: f,
+        frame: canvasFrame,
         layoutKey: f.layoutKey ?? f.id,
         ports: isBehaviorPartitionLane(f) ? [] : assignPortHandles(f.ports, opts.portOverrides),
         w: size.w,
@@ -186422,7 +187028,7 @@ function modelToFlow(model, opts) {
       position: { x: 0, y: 0 },
       data: {
         kind: model.kind,
-        frame: boundary,
+        frame: frameForCanvas(boundary),
         layoutKey: boundary.layoutKey ?? boundary.id,
         ports: assignPortHandles(boundary.ports, opts.portOverrides),
         w: size.w,
@@ -203679,7 +204285,6 @@ function PortGlyph({ ph, w, h, topReserve = 0, showLabels, selected: selected2,
   const x = rect.cx;
   const y = rect.cy;
   const half = rect.across / 2;
-  const size = rect.across;
   const d = ph.port.direction;
   const v = ph.side === "top" ? { x: 0, y: -1 } : ph.side === "bottom" ? { x: 0, y: 1 } : ph.side === "left" ? { x: -1, y: 0 } : { x: 1, y: 0 };
   const perp = { x: -v.y, y: v.x };
@@ -205182,7 +205787,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.28.0" : "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;