@neocompose/cli 0.89.1 → 0.89.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.89.2
+
+### Patch Changes
+
+- 7095bfe: Fix collection paths assigned to reference sets being treated as single stored references. Preserve computed selections in nested initializers and field defaults, allow static collection defaults, and locate malformed reference selections at their source expression.
+- db2d1d5: Preserve reference-set default types when selection literals contain computed entries. Method results, mixed stored and computed targets, and constructor parameters now prepare and export consistently while retaining target identity.
+- 03bb210: Keep constructed objects in member receiver chains after initializer blocks. Restore completion, hover, navigation, and method signature help after expressions such as `new Box<Item> { Value=new() }.Value`.
+- 68831cd: Complete generic type arguments in constructors and method calls, including nested types, incomplete expressions, scoped type parameters, and constrained method arguments. Keep ordinary argument commas in value completion.
+- 5b8dac4: Stop offering named arguments for ordinary method and delegate calls, which require positional arguments. Keep typed argument completion and report unsupported named calls in initializer diagnostics before evaluation.
+- cb282c1: Suggest the supported id and withProvenance arguments in typed Reference calls across initializers, functions, and decorator values. Preserve existing labels and positional value completion, and omit unsupported provenance arguments on file references and listener metadata.
+- 5039d9b: Infer editor parameter types from a lambda's expected delegate type. Restore member completion, hover, and navigation in stored lambdas, including nested collection values, constructors, and tuple parameters.
+- 582d9a7: Use delegate return types for stored lambda completion, including contextual enum values, booleans, and returned object initializers. Preserve local assignment and nested call context, constructor argument names, and variant discovery. Distinguish switch arm separators from lambda arrows.
+- f2f83cb: Preserve expected result types in switch-arm completions, including target-typed constructors, initializer fields, and enum values nested in collections and constructor arguments.
+- 82ce448: Complete target-typed construction fields and arguments within tuple elements. Preserve tuple element types through nested tuples, collections, constructor arguments, and grouping parentheses.
+
 ## 0.89.1
 
 ### Patch Changes

package/dist/neo-runtime.mjs

@@ -19377,7 +19377,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.89.1",
+      cliVersion: "0.89.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -62535,18 +62535,19 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       lexed,
       diagnostics
     );
+    const regionCalls = indexCalls(executable, executablePairs, lexed);
     const regionLocals = applySwitchSectionScopes(
       indexLocals(
         executable,
         executablePairs,
         lexed,
         diagnostics,
-        lambdaBodies
+        lambdaBodies,
+        regionCalls
       ),
       regionSwitches,
       lexed
     );
-    const regionCalls = indexCalls(executable, executablePairs, lexed);
     const declarations = new Set(
       regionLocals.map(
         (local) => `${local.nameRange.start.line}:${local.nameRange.start.character}`
@@ -62999,9 +63000,10 @@ function duplicateUnitDiagnostic(label, units, diagnostics) {
     ]
   });
 }
-function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
+function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies, calls) {
   const locals = [];
   const braceScope = braceScopeIndex(tokens, lexed.end);
+  const switchArrows = switchExpressionArrowIndexes(tokens, calls);
   for (let index = 0; index < tokens.length; index++) {
     const caught = tryParseCatchParameter(tokens, index, pairs, lexed);
     if (caught) {
@@ -63022,7 +63024,13 @@ function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
       index = loop.resumeTokenIndex;
       continue;
     }
-    const lambda = tryParseLambdaParameters(tokens, index, pairs, lexed);
+    const lambda = tryParseLambdaParameters(
+      tokens,
+      index,
+      pairs,
+      lexed,
+      switchArrows
+    );
     if (lambda) {
       locals.push(...lambda.locals);
       lambdaBodies.push(lambda.body);
@@ -63183,7 +63191,35 @@ function statementEndTokenIndex(tokens, start) {
   }
   return tokens.length;
 }
-function tryParseLambdaParameters(tokens, start, pairs, lexed) {
+function switchExpressionArrowIndexes(tokens, calls) {
+  const enclosing = enclosingOpenerIndex(tokens);
+  const inResult = /* @__PURE__ */ new Set();
+  const arrows = /* @__PURE__ */ new Set();
+  const genericEnds = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const first = call.typeArgumentTokens?.[0];
+    if (first) genericEnds.set(first.start, call.openParenOffset);
+  }
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    const genericEnd = genericEnds.get(token.start);
+    if (genericEnd !== void 0) {
+      while (tokens[index + 1] && tokens[index + 1].start < genericEnd)
+        index++;
+      continue;
+    }
+    const opener = enclosing[index];
+    if (tokens[opener]?.text !== "{" || tokens[opener - 1]?.text !== "switch")
+      continue;
+    if (token.text === ",") inResult.delete(opener);
+    else if (token.text === "=>" && !inResult.has(opener)) {
+      arrows.add(index);
+      inResult.add(opener);
+    }
+  }
+  return arrows;
+}
+function tryParseLambdaParameters(tokens, start, pairs, lexed, switchArrows) {
   const open2 = tokens[start];
   if (!open2) return null;
   if (open2.kind === "identifier") {
@@ -63191,6 +63227,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
     if (!arrow2 || arrow2.kind !== "operator" || arrow2.text !== "=>") {
       return null;
     }
+    if (switchArrows.has(start + 1)) return null;
     const body2 = lambdaBodySpan(tokens, start + 1, pairs, lexed);
     return {
       locals: [
@@ -63215,6 +63252,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
   if (closeIndex === void 0) return null;
   const arrow = tokens[closeIndex + 1];
   if (!arrow || arrow.kind !== "operator" || arrow.text !== "=>") return null;
+  if (switchArrows.has(closeIndex + 1)) return null;
   const body = lambdaBodySpan(tokens, closeIndex + 1, pairs, lexed);
   const locals = [];
   for (const [parameterIndex, [from, to]] of patternSegments(
@@ -95922,6 +95960,8 @@ function validateOwnedStaticDefault(uri, member, ownerName, scope, environment,
   const initializer = member.initializer;
   if (initializer === void 0) return;
   if (member.type.name === "Reference") return;
+  if (member.type.name === "Set" && member.type.typeArguments[0]?.name === "Reference")
+    return;
   let expression;
   try {
     expression = parseExpression(initializer.text);
@@ -97044,6 +97084,21 @@ function knownGeneratorExpression(expression, scope, environment) {
   return candidates !== void 0 && candidates.length > 0 && candidates.every((member) => member.generator === true);
 }
 function validateExpression(expression, expected, scope, environment, uri, range2, diagnostics, anchor, storedValue = true) {
+  if (anchor !== void 0 && expression.kind === "call") {
+    const error = sourceCallBinding(expression, scope, environment)?.error;
+    if (error?.message.includes(
+      "Named arguments are not supported for this call."
+    )) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        anchorSpan(anchor, error, 1),
+        "invalid-function-call",
+        error.message.replace(/^\d+:\d+: /, "")
+      );
+      return;
+    }
+  }
   if (expression.kind === "new" && expression.typeArguments?.length) {
     const { context } = initializerResolver(
       environment,
@@ -123968,7 +124023,7 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       storesSelectionArray,
       `${ownerClass.name}.${declaration.name}`,
       !declaration.modifiers.includes("static") && contextualEnumArgument(settings, "kind") === "Unordered",
-      reference2 !== null
+      reference2 !== null ? fieldType : null
     )
   };
   if (fieldType.tupleElements) {
@@ -125246,7 +125301,7 @@ function spellsReference(expression) {
   }
   return expression.kind === "call" && expression.callee.kind === "ident" && expression.callee.name === "Reference";
 }
-function lowerDefault(context, initializer, type2, ownerClass, base, memberId, storesSelectionArray, path, unorderedList = false, reference2 = false) {
+function lowerDefault(context, initializer, type2, ownerClass, base, memberId, storesSelectionArray, path, unorderedList = false, referenceType = null) {
   if (initializer === null) {
     return base?.defaultValue && "serverValueId" in base.defaultValue ? base.defaultValue : null;
   }
@@ -125268,9 +125323,14 @@ function lowerDefault(context, initializer, type2, ownerClass, base, memberId, s
   }
   if (base?.defaultValue != null && matchesStoredInitializer(base.defaultValue, initializer))
     return base.defaultValue;
-  const deferred = reference2 ? deferredReferenceDefault(context, expression) : null;
+  const deferred = referenceType !== null && (referenceType.name !== "Set" || expression.kind === "litList") ? deferredReferenceDefault(context, expression) : null;
   if (deferred !== null) return { value: deferred, classId: null };
-  if (unorderedList && expression.kind === "litList" && expression.elements.length > 0 || constructsValue(expression) && slotForwardsTypeParameter(context, type2, ownerClass) || positionRequiresEvaluation(context, expression, type2, ownerClass)) {
+  if (unorderedList && expression.kind === "litList" && expression.elements.length > 0 || constructsValue(expression) && slotForwardsTypeParameter(context, type2, ownerClass) || positionRequiresEvaluation(
+    context,
+    expression,
+    referenceType ?? type2,
+    ownerClass
+  )) {
     return {
       init: {
         code: context.settleInitializerReferences(
@@ -125286,7 +125346,7 @@ function lowerDefault(context, initializer, type2, ownerClass, base, memberId, s
   if (context.rowBackedDefaultMemberIds.has(memberId) && base?.defaultValue && !("serverValueId" in base.defaultValue)) {
     return base.defaultValue;
   }
-  const slot = reference2 ? slotReferenceType(type2) : null;
+  const slot = referenceType !== null ? slotReferenceType(type2) : null;
   if (slot !== null && !spellsReference(expression)) {
     throw new Error(
       `A ${formatManifestType(slot)} default names a stored ${formatManifestType(requiredTypeArgument(slot, 0))}, not a value. Wrap a member path in Reference(), or give a row id.`
@@ -162374,8 +162434,14 @@ function memberInitializerRequiresEvaluation(context, member, expression, source
     return false;
   }
   if (member.kind === "lookup" && expression.kind === "litList") {
+    const elementMember = { ...member, multiselect: false };
     return expression.elements.some(
-      (element) => memberInitializerRequiresEvaluation(context, member, element, source)
+      (element) => memberInitializerRequiresEvaluation(
+        context,
+        elementMember,
+        element,
+        source
+      )
     );
   }
   const unorderedDefault = source.purpose === "memberDefault" && member.id === source.memberId && member.kind === "list" && member.listKind === "unordered" && expression.kind === "litList" && expression.elements.length > 0;
@@ -162416,6 +162482,7 @@ function deferredPathSpelling(context, expression, expected) {
 }
 function isDeferredPathReferenceValue(context, sourceExpression, expected) {
   const expression = annotatedValue(sourceExpression).expression;
+  if (expected.multiselect && expression.kind !== "litList") return false;
   const elements = expression.kind === "litList" ? expression.elements : [expression];
   let indexPaths = 0;
   for (const element of elements) {
@@ -166292,9 +166359,13 @@ function lowerEnum2(context, member, expression) {
   });
 }
 function lowerReferences(context, member, expression, ownerValueId, source) {
+  function refuse(message, at3 = expression) {
+    context.loweringFailures.push({ message, site: referenceSite(source, at3) });
+    throw new ReportedLoweringFailure(message);
+  }
   const elements = member.multiselect ? expression.kind === "litList" ? expression.elements : null : [expression];
   if (elements === null) {
-    throw new Error(`Reference member ${member.name} requires [...].`);
+    refuse(`Reference member ${member.name} requires [...].`);
   }
   const ids = [];
   for (const [index, entry] of elements.entries()) {
@@ -166312,7 +166383,7 @@ function lowerReferences(context, member, expression, ownerValueId, source) {
     }
     const target = referenceTargetSpelling(context, entry);
     if (target === null) {
-      throw new Error(`Reference member ${member.name} has an invalid target.`);
+      refuse(`Reference member ${member.name} has an invalid target.`, entry);
     }
     if (target.spelling === "key" || target.spelling === "local") {
       ids.push(`${PENDING_ID_PREFIX}reference-key:${source.label}:${index}`);
@@ -166335,9 +166406,7 @@ function lowerReferences(context, member, expression, ownerValueId, source) {
     ids.push(target.spelling === "id" ? target.id : target.resolved.id);
   }
   if (new Set(ids).size !== ids.length) {
-    throw new Error(
-      `Reference member ${member.name} cannot contain duplicate targets.`
-    );
+    refuse(`Reference member ${member.name} cannot contain duplicate targets.`);
   }
   return ids;
 }
@@ -185150,43 +185219,6 @@ var init_export_state = __esm({
   }
 });
 
-// ../packages/neoscript-language/src/argument-name-completions.ts
-function argumentNameCompletions(fields, tokens, start, prefixEnd, position) {
-  const edit = argumentNameCompletionEdit(tokens, start, prefixEnd, position);
-  if (!edit) return [];
-  const { range: range2, hasColon } = edit;
-  const items = [];
-  for (const field of fields) {
-    const insertText = hasColon ? field.name : `${field.name}: `;
-    items.push({
-      label: field.name,
-      kind: "property",
-      detail: field.defaultText === void 0 ? field.type : `[${field.type} = ${field.defaultText}]`,
-      insertText,
-      textEdit: { range: range2, newText: insertText }
-    });
-  }
-  return items;
-}
-function argumentNameCompletionEdit(tokens, start, prefixEnd, position) {
-  const first = tokens[start];
-  if (prefixEnd > start + 1) return null;
-  if (prefixEnd > start && (!first || !isCallArgumentLabelToken(first)))
-    return null;
-  const editingName = first !== void 0 && isCallArgumentLabelToken(first) && positionCompare(first.range.start, position) <= 0 && positionCompare(position, first.range.end) <= 0;
-  if (first && isCallArgumentLabelToken(first) && !editingName) return null;
-  const hasColon = editingName && tokens[start + 1]?.text === ":";
-  const range2 = editingName ? first.range : { start: position, end: position };
-  return { range: range2, hasColon };
-}
-var init_argument_name_completions = __esm({
-  "../packages/neoscript-language/src/argument-name-completions.ts"() {
-    "use strict";
-    init_executable_parser();
-    init_project_source_tokens();
-  }
-});
-
 // ../packages/neoscript-language/src/tuple-symbols.ts
 function tupleElementSymbol(element, index, alias = false) {
   const location3 = alias ? void 0 : element.labelLocation;
@@ -185528,15 +185560,7 @@ function complete(snapshot, position) {
   const tokens = significantTokensBefore(snapshot.lexed.tokens, word.start);
   const tail = tokens[tokens.length - 1];
   let candidates;
-  const genericMember = tail?.text === "<" ? resolveChain(
-    snapshot,
-    expressionTokensBefore(tokens, tokens.length - 1),
-    offset
-  )?.symbol : void 0;
-  const genericMemberId = genericMember?.id;
-  const firstTypeParameter = genericMember?.typeParameters?.[0]?.type;
-  const functionConstraint = firstTypeParameter?.kind === "typeParameter" && firstTypeParameter.constraint?.kind === "named" ? firstTypeParameter.constraint.typeId : void 0;
-  const nativeGenericClassId = genericMemberId === NEO_TILE_CONVERT_MEMBER_ID ? NEO_TILE_CLASS_ID : functionConstraint;
+  const genericTypes = typeArgumentCompletionItems(snapshot, tokens, word);
   const catchFilterCandidates = catchFilterCompletionItems(
     snapshot,
     word.start,
@@ -185553,7 +185577,9 @@ function complete(snapshot, position) {
     prefix,
     word
   );
-  if (catchFilterCandidates) {
+  if (genericTypes) {
+    candidates = genericTypes;
+  } else if (catchFilterCandidates) {
     candidates = catchFilterCandidates;
   } else if (catchClauseCandidates) {
     candidates = catchClauseCandidates;
@@ -185580,14 +185606,6 @@ function complete(snapshot, position) {
       word,
       expectedValueAt(snapshot, word.start)
     );
-  } else if (nativeGenericClassId) {
-    candidates = [...snapshot.project.typeByName.values()].filter(
-      (type2) => type2.kind === "class" && (genericMemberId !== NEO_TILE_CONVERT_MEMBER_ID || !type2.abstract && !type2.typeParameters?.length) && isNeoScriptTypeAssignable(
-        { kind: "named", typeId: type2.id },
-        { kind: "named", typeId: nativeGenericClassId },
-        snapshot.project
-      )
-    ).map((type2) => typeCompletion(type2, word, snapshot));
   } else if (isTypePosition(tokens)) {
     candidates = typeCompletionItems(snapshot, word);
   } else if (isLambdaParameterPosition(tokens)) {
@@ -185600,6 +185618,88 @@ function complete(snapshot, position) {
     items: rankAndDeduplicate(candidates, prefix)
   };
 }
+function completeTypeArgument(snapshot, position) {
+  const offset = snapshot.source.offsetAt(position);
+  if (insidePlainString(snapshot.lexed.tokens, offset)) return null;
+  const word = {
+    start: wordRangeAt(snapshot.source.text, offset).start,
+    end: offset
+  };
+  const tokens = significantTokensBefore(snapshot.lexed.tokens, word.start);
+  const items = typeArgumentCompletionItems(snapshot, tokens, word);
+  return items === null ? null : {
+    isIncomplete: hasUnclosedConstruct(snapshot.lexed.tokens, offset),
+    items: rankAndDeduplicate(
+      items,
+      snapshot.source.text.slice(word.start, offset)
+    )
+  };
+}
+function typeArgumentCompletionItems(snapshot, tokens, word) {
+  let depth = 0;
+  let argumentIndex = 0;
+  let tupleDepth = 0;
+  let inTuple = false;
+  for (let index = tokens.length - 1; index >= 0; index--) {
+    const token = tokens[index];
+    if (token.text === ")") tupleDepth++;
+    else if (token.text === "(") {
+      if (!["<", ",", "("].includes(tokens[index - 1]?.text ?? "")) return null;
+      if (tupleDepth > 0) tupleDepth--;
+      else inTuple = true;
+    } else if (/^>+$/.test(token.text)) depth += token.text.length;
+    else if (token.text === "<") {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      const name = tokens[index - 1]?.text;
+      const resolution = resolveChain(
+        snapshot,
+        expressionTokensBefore(tokens, index),
+        word.start
+      );
+      const member = resolution?.symbol;
+      const declaration = (tokens[index - 2]?.text === "new" || resolution === null) && name ? snapshot.project.typeByName.get(name) : resolution?.staticType;
+      const parameters = member?.typeParameters ?? declaration?.typeParameters;
+      const builtin = name !== void 0 && member === void 0 && tokens[index - 2]?.text !== "." && [
+        "List",
+        "Set",
+        "Dictionary",
+        "Reference",
+        "Partial",
+        "FunctionRef",
+        "NeoDelegate",
+        "NeoAction"
+      ].includes(name);
+      const tileConversion = member?.id === NEO_TILE_CONVERT_MEMBER_ID && argumentIndex === 0;
+      if (!parameters?.length && !builtin && !tileConversion) return null;
+      const parameter4 = inTuple ? void 0 : parameters?.[argumentIndex]?.type;
+      const constraint = parameter4?.kind === "typeParameter" ? parameter4.constraint : void 0;
+      const constraintId = constraint?.kind === "named" ? constraint.typeId : void 0;
+      const classId = tileConversion ? NEO_TILE_CLASS_ID : constraintId;
+      if (!classId) return typeCompletionItems(snapshot, word);
+      const candidates = [...snapshot.project.typeByName.values()].filter(
+        (type2) => type2.kind === "class" && (!tileConversion || !type2.abstract && !type2.typeParameters?.length) && isNeoScriptTypeAssignable(
+          { kind: "named", typeId: type2.id },
+          { kind: "named", typeId: classId },
+          snapshot.project
+        )
+      ).map((type2) => typeCompletion(type2, word, snapshot));
+      if (!tileConversion)
+        candidates.push(
+          ...typeParameterCompletionItems(snapshot, word, constraint)
+        );
+      return candidates;
+    } else if (!isCallTypeArgumentToken(token)) return null;
+    else if (depth === 0 && tupleDepth === 0 && token.text === ",")
+      argumentIndex++;
+  }
+  return null;
+}
+function completeLambdaBody(snapshot, position) {
+  return lambdaBodyAt(snapshot, snapshot.source.offsetAt(position)) ? complete(snapshot, position) : null;
+}
 function completeFunctionArgument(snapshot, position) {
   const argument2 = callArgumentAt(snapshot, snapshot.source.offsetAt(position));
   if (!argument2 || argument2.call.kind === "constructor" || !callSymbol(snapshot, argument2.call))
@@ -185608,76 +185708,7 @@ function completeFunctionArgument(snapshot, position) {
   for (let opener = innermostOpener(features, snapshot.source.offsetAt(position)); opener >= 0 && features.tokens[opener].start > argument2.call.openParenOffset; opener = features.enclosingOpener[opener]) {
     if (features.tokens[opener].text === "{") return null;
   }
-  const values = complete(snapshot, position);
-  const names2 = functionArgumentNames(snapshot, position);
-  if (!names2) return values;
-  const offset = snapshot.source.offsetAt(position);
-  const word = wordRangeAt(snapshot.source.text, offset);
-  return {
-    ...values,
-    items: rankAndDeduplicate(
-      names2.onlyNames ? names2.items : [...names2.items, ...values.items],
-      snapshot.source.text.slice(word.start, offset)
-    )
-  };
-}
-function functionArgumentNames(snapshot, position) {
-  const offset = snapshot.source.offsetAt(position);
-  if (lambdaBodyAt(snapshot, offset)) return null;
-  const argument2 = callArgumentAt(snapshot, offset);
-  if (argument2?.call.kind !== "function") return null;
-  const { call, index } = argument2;
-  const { tokens } = scriptFeatureIndex(snapshot);
-  const startOffset = call.argumentRanges[index] ? snapshot.source.offsetAt(call.argumentRanges[index].start) : offset;
-  const start = firstIndex(tokens, (token) => token.start >= startOffset);
-  const prefixEnd = firstIndex(tokens, (token) => token.start >= offset);
-  const edit = argumentNameCompletionEdit(tokens, start, prefixEnd, position);
-  if (!edit) return null;
-  const symbol = callSymbol(snapshot, call);
-  if (!symbol?.parameters) return null;
-  const labels = [...call.argumentNames];
-  labels[index] = null;
-  const bound = boundOverloadId(
-    snapshot,
-    snapshot.source.offsetAt(call.nameRange.start),
-    call.name
-  );
-  const overloads = callOverloads(snapshot, call, symbol, bound).map(
-    (overload) => ({ parameters: overload.parameters ?? [] })
-  );
-  const reachable = neoScriptApplicableSignatures(overloads, labels);
-  const fields = /* @__PURE__ */ new Map();
-  for (const { parameters } of reachable) {
-    const used = /* @__PURE__ */ new Set();
-    call.argumentNames.forEach((name, argumentIndex) => {
-      if (argumentIndex === index) return;
-      const parameter4 = neoScriptArgumentParameter(
-        parameters,
-        name,
-        argumentIndex
-      );
-      if (parameter4) used.add(parameter4.name.toLowerCase());
-    });
-    for (const parameter4 of parameters) {
-      const key = parameter4.name.toLowerCase();
-      if (used.has(key) || fields.has(key)) continue;
-      fields.set(key, {
-        name: parameter4.name,
-        type: formatType(parameter4.type, snapshot.project),
-        ...parameter4.defaultValue ? { defaultText: parameter4.defaultValue.displayText } : {}
-      });
-    }
-  }
-  return {
-    items: argumentNameCompletions(
-      [...fields.values()],
-      tokens,
-      start,
-      prefixEnd,
-      position
-    ),
-    onlyNames: edit.hasColon
-  };
+  return complete(snapshot, position);
 }
 function hover(snapshot, position) {
   const offset = snapshot.source.offsetAt(position);
@@ -187071,6 +187102,32 @@ function initializerConstruction(snapshot, brace, constructor2) {
   }
   return construction;
 }
+function initializerKeyContextAt(snapshot, position) {
+  const features = scriptFeatureIndex(snapshot);
+  const offset = snapshot.source.offsetAt(position);
+  const brace = innermostOpener(features, offset);
+  const constructor2 = features.objectInitializers.get(brace);
+  if (constructor2 === void 0) return null;
+  const keys = [];
+  let atKey = true;
+  for (let index = brace + 1; index < features.tokens.length; index++) {
+    const token = features.tokens[index];
+    if (token.start >= offset) break;
+    if (features.enclosingOpener[index] !== brace) continue;
+    const call = features.calls.get(token.start);
+    if (call?.typeArgumentTokens?.length) {
+      index = (features.tokenIndexes.get(call.openParenOffset) ?? index + 1) - 1;
+      continue;
+    }
+    if (token.text === "=") {
+      keys.push(features.tokens[index - 1].text);
+      atKey = false;
+    } else if (token.text === ",") atKey = true;
+  }
+  if (!atKey) return null;
+  const construction = initializerConstruction(snapshot, brace, constructor2);
+  return construction ? { typeName: construction.declaration.name, keys } : null;
+}
 function initializerExpectedType(snapshot, offset, bodyStart) {
   const features = scriptFeatureIndex(snapshot);
   const { tokens, enclosingOpener, callOpenings, objectInitializers } = features;
@@ -187484,6 +187541,27 @@ function matchingCloseBraceIndex(tokens, openIndex) {
   }
   return null;
 }
+function typeParameterCompletionItems(snapshot, word, constraint) {
+  const items = [];
+  for (const parameter4 of [
+    ...contextualTypeParameters(snapshot),
+    ...snapshot.context.typeParameters ?? []
+  ]) {
+    if (constraint && !isNeoScriptTypeAssignable(parameter4.type, constraint, snapshot.project))
+      continue;
+    items.push(
+      completion(
+        parameter4.name,
+        "typeParameter",
+        parameter4.name,
+        "Type parameter",
+        word,
+        snapshot
+      )
+    );
+  }
+  return items;
+}
 function typeCompletionItems(snapshot, word) {
   const items = NEOSCRIPT_PRIMITIVE_TYPES.map(
     (name) => completion(name, "keyword", name, "Primitive type", word, snapshot)
@@ -187499,8 +187577,9 @@ function typeCompletionItems(snapshot, word) {
       "snippet"
     )
   );
+  items.push(...typeParameterCompletionItems(snapshot, word));
   for (const type2 of snapshot.project.typeByName.values()) {
-    if (type2.id === NEOSCRIPT_MATH_TYPE_ID || type2.id === "builtin:Debug")
+    if (type2.kind === "builtin" && !ANNOTATION_TYPE_NAMES.has(type2.name))
       continue;
     items.push(typeCompletion(type2, word, snapshot));
   }
@@ -189301,6 +189380,18 @@ function inferLambdaParameterType(local, snapshot) {
   if (declarationIndex < 0) return UNKNOWN_TYPE;
   const arrow = tokens[declarationIndex + 1];
   let opener = enclosingOpener[declarationIndex];
+  let lambdaStart = arrow?.text === "=>" ? declarationIndex : opener;
+  for (let depth = 0; depth < (local.tuplePath?.length ?? 0); depth++)
+    lambdaStart = enclosingOpener[lambdaStart] ?? -1;
+  if (lambdaStart >= 0) {
+    const offset = tokens[lambdaStart].start;
+    const argument2 = resolvedCallArgumentAt(snapshot, offset);
+    const expected = isCollectionCallbackArgument(argument2) ? null : expectedTypeAt(snapshot, offset, void 0, argument2);
+    if (expected?.kind === "delegate") {
+      const parameter4 = expected.parameterTypes[local.lambdaParameterIndex ?? 0];
+      if (parameter4) return tuplePathType(parameter4, local.tuplePath);
+    }
+  }
   if (!(arrow?.kind === "operator" && arrow.text === "=>")) {
     if (opener < 0 || tokens[opener]?.text !== "(") return UNKNOWN_TYPE;
     opener = enclosingOpener[opener];
@@ -189571,17 +189662,20 @@ function expressionTokensBefore(tokens, endExclusive) {
   for (; start >= 0; start--) {
     const token = tokens[start];
     if (!token) continue;
-    if (token.kind === "punctuation" && [")", "]"].includes(token.text)) {
+    if (token.kind === "punctuation" && [")", "]", "}"].includes(token.text)) {
+      if (token.text === "}" && depth === 0 && start < endExclusive - 1 && ![".", "?.", "!"].includes(tokens[start + 1]?.text ?? ""))
+        break;
       if (depth === 0) groupEnd = start;
       depth++;
     }
-    if (token.kind === "punctuation" && ["(", "["].includes(token.text)) {
+    if (token.kind === "punctuation" && ["(", "[", "{"].includes(token.text)) {
       if (depth > 0) depth--;
       else break;
       if (depth === 0 && ["if", "while", "for", "foreach"].includes(
         tokens[start - 1]?.text ?? ""
       ))
         return tokens.slice(groupEnd + 1, endExclusive);
+      continue;
     }
     if (depth === 0 && token.kind === "operator" && token.text === ">") {
       const name = genericCallNameIndex(tokens, start);
@@ -189598,8 +189692,7 @@ function expressionTokensBefore(tokens, endExclusive) {
   return tokens.slice(start + 1, endExclusive);
 }
 function genericCallNameIndex(tokens, close) {
-  if (tokens[close + 1]?.text !== "(" && tokens[close + 1]?.text !== ".")
-    return -1;
+  if (!["(", ".", "{"].includes(tokens[close + 1]?.text ?? "")) return -1;
   let depth = 0;
   for (let cursor = close; cursor > 0; cursor--) {
     const token = tokens[cursor];
@@ -189607,7 +189700,7 @@ function genericCallNameIndex(tokens, close) {
     if (token.text === ">") depth++;
     else if (token.text === "<") {
       if (--depth === 0) {
-        const valid = tokens[close + 1]?.text === "." ? new Parser(tokens.slice(cursor - 1, close + 1)).typeEnd() === close - cursor + 2 : callOpenParenIndex(tokens, cursor - 1) === close + 1;
+        const valid = tokens[close + 1]?.text !== "(" ? new Parser(tokens.slice(cursor - 1, close + 1)).typeEnd() === close - cursor + 2 : callOpenParenIndex(tokens, cursor - 1) === close + 1;
         return valid ? cursor - 1 : -1;
       }
     } else if (!isCallTypeArgumentToken(token)) return -1;
@@ -189633,13 +189726,6 @@ function wordRangeAt(text, offset) {
 function isTypePosition(tokens) {
   const tail = tokens[tokens.length - 1];
   if (!tail) return false;
-  if (tail.kind === "operator" && tail.text === "<") {
-    const previous = tokens[tokens.length - 2];
-    return previous?.text === "Dictionary" || previous?.text === "Set";
-  }
-  if (tail.kind === "punctuation" && tail.text === ",") {
-    return tokens.some((token) => token.text === "Dictionary");
-  }
   if (tail.kind === "keyword" && tail.text === "is") return true;
   if (tail.text === "not" && tokens.at(-2)?.text === "is") return true;
   return false;
@@ -189758,11 +189844,10 @@ function isTypeAnnotationReference(snapshot, reference2) {
 function isConstructorTypeReference(snapshot, reference2) {
   return scriptFeatureIndex(snapshot).calls.get(reference2.start)?.kind === "constructor";
 }
-var SCRIPT_FEATURE_INDEX, assumedLambdaInputs, LIST_OPENERS, LIST_CLOSERS, TUPLE_LABEL_DECLARATIONS, NAMED_ARGUMENT_LABELS, NO_EXPECTED_VALUE, CONSTRUCTIONS, FLOW_PROBES, OVERLOADED_FUNCTION_NAMES, GENERIC_CALL_NAMES, LOCAL_SCOPE_INDEX, NAMED_ITEM_INDEX, COLLECTION_FUNCTION_DOCUMENTATION, LOCAL_SYMBOL_CACHE, CALL_COMMIT_CHARACTERS, GENERIC_CALL_COMMIT_CHARACTERS, SETTER_VALUE_ID_SUFFIX, LAMBDA_BODY_INDEX;
+var SCRIPT_FEATURE_INDEX, assumedLambdaInputs, LIST_OPENERS, LIST_CLOSERS, TUPLE_LABEL_DECLARATIONS, NAMED_ARGUMENT_LABELS, NO_EXPECTED_VALUE, CONSTRUCTIONS, ANNOTATION_TYPE_NAMES, FLOW_PROBES, OVERLOADED_FUNCTION_NAMES, GENERIC_CALL_NAMES, LOCAL_SCOPE_INDEX, NAMED_ITEM_INDEX, COLLECTION_FUNCTION_DOCUMENTATION, LOCAL_SYMBOL_CACHE, CALL_COMMIT_CHARACTERS, GENERIC_CALL_COMMIT_CHARACTERS, SETTER_VALUE_ID_SUFFIX, LAMBDA_BODY_INDEX;
 var init_analyzer = __esm({
   "../packages/neoscript-language/src/analyzer.ts"() {
     "use strict";
-    init_argument_name_completions();
     init_extension_members();
     init_random_contract();
     init_error_contract();
@@ -189790,6 +189875,9 @@ var init_analyzer = __esm({
     NAMED_ARGUMENT_LABELS = /* @__PURE__ */ new WeakMap();
     NO_EXPECTED_VALUE = { type: null };
     CONSTRUCTIONS = /* @__PURE__ */ new WeakMap();
+    ANNOTATION_TYPE_NAMES = new Set(
+      NEOSCRIPT_BUILTIN_ANNOTATION_TYPES
+    );
     FLOW_PROBES = /* @__PURE__ */ new WeakMap();
     OVERLOADED_FUNCTION_NAMES = /* @__PURE__ */ new WeakMap();
     GENERIC_CALL_NAMES = /* @__PURE__ */ new WeakMap();
@@ -189853,6 +189941,43 @@ var init_parity_contract = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/argument-name-completions.ts
+function argumentNameCompletions(fields, tokens, start, prefixEnd, position) {
+  const edit = argumentNameCompletionEdit(tokens, start, prefixEnd, position);
+  if (!edit) return [];
+  const { range: range2, hasColon } = edit;
+  const items = [];
+  for (const field of fields) {
+    const insertText = hasColon ? field.name : `${field.name}: `;
+    items.push({
+      label: field.name,
+      kind: "property",
+      detail: field.defaultText === void 0 ? field.type : `[${field.type} = ${field.defaultText}]`,
+      insertText,
+      textEdit: { range: range2, newText: insertText }
+    });
+  }
+  return items;
+}
+function argumentNameCompletionEdit(tokens, start, prefixEnd, position) {
+  const first = tokens[start];
+  if (prefixEnd > start + 1) return null;
+  if (prefixEnd > start && (!first || !isCallArgumentLabelToken(first)))
+    return null;
+  const editingName = first !== void 0 && isCallArgumentLabelToken(first) && positionCompare(first.range.start, position) <= 0 && positionCompare(position, first.range.end) <= 0;
+  if (first && isCallArgumentLabelToken(first) && !editingName) return null;
+  const hasColon = editingName && tokens[start + 1]?.text === ":";
+  const range2 = editingName ? first.range : { start: position, end: position };
+  return { range: range2, hasColon };
+}
+var init_argument_name_completions = __esm({
+  "../packages/neoscript-language/src/argument-name-completions.ts"() {
+    "use strict";
+    init_executable_parser();
+    init_project_source_tokens();
+  }
+});
+
 // ../packages/neoscript-language/src/project-listener-annotations.ts
 function createContext2(analysis, source) {
   const project = cachedProjectIndex(analysis.project);
@@ -189948,6 +190073,20 @@ function sourceTypeAst(type2) {
       column: type2.range.start.character + 1
     }
   };
+  if (type2.tupleElements)
+    return {
+      ...common,
+      kind: "tuple",
+      elements: type2.tupleElements.map((element) => {
+        const nested = sourceTypeAst(element.type);
+        return {
+          type: nested,
+          pos: nested.pos,
+          ...element.name ? { name: element.name } : {},
+          ...element.nameRange ? { nameRange: element.nameRange } : {}
+        };
+      })
+    };
   const args = type2.typeArguments;
   if ((type2.name === "List" || type2.name === "Set") && args[0])
     return {
@@ -190828,6 +190967,63 @@ function projectDiagnostics(analysis, uri) {
   }));
 }
 function projectCompletions(analysis, document, position) {
+  const result = projectCompletionsAt(analysis, document, position);
+  const referenceNames = projectReferenceArgumentCompletions(
+    analysis,
+    document,
+    position
+  );
+  return referenceNames.length ? { ...result, items: [...referenceNames, ...result.items] } : result;
+}
+function projectReferenceArgumentCompletions(analysis, document, position) {
+  if (projectTokenAt(document, position)?.kind === "comment") return [];
+  const documentTokens = projectSignificantTokens(analysis, document);
+  const tokens = tokensBeforePosition(documentTokens, position);
+  const openIndex = activeCallOpenIndex(tokens, position);
+  if (openIndex < 0) return [];
+  const calleeIndex = projectCallCalleeIndex(tokens, openIndex);
+  if (tokens[calleeIndex]?.text !== "Reference" || tokens[calleeIndex + 1]?.text !== "<")
+    return [];
+  if ([".", "?.", "new"].includes(tokens[calleeIndex - 1]?.text ?? ""))
+    return [];
+  const active = activeCallArgument(tokens, openIndex, position);
+  if (active.label !== null) return [];
+  if (tokens.length > active.start + 1) return [];
+  const args = projectCallArguments(documentTokens, openIndex);
+  let field;
+  if (active.index === 0) field = { name: "id", type: "string" };
+  else if (active.index === 1 && args[0]?.name === "id") {
+    const source = analysis.documents.get(document.uri);
+    if (source?.listenerStatements?.some(
+      (statement) => rangeContains(statement.range, position)
+    ))
+      return [];
+    const before = tokens[calleeIndex - 1];
+    if (before?.text === ")" && !initializerRootAt(analysis, document, position) && !projectBodySnapshotAt(analysis, document, position)) {
+      const annotationOpen = activeCallOpenIndex(
+        tokens.slice(0, calleeIndex - 1),
+        before.range.start
+      );
+      if (tokens[annotationOpen - 1]?.text === "listeners" && tokens[annotationOpen - 2]?.text === "@")
+        return [];
+    }
+    const target = tokens[calleeIndex + 2]?.text;
+    if (target === "NeoImage" || target === "NeoAudioClip") return [];
+    field = { name: "withProvenance", type: "bool", defaultText: "false" };
+  } else return [];
+  if (args.some(
+    (argument2) => argument2.index !== active.index && argument2.name === field.name
+  ))
+    return [];
+  return argumentNameCompletions(
+    [field],
+    documentTokens,
+    active.start,
+    tokens.length,
+    position
+  );
+}
+function projectCompletionsAt(analysis, document, position) {
   if (projectTokenAt(document, position)?.kind === "comment") {
     return { isIncomplete: false, items: [] };
   }
@@ -190902,6 +191098,29 @@ function projectCompletions(analysis, document, position) {
     position,
     annotationSite
   );
+  const lambda = expression && completeLambdaBody(expression.snapshot, position);
+  if (lambda && expression) {
+    const members3 = projectInitializerMemberCompletions(
+      analysis,
+      document,
+      position,
+      expression.snapshot
+    );
+    if (members3) return { ...lambda, items: members3 };
+    const names2 = projectConstructorArgumentCompletions(
+      analysis,
+      document,
+      position,
+      expression.snapshot
+    );
+    const items = names2?.length ? [...names2, ...lambda.items] : lambda.items;
+    return {
+      ...lambda,
+      items: variantScopeInBody ? [...items, variantScopeInBody] : items
+    };
+  }
+  const typeArgument = expression && completeTypeArgument(expression.snapshot, position);
+  if (typeArgument) return typeArgument;
   const argument2 = expression && completeFunctionArgument(expression.snapshot, position);
   if (argument2) return argument2;
   const builtinMembers = projectBuiltinStaticMemberCompletions(
@@ -191430,7 +191649,7 @@ function projectExpressionMemberCompletions(analysis, document, position, annota
   const dot = before.at(-1);
   if (dot?.text !== "." && dot?.text !== "?.") return null;
   const receiver = before.at(-2);
-  if (!receiver || !(receiver.kind === "identifier" || receiver.kind === "type" || [")", "]", ">", "!", "this", "base", "root"].includes(receiver.text)))
+  if (!receiver || !(receiver.kind === "identifier" || receiver.kind === "type" || [")", "]", "}", ">", "!", "this", "base", "root"].includes(receiver.text)))
     return null;
   const expression = projectExpressionSnapshotAt(
     analysis,
@@ -191460,6 +191679,11 @@ function projectExpressionSnapshotAt(analysis, document, position, annotationSit
     const { thisClass: _thisClass, ...staticContext } = language.context;
     context = { ...staticContext, staticMember: true };
   }
+  if (root && !argument2) {
+    const expected = constructionSiteAt(analysis, document, root.range.start);
+    if (expected?.expectedTypeRef)
+      context = { ...context, returnType: expected.expectedTypeRef };
+  }
   const key = range2 ?? context;
   let documents = PROJECT_EXPRESSION_SNAPSHOT_CACHE.get(analysis);
   if (!documents) {
@@ -191863,6 +192087,7 @@ function projectConstructorArgumentCompletions(analysis, document, position, bod
   if (!typeName) return null;
   const active = activeCallArgument(tokens, openIndex, position);
   if (active.label !== null) return null;
+  if (tokens.length > active.start + 1) return null;
   const args = projectCallArguments(documentTokens, openIndex);
   const builtin = lookupVariantFolderArgumentFields(typeName) ?? graphConstructorNamedArguments(typeName);
   const fields = builtin ? unusedConstructorArguments(builtin, args, active.index) : declaredConstructorNamedArguments(analysis, typeName, args, active.index);
@@ -191946,18 +192171,16 @@ function parameterArgumentField(parameter4) {
     ...parameter4.defaultValue === void 0 ? {} : { defaultText: parameter4.defaultValue.text }
   };
 }
-function projectInitializerMemberCompletions(analysis, document, position) {
-  const site = constructionSiteAt(analysis, document, position);
-  if (!site?.atInitializerKey) return null;
-  const typeName = site.initializerTypeName;
-  if (typeName === null) return null;
+function projectInitializerMemberCompletions(analysis, document, position, body) {
+  const site = body ? null : constructionSiteAt(analysis, document, position);
+  const context = body ? initializerKeyContextAt(body, position) : null;
+  const typeName = body ? context?.typeName : site?.initializerTypeName;
+  if (typeName == null) return null;
+  if (!body && !site?.atInitializerKey) return null;
+  const keys = context?.keys ?? site?.initializerKeys ?? [];
   const index = projectConstructionIndex(analysis);
-  const unsettled = unsettledRequiredMembers(
-    index,
-    typeName,
-    site.initializerKeys
-  );
-  const taken = new Set(site.initializerKeys.map((key) => key.toLowerCase()));
+  const unsettled = unsettledRequiredMembers(index, typeName, keys);
+  const taken = new Set(keys.map((key) => key.toLowerCase()));
   for (const member of unsettled) taken.add(member.name.toLowerCase());
   const items = unsettled.map((member) => ({
     label: member.name,
@@ -193635,6 +193858,7 @@ function indexConstructionSites(analysis, document, root) {
     end++;
   const tokens = allTokens.slice(start, end).filter((token) => token.kind !== "comment" && token.kind !== "eof");
   let delimiterEnds;
+  const genericCallOpens = constructionGenericCallOpens(tokens);
   const language = listenerSourceContext(analysis, document, root.range.start);
   const sourceType = (type2) => resolveSourceType(type2, language.context, language.project);
   const fieldType = (owner, name) => {
@@ -193687,7 +193911,11 @@ function indexConstructionSites(analysis, document, root) {
       case "object":
       case "list":
       case "dictionary":
+      case "tuple":
+      case "group":
         return frame.slotId;
+      case "switch":
+        return frame.inResult ? frame.slotId : null;
       case "call":
       case "opaque":
         return null;
@@ -193699,7 +193927,12 @@ function indexConstructionSites(analysis, document, root) {
     switch (frame.kind) {
       case "object":
       case "dictionary":
+      case "group":
         return frame.slotTypeRef;
+      case "tuple":
+        return frame.typeRef.elements[frame.elementIndex]?.type ?? null;
+      case "switch":
+        return frame.inResult ? frame.resultTypeRef : null;
       case "list":
         return frame.elementTypeRef;
       case "opaque":
@@ -193737,7 +193970,12 @@ function indexConstructionSites(analysis, document, root) {
     switch (frame.kind) {
       case "object":
       case "dictionary":
+      case "group":
         return frame.slotType;
+      case "tuple":
+        return frame.type?.tupleElements?.[frame.elementIndex]?.type ?? null;
+      case "switch":
+        return frame.inResult ? frame.resultType : null;
       case "list":
         return frame.elementType;
       case "call":
@@ -193834,7 +194072,7 @@ function indexConstructionSites(analysis, document, root) {
       sawNew = true;
       newStart = index;
       pendingNewTypeRef = expectedTypeRef();
-      pendingNewTypeName = expectedType()?.name ?? null;
+      pendingNewTypeName = pendingNewTypeRef?.kind === "named" ? language.project.typeById.get(pendingNewTypeRef.typeId)?.name ?? null : expectedType()?.name ?? null;
       closedConstructorTypeName = null;
       continue;
     }
@@ -193872,8 +194110,24 @@ function indexConstructionSites(analysis, document, root) {
       }
       continue;
     }
+    if (!sawNew) {
+      const call = genericCallOpens.get(index) ?? -1;
+      if (call >= 0) {
+        index = call - 1;
+        closedConstructorTypeName = null;
+        continue;
+      }
+    }
     if (token.text === "{") {
-      if (sawNew || closedConstructorTypeName !== null) {
+      if (tokens[index - 1]?.text === "switch") {
+        stack.push({
+          kind: "switch",
+          resultType: expectedType(),
+          resultTypeRef: expectedTypeRef(),
+          slotId: expectedSlotId(),
+          inResult: false
+        });
+      } else if (sawNew || closedConstructorTypeName !== null) {
         const frame2 = {
           kind: "object",
           typeName: pendingNewTypeName ?? closedConstructorTypeName,
@@ -193934,7 +194188,33 @@ function indexConstructionSites(analysis, document, root) {
         sawNew = false;
         pendingNewTypeName = null;
       } else {
-        stack.push({ kind: "opaque" });
+        const ends = delimiterEnds ??= projectDelimiterEnds(tokens);
+        const expected = expectedTypeRef();
+        const kind = constructionParenthesesKind(
+          tokens,
+          index,
+          ends,
+          genericCallOpens,
+          expected?.kind === "tuple"
+        );
+        if (kind === "tuple" && expected?.kind === "tuple") {
+          stack.push({
+            kind: "tuple",
+            type: expectedType(),
+            typeRef: expected,
+            slotId: expectedSlotId(),
+            elementIndex: 0
+          });
+        } else if (kind === "group") {
+          stack.push({
+            kind: "group",
+            slotType: expectedType(),
+            slotTypeRef: expected,
+            slotId: expectedSlotId()
+          });
+        } else {
+          stack.push({ kind: "opaque" });
+        }
       }
       closedConstructorTypeName = null;
       continue;
@@ -193987,6 +194267,11 @@ function indexConstructionSites(analysis, document, root) {
         frame.slotType = null;
         frame.slotTypeRef = null;
       }
+    } else if (frame.kind === "tuple") {
+      if (token.text === ",") frame.elementIndex++;
+    } else if (frame.kind === "switch") {
+      if (token.text === "=>") frame.inResult = true;
+      else if (token.text === ",") frame.inResult = false;
     } else if (frame.kind === "call") {
       if (token.text === ",") {
         frame.argumentIndex++;
@@ -194005,6 +194290,43 @@ function indexConstructionSites(analysis, document, root) {
   sites.push({ position: previousPosition, site: snapshot() });
   return sites;
 }
+function constructionParenthesesKind(tokens, open2, ends, genericCallOpens, tupleExpected) {
+  const previous = tokens[open2 - 1];
+  const close = ends.get(open2);
+  if (previous?.kind === "identifier" || previous?.kind === "type" || [")", "]", ">", "!"].includes(previous?.text ?? "") || close !== void 0 && tokens[close + 1]?.text === "=>")
+    return null;
+  for (let index = open2 + 1; index < (close ?? tokens.length); index++) {
+    const token = tokens[index];
+    if (token.text === ",") return "tuple";
+    if (["(", "[", "{"].includes(token.text)) {
+      const end = ends.get(index);
+      if (end === void 0) return tupleExpected ? "tuple" : "group";
+      index = end;
+    } else if (token.text === "new" && tokens[index + 1]?.text !== "(") {
+      const end = new Parser(tokens, index + 1).typeEnd();
+      if (end > index + 1) index = end - 1;
+    } else {
+      const call = genericCallOpens.get(index) ?? -1;
+      if (call >= 0) index = call - 1;
+    }
+  }
+  return close === void 0 && tupleExpected ? "tuple" : "group";
+}
+function constructionGenericCallOpens(tokens) {
+  const opens = [];
+  const calls = /* @__PURE__ */ new Map();
+  for (let index = 0; index < tokens.length; index++) {
+    if (tokens[index].text === "<") opens.push(index);
+    else if (tokens[index].text === ">") {
+      const open2 = opens.pop();
+      if (open2 === void 0 || open2 === 0 || tokens[index + 1]?.text !== "(")
+        continue;
+      const end = new Parser(tokens, open2 - 1).typeEnd();
+      if (end === index + 1) calls.set(open2 - 1, end);
+    }
+  }
+  return calls;
+}
 function collectionElementType2(type2) {
   if (!type2) return null;
   if (type2.name === "List" || type2.name === "Set") {
@@ -238168,7 +238490,7 @@ var releaseWorkspaceLock = () => void 0;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.89.1");
+    console.log("0.89.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/dist/test-worker.mjs

@@ -49949,18 +49949,19 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       lexed,
       diagnostics
     );
+    const regionCalls = indexCalls(executable, executablePairs, lexed);
     const regionLocals = applySwitchSectionScopes(
       indexLocals(
         executable,
         executablePairs,
         lexed,
         diagnostics,
-        lambdaBodies
+        lambdaBodies,
+        regionCalls
       ),
       regionSwitches,
       lexed
     );
-    const regionCalls = indexCalls(executable, executablePairs, lexed);
     const declarations = new Set(
       regionLocals.map(
         (local) => `${local.nameRange.start.line}:${local.nameRange.start.character}`
@@ -50413,9 +50414,10 @@ function duplicateUnitDiagnostic(label, units, diagnostics) {
     ]
   });
 }
-function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
+function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies, calls) {
   const locals = [];
   const braceScope = braceScopeIndex(tokens, lexed.end);
+  const switchArrows = switchExpressionArrowIndexes(tokens, calls);
   for (let index = 0; index < tokens.length; index++) {
     const caught = tryParseCatchParameter(tokens, index, pairs, lexed);
     if (caught) {
@@ -50436,7 +50438,13 @@ function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
       index = loop.resumeTokenIndex;
       continue;
     }
-    const lambda = tryParseLambdaParameters(tokens, index, pairs, lexed);
+    const lambda = tryParseLambdaParameters(
+      tokens,
+      index,
+      pairs,
+      lexed,
+      switchArrows
+    );
     if (lambda) {
       locals.push(...lambda.locals);
       lambdaBodies.push(lambda.body);
@@ -50604,7 +50612,35 @@ function statementEndTokenIndex(tokens, start) {
   }
   return tokens.length;
 }
-function tryParseLambdaParameters(tokens, start, pairs, lexed) {
+function switchExpressionArrowIndexes(tokens, calls) {
+  const enclosing = enclosingOpenerIndex(tokens);
+  const inResult = /* @__PURE__ */ new Set();
+  const arrows = /* @__PURE__ */ new Set();
+  const genericEnds = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const first = call.typeArgumentTokens?.[0];
+    if (first) genericEnds.set(first.start, call.openParenOffset);
+  }
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    const genericEnd = genericEnds.get(token.start);
+    if (genericEnd !== void 0) {
+      while (tokens[index + 1] && tokens[index + 1].start < genericEnd)
+        index++;
+      continue;
+    }
+    const opener = enclosing[index];
+    if (tokens[opener]?.text !== "{" || tokens[opener - 1]?.text !== "switch")
+      continue;
+    if (token.text === ",") inResult.delete(opener);
+    else if (token.text === "=>" && !inResult.has(opener)) {
+      arrows.add(index);
+      inResult.add(opener);
+    }
+  }
+  return arrows;
+}
+function tryParseLambdaParameters(tokens, start, pairs, lexed, switchArrows) {
   const open = tokens[start];
   if (!open) return null;
   if (open.kind === "identifier") {
@@ -50612,6 +50648,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
     if (!arrow2 || arrow2.kind !== "operator" || arrow2.text !== "=>") {
       return null;
     }
+    if (switchArrows.has(start + 1)) return null;
     const body2 = lambdaBodySpan(tokens, start + 1, pairs, lexed);
     return {
       locals: [
@@ -50636,6 +50673,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
   if (closeIndex === void 0) return null;
   const arrow = tokens[closeIndex + 1];
   if (!arrow || arrow.kind !== "operator" || arrow.text !== "=>") return null;
+  if (switchArrows.has(closeIndex + 1)) return null;
   const body = lambdaBodySpan(tokens, closeIndex + 1, pairs, lexed);
   const locals = [];
   for (const [parameterIndex, [from, to]] of patternSegments(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.89.1",
+  "version": "0.89.2",
   "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.89.1 -->
+<!-- reviewed-through-cli: 0.89.2 -->
 
 # Neo Compose CLI
 

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

@@ -109,7 +109,7 @@ The marker near the top of `SKILL.md` must exactly match the package version,
 and this quoted copy is checked too:
 
 ```html
-<!-- reviewed-through-cli: 0.89.1 -->
+<!-- reviewed-through-cli: 0.89.2 -->
 ```
 
 Keep this skill on current behavior. Upgrade steps, rollout prerequisites,

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

@@ -66,6 +66,13 @@ public Reference<NeoVariant<Tree>> Look = root.Garden.Felled;
 - `Set<Reference<T>>` selections can mix bare paths and explicit references.
   Computed selections deduplicate by target identity, not by current value.
   A literal selection of fixed targets must not repeat the same target.
+  A selection literal may also evaluate its entries, for example
+  `[root.Assets.Items.First(), selected]`. Those entries must resolve to
+  existing objects; the selection evaluates when its owner is constructed.
+  A compatible `Set<T>` path is a computed selection, including a set of a
+  derived class assigned to `Set<Reference<Base>>`. Each selected object keeps
+  its identity; the selection does not acquire the source collection's row.
+  Convert a `List<T>` to a set with `.ToSet()`.
 - A bare path to an existing reference copies its current target when the
   object is constructed. Later rebinding of that source reference does not
   rebind the copy.