sysml-v2-lsp 0.34.0 → 0.36.0

package/dist/server/browserServerMain.js

@@ -3362,7 +3362,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         uinteger3.is = is;
       })(uinteger || (uinteger = {}));
-      (function(Position4) {
+      (function(Position5) {
         function create(line, character) {
           if (line === Number.MAX_VALUE) {
             line = uinteger.MAX_VALUE;
@@ -3372,14 +3372,14 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return { line, character };
         }
-        Position4.create = create;
+        Position5.create = create;
         function is(value) {
           const candidate = value;
           return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
         }
-        Position4.is = is;
+        Position5.is = is;
       })(Position || (Position = {}));
-      (function(Range4) {
+      (function(Range5) {
         function create(one, two, three, four) {
           if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
             return { start: Position.create(one, two), end: Position.create(three, four) };
@@ -3389,12 +3389,12 @@ ${JSON.stringify(message, null, 4)}`);
             throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
           }
         }
-        Range4.create = create;
+        Range5.create = create;
         function is(value) {
           const candidate = value;
           return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
         }
-        Range4.is = is;
+        Range5.is = is;
       })(Range || (Range = {}));
       (function(Location4) {
         function create(uri, range) {
@@ -12435,7 +12435,7 @@ ${JSON.stringify(message, null, 4)}`);
         }
         uinteger3.is = is;
       })(uinteger2 || (uinteger2 = {}));
-      (function(Position4) {
+      (function(Position5) {
         function create(line, character) {
           if (line === Number.MAX_VALUE) {
             line = uinteger2.MAX_VALUE;
@@ -12445,14 +12445,14 @@ ${JSON.stringify(message, null, 4)}`);
           }
           return { line, character };
         }
-        Position4.create = create;
+        Position5.create = create;
         function is(value) {
           let candidate = value;
           return Is2.objectLiteral(candidate) && Is2.uinteger(candidate.line) && Is2.uinteger(candidate.character);
         }
-        Position4.is = is;
+        Position5.is = is;
       })(Position2 || (Position2 = {}));
-      (function(Range4) {
+      (function(Range5) {
         function create(one, two, three, four) {
           if (Is2.uinteger(one) && Is2.uinteger(two) && Is2.uinteger(three) && Is2.uinteger(four)) {
             return { start: Position2.create(one, two), end: Position2.create(three, four) };
@@ -12462,12 +12462,12 @@ ${JSON.stringify(message, null, 4)}`);
             throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
           }
         }
-        Range4.create = create;
+        Range5.create = create;
         function is(value) {
           let candidate = value;
           return Is2.objectLiteral(candidate) && Position2.is(candidate.start) && Position2.is(candidate.end);
         }
-        Range4.is = is;
+        Range5.is = is;
       })(Range2 || (Range2 = {}));
       (function(Location4) {
         function create(uri, range) {
@@ -130252,6 +130252,10 @@ ${JSON.stringify(message, null, 4)}`);
   function canonicalUri(uri) {
     return uri.replace(/^file:\/\/\/([A-Za-z])(?::|%3[Aa])(?=\/|$)/, (_m, drive) => `file:///${drive.toLowerCase()}:`);
   }
+  function isInFolder(uri, folderUri) {
+    const folder = canonicalUri(folderUri);
+    return canonicalUri(uri).startsWith(folder.endsWith("/") ? folder : `${folder}/`);
+  }
   function isSameDocumentUri(a, b) {
     return a === b || canonicalUri(a) === canonicalUri(b);
   }
@@ -130410,6 +130414,7 @@ ${JSON.stringify(message, null, 4)}`);
   var NAMESPACE_URL = v5_default.URL;
   var DEFAULT_URL_PREFIX = "https://github.com/daltskin/sysml-v2-lsp/";
   var urlPrefix = DEFAULT_URL_PREFIX;
+  var folderPrefixes = [];
   function setProjectId(projectId) {
     if (projectId === void 0) {
       urlPrefix = DEFAULT_URL_PREFIX;
@@ -130419,8 +130424,14 @@ ${JSON.stringify(message, null, 4)}`);
     urlPrefix = `urn:uuid:${projectId.toLowerCase()}/`;
     return true;
   }
-  function getUrlPrefix() {
-    return urlPrefix;
+  function setFolderProjectIds(projectIds) {
+    const rejected = projectIds.filter((p) => !validate_default(p.projectId));
+    folderPrefixes = projectIds.filter((p) => validate_default(p.projectId)).map((p) => ({ folderUri: p.folderUri, prefix: `urn:uuid:${p.projectId.toLowerCase()}/` })).sort((a, b) => b.folderUri.length - a.folderUri.length);
+    return rejected;
+  }
+  function getUrlPrefix(uri) {
+    const match = uri === void 0 ? void 0 : folderPrefixes.find((f2) => isInFolder(uri, f2.folderUri));
+    return match?.prefix ?? urlPrefix;
   }
   function uuidV5(namespace, name) {
     return v5_default(name, namespace);
@@ -130502,6 +130513,10 @@ ${JSON.stringify(message, null, 4)}`);
         return "RequirementDefinition";
       case "requirement" /* RequirementUsage */:
         return "RequirementUsage";
+      case "concern def" /* ConcernDef */:
+        return "ConcernDefinition";
+      case "concern" /* ConcernUsage */:
+        return "ConcernUsage";
       case "constraint def" /* ConstraintDef */:
         return "ConstraintDefinition";
       case "constraint" /* ConstraintUsage */:
@@ -130624,7 +130639,7 @@ ${JSON.stringify(message, null, 4)}`);
       declaration.parentId = owner?.symbolId;
       const path = declaration.qualifiedName !== void 0 ? this.qualifiedNameAsWritten(declaration) : owner ? `${this.paths.get(owner)}/${segmentOf(declaration)}` : segmentOf(declaration);
       const namespace = owner ? this.topLevelOf(owner).symbolId : NAMESPACE_URL;
-      const key = owner ? path : getUrlPrefix() + encodeURIComponent(path);
+      const key = owner ? path : getUrlPrefix(declaration.uri) + encodeURIComponent(path);
       const groupId = this.uuidOf(namespace, key);
       this.groupKeys.set(groupId, { namespace, key, path });
       this.groupOf.set(declaration, groupId);
@@ -130809,6 +130824,12 @@ ${JSON.stringify(message, null, 4)}`);
     // 343
     [SysMLv2Parser.RULE_requirementDefinition, "requirement def" /* RequirementDef */],
     // 384
+    [SysMLv2Parser.RULE_concernDefinition, "concern def" /* ConcernDef */],
+    // 405
+    [SysMLv2Parser.RULE_concernUsage, "concern" /* ConcernUsage */],
+    // 406
+    [SysMLv2Parser.RULE_framedConcernUsage, "concern" /* ConcernUsage */],
+    // 394
     [SysMLv2Parser.RULE_constraintDefinition, "constraint def" /* ConstraintDef */],
     // 380
     [SysMLv2Parser.RULE_itemDefinition, "item def" /* ItemDef */],
@@ -130881,6 +130902,10 @@ ${JSON.stringify(message, null, 4)}`);
     // 268
     [SysMLv2Parser.RULE_performActionUsage, "perform action" /* PerformActionUsage */],
     // 298
+    // A state's `entry`/`do`/`exit` action (`exit action a : A;`, `exit a;`): the
+    // StatePerformActionUsage production, a PerformActionUsage without `perform`.
+    [SysMLv2Parser.RULE_statePerformActionUsage, "perform action" /* PerformActionUsage */],
+    // 352
     [SysMLv2Parser.RULE_exhibitStateUsage, "exhibit state" /* ExhibitStateUsage */],
     // 359
     [SysMLv2Parser.RULE_transitionUsage, "transition" /* TransitionUsage */],
@@ -131004,8 +131029,10 @@ ${JSON.stringify(message, null, 4)}`);
     // 210
     SysMLv2Parser.RULE_definition,
     // 192
-    SysMLv2Parser.RULE_usage
+    SysMLv2Parser.RULE_usage,
     // 208
+    SysMLv2Parser.RULE_payloadFeatureSpecializationPart
+    // 157
   ]);
   var DOC_RULE_INDICES = /* @__PURE__ */ new Set([
     SysMLv2Parser.RULE_comment,
@@ -131630,8 +131657,9 @@ ${JSON.stringify(message, null, 4)}`);
       const shortName = transition || isFlowUsage(kind) && !declaredName ? void 0 : this.extractShortName(ctx);
       const qualifiedName = anonymous || owner && owner.qualifiedName === void 0 ? void 0 : owner ? `${owner.qualifiedName}::${name}` : name;
       const selectionRange = anonymous ? ctx.start ? tokenToRange(ctx.start) : range : this.extractNameRange(ctx) ?? range;
-      const typeNames = isFlowUsage(kind) ? this.extractFlowTypeNames(ctx) : this.extractTypeNames(ctx);
+      const typeNames = isFlowUsage(kind) ? this.extractFlowTypeNames(ctx) : transition ? this.extractTransitionTypeNames(ctx) : this.extractTypeNames(ctx);
       const specializationNames = this.extractSpecializationNames(ctx);
+      const redefinedFeatureTargets = this.extractRedefinedFeatureTargets(ctx);
       const typeName = typeNames[0];
       const documentation = this.extractDocumentation(ctx);
       const visibility = this.extractVisibility(ctx);
@@ -131662,6 +131690,7 @@ ${JSON.stringify(message, null, 4)}`);
         typeName,
         typeNames,
         specializationNames,
+        redefinedFeatureTargets: redefinedFeatureTargets.length > 0 ? redefinedFeatureTargets : void 0,
         documentation,
         visibility,
         source: transition?.source,
@@ -131745,6 +131774,25 @@ ${JSON.stringify(message, null, 4)}`);
       const typeDeclaration = declaration && (this.findOwnHeaderRule(declaration, SysMLv2Parser.RULE_featureDeclaration) ?? this.findOwnHeaderRule(declaration, SysMLv2Parser.RULE_usageDeclaration));
       return typeDeclaration ? this.extractTypeNames(typeDeclaration) : [];
     }
+    /**
+     * A transition's own typing, then the types of the payload its trigger
+     * accepts (`accept cmd : Command`, `accept Command`; TriggerAction ->
+     * AcceptParameterPart -> PayloadParameter). Read from the parse tree only:
+     * the regex fallback of `extractTypeNames` runs on whitespace-free text, where
+     * the payload type runs into the guard, effect or target that follows it
+     * (`Commandifcmd`, `Commandthenbusy`).
+     */
+    extractTransitionTypeNames(ctx) {
+      const names = [];
+      this.collectTypeNamesFromTree(ctx, names, 0);
+      const trigger = this.findOwnHeaderRule(ctx, SysMLv2Parser.RULE_triggerActionMember);
+      const parameter = trigger && this.findRuleContext(trigger, SysMLv2Parser.RULE_payloadParameter);
+      if (parameter) {
+        const payload = this.findRuleContext(parameter, SysMLv2Parser.RULE_payloadFeature) ?? parameter;
+        this.collectTypeNamesFromTree(payload, names, 0);
+      }
+      return names;
+    }
     /** Find the first descendant of `ctx` with rule `ruleIndex`, in source order. */
     findRuleContext(ctx, ruleIndex) {
       const matches = [];
@@ -131870,7 +131918,7 @@ ${JSON.stringify(message, null, 4)}`);
      */
     anonymousDeclaration(ctx, kind, transition) {
       if (!isDefinition(kind) && !isUsage(kind)) return void 0;
-      if (transition && !(transition.source && transition.target) && this.extractTypeNames(ctx).length === 0) return void 0;
+      if (transition && !(transition.source && transition.target) && this.extractTransitionTypeNames(ctx).length === 0) return void 0;
       return this.declarationText(ctx);
     }
     /**
@@ -131894,15 +131942,28 @@ ${JSON.stringify(message, null, 4)}`);
      * such as `#metadata`.
      */
     findOwnHeaderRule(ctx, ruleIndex) {
+      const matches = [];
+      this.findOwnHeaderRules(ctx, ruleIndex, matches, true);
+      return matches[0];
+    }
+    findOwnHeaderRules(ctx, ruleIndex, matches, firstOnly = false) {
       for (let i = 0; i < ctx.getChildCount(); i++) {
         const child = ctx.getChild(i);
         if (!(child instanceof ParserRuleContext)) continue;
-        if (child.ruleIndex === ruleIndex) return child;
+        if (child.ruleIndex === ruleIndex) {
+          matches.push(child);
+          if (firstOnly) return;
+          continue;
+        }
         if (RULE_INDEX_TO_KIND.has(child.ruleIndex) || BODY_RULE_INDICES.has(child.ruleIndex) || child.ruleIndex === SysMLv2Parser.RULE_valuePart || FLOW_PART_RULE_INDICES.has(child.ruleIndex) || child.ruleIndex === SysMLv2Parser.RULE_ownedCrossMultiplicityMember || this.isPrefixOrExtensionContext(child)) continue;
-        const found = this.findOwnHeaderRule(child, ruleIndex);
-        if (found) return found;
+        this.findOwnHeaderRules(child, ruleIndex, matches, firstOnly);
+        if (firstOnly && matches.length > 0) return;
       }
-      return void 0;
+    }
+    extractRedefinedFeatureTargets(ctx) {
+      const targets = [];
+      this.findOwnHeaderRules(ctx, SysMLv2Parser.RULE_ownedRedefinition, targets);
+      return targets.map((target) => target.getText());
     }
     /**
      * A connection, interface or allocation usage's end reference paths, in
@@ -131930,13 +131991,7 @@ ${JSON.stringify(message, null, 4)}`);
       const segment = reference.getText().split(/::|\./).pop();
       return segment ? this.unquoteName(segment) : void 0;
     }
-    /**
-     * An element's declaration as written, without its body: its tokens up to
-     * its body or closing `;`, each exactly as written (a quoted name keeps its
-     * spaces), with one space wherever the source has whitespace or a comment
-     * between two of them (`connect a.p to b.p`, `connection : Conn`).
-     */
-    declarationText(ctx) {
+    declarationTokens(ctx) {
       const tokens = [];
       const visit = (node) => {
         for (let i = 0; i < node.getChildCount(); i++) {
@@ -131951,6 +132006,16 @@ ${JSON.stringify(message, null, 4)}`);
         return false;
       };
       visit(ctx);
+      return tokens;
+    }
+    /**
+     * An element's declaration as written, without its body: its tokens up to
+     * its body or closing `;`, each exactly as written (a quoted name keeps its
+     * spaces), with one space wherever the source has whitespace or a comment
+     * between two of them (`connect a.p to b.p`, `connection : Conn`).
+     */
+    declarationText(ctx) {
+      const tokens = this.declarationTokens(ctx);
       let text = "";
       tokens.forEach((token, i) => {
         if (i > 0 && token.start > tokens[i - 1].stop + 1) text += " ";
@@ -132091,17 +132156,16 @@ ${JSON.stringify(message, null, 4)}`);
       const names = [];
       this.collectTypeNamesFromTree(ctx, names, 0);
       if (names.length > 0) return names;
-      const fullText = ctx.getText();
-      const braceIdx = fullText.indexOf("{");
-      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
+      const { text: declarationText, quotedName } = this.maskedDeclaration(ctx);
+      let text = declarationText;
       text = text.replace(RE_KEYWORD_TRUNCATE, "");
       const specMatch = text.match(RE_SPEC);
       if (specMatch) {
         const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
         for (const part of specStr.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -132122,9 +132186,9 @@ ${JSON.stringify(message, null, 4)}`);
         const fullMatchIdx = text.indexOf(typingMatch[0]);
         const afterColon = text.substring(fullMatchIdx + 1).trim();
         for (const part of afterColon.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -132134,6 +132198,28 @@ ${JSON.stringify(message, null, 4)}`);
       }
       return names;
     }
+    /**
+     * The declaration tokens before the body, with each lexer STRING token
+     * replaced by a numbered placeholder (`'0'`, `'1'`, ...), and
+     * `quotedName`, which turns a placeholder in a part of that text back into
+     * the name. SysML 2.0 section 7.2.2 permits punctuation in unrestricted
+     * names (the STRING lexer production), so fallback regexes must never see
+     * their `:`, `:>`, `{` or keywords. Documentation is not a name token.
+     */
+    maskedDeclaration(ctx) {
+      const quoted = [];
+      const masked = this.declarationTokens(ctx).map((token) => {
+        const text = token.text ?? "";
+        return token.type === SysMLv2Lexer.STRING ? `'${quoted.push(text.slice(1, -1)) - 1}'` : text;
+      }).join("");
+      return {
+        text: masked,
+        quotedName: (part) => {
+          const qm = part.match(RE_QUOTED_NAME);
+          return qm ? quoted[Number(qm[1])] : void 0;
+        }
+      };
+    }
     /**
      * Extract only the specialization names (:> / specializes / subsets) from a context.
      * Uses the same tree-walk as extractTypeNames but restricted to
@@ -132144,17 +132230,15 @@ ${JSON.stringify(message, null, 4)}`);
       const names = [];
       this.collectNamesFromTree(ctx, names, 0, TYPE_SPECIALIZATION_RULE_INDICES);
       if (names.length > 0) return names;
-      const fullText = ctx.getText();
-      const braceIdx = fullText.indexOf("{");
-      let text = braceIdx >= 0 ? fullText.substring(0, braceIdx) : fullText;
-      text = text.replace(RE_KEYWORD_TRUNCATE_SPEC, "");
+      const { text: declarationText, quotedName } = this.maskedDeclaration(ctx);
+      const text = declarationText.replace(RE_KEYWORD_TRUNCATE_SPEC, "");
       const specMatch = text.match(RE_SPEC_WITH_SUBSETS);
       if (specMatch) {
         const specStr = text.substring(text.indexOf(specMatch[0]) + specMatch[0].indexOf(specMatch[1]));
         for (const part of specStr.split(",")) {
-          const qm = part.match(RE_QUOTED_NAME);
-          if (qm) {
-            names.push(qm[1]);
+          const quoted = quotedName(part);
+          if (quoted !== void 0) {
+            names.push(quoted);
             continue;
           }
           const m2 = part.trim().match(RE_IDENT_START);
@@ -132950,6 +133034,17 @@ ${JSON.stringify(message, null, 4)}`);
       }
       return this.wsSymbolTable;
     }
+    /**
+     * Rebuild the symbol tables of `uris` on next use, e.g. after their projectId
+     * changed, which changes their symbol IDs (see `setFolderProjectIds`).
+     */
+    invalidateSymbols(uris) {
+      for (const uri of uris) {
+        const cached = this.cache.get(uri);
+        if (cached) cached.symbolTable = void 0;
+        this.wsBuiltVersions.delete(uri);
+      }
+    }
     /**
      * Cache semantic diagnostics for the current document version.
      */
@@ -136348,14 +136443,21 @@ ${JSON.stringify(message, null, 4)}`);
      * namespace.
      */
     isLocallyVisible(symbol, name, indexes) {
-      return this.resolveQualifiedNameFrom(ownerKeyOf(symbol, indexes.byId), name, indexes) !== void 0;
+      return this.resolveNameFrom(symbol, name, indexes) !== void 0;
+    }
+    /**
+     * Resolve a (possibly qualified) name from the namespace containing
+     * `symbol`, respecting namespace membership and visibility.
+     */
+    resolveNameFrom(symbol, name, indexes) {
+      return this.resolveQualifiedNameFrom(ownerKeyOf(symbol, indexes.byId), name, indexes);
     }
     /**
      * Resolve a (possibly qualified) name to its symbol per §7.5.1, searching
      * outward from namespace `start` and its enclosing namespaces (its own resolved
      * members first, then its parent's, ...). Shared by `isLocallyVisible` (an
-     * ordinary reference resolving relative to its own enclosing namespace) and
-     * import-target resolution (an `import` declaration's target is itself a
+     * ordinary reference resolving relative to its own enclosing namespace),
+     * `resolveNameFrom`, and import-target resolution (an `import` declaration's target is itself a
      * qualifiedName, resolved the same relative way -- not as an absolute/global
      * name -- so a bare `import C;` inside a nested package can pick up a `C`
      * its own enclosing package already imported, per §7.5.1/§7.5.3).
@@ -139305,6 +139407,8 @@ ${childIndent}item def ${unresolvedType};
       // Requirements → Object
       case "requirement def" /* RequirementDef */:
       case "requirement" /* RequirementUsage */:
+      case "concern def" /* ConcernDef */:
+      case "concern" /* ConcernUsage */:
       case "actor" /* ActorUsage */:
       case "subject" /* SubjectUsage */:
       case "stakeholder" /* StakeholderUsage */:
@@ -140563,6 +140667,13 @@ ${info.documentation}`);
     "assert",
     "assume"
   ]);
+  var CONNECTOR_KINDS = /* @__PURE__ */ new Set([
+    "connection" /* ConnectionUsage */,
+    "interface" /* InterfaceUsage */,
+    "allocation" /* AllocationUsage */,
+    "flow" /* FlowUsage */,
+    "succession flow" /* SuccessionFlowUsage */
+  ]);
   var SemanticValidator = class _SemanticValidator {
     constructor(documentManager2) {
       this.documentManager = documentManager2;
@@ -140639,7 +140750,7 @@ ${info.documentation}`);
       diagnostics.push(...this.checkAmbiguousNamespaceName(symbols, allSymbols));
       diagnostics.push(...this.checkUnusedDefinitions(allSymbols, uri));
       diagnostics.push(...this.checkRedefinitionMultiplicity(symbols, indexes, text));
-      diagnostics.push(...this.checkPortCompatibility(text, uri, indexes));
+      diagnostics.push(...this.checkPortCompatibility(text, uri, symbols, indexes));
       diagnostics.push(...this.checkConstraintBodyReferences(text, uri, symbols, indexes));
       diagnostics.push(...this.checkCircularSpecialization(symbols, indexes));
       diagnostics.push(...this.checkUnsatisfiedRequirements(symbols, indexes));
@@ -140860,7 +140971,7 @@ ${info.documentation}`);
         opts?.text ? [opts.text] : []
       ));
       if (opts?.text && opts.uri) {
-        diagnostics.push(...instance.checkPortCompatibility(opts.text, opts.uri, indexes));
+        diagnostics.push(...instance.checkPortCompatibility(opts.text, opts.uri, symbolsInUri, indexes));
         diagnostics.push(...instance.checkConstraintBodyReferences(opts.text, opts.uri, symbolsInUri, indexes));
       }
       return instance.dedupeDiagnostics(diagnostics);
