@neocompose/cli 0.31.4 → 0.31.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.31.6] - 2026-08-15
+
+### Added
+
+- Improve shared NeoScript editor intelligence with inferred-type and
+  low-noise parameter inlay hints, spelling-aware diagnostics and quick fixes,
+  and a contextual `var`-to-explicit-type refactoring.
+
+### Fixed
+
+- Disambiguate same-named types, values, members, and contextual enum options
+  by their expression role, receiver, and expected type. Member completion and
+  navigation now separate static and instance access and follow inherited
+  members with derived-first hiding.
+
+## [0.31.5] - 2026-08-15
+
+### Fixed
+
+- Resolve callable members through generic class and interface constraints, so
+  an open generic value can call guaranteed APIs such as `Class.Clone()`.
+
 ## [0.31.4] - 2026-08-14
 
 ### Fixed

package/dist/neo.mjs

@@ -1832,6 +1832,21 @@ var init_generated_csharp_identifiers = __esm({
 });
 
 // ../packages/neoscript-language/src/project.ts
+function neoScriptMemberLookupType(type) {
+  if (type.kind !== "typeParameter") return type;
+  const visited = /* @__PURE__ */ new Set();
+  let current = type;
+  let nullable = type.nullable === true;
+  while (current.kind === "typeParameter") {
+    if (visited.has(current.id) || current.constraint === void 0) {
+      return type;
+    }
+    visited.add(current.id);
+    nullable ||= current.constraint.nullable === true;
+    current = current.constraint;
+  }
+  return nullable && current.nullable !== true ? { ...current, nullable: true } : current;
+}
 function neoScriptParameterIsOmittable(parameter4) {
   return parameter4.defaultValue !== void 0;
 }
