sysml-diagram 0.24.0 → 0.26.0

package/out/main.js

@@ -162649,7 +162649,12 @@ function keywordFor(node) {
     JoinNode: "join",
     TerminateNode: "terminate",
     PerformStmt: "perform action",
-    EventDecl: "event occurrence"
+    EventDecl: "event occurrence",
+    // REQ-198, issue #113: a state sub-action drawn as a state-transition
+    // node keeps the keyword that says WHEN it runs (OMG 8.2.2.18.1).
+    EntryAction: "entry action",
+    DoAction: "do action",
+    ExitAction: "exit action"
   };
   if (t === "ActionDecl" && n2.inlineBody?.$type === "AcceptNode") {
     return "accept action";
@@ -165264,16 +165269,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 pathSegments = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
+        const pathSegments2 = this.isAnonymousBehaviorReference(act) ? this.featurePaths.resolveDeclarationPath(act).segments.map((segment) => segment.text) : [nameOf2(act)];
         return {
           act,
           pinSource,
-          pathSegments,
-          name: pathSegments.at(-1) ?? nameOf2(act),
+          pathSegments: pathSegments2,
+          name: pathSegments2.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, name, key }) => {
+      const performedActionInfos = performedActions.map(({ act, pinSource, pathSegments: pathSegments2, name, key }) => {
         const id2 = `${instanceId}::__perform_${key}`;
         const inheritedFromDefinition = !!localUsage && !isAstDescendantOrSelf(act, localUsage);
         const syncDeclaration2 = this.synchronizationDeclarationOf(act, index2);
@@ -165281,7 +165286,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           act,
           name,
           id: id2,
-          pathSegments,
+          pathSegments: pathSegments2,
           pins: this.actionPinPorts(pinSource, id2, index2, uri),
           meta: {
             ...ivEditMeta(act, id2, void 0, localUsage, [...localPath, name], uri),
@@ -167625,7 +167630,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       const def = this.resolveType(holder, index2);
       return def && def !== holder && def.isDef === true ? def : void 0;
     };
-    const ownStates = (holder) => membersOf(holder).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
+    const ownStates = (holder) => membersOf(holder).map((member) => this.thenActionMemberNode(member) ?? member).filter((member) => isStateDecl(member) && nameOf2(member) !== void 0);
     const nestedStates = (holder) => {
       const out = ownStates(holder);
       const def = definitionOf(holder);
@@ -167664,9 +167669,28 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       drawnStates.push({ node: anchor, id: anchorFrameId });
       idByState.set(anchor, anchorFrameId);
     }
+    const drawnRowKeys = /* @__PURE__ */ new Set();
+    const rowKey = (source) => source ? `${source.uri} ${source.range.start.line} ${source.range.start.character}` : void 0;
+    const registerDrawn = (member) => {
+      const key = rowKey(sourceOf2(member, uri));
+      if (key)
+        drawnRowKeys.add(key);
+    };
+    const namesByFrame = /* @__PURE__ */ new Map();
+    const namesIn = (frameId) => {
+      const key = frameId ?? "";
+      const existing = namesByFrame.get(key);
+      if (existing)
+        return existing;
+      const created = /* @__PURE__ */ new Map();
+      namesByFrame.set(key, created);
+      return created;
+    };
     const renderState = (s, parentFrame, depth, seen) => {
       const id2 = qnameOf(s) || nameOf2(s);
       byName.set(nameOf2(s), id2);
+      namesIn(parentFrame).set(nameOf2(s), id2);
+      registerDrawn(s);
       drawnStates.push({ node: s, id: id2 });
       idByState.set(s, id2);
       const def = s.isDef === true ? void 0 : this.resolveType(s, index2);
@@ -167704,6 +167728,75 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     };
     for (const s of topStates)
       renderState(s, anchorFrameId, 0, /* @__PURE__ */ new Set());
+    const endpointName = (path10) => typeof path10 === "string" ? path10.split(/::|\./).pop() || void 0 : void 0;
+    const controlNodeInfo = (m) => {
+      switch (m.$type) {
+        case "ActionDecl":
+          return m.isDef === true || !nameOf2(m) ? void 0 : { shape: "action", label: nameOf2(m) };
+        // A `perform` names the action it performs, which for a feature
+        // chain (`perform machine.selfTest;`) is the LAST segment.
+        case "PerformStmt": {
+          const segments = [nameOf2(m), ...m.chainSegs ?? []].filter((segment) => !!segment);
+          return { shape: "action", label: segments.at(-1) ?? typeText(m) ?? "perform" };
+        }
+        // User direction 2026-08-30: fork and join only. They express
+        // concurrency, which a transition cannot say: nothing about a
+        // guard or a trigger splits control into parallel regions or
+        // gathers it again. `decide` and `merge` are dropped because a
+        // branch between states IS a guarded transition, which this
+        // view already draws and labels, so a diamond would say the
+        // same thing a second time in the action-flow idiom.
+        // `terminate` is dropped with them: the node carries no name,
+        // so no succession can reach it and it could only ever stand
+        // alone. All three remain in the OMG 8.2.3.18 node set.
+        case "JoinNode":
+          return { shape: "join", label: nameOf2(m) ?? "" };
+        case "ForkNode":
+          return { shape: "fork", label: nameOf2(m) ?? "" };
+        default:
+          return void 0;
+      }
+    };
+    const isInitialMarker = (member) => {
+      const entry = member;
+      return !!entry && entry.$type === "EntryAction" && !entry.name && !entry.actionKw && !entry.send && !entry.accept && !entry.assign;
+    };
+    const machineNodeIds = /* @__PURE__ */ new Map();
+    const machineNodeMembers = [];
+    let anonymousNodes = 0;
+    const emitMachineNodes = (holder, frameId) => {
+      const members = membersOf(holder);
+      const drawnHere = namesIn(frameId);
+      for (const raw of members) {
+        const member = this.thenActionMemberNode(raw) ?? raw;
+        const info = controlNodeInfo(member);
+        if (!info)
+          continue;
+        const name = nameOf2(member);
+        if (name && drawnHere.has(name))
+          continue;
+        const id2 = name ? qnameOf(member) || `${frameId}::${name}` : `${frameId}::__stv_${member.$type}_${anonymousNodes++}__`;
+        if (nodes.some((n2) => n2.id === id2) || frames.some((f) => f.id === id2))
+          continue;
+        if (name) {
+          drawnHere.set(name, id2);
+          if (!byName.has(name))
+            byName.set(name, id2);
+        }
+        machineNodeIds.set(member, id2);
+        machineNodeMembers.push({ member, id: id2 });
+        nodes.push({
+          id: id2,
+          name: info.label,
+          keyword: keywordFor(member),
+          isDef: false,
+          shape: info.shape,
+          compartments: this.compartmentsFor(member, uri, index2),
+          frame: frameId,
+          source: sourceOf2(member, uri)
+        });
+      }
+    };
     const edges = [];
     let e = 0;
     const resolveState = (nm) => {
@@ -167719,53 +167812,201 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       }
       return void 0;
     };
-    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
-    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
-      if (t.$type !== "TransitionDecl")
-        continue;
-      const tn = t;
-      const from = resolveState(tn.from);
-      const to = resolveState(tn.to);
+    const drawnEdges = /* @__PURE__ */ new Set();
+    const stateLike = /* @__PURE__ */ new Set(["state", "initial", "final"]);
+    const isStateEndpoint = (id2) => {
+      const node = nodes.find((n2) => n2.id === id2);
+      return node ? stateLike.has(node.shape) : frames.some((f) => f.id === id2);
+    };
+    const link = (from, to, label, src) => {
       if (!from || !to)
-        continue;
+        return;
+      const kind = isStateEndpoint(from) && isStateEndpoint(to) ? "transition" : "succession";
+      const key = `${from}\0${to}\0${label ?? ""}`;
+      if (drawnEdges.has(key))
+        return;
+      drawnEdges.add(key);
+      if (src)
+        registerDrawn(src);
       edges.push({
         id: `e${e++}`,
         from,
         to,
-        kind: "transition",
-        label: this.transitionLabel(t),
-        source: sourceOf2(t, uri)
+        kind,
+        label,
+        source: src ? sourceOf2(src, uri) : void 0
       });
+    };
+    const guardText = (guard) => {
+      const text = guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+      return text ? `[${text}]` : void 0;
+    };
+    const resolveEndpoint = (path10, initialId, frameId) => {
+      if (typeof path10 !== "string")
+        return void 0;
+      const short = endpointName(path10);
+      const local = namesByFrame.get(frameId ?? "");
+      return (short ? local?.get(short) : void 0) ?? resolveState(path10) ?? resolveState(short) ?? (short === "start" ? initialId : void 0);
+    };
+    const transitionScope = [anchor, ...definitionOf(anchor) ? [definitionOf(anchor)] : []];
+    for (const t of transitionScope.flatMap((holder) => [...ast_utils_exports.streamAllContents(holder)])) {
+      if (t.$type !== "TransitionDecl")
+        continue;
+      const tn = t;
+      link(resolveState(tn.from), resolveState(tn.to), this.transitionLabel(t), t);
     }
-    const designatedInitial = (owner) => {
+    const designatedInitial = (owner, frameId) => {
       const members = owner.members;
       if (!Array.isArray(members))
         return void 0;
-      for (let i = 0; i < members.length - 1; i++) {
-        const entry = members[i];
-        if (entry.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+      for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (member.$type === "FirstThenChain") {
+          const chain = member;
+          if (endpointName(chain.head) !== "start")
+            continue;
+          const target2 = resolveEndpoint((chain.steps ?? [])[0], void 0, frameId);
+          if (target2) {
+            registerDrawn(member);
+            return target2;
+          }
+          continue;
+        }
+        if (!isInitialMarker(member))
           continue;
         const then = members[i + 1];
         if (then?.$type !== "ThenActionMember" || typeof then.target !== "string")
           continue;
         const target = resolveState(lastSeg(then.target));
-        if (target)
+        if (target) {
+          registerDrawn(then);
           return target;
+        }
       }
       return void 0;
     };
-    const anchorDefinition = definitionOf(anchor);
-    const firstStateId = designatedInitial(anchor) ?? (anchorDefinition ? designatedInitial(anchorDefinition) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
-    if (firstStateId) {
-      edges.push({ id: `e${e++}`, from: "__initial__", to: firstStateId, kind: "transition" });
+    const machineScope = (holder) => {
+      const def = definitionOf(holder);
+      return def ? [holder, def] : [holder];
+    };
+    if (anchorFrameId) {
+      for (const holder of machineScope(anchor))
+        emitMachineNodes(holder, anchorFrameId);
+    }
+    for (const { state, frameId } of compositeFrames) {
+      for (const holder of machineScope(state))
+        emitMachineNodes(holder, frameId);
     }
+    const anchorDefinition = definitionOf(anchor);
+    const firstStateId = designatedInitial(anchor, anchorFrameId) ?? (anchorDefinition ? designatedInitial(anchorDefinition, anchorFrameId) : void 0) ?? (topStates.length ? byName.get(nameOf2(topStates[0])) : void 0);
+    if (firstStateId)
+      link("__initial__", firstStateId, void 0, void 0);
+    const compositeInitial = /* @__PURE__ */ new Map();
     for (const { state, frameId } of compositeFrames) {
-      const target = designatedInitial(state);
+      const target = designatedInitial(state, frameId);
       if (!target)
         continue;
       const id2 = `__initial__${frameId}`;
       nodes.push({ id: id2, name: "", keyword: "initial", isDef: false, shape: "initial", frame: frameId });
-      edges.push({ id: `e${e++}`, from: id2, to: target, kind: "transition" });
+      compositeInitial.set(state, id2);
+      link(id2, target, void 0, void 0);
+    }
+    const sequentialTransitions = (holder, initialId, frameId) => {
+      let cursor;
+      const idOf = (member) => machineNodeIds.get(member) ?? idByState.get(member) ?? (nameOf2(member) ? resolveEndpoint(nameOf2(member), void 0, frameId) : void 0);
+      const endpoint = (path10) => resolveEndpoint(path10, initialId, frameId);
+      for (const member of membersOf(holder)) {
+        switch (member.$type) {
+          case "StateDecl": {
+            cursor = idOf(member) ?? cursor;
+            break;
+          }
+          // `entry;` IS the start pseudostate, so the succession written
+          // after it leaves that pseudostate rather than the last state.
+          case "EntryAction": {
+            if (isInitialMarker(member)) {
+              cursor = initialId;
+              break;
+            }
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+          // OMG 8.2.3.18 names this edge `st-succession`, so the
+          // keyworded form is a first-class state-transition edge,
+          // not action-language sugar the state view may skip.
+          // Its ends are ConnectorEnds, not bare paths.
+          case "SuccessionStmt": {
+            const succession = member;
+            let previous = endpoint(this.connectorEndPath(succession.first));
+            let firstHop = true;
+            for (const step of succession.steps ?? []) {
+              const to = endpoint(this.connectorEndPath(step));
+              link(previous, to, firstHop ? guardText(succession.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "FirstThenChain": {
+            const chain = member;
+            let previous = endpoint(chain.head);
+            let firstHop = true;
+            for (const step of chain.steps ?? []) {
+              const to = endpoint(step);
+              link(previous, to, firstHop ? guardText(chain.guard) : void 0, member);
+              previous = to;
+              firstHop = false;
+            }
+            if (previous)
+              cursor = previous;
+            break;
+          }
+          case "AcceptNode": {
+            const accept = member;
+            if (typeof accept.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(accept.thenTarget), this.acceptShorthandLabel(member), member);
+            break;
+          }
+          case "ThenActionMember": {
+            const then = member;
+            const declared = this.thenActionMemberNode(member);
+            const to = (declared ? idOf(declared) : void 0) ?? endpoint(then.target);
+            link(cursor, to, void 0, member);
+            if (to)
+              cursor = to;
+            break;
+          }
+          // issue #113: a guarded or default target succession fans out
+          // of the SAME source (a decision node, normally), so neither
+          // branch may advance the cursor past its siblings.
+          case "IfActionNode": {
+            const branch = member;
+            if (typeof branch.thenTarget !== "string")
+              break;
+            link(cursor, endpoint(branch.thenTarget), guardText(branch.cond), member);
+            break;
+          }
+          case "ElseSuccessionMember": {
+            link(cursor, endpoint(member.target), "else", member);
+            break;
+          }
+          default: {
+            cursor = machineNodeIds.get(member) ?? cursor;
+            break;
+          }
+        }
+      }
+    };
+    for (const holder of machineScope(anchor)) {
+      sequentialTransitions(holder, hostsStateMachine ? "__initial__" : void 0, anchorFrameId);
+    }
+    for (const { state, frameId } of compositeFrames) {
+      for (const holder of machineScope(state)) {
+        sequentialTransitions(holder, compositeInitial.get(state), frameId);
+      }
     }
     const exhibitorsByState = /* @__PURE__ */ new Map();
     const exhibitScope = this.packageScopeOf(anchor);
@@ -167847,6 +168088,37 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         edges.push({ id: `e${e++}`, from, to, kind: "causation", label: "\xABcausation\xBB", source: sourceOf2(c, uri) });
       }
     }
+    const wired = /* @__PURE__ */ new Set();
+    for (const edge of edges) {
+      wired.add(edge.from);
+      wired.add(edge.to);
+    }
+    const stranded = new Set(machineNodeMembers.filter(({ id: id2 }) => !wired.has(id2)).map(({ id: id2 }) => id2));
+    if (stranded.size) {
+      for (let at = nodes.length - 1; at >= 0; at--) {
+        if (stranded.has(nodes[at].id))
+          nodes.splice(at, 1);
+      }
+    }
+    for (const { member, id: id2 } of machineNodeMembers) {
+      if (!stranded.has(id2))
+        registerDrawn(member);
+    }
+    for (const frame2 of frames) {
+      const full = frame2.compartments;
+      if (!full?.length)
+        continue;
+      const kept = full.map((compartment) => ({
+        title: compartment.title,
+        items: compartment.items.filter((row) => {
+          const key = rowKey(row.source);
+          return !key || !drawnRowKeys.has(key);
+        })
+      })).filter((compartment) => compartment.items.length > 0);
+      if (kept.length === full.length && kept.every((c, at) => c.items.length === full[at].items.length))
+        continue;
+      frame2.compartments = kept.length ? kept : void 0;
+    }
     const model = this.model("stv", anchor, nodes, edges);
     if (frames.length) {
       model.frames = frames;
@@ -170032,9 +170304,25 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       return item(m, val ? `= ${val}` : "(value)");
     }));
     add("states", usages(isStateDecl).map((m) => item(m)));
-    const stateActions = members.map((m) => ({ m, kind: { EntryAction: "entry", DoAction: "do", ExitAction: "exit" }[m.$type] })).filter((x) => !!x.kind);
-    add("state actions", stateActions.map(({ m, kind }) => item(m, `${kind} ${nameOf2(m) ?? ""}`.trim())));
+    const isInitialStateMarker = (m, at) => {
+      const entry = m;
+      if (m.$type !== "EntryAction" || entry.name || entry.actionKw || entry.send || entry.accept || entry.assign)
+        return false;
+      const next = members[at + 1];
+      return next?.$type === "ThenActionMember" || next?.$type === "FirstThenChain";
+    };
+    const stateActionTitle = {
+      EntryAction: "entry",
+      DoAction: "during",
+      ExitAction: "exit"
+    };
+    const stateActionText = (m) => nameOf2(m) ?? (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").replace(/^(entry|do|exit)\s+(action\s+)?/, "").trim();
+    for (const title of ["entry", "during", "exit"]) {
+      add(title, members.filter((m, at) => stateActionTitle[m.$type] === title && !isInitialStateMarker(m, at)).map((m) => item(m, stateActionText(m))).filter((row) => !!row.text));
+    }
     add("state transition", members.filter((m) => m.$type === "TransitionDecl").map((m) => item(m, `${m.from ?? ""} \u2192 ${m.to ?? ""}`)));
+    const successionText = (m) => (m.$cstNode?.text ?? "").replace(/\s+/g, " ").replace(/;$/, "").trim();
+    add("successions", members.filter((m) => m.$type === "FirstThenChain" || m.$type === "SuccessionStmt" || m.$type === "ThenActionMember" && typeof m.target === "string" || m.$type === "ElseSuccessionMember" || (m.$type === "AcceptNode" || m.$type === "IfActionNode") && typeof m.thenTarget === "string").map((m) => item(m, successionText(m))).filter((row) => !!row.text));
     add("assert constraints", members.filter((m) => m.$type === "AssertConstraintStmt").map((m) => item(m, exprText3(m) || nameOf2(m) || "assert constraint")));
     add("invariants", members.filter((m) => m.$type === "InvShorthand").map((m) => {
       const inv = m;
@@ -170125,9 +170413,19 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // REQ-186/REQ-198 — transition label: `trigger [guard] / effect`.
   transitionLabel(t) {
     const tn = t;
-    const trigger = this.acceptTriggerLabel(tn.accept);
-    const guard = tn.guard?.$cstNode?.text?.replace(/\s+/g, " ").trim();
-    const effect = this.effectLabel(tn.effect);
+    return this.transitionLabelOf(tn.accept, tn.guard, tn.effect);
+  }
+  // REQ-198: the label of a source-less transition shorthand (`accept Sig if g
+  // do effect then t;`, OMG SysML 8.2.2.18.3). The accept node itself carries
+  // the trigger, so it reads exactly like an explicit `transition`.
+  acceptShorthandLabel(accept) {
+    const node = accept;
+    return this.transitionLabelOf(accept, node.guard, node.effect);
+  }
+  transitionLabelOf(accept, guardExpr, effectClause) {
+    const trigger = this.acceptTriggerLabel(accept);
+    const guard = guardExpr?.$cstNode?.text?.replace(/\s+/g, " ").trim();
+    const effect = this.effectLabel(effectClause);
     const parts = [];
     if (trigger)
       parts.push(String(trigger));
@@ -170418,7 +170716,9 @@ var sysmlInlayHintSettings = {
   modifiers: false,
   specialization: false,
   redefinition: false,
-  effectiveNames: false
+  effectiveNames: false,
+  importedNames: false,
+  parameterNames: false
 };
 
 // ../language-server/out/src/services/category-taxonomy.js
@@ -181119,6 +181419,329 @@ 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",
+  "ActionDecl",
+  "ConstraintDecl",
+  "FunctionDecl",
+  "PredicateDecl",
+  "BehaviorDecl",
+  "InteractionDecl"
+]);
+var CallableResolver = class {
+  services;
+  lookup;
+  linker;
+  constructor(services) {
+    this.services = services;
+    this.lookup = nameLookupFor(services?.shared);
+    this.linker = services?.references.Linker;
+  }
+  /**
+   * Every indexed callable that answers to `name`, so a caller can decide what
+   * ambiguity costs it. Signature help is transient and follows the cursor, so
+   * it takes the first; an inlay hint is a permanent annotation, so it takes a
+   * candidate only when it is the ONLY element with that name.
+   */
+  candidates(name) {
+    const simple = simpleNameOf2(name);
+    return (this.lookup?.descriptions(simple) ?? []).filter((description) => CALLABLE_TYPES.has(description.type));
+  }
+  /**
+   * The one callable `name` unambiguously names in the index, if any: the
+   * written spelling first, then its final segment, and either reading must
+   * name exactly one element.
+   */
+  uniqueCandidate(name) {
+    return this.lookup?.uniqueForPath(name, (description) => CALLABLE_TYPES.has(description.type));
+  }
+  /** The callable declaration `name` invokes in `document`, resolved locally. */
+  findLocal(document2, name) {
+    const root4 = document2.parseResult?.value;
+    if (!root4)
+      return void 0;
+    return collectCallables([root4, ...ast_utils_exports.streamAllContents(root4).toArray()]).get(unquoteName3(simpleNameOf2(name)));
+  }
+  /**
+   * SYNCHRONOUS resolution: a qualified spelling the index holds verbatim,
+   * then the document's own tree, then an unambiguous indexed callable —
+   * resolved through the linker's off-to-the-side library parse. Nothing here
+   * grows `LangiumDocuments`, and nothing here awaits, so it is safe on a
+   * request VS Code re-issues on every scroll.
+   */
+  resolve(document2, name, local) {
+    if (name.includes("::") || name.includes(".")) {
+      const exact = this.lookup?.unique(name, (description) => CALLABLE_TYPES.has(description.type));
+      const node = exact ? this.nodeOf(exact) : void 0;
+      if (node)
+        return node;
+    }
+    const found = local ? local(unquoteName3(simpleNameOf2(name))) : this.findLocal(document2, name);
+    if (found)
+      return found;
+    const candidate = this.uniqueCandidate(name);
+    return candidate ? this.nodeOf(candidate) : void 0;
+  }
+  /** An indexed description as a node, through the linker's lazy library parse. */
+  nodeOf(description) {
+    return this.linker?.resolveIndexedNode?.(description) ?? description.node;
+  }
+  /**
+   * Resolution that may load a workspace document. Signature help uses it: it
+   * runs on an explicit editor gesture, not on every scroll, and a callable in
+   * a workspace file the user has not opened yet still deserves a signature.
+   */
+  // REQ-263 — Signature help on `(` / `,` / `->`
+  async resolveAsync(document2, name) {
+    const direct = this.resolve(document2, name);
+    if (direct)
+      return direct;
+    const candidate = this.candidates(name).at(0);
+    if (!candidate)
+      return void 0;
+    if (candidate.node)
+      return candidate.node;
+    const documents = this.services?.shared.workspace.LangiumDocuments;
+    const locator = this.services?.workspace.AstNodeLocator;
+    if (!documents || !locator)
+      return void 0;
+    const doc = documents.getDocument(candidate.documentUri) ?? await documents.getOrCreateDocument(candidate.documentUri);
+    const root4 = doc?.parseResult?.value;
+    return root4 ? locator.getAstNode(root4, candidate.path) : void 0;
+  }
+  /** {@link callableParameters} — the parameters, in written order. */
+  parameters(node) {
+    return callableParameters(node);
+  }
+  /**
+   * The parameters a positional argument list binds to: the INPUTS, in written
+   * order. An `out` parameter and the result are not written at the call site
+   * (OMG KerML v1.0 binds an `InvocationExpression`'s arguments to the
+   * invoked type's input features).
+   */
+  inputParameters(node) {
+    return this.parameters(node).filter((parameter) => !parameter.isReturn && parameter.direction !== "out");
+  }
+};
+function callableParameters(node) {
+  const directed = new Map(directedParameters(node).map((entry) => [entry.node, entry.direction]));
+  const result = [];
+  for (const member of membersOf2(node)) {
+    const direction = directed.get(member);
+    const isReturn = member.$type === "ReturnDecl";
+    if (!direction && !isReturn)
+      continue;
+    const name = nodeName2(member);
+    if (!name && !direction)
+      continue;
+    result.push({
+      node: member,
+      direction: direction ?? "return",
+      name,
+      type: typingText(member),
+      multiplicity: multiplicityText2(member),
+      isReturn
+    });
+  }
+  return result;
+}
+function collectCallables(nodes) {
+  const callables = /* @__PURE__ */ new Map();
+  const byDefinition = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!CALLABLE_TYPES.has(node.$type) && callableParameters(node).length === 0)
+      continue;
+    const isDefinition = node.isDef === true;
+    for (const name of [nodeName2(node), shortNameOf2(node)]) {
+      if (!name)
+        continue;
+      if (callables.has(name) && !(isDefinition && !byDefinition.has(name)))
+        continue;
+      callables.set(name, node);
+      if (isDefinition)
+        byDefinition.add(name);
+    }
+  }
+  return callables;
+}
+function membersOf2(node) {
+  const members = node?.members;
+  return Array.isArray(members) ? members.filter(isAstNode3) : [];
+}
+function isAstNode3(value) {
+  return typeof value === "object" && value !== null && typeof value.$type === "string";
+}
+function nodeName2(node) {
+  const value = node?.name;
+  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+}
+function shortNameOf2(node) {
+  const value = node?.shortName?.name;
+  return typeof value === "string" && value.length > 0 ? unquoteName3(value) : void 0;
+}
+function typingText(node) {
+  const text = node?.typing?.type?.$refText;
+  return typeof text === "string" && text.length > 0 ? text : void 0;
+}
+function multiplicityText2(node) {
+  const text = node?.multiplicity?.$cstNode?.text;
+  return typeof text === "string" && text.length > 0 ? text.trim() : void 0;
+}
+
+// ../language-server/out/src/services/inlay-hint-provider.js
 function multiplicityAnchor(node) {
   const leaves = cst_utils_exports.flattenCst(node).toArray();
   const bodyStart = leaves.find((leaf) => leaf.text === "{");
@@ -181177,6 +181800,50 @@ var EXPLICIT_SPECIALIZATION_KINDS = /* @__PURE__ */ new Set([
   "conjugates"
 ]);
 var REDEFINITION_KINDS2 = /* @__PURE__ */ new Set([":>>", "redefines"]);
+var CONSTANT_CARRYING_KINDS = /* @__PURE__ */ new Set([
+  ":>",
+  "subsets",
+  ":>>",
+  "redefines",
+  "::>",
+  "references",
+  "=>",
+  "crosses"
+]);
+var CONSTANT_MODIFIERS = /* @__PURE__ */ new Set(["constant", "const"]);
+function constantKeyword(languageId) {
+  return languageId === "kerml" ? "const" : "constant";
+}
+var PREFIXES_BEFORE_CONSTANT = /* @__PURE__ */ new Set([
+  "public",
+  "private",
+  "protected",
+  "in",
+  "out",
+  "inout",
+  "abstract",
+  "variation",
+  "variant",
+  "derived",
+  "readonly",
+  "composite",
+  "portion",
+  "ordered",
+  "nonunique",
+  "parallel"
+]);
+var PORTION_MODIFIERS = /* @__PURE__ */ new Set(["portion", "snapshot", "timeslice"]);
+var ACTION_KIND_USAGES = /* @__PURE__ */ new Set([
+  "ActionDecl",
+  "StateDecl",
+  "CalcDecl",
+  "CaseDecl",
+  "UseCaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl"
+]);
+var KERML_FEATURE_DECLS = /* @__PURE__ */ new Set(["FeatureDecl", "StepDecl", "ExpressionDecl"]);
+var REFERENCE_MODIFIERS = /* @__PURE__ */ new Set(["ref", "in", "out", "inout"]);
 var IMPLICIT_BASES = Object.freeze({
   PartDecl: { def: "Parts::Part", usage: "Parts::parts" },
   ItemDecl: { def: "Items::Item", usage: "Items::items" },
@@ -181201,6 +181868,37 @@ var IMPLICIT_BASES = Object.freeze({
   OccurrenceDecl: { def: "Occurrences::Occurrence", usage: "Occurrences::occurrences" },
   MetadataDecl: { def: "Metadata::MetadataItem", usage: "Metadata::metadataItems" }
 });
+var OCCURRENCE_KIND_OWNERS = /* @__PURE__ */ new Set([
+  ...Object.keys(IMPLICIT_BASES).filter((kind) => kind !== "AttributeDecl"),
+  // KerML fixes a library base per classifier kind too, in the same way and in
+  // the same normative place: `Class` specializes `Occurrences::Occurrence`,
+  // `Structure` specializes `Objects::Object`, `Metaclass` specializes
+  // `Metaobjects::Metaobject`, `Behavior` specializes
+  // `Performances::Performance`, `Function` and `Interaction` are Behaviors,
+  // `Predicate` is a Function, `Step` specializes `Performances::performances`
+  // and `Expression` is a Step. All of them reach `Occurrence`.
+  "ClassDecl",
+  "StructDecl",
+  "MetaclassDecl",
+  "BehaviorDecl",
+  "InteractionDecl",
+  "FunctionDecl",
+  "PredicateDecl",
+  "StepDecl",
+  "ExpressionDecl"
+  // Left out because their base is NOT an occurrence: `DatatypeDecl`
+  // (`Base::DataValue`, declared disjoint from `Occurrence`) and plain
+  // `AssociationDecl` (`Links::Link`, which specializes `Base::Anything`) —
+  // `assoc struct` is handled separately, since it is a `LinkObject`.
+  // Left out because their base is WRITTEN rather than fixed by the kind:
+  // `TypeDecl`, `ClassifierDecl`, `FeatureDecl`.
+]);
+function isOccurrenceKindOwner(owner) {
+  if (owner.$type === "AssociationDecl")
+    return owner.isStruct === true;
+  return OCCURRENCE_KIND_OWNERS.has(owner.$type);
+}
+var NON_VARYING_LIBRARY_TYPES = /* @__PURE__ */ new Set(["SelfLink", "HappensLink"]);
 function markdown(value) {
   return { kind: import_vscode_languageserver20.MarkupKind.Markdown, value };
 }
@@ -181222,19 +181920,130 @@ function descriptionRange(description) {
   const segment = description.nameSegment ?? description.selectionSegment;
   return segment?.range ?? { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
 }
+function descriptionLocation(description) {
+  return { uri: description.documentUri.toString(), range: descriptionRange(description) };
+}
+function nodeLocation(node) {
+  const range = node.$cstNode?.range;
+  if (!range)
+    return void 0;
+  return { uri: ast_utils_exports.getDocument(node).uri.toString(), range };
+}
+function specializesNonVaryingLibraryType(node) {
+  const typing = node.typing?.type?.$refText;
+  if (typing && NON_VARYING_LIBRARY_TYPES.has(lastSegment3(typing)))
+    return true;
+  return allRelationships2(node).flatMap((rel2) => rel2.targets ?? []).some((target) => NON_VARYING_LIBRARY_TYPES.has(lastSegment3(target)));
+}
+function constantAnchor(node) {
+  const cst = node.$cstNode;
+  if (!cst)
+    return void 0;
+  for (const leaf of cst_utils_exports.flattenCst(cst)) {
+    if (leaf.hidden)
+      continue;
+    if (PREFIXES_BEFORE_CONSTANT.has(leaf.text))
+      continue;
+    return /^[a-z]+$/u.test(leaf.text) ? leaf : void 0;
+  }
+  return void 0;
+}
+function membershipImportPath(node) {
+  if (isImport(node) && node.alias)
+    return void 0;
+  if (isExposePath(node) && node.dotSegs.length > 0)
+    return void 0;
+  if (node.segs.some((seg) => seg.star || seg.recursive || !seg.name))
+    return void 0;
+  const last2 = node.segs.at(-1);
+  const written = last2?.name ?? node.head;
+  const anchor = last2 ? grammar_utils_exports.findNodeForProperty(last2.$cstNode, "name") : grammar_utils_exports.findNodeForProperty(node.$cstNode, "head");
+  if (!anchor)
+    return void 0;
+  return { path: [node.head, ...node.segs.map((seg) => seg.name)].join("::"), written, anchor };
+}
+function publicFeatures(type) {
+  const members = type.members;
+  if (!Array.isArray(members))
+    return [];
+  return members.filter((member) => {
+    if (typeof member?.$type !== "string")
+      return false;
+    const decl = member;
+    if (decl.isDef !== false && decl.$type !== "FeatureDecl")
+      return false;
+    return decl.visibility === void 0 || decl.visibility === "public";
+  });
+}
+function calleeName(node) {
+  if (node.call) {
+    if (isPathExpr(node.target))
+      return node.target.path;
+    const target = node.target;
+    if (isPostfixOp(target) && target.dot && target.field)
+      return target.field;
+    return void 0;
+  }
+  if (node.arrow && node.invoke)
+    return node.invoke;
+  return void 0;
+}
+function callArguments(node) {
+  if (node.call)
+    return { args: node.callArgs, firstParameter: 0 };
+  if (node.arrow && node.invoke)
+    return { args: node.args, firstParameter: 1 };
+  return void 0;
+}
 var SysmlInlayHintProvider = class {
   services;
   /**
    * Resolved implicit bases, keyed by the qualified name in
-   * {@link IMPLICIT_BASES}. The standard library does not change once it is
-   * loaded, so this is built at most once for real; while it is still empty —
-   * before the library has been indexed — the rebuild is over a tiny index and
-   * costs nothing, which is what keeps the hint path free of a full index scan
-   * on every request.
+   * {@link IMPLICIT_BASES}. A base the index does not hold is NOT cached — the
+   * library may still be loading — and issue #240 made that miss cheap: two
+   * lookups in the shared name index rather than the full index scan it used
+   * to be, on a request VS Code re-issues on every scroll. A HIT is cached
+   * until the index is rebuilt, so the description a label links to always
+   * carries the ranges of the generation it was read from.
    */
   baseCache = /* @__PURE__ */ new Map();
+  /**
+   * REQ-395 — issue #240: the shared name lookup, built once per index
+   * generation. Every category that resolves a WRITTEN name goes through it,
+   * so no request puts an index scan on the hint path.
+   */
+  lookup;
+  /** REQ-395 — issue #240: the callee resolution signature help also uses. */
+  callables;
+  /** REQ-395 — issue #240: the linker's lazy standard-library parse. */
+  linker;
+  /**
+   * REQ-395 — issue #240: "does this element declare `constant`?", memoized by
+   * element identity, because answering it may cost one lazily parsed library
+   * file. Editing away the `constant` on the SUBSETTED feature changes the
+   * answer without changing the key, so this is dropped whenever the index is
+   * rebuilt, exactly like the shared name lookup.
+   */
+  constantCache = /* @__PURE__ */ new Map();
+  /**
+   * REQ-395 — issue #240: an element's own written names, memoized by element
+   * identity. Reading them tells a `<short>` name from a regular one, which is
+   * what lets the imported-name hint print the notation the source would have
+   * written. It costs at most one lazily parsed library file, only for an
+   * element that actually has two names, and it is dropped with the rest when
+   * the index is rebuilt.
+   */
+  declaredNameCache = /* @__PURE__ */ new Map();
   constructor(services) {
     this.services = services;
+    this.lookup = nameLookupFor(services?.shared);
+    this.callables = new CallableResolver(services);
+    this.linker = services?.references.Linker;
+    services?.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, () => {
+      this.baseCache.clear();
+      this.constantCache.clear();
+      this.declaredNameCache.clear();
+    });
   }
   getInlayHints(document2, _params) {
     const root4 = document2.parseResult?.value;
@@ -181242,7 +182051,14 @@ var SysmlInlayHintProvider = class {
       return void 0;
     const settings = sysmlInlayHintSettings;
     const hints = [];
-    for (const node of allAstNodes(root4)) {
+    const nodes = allAstNodes(root4);
+    let localCallables;
+    const localCallable = (simple) => {
+      localCallables ??= collectCallables(nodes);
+      return localCallables.get(simple);
+    };
+    const callees = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
       const decl = node;
       if (settings.multiplicity && (isPartDecl(node) || isPortDecl(node) || isAttributeDecl(node)) && !decl.isDef && !decl.multiplicity && node.$cstNode && decl.name) {
         hints.push({
@@ -181269,6 +182085,11 @@ var SysmlInlayHintProvider = class {
           });
         }
       }
+      if (settings.modifiers) {
+        const constant2 = this.implicitConstantHint(decl);
+        if (constant2)
+          hints.push(constant2);
+      }
       if (settings.modifiers && isAttributeDecl(node) && !decl.isDef && !(decl.modifiers ?? []).includes("ref")) {
         const keyword = keywordLeaf(node, "attribute");
         if (keyword) {
@@ -181310,6 +182131,17 @@ var SysmlInlayHintProvider = class {
         if (effective)
           hints.push(effective);
       }
+      if (settings.importedNames && (isImport(node) || isExposePath(node))) {
+        const imported = this.importedNameHint(node);
+        if (imported)
+          hints.push(imported);
+      }
+      if (settings.parameterNames && isPostfixOp(node)) {
+        hints.push(...this.argumentNameHints(node, document2, callees, localCallable));
+      }
+      if (settings.parameterNames && isNewExpr(node)) {
+        hints.push(...this.constructorArgumentHints(node));
+      }
       if (!settings.dimension)
         continue;
       if (isNumericPrimary(node)) {
@@ -181379,6 +182211,228 @@ var SysmlInlayHintProvider = class {
     }
     return hints;
   }
+  /**
+   * REQ-395 — issue #240: the other name a membership `import` brings in.
+   *
+   * An element may declare both a regular name and a `<short>` name, and an
+   * import brings in BOTH — the one the path does not write is invisible in
+   * the source, which is exactly what the hint is for. The written path is a
+   * datatype string, not a cross-reference, so the element is found through
+   * the shared name lookup: the spelling the index holds verbatim first, then
+   * the final segment, and either reading must name exactly ONE element. A
+   * name two packages both declare yields nothing rather than whichever the
+   * index lists first.
+   */
+  importedNameHint(node) {
+    const written = membershipImportPath(node);
+    if (!written || !this.lookup)
+      return void 0;
+    const description = this.lookup.uniqueForPath(written.path);
+    if (!description)
+      return void 0;
+    const others = this.lookup.otherNames(description, written.written);
+    if (others.length === 0)
+      return void 0;
+    const declared = this.declaredNames(description);
+    const shown = others.map((name) => declared?.shortName === name ? `<${name}>` : name);
+    const kind = isImport(node) ? "import" : "expose";
+    return {
+      position: written.anchor.range.end,
+      label: [{
+        value: ` also ${shown.join(", ")}`,
+        location: descriptionLocation(description)
+      }],
+      kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+      paddingLeft: true,
+      tooltip: markdown(`This \`${kind}\` also brings \`${shown.join("`, `")}\` into scope: an element is addressable by its regular name and by its short name, and a membership import carries both.`)
+    };
+  }
+  /**
+   * REQ-395 — issue #240: the names an indexed element declares for itself.
+   *
+   * The index records the spellings but not which of them is the `<short>`
+   * one, so the declaration is resolved through the linker's off-to-the-side
+   * library parse — the budget REQ-251 sets, spent only for an element that
+   * has more than one name, and memoized until the index is rebuilt.
+   */
+  declaredNames(description) {
+    const key = elementKey2(description);
+    const cached = this.declaredNameCache.get(key);
+    if (cached)
+      return cached;
+    const node = this.linker?.resolveIndexedNode?.(description) ?? description.node;
+    if (!node)
+      return void 0;
+    const decl = node;
+    const names = { name: decl.name, shortName: decl.shortName?.name };
+    this.declaredNameCache.set(key, names);
+    return names;
+  }
+  /**
+   * REQ-395 — issue #240: the feature each `new Type(…)` argument binds to.
+   *
+   * A `ConstructorExpression` binds its arguments to the PUBLIC features of
+   * the instantiated type, in order (OMG KerML v1.0, `ConstructorExpression`)
+   * — not to input parameters, which is what an `InvocationExpression` binds.
+   * The instantiated type IS a cross-reference here, so there is nothing to
+   * resolve by name: an unresolved one simply yields no hints.
+   */
+  constructorArgumentHints(node) {
+    if (node.args.length === 0)
+      return [];
+    if (node.args.every((argument) => argument.name !== void 0))
+      return [];
+    const instantiated = node.type?.ref;
+    if (!instantiated)
+      return [];
+    const features = publicFeatures(instantiated);
+    if (features.length === 0)
+      return [];
+    const hints = [];
+    for (let index2 = 0; index2 < node.args.length; index2++) {
+      const argument = node.args[index2];
+      if (argument.name || !argument.$cstNode)
+        continue;
+      const feature = features[index2];
+      const name = feature?.name;
+      if (!feature || !name)
+        continue;
+      const location = nodeLocation(feature);
+      hints.push({
+        position: argument.$cstNode.range.start,
+        label: [{ value: `${name} =`, ...location ? { location } : {} }],
+        kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+        paddingRight: true,
+        tooltip: markdown(`Argument ${index2 + 1} binds to \`${name}\` of \`${node.type.$refText}\`.`)
+      });
+    }
+    return hints;
+  }
+  /**
+   * REQ-395 — issue #240: the parameter a POSITIONAL invocation argument binds
+   * to.
+   *
+   * The callee of a call is an expression rather than a cross-reference, so
+   * the name is resolved through the shared {@link CallableResolver} — the
+   * same one signature help uses, which is why naming these arguments does not
+   * add a second resolution path. An argument that writes its own name has
+   * stated the correspondence, so it gets no hint.
+   */
+  argumentNameHints(node, document2, callees, localCallable) {
+    const call = callArguments(node);
+    const callee = calleeName(node);
+    if (!call || !callee || call.args.length === 0)
+      return [];
+    if (call.args.every((argument) => argument.argName !== void 0))
+      return [];
+    let callable = callees.get(callee);
+    if (callable === void 0 && !callees.has(callee)) {
+      callable = this.callables.resolve(document2, callee, localCallable);
+      callees.set(callee, callable);
+    }
+    if (!callable)
+      return [];
+    const parameters = this.callables.inputParameters(callable);
+    if (parameters.length === 0)
+      return [];
+    const hints = [];
+    for (let index2 = 0; index2 < call.args.length; index2++) {
+      const argument = call.args[index2];
+      if (argument.argName || !argument.$cstNode)
+        continue;
+      const parameter = parameters[index2 + call.firstParameter];
+      if (!parameter?.name)
+        continue;
+      const location = nodeLocation(parameter.node);
+      hints.push({
+        position: argument.$cstNode.range.start,
+        label: [{ value: `${parameter.name} =`, ...location ? { location } : {} }],
+        kind: import_vscode_languageserver20.InlayHintKind.Parameter,
+        paddingRight: true,
+        tooltip: markdown(`Argument ${index2 + 1} binds to \`${parameter.direction} ${parameter.name}\` of \`${callee}\`.`)
+      });
+    }
+    return hints;
+  }
+  /**
+   * REQ-395 — issue #240: implicit `constant`.
+   *
+   * OMG KerML v1.0 constrains `Subsetting`: `subsettedFeature.isConstant and
+   * subsettingFeature.isVariable implies subsettingFeature.isConstant`. So a
+   * usage that subsets or redefines a feature declared `constant` IS constant,
+   * without writing it — provided it can vary at all, because `Feature` also
+   * constrains `isConstant implies isVariable`.
+   *
+   * Whether it can vary is `Usage::mayTimeVary`, which OMG SysML v2 Part 1
+   * derives as "owned by a type that specializes `Occurrences::Occurrence`,
+   * and not a portion, a self/happens link, or a composite action". All four
+   * are decided here from the declaration kinds and what the source writes
+   * ({@link isOccurrenceKindOwner}, {@link PORTION_MODIFIERS},
+   * {@link ACTION_KIND_USAGES} with {@link REFERENCE_MODIFIERS}, and
+   * {@link specializesNonVaryingLibraryType}); an owner whose base is written
+   * rather than fixed by its kind leaves the category quiet, as an
+   * undecidable model must.
+   */
+  implicitConstantHint(node) {
+    const isFeature = node.isDef === false || KERML_FEATURE_DECLS.has(node.$type);
+    if (!isFeature)
+      return void 0;
+    const modifiers2 = node.modifiers ?? [];
+    if (modifiers2.some((modifier) => CONSTANT_MODIFIERS.has(modifier)))
+      return void 0;
+    if (modifiers2.some((modifier) => PORTION_MODIFIERS.has(modifier)))
+      return void 0;
+    if (ACTION_KIND_USAGES.has(node.$type) && !modifiers2.some((modifier) => REFERENCE_MODIFIERS.has(modifier)))
+      return void 0;
+    const owner = node.$container;
+    if (!owner || !isOccurrenceKindOwner(owner))
+      return void 0;
+    if (specializesNonVaryingLibraryType(node))
+      return void 0;
+    const carrier = allRelationships2(node).filter((rel2) => rel2.kind && CONSTANT_CARRYING_KINDS.has(rel2.kind)).flatMap((rel2) => rel2.targets ?? []).find((target) => this.isConstantFeature(target));
+    if (!carrier)
+      return void 0;
+    const anchor = constantAnchor(node);
+    const at = anchor?.range.start ?? node.$cstNode?.range.start;
+    if (!at)
+      return void 0;
+    const keyword = constantKeyword(this.services?.LanguageMetaData.languageId);
+    return {
+      position: at,
+      label: keyword,
+      kind: import_vscode_languageserver20.InlayHintKind.Type,
+      paddingRight: true,
+      tooltip: markdown(`Implicitly \`${keyword}\`: this feature subsets \`${lastSegment3(carrier)}\`, which is declared constant, and a subsetting feature that may vary takes the constancy of what it subsets.`),
+      // Writing the modifier is mechanically safe — it is a leading
+      // declaration prefix, and OMG puts it exactly here, before `ref`
+      // and the kind keyword.
+      ...anchor ? { textEdits: [{ range: { start: at, end: at }, newText: `${keyword} ` }] } : {}
+    };
+  }
+  /**
+   * REQ-395 — issue #240: does the feature this path names declare `constant`?
+   *
+   * The path must name exactly one element, and that element is resolved
+   * through the linker's off-to-the-side library parse — one lazily parsed
+   * indexed target, the budget REQ-251 sets, and never a document added to the
+   * workspace. The answer is memoized, so a scroll does not repeat it.
+   */
+  isConstantFeature(target) {
+    if (!this.lookup)
+      return false;
+    const description = this.lookup.uniqueForPath(target);
+    if (!description)
+      return false;
+    const key = elementKey2(description);
+    const cached = this.constantCache.get(key);
+    if (cached !== void 0)
+      return cached;
+    const node = this.linker?.resolveIndexedNode?.(description) ?? description.node;
+    const modifiers2 = node?.modifiers ?? [];
+    const answer = modifiers2.some((modifier) => CONSTANT_MODIFIERS.has(modifier));
+    this.constantCache.set(key, answer);
+    return answer;
+  }
   /**
    * REQ-395 — Find one implicit base in the index.
    *
@@ -181392,25 +182446,19 @@ var SysmlInlayHintProvider = class {
     const cached = this.baseCache.get(qualified);
     if (cached)
       return cached;
-    const index2 = this.services?.shared.workspace.IndexManager;
-    if (!index2)
+    if (!this.lookup)
       return void 0;
-    const simple = lastSegment3(qualified);
-    let fallback;
-    for (const description of index2.allElements()) {
-      if (description.name === qualified) {
-        this.baseCache.set(qualified, description);
-        return description;
-      }
-      if (fallback || description.name !== simple)
-        continue;
+    const exact = this.lookup.descriptions(qualified).at(0);
+    if (exact) {
+      this.baseCache.set(qualified, exact);
+      return exact;
+    }
+    const fallback = this.lookup.descriptions(lastSegment3(qualified)).find((description) => {
       const uri = description.documentUri instanceof URI2 ? description.documentUri : URI2.parse(String(description.documentUri));
       if (!isStandardLibraryUri(uri))
-        continue;
-      if (description.isUsage === true !== wantUsage)
-        continue;
-      fallback = description;
-    }
+        return false;
+      return description.isUsage === true === wantUsage;
+    });
     if (fallback)
       this.baseCache.set(qualified, fallback);
     return fallback;
@@ -196025,7 +197073,7 @@ var AFV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set([
   "succession",
   "successionFlow"
 ]);
-var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition"]);
+var STV_LAYOUT_EDGE_KINDS = /* @__PURE__ */ new Set(["transition", "succession"]);
 function behaviorLayoutEdgeKinds(kind) {
   return kind === "afv" ? AFV_LAYOUT_EDGE_KINDS : kind === "stv" ? STV_LAYOUT_EDGE_KINDS : void 0;
 }
@@ -201234,6 +202282,10 @@ var TOOLBOX = {
     ],
     relations: [
       rel("transition", "transition", "\u2192", "click the source state, then the target state"),
+      // issue #113 - a machine's action and control nodes are sequenced by
+      // a succession, not by a transition: `transition` needs a state at
+      // both ends (OMG SysML 8.2.2.18.3), while `first a then b` does not.
+      rel("succession", "succession", "\u21E2", "click the source node, then the target node"),
       // issue #115 — nothing could mark the initial state, so a state
       // machine could not be STARTED from a blank canvas. The gesture runs
       // from the always-drawn initial pseudostate to the first state.
@@ -201392,7 +202444,11 @@ function normalizedElementKeyword(keyword) {
     "loop action",
     "for-loop action",
     "perform action",
-    "assign"
+    "assign",
+    // issue #113 — a state sub-action drawn as a node is an action node.
+    "entry action",
+    "do action",
+    "exit action"
   ].includes(base)) {
     base = "action";
   } else if (["fork", "join", "merge", "decide", "decision"].includes(base)) {
@@ -201494,7 +202550,12 @@ function relationToolsForNode(keyword, viewKind, shape) {
       if (base === "port") return false;
       return base === "pin" && (tool.kind === "flow" || tool.kind === "successionFlow" || tool.kind === "bind");
     }
-    if (viewKind === "stv") return base === "state" && tool.kind !== "initial";
+    if (viewKind === "stv") {
+      if (base === "action" || base === "control") {
+        return tool.kind === "succession" || tool.kind === TERMINAL_RELATION;
+      }
+      return base === "state" && tool.kind !== "initial";
+    }
     if (viewKind === "sv") return shape === "lifeline" && (base === "part" || base === "lifeline");
     if (viewKind === "cv") {
       if (base === "actor") return tool.kind === "actor";
@@ -203957,7 +205018,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.24.0" : "dev";
+var VERSION2 = true ? "0.26.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;