@@ -141223,17 +141334,20 @@ ${info.documentation}`);
      * - The connection is within an interface usage
      * - Both ports are untyped (empty port defs with no features)
      */
-    checkPortCompatibility(text, uri, indexes) {
+    checkPortCompatibility(text, uri, symbolsInUri, indexes) {
       if (!text) return [];
       const diagnostics = [];
       const lines = text.split("\n");
       const re = /\bconnect\s+([A-Za-z_][\w.]*)\s+to\s+([A-Za-z_][\w.]*)/g;
       let m2;
       while ((m2 = re.exec(text)) !== null) {
-        const left = m2[1].split(".").pop();
-        const right = m2[2].split(".").pop();
-        const lSym = (indexes.portsByName.get(left) ?? [])[0];
-        const rSym = (indexes.portsByName.get(right) ?? [])[0];
+        const leftPath = m2[1].split(".");
+        const rightPath = m2[2].split(".");
+        const left = leftPath[leftPath.length - 1];
+        const right = rightPath[rightPath.length - 1];
+        const scope = this.connectorScope(symbolsInUri, this.indexToRange(text, m2.index, 0).start, indexes);
+        const lSym = this.resolveConnectorEnd(leftPath, scope, indexes);
+        const rSym = this.resolveConnectorEnd(rightPath, scope, indexes);
         if (!lSym || !rSym) continue;
         const lType = lSym.typeNames[0] ?? lSym.typeName;
         const rType = rSym.typeNames[0] ?? rSym.typeName;
@@ -141283,6 +141397,55 @@ ${info.documentation}`);
       }
       return diagnostics;
     }