@@ -2469,14 +2484,19 @@ function signatureHelp(snapshot, position) {
 function inlayHints(snapshot, range2) {
   const hints = [];
   for (const call of snapshot.parsed.calls) {
-    if (call.kind !== "constructor") continue;
-    const type = snapshot.project.typeByName.get(call.name);
-    const parameterNames = constructorParameterNames(type);
+    const reference2 = snapshot.parsed.references.find(
+      (candidate) => candidate.range.start.line === call.nameRange.start.line && candidate.range.start.character === call.nameRange.start.character
+    );
+    const resolution = reference2 ? resolveReference(snapshot, reference2) : null;
+    const parameterNames = call.kind === "constructor" ? constructorParameterNames(resolution?.staticType) : resolution?.symbol?.parameters?.map((parameter4) => parameter4.name);
     if (!parameterNames) continue;
     for (let index = 0; index < call.argumentRanges.length; index++) {
       const argumentRange = call.argumentRanges[index];
       const parameterName = parameterNames[index];
       if (!argumentRange || !parameterName) continue;
+      if (obviousParameterName(snapshot, argumentRange, parameterName)) {
+        continue;
+      }
       const position = firstNonWhitespacePosition(snapshot, argumentRange);
       if (range2 && !positionInRange(position, range2)) continue;
       hints.push({
@@ -2487,8 +2507,59 @@ function inlayHints(snapshot, range2) {
       });
     }
   }
+  for (const local of snapshot.parsed.locals) {
+    if (!local.inferred || !local.contextualKeywordRange) continue;
+    const type = resolveDeclaredType(local, snapshot);
+    if (type.kind === "primitive" && type.name === "unknown") continue;
+    const position = local.nameRange.end;
+    if (range2 && !positionInRange(position, range2)) continue;
+    hints.push({
+      position,
+      label: `: ${formatType(type, snapshot.project)}`,
+      kind: "type",
+      paddingLeft: false
+    });
+  }
   return hints;
 }
+function obviousParameterName(snapshot, argumentRange, parameterName) {
+  const start = snapshot.source.offsetAt(argumentRange.start);
+  const end = snapshot.source.offsetAt(argumentRange.end);
+  const argument2 = snapshot.source.text.slice(start, end).trim();
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(argument2) && normalizeHintName(argument2) === normalizeHintName(parameterName);
+}
+function normalizeHintName(name) {
+  return name.replaceAll("_", "").toLocaleLowerCase();
+}
+function inferredTypeRefactorings(snapshot, range2) {
+  return snapshot.parsed.locals.flatMap((local) => {
+    if (!local.inferred || !local.contextualKeywordRange || !rangesIntersect(local.declarationRange, range2)) {
+      return [];
+    }
+    const type = resolveDeclaredType(local, snapshot);
+    if (type.kind === "primitive" && type.name === "unknown") return [];
+    const formatted = formatType(type, snapshot.project);
+    return [
+      {
+        title: `Use explicit type '${formatted}'`,
+        kind: "refactor.rewrite",
+        edit: {
+          changes: {
+            [snapshot.uri]: [
+              { range: local.contextualKeywordRange, newText: formatted }
+            ]
+          }
+        }
+      }
+    ];
+  });
+}
+function rangesIntersect(left, right) {
+  return positionCompare(left.start, right.end) <= 0 && positionCompare(right.start, left.end) <= 0;
+}
+function positionCompare(left, right) {
+  return left.line - right.line || left.character - right.character;
+}
 function constructorParameterNames(type) {
   const declared = type?.declaredConstructors ?? [];
   if (declared.length > 0) {
@@ -3160,7 +3231,8 @@ function completionItemsForResolution(snapshot, resolved, word) {
       (member) => member.static === true && isMemberCompletionAccessible(snapshot, staticType, member)
     ).map((member) => symbolCompletion(member, word, snapshot));
   }
-  const owner = resolved.type.kind === "named" ? snapshot.project.typeById.get(resolved.type.typeId) : void 0;
+  const memberType2 = neoScriptMemberLookupType(resolved.type);
+  const owner = memberType2.kind === "named" ? snapshot.project.typeById.get(memberType2.typeId) : void 0;
   return membersForType(snapshot, resolved.type).filter(
     (symbol) => owner === void 0 || isMemberCompletionAccessible(snapshot, owner, symbol)
   ).map((symbol) => symbolCompletion(symbol, word, snapshot));
@@ -3174,6 +3246,17 @@ function isMemberCompletionAccessible(snapshot, owner, symbol) {
   }) === null;
 }
 function membersForType(snapshot, type) {
+  const memberType2 = neoScriptMemberLookupType(type);
+  if (memberType2 !== type) {
+    const members = [...membersForType(snapshot, memberType2)];
+    if (type.kind !== "typeParameter" || type.nullable === true) return members;
+    const named = memberType2.kind === "named" ? snapshot.project.typeById.get(memberType2.typeId) : void 0;
+    if (named?.kind !== "class") return members;
+    const cloneId = `builtin:${named.id}:Clone`;
+    return members.map(
+      (member) => member.id === cloneId ? cloneSymbol(named, type) : member
+    );
+  }
   if (type.kind === "named") {
     const named = snapshot.project.typeById.get(type.typeId);
     if (!named) return [];
@@ -3950,13 +4033,13 @@ function stringContainsSymbol() {
     "Returns true when the string contains the substring."
   );
 }
-function cloneSymbol(type) {
+function cloneSymbol(type, returnType = { kind: "named", typeId: type.id }) {
   return {
     id: `builtin:${type.id}:Clone`,
     name: "Clone",
     kind: "method",
-    type: { kind: "named", typeId: type.id },
-    returnType: { kind: "named", typeId: type.id },
+    type: returnType,
+    returnType,
     parameters: [],
     documentation: `Deep-copy this ${type.name} into a new parentless writable value.`
   };
@@ -11871,11 +11954,12 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (receiver.type.kind === "named") {
-          const type = this.project.typeById.get(receiver.type.typeId);
+        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        if (memberReceiverType.kind === "named") {
+          const type = this.project.typeById.get(memberReceiverType.typeId);
           if (!type) {
             throw new CompileError(
-              `Type ${receiver.type.typeId} was not found in the project.`,
+              `Type ${memberReceiverType.typeId} was not found in the project.`,
               pos
             );
           }
@@ -11909,7 +11993,7 @@ var init_strict_resolver = __esm({
           }
           const memberType2 = substituteTypeParameters(
             member.type,
-            receiver.type,
+            memberReceiverType,
             type
           );
           if (member.computed === true) {
@@ -12350,8 +12434,9 @@ var init_strict_resolver = __esm({
             pos
           );
         }
-        if (receiver.type.kind === "named") {
-          const type = this.project.typeById.get(receiver.type.typeId);
+        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        if (memberReceiverType.kind === "named") {
+          const type = this.project.typeById.get(memberReceiverType.typeId);
           const member = type?.members.find(
             (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
           );
@@ -12365,7 +12450,10 @@ var init_strict_resolver = __esm({
             }
             return this.resolveSymbolCall(
               member,
-              { kind: "instance", expression: receiver },
+              {
+                kind: "instance",
+                expression: memberReceiverType === receiver.type ? receiver : { ...receiver, type: memberReceiverType }
+              },
               argumentsList2,
               scope,
               pos,
@@ -12385,7 +12473,7 @@ var init_strict_resolver = __esm({
                 pos
               );
             }
-            const schemaClass2 = toWireType(receiver.type, this.project);
+            const schemaClass2 = toWireType(memberReceiverType, this.project);
             return {
               pointer: {
                 type: "function" /* Function */,
@@ -17457,7 +17545,7 @@ var init_project_source_parser = __esm({
 
 // ../packages/neoscript-language/src/project-source-tokens.ts
 function rangeContains(range2, position) {
-  return positionCompare(range2.start, position) <= 0 && positionCompare(position, range2.end) <= 0;
+  return positionCompare2(range2.start, position) <= 0 && positionCompare2(position, range2.end) <= 0;
 }
 function rangeSize(range2) {
   return (range2.end.line - range2.start.line) * 1e6 + range2.end.character - range2.start.character;
@@ -17585,9 +17673,9 @@ function tripleInterpolationEnd(text, start, limit) {
   return null;
 }
 function rangesEqual(left, right) {
-  return positionCompare(left.start, right.start) === 0 && positionCompare(left.end, right.end) === 0;
+  return positionCompare2(left.start, right.start) === 0 && positionCompare2(left.end, right.end) === 0;
 }
-function positionCompare(left, right) {
+function positionCompare2(left, right) {
   return left.line === right.line ? left.character - right.character : left.line - right.line;
 }
 var PROJECT_TOKEN_CACHE;
@@ -17692,7 +17780,7 @@ function scanAnnotation(tokens, atIndex) {
   };
 }
 function rangeWithin(outer, inner) {
-  return positionCompare(outer.start, inner.start) <= 0 && positionCompare(inner.end, outer.end) <= 0;
+  return positionCompare2(outer.start, inner.start) <= 0 && positionCompare2(inner.end, outer.end) <= 0;
 }
 var init_project_source_registry = __esm({
   "../packages/neoscript-language/src/project-source-registry.ts"() {
@@ -26441,7 +26529,8 @@ function collectDeclarationSymbols(uri, document, declaration, symbols, diagnost
       void 0,
       member.type.name,
       member.kind === "function",
-      member.docsText
+      member.docsText,
+      member.modifiers.includes("static")
     );
     if (member.kind === "function") {
       for (const parameter4 of member.parameters) {
@@ -26531,7 +26620,7 @@ function collectFlowSymbols(uri, content, ownerName, scopeRange, symbols, diagno
     }
   }
 }
-function collectSymbol(uri, kind, name, range2, annotations, ownerName, symbols, diagnostics, scopeRange, detail, callable2, documentation) {
+function collectSymbol(uri, kind, name, range2, annotations, ownerName, symbols, diagnostics, scopeRange, detail, callable2, documentation, staticMember) {
   if (RESERVED_NAMES3.has(name)) {
     diagnostics.push({
       uri,
@@ -26561,6 +26650,7 @@ function collectSymbol(uri, kind, name, range2, annotations, ownerName, symbols,
     ...scopeRange ? { scopeRange } : {},
     ...detail ? { detail } : {},
     ...callable2 ? { callable: callable2 } : {},
+    ...staticMember ? { static: true } : {},
     ...documentation ? { documentation } : {},
     location: { uri, range: range2 }
   });
@@ -27345,16 +27435,16 @@ function projectAnnotationNamesAt(analysis, document, position) {
   const containing = declarationContaining(source, position);
   if (containing?.kind === "enum") return ["id"];
   if (containing?.kind === "class" || containing?.kind === "interface") {
-    if (positionCompare(position, containing.nameRange.start) < 0) {
+    if (positionCompare2(position, containing.nameRange.start) < 0) {
       return projectDeclarationAnnotationNames(containing);
     }
     const member = containing.members.find(
-      (candidate) => rangeContains(candidate.range, position) || positionCompare(position, candidate.range.start) <= 0
+      (candidate) => rangeContains(candidate.range, position) || positionCompare2(position, candidate.range.start) <= 0
     );
     return projectMemberAnnotationNames(member);
   }
   const following = source.declarations.find(
-    (declaration) => positionCompare(position, declaration.range.start) <= 0
+    (declaration) => positionCompare2(position, declaration.range.start) <= 0
   );
   if (following) return projectDeclarationAnnotationNames(following);
   return ["id"];
@@ -27696,7 +27786,10 @@ function sourceTypeAt(document, position) {
 }
 function projectMemberCompletions(analysis, document, position) {
   const tokens = projectTokens(document).filter(
-    (token) => token.kind !== "eof" && token.kind !== "comment" && positionCompare(token.range.start, position) <= 0
+    (token) => token.kind !== "eof" && token.kind !== "comment" && // Auto-inserted/future punctuation at the cursor has not been authored
+    // yet for completion purposes. Including a semicolon that starts at the
+    // cursor makes `Device.|;` lose the dot it is completing.
+    positionCompare2(token.range.start, position) < 0
   );
   let cursor = tokens.length - 1;
   const current = tokens[cursor];
@@ -27708,16 +27801,19 @@ function projectMemberCompletions(analysis, document, position) {
   if (!owner || owner.kind !== "identifier") return null;
   const resolvedOwner = projectSymbolAt(analysis, document, owner.range.start);
   if (!resolvedOwner) return null;
-  const ownerNames = /* @__PURE__ */ new Set();
-  const typeName = projectSymbolTypeName(resolvedOwner.symbol);
-  if (typeName) ownerNames.add(typeName);
-  if (resolvedOwner.symbol.kind === "global") {
-    ownerNames.add(resolvedOwner.symbol.name);
+  const ownerNames = projectReceiverOwnerNames(analysis, resolvedOwner.symbol);
+  if (ownerNames.length === 0) return null;
+  const members = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const ownerName of ownerNames) {
+    for (const symbol of analysis.symbols) {
+      if (symbol.kind !== "member" && symbol.kind !== "graphChild" && symbol.kind !== "enumOption" || symbol.ownerName !== ownerName || !projectQualifiedSymbolMatchesReceiver(symbol, resolvedOwner.symbol) || seenNames.has(symbol.name)) {
+        continue;
+      }
+      seenNames.add(symbol.name);
+      members.push(symbol);
+    }
   }
-  if (ownerNames.size === 0) return null;
-  const members = analysis.symbols.filter(
-    (symbol) => (symbol.kind === "member" || symbol.kind === "graphChild") && symbol.ownerName !== void 0 && ownerNames.has(symbol.ownerName)
-  );
   return members.length > 0 ? members : null;
 }
 function projectConstructorArgumentCompletions(analysis, document, position) {
@@ -27860,7 +27956,7 @@ function projectConstructionIndex(analysis) {
 }
 function projectDottedPathBefore(document, position) {
   const tokens = projectTokens(document).filter(
-    (token) => token.kind !== "eof" && token.kind !== "comment" && positionCompare(token.range.start, position) < 0
+    (token) => token.kind !== "eof" && token.kind !== "comment" && positionCompare2(token.range.start, position) < 0
   );
   let cursor = tokens.length - 1;
   const current = tokens[cursor];
@@ -27987,7 +28083,7 @@ function projectGraphTargetCompletions(analysis, document, position) {
   const declaration = source ? declarationContaining(source, position) : void 0;
   if (declaration?.kind !== "class") return null;
   const member = declaration.members.filter(
-    (candidate) => positionCompare(candidate.range.start, position) <= 0
+    (candidate) => positionCompare2(candidate.range.start, position) <= 0
   ).at(-1);
   if (member?.kind !== "field" || !member.flowInitializer) return null;
   return analysis.symbols.filter(
@@ -28315,6 +28411,9 @@ function projectInlayHints(analysis, document, range2) {
       if (!argumentToken || argumentToken.named) continue;
       const name = parameterNames[argument2];
       if (!name) continue;
+      if (argumentToken.identifier && normalizeProjectHintName(argumentToken.identifier) === normalizeProjectHintName(name)) {
+        continue;
+      }
       if (range2 && !rangeContains(range2, argumentToken.start)) continue;
       hints.push({
         position: argumentToken.start,
@@ -28334,6 +28433,10 @@ function projectInlayHints(analysis, document, range2) {
   }
   return hints;
 }
+function projectInferredTypeRefactorings(analysis, document, range2) {
+  const snapshot = projectBodySnapshotAt(analysis, document, range2.start) ?? projectBodySnapshotAt(analysis, document, range2.end);
+  return snapshot ? inferredTypeRefactorings(snapshot, range2) : [];
+}
 function projectCallParameterNames(analysis, document, callee, beforeCallee) {
   if (callee.text === "Reference") return null;
   if (callee.text === "Pause") {
@@ -28380,7 +28483,8 @@ function projectCallArguments(tokens, openIndex) {
     if (depth === 0 && atArgumentStart) {
       result.push({
         start: token.range.start,
-        named: token.kind === "identifier" && tokens[index + 1]?.text === ":"
+        named: token.kind === "identifier" && tokens[index + 1]?.text === ":",
+        ...token.kind === "identifier" && (tokens[index + 1]?.text === "," || tokens[index + 1]?.text === ")") ? { identifier: token.text } : {}
       });
       atArgumentStart = false;
     }
@@ -28392,6 +28496,9 @@ function projectCallArguments(tokens, openIndex) {
   }
   return result;
 }
+function normalizeProjectHintName(name) {
+  return name.replaceAll("_", "").toLocaleLowerCase();
+}
 function positionKey(position) {
   return `${position.line}:${position.character}`;
 }
@@ -28576,7 +28683,7 @@ function projectSemanticTokens(document, analysis) {
     );
   }
   return result.sort(
-    (left, right) => positionCompare(left.range.start, right.range.start)
+    (left, right) => positionCompare2(left.range.start, right.range.start)
   );
 }
 function isProjectContextualKeyword(tokens, tokenIndex) {
@@ -28607,7 +28714,8 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     (candidate) => candidate.start === token.start && candidate.end === token.end
   );
   const source = analysis.documents.get(document.uri);
-  if (source && sourceTypeAt(source, token.range.start) || sourceTokens[tokenIndex - 1]?.text === "new") {
+  const typePosition = source && sourceTypeAt(source, token.range.start);
+  if (typePosition || sourceTokens[tokenIndex - 1]?.text === "new") {
     const types = candidates.filter(
       (symbol) => symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter"
     );
@@ -28620,10 +28728,15 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
   );
   if (scoped.length > 0) return { token, symbol: scoped[0] };
   const visibleCandidates = candidates.filter((symbol) => !symbol.scopeRange);
-  if (visibleCandidates.length === 1) {
-    return { token, symbol: visibleCandidates[0] };
-  }
   if (visibleCandidates.length === 0) return null;
+  const contextualEnum = contextualProjectEnumOptionSymbol(
+    analysis,
+    document,
+    token,
+    visibleCandidates,
+    source
+  );
+  if (contextualEnum) return { token, symbol: contextualEnum };
   if (sourceTokens[tokenIndex + 1]?.text === "=" && sourceTokens[tokenIndex + 2]?.text !== "=") {
     const constructed = constructionMemberSymbol(
       analysis,
@@ -28634,7 +28747,7 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     if (constructed) return { token, symbol: constructed };
   }
   const owner = source ? declarationContaining(source, token.range.start)?.name : void 0;
-  if (owner) {
+  if (owner && sourceTokens[tokenIndex - 1]?.text !== ".") {
     const owned = visibleCandidates.filter(
       (symbol) => symbol.ownerName === owner
     );
@@ -28648,24 +28761,100 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
       dotOwner.range.start,
       index
     );
-    const ownerNames = /* @__PURE__ */ new Set();
-    if (resolvedOwner) {
-      const typeName = projectSymbolTypeName(resolvedOwner.symbol);
-      if (typeName) ownerNames.add(typeName);
-      if (resolvedOwner.symbol.kind === "global") {
-        ownerNames.add(resolvedOwner.symbol.name);
-      }
-    } else {
-      ownerNames.add(dotOwner.text);
-    }
+    const ownerNames = resolvedOwner ? projectReceiverOwnerNames(analysis, resolvedOwner.symbol) : [dotOwner.text];
     const qualified = visibleCandidates.filter(
-      (symbol) => symbol.ownerName !== void 0 && ownerNames.has(symbol.ownerName)
+      (symbol) => symbol.ownerName !== void 0 && ownerNames.includes(symbol.ownerName) && (resolvedOwner === null || projectQualifiedSymbolMatchesReceiver(symbol, resolvedOwner.symbol))
     );
-    if (qualified.length === 1) return { token, symbol: qualified[0] };
+    for (const ownerName of ownerNames) {
+      const nearest = qualified.filter(
+        (symbol) => symbol.ownerName === ownerName
+      );
+      if (nearest.length === 1) return { token, symbol: nearest[0] };
+      if (nearest.length > 1) return null;
+    }
+    return null;
   }
-  const projectLevel = visibleCandidates.filter((symbol) => !symbol.ownerName);
+  const values = visibleCandidates.filter(
+    (symbol) => !isProjectTypeSymbol(symbol)
+  );
+  if (values.length === 1) return { token, symbol: values[0] };
+  const projectLevel = (values.length > 0 ? values : visibleCandidates).filter(
+    (symbol) => !symbol.ownerName
+  );
   return projectLevel.length === 1 ? { token, symbol: projectLevel[0] } : null;
 }
+function isProjectTypeSymbol(symbol) {
+  return symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter";
+}
+function projectQualifiedSymbolMatchesReceiver(symbol, receiver) {
+  if (isProjectTypeSymbol(receiver)) {
+    if (receiver.kind === "enum") return symbol.kind === "enumOption";
+    return symbol.kind === "member" && symbol.static === true;
+  }
+  if (symbol.kind === "enumOption") return false;
+  return symbol.kind !== "member" || symbol.static !== true;
+}
+function projectReceiverOwnerNames(analysis, receiver) {
+  const result = [];
+  const visitedTypes = /* @__PURE__ */ new Set();
+  const appendTypeAndBases = (typeName2) => {
+    if (visitedTypes.has(typeName2)) return;
+    visitedTypes.add(typeName2);
+    if (!result.includes(typeName2)) result.push(typeName2);
+    const declaration = findTypeDeclaration(analysis, typeName2);
+    if (declaration?.kind !== "class" && declaration?.kind !== "interface") {
+      return;
+    }
+    for (const base of declaration.baseTypes) {
+      const resolved = findTypeDeclaration(analysis, base.name);
+      if (resolved?.kind === "class" || resolved?.kind === "interface") {
+        appendTypeAndBases(base.name);
+      }
+    }
+  };
+  if (receiver.kind === "global") {
+    result.push(receiver.name);
+  }
+  const typeName = projectSymbolTypeName(receiver);
+  if (typeName) appendTypeAndBases(typeName);
+  return result;
+}
+function contextualProjectEnumOptionSymbol(analysis, document, token, candidates, source) {
+  if (!isContextualDot(document.text, token.start)) return null;
+  const expectedTypeName = constructionSiteAt(analysis, document, token.range.start)?.expectedTypeName ?? (source ? parameterDefaultTypeNameAt(source, token.range.start) : null);
+  if (!expectedTypeName) return null;
+  const options = candidates.filter(
+    (symbol) => symbol.kind === "enumOption" && symbol.ownerName === expectedTypeName
+  );
+  return options.length === 1 ? options[0] : null;
+}
+function parameterDefaultTypeNameAt(document, position) {
+  const fromParameters = (parameters) => {
+    const parameter4 = parameters?.find(
+      (candidate) => candidate.defaultValue && rangeContains(candidate.defaultValue.range, position)
+    );
+    return parameter4?.type.name ?? null;
+  };
+  for (const declaration of document.declarations) {
+    if (declaration.kind !== "class" && declaration.kind !== "interface") {
+      continue;
+    }
+    if (declaration.kind === "class") {
+      const header = fromParameters(declaration.headerParameters);
+      if (header) return header;
+      for (const constructor2 of declaration.constructors) {
+        const constructorParameter = fromParameters(constructor2.parameters);
+        if (constructorParameter) return constructorParameter;
+      }
+    }
+    for (const member of declaration.members) {
+      if (member.kind !== "function") continue;
+      const functionParameter = fromParameters(member.parameters);
+      if (functionParameter) return functionParameter;
+    }
+  }
+  return null;
+}
 function constructionMemberSymbol(analysis, document, token, candidates) {
   const site = constructionSiteAt(analysis, document, token.range.start);
   let current = site?.enclosingTypeName ?? null;
@@ -28702,7 +28891,7 @@ function projectSymbolTypeName(symbol) {
 }
 function declarationContaining(document, position) {
   return document.declarations.find(
-    (declaration) => positionCompare(declaration.range.start, position) <= 0 && positionCompare(position, declaration.range.end) <= 0
+    (declaration) => positionCompare2(declaration.range.start, position) <= 0 && positionCompare2(position, declaration.range.end) <= 0
   );
 }
 function sameProjectSymbol(left, right) {
@@ -28714,14 +28903,14 @@ function sameProjectSymbol(left, right) {
 }
 function tokensBeforePosition(text, position) {
   return lex(text).tokens.filter(
-    (token) => token.kind !== "comment" && token.kind !== "eof" && positionCompare(token.range.start, position) < 0
+    (token) => token.kind !== "comment" && token.kind !== "eof" && positionCompare2(token.range.start, position) < 0
   );
 }
 function activeCallOpenIndex(tokens, position) {
   let closeDepth = 0;
   for (let index = tokens.length - 1; index >= 0; index--) {
     const token = tokens[index];
-    if (!token || positionCompare(token.range.start, position) > 0) continue;
+    if (!token || positionCompare2(token.range.start, position) > 0) continue;
     if (token.text === ")") {
       closeDepth++;
       continue;
@@ -28740,7 +28929,7 @@ function activeCallParameter(tokens, openIndex, position) {
   let parameter4 = 0;
   for (let index = openIndex + 1; index < tokens.length; index++) {
     const token = tokens[index];
-    if (!token || positionCompare(token.range.start, position) >= 0) break;
+    if (!token || positionCompare2(token.range.start, position) >= 0) break;
     if (token.text === "(" || token.text === "[" || token.text === "{") {
       depth++;
       continue;
@@ -28823,7 +29012,7 @@ function constructionSiteAt(analysis, document, position) {
   const root = initializerRootAt(analysis, document, position);
   if (!root) return null;
   const tokens = projectTokens(document).filter(
-    (token) => token.kind !== "comment" && token.kind !== "eof" && rangeContains(root.range, token.range.start) && positionCompare(token.range.start, position) < 0
+    (token) => token.kind !== "comment" && token.kind !== "eof" && rangeContains(root.range, token.range.start) && positionCompare2(token.range.start, position) < 0
   );
   const stack = [];
   const expectedType = () => {
@@ -32051,6 +32240,154 @@ var init_project_schema_manifest = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/spelling-diagnostics.ts
+function enhanceSpellingDiagnostics(document, diagnostics, completionAt) {
+  return diagnostics.map((diagnostic) => {
+    const misspelling = diagnosticMisspelling(diagnostic);
+    if (!misspelling) return diagnostic;
+    const token = diagnosticIdentifierToken(
+      document,
+      diagnostic,
+      misspelling.name
+    );
+    if (!token) return diagnostic;
+    const candidates = spellingCandidates(
+      misspelling,
+      completionAt(token.range.start)
+    );
+    if (candidates.length === 0) return diagnostic;
+    return {
+      ...diagnostic,
+      message: `${diagnostic.message} ${didYouMean(candidates)}`,
+      suggestions: candidates
+    };
+  });
+}
+function spellingQuickFixes(document, diagnostic) {
+  const misspelling = diagnosticMisspelling(diagnostic);
+  if (!misspelling || !diagnostic.suggestions) return [];
+  const token = diagnosticIdentifierToken(
+    document,
+    diagnostic,
+    misspelling.name
+  );
+  if (!token) return [];
+  return diagnostic.suggestions.filter((suggestion) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(suggestion)).map((suggestion, index) => ({
+    title: `Change '${misspelling.name}' to '${suggestion}'`,
+    kind: "quickfix",
+    diagnostics: [diagnostic],
+    edit: {
+      changes: {
+        [document.uri]: [{ range: token.range, newText: suggestion }]
+      }
+    },
+    preferred: index === 0
+  }));
+}
+function diagnosticMisspelling(diagnostic) {
+  if (/to initialize\b/.test(diagnostic.message)) return null;
+  const unknown = /Unknown (identifier|function) '([^']+)'/.exec(
+    diagnostic.message
+  );
+  if (unknown?.[2]) {
+    return {
+      name: unknown[2],
+      kind: unknown[1] === "function" ? "callable" : "value"
+    };
+  }
+  const member = /has no (?:static )?(?:callable )?member '([^']+)'/.exec(
+    diagnostic.message
+  );
+  if (!member?.[1]) return null;
+  return {
+    name: member[1],
+    kind: /callable member/.test(member[0]) ? "callable" : "member"
+  };
+}
+function diagnosticIdentifierToken(document, diagnostic, name) {
+  const candidates = projectTokens(document).filter(
+    (token) => (token.kind === "identifier" || token.kind === "type") && token.text === name
+  );
+  if (candidates.length === 0) return null;
+  const target = positionScore(diagnostic.range.start);
+  return candidates.sort(
+    (left, right) => Math.abs(positionScore(left.range.start) - target) - Math.abs(positionScore(right.range.start) - target)
+  )[0] ?? null;
+}
+function positionScore(position) {
+  return position.line * 1e6 + position.character;
+}
+function spellingCandidates(misspelling, items) {
+  const allowedKinds = misspelling.kind === "callable" ? /* @__PURE__ */ new Set(["method", "function"]) : misspelling.kind === "member" ? /* @__PURE__ */ new Set(["field", "property", "method", "function", "enumMember"]) : /* @__PURE__ */ new Set([
+    "variable",
+    "parameter",
+    "field",
+    "property",
+    "enumMember",
+    "value"
+  ]);
+  const original = misspelling.name.toLocaleLowerCase();
+  const maximumDistance = original.length <= 4 ? 1 : original.length <= 8 ? 2 : 3;
+  const ranked = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!allowedKinds.has(item.kind)) continue;
+    const candidate = item.label.replace(/^\./, "");
+    if (candidate.toLocaleLowerCase() === original) continue;
+    const distance = damerauLevenshtein(
+      original,
+      candidate.toLocaleLowerCase()
+    );
+    if (distance > maximumDistance) continue;
+    const prior = ranked.get(candidate);
+    if (prior === void 0 || distance < prior)
+      ranked.set(candidate, distance);
+  }
+  return [...ranked].sort(
+    ([left, leftDistance], [right, rightDistance]) => leftDistance - rightDistance || left.localeCompare(right)
+  ).slice(0, 3).map(([candidate]) => candidate);
+}
+function damerauLevenshtein(left, right) {
+  const rows = left.length + 1;
+  const columns = right.length + 1;
+  const distance = Array.from(
+    { length: rows },
+    () => Array(columns).fill(0)
+  );
+  for (let row = 0; row < rows; row++) distance[row][0] = row;
+  for (let column = 0; column < columns; column++) {
+    distance[0][column] = column;
+  }
+  for (let row = 1; row < rows; row++) {
+    for (let column = 1; column < columns; column++) {
+      const substitution = left[row - 1] === right[column - 1] ? 0 : 1;
+      distance[row][column] = Math.min(
+        distance[row - 1][column] + 1,
+        distance[row][column - 1] + 1,
+        distance[row - 1][column - 1] + substitution
+      );
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        distance[row][column] = Math.min(
+          distance[row][column],
+          distance[row - 2][column - 2] + 1
+        );
+      }
+    }
+  }
+  return distance[left.length][right.length];
+}
+function didYouMean(candidates) {
+  const quoted = candidates.map((candidate) => `'${candidate}'`);
+  if (quoted.length === 1) return `Did you mean ${quoted[0]}?`;
+  if (quoted.length === 2) return `Did you mean ${quoted[0]} or ${quoted[1]}?`;
+  return `Did you mean ${quoted.slice(0, -1).join(", ")}, or ${quoted.at(-1)}?`;
+}
+var init_spelling_diagnostics = __esm({
+  "../packages/neoscript-language/src/spelling-diagnostics.ts"() {
+    "use strict";
+    init_project_source_tokens();
+  }
+});
+
 // ../packages/neoscript-language/src/service.ts
 function createNeoScriptLanguageService() {
   return new LanguageService();
@@ -32145,6 +32482,7 @@ var init_service = __esm({
     init_project_source_language_features();
     init_project_source_tokens();
     init_quick_fixes();
+    init_spelling_diagnostics();
     init_syntax();
     init_test_prelude();
     LanguageService = class {
@@ -32234,14 +32572,17 @@ var init_service = __esm({
         if (isProjectDocument(state.document, state.context)) {
           const project = this.projectAnalysis();
           return {
-            diagnostics: projectDiagnostics(project, uri),
+            diagnostics: this.enhanceDiagnostics(
+              state,
+              projectDiagnostics(project, uri)
+            ),
             symbols: projectDocumentSymbols(state.document, project),
             semanticTokens: projectSemanticTokens(state.document, project)
           };
         }
         const snapshot = this.scriptSnapshot(state);
         return {
-          diagnostics: finalizeDiagnostics(uri, [
+          diagnostics: this.enhanceDiagnostics(state, [
             ...snapshot.parsed.diagnostics,
             ...semanticDiagnostics(snapshot)
           ]),
@@ -32254,7 +32595,10 @@ var init_service = __esm({
         if (signal?.aborted) return [];
         const generation = ++state.validationGeneration;
         if (isProjectDocument(state.document, state.context)) {
-          const diagnostics = projectDiagnostics(this.projectAnalysis(), uri);
+          const diagnostics = this.enhanceDiagnostics(
+            state,
+            projectDiagnostics(this.projectAnalysis(), uri)
+          );
           if (signal?.aborted) return [];
           const current2 = this.documents.get(uri);
           if (!current2 || current2.validationGeneration !== generation) return [];
@@ -32272,7 +32616,7 @@ var init_service = __esm({
         if (signal?.aborted) return [];
         const current = this.documents.get(uri);
         if (!current || current.validationGeneration !== generation) return [];
-        return finalizeDiagnostics(uri, [
+        return this.enhanceDiagnostics(state, [
           ...snapshot.parsed.diagnostics,
           ...strictDiagnostics
         ]);
@@ -32385,10 +32729,15 @@ var init_service = __esm({
           ...isProjectDocument(state.document, state.context) ? {} : { kind: options?.kind ?? state.context.kind }
         });
       }
-      codeActions(uri, diagnostics) {
+      codeActions(uri, diagnostics, range2) {
         const state = this.requireState(uri);
         const actions = [];
         const project = isProjectDocument(state.document, state.context) ? this.projectAnalysis() : null;
+        if (range2) {
+          actions.push(
+            ...project ? projectInferredTypeRefactorings(project, state.document, range2) : inferredTypeRefactorings(this.scriptSnapshot(state), range2)
+          );
+        }
         for (const diagnostic of finalizeDiagnostics(uri, diagnostics)) {
           if (project) {
             actions.push(
@@ -32398,6 +32747,7 @@ var init_service = __esm({
               ...projectConstructionQuickFixes(project, state.document, diagnostic)
             );
           }
+          actions.push(...spellingQuickFixes(state.document, diagnostic));
           const edit = quickFixFor(state.document, diagnostic);
           if (!edit) continue;
           actions.push({
@@ -32410,6 +32760,17 @@ var init_service = __esm({
         }
         return deduplicateCodeActions(actions);
       }
+      /** Adds conservative, completion-backed spelling suggestions to diagnostics. */
+      enhanceDiagnostics(state, diagnostics) {
+        return finalizeDiagnostics(
+          state.document.uri,
+          enhanceSpellingDiagnostics(
+            state.document,
+            diagnostics,
+            (position) => this.complete(state.document.uri, position).items
+          )
+        );
+      }
       projectAnalysis() {
         if (this.cachedProjectAnalysis?.generation === this.projectGeneration) {
           return this.cachedProjectAnalysis.analysis;
@@ -110651,7 +111012,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.12",
-      cliVersion: "0.31.4",
+      cliVersion: "0.31.6",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -117246,7 +117607,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.31.4");
+    console.log("0.31.6");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.31.4",
+  "version": "0.31.6",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.31.4 -->
+<!-- reviewed-through-cli: 0.31.6 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -83,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.31.4 -->
+<!-- reviewed-through-cli: 0.31.6 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale