@neocompose/cli 0.5.3 → 0.5.4

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.5.4] - 2026-07-19
+
+### Fixed
+
+- Stop reporting phantom member updates when a stored type info spells an
+  empty generic-binding map as `typeArguments: {}` or `null` instead of an
+  absent key. Convex round trips produce these spellings interchangeably;
+  nested type-info binding maps now normalize to absent at every depth
+  before semantic comparison.
+
 ## [0.5.3] - 2026-07-19
 
 ### Fixed

package/dist/neo.mjs

@@ -1185,9 +1185,29 @@ function normalizeDocumentFields(recordKind, value) {
     }
     if (current === void 0) normalized[field] = null;
   }
+  if (recordKind === "member") {
+    normalizeTypeInfoBindings(normalized.returnTypeInfo);
+    if (Array.isArray(normalized.argumentTypes)) {
+      for (const argument2 of normalized.argumentTypes) {
+        normalizeTypeInfoBindings(argument2);
+      }
+    }
+  }
   omitRedundantDeclarationOrder(recordKind, normalized);
   return normalized;
 }
+function normalizeTypeInfoBindings(value) {
+  if (!isRecord(value)) return;
+  const bindings = value.typeArguments;
+  if (bindings === null || isRecord(bindings) && Object.keys(bindings).length === 0) {
+    delete value.typeArguments;
+  } else if (isRecord(bindings)) {
+    for (const binding of Object.values(bindings)) {
+      normalizeTypeInfoBindings(binding);
+    }
+  }
+  normalizeTypeInfoBindings(value.entryTypeInfo);
+}
 function memberDefaultApplies(field, type) {
   if (field === "isVirtual" || field === "isAbstract" || field === "locked" || field === "required") {
     return true;
@@ -12341,6 +12361,151 @@ var init_project_source_ast = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/project-source-tokens.ts
+function rangeContains(range2, position) {
+  return positionCompare(range2.start, position) <= 0 && positionCompare(position, range2.end) <= 0;
+}
+function rangeSize(range2) {
+  return (range2.end.line - range2.start.line) * 1e6 + range2.end.character - range2.start.character;
+}
+function documentPrefix(text, position) {
+  const lines = text.split("\n");
+  return [
+    ...lines.slice(0, position.line),
+    (lines[position.line] ?? "").slice(0, position.character)
+  ].join("\n");
+}
+function projectTokenAt(document, position) {
+  const offset = new SourceText(document.text).offsetAt(position);
+  const tokens = projectTokens(document);
+  const containing = tokens.find(
+    (token) => token.start <= offset && offset < token.end
+  );
+  if (containing?.kind === "identifier") return containing;
+  const touching = tokens.find(
+    (token) => token.kind === "identifier" && token.end === offset
+  );
+  return touching ?? containing;
+}
+function projectTokens(document) {
+  const cached = PROJECT_TOKEN_CACHE.get(document);
+  if (cached) return cached;
+  const source = new SourceText(document.text);
+  const tokens = lex(document.text).tokens.flatMap(
+    (token) => {
+      if (token.kind !== "string" || !token.raw.startsWith('"""')) {
+        return [token];
+      }
+      const result = [];
+      const contentEnd = token.raw.endsWith('"""') ? token.end - 3 : token.end;
+      let segmentStart = token.start;
+      let cursor = token.start + 3;
+      while (cursor < contentEnd) {
+        if (document.text[cursor] !== "{" || document.text[cursor + 1] === "{") {
+          cursor++;
+          continue;
+        }
+        const close = tripleInterpolationEnd(
+          document.text,
+          cursor + 1,
+          contentEnd
+        );
+        if (close === null) break;
+        if (segmentStart < cursor + 1) {
+          result.push(
+            projectToken(
+              "string",
+              document.text,
+              source,
+              segmentStart,
+              cursor + 1
+            )
+          );
+        }
+        const expressionStart = cursor + 1;
+        const expression = document.text.slice(expressionStart, close);
+        for (const nested of lex(expression).tokens) {
+          if (nested.kind === "eof") continue;
+          const start = expressionStart + nested.start;
+          const end = expressionStart + nested.end;
+          result.push({
+            ...nested,
+            start,
+            end,
+            raw: document.text.slice(start, end),
+            range: source.range(start, end)
+          });
+        }
+        segmentStart = close;
+        cursor = close + 1;
+      }
+      if (segmentStart < token.end) {
+        result.push(
+          projectToken(
+            "string",
+            document.text,
+            source,
+            segmentStart,
+            token.end
+          )
+        );
+      }
+      return result;
+    }
+  );
+  PROJECT_TOKEN_CACHE.set(document, tokens);
+  return tokens;
+}
+function projectToken(kind, text, source, start, end) {
+  const raw = text.slice(start, end);
+  return { kind, text: raw, raw, start, end, range: source.range(start, end) };
+}
+function tripleInterpolationEnd(text, start, limit) {
+  let depth = 0;
+  let cursor = start;
+  while (cursor < limit) {
+    const char = text[cursor];
+    const next = text[cursor + 1];
+    if (char === '"') {
+      cursor++;
+      while (cursor < limit) {
+        if (text[cursor] === "\\") cursor += 2;
+        else if (text[cursor] === '"') {
+          cursor++;
+          break;
+        } else cursor++;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      while (cursor < limit && text[cursor] !== "\n") cursor++;
+      continue;
+    }
+    if (char === "{") depth++;
+    else if (char === "}") {
+      if (depth === 0) return cursor;
+      depth--;
+    }
+    cursor++;
+  }
+  return null;
+}
+function rangesEqual(left, right) {
+  return positionCompare(left.start, right.start) === 0 && positionCompare(left.end, right.end) === 0;
+}
+function positionCompare(left, right) {
+  return left.line === right.line ? left.character - right.character : left.line - right.line;
+}
+var PROJECT_TOKEN_CACHE;
+var init_project_source_tokens = __esm({
+  "../packages/neoscript-language/src/project-source-tokens.ts"() {
+    "use strict";
+    init_lexer();
+    init_source_text();
+    PROJECT_TOKEN_CACHE = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../packages/neoscript-language/src/project-source-parser.ts
 function parseNeoProjectSource(sourceValue, kind) {
   const lexed = lex(sourceValue);
@@ -18792,7 +18957,13 @@ function analyzeNeoProjectSources(inputs) {
   const symbols = [];
   for (const [uri, document] of documents) {
     for (const declaration of document.declarations) {
-      collectDeclarationSymbols(uri, declaration, symbols, diagnostics);
+      collectDeclarationSymbols(
+        uri,
+        document,
+        declaration,
+        symbols,
+        diagnostics
+      );
     }
   }
   validateSymbolUniqueness(symbols, diagnostics);
@@ -18802,7 +18973,7 @@ function analyzeNeoProjectSources(inputs) {
   diagnostics.push(...compileProjectSourceBodies(documents).diagnostics);
   return { documents, symbols, diagnostics };
 }
-function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
+function collectDeclarationSymbols(uri, document, declaration, symbols, diagnostics) {
   const declarationKind = declaration.kind;
   collectSymbol(
     uri,
@@ -18812,7 +18983,9 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     declaration.annotations,
     void 0,
     symbols,
-    diagnostics
+    diagnostics,
+    void 0,
+    declaration.kind === "global" ? declaration.type.name : void 0
   );
   if (declaration.kind === "enum") {
     for (const option of declaration.options) {
@@ -18829,7 +19002,10 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     }
     return;
   }
-  if (declaration.kind === "global") return;
+  if (declaration.kind === "global") {
+    collectGlobalChildSymbols(uri, document, declaration, symbols, diagnostics);
+    return;
+  }
   if (declaration.kind === "class") {
     for (const parameter3 of declaration.genericParameters) {
       collectSymbol(
@@ -18886,6 +19062,104 @@ function collectDeclarationSymbols(uri, declaration, symbols, diagnostics) {
     }
   }
 }
+function collectGlobalChildSymbols(uri, document, declaration, symbols, diagnostics) {
+  if (declaration.type.name === "Root") return;
+  const initializer = declaration.initializer;
+  const tokens = lex(document.sourceText).tokens.filter(
+    (token) => token.kind !== "comment" && token.kind !== "eof" && rangeWithin(initializer.range, token.range)
+  );
+  let braceDepth = 0;
+  let groupDepth = 0;
+  let pendingAnnotations = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.text === "{") {
+      braceDepth++;
+      continue;
+    }
+    if (token.text === "}") {
+      braceDepth--;
+      continue;
+    }
+    if (braceDepth !== 1) continue;
+    if (token.text === "(" || token.text === "[") {
+      groupDepth++;
+      continue;
+    }
+    if (token.text === ")" || token.text === "]") {
+      groupDepth--;
+      continue;
+    }
+    if (groupDepth !== 0) continue;
+    if (token.text === ";") {
+      pendingAnnotations = [];
+      continue;
+    }
+    if (token.text === "@") {
+      const annotation2 = scanAnnotation(tokens, index);
+      if (annotation2) {
+        pendingAnnotations.push(annotation2.annotation);
+        index = annotation2.endIndex;
+      }
+      continue;
+    }
+    const name = tokens[index + 1];
+    if ((token.kind === "type" || token.kind === "identifier") && name?.kind === "identifier" && tokens[index + 2]?.text === "=" && tokens[index + 3]?.text !== "=" && // A pending annotation or statement boundary precedes a declaration;
+    // `key: value` fields and expression member accesses never do.
+    tokens[index - 1]?.text !== "." && tokens[index - 1]?.text !== ":") {
+      collectSymbol(
+        uri,
+        "graphChild",
+        name.text,
+        name.range,
+        pendingAnnotations,
+        declaration.name,
+        symbols,
+        diagnostics,
+        void 0,
+        token.text
+      );
+      pendingAnnotations = [];
+      index += 2;
+    }
+  }
+}
+function scanAnnotation(tokens, atIndex) {
+  const marker = tokens[atIndex];
+  const name = tokens[atIndex + 1];
+  if (!name || name.kind !== "identifier" && name.kind !== "keyword") {
+    return null;
+  }
+  const argumentsList2 = [];
+  let endIndex = atIndex + 1;
+  let endRange = name.range;
+  if (tokens[atIndex + 2]?.text === "(") {
+    let depth = 0;
+    for (let index = atIndex + 2; index < tokens.length; index++) {
+      const token = tokens[index];
+      if (token.text === "(") depth++;
+      else if (token.text === ")" && --depth === 0) {
+        endIndex = index;
+        endRange = token.range;
+        break;
+      } else if (depth === 1 && token.kind === "string") {
+        argumentsList2.push({ text: token.raw, range: token.range });
+      }
+    }
+  }
+  return {
+    annotation: {
+      name: name.text,
+      nameRange: name.range,
+      arguments: argumentsList2,
+      range: { start: marker.range.start, end: endRange.end }
+    },
+    endIndex
+  };
+}
+function rangeWithin(outer, inner) {
+  return positionCompare(outer.start, inner.start) <= 0 && positionCompare(inner.end, outer.end) <= 0;
+}
 function collectFlowSymbols(uri, content, ownerName, scopeRange, symbols, diagnostics) {
   for (const binding of content.bindings) {
     collectSymbol(
@@ -19177,6 +19451,8 @@ var init_project_source_analysis = __esm({
   "../packages/neoscript-language/src/project-source-analysis.ts"() {
     "use strict";
     init_language_spec();
+    init_lexer();
+    init_project_source_tokens();
     init_project_source_parser();
     init_project_source_semantics();
     init_project_source_script_compiler();
@@ -21242,151 +21518,6 @@ var init_project_schema_manifest = __esm({
   }
 });
 
-// ../packages/neoscript-language/src/project-source-tokens.ts
-function rangeContains(range2, position) {
-  return positionCompare(range2.start, position) <= 0 && positionCompare(position, range2.end) <= 0;
-}
-function rangeSize(range2) {
-  return (range2.end.line - range2.start.line) * 1e6 + range2.end.character - range2.start.character;
-}
-function documentPrefix(text, position) {
-  const lines = text.split("\n");
-  return [
-    ...lines.slice(0, position.line),
-    (lines[position.line] ?? "").slice(0, position.character)
-  ].join("\n");
-}
-function projectTokenAt(document, position) {
-  const offset = new SourceText(document.text).offsetAt(position);
-  const tokens = projectTokens(document);
-  const containing = tokens.find(
-    (token) => token.start <= offset && offset < token.end
-  );
-  if (containing?.kind === "identifier") return containing;
-  const touching = tokens.find(
-    (token) => token.kind === "identifier" && token.end === offset
-  );
-  return touching ?? containing;
-}
-function projectTokens(document) {
-  const cached = PROJECT_TOKEN_CACHE.get(document);
-  if (cached) return cached;
-  const source = new SourceText(document.text);
-  const tokens = lex(document.text).tokens.flatMap(
-    (token) => {
-      if (token.kind !== "string" || !token.raw.startsWith('"""')) {
-        return [token];
-      }
-      const result = [];
-      const contentEnd = token.raw.endsWith('"""') ? token.end - 3 : token.end;
-      let segmentStart = token.start;
-      let cursor = token.start + 3;
-      while (cursor < contentEnd) {
-        if (document.text[cursor] !== "{" || document.text[cursor + 1] === "{") {
-          cursor++;
-          continue;
-        }
-        const close = tripleInterpolationEnd(
-          document.text,
-          cursor + 1,
-          contentEnd
-        );
-        if (close === null) break;
-        if (segmentStart < cursor + 1) {
-          result.push(
-            projectToken(
-              "string",
-              document.text,
-              source,
-              segmentStart,
-              cursor + 1
-            )
-          );
-        }
-        const expressionStart = cursor + 1;
-        const expression = document.text.slice(expressionStart, close);
-        for (const nested of lex(expression).tokens) {
-          if (nested.kind === "eof") continue;
-          const start = expressionStart + nested.start;
-          const end = expressionStart + nested.end;
-          result.push({
-            ...nested,
-            start,
-            end,
-            raw: document.text.slice(start, end),
-            range: source.range(start, end)
-          });
-        }
-        segmentStart = close;
-        cursor = close + 1;
-      }
-      if (segmentStart < token.end) {
-        result.push(
-          projectToken(
-            "string",
-            document.text,
-            source,
-            segmentStart,
-            token.end
-          )
-        );
-      }
-      return result;
-    }
-  );
-  PROJECT_TOKEN_CACHE.set(document, tokens);
-  return tokens;
-}
-function projectToken(kind, text, source, start, end) {
-  const raw = text.slice(start, end);
-  return { kind, text: raw, raw, start, end, range: source.range(start, end) };
-}
-function tripleInterpolationEnd(text, start, limit) {
-  let depth = 0;
-  let cursor = start;
-  while (cursor < limit) {
-    const char = text[cursor];
-    const next = text[cursor + 1];
-    if (char === '"') {
-      cursor++;
-      while (cursor < limit) {
-        if (text[cursor] === "\\") cursor += 2;
-        else if (text[cursor] === '"') {
-          cursor++;
-          break;
-        } else cursor++;
-      }
-      continue;
-    }
-    if (char === "/" && next === "/") {
-      while (cursor < limit && text[cursor] !== "\n") cursor++;
-      continue;
-    }
-    if (char === "{") depth++;
-    else if (char === "}") {
-      if (depth === 0) return cursor;
-      depth--;
-    }
-    cursor++;
-  }
-  return null;
-}
-function rangesEqual(left, right) {
-  return positionCompare(left.start, right.start) === 0 && positionCompare(left.end, right.end) === 0;
-}
-function positionCompare(left, right) {
-  return left.line === right.line ? left.character - right.character : left.line - right.line;
-}
-var PROJECT_TOKEN_CACHE;
-var init_project_source_tokens = __esm({
-  "../packages/neoscript-language/src/project-source-tokens.ts"() {
-    "use strict";
-    init_lexer();
-    init_source_text();
-    PROJECT_TOKEN_CACHE = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // ../packages/neoscript-language/src/quick-fixes.ts
 function quickFixFor(document, diagnostic) {
   if (diagnostic.code === "missing-semicolon") {
@@ -21703,11 +21834,17 @@ 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) return null;
-  return analysis.symbols.filter(
-    (symbol) => symbol.kind === "member" && symbol.ownerName === typeName
+  if (typeName) ownerNames.add(typeName);
+  if (resolvedOwner.symbol.kind === "global") {
+    ownerNames.add(resolvedOwner.symbol.name);
+  }
+  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) {
   const tokens = lex(document.text).tokens.filter(
@@ -21799,6 +21936,15 @@ function graphConstructorNamedArguments(typeName) {
         { name: "reason", type: "string" },
         { name: "duration", type: "decimal?" }
       ];
+    case "Vector2":
+    case "Vector2Int":
+    case "Vector3":
+    case "Vector3Int":
+    case "Color":
+      return graphConstructorParameters(typeName).map((parameter3) => ({
+        name: parameter3.name,
+        type: parameter3.type
+      }));
     default:
       return null;
   }
@@ -22234,6 +22380,19 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     return { token, symbol: visibleCandidates[0] };
   }
   if (visibleCandidates.length === 0) return null;
+  const sourceTokens = projectTokens(document);
+  const tokenIndex = sourceTokens.findIndex(
+    (candidate) => candidate.start === token.start && candidate.end === token.end
+  );
+  if (sourceTokens[tokenIndex + 1]?.text === "=" && sourceTokens[tokenIndex + 2]?.text !== "=") {
+    const constructed = constructionMemberSymbol(
+      analysis,
+      document,
+      token,
+      visibleCandidates
+    );
+    if (constructed) return { token, symbol: constructed };
+  }
   const source = analysis.documents.get(document.uri);
   const owner = source ? declarationContaining(source, token.range.start)?.name : void 0;
   if (owner) {
@@ -22242,10 +22401,6 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     );
     if (owned.length === 1) return { token, symbol: owned[0] };
   }
-  const sourceTokens = projectTokens(document);
-  const tokenIndex = sourceTokens.findIndex(
-    (candidate) => candidate.start === token.start && candidate.end === token.end
-  );
   const dotOwner = sourceTokens[tokenIndex - 1]?.text === "." ? sourceTokens[tokenIndex - 2] : void 0;
   if (dotOwner) {
     const resolvedOwner = indexedProjectSymbolAt(
@@ -22254,15 +22409,39 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
       dotOwner.range.start,
       index
     );
-    const ownerType = resolvedOwner ? projectSymbolTypeName(resolvedOwner.symbol) : dotOwner.text;
+    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 qualified = visibleCandidates.filter(
-      (symbol) => symbol.ownerName === ownerType
+      (symbol) => symbol.ownerName !== void 0 && ownerNames.has(symbol.ownerName)
     );
     if (qualified.length === 1) return { token, symbol: qualified[0] };
   }
   const projectLevel = visibleCandidates.filter((symbol) => !symbol.ownerName);
   return projectLevel.length === 1 ? { token, symbol: projectLevel[0] } : null;
 }
+function constructionMemberSymbol(analysis, document, token, candidates) {
+  const site = constructionSiteAt(analysis, document, token.range.start);
+  let current = site?.enclosingTypeName ?? null;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const owned = candidates.find(
+      (symbol) => symbol.kind === "member" && symbol.ownerName === current
+    );
+    if (owned) return owned;
+    const declaration = findTypeDeclaration(analysis, current);
+    current = declaration?.kind === "class" ? resolvableBaseClassName(analysis, declaration) : null;
+  }
+  return null;
+}
 function projectSymbolTypeName(symbol) {
   switch (symbol.kind) {
     case "class":
@@ -22360,21 +22539,219 @@ function signatureResult(name, parameters, activeParameter) {
   };
 }
 function contextualConstructorType(analysis, document, position) {
+  return constructionSiteAt(analysis, document, position)?.expectedTypeName ?? null;
+}
+function initializerRootAt(analysis, document, position) {
   const source = analysis.documents.get(document.uri);
   if (!source) return null;
   for (const declaration of source.declarations) {
     if (declaration.kind === "global") {
       if (rangeContains(declaration.initializer.range, position)) {
-        return declaration.type.name;
+        return {
+          type: declaration.type,
+          range: declaration.initializer.range
+        };
       }
       continue;
     }
     if (declaration.kind === "enum") continue;
     for (const member of declaration.members) {
       if (member.kind === "field" && member.initializer && rangeContains(member.initializer.range, position)) {
-        return member.type.name;
+        return { type: member.type, range: member.initializer.range };
+      }
+    }
+  }
+  return null;
+}
+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
+  );
+  const stack = [];
+  const expectedType = () => {
+    const frame = stack.at(-1);
+    if (!frame) return root.type;
+    switch (frame.kind) {
+      case "object":
+      case "dictionary":
+        return frame.slotType;
+      case "list":
+        return frame.elementType;
+      case "call":
+        return constructorArgumentType(analysis, frame);
+      case "opaque":
+        return null;
+    }
+  };
+  let sawNew = false;
+  let pendingNewTypeName = null;
+  let closedConstructorTypeName = null;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.text === "@") {
+      if ((tokens[index + 1]?.kind === "identifier" || tokens[index + 1]?.kind === "keyword") && tokens[index + 2]?.text === "(") {
+        let depth = 0;
+        index += 2;
+        for (; index < tokens.length; index++) {
+          if (tokens[index].text === "(") depth++;
+          else if (tokens[index].text === ")" && --depth === 0) break;
+        }
+      } else if (tokens[index + 1]?.kind === "identifier") {
+        index += 1;
+      }
+      continue;
+    }
+    if (token.text === "new") {
+      sawNew = true;
+      pendingNewTypeName = expectedType()?.name ?? null;
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (sawNew && (token.kind === "identifier" || token.kind === "type")) {
+      pendingNewTypeName = token.text;
+      continue;
+    }
+    if (sawNew && token.text === "<") {
+      let depth = 0;
+      for (; index < tokens.length; index++) {
+        if (tokens[index].text === "<") depth++;
+        else if (tokens[index].text === ">" && --depth === 0) break;
+      }
+      continue;
+    }
+    if (token.text === "{") {
+      if (sawNew || closedConstructorTypeName !== null) {
+        stack.push({
+          kind: "object",
+          typeName: pendingNewTypeName ?? closedConstructorTypeName,
+          slotType: null
+        });
+        sawNew = false;
+        pendingNewTypeName = null;
+      } else {
+        const expected = expectedType();
+        if (expected?.name === "Dictionary") {
+          stack.push({
+            kind: "dictionary",
+            valueType: expected.typeArguments[1] ?? null,
+            slotType: null
+          });
+        } else {
+          stack.push({ kind: "opaque" });
+        }
       }
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === "(") {
+      if (sawNew) {
+        stack.push({
+          kind: "call",
+          typeName: pendingNewTypeName,
+          argumentIndex: 0,
+          argumentName: null
+        });
+        sawNew = false;
+        pendingNewTypeName = null;
+      } else {
+        stack.push({ kind: "opaque" });
+      }
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === "[") {
+      stack.push({
+        kind: "list",
+        elementType: collectionElementType2(expectedType())
+      });
+      closedConstructorTypeName = null;
+      continue;
+    }
+    if (token.text === ")") {
+      const frame2 = stack.pop();
+      closedConstructorTypeName = frame2?.kind === "call" ? frame2.typeName : null;
+      continue;
+    }
+    if (token.text === "}" || token.text === "]") {
+      stack.pop();
+      closedConstructorTypeName = null;
+      continue;
+    }
+    closedConstructorTypeName = null;
+    const frame = stack.at(-1);
+    if (!frame) continue;
+    if (frame.kind === "object") {
+      if (token.text === "=" && tokens[index + 1]?.text !== "=") {
+        const nameToken = tokens[index - 1];
+        frame.slotType = nameToken && (nameToken.kind === "identifier" || nameToken.kind === "type") ? declaredFieldType(analysis, frame.typeName, nameToken.text) : null;
+      } else if (token.text === ",") {
+        frame.slotType = null;
+      }
+    } else if (frame.kind === "dictionary") {
+      if (token.text === ":") frame.slotType = frame.valueType;
+      else if (token.text === ",") frame.slotType = null;
+    } else if (frame.kind === "call") {
+      if (token.text === ",") {
+        frame.argumentIndex++;
+        frame.argumentName = null;
+      } else if (token.text === ":") {
+        const nameToken = tokens[index - 1];
+        frame.argumentName = nameToken?.kind === "identifier" ? nameToken.text : null;
+      }
+    }
+  }
+  const enclosing = [...stack].reverse().find(
+    (frame) => frame.kind === "object"
+  );
+  return {
+    expectedTypeName: expectedType()?.name ?? null,
+    enclosingTypeName: enclosing?.typeName ?? null
+  };
+}
+function collectionElementType2(type) {
+  if (!type) return null;
+  if (type.name === "List" || type.name === "Set") {
+    return type.typeArguments[0] ?? null;
+  }
+  return null;
+}
+function constructorArgumentType(analysis, frame) {
+  if (!frame.typeName) return null;
+  const declaration = findTypeDeclaration(analysis, frame.typeName);
+  if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
+    return null;
+  }
+  const fields = declaration.members.filter(
+    (member) => member.kind === "field" && !member.modifiers.includes("static")
+  );
+  if (frame.argumentName !== null) {
+    return fields.find((field) => field.name === frame.argumentName)?.type ?? null;
+  }
+  return fields[frame.argumentIndex]?.type ?? null;
+}
+function declaredFieldType(analysis, typeName, fieldName) {
+  let current = typeName;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const declaration = findTypeDeclaration(analysis, current);
+    if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
+      return null;
     }
+    const member = declaration.members.find(
+      (candidate) => candidate.kind === "field" && candidate.name === fieldName
+    );
+    if (member) return member.type;
+    current = declaration.kind === "class" ? resolvableBaseClassName(analysis, declaration) : null;
+  }
+  return null;
+}
+function resolvableBaseClassName(analysis, declaration) {
+  for (const base of declaration.baseTypes) {
+    const resolved = findTypeDeclaration(analysis, base.name);
+    if (resolved?.kind === "class") return base.name;
   }
   return null;
 }
@@ -22448,6 +22825,35 @@ function graphConstructorParameters(typeName) {
         { type: "string", name: "reason" },
         { type: "decimal?", name: "duration" }
       ];
+    case "Vector2":
+      return [
+        { type: "float", name: "x" },
+        { type: "float", name: "y" }
+      ];
+    case "Vector2Int":
+      return [
+        { type: "int", name: "x" },
+        { type: "int", name: "y" }
+      ];
+    case "Vector3":
+      return [
+        { type: "float", name: "x" },
+        { type: "float", name: "y" },
+        { type: "float", name: "z" }
+      ];
+    case "Vector3Int":
+      return [
+        { type: "int", name: "x" },
+        { type: "int", name: "y" },
+        { type: "int", name: "z" }
+      ];
+    case "Color":
+      return [
+        { type: "float", name: "r" },
+        { type: "float", name: "g" },
+        { type: "float", name: "b" },
+        { type: "float", name: "a" }
+      ];
     default:
       return [];
   }

package/package.json

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