sysml-diagram 0.23.0 → 0.25.0

package/out/main.js

@@ -162474,6 +162474,35 @@ function connectionEndMultiplicity(node) {
     return void 0;
   return hi == null || hi === lo ? `[${lo}]` : `[${lo}..${hi}]`;
 }
+function isEmptyPrefixFlow(node) {
+  const fm = node;
+  return node.$type === "FlowStmt" && fm.target !== void 0 && fm.source === void 0;
+}
+function flowStmtName(node) {
+  return isEmptyPrefixFlow(node) ? void 0 : effectiveNameOf(node);
+}
+function flowKeyword(fm) {
+  return `${fm.succession === true ? "succession " : ""}${fm.flowKind === "message" ? "message" : "flow"}`;
+}
+function flowTransferredFeature(ends) {
+  const sourceFeature = ends.source ? lastSeg(ends.source) : void 0;
+  const targetFeature = ends.target ? lastSeg(ends.target) : void 0;
+  return sourceFeature === targetFeature ? sourceFeature : sourceFeature ?? targetFeature;
+}
+function flowDecorationMeta(carried) {
+  const drawn = carried.filter((flow) => !flow.message);
+  if (!drawn.length)
+    return {};
+  return {
+    flowDecorations: drawn.map(({ keyword, label, name, reversed, row }) => ({
+      keyword,
+      ...label ? { label } : {},
+      ...name ? { name } : {},
+      reversed,
+      ...row.source ? { source: row.source } : {}
+    }))
+  };
+}
 var END_PROPERTY_ADORNMENTS = /* @__PURE__ */ new Set(["abstract", "derived", "readonly", "ordered", "nonunique"]);
 var uniqueStrings = (values2) => [...new Set([...values2].filter((value) => !!value))];
 function formatConnectionEndAdornment(notation) {
@@ -164919,6 +164948,27 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     return { source: void 0, target: fm.target ? String(fm.target) : void 0 };
   }
+  // REQ-401 — the `flows-compartment` row of one flow or message usage (OMG
+  // SysML 8.2.3.16). Rebuilt from the declaration instead of copied from the
+  // source text, because a flow may carry a BODY (`flow a.x to b.y { doc ... }`)
+  // whose whole text would otherwise be inlined into one compartment row.
+  // `ends` overrides the declared endpoints with the concrete ones a relationship
+  // usage rebinds them to (REQ-402).
+  // REQ-401 — Flow notation: on-connection decoration, port docking, and the flow usage node
+  flowRowText(flow, ends) {
+    const fm = flow;
+    const declared = ends ?? this.flowStmtEnds(fm);
+    const type = typeText(flow);
+    const payload = this.flowPayloadText(fm);
+    return [
+      flowKeyword(fm),
+      flowStmtName(flow),
+      type ? `: ${type}` : void 0,
+      payload ? `of ${payload}` : void 0,
+      declared.source ? `from ${declared.source}` : void 0,
+      declared.target ? `to ${declared.target}` : void 0
+    ].filter(Boolean).join(" ");
+  }
   // Payload text of a flow/message (`of Fuel` / `of f : Fuel`) per OMG SysML
   // 8.2.2.16 PayloadFeature.
   flowPayloadText(fm) {
@@ -164928,6 +164978,87 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     const typeRef = p.type?.$refText ?? p.typing?.type?.$refText;
     return typeRef ? lastSeg(typeRef) : p.name;
   }
+  // REQ-402 — the flows a connection or interface usage CARRIES. A flow declared
+  // in a `connection def` / `interface def` body (OMG SysML 8.2.3.16, and the
+  // `Flow Interface Example` of the training corpus) is transported by every
+  // usage of that definition; it is not a transfer of its own between two
+  // unrelated features. Each end path is rebound through the usage's own end
+  // bindings, so the definition-local `supplierPort.fuelSupply` reads as the
+  // concrete `tankAssy.fuelTankPort.fuelSupply` this usage connects, and the
+  // transfer direction is expressed relative to the usage's own end ordinals so
+  // it survives whichever notation the relationship is drawn in.
+  // REQ-402 — Flows carried by a connection or interface usage
+  carriedFlowsOf(usage, ends, index2, uri) {
+    const ordinalByRole = /* @__PURE__ */ new Map();
+    const pathByRole = /* @__PURE__ */ new Map();
+    for (const end of ends) {
+      const role = end.notation.role;
+      if (!role)
+        continue;
+      if (!ordinalByRole.has(role))
+        ordinalByRole.set(role, end.ordinal);
+      if (end.path && !pathByRole.has(role))
+        pathByRole.set(role, end.path);
+    }
+    const rebind = (path10) => {
+      if (!path10)
+        return void 0;
+      const segs = path10.split(".");
+      const bound = pathByRole.get(segs[0]);
+      return bound ? [bound, ...segs.slice(1)].join(".") : path10;
+    };
+    const carried = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const source of [usage, ...this.inheritedFeatureOwnersOf(usage, index2)]) {
+      for (const member of membersOf(source)) {
+        if (member.$type !== "FlowStmt" || member.isDef === true)
+          continue;
+        const fm = member;
+        const flowEnds = this.flowStmtEnds(fm);
+        const name = flowStmtName(member);
+        const payload = this.flowPayloadText(fm);
+        const key = name ?? `\0${flowEnds.source ?? ""}\0${flowEnds.target ?? ""}\0${payload ?? typeText(member) ?? ""}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        const fromOrdinal = flowEnds.source ? ordinalByRole.get(flowEnds.source.split(".")[0]) : void 0;
+        const from = rebind(flowEnds.source);
+        const to = rebind(flowEnds.target);
+        carried.push({
+          flow: member,
+          keyword: flowKeyword(fm),
+          label: payload ?? typeText(member) ?? flowTransferredFeature(flowEnds),
+          name,
+          // The decoration rides the relationship, whose drawn direction
+          // runs from its first end to its second.
+          reversed: fromOrdinal !== void 0 && fromOrdinal > 0,
+          inherited: source !== usage,
+          message: fm.flowKind === "message",
+          row: {
+            text: this.flowRowText(member, { source: from, target: to }),
+            source: sourceOf2(member, uri)
+          }
+        });
+      }
+    }
+    return carried;
+  }
+  // REQ-402 — merge the transfers a relationship usage carries from its
+  // definitions into the `flows` compartment its own body already contributes,
+  // so one heading holds every transfer the usage transports.
+  // REQ-402 — Flows carried by a connection or interface usage
+  withCarriedFlowRows(compartments, carried) {
+    const rows = carried.filter((flow) => flow.inherited).map((flow) => flow.row);
+    if (!rows.length)
+      return compartments;
+    const out = [...compartments ?? []];
+    const existing = out.findIndex((compartment) => compartment.title === "flows");
+    if (existing >= 0)
+      out[existing] = { ...out[existing], items: [...out[existing].items, ...rows] };
+    else
+      out.push({ title: "flows", items: rows });
+    return out;
+  }
   // REQ-192/360/363 — the ONE recursive Interconnection View renderer. Given the
   // top-level `roots` to draw, it renders each part instance and nests its
   // internals recursively, drilling into a usage's type DEFINITION (+
@@ -164976,7 +165107,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
       for (const source of [part, ...this.inheritedFeatureOwnersOf(part, index2)]) {
         for (const member of membersOf(source)) {
           const relationship = member;
-          const emptyPrefixFlow = member.$type === "FlowStmt" && relationship.target !== void 0 && relationship.source === void 0;
+          const emptyPrefixFlow = isEmptyPrefixFlow(member);
           const emptyPrefixInterface = isInterfaceDecl(member) && relationship.target !== void 0 && relationship.connect === void 0;
           const namedRelationship = isConnectorDecl(member) || isConnectionDecl(member) || isInterfaceDecl(member) && !emptyPrefixInterface || member.$type === "BindingDecl" || member.$type === "FlowStmt" && !emptyPrefixFlow;
           if (namedRelationship) {
@@ -165133,16 +165264,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);
@@ -165150,7 +165281,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),
@@ -165334,6 +165465,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
   // synthetic n-ary dot with that container's frame id).
   emitInterconnectEdges(members, resolveEnd, parts, index2, uri, nodes, edges, eRef, frameId, actionPinIds = /* @__PURE__ */ new Set(), structuralPortIds = /* @__PURE__ */ new Set(), memberOwner, memberOwnerInherited = false, endpointProvenance = /* @__PURE__ */ new Map()) {
     const memberList2 = [...members];
+    const pendingFlows = [];
+    const firstEdge = edges.length;
     const relationshipFields = (source) => {
       let directMember = source;
       while (directMember.$container && directMember.$container !== memberOwner) {
@@ -165488,22 +165621,8 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           }
         }
       } else if (m.$type === "FlowStmt") {
-        const fm = m;
-        if (fm.flowKind === "message")
-          continue;
-        const { source, target } = this.flowStmtEnds(fm);
-        const from = resolveEnd(source ?? "");
-        const to = resolveEnd(target ?? "");
-        if (from && to && supportsEndpoints("flow", [from, to])) {
-          edges.push({
-            id: `e${eRef.n++}`,
-            from,
-            to,
-            kind: "flow",
-            label: this.flowPayloadText(fm) ?? typeText(m) ?? nameOf2(m),
-            ...relationshipFields(m)
-          });
-        }
+        if (m.isDef !== true)
+          pendingFlows.push(m);
       } else if (m.$type === "BindStmt" || m.$type === "BindingConnectorStmt" || m.$type === "BindingDecl") {
         const bn = m;
         const leftEnd = bn.left ?? bn.source;
@@ -165591,6 +165710,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             }
           };
         });
+        const carriedFlows = this.carriedFlowsOf(m, usageEnds, index2, uri);
         nodes.push({
           id: usageId,
           name: name ?? ANONYMOUS_INTERFACE_NAME,
@@ -165601,12 +165721,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           multiplicity: multText(m),
           ports,
           ...usageFrame ? { frame: usageFrame } : {},
-          compartments: this.compartmentsFor(m, uri, index2),
+          compartments: this.withCarriedFlowRows(this.compartmentsFor(m, uri, index2), carriedFlows),
           source: usageSource,
           meta: {
             ...relationship.meta ?? {},
             interfaceUsage: true,
-            ...name ? { explicitRelationshipName: name } : {}
+            ...name ? { explicitRelationshipName: name } : {},
+            ...flowDecorationMeta(carriedFlows)
           }
         });
         for (const { end, ordinal, targetId } of visibleUsageEnds) {
@@ -165675,6 +165796,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
             }
           };
         });
+        const carriedFlows = this.carriedFlowsOf(m, usageEnds, index2, uri);
         nodes.push({
           id: usageId,
           name: name ?? "connection",
@@ -165684,12 +165806,13 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           type,
           ports,
           ...usageFrame ? { frame: usageFrame } : {},
-          compartments: this.compartmentsFor(m, uri, index2),
+          compartments: this.withCarriedFlowRows(this.compartmentsFor(m, uri, index2), carriedFlows),
           source: usageSource,
           meta: {
             ...relationship.meta ?? {},
             connectionUsage: true,
-            ...name ? { explicitRelationshipName: name } : {}
+            ...name ? { explicitRelationshipName: name } : {},
+            ...flowDecorationMeta(carriedFlows)
           }
         });
         for (const { end, ordinal, targetId } of visibleUsageEnds) {
@@ -165717,6 +165840,92 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
         }
       }
     }
+    const resolveFlowEnd = (pathText) => {
+      const direct = resolveEnd(pathText);
+      if (direct)
+        return { id: direct, docked: false };
+      const parts2 = pathText.split(/(::|\.)/u).filter((part) => part.length > 0);
+      for (let length2 = parts2.length - 2; length2 >= 1; length2 -= 2) {
+        const carrier = resolveEnd(parts2.slice(0, length2).join(""));
+        if (carrier)
+          return { id: carrier, docked: true };
+      }
+      return void 0;
+    };
+    const transportFor = (from, to) => edges.slice(firstEdge).find((edge) => (edge.kind === "connect" || edge.kind === "interface") && (edge.from === from && edge.to === to || edge.from === to && edge.to === from));
+    const flowUsageNodeId = (flow) => {
+      const src = sourceOf2(flow, uri);
+      const ownerId = frameId ?? (qnameOf(memberOwner ?? flow) || "iv");
+      const suffix = (frameId ? flowStmtName(flow) : qnameOf(flow)) ?? (src ? `${src.range.start.line}_${src.range.start.character}` : `${eRef.n}`);
+      return `${ownerId}::__flow_${suffix}`;
+    };
+    for (const m of pendingFlows) {
+      const fm = m;
+      const message = fm.flowKind === "message";
+      const keyword = flowKeyword(fm);
+      const { source, target } = this.flowStmtEnds(fm);
+      const flowName = flowStmtName(m);
+      const sourceEnd = message ? void 0 : resolveFlowEnd(source ?? "");
+      const targetEnd = message ? void 0 : resolveFlowEnd(target ?? "");
+      const selfDock = sourceEnd !== void 0 && sourceEnd.id === targetEnd?.id && (sourceEnd.docked || targetEnd.docked);
+      const from = selfDock ? void 0 : sourceEnd?.id;
+      const to = selfDock ? void 0 : targetEnd?.id;
+      const transferred = flowTransferredFeature({ source, target });
+      const label = this.flowPayloadText(fm) ?? typeText(m) ?? transferred ?? flowName;
+      if (from && to && supportsEndpoints("flow", [from, to])) {
+        const transport = transportFor(from, to);
+        if (transport) {
+          const decorations = Array.isArray(transport.meta?.flowDecorations) ? transport.meta.flowDecorations : [];
+          transport.meta = {
+            ...transport.meta ?? {},
+            flowDecorations: [...decorations, {
+              keyword,
+              label,
+              ...flowName ? { name: flowName } : {},
+              reversed: transport.from === to,
+              source: sourceOf2(m, uri)
+            }]
+          };
+          continue;
+        }
+        edges.push({
+          id: `e${eRef.n++}`,
+          from,
+          to,
+          kind: "flow",
+          label,
+          ...relationshipFields(m)
+        });
+        continue;
+      }
+      if (message || !flowName)
+        continue;
+      const ownerNode = frameId ? nodes.find((node) => node.id === frameId) : void 0;
+      const ends = [
+        ...source ? [{ text: `from ${source}` }] : [],
+        ...target ? [{ text: `to ${target}` }] : []
+      ];
+      nodes.push({
+        id: flowUsageNodeId(m),
+        name: flowName,
+        keyword,
+        isDef: false,
+        shape: "box",
+        type: typeText(m),
+        multiplicity: multText(m),
+        ...ownerNode ? { frame: ownerNode.frame } : frameId ? { frame: frameId } : {},
+        compartments: [
+          ...label ? [{ title: "payload", items: [{ text: label }] }] : [],
+          ...ends.length ? [{ title: "ends", items: ends }] : []
+        ],
+        source: sourceOf2(m, uri),
+        meta: {
+          ...relationshipFields(m).meta ?? {},
+          flowUsage: true,
+          explicitRelationshipName: flowName
+        }
+      });
+    }
   }
   // ── iv overview (REQ-360) — recursive nested Interconnection View over a
   // package. The hierarchy follows COMPOSITION, not text layout: the roots are
@@ -167077,9 +167286,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
           const to = resolvePin(ends.target, occurrenceContext);
           if (from && to) {
             const kind = fm.succession === true ? "successionFlow" : "flow";
-            const sourceFeature = ends.source ? lastSeg(ends.source) : void 0;
-            const targetFeature = ends.target ? lastSeg(ends.target) : void 0;
-            const transferredFeature = sourceFeature === targetFeature ? sourceFeature : sourceFeature ?? targetFeature;
+            const transferredFeature = flowTransferredFeature(ends);
             edges.push({
               id: `e${e++}`,
               from,
@@ -169777,6 +169984,7 @@ var SysmlDiagramModelProvider = class _SysmlDiagramModelProvider {
     }
     add("connections", members.filter((member) => isConnectionDecl(member) && member.isDef !== true && isOrdinaryMember(member)).map((member) => item(member, this.featureText(member) || "(anonymous connection)")));
     add("interfaces", members.filter((m) => isInterfaceDecl(m) && m.isDef !== true && isOrdinaryMember(m)).map((m) => item(m, this.interfaceRowText(m))));
+    add("flows", members.filter((m) => m.$type === "FlowStmt" && m.isDef !== true && isOrdinaryMember(m)).map((m) => item(m, this.flowRowText(m))));
     add("features", members.filter((m) => m.$type === "FeatureShorthand" || m.$type === "FeatureRedefinitionShorthand").filter(isOrdinaryMember).filter((m) => !isOccurrenceModified(m)).map((m) => item(m, canonicalFeatureText(m))));
     const undirected = (guard) => usages(guard);
     add("items", undirected(isItemDecl).filter(notPortion).map((m) => item(m)));
@@ -170210,7 +170418,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
@@ -180911,6 +181121,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 === "{");
@@ -180969,6 +181502,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" },
@@ -180993,6 +181570,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 };
 }
@@ -181014,19 +181622,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;
@@ -181034,7 +181753,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({
@@ -181061,6 +181787,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) {
@@ -181102,6 +181833,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)) {
@@ -181171,6 +181913,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.
    *
@@ -181184,25 +182148,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;
@@ -183835,7 +184793,7 @@ function compartmentWidth(node) {
 }
 function nodeForCanvas(node) {
   if (node.meta?.connectionUsage === true || node.meta?.interfaceUsage === true) {
-    const compartments2 = node.compartments?.filter((compartment) => compartment.title === "doc");
+    const compartments2 = node.compartments?.filter((compartment) => compartment.title === "doc" || compartment.title === "flows");
     return {
       ...node,
       compartments: compartments2?.length ? compartments2 : void 0
@@ -184367,7 +185325,8 @@ function hideExplicitRelationshipBoxes(model, relationship) {
     bindings: explicitRelationshipBindings(usage, model),
     endCount: usage.ports?.length ?? 0
   }));
-  const retainedIds = new Set(projections.filter(({ usage, bindings, endCount }) => (nodeForCanvas(usage).compartments?.length ?? 0) > 0 || annotatedUsageIds.has(usage.id) || endCount < 2 || bindings.length !== endCount).map(({ usage }) => usage.id));
+  const blocksCompaction = ({ usage, endCount }) => (nodeForCanvas(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) {
     if (retainedIds.has(usage.id)) continue;
@@ -184424,6 +185383,8 @@ function hideExplicitRelationshipBoxes(model, relationship) {
       });
       continue;
     }
+    const hubMeta = { ...baseMeta };
+    delete hubMeta.flowDecorations;
     const hubId = `${usage.id}::__compact_hub`;
     compactNodes.push({
       id: hubId,
@@ -184434,7 +185395,7 @@ function hideExplicitRelationshipBoxes(model, relationship) {
       ...usage.frame ? { frame: usage.frame } : {},
       source: usage.source,
       meta: {
-        ...baseMeta,
+        ...hubMeta,
         naryConnectionHub: true,
         ...relationship === "connection" ? { compactConnectionUsageHub: true } : { compactInterfaceUsageHub: true }
       }
@@ -184454,7 +185415,7 @@ function hideExplicitRelationshipBoxes(model, relationship) {
         endAdornmentTo: binding.adornment,
         source: usage.source ?? binding.edge.source,
         meta: {
-          ...baseMeta,
+          ...hubMeta,
           ...relationship === "connection" ? { compactConnectionUsageEnd: true } : { compactInterfaceUsageEnd: true },
           connectionEndOrdinal: binding.ordinal,
           ...binding.role ? { connectionEndRole: binding.role } : {}
@@ -198165,6 +199126,45 @@ function successionFlowLabelPoint(centre, mark) {
     y: markCoordinate(centre.y - mark.normal.y * 16)
   };
 }
+function flowDecorationsOf(edge) {
+  const raw = edge.meta?.flowDecorations;
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const decoration = entry;
+    return [{
+      keyword: typeof decoration.keyword === "string" ? decoration.keyword : "flow",
+      label: typeof decoration.label === "string" ? decoration.label : void 0,
+      name: typeof decoration.name === "string" ? decoration.name : void 0,
+      reversed: decoration.reversed === true
+    }];
+  });
+}
+var FLOW_DECORATION_STEP = 26;
+function flowDecorationGeometry(centre, points, source, target, index2, count, reversed) {
+  const raw = midpointTangent(points?.length ? points : [source, target]) ?? { x: target.x - source.x, y: target.y - source.y };
+  const length2 = Math.hypot(raw.x, raw.y);
+  if (length2 <= 0) return void 0;
+  const tangent = { x: raw.x / length2, y: raw.y / length2 };
+  const normal = { x: -tangent.y, y: tangent.x };
+  const shift = (index2 - (count - 1) / 2) * FLOW_DECORATION_STEP;
+  const at = { x: centre.x + tangent.x * shift, y: centre.y + tangent.y * shift };
+  const sign = reversed ? -1 : 1;
+  const tip = { x: at.x + tangent.x * 5 * sign, y: at.y + tangent.y * 5 * sign };
+  const back = { x: at.x - tangent.x * 4 * sign, y: at.y - tangent.y * 4 * sign };
+  const corner = (side) => ({
+    x: back.x + normal.x * 4 * side,
+    y: back.y + normal.y * 4 * side
+  });
+  const wing = [corner(1), corner(-1)];
+  return {
+    chevron: [tip, wing[0], wing[1]].map((point) => `${markCoordinate(point.x)},${markCoordinate(point.y)}`).join(" "),
+    label: {
+      x: markCoordinate(at.x + normal.x * 13),
+      y: markCoordinate(at.y + normal.y * 13)
+    }
+  };
+}
 function routePointNearSource(points, source, target, distance2) {
   const route = [source, ...points ?? [], target].filter((point, index2, all) => index2 === 0 || point.x !== all[index2 - 1].x || point.y !== all[index2 - 1].y);
   let remaining = distance2;
@@ -199194,6 +200194,13 @@ body {
 .dlink { stroke: var(--diagram-line-structural); stroke-width: 1.2; fill: none; }
 .dlink.successionFlow { stroke-width: 2; }
 .dsuccession-flow-mark { pointer-events: none; stroke-linecap: butt; }
+/* REQ-401 \u2014 OMG 8.2.3.16 flow-on-connection: the payload chevron rides the
+   connector that transports it, in the item-flow hue, and never takes pointer
+   events away from the connector it decorates. */
+.dflow-decoration {
+  pointer-events: none; stroke: none;
+  fill: var(--diagram-line-connection, #6cd1d9);
+}
 /* REQ-196: AFV control transitions (IR succession) use a dotted route so
    they remain visually distinct from continuous item and succession flows. */
 .dlink.succession { stroke-dasharray: 1 3; stroke-linecap: round; }
@@ -200373,6 +201380,24 @@ function buildDiagramSvg(options) {
       extendPoint(sequencingMark.x1, sequencingMark.y1, 2);
       extendPoint(sequencingMark.x2, sequencingMark.y2, 2);
     }
+    const decorations = semantic ? flowDecorationsOf(semantic) : [];
+    decorations.forEach((decoration, index2) => {
+      const placement = flowDecorationGeometry(
+        geometry.label,
+        geometry.points ?? geometry.anchors,
+        geometry.source,
+        geometry.target,
+        index2,
+        decorations.length,
+        decoration.reversed === true
+      );
+      if (!placement) return;
+      edgeParts.push(`<polygon class="dflow-decoration ${decoration.keyword.replace(/\s+/gu, "-")}" points="${placement.chevron}"/>`);
+      const text = [decoration.name, decoration.label].filter(Boolean).join(" : ");
+      if (!text) return;
+      labelParts.push(labelSvg(text, placement.label.x, placement.label.y, "elabel flow"));
+      extendLabel(text, placement.label.x, placement.label.y);
+    });
     extendPoint(geometry.source.x, geometry.source.y, MARKER_ALLOWANCE);
     extendPoint(geometry.target.x, geometry.target.y, MARKER_ALLOWANCE);
     for (const point of geometry.points ?? geometry.anchors) extendPoint(point.x, point.y, MARKER_ALLOWANCE);
@@ -203682,7 +204707,7 @@ async function runExport(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.23.0" : "dev";
+var VERSION2 = true ? "0.25.0" : "dev";
 function display(file) {
   const rel2 = path9.relative(process.cwd(), file);
   return rel2 && !rel2.startsWith("..") ? rel2.split(path9.sep).join("/") : file;