+    /**
+     * The innermost element around `position` that owns a connector declared
+     * there: the connector's own symbol, when it has one, is skipped.
+     */
+    connectorScope(symbols, position, indexes) {
+      const before = (a, b) => a.line < b.line || a.line === b.line && a.character <= b.character;
+      const size = (r) => (r.end.line - r.start.line) * 1e6 + (r.end.character - r.start.character);
+      let scope;
+      for (const s of symbols) {
+        if (!before(s.range.start, position) || !before(position, s.range.end)) continue;
+        if (!scope || size(s.range) < size(scope.range)) scope = s;
+      }
+      while (scope && CONNECTOR_KINDS.has(scope.kind)) scope = ownerOf(scope, indexes);
+      return scope;
+    }
+    /**
+     * The port that a connector end (`a.p`, `a.p.q`) names, resolved from
+     * `scope` outward: its first segment is a feature of `scope` or of one of
+     * its owners, each next one a feature of the one before. Two parts can each
+     * have a port of the same name, so an end is never matched by its last
+     * segment alone, except when the path does not resolve and the workspace
+     * has only one port of that name.
+     */
+    resolveConnectorEnd(path, scope, indexes) {
+      let feature;
+      for (let namespace = scope; namespace && !feature; namespace = ownerOf(namespace, indexes)) {
+        feature = this.findFeature(namespace, path[0], indexes);
+      }
+      for (const name of path.slice(1)) {
+        feature = feature && this.findFeature(feature, name, indexes);
+      }
+      if (feature) return feature.kind === "port" /* PortUsage */ ? feature : void 0;
+      const sameName = indexes.portsByName.get(path[path.length - 1]) ?? [];
+      return sameName.length === 1 ? sameName[0] : void 0;
+    }
+    /** The feature `name` of `owner`: its own member, else a member of one of its types or their supertypes. */
+    findFeature(owner, name, indexes) {
+      const own = (indexes.byParent.get(namespaceKeyOf(owner)) ?? []).find((s) => s.name === name);
+      if (own) return own;
+      for (const typeName of owner.typeNames) {
+        const type = this.namespaceResolver.resolveNameFrom(owner, typeName, indexes);
+        if (!type || !isDefinition(type.kind)) continue;
+        for (const definition of this.getSpecializationHierarchy(type, indexes).flat()) {
+          const member = (indexes.byParent.get(namespaceKeyOf(definition)) ?? []).find((s) => s.name === name);
+          if (member) return member;
+        }
+      }
+      return void 0;
+    }
     /**
      * Resolve the full type hierarchy for a type name by following
      * specialization chains transitively (max depth 10).
@@ -141330,7 +141493,7 @@ ${info.documentation}`);
         }
         const parent = this.findConstraintScopeSymbol(symbolsInUri, indexes, b.startLine);
         if (!parent) continue;
-        const parentMembers = indexes.byParent.get(namespaceKeyOf(parent)) ?? [];
+        const parentMembers = this.getConstraintScopeMembers(parent, indexes);
         if (parentMembers.length === 0) continue;
         const ignoredRanges = this.getIgnoredBodyRanges(b.body);
         const idRe = /\b([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*)\b/g;
@@ -141389,18 +141552,135 @@ ${info.documentation}`);
       const root = parentMembers.find((s) => s.name === path[0]);
       if (!root) return false;
       if (path.length === 1) return true;
-      let typeName = root.typeNames[0] ?? root.typeName;
+      let current = root;
       for (let i = 1; i < path.length; i++) {
+        const typeName = current.typeNames[0] ?? current.typeName;
         if (!typeName) return false;
-        const typeDefs = indexes.definitionsByName.get(typeName) ?? [];
-        const typeDef = typeDefs[0];
-        if (!typeDef) return false;
-        const member = (indexes.byParent.get(namespaceKeyOf(typeDef)) ?? []).find((s) => s.name === path[i]);
+        const typeDef = this.namespaceResolver.resolveNameFrom(current, typeName, indexes);
+        if (!typeDef || !isDefinition(typeDef.kind)) return false;
+        const member = this.getConstraintScopeMembers(typeDef, indexes, true).find((s) => s.name === path[i]);
         if (!member) return false;
-        typeName = member.typeNames[0] ?? member.typeName;
+        current = member;
       }
       return true;
     }
+    getConstraintScopeMembers(scope, indexes, publicOnly = false) {
+      const hierarchy = [[scope]];
+      const visited = /* @__PURE__ */ new Set([scope]);
+      let frontier = [scope];
+      while (frontier.length > 0) {
+        const next = [];
+        for (const current of frontier) {
+          for (const typeName of current.typeNames) {
+            const supertype = this.namespaceResolver.resolveNameFrom(current, typeName, indexes);
+            if (!supertype || !isDefinition(supertype.kind) || visited.has(supertype)) continue;
+            visited.add(supertype);
+            next.push(supertype);
+          }
+        }
+        if (next.length > 0) hierarchy.push(next);
+        frontier = next;
+      }
+      const membersByLevel = hierarchy.map((level) => level.flatMap((namespace) => indexes.byParent.get(namespaceKeyOf(namespace)) ?? []));
+      const hiddenMembers = /* @__PURE__ */ new Set();
+      for (let level = membersByLevel.length - 1; level >= 0; level--) {
+        for (const redefining of membersByLevel[level]) {
+          for (const target of redefining.redefinedFeatureTargets ?? []) {
+            const owner = ownerOf(redefining, indexes);
+            if (!owner) continue;
+            for (const candidate of this.resolveInheritedRedefinitionTarget(owner, target, hiddenMembers, indexes)) {
+              hiddenMembers.add(candidate.symbolId);
+            }
+          }
+          if (redefining.kind === "subject" /* SubjectUsage */) {
+            const owner = ownerOf(redefining, indexes);
+            if (!owner) continue;
+            for (const ancestor of this.getSpecializationHierarchy(owner, indexes).slice(1).flat()) {
+              for (const candidate of indexes.byParent.get(namespaceKeyOf(ancestor)) ?? []) {
+                if (candidate.kind === "subject" /* SubjectUsage */) hiddenMembers.add(candidate.symbolId);
+              }
+            }
+          }
+        }
+      }
+      const membersByName = /* @__PURE__ */ new Map();
+      for (let level = 0; level < membersByLevel.length; level++) {
+        for (const member of membersByLevel[level]) {
+          if (level > 0 && member.visibility === "private") continue;
+          if (publicOnly && member.visibility !== void 0 && member.visibility !== "public") continue;
+          if (hiddenMembers.has(member.symbolId) || membersByName.has(member.name)) continue;
+          membersByName.set(member.name, member);
+        }
+      }
+      return [...membersByName.values()];
+    }
+    resolveInheritedRedefinitionTarget(owner, target, alreadyRedefined, indexes) {
+      if (target.includes(".")) return [];
+      const segments = target.split("::");
+      const targetName = segments.pop()?.replace(/^'|'$/g, "");
+      if (!targetName) return [];
+      const qualifier = segments.join("::").replace(/^'|'$/g, "");
+      const matches = /* @__PURE__ */ new Map();
+      for (const supertype of this.resolveDirectSupertypes(owner, indexes)) {
+        const branch = this.getSpecializationHierarchy(supertype, indexes);
+        const anchors = qualifier ? branch.flat().filter((type) => this.matchesSpecializationQualifier(type, qualifier)) : [supertype];
+        for (const anchor of anchors) {
+          let frontier = [anchor];
+          const visited = new Set(frontier);
+          const candidates = [];
+          while (frontier.length > 0 && candidates.length === 0) {
+            for (const type of frontier) {
+              for (const member of indexes.byParent.get(namespaceKeyOf(type)) ?? []) {
+                if (member.name === targetName && member.visibility !== "private" && !alreadyRedefined.has(member.symbolId)) {
+                  candidates.push(member);
+                }
+              }
+            }
+            if (candidates.length > 0) break;
+            const next = /* @__PURE__ */ new Map();
+            for (const type of frontier) {
+              for (const parent of this.resolveDirectSupertypes(type, indexes)) {
+                if (visited.has(parent)) continue;
+                visited.add(parent);
+                next.set(parent.symbolId, parent);
+              }
+            }
+            frontier = [...next.values()];
+          }
+          for (const candidate of candidates) matches.set(candidate.symbolId, candidate);
+        }
+      }
+      return matches.size === 1 ? [...matches.values()] : [];
+    }
+    resolveDirectSupertypes(scope, indexes) {
+      const supertypes = /* @__PURE__ */ new Map();
+      for (const typeName of scope.typeNames) {
+        const supertype = this.namespaceResolver.resolveNameFrom(scope, typeName, indexes);
+        if (supertype && isDefinition(supertype.kind)) supertypes.set(supertype.symbolId, supertype);
+      }
+      return [...supertypes.values()];
+    }
+    getSpecializationHierarchy(scope, indexes) {
+      const levels = [[scope]];
+      const visited = /* @__PURE__ */ new Set([scope]);
+      let frontier = [scope];
+      while (frontier.length > 0) {
+        const next = [];
+        for (const type of frontier) {
+          for (const parent of this.resolveDirectSupertypes(type, indexes)) {
+            if (visited.has(parent)) continue;
+            visited.add(parent);
+            next.push(parent);
+          }
+        }
+        if (next.length > 0) levels.push(next);
+        frontier = next;
+      }
+      return levels;
+    }
+    matchesSpecializationQualifier(type, qualifier) {
+      return type.name === qualifier || type.qualifiedName === qualifier || type.qualifiedName?.endsWith(`::${qualifier}`) === true;
+    }
     findContainingSymbolByLine(symbols, line) {
       return symbols.filter((s) => s.range.start.line <= line && s.range.end.line >= line).sort((a, b) => {
         const ar = (a.range.end.line - a.range.start.line) * 1e3 + (a.range.end.character - a.range.start.character);
@@ -141411,7 +141691,7 @@ ${info.documentation}`);
     findConstraintScopeSymbol(symbolsInUri, indexes, line) {
       let scope = this.findContainingSymbolByLine(symbolsInUri, line);
       while (scope) {
-        const members = indexes.byParent.get(namespaceKeyOf(scope)) ?? [];
+        const members = this.getConstraintScopeMembers(scope, indexes);
         if (members.length > 0) return scope;
         if (!scope.parentId) return scope;
         scope = ownerOf(scope, indexes);
@@ -141704,6 +141984,10 @@ ${info.documentation}`);
   var hasConfigurationCapability = false;
   var hasWorkspaceFolderCapability = false;
   var workspaceRoots = [];
+  var workspaceFolderUris = [];
+  function rootsOf(folderUris) {
+    return folderUris.map((uri) => toFsPath(uri)).filter((p) => p !== void 0);
+  }
   var isWorkspaceFile = false;
   var preloadOnOpen = "workspaceOnly";
   var disabledDiagnosticCodes = /* @__PURE__ */ new Set();
@@ -141715,6 +141999,10 @@ ${info.documentation}`);
   }
   var skipDirs = new Set(DEFAULT_SKIP_DIRS);
   var serverReady = false;
+  var resolveInitialization;
+  var initialization = new Promise((resolve) => {
+    resolveInitialization = resolve;
+  });
   var earlyOpenUris = /* @__PURE__ */ new Set();
   var workerRequestId = 0;
   var isBrowserServer = true;
@@ -141828,7 +142116,8 @@ ${info.documentation}`);
       connection.console.warn(`projectId is not a UUID: ${initOpts.projectId}; symbol IDs are unique only within this workspace`);
     }
     if (params.workspaceFolders) {
-      workspaceRoots = params.workspaceFolders.map((f2) => toFsPath(f2.uri)).filter((p) => p !== void 0);
+      workspaceFolderUris = params.workspaceFolders.map((f2) => f2.uri);
+      workspaceRoots = rootsOf(workspaceFolderUris);
     } else if (params.rootUri) {
       const root = toFsPath(params.rootUri);
       if (root) workspaceRoots = [root];
@@ -141878,7 +142167,8 @@ ${info.documentation}`);
     if (hasWorkspaceFolderCapability) {
       result.capabilities.workspace = {
         workspaceFolders: {
-          supported: true
+          supported: true,
+          changeNotifications: true
         }
       };
     }
@@ -141890,8 +142180,17 @@ ${info.documentation}`);
         import_node11.DidChangeConfigurationNotification.type,
         void 0
       );
