sysml-v2-lsp 0.40.0 → 0.41.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.41.0]
+
+### Changed
+
+- Update the pinned grammar to `v2026.09.1` (OMG release `2026-09.1`) and refresh the parser and DFA snapshot with `make update-grammar`. The lexer and parser grammars are unchanged from `v2026.09.0`; this introduces no language behavior changes.
+
+### Fixed
+
+- `sysml/model` reports an element's prefix from its own prefix and multiplicity productions (SysML 8.2.2.6.2 `RefPrefix`, `BasicUsagePrefix`, `EndUsagePrefix`, 8.2.2.6.6 `MultiplicityPart`): `modifier` now includes `ref`, `constant` and `end`, in written order; `direction` is reported for every usage, not only ports; `ordered: true` and `nonunique: true` when written. A keyword in a member's or an owned feature's declaration (e.g. a transition's trigger payload or guard), in a name or reference spelled like a keyword (`var`), or in a comment is no longer credited to the element.
+- `readonly`, which is not a keyword in the SysML v2 grammar (KERML_-57 renamed it to `constant`), is no longer reported in `modifier` when written; completion offers `constant` instead. Resolved features have `isConstant`.
+- `sysml/model` reports the value of every kind of usage, not only attributes, read from its own `ValuePart` (SysML 8.2.2.6.2): the expression after `=`, `:=` or `default`, with `isDefault` and `isInitial` for a default and an initial value (SysML 7.13.4). A cross subsetting (`=> x`) is no longer reported as a value.
+- `sysml/model` reports an element's specializations from its own declaration only (SysML 8.2.2.6.1, 8.2.2.6.2), one relationship per target with its `notation`: a usage's `:>` as `subsetting` (not `specializes`), every `:>>` target as `redefinition`, and new `referenceSubsetting` (`::>`, `perform a`) and `crossSubsetting` (`=>`). A definition's `:>`, an anonymous redefinition and a transition's trigger payload are no longer reported as typings, a target keeps `$::` and a conjugated port typing's `~`, and `resolvedTypes` covers each usage with specializations of its own, its `specializes` listing the same targets.
+
+### Deprecated
+
+- The resolved features' `isReadonly`: use `isConstant` instead, which it always equals. It will be removed in a future release.
+
 ## [0.40.0]
 
 ### Security

package/dist/server/browserServerMain.js

@@ -130404,7 +130404,10 @@ ${JSON.stringify(message, null, 4)}`);
     return parts;
   }
   function joinQualifiedName(parts) {
-    return parts.map((part) => /::|['\\\r\n\t\b\f]|^\s|\s$/.test(part) ? quoteName(part) : part).join("::");
+    return parts.map((part) => /::|^:|:$|['\\\r\n\t\b\f]|^\s|\s$|^\$?$/.test(part) ? quoteName(part) : part).join("::");
+  }
+  function joinReference(chain, conjugated = false) {
+    return (conjugated ? "~" : "") + chain.map(({ global, names }) => (global ? "$::" : "") + names.map((name) => /\.|^~/.test(name) ? quoteName(name) : joinQualifiedName([name])).join("::")).join(".");
   }
   function readNameAt(text, start, allowIncomplete = false) {
     if (text[start] === "'") {
@@ -131830,12 +131833,44 @@ ${JSON.stringify(message, null, 4)}`);
   var BODY_RULE_INDICES = new Set(
     SysMLv2Parser.ruleNames.flatMap((ruleName, index2) => ruleName.endsWith("Body") ? [index2] : [])
   );
+  var VALUE_DECLARATION_RULE_INDICES = /* @__PURE__ */ new Set([
+    SysMLv2Parser.RULE_usage,
+    SysMLv2Parser.RULE_usageCompletion,
+    SysMLv2Parser.RULE_actionUsageDeclaration,
+    SysMLv2Parser.RULE_performActionUsageDeclaration,
+    SysMLv2Parser.RULE_constraintUsageDeclaration,
+    SysMLv2Parser.RULE_interfaceUsageDeclaration,
+    SysMLv2Parser.RULE_flowDeclaration,
+    SysMLv2Parser.RULE_messageDeclaration
+  ]);
   var FLOW_PART_RULE_INDICES = /* @__PURE__ */ new Set([
     SysMLv2Parser.RULE_payloadFeatureMember,
     SysMLv2Parser.RULE_flowPayloadFeatureMember,
     SysMLv2Parser.RULE_flowEndMember,
     SysMLv2Parser.RULE_messageEventMember
   ]);
+  var SPECIALIZATION_DECLARATION_RULE_INDICES = /* @__PURE__ */ new Set([
+    SysMLv2Parser.RULE_definition,
+    SysMLv2Parser.RULE_definitionDeclaration,
+    SysMLv2Parser.RULE_usage,
+    SysMLv2Parser.RULE_usageDeclaration,
+    SysMLv2Parser.RULE_featureDeclaration,
+    SysMLv2Parser.RULE_featureSpecializationPart,
+    SysMLv2Parser.RULE_actionUsageDeclaration,
+    SysMLv2Parser.RULE_performActionUsageDeclaration,
+    SysMLv2Parser.RULE_constraintUsageDeclaration,
+    SysMLv2Parser.RULE_interfaceUsageDeclaration,
+    SysMLv2Parser.RULE_allocationUsageDeclaration,
+    SysMLv2Parser.RULE_flowDeclaration,
+    SysMLv2Parser.RULE_messageDeclaration
+  ]);
+  var REFERENCE_SHORTHAND_RULE_INDICES = /* @__PURE__ */ new Set([
+    SysMLv2Parser.RULE_variantReference,
+    SysMLv2Parser.RULE_performActionUsageDeclaration,
+    SysMLv2Parser.RULE_exhibitStateUsage,
+    SysMLv2Parser.RULE_framedConcernUsage,
+    SysMLv2Parser.RULE_includeUseCaseUsage
+  ]);
   var FLOW_DECLARATION_RULE_INDICES = [
     SysMLv2Parser.RULE_flowDeclaration,
     SysMLv2Parser.RULE_messageDeclaration
@@ -131941,6 +131976,50 @@ ${JSON.stringify(message, null, 4)}`);
     SysMLv2Parser.RULE_endFeaturePrefix
     // 86
   ]);
+  var PREFIX_KEYWORD_TOKENS = /* @__PURE__ */ new Set([
+    SysMLv2Lexer.IN,
+    SysMLv2Lexer.OUT,
+    SysMLv2Lexer.INOUT,
+    SysMLv2Lexer.ABSTRACT,
+    SysMLv2Lexer.VARIATION,
+    SysMLv2Lexer.INDIVIDUAL,
+    SysMLv2Lexer.DERIVED,
+    SysMLv2Lexer.CONSTANT,
+    SysMLv2Lexer.REF,
+    SysMLv2Lexer.END,
+    SysMLv2Lexer.ORDERED,
+    SysMLv2Lexer.NONUNIQUE
+  ]);
+  var PREFIX_PATH_RULE_INDICES = /* @__PURE__ */ new Set([
+    SysMLv2Parser.RULE_usagePrefix,
+    SysMLv2Parser.RULE_unextendedUsagePrefix,
+    SysMLv2Parser.RULE_basicUsagePrefix,
+    SysMLv2Parser.RULE_endUsagePrefix,
+    SysMLv2Parser.RULE_refPrefix,
+    SysMLv2Parser.RULE_featureDirection,
+    SysMLv2Parser.RULE_occurrenceUsagePrefix,
+    SysMLv2Parser.RULE_controlNodePrefix,
+    SysMLv2Parser.RULE_definitionPrefix,
+    SysMLv2Parser.RULE_basicDefinitionPrefix,
+    SysMLv2Parser.RULE_occurrenceDefinitionPrefix,
+    SysMLv2Parser.RULE_usage,
+    SysMLv2Parser.RULE_usageDeclaration,
+    SysMLv2Parser.RULE_featureDeclaration,
+    SysMLv2Parser.RULE_featureSpecializationPart,
+    SysMLv2Parser.RULE_multiplicityPart,
+    SysMLv2Parser.RULE_actionUsageDeclaration,
+    SysMLv2Parser.RULE_performActionUsageDeclaration,
+    SysMLv2Parser.RULE_constraintUsageDeclaration,
+    SysMLv2Parser.RULE_interfaceUsageDeclaration,
+    SysMLv2Parser.RULE_allocationUsageDeclaration,
+    SysMLv2Parser.RULE_flowDeclaration,
+    SysMLv2Parser.RULE_messageDeclaration
+  ]);
+  var OCCURRENCE_USAGE_ELEMENT_RULE_INDICES = /* @__PURE__ */ new Set([
+    SysMLv2Parser.RULE_occurrenceUsageElement,
+    SysMLv2Parser.RULE_structureUsageElement,
+    SysMLv2Parser.RULE_behaviorUsageElement
+  ]);
   var TYPE_SPECIALIZATION_RULE_INDICES = /* @__PURE__ */ new Set([
     SysMLv2Parser.RULE_specialization,
     // 66
@@ -132775,6 +132854,9 @@ ${JSON.stringify(message, null, 4)}`);
       const typeName = typeNames[0];
       const documentation = this.extractDocumentation(ctx);
       const visibility = this.extractVisibility(ctx);
+      const featureValue = this.extractFeatureValue(ctx);
+      const prefixKeywords = this.extractPrefixKeywords(ctx);
+      const ownedSpecializations = this.extractOwnedSpecializations(ctx);
       const { multiplicity, multiplicityRange } = isUsage(kind) ? this.extractMultiplicity(ctx) : {};
       const metadataAnnotations = this.extractPrefixMetadataAnnotations(ctx);
       const isView = kind === "view" /* ViewUsage */ || kind === "view def" /* ViewDef */;
@@ -132807,6 +132889,9 @@ ${JSON.stringify(message, null, 4)}`);
         namingReference,
         documentation,
         visibility,
+        featureValue,
+        prefixKeywords: prefixKeywords.length > 0 ? prefixKeywords : void 0,
+        ownedSpecializations: ownedSpecializations.length > 0 ? ownedSpecializations : void 0,
         source: transition?.source,
         target: transition?.target,
         flowDetails,
@@ -133190,7 +133275,23 @@ ${JSON.stringify(message, null, 4)}`);
      * between two of them (`connect a.p to b.p`, `connection : Conn`).
      */
     declarationText(ctx) {
-      const tokens = this.declarationTokens(ctx);
+      return this.tokensText(this.declarationTokens(ctx));
+    }
+    /** Every token of `ctx`, in source order: a whole expression, bodies and `;` included. */
+    subtreeTokens(ctx, tokens = []) {
+      for (let i = 0; i < ctx.getChildCount(); i++) {
+        const child = ctx.getChild(i);
+        if (child instanceof TerminalNode) {
+          if (child.symbol.tokenIndex >= 0) tokens.push(child.symbol);
+        } else if (child instanceof ParserRuleContext) this.subtreeTokens(child, tokens);
+      }
+      return tokens;
+    }
+    /**
+     * Tokens joined as written, with one space wherever the source has
+     * whitespace or a comment between two of them.
+     */
+    tokensText(tokens) {
       let text = "";
       tokens.forEach((token, i) => {
         if (i > 0 && token.start > tokens[i - 1].stop + 1) text += " ";
@@ -133296,6 +133397,139 @@ ${JSON.stringify(message, null, 4)}`);
       }
       return void 0;
     }
+    /**
+     * `ctx`'s own feature value (SysML 7.13.4, 8.2.2.6.2 `ValuePart`, `FeatureValue`):
+     * its expression as written, and whether it is a default (`default`) and an
+     * initial (`:=`) value. Never a nested element's value; a cross subsetting
+     * (`=> x`) is not a value. The expression is the whole `OwnedExpression`,
+     * expression bodies included, with whitespace and comments as one space.
+     */
+    extractFeatureValue(ctx) {
+      const featureValueCtx = this.findOwnValuePart(ctx)?.getRuleContext(0, FeatureValueContext);
+      const expression = featureValueCtx?.ownedExpression();
+      const text = expression && this.tokensText(this.subtreeTokens(expression));
+      if (!featureValueCtx || !text) return void 0;
+      return {
+        expression: text,
+        isDefault: featureValueCtx.DEFAULT() !== null,
+        isInitial: featureValueCtx.COLON_EQ() !== null
+      };
+    }
+    /**
+     * `ctx`'s own `ValuePart`: a direct child of its element rule, or of one of
+     * its declaration rules (`VALUE_DECLARATION_RULE_INDICES`). Never one of an
+     * inline-owned element, e.g. a transition's accept payload or effect action.
+     */
+    findOwnValuePart(ctx) {
+      for (let i = 0; i < ctx.getChildCount(); i++) {
+        const child = ctx.getChild(i);
+        if (!(child instanceof ParserRuleContext)) continue;
+        if (child.ruleIndex === SysMLv2Parser.RULE_valuePart) return child;
+        if (!VALUE_DECLARATION_RULE_INDICES.has(child.ruleIndex)) continue;
+        const valuePart = this.findOwnValuePart(child);
+        if (valuePart) return valuePart;
+      }
+      return void 0;
+    }
+    /**
+     * The specializations of `ctx`'s own declaration, one per target in written
+     * order, read only from its `FeatureSpecialization`s (SysML v2 8.2.2.6.2),
+     * `SubclassificationPart` (8.2.2.6.1) and a shorthand's reference
+     * (`perform a`, `REFERENCE_SHORTHAND_RULE_INDICES`), reached through
+     * `SPECIALIZATION_DECLARATION_RULE_INDICES`.
+     */
+    extractOwnedSpecializations(ctx) {
+      const specializations = [];
+      const add = (kind, targets, notation) => {
+        for (const targetCtx of targets) {
+          const target = targetCtx && this.specializationTarget(targetCtx);
+          if (target) specializations.push(notation ? { kind, target, notation: notation.getText() } : { kind, target });
+        }
+      };
+      const visit = (node) => {
+        for (let i = 0; i < node.getChildCount(); i++) {
+          const child = node.getChild(i);
+          if (child instanceof FeatureSpecializationContext) {
+            const typings = child.typings();
+            const subsettings = child.subsettings();
+            const references = child.references();
+            const crosses = child.crosses();
+            const redefinitions = child.redefinitions();
+            if (typings) {
+              const typedBy = typings.typedBy();
+              add("typing", [typedBy?.featureTyping(), ...typings.featureTyping()].map((typing) => typing && (typing.ownedFeatureTyping() ?? typing.conjugatedPortTyping())));
+            } else if (subsettings) {
+              const subsets = subsettings.subsets();
+              add("subsetting", [subsets?.ownedSubsetting(), ...subsettings.ownedSubsetting()], subsets && (subsets.COLON_GT() ?? subsets.SUBSETS()));
+            } else if (references) {
+              add("referenceSubsetting", [references.ownedReferenceSubsetting()], references.COLON_COLON_GT() ?? references.REFERENCES());
+            } else if (crosses) {
+              add("crossSubsetting", [crosses.ownedCrossSubsetting()], crosses.FAT_ARROW() ?? crosses.CROSSES());
+            } else if (redefinitions) {
+              const redefines = redefinitions.redefines();
+              add("redefinition", [redefines?.ownedRedefinition(), ...redefinitions.ownedRedefinition()], redefines && (redefines.COLON_GT_GT() ?? redefines.REDEFINES()));
+            }
+          } else if (child instanceof OwnedReferenceSubsettingContext && REFERENCE_SHORTHAND_RULE_INDICES.has(node.ruleIndex)) {
+            add("referenceSubsetting", [child]);
+          } else if (child instanceof SubclassificationPartContext) {
+            add("specializes", child.ownedSubclassification(), child.COLON_GT() ?? child.SPECIALIZES());
+          } else if (child instanceof ParserRuleContext && SPECIALIZATION_DECLARATION_RULE_INDICES.has(child.ruleIndex)) {
+            visit(child);
+          }
+        }
+      };
+      visit(ctx);
+      return specializations;
+    }
+    /**
+     * The general type or feature a specialization's target rule names: its
+     * qualified name, or its feature chain (`v.engine`), with a global `$::`
+     * (KerML 7.2.2) and a conjugated port typing's `~` (`~P`, SysML 8.3.12.3).
+     * Its names are quoted as everywhere in the server (`joinReference`).
+     * Undefined for a target missing after a syntax error.
+     */
+    specializationTarget(ctx) {
+      const chain = ctx.getRuleContexts(QualifiedNameContext).map((qualifiedName) => ({
+        global: qualifiedName.DOLLAR() !== null,
+        names: qualifiedName.getRuleContexts(NameContext).map((name) => name.getText())
+      }));
+      if (chain.length === 0 || chain.some(({ names }) => names.length === 0 || names.some((name) => !name))) return void 0;
+      return joinReference(
+        chain.map(({ global, names }) => ({ global, names: names.map(unquoteName) })),
+        ctx instanceof ConjugatedPortTypingContext
+      );
+    }
+    /**
+     * The keywords of `ctx`'s own prefix and multiplicity part, in written
+     * order (`in`, `abstract`, `constant`, `ref`, `end`, `ordered`, ...),
+     * read only from the rules in `PREFIX_PATH_RULE_INDICES`.
+     */
+    extractPrefixKeywords(ctx) {
+      const keywords = [];
+      const visit = (node) => {
+        for (let i = 0; i < node.getChildCount(); i++) {
+          const child = node.getChild(i);
+          if (child instanceof TerminalNode) {
+            if (PREFIX_KEYWORD_TOKENS.has(child.symbol.type)) keywords.push(child.getText());
+            continue;
+          }
+          if (child instanceof ParserRuleContext && PREFIX_PATH_RULE_INDICES.has(child.ruleIndex)) visit(child);
+        }
+      };
+      visit(ctx);
+      return this.isEndOccurrence(ctx) ? ["end", ...keywords] : keywords;
+    }
+    /**
+     * Whether `ctx` is the occurrence usage of an `endOccurrenceUsageElement`
+     * (`end part a`), whose `end` precedes the usage's own rule.
+     */
+    isEndOccurrence(ctx) {
+      let current = ctx.parent;
+      while (current instanceof ParserRuleContext && OCCURRENCE_USAGE_ELEMENT_RULE_INDICES.has(current.ruleIndex)) {
+        current = current.parent;
+      }
+      return current !== ctx.parent && current instanceof ParserRuleContext && current.ruleIndex === SysMLv2Parser.RULE_endOccurrenceUsageElement;
+    }
     /**
      * Extract the range of just the name token.
      */
@@ -137633,22 +137867,6 @@ ${JSON.stringify(message, null, 4)}`);
     const start = skipWS(text, afterPos);
     return readIdent(text, start, allowDots);
   }
-  function readCommaSeparatedIdents(text, pos) {
-    const names = [];
-    let p = skipWS(text, pos);
-    while (p < text.length) {
-      const [name, end] = readIdent(text, p);
-      if (!name) break;
-      names.push(name);
-      p = skipWS(text, end);
-      if (p < text.length && text[p] === ",") {
-        p = skipWS(text, p + 1);
-      } else {
-        break;
-      }
-    }
-    return names;
-  }
   function symbolsById(symbols) {
     return new Map(symbols.map((s) => [s.symbolId, s]));
   }
@@ -137694,7 +137912,7 @@ ${JSON.stringify(message, null, 4)}`);
         result.activityDiagrams = this.extractActivityDiagrams(symbolTable, uri, lines);
       }
       if (scopeSet.has("resolvedTypes")) {
-        result.resolvedTypes = this.extractResolvedTypes(symbolTable, uri, lines);
+        result.resolvedTypes = this.extractResolvedTypes(symbolTable, uri);
       }
       if (scopeSet.has("diagnostics")) {
         result.diagnostics = this.extractSemanticDiagnostics(symbolTable, uri);
@@ -137793,44 +138011,34 @@ ${JSON.stringify(message, null, 4)}`);
       if (symbol.viewRendering) {
         attributes["viewRendering"] = symbol.viewRendering;
       }
-      const direction = this.extractDirection(symbol, lines);
-      if (direction) {
-        attributes["direction"] = direction;
+      const prefix = prefixAttributesOf(symbol);
+      if (prefix.direction) {
+        attributes["direction"] = prefix.direction;
       }
       if (symbol.multiplicity) {
         attributes["multiplicity"] = symbol.multiplicity;
       }
-      const modifier = this.extractModifier(symbol, lines);
-      if (modifier) {
-        attributes["modifier"] = modifier;
+      if (prefix.modifier) {
+        attributes["modifier"] = prefix.modifier;
+      }
+      if (prefix.ordered) {
+        attributes["ordered"] = true;
+      }
+      if (prefix.nonunique) {
+        attributes["nonunique"] = true;
       }
       if (symbol.visibility) {
         attributes["visibility"] = symbol.visibility;
       }
-      const value = this.extractValue(symbol, lines);
-      if (value) {
-        attributes["value"] = value;
+      if (symbol.featureValue) {
+        attributes["value"] = symbol.featureValue.expression;
+        if (symbol.featureValue.isDefault) attributes["isDefault"] = true;
+        if (symbol.featureValue.isInitial) attributes["isInitial"] = true;
       }
       const relationships = [];
-      for (const tn of symbol.typeNames) {
-        relationships.push({
-          type: "typing",
-          source: symbol.name,
-          sourceId: symbol.symbolId,
-          target: tn
-        });
-      }
+      relationships.push(...this.specializationRelationships(symbol));
       const flowRelationship = this.flowRelationship(symbol);
       if (flowRelationship) relationships.push(flowRelationship);
-      const specializations = this.extractSpecializations(symbol, lines);
-      for (const spec of specializations) {
-        relationships.push({
-          type: "specializes",
-          source: symbol.name,
-          sourceId: symbol.symbolId,
-          target: spec
-        });
-      }
       return {
         type: symbol.kind,
         name: symbol.name,
@@ -137842,6 +138050,20 @@ ${JSON.stringify(message, null, 4)}`);
         relationships
       };
     }
+    /**
+     * The typings, subclassifications, subsettings and redefinitions of the
+     * element's own declaration, one per target in written order (SysML v2
+     * 8.2.2.6.1, 8.2.2.6.2).
+     */
+    specializationRelationships(symbol) {
+      return (symbol.ownedSpecializations ?? []).map(({ kind, target, notation }) => ({
+        type: kind,
+        source: symbol.name,
+        sourceId: symbol.symbolId,
+        target,
+        ...notation ? { notation } : {}
+      }));
+    }
     flowRelationship(symbol) {
       const details = symbol.flowDetails;
       if (!isFlowUsage(symbol.kind) || !details?.source || !details.target) return void 0;
@@ -137875,25 +138097,7 @@ ${JSON.stringify(message, null, 4)}`);
         if (symbol.kind === "package" /* Package */ || symbol.kind === "import" /* Import */ || symbol.kind === "comment" /* Comment */ || symbol.kind === "doc" /* Doc */) {
           continue;
         }
-        if (symbol.typeNames.length > 0 && isUsage(symbol.kind)) {
-          for (const tn of symbol.typeNames) {
-            relationships.push({
-              type: "typing",
-              source: symbol.name,
-              sourceId: symbol.symbolId,
-              target: tn
-            });
-          }
-        }
-        const specializations = this.extractSpecializations(symbol, lines);
-        for (const spec of specializations) {
-          relationships.push({
-            type: "specializes",
-            source: symbol.name,
-            sourceId: symbol.symbolId,
-            target: spec
-          });
-        }
+        relationships.push(...this.specializationRelationships(symbol));
         if (symbol.kind === "connection" /* ConnectionUsage */) {
           const connectionTargets = this.extractConnectionEndpoints(symbol, lines);
           if (connectionTargets.length === 2) {
@@ -138386,41 +138590,30 @@ ${JSON.stringify(message, null, 4)}`);
      * Because the LSP server doesn't yet have a full type resolver or library
      * index, we provide what's available from the parse tree.
      */
-    extractResolvedTypes(symbolTable, uri, lines) {
+    extractResolvedTypes(symbolTable, uri) {
       const symbols = symbolTable.getSymbolsForUri(uri);
       const result = {};
       for (const symbol of symbols) {
         const qualifiedName = symbol.qualifiedName;
         if (qualifiedName === void 0) continue;
-        if (!isDefinition(symbol.kind) && symbol.typeNames.length === 0) {
+        if (!isDefinition(symbol.kind) && !symbol.ownedSpecializations) {
           continue;
         }
-        const specializes = [];
-        const specList = this.extractSpecializations(symbol, lines);
-        for (const s of specList) {
-          if (!specializes.includes(s)) {
-            specializes.push(s);
-          }
-        }
-        for (const tn of symbol.typeNames) {
-          if (!specializes.includes(tn)) {
-            specializes.push(tn);
-          }
-        }
+        const specializes = [...new Set((symbol.ownedSpecializations ?? []).map(({ target }) => target))];
         const specializationChain = [...specializes];
         const children = this.getChildSymbols(symbol, symbolTable);
         const features = children.filter((c) => isUsage(c.kind)).map((c) => {
-          const modifier = this.extractModifier(c, lines);
-          const direction = this.extractDirection(c, lines);
+          const prefix = prefixAttributesOf(c);
           return {
             name: c.name,
             kind: toMetaclassName(c.kind),
             type: c.typeNames.join(", ") || void 0,
             multiplicity: c.multiplicity,
-            direction,
+            direction: prefix.direction,
             visibility: c.visibility,
-            isDerived: modifier?.split(", ").includes("derived") ?? false,
-            isReadonly: modifier?.split(", ").includes("readonly") ?? false
+            isDerived: prefix.keywords.includes("derived"),
+            isConstant: prefix.isConstant,
+            isReadonly: prefix.isConstant
           };
         });
         result[qualifiedName] = {
@@ -138537,67 +138730,6 @@ ${JSON.stringify(message, null, 4)}`);
       const endLine = Math.min(symbol.range.end.line, lines.length - 1);
       return lines.slice(startLine, endLine + 1).join("\n");
     }
-    /** Extract port direction (in | out | inout) from source text. */
-    extractDirection(symbol, lines) {
-      if (symbol.kind !== "port" /* PortUsage */ && symbol.kind !== "port def" /* PortDef */) {
-        return void 0;
-      }
-      const elementText = this.getElementText(symbol, lines);
-      if (containsWord(elementText, "inout")) return "inout";
-      if (containsWord(elementText, "in")) return "in";
-      if (containsWord(elementText, "out")) return "out";
-      return void 0;
-    }
-    /** Extract modifiers (abstract, readonly, derived, etc.) from source text. */
-    extractModifier(symbol, lines) {
-      const elementText = this.getElementText(symbol, lines);
-      const modifiers = [];
-      if (containsWord(elementText, "abstract")) modifiers.push("abstract");
-      if (containsWord(elementText, "readonly")) modifiers.push("readonly");
-      if (containsWord(elementText, "derived")) modifiers.push("derived");
-      if (containsWord(elementText, "variation")) modifiers.push("variation");
-      if (containsWord(elementText, "individual")) modifiers.push("individual");
-      return modifiers.length > 0 ? modifiers.join(", ") : void 0;
-    }
-    /** Extract default/assigned value from source text. */
-    extractValue(symbol, lines) {
-      if (symbol.kind !== "attribute" /* AttributeUsage */) {
-        return void 0;
-      }
-      const elementText = this.getElementText(symbol, lines);
-      const eqIdx = elementText.indexOf("=");
-      if (eqIdx < 0) return void 0;
-      let start = eqIdx + 1;
-      if (start < elementText.length && elementText[start] === "=") return void 0;
-      start = skipWS(elementText, start);
-      let end = start;
-      while (end < elementText.length) {
-        const ch = elementText[end];
-        if (ch === ";" || ch === "{" || ch === "}" || ch === "\n") break;
-        end++;
-      }
-      const val = elementText.substring(start, end).trim();
-      if (val && !val.includes("def") && val.length < 100) {
-        return val;
-      }
-      return void 0;
-    }
-    /** Extract all specialization targets from `:>` or `specializes` syntax. */
-    extractSpecializations(symbol, lines) {
-      const elementText = this.getElementText(symbol, lines);
-      const colonGtIdx = elementText.indexOf(":>");
-      if (colonGtIdx >= 0) {
-        if (colonGtIdx + 2 < elementText.length && elementText[colonGtIdx + 2] === ">") {
-        } else {
-          return readCommaSeparatedIdents(elementText, colonGtIdx + 2);
-        }
-      }
-      const specPositions = findWordPositions(elementText, "specializes");
-      if (specPositions.length > 0) {
-        return readCommaSeparatedIdents(elementText, specPositions[0].afterPos);
-      }
-      return [];
-    }
     /** Extract connection endpoints from `connect` syntax. */
     extractConnectionEndpoints(symbol, lines) {
       const elementText = this.getElementText(symbol, lines);
@@ -138661,16 +138793,6 @@ ${JSON.stringify(message, null, 4)}`);
       const fromElement = { source: elementName, sourceId: element.symbolId };
       elementText = stripComments(elementText);
       const rels = [];
-      const subsetsPositions = findWordPositions(elementText, "subsets");
-      if (subsetsPositions.length > 0) {
-        const [target] = readWordAfterKeyword(elementText, subsetsPositions[0].afterPos);
-        if (target) rels.push({ type: "subsetting", ...fromElement, target });
-      }
-      const redefPositions = findWordPositions(elementText, "redefines");
-      if (redefPositions.length > 0) {
-        const [target] = readWordAfterKeyword(elementText, redefPositions[0].afterPos);
-        if (target) rels.push({ type: "redefinition", ...fromElement, target });
-      }
       const satisfyPositions = findWordPositions(elementText, "satisfy");
       if (satisfyPositions.length > 0) {
         let pos = skipWS(elementText, satisfyPositions[0].afterPos);
@@ -138964,6 +139086,21 @@ ${this.followingBranchStatements(symbol, lines)}`;
       };
     }
   };
+  var DIRECTIONS = /* @__PURE__ */ new Set(["in", "out", "inout"]);
+  var MULTIPLICITY_KEYWORDS = /* @__PURE__ */ new Set(["ordered", "nonunique"]);
+  function prefixAttributesOf(symbol) {
+    const keywords = symbol.prefixKeywords ?? [];
+    const direction = keywords.find((keyword) => DIRECTIONS.has(keyword));
+    const modifiers = keywords.filter((keyword) => !DIRECTIONS.has(keyword) && !MULTIPLICITY_KEYWORDS.has(keyword));
+    return {
+      keywords,
+      direction,
+      modifier: modifiers.length > 0 ? modifiers.join(", ") : void 0,
+      isConstant: keywords.includes("constant"),
+      ordered: keywords.includes("ordered"),
+      nonunique: keywords.includes("nonunique")
+    };
+  }
 
   // server/src/platform/connection.browser.ts
   var import_browser = __toESM(require_browser3());
@@ -139640,7 +139777,7 @@ ${childIndent}item def ${sourceName};
     { label: "satisfy", kind: import_node2.CompletionItemKind.Operator, detail: "Satisfaction", documentation: "Indicates requirement satisfaction", insertText: "satisfy ${1:requirement} by ${2:element};", insertTextFormat: import_node2.InsertTextFormat.Snippet },
     // Modifiers
     { label: "abstract", kind: import_node2.CompletionItemKind.Keyword, detail: "Abstract modifier", documentation: "Makes element abstract" },
-    { label: "readonly", kind: import_node2.CompletionItemKind.Keyword, detail: "Readonly modifier", documentation: "Makes attribute readonly" },
+    { label: "constant", kind: import_node2.CompletionItemKind.Keyword, detail: "Constant modifier", documentation: "Makes feature constant" },
     { label: "derived", kind: import_node2.CompletionItemKind.Keyword, detail: "Derived modifier", documentation: "Indicates value is derived/calculated" },
     { label: "in", kind: import_node2.CompletionItemKind.Keyword, detail: "Input direction", documentation: "Port/parameter receives input" },
     { label: "out", kind: import_node2.CompletionItemKind.Keyword, detail: "Output direction", documentation: "Port/parameter provides output" },