sysml-validate 0.15.4 → 0.15.6

package/out/main.js

@@ -58670,7 +58670,22 @@ var DIAGNOSTIC_MESSAGES = {
   // REQ-007 — SysML v1 → v2 migration guardrail.
   MIG001_V1_KEYWORD: (keyword, v2, note) => `'${keyword}' is a SysML v1 construct, not a SysML v2 keyword. ${note} Use '${v2}'.`,
   MIG002_V1_STEREOTYPE_KNOWN: (stereotype, v2, note) => `SysML v2 has no stereotypes. ${note} Replace \xAB${stereotype}\xBB with '${v2}'.`,
-  MIG002_V1_STEREOTYPE_UNKNOWN: (stereotype) => `SysML v2 has no \xAB${stereotype}\xBB stereotype. Model it as a 'metadata def' applied with '@', or use the matching v2 definition keyword.`
+  MIG002_V1_STEREOTYPE_UNKNOWN: (stereotype) => `SysML v2 has no \xAB${stereotype}\xBB stereotype. Model it as a 'metadata def' applied with '@', or use the matching v2 definition keyword.`,
+  // REQ-390 — issue #104. Whole-model type conformance. Each message names the
+  // two types it compared and the relationship that required them to agree, so
+  // the reader can see WHICH end to change without opening the other file.
+  SSM017_REDEFINITION_TYPE: (feature, subType, superType) => `Type '${subType}' does not specialize '${superType}', the type of the redefined feature '${feature}'. A redefinition narrows a feature \u2014 it cannot re-type it to something unrelated.`,
+  SSM018_CONNECTOR_END_TYPES: (keyword, sourceType, targetType) => `'${keyword}' binds features of unrelated types '${sourceType}' and '${targetType}'. A binding asserts its two ends hold the same value, so their types must be related \u2014 one specializing the other, or conjugates ('~').`,
+  SSM019_VALUE_TYPE: (typeName, expected, actual) => `A ${actual} literal is not a value of '${typeName}', which accepts ${expected === "number" ? "a numeric" : `a ${expected}`} value.`,
+  SSM020_FLOW_PAYLOAD: (payload, endKind, endType) => `Payload '${payload}' is unrelated to the flow's ${endKind} type '${endType}'. A flow carries its payload between features that can hold it.`,
+  SSM021_ABSTRACT_TYPE: (usage, typeName) => `'${usage}' is typed only by the abstract definition '${typeName}'. An abstract definition has no complete form \u2014 give the usage a concrete type, subset a concrete usage, or mark it 'abstract' too.`,
+  SSM022_DEFINITION_DOMAIN: (keyword, typeName, typeKeyword, expected) => `A '${keyword}' usage cannot be defined by '${typeName}', which is a '${typeKeyword} def'. Type it by ${expected}.`,
+  SSM023_GUARD_NOT_BOOLEAN: (construct) => `A ${construct} guard must be a Boolean expression \u2014 this one cannot evaluate to true or false.`,
+  SSM024_ASSIGNMENT_VALUE: (target, typeName, expected, actual) => `'${target}' is a '${typeName}', which holds ${expected === "number" ? "a numeric" : `a ${expected}`} value \u2014 the assigned expression is ${actual === "number" ? "numeric" : actual}.`,
+  SSM025_ACTION_PARAMETER_COUNT: (usage, declared, typeName, available) => `'${usage}' declares ${declared} directed parameter${declared === 1 ? "" : "s"} but its definition '${typeName}' has ${available}. An action usage's parameters correspond positionally to its definition's, so there is no ${available === 0 ? "parameter" : `${available + 1}th parameter`} to correspond to.`,
+  SSM025_ACTION_PARAMETER_DIRECTION: (position, mine, typeName, theirs) => `Parameter ${position} is '${mine}' but the corresponding parameter of '${typeName}' is '${theirs}'. Positional correspondence redefines that parameter, and a redefinition cannot reverse a parameter's direction.`,
+  SSM026_REDEFINITION_DIRECTION: (feature, mine, theirs) => `Direction '${mine}' reverses the redefined feature '${feature}', which is '${theirs}'. A redefinition refines a feature \u2014 it cannot turn an input into an output.`,
+  SSM027_INTERFACE_END_TYPE: (position, endType, definition, expected) => `End ${position} is a '${endType}', but '${definition}' declares that end as '${expected}'. An interface usage connects through the ends its definition declares.`
 };
 var KEYWORD_TOOLTIPS = {
   // Package / namespace
@@ -58934,7 +58949,9 @@ var SysmlIndexManager = class extends DefaultIndexManager {
       selectionSegment: symbol.selectionSegment,
       // REQ-068 — preserve declared visibility for wildcard re-export.
       ...symbol.isPrivate ? { isPrivate: true } : {},
-      ...symbol.visibility ? { visibility: symbol.visibility } : {}
+      ...symbol.visibility ? { visibility: symbol.visibility } : {},
+      // REQ-242 — issue #103 — keeps type completion to definitions.
+      ...symbol.isUsage ? { isUsage: true } : {}
     };
   }
 };
@@ -59133,6 +59150,46 @@ var FeaturePathResolver = class {
   isPathExpr(node) {
     return isPathExpr(node);
   }
+  // REQ-242 — issue #103: the members reachable through a path the user is
+  // still typing (`engine.power.`). Completion cannot go through `resolve`,
+  // which needs a parsed `PathExpr` with a CST leaf per segment; the text
+  // after the last separator is not part of any node yet. The resolution
+  // rules are otherwise identical, so the same root/child walk answers it —
+  // which is what makes member completion see cross-file and inherited
+  // members that a document-local name search cannot reach.
+  membersForPath(context, steps) {
+    if (steps.length === 0)
+      return [];
+    const root3 = ast_utils_exports.getDocument(context).parseResult.value;
+    const snapshot = this.snapshot(root3);
+    let current2 = this.resolveRoot(context, steps[0].text, snapshot);
+    for (let index = 1; index < steps.length; index += 1) {
+      if (!current2.node && !current2.description)
+        return [];
+      current2 = this.resolveChild(current2, steps[index].text, steps, index, snapshot);
+    }
+    const owner = this.followAlias(current2, snapshot);
+    const node = owner.node ?? this.nodeOf(owner.description);
+    return node ? this.visibleMembers(node, snapshot) : [];
+  }
+  // REQ-242 — issue #103: an element's own named children plus everything it
+  // inherits, following typing (`part p : Engine`) and every specialization
+  // relationship transitively. A usage carries almost no members of its own;
+  // essentially all of them come from the type it is defined by and that
+  // type's supertypes.
+  visibleMembers(node, snapshot = this.snapshot(ast_utils_exports.getDocument(node).parseResult.value)) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const owner of [node, ...this.typedAndSpecializedOwners(node, snapshot)]) {
+      for (const child of directNamedChildren(owner)) {
+        if (seen.has(child))
+          continue;
+        seen.add(child);
+        result.push(child);
+      }
+    }
+    return result;
+  }
   segmentsOf(node) {
     const cst = node.$cstNode;
     if (!cst)
@@ -59422,6 +59479,282 @@ function isNamespaceOnlyDecl(node) {
   return node.isDef === true;
 }
 
+// ../language-server/out/src/services/conformance.js
+var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([
+  ":>",
+  ":>>",
+  "specializes",
+  "subsets",
+  "redefines"
+]);
+var COMPOSITION_KINDS = /* @__PURE__ */ new Set(["unions", "intersects", "differences"]);
+var MAX_CLOSURE_DEPTH = 32;
+function simpleTypeName(name) {
+  const last2 = name.trim().split(/::|\./u).pop() ?? name.trim();
+  return last2.replace(/^'(.*)'$/u, "$1");
+}
+function declaredTypesOf(node) {
+  const decl = node;
+  const out = [];
+  for (const typing of [decl.typing, ...decl.moreTypings ?? []]) {
+    if (!typing)
+      continue;
+    const conjugated = typing.conjugate === true;
+    for (const ref of [typing.type, ...typing.moreTypes ?? []]) {
+      const text = ref?.$refText?.trim();
+      if (text)
+        out.push({ text, simple: simpleTypeName(text), conjugated });
+    }
+  }
+  return out;
+}
+function specializedNamesOf(node) {
+  const decl = node;
+  const out = [];
+  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+    if (!rel.kind || !SPECIALIZATION_KINDS2.has(rel.kind))
+      continue;
+    for (const target of rel.targets ?? []) {
+      const text = target.trim();
+      if (text)
+        out.push(text);
+    }
+  }
+  return out;
+}
+function compositionGroupsOf(node) {
+  const decl = node;
+  const out = [];
+  for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+    if (!rel.kind || !COMPOSITION_KINDS.has(rel.kind))
+      continue;
+    const targets = (rel.targets ?? []).map((t) => t.trim()).filter((t) => t.length > 0);
+    if (targets.length > 0)
+      out.push({ kind: rel.kind, targets });
+  }
+  return out;
+}
+function isAbstractDecl(node) {
+  return (node.modifiers ?? []).includes("abstract");
+}
+var SCALAR_ROOT_KINDS = {
+  String: "string",
+  Boolean: "boolean",
+  NumericalValue: "number",
+  Number: "number",
+  Integer: "number",
+  Rational: "number",
+  Real: "number",
+  Complex: "number",
+  Natural: "number",
+  Positive: "number",
+  Cardinal: "number"
+};
+function literalKindOf(node) {
+  if (!node)
+    return void 0;
+  switch (node.$type) {
+    case "LiteralStr":
+      return "string";
+    case "LiteralBool":
+      return "boolean";
+    case "NumericPrimary":
+      return "number";
+    // A signed literal is still a literal of the same kind.
+    case "UnaryMinusExpr":
+    case "UnaryPlusExpr":
+      return literalKindOf(node.operand);
+    // A single-item parenthesis carries its item's kind through.
+    case "ParenExpr": {
+      const items = node.items ?? [];
+      return items.length === 1 ? literalKindOf(items[0]) : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+var BOOLEAN_RESULT_OPS = /* @__PURE__ */ new Set([
+  "and",
+  "&",
+  "or",
+  "|",
+  "xor",
+  "implies",
+  "==",
+  "!=",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "hastype",
+  "istype",
+  "@",
+  "@@"
+]);
+var NUMERIC_RESULT_OPS = /* @__PURE__ */ new Set(["-", "*", "/", "%", "**", "^"]);
+function expressionKindOf(node) {
+  if (!node)
+    return void 0;
+  const literal = literalKindOf(node);
+  if (literal)
+    return literal;
+  switch (node.$type) {
+    case "NotExpr":
+    case "QuantifierExpr":
+    case "SelfClassifyExpr":
+      return "boolean";
+    case "ClassifyOp": {
+      const op = node.op;
+      return op && BOOLEAN_RESULT_OPS.has(op) ? "boolean" : void 0;
+    }
+    case "ParenExpr": {
+      const items = node.items ?? [];
+      return items.length === 1 ? expressionKindOf(items[0]) : void 0;
+    }
+    case "UnaryMinusExpr":
+    case "UnaryPlusExpr": {
+      return expressionKindOf(node.operand) === "number" ? "number" : void 0;
+    }
+    case "IfExpr": {
+      const branch = node;
+      const left = expressionKindOf(branch.thenExpr ?? branch.then);
+      const right = expressionKindOf(branch.elseExpr ?? branch.else);
+      return left && left === right ? left : void 0;
+    }
+    case "BinExpr": {
+      const bin = node;
+      const op = bin.op;
+      if (!op)
+        return void 0;
+      if (BOOLEAN_RESULT_OPS.has(op))
+        return "boolean";
+      if (NUMERIC_RESULT_OPS.has(op))
+        return "number";
+      const left = expressionKindOf(bin.left);
+      return (op === "+" || op === "??") && left && left === expressionKindOf(bin.right) ? left : void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+var ConformanceModel = class {
+  resolve;
+  closures = /* @__PURE__ */ new Map();
+  /**
+   * @param resolve  A written type name → its declaration, or `undefined` when
+   *   the name is absent, ambiguous, or its document is not loaded. The
+   *   validator supplies its `resolveUnique`, so an ambiguous name is treated
+   *   exactly as an unreadable one: it makes the walk incomplete rather than
+   *   resolving to an arbitrary same-named element.
+   */
+  constructor(resolve7) {
+    this.resolve = resolve7;
+  }
+  /** The transitive supertype names of the type written as `name`. */
+  closureOf(name) {
+    return this.walk(name, /* @__PURE__ */ new Set());
+  }
+  // The closure is keyed by SIMPLE name throughout: a supertype is written
+  // qualified in one file and bare in the next, and both spell the same type.
+  // Two unrelated types that share a simple name can therefore look related —
+  // which only ever makes a check stay silent, never fire.
+  walk(name, visiting) {
+    const key = name.trim();
+    const simple = simpleTypeName(key);
+    const cached = this.closures.get(key);
+    if (cached)
+      return cached;
+    if (visiting.has(key) || visiting.size >= MAX_CLOSURE_DEPTH) {
+      return { names: /* @__PURE__ */ new Set([simple]), complete: false };
+    }
+    const node = this.resolve(key);
+    if (!node)
+      return { names: /* @__PURE__ */ new Set([simple]), complete: false };
+    visiting.add(key);
+    const names = /* @__PURE__ */ new Set([simple]);
+    let complete = true;
+    const absorb = (closure3) => {
+      for (const each of closure3.names)
+        names.add(each);
+      complete &&= closure3.complete;
+    };
+    for (const supertype of [...declaredTypesOf(node).map((t) => t.text), ...specializedNamesOf(node)]) {
+      absorb(this.walk(supertype, visiting));
+    }
+    for (const group of compositionGroupsOf(node)) {
+      if (group.kind === "intersects") {
+        for (const operand of group.targets)
+          absorb(this.walk(operand, visiting));
+      } else if (group.kind === "differences") {
+        absorb(this.walk(group.targets[0], visiting));
+      } else {
+        let shared;
+        for (const operand of group.targets) {
+          const closure3 = this.walk(operand, visiting);
+          complete &&= closure3.complete;
+          shared = shared === void 0 ? new Set(closure3.names) : new Set([...shared].filter((each) => closure3.names.has(each)));
+        }
+        for (const each of shared ?? [])
+          names.add(each);
+      }
+    }
+    visiting.delete(key);
+    const closure2 = { names, complete };
+    this.closures.set(key, closure2);
+    return closure2;
+  }
+  /** Does the type written as `subName` specialize the type written as `superName`? */
+  conforms(subName, superName) {
+    const target = simpleTypeName(superName);
+    const closure2 = this.closureOf(subName);
+    if (closure2.names.has(target))
+      return "conforms";
+    return closure2.complete ? "unrelated" : "unknown";
+  }
+  /** Are two written types related in EITHER direction? Used where the model
+   *  states an equality (a binding, a flow payload) rather than a refinement. */
+  compatible(a2, b) {
+    const forward = this.conforms(a2, b);
+    if (forward === "conforms")
+      return "conforms";
+    const backward = this.conforms(b, a2);
+    if (backward === "conforms")
+      return "conforms";
+    if (forward === "unknown" || backward === "unknown")
+      return "unknown";
+    return "unrelated";
+  }
+  /** The declaration a written type name names, when it is readable. */
+  declarationOf(name) {
+    return this.resolve(name);
+  }
+  /**
+   * The literal shape a declared type accepts, or `undefined` when the model
+   * does not say. Two independent sources agree on the answer:
+   *  • the specialization closure reaching one of the ScalarValues roots, and
+   *  • the precomputed dimension table, which knows every `*Value` quantity of
+   *    the OMG `Quantities and Units` library is numeric — so `MassValue` is
+   *    decided without parsing a single library file.
+   * A closure that reaches two DIFFERENT roots is a model defect of its own
+   * and is reported as undecided here rather than guessed.
+   */
+  literalKindAccepted(typeName) {
+    const closure2 = this.closureOf(typeName);
+    let kind;
+    for (const name of closure2.names) {
+      const root3 = SCALAR_ROOT_KINDS[name] ?? (quantityDimension(name) ? "number" : void 0);
+      if (!root3)
+        continue;
+      if (kind && kind !== root3)
+        return void 0;
+      kind = root3;
+    }
+    return kind;
+  }
+};
+
 // ../language-server/out/src/services/validator.js
 var severityOverrides = {};
 function setSeverityOverrides(overrides) {
@@ -59494,7 +59827,7 @@ function maskNonCode(text) {
   }
   return out.join("");
 }
-var SPECIALIZATION_KINDS2 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 var CONSTRAINT_SIDE_EFFECT_TYPES = /* @__PURE__ */ new Set([
   "AssignNode",
   "SendNode",
@@ -60737,6 +61070,336 @@ ${baseIndent}}`;
       this.checkInverseOfTargets(decl, index, accept);
       this.checkTypeComposition(decl, index, accept);
     }
+    this.checkTypeConformance(decls, index, accept);
+  }
+  // ══════════════════════════════════════════════════════════════════════
+  // REQ-390 — SSM017-SSM021: whole-model type conformance (issue #104)
+  // ══════════════════════════════════════════════════════════════════════
+  // Every check below is silent unless the model says otherwise DEFINITIVELY:
+  // `ConformanceModel` answers `unrelated` only when it read every supertype on
+  // the walk, so a type rooted in the unparsed standard library yields
+  // `unknown` and no diagnostic. That is what keeps the OMG corpus clean while
+  // still catching the workspace-local mistakes these codes exist for.
+  checkTypeConformance(decls, index, accept) {
+    const model = new ConformanceModel((name) => this.resolveUnique(name, index));
+    for (const decl of decls) {
+      this.checkRedefinitionTypeConformance(decl, model, index, accept);
+      this.checkValueAssignability(decl, model, accept);
+      this.checkAbstractTyping(decl, model, accept);
+      this.checkConnectorEndTypes(decl, model, index, accept);
+      this.checkFlowPayload(decl, model, index, accept);
+      this.checkDefinitionDomain(decl, model, accept);
+      this.checkGuardIsBoolean(decl, accept);
+      this.checkAssignmentValue(decl, model, index, accept);
+      this.checkActionParameterCorrespondence(decl, model, accept);
+      this.checkRedefinitionDirection(decl, index, accept);
+      this.checkInterfaceEndTypes(decl, model, index, accept);
+    }
+  }
+  // REQ-390 — SSM017: a redefining feature narrows the feature it redefines, so
+  // its type must specialize the redefined feature's type (OMG KerML 8.4.4.5.4
+  // Redefinition; SysML v2 Part 1 §7.7.4). Re-typing to something unrelated
+  // silently produces a feature that no longer fits where the original did.
+  // KSM002 already guards the multiplicity half of the same rule.
+  checkRedefinitionTypeConformance(decl, model, index, accept) {
+    const mine = soleDeclaredType(decl);
+    if (!mine || mine.conjugated)
+      return;
+    for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+      const kind = rel.kind;
+      if (kind !== ":>>" && kind !== "redefines")
+        continue;
+      for (const target of rel.targets ?? []) {
+        const redefined = this.resolveUnique(target, index);
+        if (!redefined)
+          continue;
+        const theirs = soleDeclaredType(redefined);
+        if (!theirs || theirs.conjugated)
+          continue;
+        if (model.conforms(mine.text, theirs.text) !== "unrelated")
+          continue;
+        accept(severity("SSM017", "error"), DIAGNOSTIC_MESSAGES.SSM017_REDEFINITION_TYPE(simpleTypeName(target), mine.text, theirs.text), { node: decl, code: "SSM017", relatedInformation: declarationSite(redefined, target) });
+      }
+    }
+  }
+  // REQ-390 — SSM018: a BINDING connector asserts that its two ends have the
+  // same values (OMG KerML 8.2.5.5.2 BindingConnector; SysML v2 Part 1
+  // §7.9.4), so their types must be related — one specializing the other, or
+  // both the same. Nothing can be both a `Fuel` and a `Signal`, so a binding
+  // across unrelated types describes a model that cannot hold.
+  //
+  // A plain `connect` is deliberately NOT judged, and the OMG corpus is why:
+  // Annex A's SimpleVehicleModel connects `DiffPort` to `AxlePort` and
+  // `ShaftPort_a` to `ShaftPort_b`, four bare port definitions with nothing in
+  // common. A connection relates two things — it does not equate them — so
+  // conformance is not a rule there, and the deeper interface-end rule (an
+  // `interface def`'s own ends constraining what its usages may connect) is
+  // the remaining part of issue #104's connector bullet.
+  //
+  // A conjugated end is skipped throughout: `~T` inverts the type's directions
+  // and is exactly how two `T` ends are legitimately joined.
+  checkConnectorEndTypes(decl, model, index, accept) {
+    const keyword = BINDING_KEYWORDS[decl.$type];
+    if (!keyword)
+      return;
+    for (const [sourcePath, targetPath] of binaryConnectorEnds(decl)) {
+      const source = this.endType(sourcePath, index);
+      const target = this.endType(targetPath, index);
+      if (!source || !target)
+        continue;
+      if (source.conjugated || target.conjugated)
+        continue;
+      if (model.compatible(source.text, target.text) !== "unrelated")
+        continue;
+      accept(severity("SSM018", "error"), DIAGNOSTIC_MESSAGES.SSM018_CONNECTOR_END_TYPES(keyword, source.text, target.text), { node: decl, code: "SSM018" });
+    }
+  }
+  /** The declared type of a connector end, when the end resolves unambiguously
+   *  to a usage carrying exactly one written type. */
+  endType(path10, index) {
+    const node = this.resolveUnique(path10, index);
+    if (!node || node.isDef === true)
+      return void 0;
+    return soleDeclaredType(node);
+  }
+  // REQ-390 — SSM019: a feature's value must be a value of its type (OMG KerML
+  // 8.4.4.7 FeatureValue). Only BARE LITERALS are judged, against types whose
+  // scalar root the model can name — `ScalarValues` reached through the
+  // specialization closure, or a `Quantities and Units` value type named by the
+  // dimension table. Anything computed keeps its silence: inferring the type of
+  // an arbitrary expression is the deferred half of issue #104.
+  checkValueAssignability(decl, model, accept) {
+    const declared = soleDeclaredType(decl);
+    if (!declared || declared.conjugated)
+      return;
+    const expected = model.literalKindAccepted(declared.text);
+    if (!expected)
+      return;
+    const withDefault = decl;
+    for (const value of [withDefault.value, withDefault.default?.value]) {
+      const actual = expressionKindOf(value);
+      if (!actual || actual === expected)
+        continue;
+      accept(severity("SSM019", "error"), DIAGNOSTIC_MESSAGES.SSM019_VALUE_TYPE(declared.text, expected, actual), { node: value, code: "SSM019" });
+    }
+  }
+  // REQ-390 — SSM020: a flow's payload travels from its source feature to its
+  // target feature, so each end must be able to hold it (OMG SysML v2 Part 1
+  // §7.12 ItemFlow / PayloadFeature). Reported per end, and only when the end
+  // resolves unambiguously and carries exactly one written type.
+  checkFlowPayload(decl, model, index, accept) {
+    if (decl.$type !== "FlowStmt")
+      return;
+    const flow = decl;
+    const payload = flowPayloadType(flow.payload);
+    if (!payload || payload.conjugated)
+      return;
+    for (const [endKind, path10] of [["source", flow.source], ["target", flow.target]]) {
+      if (!path10)
+        continue;
+      const end = this.resolveUnique(path10, index);
+      const endType = end ? soleDeclaredType(end) : void 0;
+      if (!endType || endType.conjugated)
+        continue;
+      if (model.compatible(payload.text, endType.text) !== "unrelated")
+        continue;
+      accept(severity("SSM020", "error"), DIAGNOSTIC_MESSAGES.SSM020_FLOW_PAYLOAD(payload.text, endKind, endType.text), { node: decl, code: "SSM020" });
+    }
+  }
+  // REQ-390 — SSM021: a usage typed ONLY by an abstract definition names no
+  // complete form (OMG SysML v2 Part 1 §7.4.2 — an abstract definition
+  // classifies nothing on its own; every instance belongs to a specialization).
+  // Deliberately narrow, because typing against an abstract definition is a
+  // normal intermediate step:
+  //   · the usage itself may be `abstract`, a `variation`, or a `variant`;
+  //   · it may narrow the abstract type through a further `:>`/`subsets`/
+  //     `redefines`, which is the sanctioned way to reach a concrete form;
+  //   · a definition is not a usage — `part def A :> AbstractB` is ordinary
+  //     specialization and is not touched;
+  //   · a usage that owns members refines the type in place.
+  // What is left is the case the code is for: a leaf usage that says only
+  // "one of these", where the model never says which. It defaults to a HINT,
+  // not an error — the text is legal, and the modeller may be mid-decomposition.
+  checkAbstractTyping(decl, model, accept) {
+    if (decl.isDef === true || !isCompositeOrRefUsage(decl))
+      return;
+    if (isAbstractDecl(decl))
+      return;
+    const modifiers2 = decl.modifiers ?? [];
+    if (modifiers2.includes("variation") || modifiers2.includes("variant"))
+      return;
+    if (specializedNamesOf(decl).length > 0)
+      return;
+    if ((decl.members ?? []).length > 0)
+      return;
+    const declared = soleDeclaredType(decl);
+    if (!declared || declared.conjugated)
+      return;
+    const type = model.declarationOf(declared.text);
+    if (!type || !isAbstractDecl(type) || type.isDef !== true)
+      return;
+    accept(severity("SSM021", "hint"), DIAGNOSTIC_MESSAGES.SSM021_ABSTRACT_TYPE(decl.name ?? `this ${kindLabel(decl)}`, declared.text), { node: decl, code: "SSM021", relatedInformation: declarationSite(type, declared.text) });
+  }
+  // REQ-390 — SSM022: a usage names a definition of ITS OWN kind (OMG SysML v2
+  // Part 1 §7.2 — every usage kind has a matching definition kind, and §7.4's
+  // `Usage::definition` is typed to it). `part p : SomeAttributeDef` is not a
+  // narrower part, it is a category error the rest of the model then inherits.
+  //
+  // Judged only when the written type resolves to a SysML DEFINITION whose
+  // keyword is knowable. A KerML classifier (`class`, `struct`, `datatype`,
+  // `behavior`) is always accepted — a SysML definition specializes the kernel,
+  // and typing a usage straight against a kernel classifier is legal — as is
+  // anything the workspace cannot read. `USAGE_DEFINITION_DOMAINS` errs WIDE,
+  // admitting each kind's metamodel supertypes (a part definition is an item
+  // definition, a case definition is an action definition), so only genuinely
+  // disjoint families are reported.
+  checkDefinitionDomain(decl, model, accept) {
+    if (decl.isDef === true)
+      return;
+    const domain = USAGE_DEFINITION_DOMAINS[decl.$type];
+    if (!domain)
+      return;
+    for (const declared of declaredTypesOf(decl)) {
+      const type = model.declarationOf(declared.text);
+      if (!type || type.isDef !== true)
+        continue;
+      if (domain.allowed.has(type.$type))
+        continue;
+      accept(severity("SSM022", "error"), DIAGNOSTIC_MESSAGES.SSM022_DEFINITION_DOMAIN(domain.keyword, declared.text, kindLabel(type), domain.expected), { node: decl, code: "SSM022", relatedInformation: declarationSite(type, declared.text) });
+    }
+  }
+  // REQ-390 — SSM023: a guard decides whether a transition or succession is
+  // taken, so it must be able to be true or false (OMG SysML v2 Part 1 §7.19.4
+  // TransitionUsage `guard`, §7.17.5 GuardedSuccession). Uses the same
+  // conservative "definitely not Boolean" test as KSM008 on filter conditions —
+  // a bare feature path may well resolve to a Boolean attribute and is left
+  // alone; a string, a quantity, or an arithmetic expression cannot.
+  checkGuardIsBoolean(decl, accept) {
+    const guard = decl.guard;
+    if (!guard)
+      return;
+    const nonBoolean = isDefinitelyNonBoolean(guard) || expressionKindOf(guard) === "string" || expressionKindOf(guard) === "number";
+    if (!nonBoolean)
+      return;
+    accept(severity("SSM023", "error"), DIAGNOSTIC_MESSAGES.SSM023_GUARD_NOT_BOOLEAN(GUARD_CONSTRUCTS[decl.$type] ?? "succession"), { node: guard, code: "SSM023" });
+  }
+  // REQ-390 — SSM024: `assign x := expr` writes a value into a feature, so the
+  // same rule SSM019 applies to a declared value applies here (OMG SysML v2
+  // Part 1 §7.17.7 AssignmentActionUsage). The target is a feature path; only
+  // an unambiguously resolved one carrying exactly one written type is judged.
+  checkAssignmentValue(decl, model, index, accept) {
+    if (decl.$type !== "AssignNode")
+      return;
+    const node = decl;
+    if (!node.target || !node.value)
+      return;
+    const target = this.resolveUnique(node.target, index);
+    const declared = target ? soleDeclaredType(target) : void 0;
+    if (!declared || declared.conjugated)
+      return;
+    const expected = model.literalKindAccepted(declared.text);
+    const actual = expressionKindOf(node.value);
+    if (!expected || !actual || expected === actual)
+      return;
+    accept(severity("SSM024", "error"), DIAGNOSTIC_MESSAGES.SSM024_ASSIGNMENT_VALUE(node.target, declared.text, expected, actual), { node: node.value, code: "SSM024" });
+  }
+  // REQ-390 — SSM025: an action usage's directed parameters correspond
+  // POSITIONALLY to its definition's (OMG SysML v2 Part 1 §7.16.4 — the n-th
+  // parameter of the usage implicitly redefines the n-th of the definition).
+  // Two consequences are checkable without modelling implicit redefinition
+  // itself: the usage cannot declare more parameters than there are to
+  // correspond to, and a parameter it does declare cannot reverse the
+  // direction of the one it lines up with.
+  //
+  // A parameter that redefines EXPLICITLY is skipped — it names its
+  // counterpart rather than taking it by position, and SSM026 judges that one.
+  checkActionParameterCorrespondence(decl, model, accept) {
+    if (decl.isDef === true || !PARAMETERIZED_USAGE_TYPES.has(decl.$type))
+      return;
+    const declared = soleDeclaredType(decl);
+    if (!declared || declared.conjugated)
+      return;
+    const definition = model.declarationOf(declared.text);
+    if (!definition || definition.isDef !== true)
+      return;
+    const mine = directedParameters(decl);
+    if (mine.length === 0)
+      return;
+    const theirs = directedParameters(definition);
+    if (theirs.length === 0)
+      return;
+    if (mine.length > theirs.length) {
+      accept(severity("SSM025", "error"), DIAGNOSTIC_MESSAGES.SSM025_ACTION_PARAMETER_COUNT(decl.name ?? `this ${kindLabel(decl)}`, mine.length, declared.text, theirs.length), { node: mine[theirs.length].node, code: "SSM025" });
+      return;
+    }
+    for (let position = 0; position < mine.length; position += 1) {
+      if (specializedNamesOf(mine[position].node).length > 0)
+        continue;
+      if (mine[position].direction === theirs[position].direction)
+        continue;
+      accept(severity("SSM025", "error"), DIAGNOSTIC_MESSAGES.SSM025_ACTION_PARAMETER_DIRECTION(position + 1, mine[position].direction, declared.text, theirs[position].direction), { node: mine[position].node, code: "SSM025" });
+    }
+  }
+  // REQ-390 — SSM026: a redefinition refines the feature it names, and a
+  // feature's direction is part of what it is (OMG KerML 8.4.4.5.4 — a
+  // redefining feature's direction must be consistent with the redefined
+  // one's). Turning an `in` into an `out` does not narrow anything; it
+  // reverses the flow the supertype declared and every caller relies on.
+  // `inout` is compatible with either, so only a straight in/out flip is
+  // reported.
+  checkRedefinitionDirection(decl, index, accept) {
+    const mine = directionOf(decl);
+    if (mine !== "in" && mine !== "out")
+      return;
+    for (const rel of [...decl.preRelationships ?? [], ...decl.relationships ?? []]) {
+      const kind = rel.kind;
+      if (kind !== ":>>" && kind !== "redefines")
+        continue;
+      for (const target of rel.targets ?? []) {
+        const redefined = this.resolveUnique(target, index);
+        if (!redefined)
+          continue;
+        const theirs = directionOf(redefined);
+        if (theirs !== "in" && theirs !== "out")
+          continue;
+        if (theirs === mine)
+          continue;
+        accept(severity("SSM026", "error"), DIAGNOSTIC_MESSAGES.SSM026_REDEFINITION_DIRECTION(simpleTypeName(target), mine, theirs), { node: decl, code: "SSM026", relatedInformation: declarationSite(redefined, target) });
+      }
+    }
+  }
+  // REQ-390 — SSM027: an interface usage connects through the ends its
+  // definition declares (OMG SysML v2 Part 1 §7.11.3 — an InterfaceUsage's
+  // connector ends redefine the InterfaceDefinition's `end` features, in
+  // order). This is the part of issue #104's connector bullet that survives
+  // the corpus: a plain `connect` states no conformance, but an interface
+  // whose DEFINITION names its end types does.
+  checkInterfaceEndTypes(decl, model, index, accept) {
+    if (decl.$type !== "InterfaceDecl" || decl.isDef === true)
+      return;
+    const declared = soleDeclaredType(decl);
+    if (!declared || declared.conjugated)
+      return;
+    const definition = model.declarationOf(declared.text);
+    if (!definition || definition.isDef !== true)
+      return;
+    const expected = interfaceEndTypes(definition);
+    const connect = decl.connect;
+    const written = [connect?.source, connect?.target];
+    if (expected.length !== written.length)
+      return;
+    for (let position = 0; position < written.length; position += 1) {
+      const path10 = endPath(written[position]);
+      const wanted = expected[position];
+      if (!path10 || !wanted || wanted.conjugated)
+        continue;
+      const end = this.endType(path10, index);
+      if (!end || end.conjugated)
+        continue;
+      if (model.conforms(end.text, wanted.text) !== "unrelated")
+        continue;
+      accept(severity("SSM027", "error"), DIAGNOSTIC_MESSAGES.SSM027_INTERFACE_END_TYPE(position + 1, end.text, declared.text, wanted.text), { node: decl, code: "SSM027" });
+    }
   }
   // ══════════════════════════════════════════════════════════════════════
   // REQ-160 — occurrence portions: `timeslice` / `snapshot` well-formedness
@@ -61768,7 +62431,7 @@ function specializationTargets(node) {
     ...node.relationships ?? []
   ];
   for (const rel of rels) {
-    if (rel.kind && SPECIALIZATION_KINDS2.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS3.has(rel.kind))
       out.push(...rel.targets);
   }
   return out;
@@ -61821,6 +62484,103 @@ function literalBound(b) {
 function sameDocument(a2, b) {
   return ast_utils_exports.getDocument(a2).uri.toString() === ast_utils_exports.getDocument(b).uri.toString();
 }
+function soleDeclaredType(node) {
+  const types = declaredTypesOf(node);
+  return types.length === 1 ? types[0] : void 0;
+}
+function declarationSite(node, label) {
+  const range = node.$cstNode?.range;
+  if (!range)
+    return void 0;
+  return [{
+    location: { uri: ast_utils_exports.getDocument(node).uri.toString(), range },
+    message: `'${simpleTypeName(label)}' is declared here`
+  }];
+}
+var BINDING_KEYWORDS = {
+  BindStmt: "bind",
+  BindingDecl: "binding",
+  BindingConnectorStmt: "binding"
+};
+function endPath(end) {
+  const path10 = end?.path?.trim();
+  return path10 && path10.length > 0 ? path10 : void 0;
+}
+function binaryConnectorEnds(decl) {
+  const node = decl;
+  const pairs = [];
+  const push2 = (a2, b) => {
+    const from = endPath(a2);
+    const to = endPath(b);
+    if (from && to)
+      pairs.push([from, to]);
+  };
+  push2(node.source, node.target);
+  push2(node.left, node.right);
+  return pairs;
+}
+function flowPayloadType(payload) {
+  if (!payload)
+    return void 0;
+  const bare = payload.type?.$refText?.trim();
+  if (bare)
+    return { text: bare, simple: simpleTypeName(bare), conjugated: false };
+  return soleDeclaredType(payload);
+}
+function isCompositeOrRefUsage(node) {
+  return COMPOSITE_FEATURE_USAGE_TYPES.has(node.$type) && node.isDef !== true;
+}
+var USAGE_DEFINITION_DOMAINS = {
+  PartDecl: { keyword: "part", expected: "a 'part def' (or the 'item def' / 'occurrence def' it specializes)", allowed: /* @__PURE__ */ new Set(["PartDecl", "ItemDecl", "OccurrenceDecl"]) },
+  ItemDecl: { keyword: "item", expected: "an 'item def' (a 'part def' is one)", allowed: /* @__PURE__ */ new Set(["ItemDecl", "PartDecl", "OccurrenceDecl"]) },
+  PortDecl: { keyword: "port", expected: "a 'port def'", allowed: /* @__PURE__ */ new Set(["PortDecl"]) },
+  AttributeDecl: { keyword: "attribute", expected: "an 'attribute def' or an 'enum def'", allowed: /* @__PURE__ */ new Set(["AttributeDecl", "EnumDecl"]) },
+  EnumDecl: { keyword: "enum", expected: "an 'enum def'", allowed: /* @__PURE__ */ new Set(["EnumDecl", "AttributeDecl"]) },
+  OccurrenceDecl: { keyword: "occurrence", expected: "an 'occurrence def', 'part def' or 'item def'", allowed: /* @__PURE__ */ new Set(["OccurrenceDecl", "PartDecl", "ItemDecl"]) },
+  ActionDecl: { keyword: "action", expected: "an 'action def' (or a 'calc def' / 'case def', which are ones)", allowed: /* @__PURE__ */ new Set(["ActionDecl", "CalcDecl", "CaseDecl", "UseCaseDecl", "AnalysisCaseDecl", "VerificationCaseDecl", "StateDecl"]) },
+  StateDecl: { keyword: "state", expected: "a 'state def' (an 'action def' is one)", allowed: /* @__PURE__ */ new Set(["StateDecl", "ActionDecl"]) },
+  CalcDecl: { keyword: "calc", expected: "a 'calc def' (an 'action def' is one)", allowed: /* @__PURE__ */ new Set(["CalcDecl", "ActionDecl", "CaseDecl", "AnalysisCaseDecl"]) },
+  ConstraintDecl: { keyword: "constraint", expected: "a 'constraint def' (a 'requirement def' is one)", allowed: /* @__PURE__ */ new Set(["ConstraintDecl", "RequirementDecl"]) },
+  RequirementDecl: { keyword: "requirement", expected: "a 'requirement def' (a 'constraint def' is one)", allowed: /* @__PURE__ */ new Set(["RequirementDecl", "ConstraintDecl", "ConcernDecl"]) },
+  ConcernDecl: { keyword: "concern", expected: "a 'concern def' (a 'requirement def' is one)", allowed: /* @__PURE__ */ new Set(["ConcernDecl", "RequirementDecl", "ConstraintDecl"]) },
+  ConnectionDecl: { keyword: "connection", expected: "a 'connection def' (an 'interface def' / 'allocation def' is one)", allowed: /* @__PURE__ */ new Set(["ConnectionDecl", "InterfaceDecl", "AllocationDecl", "PartDecl", "ItemDecl"]) },
+  InterfaceDecl: { keyword: "interface", expected: "an 'interface def' (a 'connection def' is one)", allowed: /* @__PURE__ */ new Set(["InterfaceDecl", "ConnectionDecl"]) },
+  AllocationDecl: { keyword: "allocation", expected: "an 'allocation def' (a 'connection def' is one)", allowed: /* @__PURE__ */ new Set(["AllocationDecl", "ConnectionDecl"]) },
+  ViewDecl: { keyword: "view", expected: "a 'view def'", allowed: /* @__PURE__ */ new Set(["ViewDecl", "PartDecl"]) },
+  ViewpointDecl: { keyword: "viewpoint", expected: "a 'viewpoint def' (a 'requirement def' is one)", allowed: /* @__PURE__ */ new Set(["ViewpointDecl", "RequirementDecl", "ConcernDecl"]) },
+  RenderingDecl: { keyword: "rendering", expected: "a 'rendering def'", allowed: /* @__PURE__ */ new Set(["RenderingDecl", "PartDecl"]) },
+  MetadataDecl: { keyword: "metadata", expected: "a 'metadata def'", allowed: /* @__PURE__ */ new Set(["MetadataDecl"]) }
+};
+var GUARD_CONSTRUCTS = {
+  TransitionDecl: "transition",
+  SuccessionStmt: "succession",
+  TransitionStmt: "transition"
+};
+var PARAMETERIZED_USAGE_TYPES = /* @__PURE__ */ new Set([
+  "ActionDecl",
+  "CalcDecl",
+  "CaseDecl",
+  "UseCaseDecl",
+  "AnalysisCaseDecl",
+  "VerificationCaseDecl",
+  "ConstraintDecl"
+]);
+var PARAMETER_DIRECTIONS = /* @__PURE__ */ new Set(["in", "out", "inout"]);
+function directionOf(node) {
+  return (node.modifiers ?? []).find((modifier) => PARAMETER_DIRECTIONS.has(modifier));
+}
+function directedParameters(node) {
+  const out = [];
+  for (const member of node.members ?? []) {
+    const direction = directionOf(member);
+    if (direction)
+      out.push({ node: member, direction });
+  }
+  return out;
+}
+function interfaceEndTypes(definition) {
+  return (definition.members ?? []).filter((member) => member.$type === "EndDecl" || member.modifiers?.includes("end")).map((member) => soleDeclaredType(member));
+}
 var NON_BOOLEAN_BIN_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "**", "^", ".."]);
 function isDefinitelyNonBoolean(node) {
   const type = node.$type;
@@ -62651,7 +63411,7 @@ function trailingBlockBody(node) {
 }
 
 // ../language-server/out/src/services/document-symbol-provider.js
-var SPECIALIZATION_KINDS3 = /* @__PURE__ */ new Set([":>", "specializes"]);
+var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", "specializes"]);
 var REDEFINITION_KINDS = /* @__PURE__ */ new Set([":>>", "redefines"]);
 var INHERITABLE_FEATURE_TYPES = /* @__PURE__ */ new Set([
   "ActionDecl",
@@ -62720,7 +63480,7 @@ function specializationTargets2(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS3.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS4.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -64341,24 +65101,46 @@ var MULTIPLICITY_TEMPLATES = [
   insertText,
   detail: "Multiplicity"
 }));
+var ARROW_FUNCTION_LIBRARIES = /* @__PURE__ */ new Set([
+  "ControlFunctions",
+  "SequenceFunctions",
+  "CollectionFunctions"
+]);
 var ARROW_FUNCTIONS = [
+  // ControlFunctions — take a body expression over each element.
+  ["collect", "collect { in ${1:x}; ${0:x} }"],
+  ["select", "select { in ${1:x}; ${0:true} }"],
+  ["selectOne", "selectOne { in ${1:x}; ${0:true} }"],
+  ["reject", "reject { in ${1:x}; ${0:false} }"],
+  ["reduce", "reduce ${0:'+'}"],
+  ["forAll", "forAll { in ${1:x}; ${0:true} }"],
+  ["exists", "exists { in ${1:x}; ${0:true} }"],
+  ["minimize", "minimize { in ${1:x}; ${0:x} }"],
+  ["maximize", "maximize { in ${1:x}; ${0:x} }"],
+  ["allTrue", "allTrue()"],
+  ["anyTrue", "anyTrue()"],
+  // SequenceFunctions / CollectionFunctions — size and element access.
   ["size", "size()"],
   ["isEmpty", "isEmpty()"],
   ["notEmpty", "notEmpty()"],
-  ["at", "at(${1:index})"],
   ["head", "head()"],
   ["tail", "tail()"],
-  ["includes", "includes(${1:item})"],
-  ["excludes", "excludes(${1:item})"],
-  ["including", "including(${1:item})"],
-  ["excluding", "excluding(${1:item})"],
-  ["union", "union(${1:other})"],
-  ["intersection", "intersection(${1:other})"],
-  ["difference", "difference(${1:other})"],
-  ["select", "select { in ${1:x}; ${0:true} }"],
-  ["forAll", "forAll { in ${1:x}; ${0:true} }"],
-  ["exists", "exists { in ${1:x}; ${0:true} }"],
-  ["collect", "collect { in ${1:x}; ${0:x} }"]
+  ["last", "last()"],
+  ["subsequence", "subsequence(${1:startIndex}, ${0:endIndex})"],
+  // Membership and set algebra.
+  ["includes", "includes(${0:item})"],
+  ["includesOnly", "includesOnly(${0:other})"],
+  ["excludes", "excludes(${0:item})"],
+  ["contains", "contains(${0:item})"],
+  ["containsAll", "containsAll(${0:other})"],
+  ["including", "including(${0:values})"],
+  ["includingAt", "includingAt(${1:values}, ${0:index})"],
+  ["excluding", "excluding(${0:values})"],
+  ["excludingAt", "excludingAt(${1:startIndex}, ${0:endIndex})"],
+  ["union", "union(${0:other})"],
+  ["intersection", "intersection(${0:other})"],
+  ["equals", "equals(${0:other})"],
+  ["same", "same(${0:other})"]
 ].map(([label, insertText]) => ({
   label,
   kind: import_vscode_languageserver16.CompletionItemKind.Function,
@@ -64551,6 +65333,10 @@ var SNIPPETS = [
 ];
 var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   indexManager;
+  // REQ-242 — issue #103: member completion resolves the written receiver with
+  // the same service that answers go-to-definition, so `.` offers exactly the
+  // members navigation can reach — including inherited and cross-file ones.
+  featurePaths;
   // REQ-245, REQ-268 — Qualified names of every indexed element, keyed by the
   // element it names. Built once per workspace build and evicted with the rest
   // of the workspace caches; see [[qualifiedNamesByElement]].
@@ -64561,6 +65347,7 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
   constructor(services) {
     super(services);
     this.indexManager = services.shared.workspace.IndexManager;
+    this.featurePaths = new FeaturePathResolver(services);
     this.qualifiedNameCache = new WorkspaceCache(services.shared);
   }
   async getCompletion(document, params) {
@@ -64591,6 +65378,21 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
       item.labelDetails = { description: categoryLabel(category), ...item.labelDetails ?? {} };
     }
   }
+  // REQ-242 — issue #103: a `CompletionItem` keeps only a label and the AST
+  // type name, so once Langium has produced a cross-reference item there is no
+  // way back to the description that justified it. Record the two facts the
+  // typing filter needs while the description is still in hand.
+  createReferenceCompletionItem(nodeDescription) {
+    const item = super.createReferenceCompletionItem(nodeDescription);
+    return {
+      ...item,
+      data: {
+        ...item.data,
+        isDefinition: isDefinitionDescription(nodeDescription),
+        isDottedPath: nodeDescription.name.includes(".")
+      }
+    };
+  }
   filterDefaultsForContext(items, context) {
     if (context.kind === "package-body" || context.kind === "member-body")
       return;
@@ -64604,11 +65406,15 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
       allowedLabels.add("subsets");
       allowedLabels.add("redefines");
     }
+    const definitionsOnly = context.kind === "typing";
+    const rejectDottedPaths = definitionsOnly || context.kind === "specialization";
     const allowedTypes = new Set(this.symbolTypesForContext(context));
     for (let i = items.length - 1; i >= 0; i--) {
       const item = items[i];
       const detail = typeof item.detail === "string" ? item.detail : void 0;
-      if (allowedLabels.has(item.label) || detail && allowedTypes.has(detail))
+      if (allowedLabels.has(item.label))
+        continue;
+      if (detail && allowedTypes.has(detail) && (!definitionsOnly || isDefinitionItem(item)) && (!rejectDottedPaths || !isDottedPathItem(item)))
         continue;
       items.splice(i, 1);
     }
@@ -64647,14 +65453,17 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
             detail: "Conjugated port type"
           })));
         }
+        if (context.kind === "specialization") {
+          addUnique(items, this.inheritedFeatureItems(document, offset, context));
+        }
         return;
       }
       case "member-access": {
-        addUnique(items, this.memberAccessItems(document, context.receiver));
+        addUnique(items, this.memberAccessItems(document, context.receiver, offset));
         return;
       }
       case "arrow": {
-        addUnique(items, ARROW_FUNCTIONS);
+        addUnique(items, this.arrowFunctionItems());
         return;
       }
       case "import": {
@@ -64786,24 +65595,54 @@ var SysmlCompletionProvider = class extends DefaultCompletionProvider {
     }
     return items;
   }
-  memberAccessItems(document, receiver) {
+  memberAccessItems(document, receiver, offset) {
     if (!receiver)
       return [];
     const root3 = document.parseResult.value;
-    const members = resolveReceiverMembers(root3, receiver);
+    const context = smallestNodeAtOffset(root3, offset) ?? root3;
+    const members = this.featurePaths.membersForPath(context, receiverSteps(receiver));
     return members.map((node) => this.itemForNode(node)).filter(isDefined);
   }
   connectPortItems(document, offset) {
     const root3 = document.parseResult.value;
     const enclosing = smallestNodeAtOffset(root3, offset);
     const owner = nearestMemberOwner(enclosing) ?? root3;
-    return collectReachablePorts(owner).map((path10) => ({
+    return collectReachablePorts(owner, (node) => this.featurePaths.visibleMembers(node)).map((path10) => ({
       label: path10,
       kind: import_vscode_languageserver16.CompletionItemKind.Interface,
       detail: "Reachable port",
       sortText: "0"
     }));
   }
+  // REQ-242 — issue #103: `subsets` and `redefines` name a FEATURE of the
+  // enclosing declaration, and the ones worth offering are normally the
+  // inherited ones — refining a feature the supertype introduced is what the
+  // operators are for. Those features are declared in another namespace, so
+  // no scope rooted at the current one reaches them; walk the enclosing
+  // declaration's own supertypes instead. The declaration being written is
+  // excluded, so `part frontWheels :>` never offers `frontWheels`.
+  inheritedFeatureItems(document, offset, context) {
+    const root3 = document.parseResult.value;
+    const owner = nearestMemberOwner(smallestNodeAtOffset(root3, offset));
+    if (!owner)
+      return [];
+    const allowed = new Set(this.symbolTypesForContext(context));
+    return this.featurePaths.visibleMembers(owner).filter((node) => allowed.has(node.$type) && isUsage(node) && !coversOffset(node, offset)).map((node) => this.itemForNode(node)).filter(isDefined);
+  }
+  // REQ-242 — issue #103: the curated table carries the argument shapes, but
+  // the vendored library is the authority on WHICH functions exist. Merge in
+  // any collection-processing function the index knows and the table does not,
+  // so a library revision does not silently stop being offered.
+  arrowFunctionItems() {
+    const items = [...ARROW_FUNCTIONS];
+    addUnique(items, this.indexManager.allElements().filter((desc) => desc.type === "FunctionDecl" || desc.type === "PredicateDecl").map((desc) => desc.name.split("::")).filter((parts) => parts.length === 2 && ARROW_FUNCTION_LIBRARIES.has(parts[0]) && isArrowInvocableName(parts[1])).map((parts) => ({
+      label: parts[1],
+      kind: import_vscode_languageserver16.CompletionItemKind.Function,
+      detail: "Kernel Function Library",
+      sortText: "0"
+    })).toArray());
+    return items;
+  }
   unitSymbolItems() {
     const symbols = getDimensionTable()?.unitSymbols ?? COMMON_UNIT_SYMBOLS;
     return symbols.map((symbol) => ({
@@ -64959,9 +65798,21 @@ function isPackageBody(prefix) {
 function elementKey(desc) {
   return `${desc.documentUri.toString()}#${desc.path}#${desc.type}`;
 }
+function isArrowInvocableName(name) {
+  return /^[\p{L}_][\p{L}\p{N}_]*$/u.test(name);
+}
 function isDefinitionDescription(desc) {
   const node = desc.node;
-  return node?.isDef === void 0 || node.isDef === true;
+  if (node?.isDef !== void 0)
+    return node.isDef === true;
+  const usage = desc.isUsage;
+  return usage !== true;
+}
+function isDefinitionItem(item) {
+  return item.data?.isDefinition !== false;
+}
+function isDottedPathItem(item) {
+  return item.data?.isDottedPath === true;
 }
 function addUnique(items, additions) {
   const labels = new Map(items.map((item, index) => [item.label, index]));
@@ -65015,54 +65866,33 @@ function isUsage(node) {
   const isDef = node.isDef;
   return isDef === void 0 || isDef === false;
 }
-function typingTarget(node) {
-  const ref = node?.typing?.type;
-  if (!ref)
-    return void 0;
-  try {
-    if (ref.ref)
-      return ref.ref;
-  } catch {
-  }
-  const refText = ref.$refText;
-  if (typeof refText !== "string")
-    return void 0;
-  return findNamedNode(ast_utils_exports.getDocument(node).parseResult.value, simpleName(refText), { definitionsOnly: true });
-}
-function resolveReceiverMembers(root3, receiver) {
-  let current2 = findNamedNode(root3, simpleName(receiver.split(/[.:]+/u)[0]));
-  for (const segment of receiver.split(/(?:\.|::)/u).slice(1)) {
-    current2 = collectMembersWithTyped(current2).find((member) => nodeName(member) === segment);
-    if (!current2)
-      return [];
-  }
-  return collectMembersWithTyped(current2);
-}
-function collectMembersWithTyped(node) {
-  if (!node)
-    return [];
-  const members = [...nodeMembers(node)];
-  const typed = typingTarget(node);
-  if (typed && typed !== node) {
-    members.push(...nodeMembers(typed));
+function receiverSteps(receiver) {
+  const steps = [];
+  const pattern = /(::|\.)?\s*([\p{L}_'][\p{L}\p{N}_']*)/gu;
+  let match;
+  while ((match = pattern.exec(receiver)) !== null) {
+    steps.push({
+      text: unquoteName2(match[2]),
+      separator: steps.length === 0 ? void 0 : match[1]
+    });
   }
-  return uniqueNodes(members).filter((member) => nodeName(member) !== void 0);
+  return steps;
 }
-function collectReachablePorts(owner) {
+function collectReachablePorts(owner, members) {
   const seenOwners = /* @__PURE__ */ new Set();
   const paths = /* @__PURE__ */ new Set();
   const visitOwner = (node, prefix) => {
     if (!node || seenOwners.has(node))
       return;
     seenOwners.add(node);
-    for (const member of collectMembersWithTyped(node)) {
+    for (const member of members(node)) {
       const name = nodeName(member);
       if (!name || !isUsage(member))
         continue;
       if (member.$type === "PortDecl") {
         paths.add(`${prefix}${name}`);
       } else if (member.$type === "PartDecl") {
-        visitOwner(typingTarget(member) ?? member, `${prefix}${name}.`);
+        visitOwner(member, `${prefix}${name}.`);
       }
     }
     seenOwners.delete(node);
@@ -65070,12 +65900,6 @@ function collectReachablePorts(owner) {
   visitOwner(owner, "");
   return [...paths].sort();
 }
-function findNamedNode(root3, name, options = {}) {
-  if (!name)
-    return void 0;
-  const matches = [root3, ...ast_utils_exports.streamAllContents(root3).toArray()].filter((node) => nodeName(node) === name).filter((node) => !options.definitionsOnly || node.isDef !== false);
-  return matches.find((node) => node.isDef === true) ?? matches[0];
-}
 function smallestNodeAtOffset(root3, offset) {
   let best;
   for (const node of [root3, ...ast_utils_exports.streamAllContents(root3).toArray()]) {
@@ -65088,6 +65912,10 @@ function smallestNodeAtOffset(root3, offset) {
   }
   return best;
 }
+function coversOffset(node, offset) {
+  const cst = node.$cstNode;
+  return cst !== void 0 && cst.offset <= offset && cst.end >= offset;
+}
 function nearestMemberOwner(node) {
   let current2 = node;
   while (current2) {
@@ -65097,9 +65925,6 @@ function nearestMemberOwner(node) {
   }
   return void 0;
 }
-function uniqueNodes(nodes) {
-  return [...new Set(nodes)];
-}
 function simpleName(name) {
   if (!name)
     return void 0;
@@ -65519,12 +66344,12 @@ function importSignature(imp) {
   const segments = imp.segs.map((seg) => `${seg.name ?? ""}${seg.star ? "*" : ""}${seg.recursive ? "**" : ""}`);
   return `${importVisibility(imp)} ${imp.head}::${segments.join("::")}${imp.alias ? ` as ${imp.alias}` : ""}`;
 }
-var SPECIALIZATION_KINDS4 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets3(node) {
   const n = node;
   const out = [];
   for (const rel of [...n.preRelationships ?? [], ...n.relationships ?? []]) {
-    if (rel.kind && SPECIALIZATION_KINDS4.has(rel.kind))
+    if (rel.kind && SPECIALIZATION_KINDS5.has(rel.kind))
       out.push(...rel.targets ?? []);
   }
   return out;
@@ -65729,7 +66554,11 @@ var SysmlScopeComputation = class extends DefaultScopeComputation {
       ...base,
       ...visibility ? { visibility } : {},
       ...visibility === "private" ? { isPrivate: true } : {},
-      ...alias.derived ? { isDerivedAlias: true } : {}
+      ...alias.derived ? { isDerivedAlias: true } : {},
+      // REQ-242 — issue #103 — mirrors what the precomputed library index
+      // records, so consumers read def-ness the same way for workspace and
+      // library symbols.
+      ...node.isDef === false ? { isUsage: true } : {}
     };
     if (!alias.cstNode)
       return description;
@@ -65801,12 +66630,12 @@ function directImportEntries(imp, descriptions) {
   }
   return entries;
 }
-var SPECIALIZATION_KINDS5 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
+var SPECIALIZATION_KINDS6 = /* @__PURE__ */ new Set([":>", ":>>", "specializes", "subsets", "redefines"]);
 function specializationTargets4(node) {
   const value = node;
   const targets = [];
   for (const relationship of [...value.preRelationships ?? [], ...value.relationships ?? []]) {
-    if (relationship.kind && SPECIALIZATION_KINDS5.has(relationship.kind)) {
+    if (relationship.kind && SPECIALIZATION_KINDS6.has(relationship.kind)) {
       targets.push(...relationship.targets ?? []);
     }
   }
@@ -69183,7 +70012,7 @@ async function runValidation(command) {
 }
 
 // src/main.ts
-var VERSION2 = true ? "0.15.4" : "dev";
+var VERSION2 = true ? "0.15.6" : "dev";
 async function main(argv) {
   const command = parseArgs(argv);
   if (command.kind === "help") {