+    }
+    if (hasWorkspaceFolderCapability) {
+      connection.workspace.onDidChangeWorkspaceFolders((event) => {
+        onWorkspaceFoldersChanged(event).catch((e) => connection.console.error(`Workspace folder change failed: ${e}`));
+      });
+    }
+    if (hasConfigurationCapability) {
       await pullSettings().catch(() => {
       });
+      await pullFolderProjectIds().catch(() => {
+      });
     }
     const libCount = initLibraryIndex("/");
     connection.console.log(`SysML v2 Language Server initialized (${libCount} library packages indexed)`);
@@ -141907,14 +142206,13 @@ ${info.documentation}`);
       );
     }
     serverReady = true;
+    resolveInitialization();
     spawnParseWorker();
     if (workspaceRoots.length > 0 && (preloadOnOpen === "always" || preloadOnOpen === "workspaceOnly" && isWorkspaceFile)) {
-      documentManager.setWorkspaceScanComplete(false);
-      scanWorkspaceFoldersAsync(workspaceRoots).then(({ fileCount, scanMs }) => {
+      scanWorkspaceFolders(workspaceRoots).then(({ fileCount, scanMs }) => {
         connection.console.log(
           `Workspace scan: pre-parsed ${fileCount} .sysml files in ${scanMs} ms`
         );
-        documentManager.setWorkspaceScanComplete(true);
         revalidateOpenDocuments();
       });
     }
@@ -141949,9 +142247,80 @@ ${info.documentation}`);
     }
   }
   connection.onDidChangeConfiguration((_change) => {
-    pullSettings().then(() => revalidateOpenDocuments()).catch(() => {
+    pullSettings().then(() => pullFolderProjectIds()).then(() => revalidateOpenDocuments()).catch(() => {
+    });
+  });
+  function latestWins(task) {
+    let calls = 0;
+    let latest = Promise.resolve();
+    return () => {
+      const call = ++calls;
+      const isSuperseded = () => call !== calls;
+      const run = task(isSuperseded).then(() => isSuperseded() ? latest : void 0);
+      latest = run;
+      return run;
+    };
+  }
+  var pullFolderProjectIds = latestWins(async (isSuperseded) => {
+    if (!hasConfigurationCapability) return;
+    const folderUris = [...workspaceFolderUris];
+    const answers = folderUris.length === 0 ? [] : await connection.workspace.getConfiguration(folderUris.map((scopeUri) => ({ scopeUri, section: "sysml.project" })));
+    if (isSuperseded()) return;
+    const projectIds = folderUris.flatMap((folderUri, i) => {
+      const projectId = answers[i]?.projectId;
+      return typeof projectId === "string" ? [{ folderUri, projectId }] : [];
     });
+    const uris = documentManager.getUris();
+    const prefixBefore = new Map(uris.map((uri) => [uri, getUrlPrefix(uri)]));
+    const rejected = setFolderProjectIds(projectIds);
+    for (const entry of rejected) {
+      connection.console.warn(`projectId of ${entry.folderUri} is not a UUID: ${entry.projectId}; ignored, so its documents use the projectId of an enclosing folder, else initializationOptions.projectId, else the default prefix`);
+    }
+    documentManager.invalidateSymbols(uris.filter((uri) => getUrlPrefix(uri) !== prefixBefore.get(uri)));
+    logFolderPrefixes(new Set(projectIds.filter((p) => !rejected.includes(p)).map((p) => p.folderUri)));
   });
+  var loggedFolderPrefixes = /* @__PURE__ */ new Map();
+  function logFolderPrefixes(ownProjectIds) {
+    for (const folderUri of workspaceFolderUris) {
+      const prefix = getUrlPrefix(`${folderUri.endsWith("/") ? folderUri : `${folderUri}/`}_.sysml`);
+      if (loggedFolderPrefixes.get(folderUri) === prefix) continue;
+      loggedFolderPrefixes.set(folderUri, prefix);
+      const source = ownProjectIds.has(folderUri) ? "its projectId" : prefix === getUrlPrefix() ? prefix === DEFAULT_URL_PREFIX ? "the default prefix, no projectId" : "initializationOptions.projectId" : "an enclosing folder's projectId";
+      const folderPath = toFsPath(folderUri) ?? folderUri;
+      connection.console.debug(`Folder ${folderPath}: element ID namespace ${prefix} (${source}; ID namespace only, no network access)`);
+    }
+    for (const folderUri of loggedFolderPrefixes.keys()) {
+      if (!workspaceFolderUris.includes(folderUri)) loggedFolderPrefixes.delete(folderUri);
+    }
+  }
+  async function onWorkspaceFoldersChanged(event) {
+    const initialScanPending = !serverReady;
+    const removed = new Set(event.removed.map((f2) => f2.uri));
+    workspaceFolderUris = [...workspaceFolderUris.filter((uri) => !removed.has(uri)), ...event.added.map((f2) => f2.uri)];
+    workspaceRoots = rootsOf(workspaceFolderUris);
+    dropDocumentsOutsideWorkspace(event.removed.map((f2) => f2.uri));
+    await pullFolderProjectIds().catch(() => {
+    });
+    if (initialScanPending) return;
+    const addedRoots = rootsOf(event.added.map((f2) => f2.uri).filter((uri) => workspaceFolderUris.includes(uri)));
+    if (addedRoots.length > 0 && (preloadOnOpen === "always" || preloadOnOpen === "workspaceOnly" && isWorkspaceFile)) {
+      const { fileCount, scanMs } = await scanWorkspaceFolders(addedRoots);
+      connection.console.log(`Workspace scan: pre-parsed ${fileCount} .sysml files of ${addedRoots.length} added folder(s) in ${scanMs} ms`);
+    }
+    revalidateOpenDocuments();
+  }
+  function dropDocumentsOutsideWorkspace(folderUris) {
+    for (const uri of documentManager.getUris()) {
+      if (openDocumentFor(uri)) continue;
+      if (folderUris.some((f2) => isInFolder(uri, f2)) && !isInWorkspace(uri)) {
+        documentManager.remove(uri);
+        modelProvider.removeUri(uri);
+      }
+    }
+  }
+  function isInWorkspace(uri) {
+    return workspaceRoots.some((root) => isInFolder(uri, pathToFileURL(root).toString()));
+  }
   function openDocumentFor(uri) {
     return documents.get(uri) ?? documents.all().find((d) => isSameDocumentUri(d.uri, uri));
   }
@@ -141976,6 +142345,16 @@ ${info.documentation}`);
     documentManager.parse(doc);
     return true;
   }
+  var runningScans = 0;
+  async function scanWorkspaceFolders(roots) {
+    runningScans++;
+    documentManager.setWorkspaceScanComplete(false);
+    try {
+      return await scanWorkspaceFoldersAsync(roots);
+    } finally {
+      if (--runningScans === 0) documentManager.setWorkspaceScanComplete(true);
+    }
+  }
   async function scanWorkspaceFoldersAsync(roots) {
     const scanT0 = Date.now();
     const fileArrays = await Promise.all(roots.map((r) => findSysMLFilesAsync(r, skipDirs)));
@@ -141987,6 +142366,7 @@ ${info.documentation}`);
       const filePath = allFiles[i];
       const uri = pathToFileURL(filePath).toString();
       if (openDocumentFor(uri)) continue;
+      if (!isInWorkspace(uri)) continue;
       const content = fileContents.get(filePath);
       if (content === void 0) continue;
       documentManager.parseBatch(uri, 0, content);
@@ -142199,14 +142579,16 @@ ${info.documentation}`);
       return formattingProvider.provideRangeFormatting(params);
     }
   );
-  connection.onRequest("sysml/model", (params) => {
+  connection.onRequest("sysml/model", async (params) => {
+    await initialization;
     return modelProvider.getModel(
       params.textDocument.uri,
       documentManager.getVersion(params.textDocument.uri),
       params.scope
     );
   });
-  connection.onRequest("sysml/elementLookup", (params) => {
+  connection.onRequest("sysml/elementLookup", async (params) => {
+    await initialization;
     return elementLookupProvider.elementLookup(params);
   });
   connection.onRequest("sysml/serverStats", () => {