@neocompose/cli 0.31.5 → 0.31.7

package/dist/neo.mjs

@@ -2484,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({
@@ -2502,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) {
@@ -17489,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;
@@ -17617,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;
@@ -17724,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"() {
@@ -17740,7 +17796,7 @@ var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
-    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.12";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.13";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -26473,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) {
@@ -26563,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,
@@ -26593,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 }
   });
@@ -27377,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"];
@@ -27728,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];
@@ -27740,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) {
@@ -27892,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];
@@ -28019,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(
@@ -28347,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,
@@ -28366,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") {
@@ -28412,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;
     }
@@ -28424,6 +28496,9 @@ function projectCallArguments(tokens, openIndex) {
   }
   return result;
 }
+function normalizeProjectHintName(name) {
+  return name.replaceAll("_", "").toLocaleLowerCase();
+}
 function positionKey(position) {
   return `${position.line}:${position.character}`;
 }
@@ -28608,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) {
@@ -28639,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"
     );
@@ -28652,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,
@@ -28666,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
     );
@@ -28680,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;
@@ -28734,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) {
@@ -28746,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;
@@ -28772,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;
@@ -28855,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 = () => {
@@ -30601,15 +30758,21 @@ function projectSchemaManifest(input, options = {}) {
     "ProjectSchemaManifest.interfaces"
   );
   const genericNames = /* @__PURE__ */ new Map();
+  const genericDeclarations = /* @__PURE__ */ new Map();
+  const genericOwnerClassIds = /* @__PURE__ */ new Map();
   for (const schemaClass2 of classes) {
+    const classId = string2(schemaClass2.id, "schemaClass.id");
     for (const parameter4 of records(
       schemaClass2.genericParameters ?? [],
       "schemaClass.genericParameters"
     )) {
+      const parameterId = string2(parameter4.id, "genericParameter.id");
       genericNames.set(
-        string2(parameter4.id, "genericParameter.id"),
+        parameterId,
         string2(parameter4.name, "genericParameter.name")
       );
+      genericDeclarations.set(parameterId, parameter4);
+      genericOwnerClassIds.set(parameterId, classId);
     }
   }
   const rootMemberIds2 = options.rootMemberIds ?? inferRootMemberIds(members);
@@ -30620,6 +30783,8 @@ function projectSchemaManifest(input, options = {}) {
     interfaces: interfaceById,
     enums: indexById(enums, "ProjectSchemaManifest.enums"),
     genericNames,
+    genericDeclarations,
+    genericOwnerClassIds,
     effectiveWritabilityByMemberId: effectiveMemberWritability(
       members,
       classes,
@@ -30993,7 +31158,7 @@ function schemaClass(value, environment, field) {
       return {
         id: parameterId,
         name,
-        type: { kind: "typeParameter", id: parameterId, name },
+        type: typeParameter(parameterId, environment, false),
         ...spanAndSelectionLocations(
           parameter4.source,
           parameter4.selectionSpan ?? parameter4.source,
@@ -31982,14 +32147,73 @@ function manifestPrimitive(kind) {
       return null;
   }
 }
-function typeParameter(id2, environment, nullable) {
+function typeParameter(id2, environment, nullable, visiting = /* @__PURE__ */ new Set()) {
+  const declaration = environment.genericDeclarations.get(id2);
+  const constraint = declaration?.constraint;
+  const next = new Set(visiting).add(id2);
   return {
     kind: "typeParameter",
     id: id2,
     name: environment.genericNames.get(id2) ?? id2,
+    ...environment.genericOwnerClassIds.has(id2) ? { ownerClassId: environment.genericOwnerClassIds.get(id2) } : {},
+    ...visiting.has(id2) || constraint === void 0 || constraint === null ? {} : {
+      constraint: genericConstraintType(
+        constraint,
+        environment,
+        next,
+        `generic parameter ${id2}.constraint`
+      )
+    },
     nullable
   };
 }
+function genericConstraintType(value, environment, visiting, field) {
+  const constraint = record2(value, field);
+  if (constraint.kind === "enum") {
+    return {
+      kind: "named",
+      typeId: string2(constraint.enumId, `${field}.enumId`),
+      nullable: false
+    };
+  }
+  if (constraint.kind !== "class") {
+    throw new Error(`${field}.kind must be "class" or "enum".`);
+  }
+  const classId = string2(constraint.classId, `${field}.classId`);
+  const target = environment.classes.get(classId);
+  const parameters = target ? records(target.genericParameters ?? [], `${field}.genericParameters`) : [];
+  const bindings = optionalRecord(constraint.classArguments) ?? {};
+  const typeArguments = parameters.flatMap((parameter4) => {
+    const parameterId = string2(parameter4.id, `${field}.genericParameter.id`);
+    const binding = optionalRecord(bindings[parameterId]);
+    if (binding?.kind === "generic" && typeof binding.genericParamId === "string") {
+      return [
+        typeParameter(binding.genericParamId, environment, false, visiting)
+      ];
+    }
+    if (binding?.kind === "member" && typeof binding.memberId === "string") {
+      const member = environment.members.get(binding.memberId);
+      return member ? [
+        {
+          ...memberType(
+            member,
+            environment,
+            /* @__PURE__ */ new Set(),
+            `${field}.classArguments.${parameterId}`
+          ),
+          nullable: false
+        }
+      ] : [];
+    }
+    return [];
+  });
+  return {
+    kind: "named",
+    typeId: classId,
+    nullable: false,
+    ...typeArguments.length === parameters.length && typeArguments.length > 0 ? { typeArguments } : {}
+  };
+}
 function primitive(name, nullable) {
   return { kind: "primitive", name, nullable };
 }
@@ -32083,6 +32307,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();
@@ -32177,6 +32549,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 {
@@ -32266,14 +32639,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)
           ]),
@@ -32286,7 +32662,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 [];
@@ -32304,7 +32683,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
         ]);
@@ -32417,10 +32796,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(
@@ -32430,6 +32814,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({
@@ -32442,6 +32827,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;
@@ -34344,6 +34740,16 @@ function inferMemberOwners(classes, members) {
       schemaClass2.recordId,
       set
     );
+    if (Array.isArray(schemaClass2.data.genericParams)) {
+      for (const parameterValue of schemaClass2.data.genericParams) {
+        if (!isRecord2(parameterValue)) continue;
+        const parameterId = parameterValue.id;
+        const constraint = parameterValue.constraint;
+        if (typeof parameterId !== "string" || !isRecord2(constraint)) continue;
+        if (constraint.kind !== "class") continue;
+        collectGenericOwners(constraint.classArguments, parameterId, set);
+      }
+    }
   }
   for (const [memberId, member] of members) {
     if (typeof member.entryMemberId === "string") {
@@ -37744,8 +38150,19 @@ function assertGenericParameter(value, path) {
   if (parameter4.constraint === null) return;
   const constraint = requireRecord(parameter4.constraint, `${path}.constraint`);
   if (constraint.kind === "class") {
-    knownKeys(constraint, `${path}.constraint`, ["kind", "classId"]);
+    knownKeysWithOptional(
+      constraint,
+      `${path}.constraint`,
+      ["kind", "classId"],
+      ["classArguments"]
+    );
     nonEmptyString(constraint.classId, `${path}.constraint.classId`);
+    if (constraint.classArguments !== void 0 && constraint.classArguments !== null) {
+      assertGenericBindingRecord(
+        constraint.classArguments,
+        `${path}.constraint.classArguments`
+      );
+    }
     return;
   }
   if (constraint.kind === "enum") {
@@ -41483,7 +41900,9 @@ function isGenericParamConstraint(value) {
   if (v.kind === "class") {
     if (typeof v.classId !== "string") return false;
     if (v.classId.length === 0) return false;
-    return v.enumId === void 0;
+    if (v.enumId !== void 0) return false;
+    const argumentsValue = v.classArguments;
+    return argumentsValue === void 0 || argumentsValue === null || isGenericBindingsRecord(argumentsValue);
   }
   if (v.kind === "enum") {
     if (typeof v.enumId !== "string") return false;
@@ -49253,11 +49672,7 @@ function emitClass(context, schemaClass2, memberIds) {
   const modifier = schemaClass2.isSealed ? "sealed " : schemaClass2.declarationModifier === "abstract" ? "abstract " : "";
   const generics = schemaClass2.genericParameters.length ? `<
 ${schemaClass2.genericParameters.map((parameter4) => {
-    const constraint = parameter4.constraint ? ` extends ${parameter4.constraint.kind === "class" ? required(
-      context.classes,
-      parameter4.constraint.classId,
-      "class"
-    ).name : required(context.enums, parameter4.constraint.enumId, "enum").name}` : "";
+    const constraint = parameter4.constraint ? ` extends ${renderGenericConstraint(context, parameter4.constraint)}` : "";
     return `  ${id(parameter4.id)}  ${parameter4.name}${constraint}`;
   }).join(",\n")}
 >` : "";
@@ -49331,6 +49746,31 @@ ${members.join("\n\n")}
 }
 `;
 }
+function renderGenericConstraint(context, constraint) {
+  if (constraint.kind === "enum") {
+    return required(context.enums, constraint.enumId, "enum").name;
+  }
+  const target = required(context.classes, constraint.classId, "class");
+  if (target.genericParameters.length === 0) return target.name;
+  const bindings = constraint.classArguments;
+  if (bindings === void 0 || bindings === null) return target.name;
+  const argumentsValue = target.genericParameters.map((parameter4) => {
+    const binding = bindings[parameter4.id];
+    if (binding === void 0) {
+      throw new Error(
+        `Generic constraint ${target.name} is missing its argument for ${parameter4.name}.`
+      );
+    }
+    if (binding.kind === "generic") {
+      return genericName(context, binding.genericParamId);
+    }
+    return renderMemberType(
+      context,
+      required(context.members, binding.memberId, "generic constraint binding")
+    ).replace(/\?$/u, "");
+  });
+  return `${target.name}<${argumentsValue.join(", ")}>`;
+}
 function baseConstruction(requiredConstructor) {
   if (requiredConstructor === void 0) return "";
   const args = requiredConstructor.baseArguments ?? [];
@@ -55810,7 +56250,15 @@ function lowerClass(context, declaration) {
     return {
       id: parameterId,
       name: parameter4.name,
-      constraint: parameter4.constraint ? genericConstraint(context, parameter4.constraint) : null,
+      constraint: parameter4.constraint ? genericConstraint(
+        context,
+        declaration,
+        parameterId,
+        parameter4.constraint,
+        base?.genericParameters.find(
+          (candidate) => candidate.id === parameterId
+        )?.constraint
+      ) : null,
       source: span(parameter4.identity),
       selectionSpan: span(parameter4.identity)
     };
@@ -57761,9 +58209,22 @@ function lowerGenericArgument(context, ownerClass, type, memberId, genericParamI
     )
   );
 }
-function genericConstraint(context, type) {
+function genericConstraint(context, ownerClass, parameterId, type, baseConstraint) {
   const classId = context.classIdsByName.get(type.name);
-  if (classId) return { kind: "class", classId };
+  if (classId) {
+    const classArguments2 = type.arguments.length === 0 ? void 0 : lowerClassArguments(
+      context,
+      ownerClass,
+      parameterId,
+      type,
+      baseConstraint?.kind === "class" ? baseConstraint.classArguments ?? void 0 : void 0
+    );
+    return {
+      kind: "class",
+      classId,
+      ...classArguments2 === void 0 ? {} : { classArguments: classArguments2 }
+    };
+  }
   return {
     kind: "enum",
     enumId: requiredName2(context.enumIdsByName, type.name, "enum")
@@ -58669,18 +59130,12 @@ function classToLanguageType(schemaClass2, context) {
       typeParameters: schemaClass2.genericParams.map((parameter4) => ({
         id: parameter4.id,
         name: parameter4.name,
-        type: {
-          kind: "typeParameter",
-          id: parameter4.id,
-          name: parameter4.name,
-          ownerClassId: schemaClass2.id,
-          ...parameter4.constraint === void 0 || parameter4.constraint === null ? {} : {
-            constraint: namedType(
-              parameter4.constraint.kind === "class" ? parameter4.constraint.classId : parameter4.constraint.enumId,
-              true
-            )
-          }
-        },
+        type: genericParameterLanguageType(
+          parameter4.id,
+          true,
+          context,
+          genericEnvironment
+        ),
         location: virtualIdentifierLocation(
           context,
           "Classes",
@@ -59330,31 +59785,12 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
           );
         }
       }
-      for (const owner of context.vm.classes) {
-        const parameter4 = owner.genericParams?.find(
-          (candidate) => candidate.id === genericParamId
-        );
-        if (parameter4) {
-          if (parameter4.constraint?.kind === "class") {
-            return namedType(parameter4.constraint.classId, required2);
-          }
-          if (parameter4.constraint?.kind === "enum") {
-            return namedType(parameter4.constraint.enumId, required2);
-          }
-          return {
-            kind: "typeParameter",
-            id: genericParamId,
-            name: parameter4.name,
-            nullable: !required2
-          };
-        }
-      }
-      return {
-        kind: "typeParameter",
-        id: genericParamId,
-        name: genericParamId,
-        nullable: !required2
-      };
+      return genericParameterLanguageType(
+        genericParamId,
+        required2,
+        context,
+        genericEnvironment
+      );
     }
     case 27 /* Variant */: {
       if (!isMemberVariantBase(member)) return UNKNOWN_TYPE2;
@@ -59417,13 +59853,13 @@ function classArguments(member, context, seen, genericEnvironment) {
           )
         ] : [];
       }
-      const declaration = context.vm.classes.flatMap((schemaClass2) => schemaClass2.genericParams ?? []).find((candidate) => candidate.id === binding.genericParamId);
       return [
-        {
-          kind: "typeParameter",
-          id: binding.genericParamId,
-          name: declaration?.name ?? binding.genericParamId
-        }
+        genericParameterLanguageType(
+          binding.genericParamId,
+          true,
+          context,
+          genericEnvironment
+        )
       ];
     }
     const argument2 = analyzerMemberById(context.vm, binding.memberId);
@@ -59571,33 +60007,89 @@ function toLanguageType(type, context, genericEnvironment) {
           );
         }
       }
-      const effectiveParamId = environmentEntry?.kind === "unbound" ? environmentEntry.paramId : type.genericParamId;
-      const owner = context.vm.classes.find(
-        (item) => item.id === type.ownerClassId || item.genericParams?.some(
-          (parameter4) => parameter4.id === effectiveParamId
-        )
+      return genericParameterLanguageType(
+        environmentEntry?.kind === "unbound" ? environmentEntry.paramId : type.genericParamId,
+        required2,
+        context,
+        genericEnvironment
       );
-      const name = owner?.genericParams?.find(
-        (parameter4) => parameter4.id === effectiveParamId
-      )?.name ?? effectiveParamId;
-      const declaration = owner?.genericParams?.find(
-        (parameter4) => parameter4.id === effectiveParamId
+    }
+  }
+}
+function genericParameterLanguageType(genericParamId, required2, context, genericEnvironment, visiting = /* @__PURE__ */ new Set()) {
+  const environmentEntry = genericEnvironment?.get(genericParamId);
+  if (environmentEntry?.kind === "member") {
+    const binding = analyzerMemberById(context.vm, environmentEntry.memberId);
+    if (binding) {
+      return requiredType(
+        memberRuntimeType(binding, context, /* @__PURE__ */ new Set(), genericEnvironment)
       );
-      return {
-        kind: "typeParameter",
-        id: effectiveParamId,
-        name,
-        ...owner === void 0 ? {} : { ownerClassId: owner.id },
-        ...declaration?.constraint === void 0 || declaration.constraint === null ? {} : {
-          constraint: namedType(
-            declaration.constraint.kind === "class" ? declaration.constraint.classId : declaration.constraint.enumId,
-            true
-          )
-        },
-        nullable: !required2
-      };
     }
   }
+  const effectiveParamId = environmentEntry?.kind === "unbound" ? environmentEntry.paramId : genericParamId;
+  const owner = context.vm.classes.find(
+    (schemaClass2) => schemaClass2.genericParams?.some(
+      (parameter4) => parameter4.id === effectiveParamId
+    )
+  );
+  const declaration = owner?.genericParams?.find(
+    (parameter4) => parameter4.id === effectiveParamId
+  );
+  const next = new Set(visiting).add(effectiveParamId);
+  return {
+    kind: "typeParameter",
+    id: effectiveParamId,
+    name: declaration?.name ?? effectiveParamId,
+    ...owner === void 0 ? {} : { ownerClassId: owner.id },
+    ...visiting.has(effectiveParamId) || declaration?.constraint == null ? {} : {
+      constraint: genericConstraintLanguageType(
+        declaration.constraint,
+        context,
+        genericEnvironment,
+        next
+      )
+    },
+    nullable: !required2
+  };
+}
+function genericConstraintLanguageType(constraint, context, genericEnvironment, visiting = /* @__PURE__ */ new Set()) {
+  if (constraint.kind === "enum") {
+    return namedType(constraint.enumId, true);
+  }
+  const target = context.vm.classes.find(
+    (schemaClass2) => schemaClass2.id === constraint.classId
+  );
+  const bindings = constraint.classArguments;
+  if (!target?.genericParams?.length || bindings == null) {
+    return namedType(constraint.classId, true);
+  }
+  const typeArguments = target.genericParams.flatMap((parameter4) => {
+    const binding = bindings[parameter4.id];
+    if (binding === void 0) return [];
+    if (binding.kind === "generic") {
+      return [
+        genericParameterLanguageType(
+          binding.genericParamId,
+          true,
+          context,
+          genericEnvironment,
+          visiting
+        )
+      ];
+    }
+    const member = analyzerMemberById(context.vm, binding.memberId);
+    return member ? [
+      requiredType(
+        memberRuntimeType(member, context, /* @__PURE__ */ new Set(), genericEnvironment)
+      )
+    ] : [];
+  });
+  return {
+    kind: "named",
+    typeId: constraint.classId,
+    nullable: false,
+    ...typeArguments.length === target.genericParams.length ? { typeArguments } : {}
+  };
 }
 function functionReturnType(type, context, genericEnvironment) {
   return type.type === NS_TYPE_VOID ? primitive2("void", true) : toLanguageType(type, context, genericEnvironment);
@@ -59765,12 +60257,68 @@ function virtualNeoSchemaClassHeader(schemaClass2, context) {
     )?.name ?? constraint.classId : context.vm.enums.find(
       (candidate) => candidate.id === constraint.enumId
     )?.name ?? constraint.enumId;
+    const targetClass = constraint.kind === "class" ? context.vm.classes.find(
+      (candidate) => candidate.id === constraint.classId
+    ) : void 0;
+    const bindings = constraint.kind === "class" ? constraint.classArguments : void 0;
+    const argumentsValue = targetClass?.genericParams?.flatMap(
+      (targetParameter) => {
+        const binding = bindings?.[targetParameter.id];
+        if (binding?.kind === "generic") {
+          const declaration = context.vm.classes.flatMap((candidate) => candidate.genericParams ?? []).find((candidate) => candidate.id === binding.genericParamId);
+          return [
+            virtualCSharpIdentifier(
+              declaration?.name ?? binding.genericParamId
+            )
+          ];
+        }
+        if (binding?.kind === "member") {
+          const member = analyzerMemberById(context.vm, binding.memberId);
+          return [
+            member ? virtualConstraintMemberType(member, context) : "object"
+          ];
+        }
+        return [];
+      }
+    );
+    const argumentSuffix = targetClass?.genericParams?.length && argumentsValue?.length === targetClass.genericParams.length ? `<${argumentsValue.join(", ")}>` : "";
     return [
-      ` where ${virtualCSharpIdentifier(parameter4.name)} : ${virtualCSharpIdentifier(target)}`
+      ` where ${virtualCSharpIdentifier(parameter4.name)} : ${virtualCSharpIdentifier(target)}${argumentSuffix}`
     ];
   });
   return `public ${schemaClass2.isAbstract ? "abstract " : ""}partial class ${virtualCSharpIdentifier(schemaClass2.name)}${genericParameters}${inheritance}${constraints.join("")} // Neo class ${schemaClass2.id}`;
 }
+function virtualConstraintMemberType(member, context) {
+  const resolved = resolveMember2(member, context.vm.members);
+  switch (resolved.kind) {
+    case 1 /* Bool */:
+      return "bool";
+    case 2 /* Int */:
+      return "int";
+    case 3 /* String */:
+      return "string";
+    case 4 /* Float */:
+      return "double";
+    case 20 /* Decimal */:
+      return "decimal";
+    case 7 /* Class */: {
+      const classId = getOptionalString(resolved, "classId");
+      const schemaClass2 = context.vm.classes.find(
+        (candidate) => candidate.id === classId
+      );
+      return virtualCSharpIdentifier(schemaClass2?.name ?? classId ?? "object");
+    }
+    case 8 /* Enum */: {
+      const enumId = getOptionalString(resolved, "enumId");
+      const neoEnum = context.vm.enums.find(
+        (candidate) => candidate.id === enumId
+      );
+      return virtualCSharpIdentifier(neoEnum?.name ?? enumId ?? "object");
+    }
+    default:
+      return "object";
+  }
+}
 function virtualNeoSchemaClassMemberLine(schemaKey, displayName, memberId) {
   return `    public object? ${virtualCSharpIdentifier(schemaKey)} { get; init; } // ${displayName}; Neo member ${memberId}`;
 }
@@ -59806,7 +60354,7 @@ var init_neoscript_language_context_adapter = __esm({
     init_project_root_members();
     init_project_file_registry();
     init_analyzer_types();
-    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 1;
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 2;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -81908,10 +82456,13 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       `Class "${schemaClass2.name}" (${schemaClass2.id}) cannot extend sealed class "${baseClass.name}" (${baseClass.id}).`
     );
   }
-  const genericParamConstraintsById = new Map(
+  const genericParamDeclarationsById = new Map(
     classes.flatMap(
       (schemaClass2) => (schemaClass2.genericParams ?? []).map(
-        (param) => [param.id, param.constraint]
+        (param) => [
+          param.id,
+          { constraint: param.constraint, ownerClassId: schemaClass2.id }
+        ]
       )
     )
   );
@@ -82826,13 +83377,40 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     if (!isRecord7(typeInfo) || typeInfo.type !== 21 || typeof typeInfo.genericParamId !== "string") {
       return null;
     }
-    const constraint = genericParamConstraintsById.get(typeInfo.genericParamId);
+    const constraint = genericParamDeclarationsById.get(
+      typeInfo.genericParamId
+    )?.constraint;
     if (!constraint) return null;
-    return constraint.kind === "class" ? {
-      type: 7,
-      required: typeInfo.required === true,
-      classId: constraint.classId
-    } : {
+    if (constraint.kind === "class") {
+      const typeArguments = Object.fromEntries(
+        Object.entries(constraint.classArguments ?? {}).flatMap(
+          ([parameterId, binding]) => {
+            if (binding.kind !== "generic") return [];
+            const ownerClassId = genericParamDeclarationsById.get(
+              binding.genericParamId
+            )?.ownerClassId;
+            return ownerClassId === void 0 ? [] : [
+              [
+                parameterId,
+                {
+                  type: 21,
+                  required: true,
+                  ownerClassId,
+                  genericParamId: binding.genericParamId
+                }
+              ]
+            ];
+          }
+        )
+      );
+      return {
+        type: 7,
+        required: typeInfo.required === true,
+        classId: constraint.classId,
+        ...Object.keys(typeArguments).length > 0 ? { typeArguments } : {}
+      };
+    }
+    return {
       type: 8,
       required: typeInfo.required === true,
       enumId: constraint.enumId
@@ -110682,8 +111260,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.12",
-      cliVersion: "0.31.5",
+      contractVersion: "3.13",
+      cliVersion: "0.31.7",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -117278,7 +117856,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.5");
+    console.log("0.31.7");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {