@neocompose/cli 0.89.0 → 0.89.2

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.0",
+      cliVersion: "0.89.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -36679,8 +36679,12 @@ var init_function_type_inference = __esm({
             const value = actual.parameterTypes[index];
             if (value !== void 0) this.add(value, expected, "exact");
           });
-        } else if (pattern.kind === "reference" && actual.kind === "reference") {
-          this.add(actual.target, pattern.target, "exact");
+        } else if (pattern.kind === "reference") {
+          this.add(
+            actual.kind === "reference" ? actual.target : actual,
+            pattern.target,
+            "exact"
+          );
         }
       }
       fix(index) {
@@ -37834,6 +37838,17 @@ var init_read_class_member = __esm({
 });
 
 // ../packages/neoscript-language/src/declared-constructors.ts
+function neoScriptCommonParameterNames(signatures) {
+  const names2 = [];
+  for (const [signatureIndex, { parameters }] of signatures.entries()) {
+    const length = Math.max(names2.length, parameters.length);
+    for (let index = 0; index < length; index++) {
+      const name = parameters[index]?.name;
+      names2[index] = signatureIndex === 0 || names2[index] === name ? name ?? null : null;
+    }
+  }
+  return names2;
+}
 function neoScriptArgumentNameSetKey(names2) {
   return [...names2].map((name) => name.toLowerCase()).sort().join(",");
 }
@@ -47001,11 +47016,14 @@ function resolveMemberForValueRow(row, ctx, visited) {
       ctx.__valueOverlay
     );
     if (parent === null) continue;
-    const parentMember = resolveMemberForValueRow(
-      parent,
-      ctx,
-      new Set(visited)
-    );
+    let parentMember = resolveMemberForValueRow(parent, ctx, new Set(visited));
+    if (parentMember?.kind === 21 /* Generic */) {
+      parentMember = substituteMember(
+        parentMember,
+        runtimeParentGenericEnv(parent, ctx, /* @__PURE__ */ new Set()),
+        ctx.vm.members
+      );
+    }
     if (parentMember !== null && isMemberTupleBase(parentMember)) {
       const memberId = parentMember.elementMemberIds[Number(link.key)];
       return memberId === void 0 ? null : evalMemberById(ctx.vm, memberId);
@@ -62517,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}`
@@ -62981,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) {
@@ -63004,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);
@@ -63165,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") {
@@ -63173,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: [
@@ -63197,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(
@@ -63402,7 +63458,9 @@ function indexCalls(tokens, pairs, lexed) {
     const name = tokens[index];
     const openIndex = callOpenParenIndex(tokens, index);
     const open2 = tokens[openIndex];
-    if (!name || name.kind !== "identifier") continue;
+    if (!name) continue;
+    const expression = [")", "]", "!"].includes(name.text) && openIndex === index + 1;
+    if (name.kind !== "identifier" && !expression) continue;
     if (!open2 || open2.kind !== "punctuation" || open2.text !== "(") continue;
     const previous = tokens[index - 1];
     const targetTyped = isContextualNew(name, previous, open2);
@@ -63431,14 +63489,19 @@ function indexCalls(tokens, pairs, lexed) {
         segmentStart = token.end;
         segmentStartIndex = cursor + 1;
       }
+      if (tokens[cursor + 1]?.text === "<") {
+        const genericOpen = callOpenParenIndex(tokens, cursor);
+        if (genericOpen >= 0) cursor = genericOpen - 1;
+      }
     }
     if (segmentStart < (close?.start ?? lexed.end)) {
       ranges.push(lexed.source.range(segmentStart, close?.start ?? lexed.end));
       names2.push(callArgumentLabel(tokens, segmentStartIndex, limit));
     }
+    const namedKind = contextualKeyword ? "constructor" : "function";
     calls.push({
-      kind: contextualKeyword ? "constructor" : "function",
-      name: name.text,
+      kind: expression ? "expression" : namedKind,
+      name: expression ? "delegate" : name.text,
       nameRange: name.range,
       ...contextualKeyword ? { contextualKeywordRange: contextualKeyword.range } : {},
       ...targetTyped ? { targetTyped: true } : {},
@@ -67495,6 +67558,7 @@ function weighedLambda(probes, expected) {
   if (probe === void 0 || probe.type.kind !== "delegate") return void 0;
   if (probe.needsReturnContext !== true && sameCompilationType(probe.type.returnType, expected.returnType))
     return probe;
+  if (expected.returnType.kind === "reference") return void 0;
   return probe.retype?.(expected.returnType);
 }
 function replaceReturns(instructions, replaced) {
@@ -67616,6 +67680,9 @@ function andList(texts) {
   if (texts.length <= 2) return texts.join(" and ");
   return `${texts.slice(0, -1).join(", ")}, and ${texts[texts.length - 1]}`;
 }
+function isContextualReferenceExpression(expression) {
+  return expression.kind === "conditional" || expression.kind === "switchExpression" || expression.kind === "coalesce" || expression.kind === "annotated";
+}
 function isPureArgument(expression) {
   switch (expression.kind) {
     case "litInt":
@@ -68432,6 +68499,10 @@ var init_strict_resolver = __esm({
         if (expected === void 0) return;
         this.requireAssignable(resolved.type, expected, expression.pos, "value");
       }
+      /** Type a source expression with the same call binding rules as executable code. */
+      resolveExpressionType(expression) {
+        return this.resolveExpression(expression, this.initialScope()).type;
+      }
       persistedListenerCompletions(receiver, expected) {
         const scope = this.initialScope();
         let receiverType = this.context.thisClass;
@@ -70698,8 +70769,7 @@ var init_strict_resolver = __esm({
             );
         }
       }
-      resolveMemberRowOf(place, scope) {
-        const optional2 = place.optional === true;
+      resolveMemberRowOf(place, scope, resolved) {
         if ((this.context.kind === "initializer" || this.context.kind === "initializerExpression") && this.delegateCaptureContexts.length === 0 && referencePlaceRoot(place) === "this") {
           const text = referencePlaceText(place) ?? "this";
           throw new CompileError(
@@ -70707,12 +70777,12 @@ var init_strict_resolver = __esm({
             place.pos
           );
         }
-        const slot = this.resolveMemberNatural(
+        const slot = resolved ?? this.resolveMemberNatural(
           place.receiver,
           place.name,
           scope,
           place.pos,
-          optional2
+          place.optional === true
         );
         const member = slot.symbol;
         if (member === void 0) {
@@ -70730,19 +70800,55 @@ var init_strict_resolver = __esm({
             place.pos
           );
         }
-        const read = slot.optionalChainType ?? slot.type;
-        const stored = member.lookup !== void 0 && member.lookup.multiselect !== true && read.kind !== "reference" ? {
-          kind: "reference",
-          target: { ...read, nullable: false },
-          ...isNullable(read) ? { nullable: true } : {}
-        } : read;
-        const type2 = this.referenceType(stored, optional2);
+        const type2 = this.memberReferenceType(slot, place.optional === true);
         if (type2.kind !== "reference") return slot;
         return {
           pointer: { type: "rowOf" /* RowOf */, place: slot.pointer },
           type: type2
         };
       }
+      memberReferenceType(slot, optional2) {
+        const read = slot.storedType ?? slot.optionalChainType ?? slot.type;
+        const stored = slot.symbol?.lookup !== void 0 && slot.symbol.lookup.multiselect !== true && read.kind !== "reference" ? {
+          kind: "reference",
+          target: { ...read, nullable: false },
+          ...isNullable(read) ? { nullable: true } : {}
+        } : read;
+        return this.referenceType(
+          stored,
+          optional2 || slot.optionalChainType !== void 0
+        );
+      }
+      /** Only stored member slots can acquire a reference from an expected type. */
+      implicitReferenceType(expression, value) {
+        if (expression.kind !== "member") return void 0;
+        if (value.symbol === void 0 || value.symbol.computed === true)
+          return void 0;
+        return this.memberReferenceType(value, expression.optional === true);
+      }
+      referenceInferenceType(expression, value, pattern) {
+        const read = this.readReferences(value, pattern).type;
+        if (pattern.kind !== "reference" || read.kind === "reference") return read;
+        return this.implicitReferenceType(expression, value) ?? read;
+      }
+      contextualReferenceType(expression, value, expected) {
+        const read = this.readReferences(value, expected).type;
+        if (expected.kind !== "reference" || isNeoScriptTypeAssignable(read, expected, this.project))
+          return read;
+        const reference2 = this.implicitReferenceType(expression, value);
+        return reference2 !== void 0 && isNeoScriptTypeAssignable(reference2, expected, this.project) ? reference2 : read;
+      }
+      /** Use the same slot identity for explicit and expected-type references. */
+      contextualReference(expression, value, scope, expected) {
+        const read = this.readReferences(value, expected);
+        if (expected?.kind !== "reference" || isNeoScriptTypeAssignable(read.type, expected, this.project))
+          return read;
+        const reference2 = this.implicitReferenceType(expression, value);
+        if (expression.kind === "member" && reference2 !== void 0 && isNeoScriptTypeAssignable(reference2, expected, this.project)) {
+          return this.resolveMemberRowOf(expression, scope, value);
+        }
+        return read;
+      }
       /** Whether assigning `target` rebinds a reference to a handle. */
       holdsHandleReference(target) {
         if (target.type.kind === "reference") {
@@ -71351,13 +71457,15 @@ var init_strict_resolver = __esm({
         });
       }
       resolveExpression(expression, scope, expected, convertSequence = true) {
-        const value = this.readReferences(
+        const value = this.contextualReference(
+          expression,
           this.resolveReferenceExpression(
             expression,
             scope,
             expected,
             convertSequence
           ),
+          scope,
           expected
         );
         return convertSequence ? this.convertSequence(value, expected) : value;
@@ -72879,7 +72987,8 @@ var init_strict_resolver = __esm({
           }
           entryType = common;
         }
-        if (expected?.kind === "set" && this.context.kind === "initializer") {
+        const referenceSelection = expected?.kind === "set" && this.context.kind === "initializer" && (expected.elementType.kind === "reference" || hasReferenceEquality(expected.elementType, this.project));
+        if (expected?.kind === "set" && this.context.kind === "initializer" && !referenceSelection) {
           const element = expected.elementType;
           const spelling = element.kind === "named" && this.project.typeById.get(element.typeId)?.kind === "enum" ? `.Option or ${this.describe({ ...element, nullable: false })}.Option values` : "literal values";
           throw new CompileError(
@@ -72897,7 +73006,7 @@ var init_strict_resolver = __esm({
             "NeoScript strict compiler produced a non-list wire type for a list literal."
           );
         }
-        return {
+        const list = {
           pointer: {
             type: "listLiteral" /* ListLiteral */,
             typeInfo: wire,
@@ -72906,6 +73015,18 @@ var init_strict_resolver = __esm({
           type: type2,
           entries: resolved
         };
+        return referenceSelection ? this.resolveCollectionQuery(
+          list,
+          {
+            kind: "list",
+            keyType: { kind: "primitive", name: "int" },
+            valueType: entryType
+          },
+          "ToSet",
+          [],
+          scope,
+          pos
+        ) : list;
       }
       resolveDictionaryLiteral(entries, scope, expected, pos) {
         const expectedDictionary = expected?.kind === "dictionary" ? expected : void 0;
@@ -73616,7 +73737,12 @@ var init_strict_resolver = __esm({
             const rootEntry = scope.lookupFlowRoot(pathRoot(path));
             if (rootEntry) {
               const narrowed = scope.lookupNarrowedType(path, rootEntry);
-              if (narrowed) resolved = { ...resolved, type: narrowed };
+              if (narrowed)
+                resolved = {
+                  ...resolved,
+                  storedType: resolved.type,
+                  type: narrowed
+                };
             }
           }
         }
@@ -76335,17 +76461,28 @@ var init_strict_resolver = __esm({
           args,
           scope
         );
-        return resolveNeoScriptDeclaredConstructorOverload(
+        const resolve8 = (implicit) => resolveNeoScriptDeclaredConstructorOverload(
           declared,
           named.map((name, index) => {
             const inferred = inferredTypes?.[index];
-            if (!inferred) return { name };
+            const argument2 = args[index];
+            if (!inferred || !argument2) return { name };
             return {
               name,
-              matchesParameter: (parameter4) => isNeoScriptTypeAssignable(inferred, parameter4.type, this.project)
+              matchesParameter: (parameter4) => implicit && parameter4.type.kind === "reference" && isContextualReferenceExpression(argument2) ? this.targetTypedArgumentFits(argument2, parameter4.type, scope) : isNeoScriptTypeAssignable(
+                implicit ? this.contextualReferenceType(
+                  argument2,
+                  inferred,
+                  parameter4.type
+                ) : inferred.type,
+                parameter4.type,
+                this.project
+              )
             };
           })
         );
+        const direct = resolve8(false);
+        return direct.kind === "ambiguous" ? resolve8(true) : direct;
       }
       /**
        * Types for the §6.1.1 step-2 tie-break, computed only when several
@@ -76366,7 +76503,9 @@ var init_strict_resolver = __esm({
           const argument2 = args[index];
           if (!argument2) return null;
           try {
-            return this.resolveExpression(argument2, scope).type;
+            if (isContextualReferenceExpression(argument2))
+              this.typeOverloadEntries(argument2, scope);
+            return this.resolveReferenceExpression(argument2, scope);
           } catch (error) {
             if (error instanceof CompileError) return null;
             throw error;
@@ -76736,7 +76875,8 @@ var init_strict_resolver = __esm({
           (argument2) => this.overloadArgumentKind(argument2, scope)
         );
         argumentsList2.forEach((argument2, index) => {
-          if (kinds[index] !== "typed") this.typeOverloadEntries(argument2, scope);
+          if (kinds[index] !== "typed" || isContextualReferenceExpression(argument2))
+            this.typeOverloadEntries(argument2, scope);
         });
         const typed = argumentsList2.map(
           (argument2, index) => kinds[index] === "targetTyped" ? void 0 : this.resolveReferenceExpression(argument2, scope)
@@ -76784,11 +76924,11 @@ var init_strict_resolver = __esm({
           const fits = argumentsList2.every((argument2, index) => {
             const parameter4 = requiredAt(parameters, index).type;
             const resolved = typed[index];
-            if (resolved === void 0 || argument2.kind === "tuple" || kinds[index] === "numeric" && parameter4.kind === "tuple") {
+            if (resolved === void 0 || parameter4.kind === "reference" && isContextualReferenceExpression(argument2) || argument2.kind === "tuple" || kinds[index] === "numeric" && parameter4.kind === "tuple") {
               return this.targetTypedArgumentFits(argument2, parameter4, scope);
             }
             return this.typedArgumentFits(
-              this.readReferences(resolved, parameter4).type,
+              this.contextualReferenceType(argument2, resolved, parameter4),
               requiredAt(kinds, index),
               parameter4
             );
@@ -76960,6 +77100,12 @@ var init_strict_resolver = __esm({
           }
           case "annotated":
             return this.entryFits(argument2.expression, parameter4, scope);
+          case "coalesce":
+            return this.entryFits(
+              argument2.left,
+              { ...parameter4, nullable: true },
+              scope
+            ) && this.entryFits(argument2.right, parameter4, scope);
           case "conditional": {
             const { trueScope, falseScope } = this.conditionalBranchScopes(
               argument2,
@@ -77039,12 +77185,12 @@ var init_strict_resolver = __esm({
        */
       entryFits(argument2, parameter4, scope) {
         const kind = this.overloadArgumentKind(argument2, scope);
-        if (kind === "targetTyped" || argument2.kind === "tuple" || kind === "numeric" && parameter4.kind === "tuple") {
+        if (kind === "targetTyped" || parameter4.kind === "reference" && isContextualReferenceExpression(argument2) || argument2.kind === "tuple" || kind === "numeric" && parameter4.kind === "tuple") {
           return this.targetTypedArgumentFits(argument2, parameter4, scope);
         }
-        const resolved = isPureArgument(argument2) ? this.resolveExpression(argument2, scope) : this.overloadEntries.get(argument2) ?? this.resolveReferenceExpression(argument2, scope);
+        const resolved = isPureArgument(argument2) ? this.resolveReferenceExpression(argument2, scope) : this.overloadEntries.get(argument2) ?? this.resolveReferenceExpression(argument2, scope);
         return this.typedArgumentFits(
-          this.readReferences(resolved, parameter4).type,
+          this.contextualReferenceType(argument2, resolved, parameter4),
           kind,
           parameter4
         );
@@ -77087,6 +77233,10 @@ var init_strict_resolver = __esm({
           case "annotated":
             visit(argument2.expression, scope);
             return;
+          case "coalesce":
+            visit(argument2.left, scope);
+            visit(argument2.right, scope);
+            return;
           case "conditional": {
             visit(argument2.condition, scope);
             const { trueScope, falseScope } = this.conditionalBranchScopes(
@@ -77271,19 +77421,16 @@ var init_strict_resolver = __esm({
           pos,
           inferred?.typeArguments
         );
-        if (signature2.typeArguments.length > 0)
-          this.options.onCallResolved?.(pos, {
-            ...symbol,
-            type: signature2.returnType,
-            returnType: signature2.returnType,
-            parameters: signature2.parameters,
-            typeParameters: (symbol.typeParameters ?? []).map(
-              (parameter4, index) => ({
-                ...parameter4,
-                type: requiredAt(signature2.typeArguments, index)
-              })
-            )
-          });
+        this.options.onCallResolved?.(pos, {
+          ...symbol,
+          type: signature2.returnType,
+          returnType: signature2.returnType,
+          parameters: signature2.parameters,
+          typeParameters: (symbol.typeParameters ?? []).map((parameter4, index) => ({
+            ...parameter4,
+            type: requiredAt(signature2.typeArguments, index)
+          }))
+        });
         const wireTypeArguments = signature2.typeArguments.length ? {
           typeArguments: signature2.typeArguments.map(
             (argument2) => toWireType(argument2, this.project)
@@ -77458,7 +77605,12 @@ var init_strict_resolver = __esm({
           const prior = choice?.preResolved[index];
           const cached = inferred?.resolved.get(argument2);
           let resolved;
-          if (prior !== void 0) resolved = this.readReferences(prior, target);
+          if (prior !== void 0 && !(target?.kind === "reference" && isContextualReferenceExpression(argument2) && !isNeoScriptTypeAssignable(
+            this.readReferences(prior, target).type,
+            target,
+            this.project
+          )))
+            resolved = this.readReferences(prior, target);
           else if (cached && (sameCompilationType(cached.type, expected) || cached.pointer.type === "callFunction" /* CallFunction */)) {
             resolved = cached;
           } else {
@@ -77467,6 +77619,7 @@ var init_strict_resolver = __esm({
             const compile = () => this.resolveExpression(argument2, scope, target);
             resolved = weighed ?? (argument2.kind === "lambda" && lambdas ? this.inLambdaFrame(lambdas, argument2, compile) : compile());
           }
+          resolved = this.contextualReference(argument2, resolved, scope, target);
           resolved = this.convertSequence(resolved, target);
           if (!isUnknown(expected)) {
             this.requireReferenceArgument(
@@ -77541,7 +77694,10 @@ var init_strict_resolver = __esm({
           if (!hasIndependentTypeEvidence(argument2)) return;
           const prior = weighed?.typed[index];
           if (prior !== void 0) {
-            inference.add(this.readReferences(prior, void 0).type, pattern);
+            inference.add(
+              this.referenceInferenceType(argument2, prior, pattern),
+              pattern
+            );
             return;
           }
           const group = pattern.kind === "delegate" ? this.inferredMethodGroupTarget(argument2, probe) : null;
@@ -77552,10 +77708,13 @@ var init_strict_resolver = __esm({
               pattern
             );
           } else {
-            const resolved = weighed?.contextless.get(argument2) ?? this.resolveExpression(argument2, probe);
+            const resolved = weighed?.contextless.get(argument2) ?? this.resolveReferenceExpression(argument2, probe);
             weighed?.contextless.set(argument2, resolved);
             resolvedArguments.set(argument2, resolved);
-            inference.add(resolved.type, pattern);
+            inference.add(
+              this.referenceInferenceType(argument2, resolved, pattern),
+              pattern
+            );
           }
         });
         const error = inference.solve(callbacks, (callback, inputs) => {
@@ -80625,7 +80784,7 @@ var init_strict_resolver = __esm({
         }
         return canonicalPath(target) ?? "the slot";
       }
-      /** P112 §3.1. A value never converts to a reference, since it has no row. */
+      /** A transient value has no stored slot to pass by reference. */
       requireReferenceArgument(source, target, parameter4, pos) {
         if (target.kind !== "reference") return;
         if (source.kind === "reference") return;
@@ -80634,7 +80793,7 @@ var init_strict_resolver = __esm({
         const value = this.describe(source);
         const article = /^[aeiou]/i.test(value) ? "an" : "a";
         throw new CompileError(
-          `Argument \`${parameter4}\` needs a ${this.describe(target)}, not ${article} ${value}. Wrap a member path in Reference() to pass a stored ${this.describe(read)}.`,
+          `Argument \`${parameter4}\` needs a ${this.describe(target)}, not ${article} ${value}. Pass a stored ${this.describe(read)} member instead.`,
           pos
         );
       }
@@ -81988,7 +82147,8 @@ function neoSourceTypeText(type2) {
 }
 function referenceReadType(type2) {
   const target = type2.name === "Reference" ? type2.typeArguments[0] : void 0;
-  if (target !== void 0) return { ...target, nullable: type2.nullable };
+  if (target !== void 0)
+    return { ...target, nullable: type2.nullable || target.nullable };
   const element = type2.name === "Set" ? type2.typeArguments[0] : void 0;
   if (element?.name !== "Reference" || element.typeArguments.length === 0) {
     return type2;
@@ -83130,7 +83290,7 @@ var init_project_source_parser = __esm({
             ...value ? { value } : {},
             range: rangeFrom(optionStart, end)
           });
-          if (!this.eat(",") && !this.at("}")) {
+          if (!this.eat(",") && !this.at("}") && !this.done()) {
             throw this.failure(
               "enum-option-separator",
               "Enum options must be separated by a comma.",
@@ -83138,7 +83298,7 @@ var init_project_source_parser = __esm({
             );
           }
         }
-        const close = this.expect("}");
+        const close = this.expectClosingBrace();
         return {
           kind: "enum",
           annotations,
@@ -83344,7 +83504,12 @@ var init_project_source_parser = __esm({
           }
           if (this.cursor === start) this.cursor++;
         }
-        return { members: members2, constructors, initBlocks, close: this.expect("}") };
+        return {
+          members: members2,
+          constructors,
+          initBlocks,
+          close: this.expectClosingBrace()
+        };
       }
       parseMember(ownerName, ownerKind) {
         const start = this.peek();
@@ -83817,16 +83982,19 @@ var init_project_source_parser = __esm({
           if (token.text === "}") depth--;
         }
         if (depth !== 0) {
-          throw this.failure(
-            "unclosed-source-body",
-            "Unclosed source body; add `}`.",
-            open2
+          this.report(
+            this.failure(
+              "unclosed-source-body",
+              "Unclosed source body; add `}`.",
+              open2
+            )
           );
         }
-        const close = this.previous();
+        const close = depth === 0 ? this.previous() : this.peek();
         return {
           text: this.source.text.slice(open2.start, close.end),
-          range: rangeFrom(open2, close)
+          range: rangeFrom(open2, close),
+          ...depth === 0 ? {} : { unclosed: true }
         };
       }
       /**
@@ -83838,21 +84006,24 @@ var init_project_source_parser = __esm({
         const arrow = this.expect("=>");
         const expression = this.captureUntilTopLevel(/* @__PURE__ */ new Set([";"]), true);
         if (expression.text.trim().length === 0) {
-          throw this.failure(
+          const error = this.failure(
             "empty-expression-body",
             `An expression-bodied ${label} needs an expression after \`=>\`.`,
             this.peek()
           );
+          if (!this.done()) throw error;
+          this.report(error);
         }
-        const close = this.previous();
+        const close = this.done() ? this.peek() : this.previous();
         if (!this.at(";")) {
-          throw this.failure(
+          const error = this.failure(
             "unterminated-expression-body",
             `An expression-bodied ${label} must end with \`;\`.`,
             this.peek()
           );
-        }
-        this.next();
+          if (!this.done()) throw error;
+          this.report(error);
+        } else this.next();
         return {
           text: this.source.text.slice(arrow.start, close.end),
           range: rangeFrom(arrow, close),
@@ -83888,7 +84059,7 @@ var init_project_source_parser = __esm({
         if (this.cursor === startCursor) {
           return { text: "", range: start.range };
         }
-        const end = this.previous();
+        const end = this.done() ? this.peek() : this.previous();
         return {
           text: this.source.text.slice(start.start, end.end),
           range: rangeFrom(start, end)
@@ -83959,6 +84130,19 @@ var init_project_source_parser = __esm({
           message
         });
       }
+      /** Keep declarations and their editor scope when only the closing brace is missing. */
+      expectClosingBrace() {
+        if (!this.done()) return this.expect("}");
+        const end = this.peek();
+        this.report(
+          this.failure(
+            "unexpected-source-token",
+            `Expected \`}\`, but found ${describe2(end)}.`,
+            end
+          )
+        );
+        return end;
+      }
       expect(text) {
         if (!this.at(text)) {
           throw this.failure(
@@ -95467,49 +95651,65 @@ function annotationContextForDeclaration(declaration) {
   return { kind: "schema" };
 }
 function contextualAnnotationFields(document, position) {
-  for (const declaration of document.declarations) {
-    const declarationAnnotation = declaration.annotations.find(
-      (annotation2) => inAnnotationArguments(annotation2, position)
-    );
-    if (declarationAnnotation) {
-      return fieldsForAnnotation(
-        declarationAnnotation.name,
-        annotationContextForDeclaration(declaration)
-      );
+  return contextualAnnotationSite(document, position)?.fields ?? null;
+}
+function contextualAnnotationSite(document, position) {
+  let sites = ANNOTATION_SITES.get(document);
+  if (!sites) {
+    sites = collectAnnotationSites(document);
+    ANNOTATION_SITES.set(document, sites);
+  }
+  let low = 0;
+  let high = sites.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (compare(sites[middle].annotation.range.end, position) < 0)
+      low = middle + 1;
+    else high = middle;
+  }
+  const site = sites[low];
+  return site && inAnnotationArguments(site.annotation, position) ? site : null;
+}
+function collectAnnotationSites(document) {
+  const sites = [];
+  const add = (annotations, context, type2) => {
+    for (const annotation2 of annotations) {
+      const fields = fieldsForAnnotation(annotation2.name, context);
+      if (fields) sites.push({ annotation: annotation2, fields, ...type2 ? { type: type2 } : {} });
     }
+  };
+  const addType = (type2) => {
+    if (type2.annotations.length > 0)
+      add(type2.annotations, { kind: "type", type: semanticType(type2) }, type2);
+    for (const argument2 of type2.typeArguments) addType(argument2);
+  };
+  for (const declaration of document.declarations) {
+    add(declaration.annotations, annotationContextForDeclaration(declaration));
     if (declaration.kind === "global") continue;
     if (declaration.kind === "enum") {
-      for (const option of declaration.options) {
-        const annotation2 = option.annotations.find(
-          (candidate) => inAnnotationArguments(candidate, position)
-        );
-        if (annotation2)
-          return fieldsForAnnotation(annotation2.name, { kind: "schema" });
-      }
+      for (const option of declaration.options)
+        add(option.annotations, { kind: "schema" });
       continue;
     }
     for (const member of declaration.members) {
-      const annotation2 = member.annotations.find(
-        (candidate) => inAnnotationArguments(candidate, position)
-      );
-      if (annotation2) {
-        return fieldsForAnnotation(annotation2.name, {
-          kind: "member",
-          ownerName: declaration.name,
-          type: semanticType(member.type),
-          memberKind: member.kind
-        });
-      }
-      const typeAnnotation = findTypeAnnotation(member.type, position);
-      if (typeAnnotation) {
-        return fieldsForAnnotation(typeAnnotation.annotation.name, {
-          kind: "type",
-          type: semanticType(typeAnnotation.type)
-        });
-      }
+      if (member.annotations.length > 0)
+        add(
+          member.annotations,
+          {
+            kind: "member",
+            ownerName: declaration.name,
+            type: semanticType(member.type),
+            memberKind: member.kind,
+            reference: member.type.name === "Reference"
+          },
+          member.type
+        );
+      addType(member.type);
     }
   }
-  return null;
+  return sites.sort(
+    (left, right) => compare(left.annotation.range.start, right.annotation.range.start)
+  );
 }
 function generatedContractEnumCases(type2) {
   const element = /^(?:IReadOnly)?List<(.+)>$/.exec(type2)?.[1];
@@ -95525,7 +95725,6 @@ function createEnvironment(documents, project) {
   const enums = /* @__PURE__ */ new Map();
   const types = /* @__PURE__ */ new Map();
   const globals = /* @__PURE__ */ new Map();
-  const mutableFunctions = /* @__PURE__ */ new Map();
   const referenceTargets = /* @__PURE__ */ new Map();
   for (const [name, options] of Object.entries(
     NEO_PROJECT_SOURCE_RECORD_CONTRACT.enums
@@ -95570,17 +95769,6 @@ function createEnvironment(documents, project) {
           }
         }
       }
-      for (const member of declaration.members) {
-        if (member.kind !== "function") continue;
-        const signatures = mutableFunctions.get(member.name) ?? [];
-        signatures.push({
-          parameters: member.parameters.map(
-            (parameter4) => semanticType(parameter4.type)
-          ),
-          returnType: semanticType(member.type)
-        });
-        mutableFunctions.set(member.name, signatures);
-      }
     }
   }
   return {
@@ -95593,7 +95781,8 @@ function createEnvironment(documents, project) {
     enums,
     types,
     globals,
-    functions: mutableFunctions,
+    callBindings: /* @__PURE__ */ new WeakMap(),
+    callScopes: /* @__PURE__ */ new WeakMap(),
     referenceTargets,
     variantScopes: buildNeoVariantScopeIndex(documents),
     construction: buildNeoConstructionIndex(documents)
@@ -95771,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);
@@ -96004,6 +96195,7 @@ function validateFlowContent(uri, content, parentScope, environment, diagnostics
   for (const binding of content.bindings) {
     const type2 = parseTypeText(binding.typeText);
     scope.set(binding.name, type2);
+    environment.callScopes.delete(scope);
     validateAnnotations(
       uri,
       binding.annotations,
@@ -96758,7 +96950,10 @@ function validateStatements(statements, returnType, scope, environment, uri, ran
         diagnostics
       );
       const inferred = declared ?? inferExpressionType(statement.init, scope, environment);
-      if (inferred) scope.set(statement.name, inferred);
+      if (inferred) {
+        scope.set(statement.name, inferred);
+        environment.callScopes.delete(scope);
+      }
     } else if (statement.kind === "assign") {
       const target = inferExpressionType(statement.target, scope, environment);
       if (statement.value)
@@ -96889,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,
@@ -97541,7 +97751,18 @@ function validateExpression(expression, expected, scope, environment, uri, range
       );
       return;
     }
-    const parameters = callParameters(expression.callee, scope, environment);
+    const binding = sourceCallBinding(expression, scope, environment);
+    if (binding?.error?.message.replace(/^\d+:\d+: /, "").startsWith("No overload of ")) {
+      pushDiagnostic(
+        diagnostics,
+        uri,
+        anchor ? anchorSpan(anchor, binding.error, 1) : range2,
+        "invalid-function-call",
+        binding.error.message.replace(/^\d+:\d+: /, "")
+      );
+      return;
+    }
+    const parameters = callParameters(expression, scope, environment);
     expression.args.forEach((argument2, index) => {
       const name = expression.argumentNames?.[index];
       const parameter4 = name === void 0 || name === null ? parameters?.[index] : parameters?.find((candidate) => candidate.name === name);
@@ -98000,6 +98221,16 @@ function semanticAst(type2, pos) {
     return { ...common, kind: "primitive", name: type2.name };
   }
   const args = type2.arguments ?? [];
+  if (type2.name === "")
+    return {
+      ...common,
+      kind: "tuple",
+      elements: args.map((argument2, index) => ({
+        pos,
+        type: semanticAst(argument2, pos),
+        ...type2.tupleNames?.[index] ? { name: type2.tupleNames[index] } : {}
+      }))
+    };
   if ((type2.name === "List" || type2.name === "Set") && args[0]) {
     return {
       ...common,
@@ -98385,34 +98616,192 @@ function inferExpressionType(expression, scope, environment) {
       const argument2 = expression.args[0];
       return argument2 === void 0 ? void 0 : inferExpressionType(argument2, scope, environment);
     }
-    return environment.functions.get(expression.callee.name)?.[0]?.returnType;
+  }
+  if (expression.kind === "call") {
+    const binding = sourceCallBinding(expression, scope, environment);
+    if (binding?.returnType) return binding.returnType;
+    const member = sourceCallMember(expression.callee, scope, environment);
+    if (member?.member.kind === "function") {
+      const bindings = new Map(member.bindings);
+      for (const [
+        index,
+        parameter4
+      ] of member.member.genericParameters.entries()) {
+        const argument2 = expression.typeArguments?.[index];
+        if (!argument2) return void 0;
+        bindings.set(parameter4.name, semanticAstType(argument2));
+      }
+      return substituteSemanticType(semanticType(member.member.type), bindings);
+    }
+    if (member === null) return void 0;
+    const callee = inferExpressionType(expression.callee, scope, environment);
+    return callee?.name === "NeoDelegate" ? callee.arguments?.[0] : void 0;
   }
   return void 0;
 }
-function callParameters(callee, scope, environment) {
-  if (callee.kind === "ident") {
-    return environment.functions.get(callee.name)?.[0]?.parameters.map((type2) => ({ name: null, type: type2 }));
+function sourceCallBinding(expression, scope, environment) {
+  const cached = environment.callBindings.get(expression);
+  if (cached?.scope === scope) return cached.binding;
+  let entry = environment.callScopes.get(scope);
+  if (!entry) {
+    const owner = environment.types.get(scope.get("this")?.name ?? "");
+    const { context } = initializerResolver(
+      environment,
+      owner?.name ?? "",
+      false
+    );
+    const names2 = new Set(scope.keys());
+    names2.delete("this");
+    names2.delete("root");
+    for (const member of owner?.members ?? []) {
+      if (member.kind === "function") names2.delete(member.name);
+    }
+    entry = { context, names: names2, types: /* @__PURE__ */ new Map() };
+    environment.callScopes.set(scope, entry);
+  }
+  const parameters = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { name } of collectIdentifierReads(expression, entry.names)) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (!entry.types.has(name))
+      entry.types.set(
+        name,
+        semanticTypeRef(scope.get(name), scope, environment)
+      );
+    const type2 = entry.types.get(name);
+    if (type2) parameters.push({ name, type: type2 });
+  }
+  let symbol;
+  const resolver = new StrictNeoScriptResolver(
+    { ...entry.context, kind: "function", parameters },
+    environment.projectIndex,
+    void 0,
+    {
+      onCallResolved(pos, resolved) {
+        if (pos === expression.pos) symbol = resolved;
+      }
+    }
+  );
+  let binding;
+  try {
+    const type2 = resolver.resolveExpressionType(expression);
+    binding = {
+      returnType: semanticResolvedType(type2, environment.projectIndex),
+      ...symbol?.parameters ? {
+        parameters: symbol.parameters.map((parameter4) => ({
+          name: parameter4.name,
+          type: semanticResolvedType(
+            parameter4.type,
+            environment.projectIndex
+          )
+        }))
+      } : {}
+    };
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+    binding = { error };
   }
-  if (callee.kind !== "member") return void 0;
-  const receiverType = inferExpressionType(callee.receiver, scope, environment);
-  const staticDeclaration = receiverType === void 0 && callee.receiver.kind === "ident" ? environment.types.get(callee.receiver.name) : void 0;
-  let owner = staticDeclaration ?? (receiverType && environment.types.get(receiverType.name));
+  environment.callBindings.set(expression, { scope, binding });
+  return binding;
+}
+function semanticResolvedType(type2, project, read = true) {
+  const child2 = (type3) => semanticResolvedType(type3, project, false);
+  if (read && type2.kind === "reference")
+    return semanticResolvedType(
+      {
+        ...type2.target,
+        nullable: type2.nullable === true || type2.target.nullable === true
+      },
+      project
+    );
+  if (read && type2.kind === "set" && type2.elementType.kind === "reference")
+    return {
+      name: "Set",
+      nullable: type2.nullable === true,
+      arguments: [semanticResolvedType(type2.elementType, project)]
+    };
+  const nullable2 = type2.nullable === true;
+  switch (type2.kind) {
+    case "primitive":
+      return { name: type2.name, nullable: nullable2 };
+    case "typeParameter":
+      return { name: type2.name, nullable: nullable2 };
+    case "named":
+      return {
+        name: project.typeById.get(type2.typeId)?.name ?? type2.typeId,
+        nullable: nullable2,
+        arguments: (type2.typeArguments ?? []).map(child2)
+      };
+    case "tuple":
+      return {
+        name: "",
+        nullable: nullable2,
+        arguments: type2.elements.map((element) => child2(element.type)),
+        tupleNames: type2.elements.map((element) => element.name)
+      };
+    case "list":
+      return { name: "List", nullable: nullable2, arguments: [child2(type2.elementType)] };
+    case "set":
+      return { name: "Set", nullable: nullable2, arguments: [child2(type2.elementType)] };
+    case "dictionary":
+      return {
+        name: "Dictionary",
+        nullable: nullable2,
+        arguments: [child2(type2.keyType), child2(type2.valueType)]
+      };
+    case "reference":
+      return { name: "Reference", nullable: nullable2, arguments: [child2(type2.target)] };
+    case "delegate":
+      return {
+        name: "NeoDelegate",
+        nullable: nullable2,
+        arguments: [child2(type2.returnType), ...type2.parameterTypes.map(child2)]
+      };
+    case "action":
+      return {
+        name: "NeoAction",
+        nullable: nullable2,
+        arguments: type2.parameterTypes.map(child2)
+      };
+  }
+}
+function sourceCallMember(callee, scope, environment) {
+  if (callee.kind !== "ident" && callee.kind !== "member") return void 0;
+  const receiver = callee.kind === "ident" ? scope.get("this") : inferExpressionType(callee.receiver, scope, environment);
+  const staticDeclaration = !receiver && callee.kind === "member" && callee.receiver.kind === "ident" ? environment.types.get(callee.receiver.name) : void 0;
+  let owner = staticDeclaration ?? (receiver && environment.types.get(receiver.name));
   const visited = /* @__PURE__ */ new Set();
   let functionCount = 0;
-  while (owner !== void 0 && !visited.has(owner.name)) {
+  while (owner && !visited.has(owner.name)) {
     visited.add(owner.name);
-    for (const member of owner.members) {
-      if (member.name === callee.name && member.kind === "function")
+    for (const member2 of owner.members) {
+      if (member2.name === callee.name && member2.kind === "function")
         functionCount++;
     }
-    if (functionCount > 1) return void 0;
+    if (functionCount > 1) return null;
     const base = owner.baseTypes.find(
       (type2) => environment.types.has(type2.name)
     );
     owner = base && environment.types.get(base.name);
   }
-  const resolved = staticDeclaration === void 0 ? receiverType === void 0 ? void 0 : sourceClassMemberForType(receiverType, callee.name, environment) : sourceClassMemberByName(staticDeclaration, callee.name, environment);
-  if (resolved?.member.kind !== "function") return void 0;
+  const member = receiver ? sourceClassMemberForType(receiver, callee.name, environment) : staticDeclaration && sourceClassMemberByName(staticDeclaration, callee.name, environment);
+  return !staticDeclaration || member?.member.modifiers.includes("static") ? member : void 0;
+}
+function callParameters(expression, scope, environment) {
+  const binding = sourceCallBinding(expression, scope, environment);
+  if (binding?.parameters) return binding.parameters;
+  const callee = expression.callee;
+  if (callee.kind !== "member" && callee.kind !== "ident")
+    return delegateCallParameters(
+      inferExpressionType(callee, scope, environment)
+    );
+  const resolved = sourceCallMember(callee, scope, environment);
+  if (resolved === null) return void 0;
+  if (resolved?.member.kind !== "function")
+    return delegateCallParameters(
+      inferExpressionType(callee, scope, environment)
+    );
   return resolved.member.parameters.map((parameter4) => ({
     name: parameter4.name,
     type: substituteSemanticType(
@@ -98421,6 +98810,9 @@ function callParameters(callee, scope, environment) {
     )
   }));
 }
+function delegateCallParameters(type2) {
+  return type2?.name === "NeoDelegate" ? type2.arguments?.slice(1).map((type3) => ({ name: null, type: type3 })) : void 0;
+}
 function semanticMemberType(member, environment, bindings = /* @__PURE__ */ new Map()) {
   const type2 = substituteSemanticType(semanticType(member.type), bindings);
   if (type2.name !== "List") return type2;
@@ -98658,21 +99050,23 @@ function matchingDeclaredConstructor(declaration, argumentNames) {
   return neoScriptNamedCallSignature(declaration.constructors, argumentNames) ?? null;
 }
 function semanticType(type2) {
+  const read = referenceReadType(type2);
+  return read === type2 ? declaredSemanticType(type2) : semanticType(read);
+}
+function declaredSemanticType(type2) {
   if (type2.tupleElements)
     return {
       name: "",
       nullable: type2.nullable,
       arguments: type2.tupleElements.map(
-        (element) => semanticType(element.type)
+        (element) => declaredSemanticType(element.type)
       ),
       tupleNames: type2.tupleElements.map((element) => element.name)
     };
-  const read = referenceReadType(type2);
-  if (read !== type2) return semanticType(read);
   return {
     name: type2.name,
     nullable: type2.nullable,
-    arguments: type2.typeArguments.map(semanticType)
+    arguments: type2.typeArguments.map(declaredSemanticType)
   };
 }
 function semanticAstType(type2) {
@@ -98697,6 +99091,9 @@ function semanticAstType(type2) {
     arguments: type2.kind === "dict" ? [semanticAstType(type2.key), semanticAstType(type2.value)] : [semanticAstType(type2.element)]
   };
 }
+function formatAnnotationValueType(type2) {
+  return describeType(contractType(type2));
+}
 function contractType(type2) {
   const nullable2 = type2.endsWith("?");
   const withoutNullable = type2.replace(/\?$/, "");
@@ -98799,7 +99196,7 @@ function validateListAnnotations(uri, member, ownerName, environment, diagnostic
     const domainError = indexKeyDomainError(
       field.member,
       substituteSemanticType(semanticType(field.member.type), field.bindings),
-      environment
+      environment.enums
     );
     if (domainError !== null) {
       pushDiagnostic(
@@ -98838,16 +99235,16 @@ function sourceClassMemberForType(type2, name, environment) {
   }
   return sourceClassMemberByName(declaration, name, environment, bindings);
 }
-function indexKeyDomainError(field, type2, environment) {
+function indexKeyDomainError(field, type2, enums) {
   if (field.kind !== "field") {
     return `'${field.name}' is a ${field.kind}, and index keys require a stored field`;
   }
   if (type2.name === "string") {
     return annotationEnumOption(field.annotations, "settings", "format") === "Plain" ? null : `'${field.name}' is localized, and String index keys must be plain`;
   }
-  if (environment.enums.has(type2.name)) return null;
+  if (enums.has(type2.name)) return null;
   const entry = type2.arguments?.[0];
-  if (type2.name === "Set" && entry !== void 0 && environment.enums.has(entry.name)) {
+  if (type2.name === "Set" && entry !== void 0 && enums.has(entry.name)) {
     return `'${field.name}' is a multi-select Enum, and index keys require a single-select Enum`;
   }
   return `'${field.name}' is a ${type2.name} field, and index keys require a plain String or a single-select Enum`;
@@ -98860,17 +99257,6 @@ function annotationEnumOption(annotations, name, field) {
 function isListContext(context) {
   return context.kind === "member" && (context.type.name === "List" || context.type.name === "Set");
 }
-function findTypeAnnotation(type2, position) {
-  const own = type2.annotations.find(
-    (annotation2) => inAnnotationArguments(annotation2, position)
-  );
-  if (own) return { annotation: own, type: type2 };
-  for (const argument2 of type2.typeArguments) {
-    const nested = findTypeAnnotation(argument2, position);
-    if (nested) return nested;
-  }
-  return null;
-}
 function describeAnnotationContext(context) {
   if (context.kind === "member" || context.kind === "type" || context.kind === "flowBinding" || context.kind === "flowMember")
     return `${context.type.name} ${context.kind}`;
@@ -98885,8 +99271,6 @@ function contains(range2, position) {
 }
 function inAnnotationArguments(annotation2, position) {
   if (!contains(annotation2.range, position)) return false;
-  const first = annotation2.arguments[0];
-  if (first) return compare(first.range.start, position) <= 0;
   return compare(annotation2.nameRange.end, position) < 0;
 }
 function compare(left, right) {
@@ -99006,7 +99390,7 @@ function classDerivesFromName(name, ancestorName, environment, seen = /* @__PURE
     return classDerivesFromName(base.name, ancestorName, environment, seen);
   });
 }
-var NEO_VARIANT_FOLDER_SETTING, NEO_ANIMATION_CHILD_OVERRIDE_TYPE_NAME, primitiveType, LIST_COLUMN_INHERITANCE_KEY, documentContracts, previousSemanticContract, validDocuments, DECLARATION_BODY_GLOBAL_TYPES, SEMANTIC_PRIMITIVE_TYPE_NAMES, AST_PRIMITIVE_TYPE_NAMES;
+var NEO_VARIANT_FOLDER_SETTING, NEO_ANIMATION_CHILD_OVERRIDE_TYPE_NAME, primitiveType, LIST_COLUMN_INHERITANCE_KEY, documentContracts, previousSemanticContract, validDocuments, ANNOTATION_SITES, DECLARATION_BODY_GLOBAL_TYPES, SEMANTIC_PRIMITIVE_TYPE_NAMES, AST_PRIMITIVE_TYPE_NAMES;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
@@ -99036,6 +99420,7 @@ var init_project_source_semantics = __esm({
     LIST_COLUMN_INHERITANCE_KEY = "__other__";
     documentContracts = /* @__PURE__ */ new WeakMap();
     validDocuments = /* @__PURE__ */ new WeakMap();
+    ANNOTATION_SITES = /* @__PURE__ */ new WeakMap();
     DECLARATION_BODY_GLOBAL_TYPES = /* @__PURE__ */ new Set([
       NEOSCRIPT_IMAGE_REGISTRY_TYPE,
       NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE,
@@ -99129,6 +99514,16 @@ function projectSourceAccessors(input, containingRange) {
         openIndex = cursor;
         break;
       }
+      if (!body) {
+        const start = bodyStart + open2.end;
+        const end = full.offsetAt(range2.end);
+        body = {
+          range: full.range(start, end),
+          source: source.slice(start, end),
+          form: "block"
+        };
+        openIndex = tokens.length - 1;
+      }
     }
     accessors.push({
       keyword: token.text,
@@ -99155,6 +99550,7 @@ function expressionAccessor(source, full, tokens, bodyStart, firstIndex2) {
   const start = bodyStart + first.start;
   let end = bodyStart + (tokens.at(-1)?.start ?? 0);
   let depth = 0;
+  let terminated = false;
   for (let cursor = firstIndex2; cursor < tokens.length; cursor++) {
     const token = tokens[cursor];
     if (token.kind !== "punctuation") continue;
@@ -99169,6 +99565,7 @@ function expressionAccessor(source, full, tokens, bodyStart, firstIndex2) {
     if (token.text === "}") {
       if (depth === 0) {
         end = bodyStart + token.start;
+        terminated = true;
         break;
       }
       depth--;
@@ -99176,14 +99573,17 @@ function expressionAccessor(source, full, tokens, bodyStart, firstIndex2) {
     }
     if (depth === 0 && token.text === ";") {
       end = bodyStart + token.start;
+      terminated = true;
       break;
     }
   }
-  const trimmed = source.slice(start, end).trimEnd();
-  if (trimmed.length === 0) return null;
+  const authored = source.slice(start, end);
+  const trimmed = authored.trimEnd();
+  if (trimmed.length === 0 && terminated) return null;
+  const body = terminated ? trimmed : authored;
   return {
-    range: full.range(start, start + trimmed.length),
-    source: trimmed,
+    range: full.range(start, start + body.length),
+    source: body,
     form: "expression"
   };
 }
@@ -99410,7 +99810,7 @@ function compileProjectSourceBodies(documents, options = {}) {
                 `dialogue-group:${uri}:${declaration.name}:${member.name}`
               ),
               unit: "function",
-              range: expression?.range ?? innerBodyRange(document.syntax.source, member.body.range),
+              range: expression?.range ?? innerBodyRange(document.syntax.source, member.body),
               ...expression ? { bodyMode: "expression" } : {},
               context: {
                 project,
@@ -99474,10 +99874,7 @@ function compileProjectSourceBodies(documents, options = {}) {
               constructor2
             ),
             unit: "constructor",
-            range: innerBodyRange(
-              document.syntax.source,
-              constructor2.body.range
-            ),
+            range: innerBodyRange(document.syntax.source, constructor2.body),
             context: {
               project,
               declaringType,
@@ -99513,7 +99910,7 @@ function compileProjectSourceBodies(documents, options = {}) {
             declarationRange: initBlock.keywordRange,
             memberId: initId,
             unit: "init",
-            range: innerBodyRange(document.syntax.source, initBlock.body.range),
+            range: innerBodyRange(document.syntax.source, initBlock.body),
             context: {
               project,
               declaringType,
@@ -99572,7 +99969,7 @@ function compileProjectSourceBodies(documents, options = {}) {
             memberId: info.symbol.id,
             unit: "function",
             signature: sourceOverloadParameterIdentity(member),
-            range: expressionBody?.range ?? innerBodyRange(document.syntax.source, member.body.range),
+            range: expressionBody?.range ?? innerBodyRange(document.syntax.source, member.body),
             ...expressionBody ? { bodyMode: "expression" } : {},
             context: {
               ...baseContext2,
@@ -100791,10 +101188,13 @@ function memberWritability(annotations) {
   if (/\.Session\b/.test(allowed ?? "")) return "session";
   return "runtime";
 }
-function innerBodyRange(text, range2) {
-  const start = text.offsetAt(range2.start);
-  const end = text.offsetAt(range2.end);
-  return text.range(Math.min(end, start + 1), Math.max(start + 1, end - 1));
+function innerBodyRange(text, body) {
+  const start = text.offsetAt(body.range.start);
+  const end = text.offsetAt(body.range.end);
+  return text.range(
+    Math.min(end, start + 1),
+    body.unclosed ? end : Math.max(start + 1, end - 1)
+  );
 }
 function collectRegistryMembers(documents) {
   const byRegistryType = /* @__PURE__ */ new Map();
@@ -106881,8 +107281,10 @@ function parseIndexPathSpellingV4(expression) {
     key: indexed.index.value
   };
 }
-function parseSlotPathSpellingV4(expression, isStaticSymbol) {
-  if (expression.kind !== "call") return null;
+function parseSlotPathSpellingV4(expression, isStaticSymbol, allowImplicit = false) {
+  if (expression.kind !== "call") {
+    return allowImplicit ? parseSlotPath(expression, isStaticSymbol) : null;
+  }
   if (expression.callee.kind !== "ident") return null;
   if (expression.callee.name !== "Reference") return null;
   if ((expression.typeArguments?.length ?? 0) > 0) return null;
@@ -106891,8 +107293,11 @@ function parseSlotPathSpellingV4(expression, isStaticSymbol) {
   }
   const argument2 = expression.args[0];
   if (expression.args.length !== 1 || argument2 === void 0) return null;
+  return parseSlotPath(argument2, isStaticSymbol);
+}
+function parseSlotPath(expression, isStaticSymbol) {
   const steps = [];
-  let current = argument2;
+  let current = expression;
   for (; ; ) {
     const indexed = current.kind === "force" ? current.operand : current;
     if (indexed.kind === "index") {
@@ -106987,6 +107392,7 @@ function astTypeNameV4(type2) {
   if (type2.kind === "primitive" || type2.kind === "named") return type2.name;
   if (type2.kind === "list") return "List";
   if (type2.kind === "set") return "Set";
+  if (type2.kind === "tuple") return "tuple";
   return "Dictionary";
 }
 function encodeMemberDefaultKeyReferenceV4(spelling) {
@@ -122193,90 +122599,60 @@ function constructorExpressionSlice(source) {
   return normalizeInitializerSource(source);
 }
 function topLevelEntrySlices(initializer, open2, close) {
-  const start = topLevelIndexOf(initializer, open2);
-  if (start < 0) return [];
+  const tokens = lex(initializer).roots.filter(
+    (token) => token.kind !== "comment"
+  );
+  const angles = [];
+  const genericStarts = /* @__PURE__ */ new Set();
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.kind !== "operator") continue;
+    if (token.text === "<") angles.push(index);
+    else if (token.text === ">") {
+      const start = angles.pop();
+      const next = tokens[index + 1]?.text;
+      if (start !== void 0 && (next === "(" || next === "{" || next === "."))
+        genericStarts.add(start - 1);
+    }
+  }
   const slices = [];
   let depth = 0;
   let entryStart = -1;
-  let quote6 = null;
-  let escaped = false;
-  let index = start;
-  while (index < initializer.length) {
-    const character = initializer[index];
-    if (quote6 !== null) {
-      if (escaped) escaped = false;
-      else if (character === "\\") escaped = true;
-      else if (character === quote6) quote6 = null;
-      index += 1;
-      continue;
-    }
-    const afterComment = commentEndIndex(initializer, index);
-    if (afterComment !== null) {
-      index = afterComment;
-      continue;
-    }
-    if (character === '"' || character === "'") {
-      quote6 = character;
-      index += 1;
-      continue;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (genericStarts.has(index)) {
+      const end = new Parser(tokens, index).typeEnd();
+      const next = tokens[end]?.text;
+      if (end > index && (next === "(" || next === "{" || next === ".")) {
+        index = end - 1;
+        continue;
+      }
     }
+    if (token.kind !== "punctuation") continue;
+    const character = token.text;
+    if (depth === 0 && character !== open2) continue;
     if (character === "[" || character === "{" || character === "(") {
-      depth += 1;
-      if (depth === 1) entryStart = index + 1;
-      index += 1;
-      continue;
-    }
-    if (character === "]" || character === "}" || character === ")") {
-      depth -= 1;
+      depth++;
+      if (depth === 1) entryStart = token.end;
+    } else if (character === "]" || character === "}" || character === ")") {
+      depth--;
       if (depth === 0) {
         if (character !== close) return [];
         const text = normalizeInitializerSource(
-          initializer.slice(entryStart, index)
+          initializer.slice(entryStart, token.start)
         );
-        if (text.length > 0 || slices.length > 0) slices.push(text);
+        if (text.length > 0) slices.push(text);
         return slices.filter((entry) => entry.length > 0);
       }
-      index += 1;
-      continue;
-    }
-    if (character === "," && depth === 1) {
+    } else if (character === "," && depth === 1) {
       slices.push(
-        normalizeInitializerSource(initializer.slice(entryStart, index))
+        normalizeInitializerSource(initializer.slice(entryStart, token.start))
       );
-      entryStart = index + 1;
+      entryStart = token.end;
     }
-    index += 1;
   }
   return [];
 }
-function topLevelIndexOf(source, character) {
-  let quote6 = null;
-  let escaped = false;
-  let index = 0;
-  while (index < source.length) {
-    const current = source[index];
-    if (quote6 !== null) {
-      if (escaped) escaped = false;
-      else if (current === "\\") escaped = true;
-      else if (current === quote6) quote6 = null;
-      index += 1;
-      continue;
-    }
-    const afterComment = commentEndIndex(source, index);
-    if (afterComment !== null) {
-      index = afterComment;
-      continue;
-    }
-    if (current === '"' || current === "'") {
-      quote6 = current;
-      index += 1;
-      continue;
-    }
-    if (current === character) return index;
-    index += 1;
-  }
-  return -1;
-}
 function matchesStoredInitializer(defaultValue, source) {
   if (!isObjectRecord(defaultValue) || !isObjectRecord(defaultValue.init))
     return false;
@@ -122290,6 +122666,7 @@ var normalizedInitializers, normalizedInitializerCharacters, MAX_NORMALIZED_INIT
 var init_init_source = __esm({
   "src/project-source/init-source.ts"() {
     "use strict";
+    init_executable_parser();
     init_lexer();
     init_value_comparison();
     normalizedInitializers = /* @__PURE__ */ new Map();
@@ -123646,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) {
@@ -124882,10 +125259,36 @@ function deferredReferenceDefault(context, expression) {
 function deferredReferenceValue(context, expression) {
   const spelling = parseIndexPathSpellingV4(expression) ?? parseSlotPathSpellingV4(
     expression,
-    (symbol) => context.staticValueIdsBySymbol.has(symbol) || context.classIdsByName.has(symbol.slice(0, symbol.indexOf(".")))
+    (symbol) => context.staticValueIdsBySymbol.has(symbol) || context.classIdsByName.has(symbol.slice(0, symbol.indexOf("."))),
+    isStoredValuePath(context, expression)
   );
   return spelling === null ? null : encodeMemberDefaultKeyReferenceV4(spelling);
 }
+function isStoredValuePath(context, expression) {
+  const path = expressionMemberPath(expression);
+  if (path === null) return false;
+  const separator = path.lastIndexOf(".");
+  if (separator < 0) return false;
+  const receiver = path.slice(0, separator);
+  const classId = context.rootValueTargetsByPath.get(receiver)?.classId ?? context.classIdsByName.get(receiver);
+  if (classId === void 0) return false;
+  const memberId = effectiveMemberIdByName(
+    context,
+    classId,
+    path.slice(separator + 1)
+  );
+  if (memberId === null) return false;
+  if (!receiver.startsWith("root.") && !isStaticMember2(context, memberId))
+    return false;
+  const source = context.sourceMembersById.get(memberId);
+  if (source !== void 0) {
+    return source.member.kind === "field" && source.member.type.name !== "Reference" && !(source.member.type.name === "Set" && source.member.type.arguments[0]?.name === "Reference") && !source.ownerClass.genericParameters.some(
+      (parameter4) => parameter4.name === source.member.type.name
+    );
+  }
+  const member = context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
+  return member !== void 0 && member.kind !== "lookup" && member.kind !== "generic" && member.kind !== "function" && member.kind !== "scriptFunction";
+}
 function slotReferenceType(readType) {
   if (readType.name === "Reference") return readType;
   const element = readType.name === "Set" ? readType.arguments[0] : void 0;
@@ -124898,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;
   }
@@ -124920,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(
@@ -124938,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.`
@@ -125479,6 +125887,12 @@ function positionRequiresEvaluation(context, expression, expected, ownerClass) {
       ownerClass.name
     )
   );
+  const selectionEntry = expected.name === "Set" ? expected.arguments[0] : void 0;
+  if (selectionEntry?.name === "Reference" && expression.kind === "litList") {
+    return expression.elements.some(
+      (element) => positionRequiresEvaluation(context, element, selectionEntry, ownerClass)
+    );
+  }
   if (isStoredDelegateLiteral(expected, expression))
     return requiresEvaluation();
   if (isStoredActionLiteral(expected, expression)) return false;
@@ -126131,7 +126545,7 @@ function lowerGenericArgument(context, ownerClass, type2, memberId, genericParam
     genericParamId
   };
   const base = context.baseMembers.get(memberId);
-  if (base && JSON.stringify(manifestTypeForMember(context, base)) === JSON.stringify(type2)) {
+  if (base && base.kind !== "tuple" && JSON.stringify(manifestTypeForMember(context, base)) === JSON.stringify(type2)) {
     context.loweredMembers.set(memberId, { ...base, owner });
     if (base.kind === "list" || base.kind === "set" || base.kind === "dictionary") {
       lowerCollectionEntry(
@@ -127045,7 +127459,7 @@ function renderVariantSelectionV4(context, memberName, value) {
     );
   }
   const rootPath = context.collectionValuePaths.get(rowValueId);
-  const reference2 = rootPath === void 0 ? `Reference(id: ${quoteNeoString(rowValueId)})` : `Reference(${rootPath})`;
+  const reference2 = rootPath === void 0 ? `Reference(id: ${quoteNeoString(rowValueId)})` : rootPath;
   return `${path}.Bind(${reference2})`;
 }
 var init_variant_selection_source = __esm({
@@ -127868,7 +128282,7 @@ function memberSettings(context, member) {
         member.collectionValueId
       );
       settings.push(
-        rootPath === void 0 ? `collectionValue: Reference(id: ${quote(member.collectionValueId)})` : `collectionValue: Reference(${rootPath})`
+        rootPath === void 0 ? `collectionValue: Reference(id: ${quote(member.collectionValueId)})` : `collectionValue: ${rootPath}`
       );
     }
   } else if (member.kind === "dialogueLookup") {
@@ -129014,7 +129428,7 @@ function emitVariantFolder(context, className, folder) {
   const rootPath = context.collectionValuePaths.get(
     folder.binding.collectionValueId
   );
-  const collectionValue = rootPath === void 0 ? `Reference(id: ${quote(folder.binding.collectionValueId)})` : `Reference(${rootPath})`;
+  const collectionValue = rootPath === void 0 ? `Reference(id: ${quote(folder.binding.collectionValueId)})` : rootPath;
   return `${id(folder.id)}${NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME}<${className}, ${valueType}> ${variantFolderSymbol(folder)} = new(
   path: ${quote(folder.path)},
   collection: ${qualifiedMember(context, folder.binding.collectionMemberId)},
@@ -130065,7 +130479,7 @@ function emitDialogueGroup(data, recordId, name, priorityNames, dialogueNames, u
     const path = collectionValuePaths.get(data.collectionValueId);
     args.push([
       "collectionValue",
-      path === void 0 ? `Reference(id: ${quote2(data.collectionValueId)})` : `Reference(${path})`
+      path === void 0 ? `Reference(id: ${quote2(data.collectionValueId)})` : path
     ]);
   }
   const source = collectDialogueGroupFunctions(data, recordId, uiLogicResolver);
@@ -144396,14 +144810,14 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
   const currentById = new Map(
     args.document.members.map((member) => [member.id, member])
   );
-  const sourceMembers = authoredPostDocument.members.map(
+  const sourceMembers2 = authoredPostDocument.members.map(
     (member) => remappedMembers.get(member.id) ?? (recompileTargets.memberIds.has(member.id) || explicitlyChangedMemberIds.has(member.id) ? stripDerivedBodies(member) : member)
   );
   let currentSourceMembers;
   let postCompilationProject;
   let currentCompilationProject;
   const toleratedPreexistingFailures = /* @__PURE__ */ new Set();
-  for (const member of sourceMembers) {
+  for (const member of sourceMembers2) {
     if (!hasAuthoredNeoScriptBody(member)) continue;
     if (!recompileTargets.memberIds.has(member.id) || remappedMembers.has(member.id)) {
       continue;
@@ -144412,11 +144826,11 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
       compileOneAuthoredMember({
         scriptSources: scriptSources.get(`member:${member.id}`),
         document: authoredPostDocument,
-        members: sourceMembers,
+        members: sourceMembers2,
         member,
         compilationProject: postCompilationProject ??= cachedServerCompilationProject({
           ...authoredPostDocument,
-          members: sourceMembers
+          members: sourceMembers2
         })
       });
     } catch (postWriteError) {
@@ -144449,7 +144863,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     }
   }
   const compiledById = new Map(
-    sourceMembers.map((member) => [member.id, member])
+    sourceMembers2.map((member) => [member.id, member])
   );
   const explicitMemberIds = /* @__PURE__ */ new Set();
   for (const change of authoredChanges) {
@@ -144470,7 +144884,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     return { ...change, nextData: compiled };
   });
   const hashByKey = indexLiveContentHashesByRecordKey(args.contentHashHeads);
-  for (const compiled of sourceMembers) {
+  for (const compiled of sourceMembers2) {
     if (!recompileTargets.memberIds.has(compiled.id)) continue;
     if (explicitMemberIds.has(compiled.id)) continue;
     if (toleratedPreexistingFailures.has(compiled.id)) continue;
@@ -144503,7 +144917,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     targetIds: recompileTargets.constructorIds,
     contentHashHeads: args.contentHashHeads
   });
-  const constructionTypeMembers = [...sourceMembers];
+  const constructionTypeMembers = [...sourceMembers2];
   const appendConstructionTypes = () => {
     const created = compiledConstructionTypeMembers(
       constructionTypeMembers,
@@ -159180,7 +159594,7 @@ function folderBinding(context, global) {
   }
   if (collectionValue === void 0) {
     throw new Error(
-      `Lookup variant folder ${global.name} requires collectionValue: Reference(...).`
+      `Lookup variant folder ${global.name} requires collectionValue naming a collection row.`
     );
   }
   const collectionValueId = lowerReferenceValue(collectionValue);
@@ -159192,11 +159606,10 @@ function folderBinding(context, global) {
   return { collectionMemberId, collectionValueId };
 }
 function lowerReferenceValue(expression) {
-  if (expression.kind !== "call" || expression.callee.kind !== "ident" || expression.callee.name !== "Reference")
-    return null;
-  const idIndex = expression.argumentNames?.findIndex((name) => name === "id") ?? -1;
-  const target = expression.args[idIndex >= 0 ? idIndex : 0];
-  if (target?.kind === "litString") return target.value;
+  const isReferenceCall2 = expression.kind === "call" && expression.callee.kind === "ident" && expression.callee.name === "Reference";
+  const idIndex = isReferenceCall2 ? expression.argumentNames?.findIndex((name) => name === "id") ?? -1 : -1;
+  const target = isReferenceCall2 ? expression.args[idIndex >= 0 ? idIndex : 0] : expression;
+  if (isReferenceCall2 && target?.kind === "litString") return target.value;
   const path = target === void 0 ? null : dottedPath(target);
   if (path === null || !path.startsWith("root.")) return null;
   return referenceId2(`Reference(${path})`);
@@ -162017,9 +162430,20 @@ function defaultRequiresOwnedRows(context, member, sourceExpression, source) {
 }
 function memberInitializerRequiresEvaluation(context, member, expression, source) {
   if (member.kind === "class" && member.partial === true) return false;
-  if (member.kind === "lookup" && isDeferredPathReferenceValue(context, expression)) {
+  if (member.kind === "lookup" && isDeferredPathReferenceValue(context, expression, member)) {
     return false;
   }
+  if (member.kind === "lookup" && expression.kind === "litList") {
+    const elementMember = { ...member, multiselect: false };
+    return expression.elements.some(
+      (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;
   const requiresEvaluation = unorderedDefault || source.purpose === "memberDefault" && member.id === source.memberId && constructsValue(expression) && slotForwardsTypeParameter2(context, member, source.ownerClassId) || context.localValues.readsInstance(expression) || isSchemaMemberValueRead(context, expression, source) || isUnresolvedLiteralName(context, member, expression) || initializerRequiresEvaluation(
     context.declaredConstructors,
@@ -162049,18 +162473,20 @@ function slotForwardsTypeParameter2(context, member, ownerClassId) {
   }
   return false;
 }
-function deferredPathSpelling(context, expression) {
+function deferredPathSpelling(context, expression, expected) {
   return parseIndexPathSpellingV4(expression) ?? parseSlotPathSpellingV4(
     expression,
-    (symbol) => context.staticValueIdsBySymbol.has(symbol)
+    (symbol) => context.staticValueIdsBySymbol.has(symbol),
+    isStoredSlotPath(context, expression, expected)
   );
 }
-function isDeferredPathReferenceValue(context, sourceExpression) {
+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) {
-    if (deferredPathSpelling(context, element) !== null) {
+    if (deferredPathSpelling(context, element, expected) !== null) {
       indexPaths += 1;
       continue;
     }
@@ -162070,6 +162496,35 @@ function isDeferredPathReferenceValue(context, sourceExpression) {
   }
   return indexPaths > 0;
 }
+function isStoredSlotPath(context, expression, expected) {
+  const path = memberPath2(expression);
+  if (path === null) return false;
+  const separator = path.lastIndexOf(".");
+  if (separator < 0) return false;
+  const receiver = path.slice(0, separator);
+  const staticClass = context.classesByName.get(receiver);
+  const classId = context.rootValueTargetsByPath.get(receiver)?.classId ?? staticClass?.id;
+  if (classId === void 0) return false;
+  const memberId = classSchemaMemberId(
+    context,
+    classId,
+    path.slice(separator + 1)
+  );
+  const member = memberId === null ? void 0 : context.members.get(memberId);
+  if (member === void 0) return false;
+  if (staticClass !== void 0 && member.modifier !== "static") return false;
+  if (member.kind === "lookup") {
+    if (member.declaredType === null) return false;
+    if (member.multiselect) return false;
+    const storedType = {
+      kind: "reference",
+      nullable: !member.required,
+      target: member.declaredType
+    };
+    return canonicallyEqual(expected.declaredType, storedType);
+  }
+  return member.kind !== "generic" && member.kind !== "computed" && member.kind !== "function" && member.kind !== "scriptFunction";
+}
 function isSchemaMemberValueRead(context, expression, source) {
   const path = memberPath2(annotatedValue(expression).expression);
   if (path === null) return false;
@@ -165468,7 +165923,8 @@ function lowerRawMemberTypeName(context, memberId) {
   if (member.kind === 8 /* Enum */ && typeof member.enumId === "string") {
     return context.enumNames.get(member.enumId) ?? null;
   }
-  if (member.kind === 9 /* Lookup */) return "Reference";
+  if (member.kind === 9 /* Lookup */)
+    return member.selection === 1 /* Multi */ ? "Set" : "Reference";
   if (member.kind === 6 /* List */) return "List";
   if (member.kind === 28 /* Set */) return "Set";
   if (member.kind === 5 /* Dictionary */) return "Dictionary";
@@ -165484,7 +165940,7 @@ function lowerSchemaMemberTypeName(context, member) {
     case "enum":
       return context.enumNames.get(member.enumId) ?? null;
     case "lookup":
-      return "Reference";
+      return member.multiselect ? "Set" : "Reference";
     case "list":
       return "List";
     case "set":
@@ -165903,13 +166359,17 @@ 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()) {
-    const path = member.kind === "lookup" ? deferredPathSpelling(context, entry) : null;
+    const path = member.kind === "lookup" ? deferredPathSpelling(context, entry, member) : null;
     if (path !== null) {
       ids.push(`${PENDING_ID_PREFIX}reference-index:${source.label}:${index}`);
       context.referenceObligations.push({
@@ -165923,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}`);
@@ -165946,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;
 }
@@ -168938,9 +169396,14 @@ function schemaTypeForBindingMember(context, memberId, environment, visited = /*
       if (member.declaredType !== null) {
         if (member.collectionMemberId === null && member.multiselect) {
           return {
-            kind: "lookup",
+            kind: "set",
             nullable: nullable2,
-            entryType: referenceReadType2(context, member.declaredType)
+            setMemberId: member.id,
+            entryType: {
+              kind: "reference",
+              nullable: false,
+              target: member.declaredType
+            }
           };
         }
         return { kind: "reference", nullable: nullable2, target: member.declaredType };
@@ -170107,10 +170570,10 @@ function unboundReferenceTypeName(context, member, targetId) {
   if (manifestMember.collectionMemberId !== null) return null;
   const declared = manifestMember.declaredType;
   if (declared === null) return null;
-  if (declared.kind !== "class" && declared.kind !== "interface" && declared.kind !== "generic") {
+  if (declared.kind !== "interface" && declared.kind !== "generic") {
     return storedTypeArgumentName(context, declared, /* @__PURE__ */ new Map());
   }
-  const classId = declared.kind === "class" ? declared.classId : context.values.get(targetId)?.classId;
+  const classId = context.values.get(targetId)?.classId;
   if (typeof classId !== "string") return null;
   return context.manifestClasses.get(classId)?.name ?? null;
 }
@@ -185097,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,
@@ -185122,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;
@@ -185149,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)) {
@@ -185169,6 +185618,98 @@ 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))
+    return null;
+  const features = scriptFeatureIndex(snapshot);
+  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;
+  }
+  return complete(snapshot, position);
+}
 function hover(snapshot, position) {
   const offset = snapshot.source.offsetAt(position);
   const reference2 = referenceAt(snapshot.parsed.references, offset);
@@ -185274,6 +185815,10 @@ function definition(snapshot, position) {
     ) === index
   );
 }
+function constructorTypeAt(snapshot, position) {
+  const argument2 = callArgumentAt(snapshot, snapshot.source.offsetAt(position));
+  return argument2?.call.kind === "constructor" ? constructionType(snapshot, argument2.call)?.declaration.name ?? null : null;
+}
 function signatureHelp(snapshot, position) {
   const argument2 = callArgumentAt(snapshot, snapshot.source.offsetAt(position));
   if (!argument2) return null;
@@ -185670,6 +186215,12 @@ function typeArgumentCount(tokens) {
   }
   return count;
 }
+function callParametersAt(snapshot, position) {
+  const call = scriptFeatureIndex(snapshot).calls.get(
+    snapshot.source.offsetAt(position)
+  );
+  return call?.kind === "function" ? callSymbol(snapshot, call)?.parameters ?? null : null;
+}
 function inlayHints(snapshot, range2) {
   const hints = [];
   for (const call of snapshot.parsed.calls) {
@@ -185689,11 +186240,9 @@ function inlayHints(snapshot, range2) {
       if (!argumentRange || !parameterName || call.argumentNames[index]) {
         continue;
       }
-      if (obviousParameterName(snapshot, argumentRange, parameterName)) {
-        continue;
-      }
-      const position = firstNonWhitespacePosition(snapshot, argumentRange);
-      if (comparePositions(position, argumentRange.end) >= 0) continue;
+      const argument2 = argumentTokenBounds(snapshot, argumentRange);
+      if (!argument2 || obviousParameterName(argument2, parameterName)) continue;
+      const position = argument2.first.range.start;
       if (range2 && !positionInRange(position, range2)) continue;
       hints.push({
         position,
@@ -185718,11 +186267,8 @@ function inlayHints(snapshot, range2) {
   }
   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 obviousParameterName(argument2, parameterName) {
+  return argument2.first === argument2.last && argument2.first.kind === "identifier" && normalizeHintName(argument2.first.text) === normalizeHintName(parameterName);
 }
 function normalizeHintName(name) {
   return name.replaceAll("_", "").toLocaleLowerCase();
@@ -185758,18 +186304,7 @@ function positionCompare2(left, right) {
 }
 function constructorParameterNames(type2) {
   const declared = type2?.declaredConstructors ?? [];
-  if (declared.length > 0) {
-    const arity = Math.max(
-      ...declared.map((constructor2) => constructor2.parameters.length)
-    );
-    return Array.from({ length: arity }, (_, index) => {
-      const names2 = new Set(
-        declared.map((constructor2) => constructor2.parameters[index]?.name)
-      );
-      const [name] = names2;
-      return names2.size === 1 && name ? name : null;
-    });
-  }
+  if (declared.length > 0) return neoScriptCommonParameterNames(declared);
   return type2?.constructorSignature?.parameters.map((parameter4) => parameter4.name) ?? null;
 }
 function documentSymbols2(snapshot) {
@@ -186567,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;
@@ -186731,6 +187292,22 @@ function innermostOpener(features, offset) {
   return token.kind === "punctuation" && (token.text === "(" || token.text === "[" || token.text === "{") ? last : enclosingOpener[last];
 }
 function callSymbol(snapshot, call) {
+  if (call.kind === "expression") {
+    const features = scriptFeatureIndex(snapshot);
+    const open2 = features.tokenIndexes.get(call.openParenOffset);
+    if (open2 === void 0) return void 0;
+    const type2 = inferExpressionType2(
+      expressionTokensBefore(features.tokens, open2),
+      snapshot,
+      call.openParenOffset
+    );
+    return type2.kind === "delegate" ? {
+      id: `delegate:${call.openParenOffset}`,
+      name: "delegate",
+      kind: "local",
+      type: type2
+    } : void 0;
+  }
   const reference2 = scriptFeatureIndex(snapshot).references.get(
     snapshot.source.offsetAt(call.nameRange.start)
   );
@@ -186964,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)
@@ -186979,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));
   }
@@ -187292,7 +187891,7 @@ function isKnownMemberReceiver(snapshot, receiver) {
 function specializeGenericCall(snapshot, resolved, typeArguments, openParenOffset) {
   if (resolved === null) return null;
   const inferred = openParenOffset === void 0 ? void 0 : flowProbe(snapshot).calls.get(openParenOffset);
-  if (inferred !== void 0 && inferred.id === resolved.symbol?.id)
+  if (inferred !== void 0)
     return { type: inferred.returnType ?? inferred.type, symbol: inferred };
   const { symbol } = resolved;
   const parameters = symbol?.typeParameters;
@@ -187743,9 +188342,10 @@ function flowProbe(snapshot) {
     return result;
   const text = snapshot.source.text;
   const source = snapshot.source;
+  const context = snapshot.expressionRange && snapshot.context.kind === "initializerExpression" ? { ...snapshot.context, kind: "function" } : snapshot.context;
   compileNeoScriptStrict(
     { uri: snapshot.uri, languageId: "neoscript", version: 1, text },
-    snapshot.context,
+    context,
     {
       emit: false,
       projectIndex: snapshot.project,
@@ -188780,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];
@@ -189045,15 +189657,25 @@ function significantTokensBefore(tokens, offset, start = 0) {
 }
 function expressionTokensBefore(tokens, endExclusive) {
   let depth = 0;
+  let groupEnd = -1;
   let start = endExclusive - 1;
   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);
@@ -189070,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];
@@ -189079,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;
@@ -189105,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;
@@ -189207,14 +189821,16 @@ function boundParameter(parameters, call, index) {
     index
   );
 }
-function firstNonWhitespacePosition(snapshot, range2) {
+function argumentTokenBounds(snapshot, range2) {
   const start = snapshot.source.offsetAt(range2.start);
   const end = snapshot.source.offsetAt(range2.end);
-  let offset = start;
-  while (offset < end && /\s/.test(snapshot.source.text[offset] ?? "")) {
-    offset++;
-  }
-  return snapshot.source.positionAt(offset);
+  const tokens = snapshot.lexed.tokens;
+  let first = firstIndex(tokens, (token) => token.start >= start);
+  let last = firstIndex(tokens, (token) => token.start >= end) - 1;
+  while (first <= last && tokens[first].kind === "comment") first++;
+  while (last >= first && tokens[last].kind === "comment") last--;
+  if (first > last || tokens[first]?.kind === "eof") return null;
+  return { first: tokens[first], last: tokens[last] };
 }
 function positionInRange(position, range2) {
   return comparePositions(position, range2.start) >= 0 && comparePositions(position, range2.end) <= 0;
@@ -189228,7 +189844,7 @@ 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";
@@ -189259,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();
@@ -189322,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);
@@ -189336,10 +189992,25 @@ function createContext2(analysis, source) {
     } : {}
   };
   const resolver = new StrictNeoScriptResolver(context, project);
+  const parameterContexts = /* @__PURE__ */ new Map();
   const parameterResolvers = /* @__PURE__ */ new Map();
+  function parameterContext(constructorIndex) {
+    const key = constructorIndex ?? -1;
+    const cached = parameterContexts.get(key);
+    if (cached) return cached;
+    const declared = constructorIndex === void 0 ? source?.headerParameters : source?.constructors[constructorIndex]?.parameters;
+    const parameters = declared?.flatMap((parameter4) => {
+      const type2 = resolveSourceType(parameter4.type, context, project);
+      return type2 ? [{ name: parameter4.name, type: type2 }] : [];
+    });
+    const created = parameters?.length ? { ...context, parameters } : context;
+    parameterContexts.set(key, created);
+    return created;
+  }
   return {
     context,
     project,
+    parameterContext,
     provide: createListenerAnnotationProvider(project, context),
     resolver,
     /**
@@ -189352,14 +190023,8 @@ function createContext2(analysis, source) {
       const key = constructorIndex ?? -1;
       const cached = parameterResolvers.get(key);
       if (cached) return cached;
-      const declared = constructorIndex === void 0 ? source?.headerParameters : source?.constructors[constructorIndex]?.parameters;
-      const parameters = declared?.flatMap(
-        (parameter4) => {
-          const type2 = resolveSourceType(parameter4.type, context, project);
-          return type2 ? [{ name: parameter4.name, type: type2 }] : [];
-        }
-      );
-      const created = parameters?.length ? new StrictNeoScriptResolver({ ...context, parameters }, project) : resolver;
+      const scoped = parameterContext(constructorIndex);
+      const created = scoped !== context ? new StrictNeoScriptResolver(scoped, project) : resolver;
       parameterResolvers.set(key, created);
       return created;
     }
@@ -189367,9 +190032,17 @@ function createContext2(analysis, source) {
 }
 function listenerSourceContext(analysis, document, position) {
   const source = analysis.documents.get(document.uri);
-  const declaring = source?.declarations.find(
-    (declaration) => declaration.kind === "class" && rangeContains(declaration.range, position)
-  );
+  const declarations = source?.declarations ?? [];
+  let low = 0;
+  let high = declarations.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (positionCompare(declarations[middle].range.end, position) < 0)
+      low = middle + 1;
+    else high = middle;
+  }
+  const candidate = declarations[low];
+  const declaring = candidate?.kind === "class" && rangeContains(candidate.range, position) ? candidate : void 0;
   const name = declaring?.name;
   let contexts = CONTEXTS.get(analysis);
   if (!contexts) {
@@ -189400,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 {
@@ -189600,6 +190287,224 @@ var init_project_listener_annotations = __esm({
   }
 });
 
+// ../packages/neoscript-language/src/project-annotation-path-completions.ts
+function annotationSchemaPathCompletions(analysis, document, position, site, field, tokens, next) {
+  const kind = annotationSchemaPathKind(site.annotation.name, field);
+  if (!kind) return null;
+  const entryMember = kind === "member";
+  const collection = kind === "collection";
+  const atCursor = projectTokenAt(document, position);
+  if (atCursor?.kind === "comment" || atCursor?.kind === "string") return [];
+  if (next && positionCompare(position, next.range.start) < 0 && ![",", ")"].includes(next.text))
+    return [];
+  const { context, project } = listenerSourceContext(
+    analysis,
+    document,
+    position
+  );
+  const targetType = annotationTargetType(site, context, project);
+  let receiver;
+  let word;
+  if (entryMember) {
+    if (tokens.length > 1) return [];
+    receiver = targetType ? neoScriptMemberLookupType(targetType) : void 0;
+    word = tokens[0];
+  } else {
+    if (tokens.length > 3) return [];
+    if (tokens.length >= 2) {
+      if (tokens[1]?.text !== ".") return [];
+      const owner = project.typeByName.get(tokens[0].text);
+      if (!owner || owner.kind !== "class") return [];
+      receiver = { kind: "named", typeId: owner.id };
+      word = tokens[2];
+    } else {
+      word = tokens[0];
+    }
+  }
+  if (word && word.kind !== "identifier" && word.kind !== "type") return [];
+  if (word && positionCompare(word.range.end, position) < 0) return [];
+  const editingWord = word ?? (atCursor?.kind === "identifier" || atCursor?.kind === "type" ? atCursor : void 0);
+  const range2 = editingWord?.range ?? { start: position, end: position };
+  const sources2 = entryMember && site.annotation.name === "index" ? sourceMembers(analysis) : null;
+  const enums = {
+    has: (name) => project.typeByName.get(name)?.kind === "enum"
+  };
+  const isClass = (value) => {
+    const bound = neoScriptMemberLookupType(value);
+    return bound.kind === "named" && project.typeById.get(bound.typeId)?.kind === "class";
+  };
+  const eligible = (symbol, type2) => {
+    if (symbol.static || symbol.kind !== "field" && symbol.kind !== "property")
+      return false;
+    if (entryMember && site.annotation.name === "index") {
+      const source = symbol.selectionLocation;
+      const member = source ? sources2?.get(locationKey2(source.uri, source.range.start)) : void 0;
+      if (!member) return false;
+      let name = type2.kind;
+      if (type2.kind === "primitive") name = type2.name;
+      else if (type2.kind === "named")
+        name = project.typeById.get(type2.typeId)?.name ?? type2.typeId;
+      return indexKeyDomainError(member, { name }, enums) === null;
+    }
+    if (!collection) return true;
+    const entry = collectionElement(type2);
+    if (!entry) return false;
+    if (!targetType) return true;
+    const classes = isClass(targetType) && isClass(entry);
+    return isNeoScriptTypeAssignable(
+      { ...classes ? targetType : entry, nullable: false },
+      { ...classes ? entry : targetType, nullable: false },
+      project
+    );
+  };
+  const items = [];
+  if (receiver?.kind === "named") {
+    const owner = project.typeById.get(receiver.typeId);
+    if (!owner) return [];
+    for (const symbol of owner.members) {
+      const type2 = substituteTypeParameters(
+        symbol.type,
+        receiver,
+        owner,
+        project
+      );
+      if (!eligible(symbol, type2)) continue;
+      items.push({
+        label: symbol.name,
+        kind: "property",
+        detail: formatType(type2, project),
+        symbolId: symbol.id,
+        insertText: symbol.name,
+        textEdit: { range: range2, newText: symbol.name }
+      });
+    }
+  } else if (!entryMember) {
+    for (const owner of project.typeById.values()) {
+      if (owner.kind !== "class" || !owner.location) continue;
+      if (!owner.members.some((member) => eligible(member, member.type)))
+        continue;
+      items.push({
+        label: owner.name,
+        kind: "class",
+        insertText: owner.name,
+        textEdit: { range: range2, newText: owner.name }
+      });
+    }
+  }
+  if (entryMember && site.annotation.name === "column") {
+    items.push({
+      label: "__other__",
+      kind: "property",
+      detail: "Inherited columns",
+      insertText: "__other__",
+      textEdit: { range: range2, newText: "__other__" }
+    });
+  }
+  return items;
+}
+function annotationSchemaPathKind(annotation2, field) {
+  if (field === "member" && (annotation2 === "index" || annotation2 === "column"))
+    return "member";
+  if (annotation2 === "settings" && (field === "collection" || field === "target"))
+    return field;
+  return null;
+}
+function annotationTargetType(site, context, project) {
+  const declared = site.type ? resolveSourceType(site.type, context, project) : null;
+  const resolved = declared?.kind === "reference" ? declared.target : declared;
+  return resolved ? collectionElement(resolved) ?? resolved : null;
+}
+function annotationSchemaPathTarget(analysis, document, token, site) {
+  const argumentIndex = site.annotation.arguments.findIndex(
+    (argument3) => rangeContains(argument3.range, token.range.start)
+  );
+  const argument2 = site.annotation.arguments[argumentIndex];
+  if (!argument2) return void 0;
+  const field = argument2.name ?? site.fields[argumentIndex]?.name;
+  const kind = field && annotationSchemaPathKind(site.annotation.name, field);
+  if (!kind) return void 0;
+  const allTokens = projectTokens(document);
+  const tokens = [];
+  for (let index = projectTokenIndexAt(document, argument2.range.start); index < allTokens.length; index++) {
+    const current = allTokens[index];
+    if (positionCompare(current.range.start, argument2.range.end) >= 0) break;
+    if (current.kind !== "comment") tokens.push(current);
+  }
+  if (tokens[1]?.text === ":") tokens.splice(0, 2);
+  const { context, project } = listenerSourceContext(
+    analysis,
+    document,
+    token.range.start
+  );
+  let receiver;
+  if (kind === "member") {
+    if (tokens.length !== 1 || tokens[0] !== token || site.annotation.name === "column" && token.text === "__other__")
+      return null;
+    receiver = annotationTargetType(site, context, project);
+  } else {
+    const owner2 = project.typeByName.get(tokens[0]?.text ?? "");
+    if (!owner2 || owner2.kind !== "class") return null;
+    if (tokens[0] === token) return owner2;
+    if (tokens.length !== 3 || tokens[1]?.text !== "." || tokens[2] !== token)
+      return null;
+    receiver = { kind: "named", typeId: owner2.id };
+  }
+  if (!receiver) return null;
+  const bound = neoScriptMemberLookupType(receiver);
+  const owner = bound.kind === "named" ? project.typeById.get(bound.typeId) : void 0;
+  return owner ? schemaMembers(owner).get(token.text) ?? null : null;
+}
+function schemaMembers(owner) {
+  const cached = SCHEMA_MEMBERS.get(owner);
+  if (cached) return cached;
+  const members2 = /* @__PURE__ */ new Map();
+  for (const member of owner.members) {
+    if (member.static || member.kind !== "field" && member.kind !== "property")
+      continue;
+    if (!members2.has(member.name)) members2.set(member.name, member);
+  }
+  SCHEMA_MEMBERS.set(owner, members2);
+  return members2;
+}
+function collectionElement(type2) {
+  if (type2.kind === "list" || type2.kind === "set") return type2.elementType;
+  if (type2.kind === "dictionary") return type2.valueType;
+  return null;
+}
+function sourceMembers(analysis) {
+  let members2 = SOURCE_MEMBERS.get(analysis);
+  if (!members2) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [uri, document] of analysis.documents) {
+      for (const declaration of document.declarations) {
+        if (declaration.kind === "global" || declaration.kind === "enum")
+          continue;
+        for (const member of declaration.members)
+          result.set(locationKey2(uri, member.nameRange.start), member);
+      }
+    }
+    members2 = result;
+    SOURCE_MEMBERS.set(analysis, members2);
+  }
+  return members2;
+}
+function locationKey2(uri, position) {
+  return `${uri}:${position.line}:${position.character}`;
+}
+var SCHEMA_MEMBERS, SOURCE_MEMBERS;
+var init_project_annotation_path_completions = __esm({
+  "../packages/neoscript-language/src/project-annotation-path-completions.ts"() {
+    "use strict";
+    init_project_source_semantics();
+    init_project_listener_annotations();
+    init_project_source_tokens();
+    init_project2();
+    init_type_substitution();
+    SCHEMA_MEMBERS = /* @__PURE__ */ new WeakMap();
+    SOURCE_MEMBERS = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // ../packages/neoscript-language/src/project-source-lifecycle-editor.ts
 function projectLifecycleHooks(analysis) {
   let hooks = PROJECT_LIFECYCLE_HOOKS.get(analysis);
@@ -190062,6 +190967,66 @@ 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: [] };
+  }
   const variantPathInBody = projectVariantPathCompletions(
     analysis,
     document,
@@ -190078,9 +191043,16 @@ function projectCompletions(analysis, document, position) {
   const body = projectBodySnapshotAt(analysis, document, position);
   if (body) {
     const script = complete(body, position);
-    return variantScopeInBody === null ? script : {
+    const names2 = projectConstructorArgumentCompletions(
+      analysis,
+      document,
+      position,
+      body
+    );
+    const items = names2?.length ? [...names2, ...script.items] : script.items;
+    return variantScopeInBody === null ? { ...script, items } : {
       ...script,
-      items: [...script.items, variantScopeInBody]
+      items: [...items, variantScopeInBody]
     };
   }
   const groupMembers = dialogueGroupCompletions(analysis, document, position);
@@ -190109,6 +191081,48 @@ function projectCompletions(analysis, document, position) {
     const targets = listenerHandlerCompletions(listener, document);
     if (targets) return { isIncomplete: false, items: targets };
   }
+  const source = analysis.documents.get(document.uri);
+  const annotationSite = source ? contextualAnnotationSite(source, position) : null;
+  if (annotationSite) {
+    const schemaPath = projectAnnotationSchemaCompletions(
+      analysis,
+      document,
+      position,
+      annotationSite
+    );
+    if (schemaPath !== null) return { isIncomplete: false, items: schemaPath };
+  }
+  const expression = projectExpressionSnapshotAt(
+    analysis,
+    document,
+    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(
     document,
     position
@@ -190119,6 +191133,18 @@ function projectCompletions(analysis, document, position) {
       items: builtinMembers.map(projectBuiltinCompletionItem)
     };
   }
+  const expressionMembers = projectExpressionMemberCompletions(
+    analysis,
+    document,
+    position,
+    annotationSite
+  );
+  if (expressionMembers) {
+    return variantScopeInBody === null ? expressionMembers : {
+      ...expressionMembers,
+      items: [...expressionMembers.items, variantScopeInBody]
+    };
+  }
   const members2 = projectMemberCompletions(analysis, document, position);
   const variantScope = variantScopeInBody;
   if (members2 || variantScope) {
@@ -190153,43 +191179,16 @@ function projectCompletions(analysis, document, position) {
       }))
     };
   }
-  const source = analysis.documents.get(document.uri);
-  const annotationFields = source ? contextualAnnotationFields(source, position) : null;
+  const annotationFields = annotationSite?.fields;
   if (annotationFields) {
-    const activeOption = activeNamedArgument(document.text, position);
-    const activeField = activeOption ? annotationFields.find((field) => field.name === activeOption) : void 0;
-    const activeArgument = activeOption ?? activeAnnotationArgumentName(document.text, position);
-    if (activeArgument === NEO_VARIANT_FOLDER_SETTING && source) {
-      const folders = projectVariantFolderCompletions(
-        analysis,
-        source,
-        position
-      );
-      if (folders) return { isIncomplete: false, items: folders };
-    }
-    const enumCases = activeField ? generatedContractEnumCases(activeField.type) : null;
-    if (enumCases) {
-      return {
-        isIncomplete: false,
-        items: enumCases.map((name) => ({
-          label: `.${name}`,
-          kind: "enumMember",
-          ...activeField ? { detail: activeField.type } : {},
-          // The active-option matcher requires the contextual dot to have
-          // already been authored. VS Code replaces only the identifier word,
-          // so inserting another dot would produce `..Option`.
-          insertText: name
-        }))
-      };
-    }
     return {
       isIncomplete: false,
-      items: annotationFields.map((field) => ({
-        label: field.name,
-        kind: "property",
-        detail: field.type,
-        insertText: `${field.name}: `
-      }))
+      items: projectAnnotationArgumentCompletions(
+        analysis,
+        document,
+        position,
+        annotationFields
+      )
     };
   }
   const contextualEnum = projectContextualEnumCompletions(
@@ -190200,22 +191199,15 @@ function projectCompletions(analysis, document, position) {
   if (contextualEnum) {
     return { isIncomplete: false, items: contextualEnum };
   }
-  const constructorFields = projectConstructorArgumentCompletions(
+  const constructorNames = projectConstructorArgumentCompletions(
     analysis,
     document,
     position
   );
-  if (constructorFields) {
+  if (constructorNames) {
     return {
       isIncomplete: false,
-      items: constructorFields.map((field) => ({
-        label: field.name,
-        kind: "property",
-        // P65 §6. C#-style square brackets mark a defaulted parameter as
-        // omittable at the call site.
-        detail: field.defaultText === void 0 ? field.type : `[${field.type} = ${field.defaultText}]`,
-        insertText: `${field.name}: `
-      }))
+      items: constructorNames
     };
   }
   const initializerMembers = projectInitializerMemberCompletions(
@@ -190278,7 +191270,12 @@ function projectAnnotationCompletions(analysis, document, position) {
     return ["id", "listeners"].map((name) => ({
       label: `@${name}`,
       kind: "snippet",
-      insertText: name
+      insertText: name,
+      filterText: name,
+      textEdit: {
+        range: source.range(word.start, word.end),
+        newText: name
+      }
     }));
   }
   const names2 = projectAnnotationNamesAt(analysis, document, position);
@@ -190286,6 +191283,7 @@ function projectAnnotationCompletions(analysis, document, position) {
     label: `@${name}`,
     kind: "snippet",
     insertText: name,
+    filterText: name,
     textEdit: {
       range: source.range(word.start, word.end),
       newText: name
@@ -190347,7 +191345,8 @@ function projectDeclarationAnnotationNames(declaration) {
 function projectMemberAnnotationNames(member) {
   const names2 = ["id", "settings", "storage", "distribution"];
   if (member?.kind === "function") names2.push("effect");
-  if (member?.type.name === "List") names2.push("index", "column");
+  if (member?.type.name === "List" || member?.type.name === "Set")
+    names2.push("index", "column");
   return names2;
 }
 function projectContextualEnumCompletions(analysis, document, position) {
@@ -190639,6 +191638,90 @@ function projectBodyIndex(analysis, context) {
   }
   return index;
 }
+function projectExpressionMemberCompletions(analysis, document, position, annotationSite) {
+  const source = projectSourceText(document);
+  const offset = source.offsetAt(position);
+  const word = projectWordRange(document.text, offset);
+  const before = tokensBeforePosition(
+    projectSignificantTokens(analysis, document),
+    source.positionAt(word.start)
+  );
+  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)))
+    return null;
+  const expression = projectExpressionSnapshotAt(
+    analysis,
+    document,
+    dot.range.start,
+    annotationSite,
+    true
+  );
+  if (!expression) return null;
+  const result = complete(expression.snapshot, position);
+  return expression.bounded || result.items.length > 0 ? result : null;
+}
+function projectExpressionSnapshotAt(analysis, document, position, annotationSite = null, recover = false) {
+  const source = projectSourceText(document);
+  const root = initializerRootAt(analysis, document, position);
+  const argument2 = annotationSite?.annotation.arguments.find(
+    (argument3) => rangeContains(argument3.range, position)
+  );
+  const range2 = argument2?.range ?? root?.range;
+  if (!range2 && !recover) return null;
+  const cached = range2 && PROJECT_EXPRESSION_SNAPSHOT_CACHE.get(analysis)?.get(document)?.get(range2);
+  if (cached) return { snapshot: cached, bounded: true };
+  const language = listenerSourceContext(analysis, document, position);
+  const staticField = root?.slot.kind === "declared" && root.slot.field?.static;
+  let context = argument2 ? language.context : language.parameterContext(root?.constructorIndex);
+  if (staticField) {
+    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) {
+    documents = /* @__PURE__ */ new WeakMap();
+    PROJECT_EXPRESSION_SNAPSHOT_CACHE.set(analysis, documents);
+  }
+  let snapshots = documents.get(document);
+  if (!snapshots) {
+    snapshots = /* @__PURE__ */ new WeakMap();
+    documents.set(document, snapshots);
+  }
+  let snapshot = snapshots.get(key);
+  if (!snapshot) {
+    const initialStart = range2 ? source.offsetAt(range2.start) : 0;
+    let start = initialStart;
+    const end = range2 ? source.offsetAt(range2.end) : document.text.length;
+    const lexed = analysis.documents.get(document.uri)?.syntax ?? lex(document.text);
+    let sliced = sliceLexResult(lexed, start, end);
+    const tokens = sliced.tokens.filter((token) => token.kind !== "comment");
+    if (tokens[1]?.text === ":" || tokens[1]?.text === "=")
+      start = tokens[1].end;
+    else if (tokens[0]?.text === ":" || tokens[0]?.text === "=")
+      start = tokens[0].end;
+    if (start !== initialStart) sliced = sliceLexResult(lexed, start, end);
+    const syntax = analyzeNeoScriptSyntax(document.text, context.kind, sliced);
+    snapshot = {
+      uri: document.uri,
+      expressionRange: source.range(start, end),
+      source: syntax.lexed.source,
+      lexed: syntax.lexed,
+      parsed: syntax.parsed,
+      context,
+      project: projectBodyIndex(analysis, context)
+    };
+    snapshots.set(key, snapshot);
+  }
+  return { snapshot, bounded: range2 !== void 0 };
+}
 function projectWordRange(text, offset) {
   let start = offset;
   while (start > 0 && /[A-Za-z0-9_]/.test(text[start - 1] ?? "")) start--;
@@ -190851,37 +191934,203 @@ function projectBuiltinSymbolSignature(symbol) {
   }
   return `${formatType(symbol.type)} ${symbol.name}`;
 }
-function projectConstructorArgumentCompletions(analysis, document, position) {
+function projectAnnotationSchemaCompletions(analysis, document, position, site) {
+  const documentTokens = projectSignificantTokens(analysis, document);
+  const tokens = tokensBeforePosition(documentTokens, position);
+  const openIndex = activeCallOpenIndex(tokens, position);
+  if (openIndex < 0 || tokens[openIndex - 2]?.text !== "@") return null;
+  const active = activeCallArgument(tokens, openIndex, position);
+  if (active.label === null && callArgumentLabel(documentTokens, active.start, documentTokens.length) !== null)
+    return null;
+  const field = active.label === null ? site.fields[active.index] : site.fields.find((field2) => field2.name === active.label);
+  if (!field) return null;
+  const start = active.start + (active.label === null ? 0 : 2);
+  if (active.label === null && start === tokens.length) return null;
+  const items = annotationSchemaPathCompletions(
+    analysis,
+    document,
+    position,
+    site,
+    field.name,
+    documentTokens.slice(start, tokens.length),
+    documentTokens[tokens.length]
+  );
+  if (items === null || active.label !== null) return items;
+  return [
+    ...items,
+    ...projectAnnotationArgumentCompletions(
+      analysis,
+      document,
+      position,
+      site.fields
+    )
+  ];
+}
+function projectAnnotationArgumentCompletions(analysis, document, position, fields) {
+  const documentTokens = projectSignificantTokens(analysis, document);
+  const tokens = tokensBeforePosition(documentTokens, position);
+  const openIndex = activeCallOpenIndex(tokens, position);
+  if (openIndex < 0 || tokens[openIndex - 2]?.text !== "@") return [];
+  const active = activeCallArgument(tokens, openIndex, position);
+  let valueItems = [];
+  const named = callArgumentLabel(
+    documentTokens,
+    active.start,
+    documentTokens.length
+  );
+  if (active.label !== null || named === null) {
+    const field = active.label === null ? fields[active.index] : fields.find((field2) => field2.name === active.label);
+    const start = active.start + (active.label === null ? 0 : 2);
+    if (field && (active.label !== null || start < tokens.length)) {
+      const values = projectAnnotationValueCompletions(
+        analysis,
+        document,
+        position,
+        documentTokens,
+        tokens,
+        start,
+        field
+      );
+      if (values !== null) {
+        if (active.label !== null || tokens[start]?.text === ".") return values;
+        valueItems = values;
+      }
+    }
+  }
+  if (active.label !== null) return valueItems;
+  const first = documentTokens[active.start];
+  if (tokens.length > active.start + 1) return valueItems;
+  if (tokens.length > active.start && (!first || !isCallArgumentLabelToken(first)))
+    return valueItems;
+  const used = /* @__PURE__ */ new Set();
+  const args = projectCallArguments(documentTokens, openIndex);
+  for (let index = 0; index < args.length; index++) {
+    const argument2 = args[index];
+    if (first && positionCompare(argument2.start, first.range.start) === 0) {
+      continue;
+    }
+    const name = argument2.name ?? fields[index]?.name;
+    if (name !== void 0) used.add(name);
+  }
+  return [
+    ...argumentNameCompletions(
+      fields.filter((field) => !used.has(field.name)).map((field) => ({
+        ...field,
+        type: formatAnnotationValueType(field.type)
+      })),
+      documentTokens,
+      active.start,
+      tokens.length,
+      position
+    ),
+    ...valueItems
+  ];
+}
+function projectAnnotationValueCompletions(analysis, document, position, documentTokens, tokens, start, field) {
+  const dot = tokens[start]?.text === ".";
+  const wordIndex = start + (dot ? 1 : 0);
+  if (tokens.length > wordIndex + 1) return [];
+  const word = documentTokens[wordIndex];
+  const isWord = word?.kind === "identifier" || word?.text === "true" || word?.text === "false";
+  const editingWord = isWord && positionCompare(word.range.start, position) <= 0 && positionCompare(position, word.range.end) <= 0;
+  if (tokens.length > wordIndex && !editingWord) return [];
+  if (word && !editingWord && ![",", ")"].includes(word.text)) return [];
+  const atCursor = projectTokenAt(document, position);
+  if (atCursor?.kind === "comment" || atCursor?.kind === "string") return [];
+  const range2 = editingWord ? word.range : { start: position, end: position };
+  const enumCases = generatedContractEnumCases(field.type);
+  if (enumCases) {
+    return enumCases.map((name) => {
+      const insertText = dot ? name : `.${name}`;
+      return {
+        label: `.${name}`,
+        kind: "enumMember",
+        detail: field.type,
+        filterText: name,
+        insertText,
+        textEdit: { range: range2, newText: insertText }
+      };
+    });
+  }
+  if (dot) return [];
+  if (field.type === "bool" || field.type === "bool?") {
+    return ["true", "false"].map((name) => ({
+      label: name,
+      kind: "keyword",
+      detail: field.type,
+      insertText: name,
+      textEdit: { range: range2, newText: name }
+    }));
+  }
+  if (field.name === NEO_VARIANT_FOLDER_SETTING) {
+    const source = analysis.documents.get(document.uri);
+    const folders = source ? projectVariantFolderCompletions(analysis, source, position) : null;
+    if (folders)
+      return folders.map((item) => ({
+        ...item,
+        textEdit: { range: range2, newText: item.insertText ?? item.label }
+      }));
+  }
+  return null;
+}
+function projectConstructorArgumentCompletions(analysis, document, position, body) {
   const documentTokens = projectSignificantTokens(analysis, document);
   const tokens = tokensBeforePosition(documentTokens, position);
   const openIndex = activeCallOpenIndex(tokens, position);
   if (openIndex < 0) return null;
-  const callee = tokens[openIndex - 1];
+  const calleeIndex = projectCallCalleeIndex(tokens, openIndex);
+  const callee = tokens[calleeIndex];
   if (!callee) return null;
-  const beforeCallee = tokens[openIndex - 2];
-  const typeName = callee.text === "Pause" ? "Pause" : beforeCallee?.text === "new" ? callee.text : callee.text === "new" ? contextualConstructorType(analysis, document, callee.range.start) : null;
+  const beforeCallee = tokens[calleeIndex - 1];
+  const constructorType = body ? constructorTypeAt(body, position) : projectConstructorTypeName(analysis, document, callee, beforeCallee);
+  const typeName = callee.text === "Pause" ? "Pause" : constructorType;
   if (!typeName) return null;
   const active = activeCallArgument(tokens, openIndex, position);
   if (active.label !== null) return null;
-  const activeStart = documentTokens[active.start]?.range.start;
-  const used = /* @__PURE__ */ new Set();
-  for (const { name, start } of projectCallArguments(
+  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);
+  if (!fields) return null;
+  return argumentNameCompletions(
+    fields,
     documentTokens,
-    openIndex
-  )) {
-    if (name !== null && !(activeStart && positionCompare(start, activeStart) === 0)) {
-      used.add(name);
-    }
+    active.start,
+    tokens.length,
+    position
+  );
+}
+function projectCallCalleeIndex(tokens, openIndex) {
+  if (!/^>+$/.test(tokens[openIndex - 1]?.text ?? "")) return openIndex - 1;
+  let depth = 0;
+  for (let index = openIndex - 1; index >= 0; index--) {
+    const token = tokens[index];
+    if (/^>+$/.test(token.text)) depth += token.text.length;
+    else if (token.text === "<") {
+      if (--depth === 0)
+        return callOpenParenIndex(tokens, index - 1) === openIndex ? index - 1 : -1;
+    } else if (!isCallTypeArgumentToken(token)) return -1;
   }
-  const fields = lookupVariantFolderArgumentFields(typeName) ?? graphConstructorNamedArguments(typeName) ?? declaredConstructorNamedArguments(analysis, typeName, used);
-  if (!fields) return null;
-  return fields.filter((field) => !used.has(field.name));
+  return -1;
+}
+function unusedConstructorArguments(fields, args, activeIndex) {
+  const used = /* @__PURE__ */ new Set();
+  for (const argument2 of args) {
+    if (argument2.index === activeIndex) continue;
+    const parameter4 = neoScriptArgumentParameter(
+      fields,
+      argument2.name,
+      argument2.index
+    );
+    if (parameter4) used.add(parameter4.name.toLowerCase());
+  }
+  return fields.filter((field) => !used.has(field.name.toLowerCase()));
 }
 function lookupVariantFolderArgumentFields(typeName) {
   if (typeName !== NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME) return null;
   return NEO_LOOKUP_VARIANT_FOLDER_CONSTRUCTOR_ARGUMENTS;
 }
-function declaredConstructorNamedArguments(analysis, typeName, used) {
+function declaredConstructorNamedArguments(analysis, typeName, args, activeIndex) {
   const contract = classConstructionContract(
     projectConstructionIndex(analysis),
     typeName
@@ -190889,17 +192138,28 @@ function declaredConstructorNamedArguments(analysis, typeName, used) {
   if (!contract) return null;
   if (contract.kind === "implicit") return null;
   if (contract.kind === "required") {
-    return contract.parameters.map(parameterArgumentField);
+    return unusedConstructorArguments(
+      contract.parameters.map(parameterArgumentField),
+      args,
+      activeIndex
+    );
   }
-  const reachable = neoScriptApplicableSignatures(contract.constructors, [
-    ...used
-  ]);
+  const labels = projectCallArgumentLabels(args, activeIndex);
+  labels[activeIndex] = null;
+  const reachable = neoScriptApplicableSignatures(
+    contract.constructors,
+    labels
+  );
   const selected = reachable.length > 0 ? reachable : contract.constructors;
   const fields = /* @__PURE__ */ new Map();
   for (const constructor2 of selected) {
-    for (const parameter4 of constructor2.parameters) {
-      if (fields.has(parameter4.name)) continue;
-      fields.set(parameter4.name, parameterArgumentField(parameter4));
+    for (const field of unusedConstructorArguments(
+      constructor2.parameters.map(parameterArgumentField),
+      args,
+      activeIndex
+    )) {
+      const key = field.name.toLowerCase();
+      if (!fields.has(key)) fields.set(key, field);
     }
   }
   return [...fields.values()];
@@ -190911,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,
@@ -190972,10 +192230,6 @@ function constructibleMembers(analysis, typeName) {
 function sourceParameterSignatureText(parameter4) {
   return constructorParameterLabel(sourceParameterProjection(parameter4));
 }
-function functionParameterLabel(parameter4) {
-  const suffix = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.text}`;
-  return `${parameter4.type.name} ${parameter4.name}${suffix}`;
-}
 function projectConstructionIndex(analysis) {
   const cached = CONSTRUCTION_INDEX_CACHE.get(analysis);
   if (cached) return cached;
@@ -191188,22 +192442,6 @@ function graphConstructorNamedArguments(typeName) {
       return null;
   }
 }
-function activeAnnotationArgumentName(text, position) {
-  const lines = text.split("\n");
-  const prefix = [
-    ...lines.slice(0, position.line),
-    (lines[position.line] ?? "").slice(0, position.character)
-  ].join("\n");
-  return /([A-Za-z_][A-Za-z0-9_]*)\s*:\s*[A-Za-z0-9_]*$/.exec(prefix)?.[1] ?? null;
-}
-function activeNamedArgument(text, position) {
-  const lines = text.split("\n");
-  const prefix = [
-    ...lines.slice(0, position.line),
-    (lines[position.line] ?? "").slice(0, position.character)
-  ].join("\n");
-  return /([A-Za-z_][A-Za-z0-9_]*)\s*:\s*\.[A-Za-z0-9_]*$/.exec(prefix)?.[1] ?? null;
-}
 function referenceHoverText(analysis, symbol, reference2) {
   const storage = `\`${reference2.storage}\``;
   const member = symbol.ownerName === void 0 ? void 0 : cachedProjectIndex(analysis.project).typeByName.get(symbol.ownerName)?.members.find(({ name }) => name === symbol.name);
@@ -191250,7 +192488,20 @@ Requires a list of \`void(${type2})\` method targets. The member name is require
   }
   const body = projectBodySnapshotAt(analysis, document, position);
   if (body) return hover(body, position);
-  const builtin = projectBuiltinSymbolAt(document, position);
+  const sourceDocument = analysis.documents.get(document.uri);
+  const annotationSite = sourceDocument ? contextualAnnotationSite(sourceDocument, position) : null;
+  const token = projectTokenAt(document, position);
+  const parameter4 = annotationSite ? annotationParameterHover(document, position, annotationSite) : null;
+  if (parameter4) return parameter4;
+  const schemaPath = annotationSite && token ? annotationSchemaPathTarget(analysis, document, token, annotationSite) : void 0;
+  const expression = schemaPath === void 0 ? projectExpressionSnapshotAt(
+    analysis,
+    document,
+    position,
+    annotationSite
+  ) : null;
+  const inferred = expression ? hover(expression.snapshot, position) : null;
+  const builtin = inferred ? null : projectBuiltinSymbolAt(document, position);
   if (builtin) {
     if (builtin.symbol) {
       const documentation3 = builtin.symbol.documentation ? `
@@ -191276,7 +192527,7 @@ Schema id: \`${builtin.type.id}\``
     };
   }
   const resolved = projectSymbolAt(analysis, document, position);
-  if (!resolved) return null;
+  if (!resolved) return inferred;
   const owner = resolved.symbol.ownerName ? ` on \`${resolved.symbol.ownerName}\`` : "";
   const documentation = resolved.symbol.documentation ? `
 
@@ -191291,11 +192542,57 @@ ${referenceHoverText(analysis, resolved.symbol, resolved.symbol.reference)}` : "
   const setStorage = setStorageHoverMarkdown(analysis, resolved.symbol);
   const contract = resolved.symbol.kind === "class" ? projectConstructionContractMarkdown(analysis, resolved.symbol.name) : "";
   const lifecycle = resolved.symbol.kind === "member" && resolved.symbol.callable === true && resolved.symbol.static !== true && analysis.documents.get(resolved.symbol.location.uri)?.kind !== "flow" ? lifecycleHoverMarkdown(analysis, resolved.symbol.name) : "";
+  if (inferred) {
+    return {
+      ...inferred,
+      markdown: `${inferred.markdown}${reference2}${setStorage}${lifecycle}${contract}`
+    };
+  }
   return {
     range: resolved.token.range,
     markdown: `**${resolved.symbol.kind}** \`${resolved.symbol.name}\`${detail}${owner}${reference2}${setStorage}${documentation}${lifecycle}${contract}${id2}`
   };
 }
+function annotationParameterHover(document, position, site) {
+  const tokens = projectTokens(document);
+  const index = projectTokenIndexAt(document, position);
+  const token = tokens[index];
+  if (!token || !isCallArgumentLabelToken(token)) return null;
+  if (tokens[significantTokenIndex(tokens, index, 1)]?.text !== ":")
+    return null;
+  const previous = significantTokenIndex(tokens, index, -1);
+  if (tokens[previous]?.text !== "(" && tokens[previous]?.text !== ",")
+    return null;
+  const open2 = enclosingOpeners(tokens)[index];
+  const callee = tokens[significantTokenIndex(tokens, open2, -1)];
+  if (!callee || positionCompare(callee.range.start, site.annotation.nameRange.start) !== 0)
+    return null;
+  const field = site.fields.find((field2) => field2.name === token.text);
+  if (!field) return null;
+  const path = annotationSchemaPathKind(site.annotation.name, field.name);
+  let type2 = formatAnnotationValueType(field.type);
+  let description = "";
+  if (path === "member") {
+    type2 = "entry member";
+    description = "Names a member of the collection entry, such as `Slug`.";
+  } else if (path) {
+    type2 = path === "collection" ? "collection path" : "member path";
+    description = "Names a schema member using `Class.Member`.";
+  } else if (site.annotation.name === "settings" && field.name === "collectionValue") {
+    type2 = "collection reference";
+    description = "Selects a collection instance, such as `root.Assets.Items`. The `Reference(...)` wrapper is optional.";
+  }
+  const options = generatedContractEnumCases(field.type);
+  const choices = options?.length ? `
+
+Values: ${options.map((option) => `\`.${option}\``).join(", ")}.` : "";
+  return {
+    range: token.range,
+    markdown: `\`@${site.annotation.name}(${field.name}: ${type2})\`${description ? `
+
+${description}` : ""}${choices}`
+  };
+}
 function setStorageHoverMarkdown(analysis, symbol) {
   if (symbol.kind !== "member" || symbol.ownerName === void 0) return "";
   const owner = findTypeDeclaration(analysis, symbol.ownerName);
@@ -191467,7 +192764,8 @@ function projectSignatureHelp(analysis, document, position) {
   const openIndex = activeCallOpenIndex(tokens, position);
   if (openIndex < 0) return null;
   const open2 = tokens[openIndex];
-  const callee = tokens[openIndex - 1];
+  const calleeIndex = projectCallCalleeIndex(tokens, openIndex);
+  const callee = tokens[calleeIndex];
   if (!open2 || !callee) return null;
   const active = activeCallArgument(tokens, openIndex, position);
   const activeParameter = active.index;
@@ -191476,16 +192774,19 @@ function projectSignatureHelp(analysis, document, position) {
     active.start,
     documentTokens.length
   );
-  const beforeCallee = tokens[openIndex - 2];
+  const beforeCallee = tokens[calleeIndex - 1];
   if (beforeCallee?.text === "@") {
-    const source = analysis.documents.get(document.uri);
-    const contextual = source ? contextualAnnotationFields(source, position) : null;
-    const parameters = contextual?.map((field) => `${field.type} ${field.name}`) ?? annotationSignatureParameters(callee.text);
+    const source2 = analysis.documents.get(document.uri);
+    const contextual = source2 ? contextualAnnotationFields(source2, position) : null;
+    const parameters = contextual?.map((field) => ({
+      name: field.name,
+      label: `${formatAnnotationValueType(field.type)} ${field.name}`
+    })) ?? annotationSignatureParameters(callee.text);
     if (!parameters) return null;
     return signatureResult(
       `@${callee.text}`,
-      parameters,
-      neoScriptClampActiveParameter(activeParameter, parameters.length)
+      parameters.map((parameter4) => parameter4.label),
+      neoScriptActiveParameter(parameters, label, activeParameter)
     );
   }
   if (callee.text === "Reference") {
@@ -191493,7 +192794,11 @@ function projectSignatureHelp(analysis, document, position) {
     return signatureResult(
       "Reference",
       parameters,
-      neoScriptClampActiveParameter(activeParameter, parameters.length)
+      neoScriptActiveParameter(
+        [{ name: "id" }, { name: "withProvenance" }],
+        label,
+        activeParameter
+      )
     );
   }
   if (callee.text === "Pause") {
@@ -191513,8 +192818,9 @@ function projectSignatureHelp(analysis, document, position) {
   if (constructorType) {
     const overloads = declaredConstructorOverloads(analysis, constructorType);
     if (overloads) {
-      const labels = projectCallArguments(documentTokens, openIndex).map(
-        ({ name }) => name
+      const labels = projectCallArgumentLabels(
+        projectCallArguments(documentTokens, openIndex),
+        activeParameter
       );
       return constructorOverloadSignatures(
         constructorType,
@@ -191531,25 +192837,15 @@ function projectSignatureHelp(analysis, document, position) {
       neoScriptActiveParameter(parameters, label, activeParameter)
     );
   }
-  const functions = projectFunctionsNamed(analysis, callee.text);
-  if (functions.length === 0) return null;
-  return {
-    signatures: functions.map(({ owner, member }) => {
-      const parameters = member.parameters.map(functionParameterLabel);
-      return {
-        label: `${member.type.name} ${owner}.${member.name}(${parameters.join(", ")})`,
-        parameters: member.parameters.map((parameter4) => ({
-          label: functionParameterLabel(parameter4)
-        }))
-      };
-    }),
-    activeSignature: 0,
-    activeParameter: neoScriptActiveParameter(
-      functions[0].member.parameters,
-      label,
-      activeParameter
-    )
-  };
+  const source = analysis.documents.get(document.uri);
+  const expression = projectExpressionSnapshotAt(
+    analysis,
+    document,
+    callee.range.start,
+    source ? contextualAnnotationSite(source, callee.range.start) : null,
+    true
+  );
+  return expression ? signatureHelp(expression.snapshot, position) : null;
 }
 function declaredConstructorOverloads(analysis, typeName) {
   if (lookupVariantFolderArgumentFields(typeName) !== null) return null;
@@ -191581,25 +192877,21 @@ function projectInlayHints(analysis, document, range2) {
   );
   const delimiterEnds = projectDelimiterEnds(tokens);
   const hints = [];
-  for (let index = 0; index < tokens.length - 1; index++) {
-    const callee = tokens[index];
-    const open2 = tokens[index + 1];
+  for (let index = 0; index < tokens.length; index++) {
+    if (tokens[index]?.text !== "(") continue;
+    const calleeIndex = projectCallCalleeIndex(tokens, index);
+    const callee = tokens[calleeIndex];
     if (!callee || callee.kind !== "identifier" && callee.kind !== "type") {
       continue;
     }
     if (rangeItemAt(bodyContexts, callee.range.start)) {
       continue;
     }
-    if (!open2 || open2.text !== "(") continue;
-    const beforeCallee = tokens[index - 1];
+    const beforeCallee = tokens[calleeIndex - 1];
     if (beforeCallee?.text === "@") continue;
     if (declarationNames.has(positionKey(callee.range.start))) continue;
     if (range2 && positionCompare(callee.range.start, range2.end) > 0) break;
-    const callArguments2 = projectCallArguments(
-      tokens,
-      index + 1,
-      delimiterEnds
-    );
+    const callArguments2 = projectCallArguments(tokens, index, delimiterEnds);
     if (range2 && !callArguments2.some((argument2) => rangeContains(range2, argument2.start)))
       continue;
     const parameterNames = projectCallParameterNames(
@@ -191612,7 +192904,7 @@ function projectInlayHints(analysis, document, range2) {
     for (let argument2 = 0; argument2 < callArguments2.length; argument2++) {
       const argumentToken = callArguments2[argument2];
       if (!argumentToken || argumentToken.name !== null) continue;
-      const name = parameterNames[argument2];
+      const name = parameterNames[argumentToken.index];
       if (!name) continue;
       if (argumentToken.identifier && normalizeProjectHintName(argumentToken.identifier) === normalizeProjectHintName(name)) {
         continue;
@@ -191656,22 +192948,34 @@ function projectCallParameterNames(analysis, document, callee, beforeCallee) {
     beforeCallee
   );
   if (constructorType) {
+    const overloads = declaredConstructorOverloads(analysis, constructorType);
+    if (overloads) return neoScriptCommonParameterNames(overloads);
     const parameters = projectConstructorParameters(analysis, constructorType);
     if (parameters.length === 0) return null;
     return parameters.map((parameter4) => parameter4.name);
   }
-  const functions = projectFunctionsNamed(analysis, callee.text);
-  if (functions.length === 0) return null;
-  const arity = Math.max(
-    ...functions.map(({ member }) => member.parameters.length)
+  const source = analysis.documents.get(document.uri);
+  const expression = projectExpressionSnapshotAt(
+    analysis,
+    document,
+    callee.range.start,
+    source ? contextualAnnotationSite(source, callee.range.start) : null,
+    true
   );
-  return Array.from({ length: arity }, (_, parameterIndex) => {
-    const names2 = new Set(
-      functions.map(({ member }) => member.parameters[parameterIndex]?.name)
-    );
-    const [name] = names2;
-    return names2.size === 1 && name ? name : null;
-  });
+  if (expression) {
+    return callParametersAt(expression.snapshot, callee.range.start)?.map(
+      (parameter4) => parameter4.name
+    ) ?? null;
+  }
+  return null;
+}
+function projectCallArgumentLabels(args, activeIndex) {
+  const labels = Array.from(
+    { length: Math.max(activeIndex + 1, (args.at(-1)?.index ?? -1) + 1) },
+    () => null
+  );
+  for (const argument2 of args) labels[argument2.index] = argument2.name;
+  return labels;
 }
 function projectDelimiterEnds(tokens) {
   const ends = /* @__PURE__ */ new Map();
@@ -191689,6 +192993,7 @@ function projectDelimiterEnds(tokens) {
 function projectCallArguments(tokens, openIndex, delimiterEnds) {
   const result = [];
   let atArgumentStart = true;
+  let argumentIndex = 0;
   let depth = 0;
   for (let index = openIndex + 1; index < tokens.length; index++) {
     const token = tokens[index];
@@ -191704,11 +193009,13 @@ function projectCallArguments(tokens, openIndex, delimiterEnds) {
       break;
     } else if (depth === 0 && text === ",") {
       atArgumentStart = true;
+      argumentIndex++;
       continue;
     }
     if (atArgumentStart) {
       const name = callArgumentLabel(tokens, index, tokens.length);
       result.push({
+        index: argumentIndex,
         start: token.range.start,
         name,
         ...token.kind === "identifier" && (tokens[index + 1]?.text === "," || tokens[index + 1]?.text === ")") ? { identifier: token.text } : {}
@@ -191717,13 +193024,9 @@ function projectCallArguments(tokens, openIndex, delimiterEnds) {
     }
     if (opens && delimiterEnds) {
       index = delimiterEnds.get(index) ?? tokens.length;
-    } else if (text === "new" && tokens[index + 2]?.text === "<") {
-      let angles = 0;
-      index += 2;
-      for (; index < tokens.length; index++) {
-        if (tokens[index].text === "<") angles++;
-        else if (tokens[index].text === ">" && --angles === 0) break;
-      }
+    } else if (tokens[index + 1]?.text === "<") {
+      const open2 = callOpenParenIndex(tokens, index);
+      if (open2 >= 0) index = open2 - 1;
     }
   }
   return result;
@@ -191965,10 +193268,28 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
   const tokenIndex = projectTokenIndexAt(document, position);
   const sourceTokens = projectTokens(document);
   const token = sourceTokens[tokenIndex];
+  const previousIndex = significantTokenIndex(sourceTokens, tokenIndex, -1);
+  const previous = sourceTokens[previousIndex];
   if (!isProjectNameToken(token)) return null;
   if (isAnnotationName(sourceTokens, tokenIndex)) return null;
   const body = projectBodySnapshotAt(analysis, document, position);
-  const tupleLabel = body ? tupleLabelSymbolAtPosition(body, position) : null;
+  const sourceDocument = analysis.documents.get(document.uri);
+  const annotationSite = !body && sourceDocument ? contextualAnnotationSite(sourceDocument, position) : null;
+  if (annotationSite) {
+    const target = annotationSchemaPathTarget(
+      analysis,
+      document,
+      token,
+      annotationSite
+    );
+    if (target !== void 0) {
+      const location3 = target?.selectionLocation ?? target?.location;
+      const symbol = location3 && symbolsDeclaredAt(index, location3.uri, location3.range)[0];
+      return symbol ? { token, symbol } : null;
+    }
+  }
+  const executable = body ?? projectExpressionSnapshotAt(analysis, document, position, annotationSite)?.snapshot;
+  const tupleLabel = executable ? tupleLabelSymbolAtPosition(executable, position) : null;
   if (tupleLabel?.location)
     return {
       token,
@@ -191984,8 +193305,8 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     const symbol = location3 && symbolsDeclaredAt(index, location3.uri, location3.range)[0];
     return symbol ? { token, symbol } : null;
   }
-  if (body) {
-    const local = localSymbolAtPosition(body, position);
+  if (executable) {
+    const local = localSymbolAtPosition(executable, position);
     if (local?.location) {
       return {
         token,
@@ -191997,10 +193318,10 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
         }
       };
     }
-    const reference2 = referenceAtPosition(body, position);
-    const symbolId = reference2 ? resolveReferenceSymbolId(body, reference2) : null;
-    const executable = symbolId ? body.project.symbolById.get(symbolId) : void 0;
-    const location3 = executable?.selectionLocation ?? executable?.location;
+    const reference2 = referenceAtPosition(executable, position);
+    const symbolId = reference2 ? resolveReferenceSymbolId(executable, reference2) : null;
+    const target = symbolId ? executable.project.symbolById.get(symbolId) : void 0;
+    const location3 = target?.selectionLocation ?? target?.location;
     const located = location3 ? symbolsDeclaredAt(index, location3.uri, location3.range)[0] : void 0;
     const symbol = located ?? (symbolId ? index.byId.get(symbolId) : void 0);
     if (symbol) return { token, symbol };
@@ -192021,7 +193342,7 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
   const source = analysis.documents.get(document.uri);
   const typePosition = source && sourceTypeAt(source, token.range.start);
   const inScope = (symbol) => !symbol.scopeRange || symbol.location.uri === document.uri && rangeContains(symbol.scopeRange, token.range.start);
-  if (typePosition || sourceTokens[tokenIndex - 1]?.text === "new") {
+  if (typePosition || previous?.text === "new") {
     const types = candidates.filter((symbol) => isProjectTypeSymbol(symbol) && inScope(symbol)).sort(compareScopeSize);
     const innermost = types[0];
     if (innermost?.scopeRange) return { token, symbol: innermost };
@@ -192052,13 +193373,13 @@ 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 && sourceTokens[tokenIndex - 1]?.text !== ".") {
+  if (owner && previous?.text !== "." && previous?.text !== "?.") {
     const owned = visibleCandidates.filter(
       (symbol) => symbol.ownerName === owner
     );
     if (owned.length === 1) return { token, symbol: owned[0] };
   }
-  const dotOwner = sourceTokens[tokenIndex - 1]?.text === "." ? sourceTokens[tokenIndex - 2] : void 0;
+  const dotOwner = previous?.text === "." || previous?.text === "?." ? sourceTokens[significantTokenIndex(sourceTokens, previousIndex, -1)] : void 0;
   if (dotOwner) {
     const resolvedOwner = indexedProjectSymbolAt(
       analysis,
@@ -192360,6 +193681,10 @@ function activeCallArgument(tokens, openIndex, position) {
       parameter4++;
       start = end + 1;
     }
+    if (tokens[end + 1]?.text === "<") {
+      const open2 = callOpenParenIndex(tokens, end);
+      if (open2 >= 0) end = open2 - 1;
+    }
   }
   return {
     index: parameter4,
@@ -192370,28 +193695,31 @@ function activeCallArgument(tokens, openIndex, position) {
 function annotationSignatureParameters(name) {
   switch (name) {
     case "id":
-      return ["string id"];
+      return [{ name: "id", label: "string id" }];
     case "settings":
-      return ["named settings"];
+      return [{ name: "", label: "named settings" }];
     case "storage":
-      return ["StorageKind allowed"];
+      return [{ name: "allowed", label: "StorageKind allowed" }];
     case "distribution":
-      return ["NeoSubtreeDistribution kind"];
+      return [{ name: "kind", label: "NeoSubtreeDistribution kind" }];
     case "effect":
-      return ["NeoEffectKind kind"];
+      return [{ name: "kind", label: "NeoEffectKind kind" }];
     case "relations":
-      return ["relation descriptors"];
+      return [{ name: "", label: "relation descriptors" }];
     case "incomplete":
-      return ["string reason"];
+      return [{ name: "reason", label: "string reason" }];
     case "index":
-      return ["entry member", "ListIndexKind kind"];
+      return [
+        { name: "member", label: "entry member" },
+        { name: "kind", label: "ListIndexKind kind" }
+      ];
     case "column":
       return [
-        "entry member",
-        "int width",
-        "ColumnVisibilityKind visibility",
-        "ColumnPinKind pin",
-        "ColumnOverflowKind overflow"
+        { name: "member", label: "entry member" },
+        { name: "width", label: "int width" },
+        { name: "visibility", label: "ColumnVisibilityKind visibility" },
+        { name: "pin", label: "ColumnPinKind pin" },
+        { name: "overflow", label: "ColumnOverflowKind overflow" }
       ];
     default:
       return null;
@@ -192460,7 +193788,11 @@ function initializerRoots(source) {
           slot: {
             kind: "declared",
             type: member.type,
-            field: { owner: declaration.name, name: member.name }
+            field: {
+              owner: declaration.name,
+              name: member.name,
+              static: member.modifiers.includes("static")
+            }
           },
           range: member.initializer.range
         });
@@ -192526,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) => {
@@ -192578,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;
@@ -192590,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":
@@ -192628,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":
@@ -192725,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;
     }
@@ -192763,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,
@@ -192825,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;
@@ -192878,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++;
@@ -192896,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") {
@@ -193106,27 +194537,6 @@ function graphConstructorParameters(typeName) {
       return [];
   }
 }
-function projectFunctionsNamed(analysis, name) {
-  let byName = PROJECT_FUNCTIONS.get(analysis);
-  if (!byName) {
-    byName = /* @__PURE__ */ new Map();
-    for (const document of analysis.documents.values()) {
-      for (const declaration of document.declarations) {
-        if (declaration.kind === "global" || declaration.kind === "enum")
-          continue;
-        for (const member of declaration.members) {
-          if (member.kind !== "function") continue;
-          const entry = { owner: declaration.name, member };
-          const named = byName.get(member.name);
-          if (named) named.push(entry);
-          else byName.set(member.name, [entry]);
-        }
-      }
-    }
-    PROJECT_FUNCTIONS.set(analysis, byName);
-  }
-  return byName.get(name) ?? [];
-}
 function dialoguePathTokens(tokens, end) {
   const path = [];
   for (let i2 = end; i2 >= 0 && isProjectNameToken(tokens[i2]); i2 -= 2) {
@@ -193177,10 +194587,12 @@ function dialogueGroupCompletions(analysis, document, position) {
 function isDialogueGroupArgument(tokens, pathStart) {
   return tokens[pathStart - 1]?.text === ":" && tokens[pathStart - 2]?.text === "group";
 }
-var PROJECT_BODIES, PROJECT_BODY_INDEX_CACHE, PROJECT_BODY_SNAPSHOT_CACHE, SOURCE_TYPES, CONSTRUCTION_INDEX_CACHE, VARIANT_SCOPE_INDEX_CACHE, PROJECT_SYMBOL_INDEX_CACHE, ENCLOSING_OPENERS, significantTokens2, INITIALIZER_ROOTS, CONSTRUCTION_SITE_CACHE, DECLARATION_FIELDS, PROJECT_TYPE_DECLARATIONS, PROJECT_FUNCTIONS;
+var PROJECT_BODIES, PROJECT_EXPRESSION_SNAPSHOT_CACHE, PROJECT_BODY_INDEX_CACHE, PROJECT_BODY_SNAPSHOT_CACHE, SOURCE_TYPES, CONSTRUCTION_INDEX_CACHE, VARIANT_SCOPE_INDEX_CACHE, PROJECT_SYMBOL_INDEX_CACHE, ENCLOSING_OPENERS, significantTokens2, INITIALIZER_ROOTS, CONSTRUCTION_SITE_CACHE, DECLARATION_FIELDS, PROJECT_TYPE_DECLARATIONS;
 var init_project_source_language_features = __esm({
   "../packages/neoscript-language/src/project-source-language-features.ts"() {
     "use strict";
+    init_argument_name_completions();
+    init_project_annotation_path_completions();
     init_random_contract();
     init_analyzer();
     init_project_source_dialogue_groups();
@@ -193209,6 +194621,7 @@ var init_project_source_language_features = __esm({
     init_quick_fixes();
     init_syntax();
     PROJECT_BODIES = /* @__PURE__ */ new WeakMap();
+    PROJECT_EXPRESSION_SNAPSHOT_CACHE = /* @__PURE__ */ new WeakMap();
     PROJECT_BODY_INDEX_CACHE = /* @__PURE__ */ new WeakMap();
     PROJECT_BODY_SNAPSHOT_CACHE = /* @__PURE__ */ new WeakMap();
     SOURCE_TYPES = /* @__PURE__ */ new WeakMap();
@@ -193221,7 +194634,6 @@ var init_project_source_language_features = __esm({
     CONSTRUCTION_SITE_CACHE = /* @__PURE__ */ new WeakMap();
     DECLARATION_FIELDS = /* @__PURE__ */ new WeakMap();
     PROJECT_TYPE_DECLARATIONS = /* @__PURE__ */ new WeakMap();
-    PROJECT_FUNCTIONS = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -194341,7 +195753,7 @@ function sameLocationInList(target, locations) {
     (location3) => location3.uri === target.uri && location3.range.start.line === target.range.start.line && location3.range.start.character === target.range.start.character
   );
 }
-function locationKey2(location3) {
+function locationKey3(location3) {
   const { start, end } = location3.range;
   return JSON.stringify([
     location3.uri,
@@ -194909,7 +196321,7 @@ var init_service = __esm({
         const declaration = resolved.symbol;
         const family = projectReferenceFamily(analysis, declaration, index);
         const familyLocations = new Set(
-          family.map((member) => locationKey2(member.location))
+          family.map((member) => locationKey3(member.location))
         );
         const familyIds = new Set(
           family.flatMap((member) => member.id === null ? [] : [member.id])
@@ -194932,11 +196344,11 @@ var init_service = __esm({
               candidate.range.start,
               index
             )?.symbol;
-            if (!candidateSymbol || !familyLocations.has(locationKey2(candidateSymbol.location))) {
+            if (!candidateSymbol || !familyLocations.has(locationKey3(candidateSymbol.location))) {
               continue;
             }
             const location3 = { uri: state.document.uri, range: candidate.range };
-            if (!includeDeclaration && familyLocations.has(locationKey2(location3))) {
+            if (!includeDeclaration && familyLocations.has(locationKey3(location3))) {
               continue;
             }
             locations.push(location3);
@@ -194951,7 +196363,7 @@ var init_service = __esm({
             const symbolId = resolveReferenceSymbolId(snapshot, candidate);
             if (symbolId === null) continue;
             const matches = familyIds.has(symbolId) || definition(snapshot, candidate.range.start).some(
-              (location3) => familyLocations.has(locationKey2(location3))
+              (location3) => familyLocations.has(locationKey3(location3))
             );
             if (!matches) continue;
             locations.push({ uri: state.document.uri, range: candidate.range });
@@ -194959,7 +196371,7 @@ var init_service = __esm({
           if (declaration.kind !== "parameter") continue;
           for (const label of namedArgumentLabels(snapshot)) {
             const parameter4 = label.parameter.selectionLocation;
-            if (parameter4 && familyLocations.has(locationKey2(parameter4)))
+            if (parameter4 && familyLocations.has(locationKey3(parameter4)))
               locations.push({ uri: state.document.uri, range: label.range });
           }
         }
@@ -237078,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.0");
+    console.log("0.89.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {