@neocompose/cli 0.26.1 → 0.26.3

package/dist/neo.mjs

@@ -169,6 +169,9 @@ function warn(text) {
 function note(text) {
   console.log(color.dim(text));
 }
+function pad(text, width) {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
 function paintChangeKind(kind) {
   const painter = CHANGE_KIND_COLOR[kind];
   return painter === void 0 ? kind : painter(kind);
@@ -2143,16 +2146,28 @@ function complete(snapshot, position) {
     candidates = switchCaseCandidates;
   } else if (tail && (tail.kind === "punctuation" && tail.text === "." || tail.kind === "operator" && tail.text === "?.")) {
     const receiverTokens = expressionTokensBefore(tokens, tokens.length - 1);
-    const resolved = resolveChain(snapshot, receiverTokens, offset);
-    candidates = completionItemsForResolution(snapshot, resolved, word);
+    if (receiverTokens.length === 0 || isContextualCompletionDot(snapshot.source.text, word.start)) {
+      candidates = contextualEnumCompletionItems(
+        snapshot,
+        expectedTypeAt(snapshot, word.start),
+        word
+      );
+    } else {
+      const resolved = resolveChain(snapshot, receiverTokens, offset);
+      candidates = completionItemsForResolution(snapshot, resolved, word);
+    }
   } else if (tail?.kind === "identifier" && tail.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD) {
-    candidates = constructorCompletionItems(snapshot, word);
+    candidates = constructorCompletionItems(
+      snapshot,
+      word,
+      expectedTypeAt(snapshot, word.start)
+    );
   } else if (isTypePosition(tokens)) {
     candidates = typeCompletionItems(snapshot, word);
   } else if (isLambdaParameterPosition(tokens)) {
     candidates = [];
   } else {
-    candidates = topLevelCompletionItems(snapshot, offset, word);
+    candidates = contextualCompletionItems(snapshot, offset, word);
   }
   return {
     isIncomplete: hasUnclosedConstruct(snapshot.lexed.tokens, offset),
@@ -2230,12 +2245,33 @@ function signatureHelp(snapshot, position) {
   if (call.kind === "constructor") {
     const type = resolution?.staticType;
     const constructor2 = type?.constructorSignature;
-    if (!type || !constructor2) return null;
+    const declared = type?.declaredConstructors ?? [];
+    if (!type) return null;
     const activeParameter2 = countTopLevelCommas(
       snapshot.source.text,
       call.openParenOffset + 1,
       offset
     );
+    if (declared.length > 0) {
+      return {
+        signatures: declared.map((candidate) => ({
+          label: `${type.name}(${candidate.parameters.map(
+            (parameter4) => `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}`
+          ).join(", ")})`,
+          ...candidate.documentation ? { documentation: candidate.documentation } : {},
+          parameters: candidate.parameters.map((parameter4) => ({
+            label: `${formatType(parameter4.type, snapshot.project)} ${parameter4.name}`,
+            ...parameter4.documentation ? { documentation: parameter4.documentation } : {}
+          }))
+        })),
+        activeSignature: 0,
+        activeParameter: Math.min(
+          activeParameter2,
+          Math.max(0, (declared[0]?.parameters.length ?? 1) - 1)
+        )
+      };
+    }
+    if (!constructor2) return null;
     return {
       signatures: [
         {
@@ -2283,19 +2319,18 @@ function inlayHints(snapshot, range2) {
   const hints = [];
   for (const call of snapshot.parsed.calls) {
     if (call.kind !== "constructor") continue;
-    const constructor2 = snapshot.project.typeByName.get(
-      call.name
-    )?.constructorSignature;
-    if (!constructor2) continue;
+    const type = snapshot.project.typeByName.get(call.name);
+    const parameterNames = constructorParameterNames(type);
+    if (!parameterNames) continue;
     for (let index = 0; index < call.argumentRanges.length; index++) {
       const argumentRange = call.argumentRanges[index];
-      const parameter4 = constructor2.parameters[index];
-      if (!argumentRange || !parameter4) continue;
+      const parameterName = parameterNames[index];
+      if (!argumentRange || !parameterName) continue;
       const position = firstNonWhitespacePosition(snapshot, argumentRange);
       if (range2 && !positionInRange(position, range2)) continue;
       hints.push({
         position,
-        label: `${parameter4.name}:`,
+        label: `${parameterName}:`,
         kind: "parameter",
         paddingRight: true
       });
@@ -2303,6 +2338,22 @@ function inlayHints(snapshot, range2) {
   }
   return hints;
 }
+function constructorParameterNames(type) {
+  const declared = type?.declaredConstructors ?? [];
+  if (declared.length > 0) {
+    const arity = Math.max(
+      ...declared.map((constructor2) => constructor2.parameters.length)
+    );
+    return Array.from({ length: arity }, (_, index) => {
+      const names = new Set(
+        declared.map((constructor2) => constructor2.parameters[index]?.name)
+      );
+      const [name] = names;
+      return names.size === 1 && name ? name : null;
+    });
+  }
+  return type?.constructorSignature?.parameters.map((parameter4) => parameter4.name) ?? null;
+}
 function documentSymbols(snapshot) {
   const unitSymbols = snapshot.parsed.units.map((unit) => ({
     name: unit.kind,
@@ -2439,8 +2490,9 @@ function isValidNeoIdentifier(name) {
 function isValidRenameIdentifier(name) {
   return isValidNeoIdentifier(name);
 }
-function topLevelCompletionItems(snapshot, offset, word) {
+function contextualCompletionItems(snapshot, offset, word) {
   const items = [];
+  const expectedType = expectedTypeAt(snapshot, word.start);
   if (insideCatchBody(snapshot, offset)) {
     items.push(
       completion(
@@ -2454,7 +2506,12 @@ function topLevelCompletionItems(snapshot, offset, word) {
       )
     );
   }
+  const statementStart = isStatementStart(snapshot.lexed.tokens, word.start);
   for (const keyword of NEOSCRIPT_KEYWORDS) {
+    if (!statementStart && statementOnlyKeyword(keyword)) continue;
+    if (!statementStart && expectedType !== null && !literalKeywordMatchesExpectedType(keyword, expectedType)) {
+      continue;
+    }
     items.push(
       completion(
         keyword,
@@ -2467,6 +2524,7 @@ function topLevelCompletionItems(snapshot, offset, word) {
     );
   }
   for (const snippet of NEOSCRIPT_STATEMENT_SNIPPETS) {
+    if (!statementStart) continue;
     items.push(
       completion(
         snippet.label,
@@ -2479,60 +2537,282 @@ function topLevelCompletionItems(snapshot, offset, word) {
       )
     );
   }
-  items.push(
-    completion(
-      NEOSCRIPT_INFERRED_LOCAL_KEYWORD,
-      "snippet",
-      "var ${1:name} = ${0:value};",
-      "Inferred local declaration",
-      word,
-      snapshot,
-      "snippet"
-    )
-  );
-  items.push(
-    completion(
-      NEOSCRIPT_CONSTRUCTOR_KEYWORD,
-      "snippet",
-      "new ${1:ClassName}(${0})",
-      "Construct a Class value",
-      word,
-      snapshot,
-      "snippet"
-    )
-  );
-  for (const primitive3 of NEOSCRIPT_PRIMITIVE_TYPES) {
+  if (statementStart) {
     items.push(
       completion(
-        primitive3,
-        "keyword",
-        primitive3,
-        "Primitive type",
+        NEOSCRIPT_INFERRED_LOCAL_KEYWORD,
+        "snippet",
+        "var ${1:name} = ${0:value};",
+        "Inferred local declaration",
         word,
-        snapshot
+        snapshot,
+        "snippet"
+      )
+    );
+  }
+  const expectedNamed = expectedType?.kind === "named" ? snapshot.project.typeById.get(expectedType.typeId) : void 0;
+  if (expectedType === null || expectedNamed?.kind === "class" || expectedNamed?.kind === "interface") {
+    items.push(
+      completion(
+        NEOSCRIPT_CONSTRUCTOR_KEYWORD,
+        "snippet",
+        "new ${1:ClassName}(${0})",
+        "Construct a Class value",
+        word,
+        snapshot,
+        "snippet"
+      )
+    );
+  }
+  if (statementStart && expectedType === null) {
+    for (const primitive3 of NEOSCRIPT_PRIMITIVE_TYPES) {
+      items.push(
+        completion(
+          primitive3,
+          "keyword",
+          primitive3,
+          "Primitive type",
+          word,
+          snapshot
+        )
+      );
+    }
+    items.push(
+      completion(
+        "Dictionary",
+        "snippet",
+        "Dictionary<string, ${1:T}>",
+        "Dictionary type",
+        word,
+        snapshot,
+        "snippet"
       )
     );
   }
-  items.push(
-    completion(
-      "Dictionary",
-      "snippet",
-      "Dictionary<string, ${1:T}>",
-      "Dictionary type",
-      word,
-      snapshot,
-      "snippet"
-    )
-  );
   for (const symbol of scopeAt(snapshot, offset)) {
+    if (expectedType !== null && !isNeoScriptTypeAssignable(
+      symbol.returnType ?? symbol.type,
+      expectedType,
+      snapshot.project
+    )) {
+      continue;
+    }
     items.push(symbolCompletion(symbol, word, snapshot));
   }
-  for (const type of snapshot.project.typeByName.values()) {
-    if (type.kind === "builtin" && type.name.startsWith("__")) continue;
-    items.push(typeCompletion(type, word, snapshot));
+  if (statementStart && expectedType === null) {
+    for (const type of snapshot.project.typeByName.values()) {
+      if (type.kind === "builtin" && type.name.startsWith("__")) continue;
+      items.push(typeCompletion(type, word, snapshot));
+    }
   }
   return items;
 }
+function contextualEnumCompletionItems(snapshot, expected, word) {
+  if (expected?.kind !== "named") return [];
+  const type = snapshot.project.typeById.get(expected.typeId);
+  if (type?.kind !== "enum") return [];
+  return type.members.filter((member) => member.kind === "enumMember").map((member) => {
+    const item = symbolCompletion(member, word, snapshot);
+    return {
+      ...item,
+      label: `.${member.name}`,
+      insertText: member.name,
+      textEdit: {
+        range: snapshot.source.range(word.start, word.end),
+        newText: member.name
+      }
+    };
+  });
+}
+function isContextualCompletionDot(text, wordStart) {
+  if (text[wordStart - 1] !== ".") return false;
+  let cursor = wordStart - 2;
+  while (cursor >= 0 && /\s/.test(text[cursor] ?? "")) cursor--;
+  const beforeDot = text[cursor];
+  if (beforeDot !== void 0 && /[A-Za-z0-9_]/.test(beforeDot)) {
+    const precedingWord = /[A-Za-z_][A-Za-z0-9_]*$/.exec(
+      text.slice(0, cursor + 1)
+    )?.[0];
+    return precedingWord === "return" || precedingWord === "case";
+  }
+  return beforeDot === void 0 || !/[A-Za-z0-9_\])}]/.test(beforeDot);
+}
+function expectedTypeAt(snapshot, offset) {
+  const call = [...snapshot.parsed.calls].filter(
+    (candidate) => candidate.openParenOffset < offset && (candidate.closeParenOffset === void 0 || candidate.closeParenOffset >= offset)
+  ).sort((left, right) => right.openParenOffset - left.openParenOffset)[0];
+  if (call) {
+    const reference2 = snapshot.parsed.references.find(
+      (candidate) => candidate.range.start.line === call.nameRange.start.line && candidate.range.start.character === call.nameRange.start.character
+    );
+    const resolution = reference2 ? resolveReference(snapshot, reference2) : null;
+    const index = countTopLevelCommas(
+      snapshot.source.text,
+      call.openParenOffset + 1,
+      offset
+    );
+    const parameterType = call.kind === "constructor" ? constructorParameterTypeAt(resolution?.staticType, index, snapshot) : resolution?.symbol?.parameters?.[index]?.type;
+    if (parameterType) {
+      return expectedCollectionElementType(
+        parameterType,
+        snapshot.lexed.tokens,
+        call.openParenOffset + 1,
+        offset
+      );
+    }
+  }
+  const local = snapshot.parsed.locals.filter((candidate) => {
+    const first = candidate.initializerTokens?.[0];
+    return !candidate.inferred && first !== void 0 && first.start <= offset && offset <= snapshot.source.offsetAt(candidate.declarationRange.end);
+  }).sort((left, right) => right.scopeStart - left.scopeStart)[0];
+  if (local) {
+    const first = local.initializerTokens?.[0];
+    return expectedCollectionElementType(
+      resolveDeclaredType(local, snapshot),
+      snapshot.lexed.tokens,
+      first?.start ?? offset,
+      offset
+    );
+  }
+  const tokens = significantTokensBefore(snapshot.lexed.tokens, offset);
+  const boundary = lastStatementBoundary(tokens);
+  for (let index = tokens.length - 1; index > boundary; index--) {
+    const token = tokens[index];
+    if (token?.kind !== "operator" || token.text !== "=") continue;
+    const left = expressionTokensBefore(tokens, index);
+    const resolution = resolveChain(snapshot, left, offset);
+    if (resolution) {
+      return expectedCollectionElementType(
+        resolution.type,
+        tokens,
+        token.end,
+        offset
+      );
+    }
+    break;
+  }
+  for (let index = tokens.length - 1; index > boundary; index--) {
+    const token = tokens[index];
+    if (token?.kind !== "operator" || token.text !== "==" && token.text !== "!=") {
+      continue;
+    }
+    const left = expressionTokensBefore(tokens, index);
+    const type = resolveChain(snapshot, left, offset)?.type ?? inferExpressionType(left, snapshot, left[0]?.start ?? offset);
+    if (!isUnknownExpectedType(type)) return type;
+  }
+  const futureComparison = expectedTypeFromComparisonRight(snapshot, offset);
+  if (futureComparison) return futureComparison;
+  const tail = tokens.at(-1);
+  if (tail?.kind === "operator" && ["!", "&&", "||"].includes(tail.text) || tail?.kind === "punctuation" && tail.text === "(" && tokens.at(-2)?.kind === "keyword" && ["if", "while"].includes(tokens.at(-2)?.text ?? "")) {
+    return { kind: "primitive", name: "bool" };
+  }
+  const throwToken = tokens.slice(boundary + 1).find((token) => token.kind === "keyword" && token.text === "throw");
+  if (throwToken) return { kind: "primitive", name: "string" };
+  const returnToken = tokens.slice(boundary + 1).find((token) => token.kind === "keyword" && token.text === "return");
+  if (returnToken && snapshot.context.returnType) {
+    return expectedCollectionElementType(
+      snapshot.context.returnType,
+      tokens,
+      returnToken.end,
+      offset
+    );
+  }
+  return null;
+}
+function expectedTypeFromComparisonRight(snapshot, offset) {
+  const tokens = snapshot.lexed.tokens.filter(
+    (token) => token.kind !== "comment" && token.kind !== "eof"
+  );
+  let operatorIndex = -1;
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (!token || token.start < offset) continue;
+    if (token.kind === "punctuation" && [";", "{", "}"].includes(token.text)) {
+      break;
+    }
+    if (token.kind === "operator" && (token.text === "==" || token.text === "!=")) {
+      operatorIndex = index;
+      break;
+    }
+  }
+  if (operatorIndex < 0) return null;
+  const right = [];
+  let depth = 0;
+  for (let index = operatorIndex + 1; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token.kind === "punctuation" && ["(", "["].includes(token.text)) {
+      depth++;
+    } else if (token.kind === "punctuation" && [")", "]"].includes(token.text)) {
+      if (depth === 0) break;
+      depth--;
+    }
+    if (depth === 0 && token.kind === "punctuation" && [";", ",", "{"].includes(token.text)) {
+      break;
+    }
+    right.push(token);
+  }
+  const type = inferExpressionType(right, snapshot, right[0]?.start ?? offset);
+  return isUnknownExpectedType(type) ? null : type;
+}
+function isUnknownExpectedType(type) {
+  return type.kind === "primitive" && type.name === "unknown";
+}
+function constructorParameterTypeAt(type, index, snapshot) {
+  const declared = (type?.declaredConstructors ?? []).map((constructor2) => constructor2.parameters[index]?.type).filter(
+    (candidate) => candidate !== void 0
+  );
+  if ((type?.declaredConstructors?.length ?? 0) === 0) {
+    return type?.constructorSignature?.parameters[index]?.parameterType;
+  }
+  if (declared.length === 0) return void 0;
+  const first = declared[0];
+  return declared.every(
+    (candidate) => isNeoScriptTypeAssignable(candidate, first, snapshot.project) && isNeoScriptTypeAssignable(first, candidate, snapshot.project)
+  ) ? first : void 0;
+}
+function expectedCollectionElementType(initial, tokens, start, end) {
+  let expected = initial;
+  const stack = [];
+  for (const token of tokens) {
+    if (token.start < start || token.end > end || token.kind !== "punctuation") {
+      continue;
+    }
+    if (token.text === "[") {
+      stack.push(expected);
+      if (expected.kind === "list" || expected.kind === "set") {
+        expected = expected.elementType;
+      }
+    } else if (token.text === "]") {
+      expected = stack.pop() ?? expected;
+    }
+  }
+  return expected;
+}
+function lastStatementBoundary(tokens) {
+  for (let index = tokens.length - 1; index >= 0; index--) {
+    const token = tokens[index];
+    if (token?.kind === "punctuation" && (token.text === ";" || token.text === "{" || token.text === "}")) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isStatementStart(tokens, offset) {
+  const significant = significantTokensBefore(tokens, offset);
+  const tail = significant.at(-1);
+  return tail === void 0 || tail.kind === "punctuation" && (tail.text === ";" || tail.text === "{" || tail.text === "}") || tail.kind === "punctuation" && tail.text === ":";
+}
+function statementOnlyKeyword(keyword) {
+  return !["true", "false", "null", "is"].includes(keyword);
+}
+function literalKeywordMatchesExpectedType(keyword, expected) {
+  if (keyword === "true" || keyword === "false") {
+    return expected.kind === "primitive" && expected.name === "bool";
+  }
+  if (keyword === "null") return expected.nullable === true;
+  return false;
+}
 function catchFilterCompletionItems(snapshot, offset, word) {
   const prefix = snapshot.source.text.slice(0, offset);
   if (!/\bcatch\s*\(\s*string\s+[A-Za-z_][A-Za-z0-9_]*\s*\)\s*$/.test(prefix)) {
@@ -2682,16 +2962,24 @@ function typeCompletionItems(snapshot, word) {
   }
   return items;
 }
-function constructorCompletionItems(snapshot, word) {
+function constructorCompletionItems(snapshot, word, expected = null) {
   return [...snapshot.project.typeByName.values()].flatMap((type) => {
     const signature = type.constructorSignature;
-    if (!signature) return [];
+    const declared = type.declaredConstructors ?? [];
+    if (!signature && declared.length === 0) return [];
+    if (expected !== null && !isNeoScriptTypeAssignable(
+      { kind: "named", typeId: type.id },
+      expected,
+      snapshot.project
+    )) {
+      return [];
+    }
     const insertText = `${type.name}(`;
     return [
       {
         label: type.name,
         kind: "class",
-        detail: formatConstructorSignature(type.name, signature, snapshot),
+        detail: declared.length > 0 ? `${type.name} \u2014 ${declared.length} declared constructor${declared.length === 1 ? "" : "s"}` : signature ? formatConstructorSignature(type.name, signature, snapshot) : type.name,
         ...type.documentation ? { documentation: type.documentation } : {},
         insertText,
         textEdit: {
@@ -2764,6 +3052,22 @@ function membersForType(snapshot, type) {
   return [];
 }
 function resolveReference(snapshot, reference2) {
+  if (!reference2.member && (isTypeAnnotationReference(snapshot, reference2) || isConstructorTypeReference(snapshot, reference2))) {
+    const type = snapshot.project.typeByName.get(reference2.name);
+    if (type) {
+      return {
+        type: { kind: "named", typeId: type.id },
+        staticType: type
+      };
+    }
+  }
+  if (reference2.member && isContextualCompletionDot(snapshot.source.text, reference2.start)) {
+    const contextual = resolveContextualExpectedEnumReference(
+      snapshot,
+      reference2
+    );
+    if (contextual) return contextual;
+  }
   const tokens = snapshot.lexed.tokens.filter(
     (token) => token.kind !== "comment" && token.kind !== "eof" && token.end <= reference2.end
   );
@@ -2814,6 +3118,16 @@ function resolveContextualSwitchEnumReference(snapshot, reference2) {
   );
   return symbol ? { type: symbol.type, symbol } : null;
 }
+function resolveContextualExpectedEnumReference(snapshot, reference2) {
+  const expected = expectedTypeAt(snapshot, reference2.start);
+  if (expected?.kind !== "named") return null;
+  const type = snapshot.project.typeById.get(expected.typeId);
+  if (type?.kind !== "enum") return null;
+  const symbol = type.members.find(
+    (member) => member.kind === "enumMember" && member.name === reference2.name
+  );
+  return symbol ? { type: symbol.type, symbol } : null;
+}
 function switchCaseEnumContext(snapshot, offset) {
   for (const statement of snapshot.parsed.switches) {
     for (const section of statement.sections) {
@@ -3067,6 +3381,19 @@ function scopeAt(snapshot, offset) {
       )
     );
   }
+  const declaringType = snapshot.context.declaringType;
+  if (snapshot.context.implicitMemberAccess === true && declaringType?.kind === "named") {
+    const owner = snapshot.project.typeById.get(declaringType.typeId);
+    if (owner) {
+      for (const member of owner.members) {
+        if (snapshot.context.staticMember === true && member.static !== true) {
+          continue;
+        }
+        if (!isMemberCompletionAccessible(snapshot, owner, member)) continue;
+        result.push(withScope(member, 0, snapshot.source.text.length));
+      }
+    }
+  }
   if (effectiveDocumentKind(snapshot, offset) === "setter" && snapshot.context.returnType) {
     result.push(
       withScope(
@@ -3903,6 +4230,11 @@ function isTypeAnnotationReference(snapshot, reference2) {
     (local) => local.typeTokens.some((token) => token.start === reference2.start)
   );
 }
+function isConstructorTypeReference(snapshot, reference2) {
+  return snapshot.parsed.calls.some(
+    (call) => call.kind === "constructor" && call.nameRange.start.line === reference2.range.start.line && call.nameRange.start.character === reference2.range.start.character
+  );
+}
 var IDENTIFIER_PATTERN, RESERVED_NAMES;
 var init_analyzer = __esm({
   "../packages/neoscript-language/src/analyzer.ts"() {
@@ -21592,6 +21924,7 @@ function compileProjectSourceBodies(documents) {
   const graph = buildProjectGraph(documents);
   const projectIndex = createProjectIndex(graph.project);
   const bodies = [];
+  const contexts = [];
   const diagnostics = [];
   for (const [uri, document] of documents) {
     if (document.kind !== "definition") continue;
@@ -21636,6 +21969,7 @@ function compileProjectSourceBodies(documents) {
           },
           projectIndex,
           bodies,
+          contexts,
           diagnostics
         });
       }
@@ -21671,6 +22005,7 @@ function compileProjectSourceBodies(documents) {
           },
           projectIndex,
           bodies,
+          contexts,
           diagnostics
         });
       }
@@ -21711,6 +22046,7 @@ function compileProjectSourceBodies(documents) {
             },
             projectIndex,
             bodies,
+            contexts,
             diagnostics
           });
           continue;
@@ -21735,15 +22071,24 @@ function compileProjectSourceBodies(documents) {
             context: { ...baseContext2, kind: unit },
             projectIndex,
             bodies,
+            contexts,
             diagnostics
           });
         }
       }
     }
   }
-  return { project: graph.project, bodies, diagnostics };
+  return { project: graph.project, bodies, contexts, diagnostics };
 }
 function compileBody(args) {
+  args.contexts.push({
+    uri: args.uri,
+    ownerName: args.owner.declaration.name,
+    memberName: args.memberName,
+    unit: args.unit,
+    range: args.range,
+    context: args.context
+  });
   const source = new SourceText(args.document.sourceText);
   const start = source.offsetAt(args.range.start);
   const end = source.offsetAt(args.range.end);
@@ -24063,6 +24408,7 @@ function analyzeNeoProjectSources(inputs, parsedDocuments = /* @__PURE__ */ new
     symbols,
     project: bodyCompilation.project,
     compiledBodies: bodyCompilation.bodies,
+    bodyContexts: bodyCompilation.contexts,
     diagnostics
   };
 }
@@ -24890,9 +25236,25 @@ var init_quick_fixes = __esm({
 
 // ../packages/neoscript-language/src/project-source-language-features.ts
 function projectDiagnostics(analysis, uri) {
-  return analysis.diagnostics.filter((diagnostic) => diagnostic.uri === uri).map(({ uri: _uri, ...diagnostic }) => diagnostic);
+  return analysis.diagnostics.filter((diagnostic) => diagnostic.uri === uri).map((diagnostic) => ({
+    range: diagnostic.range,
+    severity: diagnostic.severity,
+    message: diagnostic.message,
+    ...diagnostic.code === void 0 ? {} : { code: diagnostic.code },
+    ...diagnostic.source === void 0 ? {} : { source: diagnostic.source },
+    ...diagnostic.relatedInformation === void 0 ? {} : { relatedInformation: diagnostic.relatedInformation },
+    ...diagnostic.suggestions === void 0 ? {} : { suggestions: diagnostic.suggestions }
+  }));
 }
 function projectCompletions(analysis, document, position) {
+  const body = projectBodySnapshotAt(analysis, document, position);
+  if (body) return complete(body, position);
+  const annotations = projectAnnotationCompletions(
+    analysis,
+    document,
+    position
+  );
+  if (annotations) return { isIncomplete: false, items: annotations };
   const members = projectMemberCompletions(analysis, document, position);
   if (members) {
     return {
@@ -24977,13 +25339,126 @@ function projectCompletions(analysis, document, position) {
   if (initializerMembers) {
     return { isIncomplete: false, items: initializerMembers };
   }
+  const contextualEnum = projectContextualEnumCompletions(
+    analysis,
+    document,
+    position
+  );
+  if (contextualEnum) {
+    return { isIncomplete: false, items: contextualEnum };
+  }
+  return projectFallbackCompletions(analysis, document, position);
+}
+function projectAnnotationCompletions(analysis, document, position) {
+  const source = new SourceText(document.text);
+  const offset = source.offsetAt(position);
+  const word = projectWordRange(document.text, offset);
+  if (document.text[word.start - 1] !== "@") return null;
+  if (initializerRootAt(analysis, document, position)) return [];
+  const names = projectAnnotationNamesAt(analysis, document, position);
+  return names.map((name) => ({
+    label: `@${name}`,
+    kind: "snippet",
+    insertText: name,
+    textEdit: {
+      range: source.range(word.start, word.end),
+      newText: name
+    }
+  }));
+}
+function projectAnnotationNamesAt(analysis, document, position) {
+  const source = analysis.documents.get(document.uri);
+  if (!source) return [];
+  if (document.languageId === "neoflow") {
+    return ["id", "primary", "incomplete"];
+  }
+  const offset = new SourceText(document.text).offsetAt(position);
+  const followingDeclaration = /^\s*(class|interface|enum)\b([^{}]*)/.exec(
+    document.text.slice(offset)
+  );
+  if (followingDeclaration?.[1] === "class") {
+    return [
+      "id",
+      "hidden",
+      "settings",
+      "storage",
+      "relations",
+      .../\bDialogue\b/.test(followingDeclaration[2] ?? "") ? ["incomplete"] : []
+    ];
+  }
+  if (followingDeclaration) return ["id"];
+  const containing = declarationContaining(source, position);
+  if (containing?.kind === "enum") return ["id"];
+  if (containing?.kind === "class" || containing?.kind === "interface") {
+    if (positionCompare(position, containing.nameRange.start) < 0) {
+      return projectDeclarationAnnotationNames(containing);
+    }
+    const member = containing.members.find(
+      (candidate) => rangeContains(candidate.range, position) || positionCompare(position, candidate.range.start) <= 0
+    );
+    return projectMemberAnnotationNames(member);
+  }
+  const following = source.declarations.find(
+    (declaration) => positionCompare(position, declaration.range.start) <= 0
+  );
+  if (following) return projectDeclarationAnnotationNames(following);
+  return ["id"];
+}
+function projectDeclarationAnnotationNames(declaration) {
+  if (declaration.kind !== "class") return ["id"];
+  return [
+    "id",
+    "hidden",
+    "settings",
+    "storage",
+    "relations",
+    ...declaration.baseTypes.some((type) => type.name === "Dialogue") ? ["incomplete"] : []
+  ];
+}
+function projectMemberAnnotationNames(member) {
+  const names = ["id", "settings", "storage", "locked"];
+  if (member?.type.name === "List") names.push("index", "column");
+  return names;
+}
+function projectContextualEnumCompletions(analysis, document, position) {
+  const source = new SourceText(document.text);
+  const offset = source.offsetAt(position);
+  const word = projectWordRange(document.text, offset);
+  if (!isContextualDot(document.text, word.start)) return null;
+  const typeName = constructionSiteAt(
+    analysis,
+    document,
+    position
+  )?.expectedTypeName;
+  if (!typeName) return null;
+  const type = analysis.project.types.find(
+    (candidate) => candidate.kind === "enum" && candidate.name === typeName
+  );
+  if (!type) return null;
+  return type.members.filter((member) => member.kind === "enumMember").map((member) => ({
+    label: `.${member.name}`,
+    kind: "enumMember",
+    detail: type.name,
+    insertText: member.name,
+    textEdit: {
+      range: source.range(word.start, word.end),
+      newText: member.name
+    },
+    symbolId: member.id
+  }));
+}
+function projectFallbackCompletions(analysis, document, position) {
   const items = /* @__PURE__ */ new Map();
-  for (const keyword of [
-    "@id",
-    "@settings",
-    "@storage",
-    "@relations",
-    "@primary",
+  const construction = constructionSiteAt(analysis, document, position);
+  const recoveredInitializerType = projectInitializerExpectedTypeNameAt(
+    document,
+    position
+  );
+  const expression = construction !== null || recoveredInitializerType !== null;
+  const expectedTypeName = construction?.expectedTypeName ?? recoveredInitializerType;
+  const afterNew = expression && projectAfterNewAt(document, position);
+  const typePosition = projectTypePositionAt(analysis, document, position);
+  const keywords = expression ? afterNew ? [] : ["new"] : typePosition ? [] : [
     "class",
     "interface",
     "enum",
@@ -24993,16 +25468,20 @@ function projectCompletions(analysis, document, position) {
     "override",
     "readonly",
     "virtual",
-    "static",
-    "new"
-  ]) {
+    "static"
+  ];
+  for (const keyword of keywords) {
     items.set(keyword, {
       label: keyword,
-      kind: keyword.startsWith("@") ? "snippet" : "keyword",
+      kind: "keyword",
       insertText: keyword
     });
   }
-  for (const typeName of NEOSCRIPT_BUILTIN_TYPES) {
+  for (const typeName of [
+    ...NEOSCRIPT_PRIMITIVE_TYPES,
+    ...NEOSCRIPT_BUILTIN_TYPES
+  ]) {
+    if (expression) continue;
     items.set(typeName, {
       label: typeName,
       kind: "class",
@@ -25010,10 +25489,31 @@ function projectCompletions(analysis, document, position) {
       insertText: typeName
     });
   }
+  const source = analysis.documents.get(document.uri);
+  const owner = source ? declarationContaining(source, position)?.name : void 0;
   for (const symbol of analysis.symbols) {
     if (symbol.scopeRange && (symbol.location.uri !== document.uri || !rangeContains(symbol.scopeRange, position))) {
       continue;
     }
+    const isType = symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter";
+    if (typePosition && !isType) continue;
+    if (expression) {
+      if (afterNew) {
+        if (!isType || symbol.kind !== "class" || expectedTypeName !== null && !projectTypeNameAssignable(analysis, symbol.name, expectedTypeName)) {
+          continue;
+        }
+      } else {
+        const isValue = symbol.kind === "parameter" || symbol.kind === "flowBinding" || symbol.kind === "graphChild" || symbol.kind === "global" || symbol.kind === "member" && symbol.ownerName === owner;
+        if (!isValue) continue;
+        if (expectedTypeName !== null && (symbol.detail === void 0 || !projectTypeNameAssignable(
+          analysis,
+          symbol.detail,
+          expectedTypeName
+        ))) {
+          continue;
+        }
+      }
+    }
     const kind = projectCompletionKind(symbol);
     items.set(symbol.name, {
       label: symbol.name,
@@ -25025,6 +25525,168 @@ function projectCompletions(analysis, document, position) {
   }
   return { isIncomplete: false, items: [...items.values()] };
 }
+function projectInitializerExpectedTypeNameAt(document, position) {
+  const prefix = documentPrefix(document.text, position);
+  const line = prefix.slice(prefix.lastIndexOf("\n") + 1);
+  return /^(?:\s*@\w+(?:\([^)]*\))?)*\s*(?:(?:public|protected|private|abstract|async|native|override|readonly|sealed|static|virtual)\s+)*([A-Za-z_][A-Za-z0-9_]*)(?:\s*<[^>]*>)?\s+[A-Za-z_][A-Za-z0-9_]*\s*=\s*[^;]*$/.exec(
+    line
+  )?.[1] ?? null;
+}
+function projectAfterNewAt(document, position) {
+  const tokens = tokensBeforePosition(document.text, position);
+  let cursor = tokens.length - 1;
+  const current = tokens[cursor];
+  const offset = new SourceText(document.text).offsetAt(position);
+  if (current?.kind === "identifier" && current.text !== "new" && /[A-Za-z0-9_]$/.test(document.text.slice(0, offset))) {
+    cursor--;
+  }
+  return tokens[cursor]?.text === "new";
+}
+function projectTypeNameAssignable(analysis, sourceName, targetName) {
+  if (sourceName === targetName) return true;
+  if (sourceName === "int" && (targetName === "float" || targetName === "decimal")) {
+    return true;
+  }
+  const source = analysis.project.types.find(
+    (type) => type.name === sourceName
+  );
+  const target = analysis.project.types.find(
+    (type) => type.name === targetName
+  );
+  if (!source || !target) return false;
+  const visited = /* @__PURE__ */ new Set();
+  const derivesFrom = (typeId) => {
+    if (typeId === target.id) return true;
+    if (visited.has(typeId)) return false;
+    visited.add(typeId);
+    const type = analysis.project.types.find(
+      (candidate) => candidate.id === typeId
+    );
+    return [
+      ...type?.baseTypeIds ?? [],
+      ...type?.interfaceTypeIds ?? []
+    ].some(derivesFrom);
+  };
+  return derivesFrom(source.id);
+}
+function projectBodySnapshotAt(analysis, document, position) {
+  const body = analysis.bodyContexts.find(
+    (candidate) => candidate.uri === document.uri && rangeContains(candidate.range, position)
+  );
+  return body ? projectBodySnapshot(analysis, document, body) : null;
+}
+function projectBodySnapshot(analysis, document, body) {
+  let snapshots = PROJECT_BODY_SNAPSHOT_CACHE.get(analysis);
+  if (!snapshots) {
+    snapshots = /* @__PURE__ */ new Map();
+    PROJECT_BODY_SNAPSHOT_CACHE.set(analysis, snapshots);
+  }
+  const cached = snapshots.get(body);
+  if (cached) return cached;
+  const source = new SourceText(document.text);
+  const start = source.offsetAt(body.range.start);
+  const end = source.offsetAt(body.range.end);
+  const text = maskOutsideProjectBody(document.text, start, end);
+  const syntax = analyzeNeoScriptSyntax(text, body.context.kind);
+  const context = { ...body.context, project: analysis.project };
+  const snapshot = {
+    uri: document.uri,
+    source: syntax.lexed.source,
+    lexed: syntax.lexed,
+    parsed: syntax.parsed,
+    context,
+    project: buildProjectIndexWithBuiltins(context)
+  };
+  snapshots.set(body, snapshot);
+  return snapshot;
+}
+function maskOutsideProjectBody(text, start, end) {
+  let masked = "";
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index] ?? "";
+    masked += index >= start && index < end || character === "\n" || character === "\r" ? character : " ";
+  }
+  return masked;
+}
+function projectWordRange(text, offset) {
+  let start = offset;
+  let end = offset;
+  while (start > 0 && /[A-Za-z0-9_]/.test(text[start - 1] ?? "")) start--;
+  while (end < text.length && /[A-Za-z0-9_]/.test(text[end] ?? "")) end++;
+  return { start, end };
+}
+function isContextualDot(text, wordStart) {
+  if (text[wordStart - 1] !== ".") return false;
+  let cursor = wordStart - 2;
+  while (cursor >= 0 && /\s/.test(text[cursor] ?? "")) cursor--;
+  const beforeDot = text[cursor];
+  if (beforeDot !== void 0 && /[A-Za-z0-9_]/.test(beforeDot)) {
+    const precedingWord = /[A-Za-z_][A-Za-z0-9_]*$/.exec(
+      text.slice(0, cursor + 1)
+    )?.[0];
+    return precedingWord === "return" || precedingWord === "case";
+  }
+  return beforeDot === void 0 || !/[A-Za-z0-9_\])}]/.test(beforeDot);
+}
+function projectTypePositionAt(analysis, document, position) {
+  const source = analysis.documents.get(document.uri);
+  if (source && sourceTypeAt(source, position)) return true;
+  const prefix = documentPrefix(document.text, position);
+  const line = prefix.slice(prefix.lastIndexOf("\n") + 1);
+  return /(?:^|[{:;,])\s*(?:(?:public|protected|private|abstract|async|native|override|readonly|sealed|static|virtual)\s+)*[A-Za-z_][A-Za-z0-9_]*(?:\s*<[^;={}()]*)?$/.test(
+    line
+  );
+}
+function sourceTypeAt(document, position) {
+  const contains2 = (type) => {
+    for (const argument2 of type.typeArguments) {
+      const nested = contains2(argument2);
+      if (nested) return nested;
+    }
+    return rangeContains(type.range, position) ? type : null;
+  };
+  const parameterType = (parameters) => {
+    for (const parameter4 of parameters ?? []) {
+      const match = contains2(parameter4.type);
+      if (match) return match;
+    }
+    return null;
+  };
+  for (const declaration of document.declarations) {
+    if (declaration.kind === "global") {
+      const match = contains2(declaration.type);
+      if (match) return match;
+      continue;
+    }
+    if (declaration.kind === "enum") continue;
+    for (const base of declaration.baseTypes) {
+      const match = contains2(base);
+      if (match) return match;
+    }
+    if (declaration.kind === "class") {
+      const header = parameterType(declaration.headerParameters);
+      if (header) return header;
+      for (const generic of declaration.genericParameters) {
+        if (!generic.constraint) continue;
+        const match = contains2(generic.constraint);
+        if (match) return match;
+      }
+      for (const constructor2 of declaration.constructors) {
+        const match = parameterType(constructor2.parameters);
+        if (match) return match;
+      }
+    }
+    for (const member of declaration.members) {
+      const memberType2 = contains2(member.type);
+      if (memberType2) return memberType2;
+      if (member.kind === "function") {
+        const match = parameterType(member.parameters);
+        if (match) return match;
+      }
+    }
+  }
+  return null;
+}
 function projectMemberCompletions(analysis, document, position) {
   const tokens = projectTokens(document).filter(
     (token) => token.kind !== "eof" && token.kind !== "comment" && positionCompare(token.range.start, position) <= 0
@@ -25262,6 +25924,8 @@ function activeNamedArgument(text, position) {
   return /([A-Za-z_][A-Za-z0-9_]*)\s*:\s*\.[A-Za-z0-9_]*$/.exec(prefix)?.[1] ?? null;
 }
 function projectHover(analysis, document, position) {
+  const body = projectBodySnapshotAt(analysis, document, position);
+  if (body) return hover(body, position);
   const resolved = projectSymbolAt(analysis, document, position);
   if (!resolved) return null;
   const owner = resolved.symbol.ownerName ? ` on \`${resolved.symbol.ownerName}\`` : "";
@@ -25309,6 +25973,8 @@ Construct with \`new(${parameters})\` \u2014 this class declares a required cons
 ${lines.join("\n\n")}`;
 }
 function projectDefinition(analysis, document, position) {
+  const body = projectBodySnapshotAt(analysis, document, position);
+  if (body) return definition(body, position);
   const resolved = projectSymbolAt(analysis, document, position);
   return resolved ? [resolved.symbol.location] : [];
 }
@@ -25375,6 +26041,8 @@ function requiredDestinationEdit(document, initializer, destination) {
   return open && close ? trailingBlockReturnEdit(document.text, open, close, destination) : null;
 }
 function projectSignatureHelp(analysis, document, position) {
+  const body = projectBodySnapshotAt(analysis, document, position);
+  if (body) return signatureHelp(body, position);
   const tokens = tokensBeforePosition(document.text, position);
   const openIndex = activeCallOpenIndex(tokens, position);
   if (openIndex < 0) return null;
@@ -25436,6 +26104,9 @@ function projectSignatureHelp(analysis, document, position) {
   };
 }
 function projectInlayHints(analysis, document, range2) {
+  const bodyContexts = analysis.bodyContexts.filter(
+    (body) => body.uri === document.uri
+  );
   const tokens = lex(document.text).tokens.filter(
     (token) => token.kind !== "comment" && token.kind !== "eof"
   );
@@ -25450,6 +26121,9 @@ function projectInlayHints(analysis, document, range2) {
     if (!callee || callee.kind !== "identifier" && callee.kind !== "type") {
       continue;
     }
+    if (bodyContexts.some((body) => rangeContains(body.range, callee.range.start))) {
+      continue;
+    }
     if (!open || open.text !== "(") continue;
     const beforeCallee = tokens[index - 1];
     if (beforeCallee?.text === "@") continue;
@@ -25476,6 +26150,14 @@ function projectInlayHints(analysis, document, range2) {
       });
     }
   }
+  for (const body of bodyContexts) {
+    const snapshot = projectBodySnapshot(analysis, document, body);
+    hints.push(
+      ...inlayHints(snapshot, range2).filter(
+        (hint) => rangeContains(body.range, hint.position)
+      )
+    );
+  }
   return hints;
 }
 function projectCallParameterNames(analysis, document, callee, beforeCallee) {
@@ -25677,8 +26359,14 @@ function symbolsDeclaredAt(index, uri, range2) {
 function projectSemanticTokens(document, analysis) {
   const index = buildProjectSymbolIndex(analysis.symbols);
   const tokens = projectTokens(document);
-  return tokens.flatMap((token, tokenIndex) => {
+  const bodyContexts = analysis.bodyContexts.filter(
+    (body) => body.uri === document.uri
+  );
+  const result = tokens.flatMap((token, tokenIndex) => {
     if (token.kind === "eof" || token.kind === "error") return [];
+    if (bodyContexts.some((body) => rangeContains(body.range, token.range.start))) {
+      return [];
+    }
     const declaration = symbolsDeclaredAt(index, document.uri, token.range)[0];
     const resolved = token.kind === "identifier" ? indexedProjectSymbolAt(analysis, document, token.range.start, index)?.symbol : void 0;
     let type;
@@ -25705,6 +26393,17 @@ function projectSemanticTokens(document, analysis) {
       }
     ];
   });
+  for (const body of bodyContexts) {
+    const snapshot = projectBodySnapshot(analysis, document, body);
+    result.push(
+      ...semanticTokens(snapshot).filter(
+        (token) => rangeContains(body.range, token.range.start)
+      )
+    );
+  }
+  return result.sort(
+    (left, right) => positionCompare(left.range.start, right.range.start)
+  );
 }
 function isProjectContextualKeyword(tokens, tokenIndex) {
   const token = tokens[tokenIndex];
@@ -25729,6 +26428,17 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
   if (exact.length === 1) return { token, symbol: exact[0] };
   const candidates = index.byName.get(token.text) ?? [];
   if (candidates.length === 0) return null;
+  const sourceTokens = projectTokens(document);
+  const tokenIndex = sourceTokens.findIndex(
+    (candidate) => candidate.start === token.start && candidate.end === token.end
+  );
+  const source = analysis.documents.get(document.uri);
+  if (source && sourceTypeAt(source, token.range.start) || sourceTokens[tokenIndex - 1]?.text === "new") {
+    const types = candidates.filter(
+      (symbol) => symbol.kind === "class" || symbol.kind === "interface" || symbol.kind === "enum" || symbol.kind === "genericParameter"
+    );
+    if (types.length === 1) return { token, symbol: types[0] };
+  }
   const scoped = candidates.filter(
     (symbol) => symbol.scopeRange && symbol.location.uri === document.uri && rangeContains(symbol.scopeRange, token.range.start)
   ).sort(
@@ -25740,10 +26450,6 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     return { token, symbol: visibleCandidates[0] };
   }
   if (visibleCandidates.length === 0) return null;
-  const sourceTokens = projectTokens(document);
-  const tokenIndex = sourceTokens.findIndex(
-    (candidate) => candidate.start === token.start && candidate.end === token.end
-  );
   if (sourceTokens[tokenIndex + 1]?.text === "=" && sourceTokens[tokenIndex + 2]?.text !== "=") {
     const constructed = constructionMemberSymbol(
       analysis,
@@ -25753,7 +26459,6 @@ function indexedProjectSymbolAt(analysis, document, position, index) {
     );
     if (constructed) return { token, symbol: constructed };
   }
-  const source = analysis.documents.get(document.uri);
   const owner = source ? declarationContaining(source, token.range.start)?.name : void 0;
   if (owner) {
     const owned = visibleCandidates.filter(
@@ -26272,10 +26977,11 @@ function projectFunctionsNamed(analysis, name) {
   }
   return result;
 }
-var CONSTRUCTION_INDEX_CACHE;
+var PROJECT_BODY_SNAPSHOT_CACHE, CONSTRUCTION_INDEX_CACHE;
 var init_project_source_language_features = __esm({
   "../packages/neoscript-language/src/project-source-language-features.ts"() {
     "use strict";
+    init_analyzer();
     init_lexer();
     init_language_spec();
     init_project_source_semantics();
@@ -26283,6 +26989,8 @@ var init_project_source_language_features = __esm({
     init_project_source_tokens();
     init_quick_fixes();
     init_source_text();
+    init_syntax();
+    PROJECT_BODY_SNAPSHOT_CACHE = /* @__PURE__ */ new WeakMap();
     CONSTRUCTION_INDEX_CACHE = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -45984,9 +46692,9 @@ ${namedArguments(
 `;
 }
 function namedArguments(entries, spaces, raw = /* @__PURE__ */ new Set()) {
-  const pad = " ".repeat(spaces);
+  const pad2 = " ".repeat(spaces);
   return entries.map(
-    ([name, value]) => `${pad}${name}: ${raw.has(name) ? rawValue(value) : jsonValue2(value)},`
+    ([name, value]) => `${pad2}${name}: ${raw.has(name) ? rawValue(value) : jsonValue2(value)},`
   ).join("\n");
 }
 function rawValue(value) {
@@ -50456,15 +51164,14 @@ function commentEndIndex(source, index) {
   return null;
 }
 function stripInitializerComments(source) {
-  const lines = [{ text: "", removedComment: false }];
+  const lines = [{ parts: [], removedComment: false }];
   let quote6 = null;
   let escaped = false;
   let index = 0;
+  let segmentStart = 0;
   while (index < source.length) {
     const character = source[index];
-    const line = lines[lines.length - 1];
     if (quote6 !== null) {
-      line.text += character;
       if (escaped) escaped = false;
       else if (character === "\\") escaped = true;
       else if (character === quote6) quote6 = null;
@@ -50473,20 +51180,34 @@ function stripInitializerComments(source) {
     }
     const afterComment = commentEndIndex(source, index);
     if (afterComment !== null) {
+      const line = lines[lines.length - 1];
+      if (segmentStart < index) {
+        line.parts.push(source.slice(segmentStart, index));
+      }
       line.removedComment = true;
       index = afterComment;
+      segmentStart = index;
       continue;
     }
     if (character === "\n") {
-      lines.push({ text: "", removedComment: false });
+      if (segmentStart < index) {
+        lines[lines.length - 1].parts.push(source.slice(segmentStart, index));
+      }
+      lines.push({ parts: [], removedComment: false });
       index += 1;
+      segmentStart = index;
       continue;
     }
     if (character === '"' || character === "'") quote6 = character;
-    line.text += character;
     index += 1;
   }
-  return lines.filter((line) => !line.removedComment || line.text.trim().length > 0).map((line) => line.text.trimEnd()).join("\n").trim();
+  if (segmentStart < source.length) {
+    lines[lines.length - 1].parts.push(source.slice(segmentStart));
+  }
+  return lines.map((line) => ({
+    text: line.parts.join("").trimEnd(),
+    removedComment: line.removedComment
+  })).filter((line) => !line.removedComment || line.text.trim().length > 0).map((line) => line.text).join("\n").trim();
 }
 function normalizeBodySource(source) {
   const trimmed = source.trim();
@@ -56658,6 +57379,19 @@ var init_NeoScriptScope = __esm({
       setLocal(bindingId, value) {
         this.#bindings.set(bindingId, value);
       }
+      bindInvocationEntry(bindingId, value) {
+        this.#bindings.set(bindingId, value);
+      }
+      bindInvocationKeyAndEntry(keyBindingId, key, entryBindingId, entry) {
+        this.#bindings.set(keyBindingId, key);
+        this.#bindings.set(entryBindingId, entry);
+      }
+      resetInvocationLocals(parameterCount) {
+        if (this.#bindings.size > parameterCount) this.#bindings.clear();
+        if (this.#readonlyBindingErrors.size > 0) {
+          this.#readonlyBindingErrors.clear();
+        }
+      }
       *keys() {
         const inherited = /* @__PURE__ */ new Set();
         if (this.parent !== null) {
@@ -61699,6 +62433,211 @@ function evalDeclaredListIndex(info, scope, ctx) {
   }
   return Array.isArray(hit) ? [...hit] : [];
 }
+function prepareCollectionCallback(callback, parentScope, ctx, isList, returnContract, onPredicateMatch) {
+  const metrics = ctx.__collectionCallbackPreparationMetrics;
+  if (metrics !== void 0) metrics.bodyValidations += 1;
+  const compilerRevision = callback.compilerRevision ?? 1;
+  if (!Number.isSafeInteger(compilerRevision)) {
+    throw new NSGetterRuntimeError(
+      "Collection callback compiler revision must be a safe integer."
+    );
+  }
+  if (compilerRevision < 1) {
+    throw new NSGetterRuntimeError(
+      "Collection callback compiler revision must be at least 1."
+    );
+  }
+  if (compilerRevision > NEOSCRIPT_COMPILER_REVISION) {
+    throw new NSGetterRuntimeError(
+      `Collection callback compiler revision ${String(compilerRevision)} is newer than supported revision ${String(NEOSCRIPT_COMPILER_REVISION)}.`
+    );
+  }
+  if (!isNSFunctionWithReturnType(callback)) {
+    throw new NSGetterRuntimeError(
+      `Collection callback body metadata is invalid for compiler revision ${String(compilerRevision)}.`
+    );
+  }
+  const parameters = callback.parameters;
+  if (parameters.length < 1) {
+    throw new NSGetterRuntimeError(
+      "Collection callback requires at least one parameter."
+    );
+  }
+  if (parameters.length > 2) {
+    throw new NSGetterRuntimeError(
+      `Collection callback supports at most two parameters, but received ${String(parameters.length)}.`
+    );
+  }
+  if (returnContract === "predicate") {
+    if (callback.typeInfo.type !== 1 /* Bool */) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate callback must declare a Bool return type."
+      );
+    }
+    if (!callback.typeInfo.required) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate callback must declare a required return type."
+      );
+    }
+  }
+  const parameterCount = parameters.length;
+  const callbackScope = ctx.__collectionCallbackStrategy === "fresh" ? null : createChildScope(parentScope);
+  const callbackOptions = evaluationOptions(ctx, false);
+  const instructions = callback.instructions;
+  const returnTypeInfo = callback.typeInfo;
+  const requiresInvocationReset = callbackBodyMayAddInvocationLocals(
+    instructions,
+    new Set(parameters.map((parameter4) => parameter4.id))
+  );
+  let finishBody;
+  if (returnContract === "predicate") {
+    finishBody = (innerScope2) => {
+      const result = evalInstructions(
+        instructions,
+        innerScope2,
+        ctx,
+        callbackOptions
+      );
+      rejectEscapedLoopTransfer(result, "collection callback");
+      if (result.kind !== "return") {
+        throw new NSGetterRuntimeError(
+          "Collection callback ended without returning a value."
+        );
+      }
+      const value = result.value;
+      if (typeof value !== "boolean") {
+        throw new NSGetterRuntimeError(
+          "Collection predicate callback returned a value that does not match its required Bool contract."
+        );
+      }
+      return value;
+    };
+  } else {
+    finishBody = (innerScope2) => {
+      const result = evalInstructions(
+        instructions,
+        innerScope2,
+        ctx,
+        callbackOptions
+      );
+      rejectEscapedLoopTransfer(result, "collection callback");
+      if (result.kind !== "return") {
+        throw new NSGetterRuntimeError(
+          "Collection callback ended without returning a value."
+        );
+      }
+      let value = result.value;
+      if (returnTypeInfo.type === 20 /* Decimal */ && typeof value === "number") {
+        value = coerceDecimalOperand(value, "collection callback return");
+      }
+      if (!runtimeValueMatchesType(value, returnTypeInfo, ctx)) {
+        throw new NSGetterRuntimeError(
+          "Collection projection callback returned a value that does not match its compiled return type."
+        );
+      }
+      return value;
+    };
+  }
+  if (metrics !== void 0) metrics.bindingPlanCreations += 1;
+  if (ctx.__collectionCallbackStrategy === "fresh" || ctx.__collectionCallbackStrategy === "prepared") {
+    return (entry, key, valueId) => {
+      if (onPredicateMatch !== void 0) {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
+      }
+      const innerScope2 = callbackScope ?? createChildScope(parentScope);
+      if (callbackScope !== null) {
+        callbackScope.resetInvocationLocals(parameterCount);
+      }
+      if (parameters.length === 1) {
+        innerScope2.setLocal(parameters[0].id, entry);
+      } else if (parameters.length === 2) {
+        innerScope2.setLocal(
+          parameters[0].id,
+          isList ? Number(key) : String(key)
+        );
+        innerScope2.setLocal(parameters[1].id, entry);
+      }
+      const value = finishBody(innerScope2);
+      if (onPredicateMatch === void 0) return value;
+      return value === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+    };
+  }
+  const innerScope = callbackScope ?? createChildScope(parentScope);
+  let bindValues;
+  if (parameterCount === 1) {
+    const entryParameterId = parameters[0].id;
+    bindValues = (entry) => {
+      innerScope.bindInvocationEntry(entryParameterId, entry);
+    };
+  } else {
+    const keyParameterId = parameters[0].id;
+    const entryParameterId = parameters[1].id;
+    bindValues = (entry, key) => {
+      innerScope.bindInvocationKeyAndEntry(
+        keyParameterId,
+        key,
+        entryParameterId,
+        entry
+      );
+    };
+  }
+  if (returnContract === "predicate") {
+    if (onPredicateMatch === void 0) {
+      throw new NSGetterRuntimeError(
+        "Collection predicate preparation requires a match handler."
+      );
+    }
+    if (requiresInvocationReset) {
+      return (entry, key, valueId) => {
+        consumeBudget(ctx, "workUnits", 1, "work unit");
+        innerScope.resetInvocationLocals(parameterCount);
+        bindValues(entry, key);
+        return finishBody(innerScope) === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+      };
+    }
+    return (entry, key, valueId) => {
+      consumeBudget(ctx, "workUnits", 1, "work unit");
+      bindValues(entry, key);
+      return finishBody(innerScope) === true ? onPredicateMatch(entry, key, valueId) : 0 /* Continue */;
+    };
+  }
+  if (requiresInvocationReset) {
+    return (entry, key) => {
+      innerScope.resetInvocationLocals(parameterCount);
+      bindValues(entry, key);
+      return finishBody(innerScope);
+    };
+  }
+  return (entry, key) => {
+    bindValues(entry, key);
+    return finishBody(innerScope);
+  };
+}
+function callbackBodyMayAddInvocationLocals(instructions, parameterIds) {
+  return instructions.some((instruction) => {
+    switch (instruction.type) {
+      case "variable" /* variable */:
+        return !parameterIds.has(instruction.variable.id);
+      case "assign" /* assign */:
+        return instruction.target.pointer.type === "variable" /* variable */ && !parameterIds.has(instruction.target.pointer.variableId);
+      case "if" /* if */:
+      case "for" /* for */:
+      case "forEach" /* forEach */:
+      case "switch" /* switch */:
+      case "try" /* try */:
+        return true;
+      default:
+        return false;
+    }
+  });
+}
+function isListCollection(collection) {
+  if (Array.isArray(collection)) return true;
+  if (typeof collection === "object" && collection !== null) return false;
+  throw new NSGetterRuntimeError(
+    "Collection callback receiver must be a present List or Dictionary value."
+  );
+}
 function evalFunction(fn, scope, ctx) {
   switch (fn.type) {
     case "classConstructor" /* classConstructor */:
@@ -61885,27 +62824,15 @@ function evalFunction(fn, scope, ctx) {
     case "where" /* where */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const innerFn = fn.info.function;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
       const out = isList ? [] : {};
-      iterateCollection(c, ctx, (entry, key, valueId) => {
-        consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = pushParams(
-          scope,
-          innerFn.parameters,
-          [
-            isList ? key : key,
-            // first param: index for list, key for dict
-            entry
-          ],
-          isList
-        );
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
-          ctx,
-          evaluationOptions(ctx, false)
-        );
-        if (result.kind === "return" && result.value === true) {
+      const callback = prepareCollectionCallback(
+        innerFn,
+        scope,
+        ctx,
+        isList,
+        "predicate",
+        (entry, key, valueId) => {
           consumeBudget(
             ctx,
             "producedCollectionEntries",
@@ -61917,42 +62844,38 @@ function evalFunction(fn, scope, ctx) {
           } else {
             out[String(key)] = valueId ?? entry;
           }
+          return 0 /* Continue */;
         }
-        return 0 /* Continue */;
-      });
+      );
+      iterateCollection(c, ctx, callback);
       return out;
     }
     case "first" /* first */:
     case "firstOrDefault" /* firstOrDefault */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const innerFn = fn.info.function ?? null;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
       const sentinel = /* @__PURE__ */ Symbol("not-found");
       let found = sentinel;
-      iterateCollection(c, ctx, (entry, key) => {
-        if (!innerFn) {
+      if (innerFn === null) {
+        iterateCollection(c, ctx, (entry) => {
           found = entry;
           return 1 /* Break */;
-        }
-        consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = pushParams(
+        });
+      } else {
+        const callback = prepareCollectionCallback(
+          innerFn,
           scope,
-          innerFn.parameters,
-          [key, entry],
-          isList
-        );
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
           ctx,
-          evaluationOptions(ctx, false)
+          isList,
+          "predicate",
+          (entry) => {
+            found = entry;
+            return 1 /* Break */;
+          }
         );
-        if (result.kind === "return" && result.value === true) {
-          found = entry;
-          return 1 /* Break */;
-        }
-        return 0 /* Continue */;
-      });
+        iterateCollection(c, ctx, callback);
+      }
       if (found !== sentinel) return found;
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
@@ -61964,31 +62887,25 @@ function evalFunction(fn, scope, ctx) {
     case "select" /* select */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
       const innerFn = fn.info.function;
-      const isList = Array.isArray(c);
+      const isList = isListCollection(c);
+      const callback = prepareCollectionCallback(
+        innerFn,
+        scope,
+        ctx,
+        isList,
+        "projection"
+      );
       const out = [];
-      iterateCollection(c, ctx, (entry, key) => {
+      iterateCollection(c, ctx, (entry, key, valueId) => {
         consumeBudget(ctx, "workUnits", 1, "work unit");
-        const innerScope = pushParams(
-          scope,
-          innerFn.parameters,
-          [key, entry],
-          isList
-        );
-        const result = evalInstructions(
-          innerFn.instructions,
-          innerScope,
+        const value = callback(entry, key, valueId);
+        consumeBudget(
           ctx,
-          evaluationOptions(ctx, false)
+          "producedCollectionEntries",
+          1,
+          "produced collection entry"
         );
-        if (result.kind === "return") {
-          consumeBudget(
-            ctx,
-            "producedCollectionEntries",
-            1,
-            "produced collection entry"
-          );
-          out.push(result.value);
-        }
+        out.push(value);
         return 0 /* Continue */;
       });
       return out;
@@ -63324,7 +64241,7 @@ function encodeRequiredConstructorArgument(args) {
     return adoptTracked(trackedId, "root");
   }
   if (args.typeInfo.type !== 6 /* List */ && args.typeInfo.type !== 5 /* Dictionary */) {
-    return args.value;
+    return cloneConstructorLiteralValue(args.value);
   }
   if (args.value === null || args.value === void 0) return null;
   if (trackedId !== null) return adoptTracked(trackedId, "root");
@@ -63368,7 +64285,7 @@ function encodeRequiredConstructorArgument(args) {
       }
       return nested;
     }
-    return registerRow(value).id;
+    return registerRow(cloneConstructorLiteralValue(value)).id;
   };
   if (collectionType.type === 6 /* List */) {
     if (!Array.isArray(args.value)) {
@@ -63962,10 +64879,10 @@ function cloneConstructorArgumentGraph(args) {
   return cloneRow(args.source, args.member, args.genericEnv);
 }
 function cloneConstructorLiteralValue(value) {
+  if (typeof value !== "object" || value === null) return value;
   if (Array.isArray(value)) {
     return value.map((entry) => cloneConstructorLiteralValue(entry));
   }
-  if (typeof value !== "object" || value === null) return value;
   return Object.fromEntries(
     Object.entries(value).map(([key, entry]) => [
       key,
@@ -64541,17 +65458,6 @@ function iterateCollection(c, ctx, callback) {
     return callback(entry, key, valueId);
   });
 }
-function pushParams(parent, parameters, positional, isList) {
-  const child = createChildScope(parent);
-  if (parameters.length === 1) {
-    child.setLocal(parameters[0].id, positional[1]);
-  } else if (parameters.length === 2) {
-    const first = isList ? Number(positional[0]) : String(positional[0]);
-    child.setLocal(parameters[0].id, first);
-    child.setLocal(parameters[1].id, positional[1]);
-  }
-  return child;
-}
 var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, NeoScriptWallClockTimeoutError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, resolutionCacheByMembers, NO_SCHEMA_REVISION, LazyValueOverlay, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
@@ -64565,6 +65471,7 @@ var init_evaluateNSGetter = __esm({
     init_neoscript();
     init_NSGetterRuntimeError();
     init_value_row_owner_members();
+    init_src();
     init_decimal();
     init_members();
     init_core();
@@ -66503,6 +67410,7 @@ var init_project_document_read = __esm({
 });
 
 // src/workspace.ts
+import { createHash as createHash2 } from "node:crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "node:fs";
 import { dirname, join as join2, resolve } from "node:path";
 function recordStateKey(recordKind, recordId) {
@@ -66735,9 +67643,12 @@ function matchUnityScalarField(content, field) {
 function readWorkspaceState(root, options = {}) {
   const statePath = join2(root, NEO_STATE_DIR, NEO_STATE_FILE);
   if (!existsSync2(statePath)) {
+    options.onSourceRead?.(null);
     return { records: {} };
   }
-  const parsed = JSON.parse(readFileSync2(statePath, "utf8"));
+  const source = readFileSync2(statePath, "utf8");
+  options.onSourceRead?.(source);
+  const parsed = JSON.parse(source);
   if (typeof parsed !== "object" || parsed === null) {
     throw new Error(`"${statePath}" must contain a JSON object.`);
   }
@@ -66780,10 +67691,20 @@ function loadWorkspace(startDir, options = {}) {
       `No "${NEO_CONFIG_FILE}" found in "${startDir}" or any parent directory. Run "neo init" first.`
     );
   }
+  let stateSourceSha256;
+  const state = readWorkspaceState(root, {
+    discardLegacyFormat2State: options.discardLegacyFormat2State,
+    ...options.fingerprintStateSource === true ? {
+      onSourceRead: (source) => {
+        stateSourceSha256 = createHash2("sha256").update(source ?? "<missing>").digest("hex");
+      }
+    } : {}
+  });
   return {
     root,
     config: readWorkspaceConfig(root),
-    state: readWorkspaceState(root, options)
+    state,
+    ...stateSourceSha256 === void 0 ? {} : { stateSourceSha256 }
   };
 }
 var NEO_CONFIG_FILE, NEO_STATE_DIR, NEO_STATE_FILE, CURRENT_FORMAT_VERSION;
@@ -72142,7 +73063,7 @@ var init_animation_clips = __esm({
 
 // src/project-source/materialized-construction-cache.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { dirname as dirname2, join as join3 } from "node:path";
 function createMaterializedConstructionExpressionsV1(args) {
   const warm = args.useBuildCaches ? readMaterializedConstructionBuildCacheV1(args.root, args.state) : null;
@@ -72234,7 +73155,7 @@ function writeMaterializedConstructionBuildCacheV1(root, state, expressions) {
   renameSync(temporary, file);
 }
 function materializedConstructionStateFingerprint(state) {
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   hash.update(String(MATERIALIZED_CONSTRUCTION_BUILD_CACHE_REVISION));
   for (const [key, record3] of Object.entries(state.records).sort(
     ([left], [right]) => left.localeCompare(right)
@@ -73060,10 +73981,10 @@ var init_neo_script_recompile_scope = __esm({
 });
 
 // ../src/database/project-content-hash.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function hashCanonicalJson(value) {
   const canonicalJson = canonicalJsonStringify(value);
-  return createHash3("sha256").update(canonicalJson).digest("hex");
+  return createHash4("sha256").update(canonicalJson).digest("hex");
 }
 var init_project_content_hash = __esm({
   "../src/database/project-content-hash.ts"() {
@@ -73130,7 +74051,7 @@ var init_project_fingerprint = __esm({
 
 // src/project-source/neoscript-build-cache.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { dirname as dirname3, join as join4 } from "node:path";
 function loadOrBuildNeoScriptProjectV1(root, document) {
   const fingerprint = neoScriptProjectFingerprint(document);
@@ -73157,7 +74078,7 @@ function loadOrBuildNeoScriptProjectV1(root, document) {
   return project;
 }
 function neoScriptProjectFingerprint(document) {
-  return createHash4("sha256").update(
+  return createHash5("sha256").update(
     canonicalJsonStringify(neoScriptCompilationProjectContract(document))
   ).digest("hex");
 }
@@ -92280,7 +93201,7 @@ var init_project_documents = __esm({
 
 // src/project-source/project-document-cache.ts
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { dirname as dirname4, join as join5 } from "node:path";
 function readProjectSourceAnalysisBuildCacheV4(root, sources) {
   try {
@@ -92404,7 +93325,7 @@ function writeProjectSourceDocumentBuildCacheV1(root, sources, documents) {
   renameSync3(temporary, file);
 }
 function projectSourceFileFingerprint(source) {
-  return createHash5("sha256").update(String(PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION)).update("\0").update(String(NEOSCRIPT_COMPILER_REVISION)).update("\0").update(source.kind).update("\0").update(source.text).digest("hex");
+  return createHash6("sha256").update(String(PROJECT_SOURCE_DOCUMENT_BUILD_CACHE_REVISION)).update("\0").update(String(NEOSCRIPT_COMPILER_REVISION)).update("\0").update(source.kind).update("\0").update(source.text).digest("hex");
 }
 function isCachedProjectSourceDocument(value, source) {
   if (value === null || typeof value !== "object") return false;
@@ -92412,7 +93333,7 @@ function isCachedProjectSourceDocument(value, source) {
   return document.kind === source.kind && document.sourceText === source.text && Array.isArray(document.declarations) && Array.isArray(document.diagnostics);
 }
 function projectSourceFingerprint(sources) {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   hash.update(String(PROJECT_SOURCE_BUILD_CACHE_REVISION));
   hash.update("\0");
   hash.update(String(NEOSCRIPT_COMPILER_REVISION));
@@ -92440,7 +93361,7 @@ var init_project_document_cache = __esm({
 });
 
 // src/project-source/project-files.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync6,
@@ -92687,7 +93608,7 @@ function discoverProjectBinariesV4(root, explicit, ignoredPaths = []) {
   }).sort((left, right) => compareCodePoints(left.path, right.path));
 }
 function sha256Bytes(bytes) {
-  return createHash6("sha256").update(bytes).digest("hex");
+  return createHash7("sha256").update(bytes).digest("hex");
 }
 function sha256File(path) {
   return sha256Bytes(readFileSync6(path));
@@ -98140,7 +99061,7 @@ var init_script = __esm({
 });
 
 // ../src/database/project-source-identity.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function hashProjectSourceFiles(inputFiles) {
   const files = normalizeSourceFiles(inputFiles);
   const bytes = Buffer.from(JSON.stringify({ version: 1, files }), "utf8");
@@ -98149,7 +99070,7 @@ function hashProjectSourceFiles(inputFiles) {
       `Project source identity is ${bytes.byteLength} bytes; the limit is ${MAX_SOURCE_BYTES} bytes.`
     );
   }
-  return createHash7("sha256").update(bytes).digest("hex");
+  return createHash8("sha256").update(bytes).digest("hex");
 }
 function normalizeSourceFiles(inputFiles) {
   if (inputFiles.length > MAX_SOURCE_FILES) {
@@ -98241,14 +99162,14 @@ var init_project_source_identity = __esm({
 
 // src/push-hook.ts
 import { spawn } from "node:child_process";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "node:fs";
 import { join as join13, relative as relative3, sep as sep3 } from "node:path";
-function fingerprintPushInputs(workspace) {
+function fingerprintPushInputs(workspace, options = {}) {
   const paths = /* @__PURE__ */ new Set([
     join13(workspace.root, "neo.json"),
     ...listProjectSourceFilesV4(workspace.root),
-    ...listProjectTestFilesV1(workspace.root),
+    ...options.includeTests === false ? [] : listProjectTestFilesV1(workspace.root),
     ...workspace.config.unityConfigPath === void 0 ? [] : [join13(workspace.root, workspace.config.unityConfigPath)]
   ]);
   const visitManaged = (directory) => {
@@ -98262,7 +99183,7 @@ function fingerprintPushInputs(workspace) {
   };
   visitManaged(join13(workspace.root, "Files", "Images"));
   visitManaged(join13(workspace.root, "Files", "AudioClips"));
-  const hash = createHash8("sha256");
+  const hash = createHash9("sha256");
   for (const path of [...paths].sort()) {
     const name = relative3(workspace.root, path).split(sep3).join("/");
     hash.update(name);
@@ -98919,7 +99840,7 @@ __export(push_exports, {
   runPush: () => runPush,
   stripServerDerivedNeoScript: () => stripServerDerivedNeoScript
 });
-import { createHash as createHash9, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
 import {
   mkdirSync as mkdirSync10,
   writeFileSync as writeFileSync10,
@@ -99702,7 +100623,7 @@ async function runPush(workspace, options, preparationOverride) {
           version: 1,
           projectFingerprint: `sha256:${preparedLocal.source.sourceHash}`,
           inputFingerprint: preparedInputFingerprint,
-          documentSha256: createHash9("sha256").update(documentJson).digest("hex"),
+          documentSha256: createHash10("sha256").update(documentJson).digest("hex"),
           document: candidate.document
         })}
 `,
@@ -101711,7 +102632,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.26.1",
+      cliVersion: "0.26.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -103004,7 +103925,7 @@ __export(test_exports, {
   maintainNeoTestBuildCache: () => maintainNeoTestBuildCache,
   runTest: () => runTest
 });
-import { createHash as createHash10, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
 import {
   existsSync as existsSync12,
   mkdirSync as mkdirSync11,
@@ -103025,6 +103946,7 @@ import {
   resolve as resolve3,
   sep as sep5
 } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -103108,9 +104030,46 @@ function stableTestValue(value) {
 function display(value) {
   return stableTestValue(value);
 }
-function assertMatcher(condition, expectationValue, message, expected, received = expectationValue.actual) {
-  if (condition === expectationValue.negated)
-    throw new NeoTestAssertionError(message, expected, received);
+function matcherFailureMessage(kind, expectationValue, expected, received, details) {
+  const actual = expectationValue.actual;
+  const negation = expectationValue.negated ? "not " : "";
+  switch (kind) {
+    case "toBe":
+      return `Expected ${display(actual)} ${negation}to be ${display(expected)}.`;
+    case "toEqual":
+      return `Expected ${display(actual)} ${negation}to equal ${display(expected)}.`;
+    case "toBeNull":
+      return `Expected ${display(actual)} ${negation}to be null.`;
+    case "boolean":
+      return `Expected ${display(actual)} ${negation}to be ${String(expected)}.`;
+    case "numeric":
+      return `Expected ${display(actual)} ${negation}to satisfy numeric comparison with ${display(expected)}.`;
+    case "toContain":
+      return `Expected ${display(actual)} ${negation}to contain ${display(expected)}.`;
+    case "toHaveLength":
+      return `Expected length ${String(expected)}, received ${String(received)}.`;
+    case "toMatchObject":
+      return `Expected ${display(actual)} ${negation}to match ${display(expected)}.`;
+    case "toThrow":
+      return `Expected callback ${negation}to throw${details === void 0 ? "" : ` a message containing ${display(details)}`}.`;
+    case "mock":
+      return `Expected mock ${negation}to match recorded calls ${display(details)}.`;
+  }
+}
+function assertMatcher(condition, expectationValue, messageKind, expected, received = expectationValue.actual, details) {
+  if (condition === expectationValue.negated) {
+    throw new NeoTestAssertionError(
+      matcherFailureMessage(
+        messageKind,
+        expectationValue,
+        expected,
+        received,
+        details
+      ),
+      expected,
+      received
+    );
+  }
 }
 function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
@@ -103118,10 +104077,11 @@ function errorMessage2(error) {
 function findDelegateTargetMemberId(value) {
   return isRecord10(value) && typeof value.memberId === "string" ? value.memberId : null;
 }
-function makeEvaluatorContext(rawDocument, interceptor, documentAlreadyIsolated = false) {
-  const isolatedDocument = documentAlreadyIsolated ? rawDocument : structuredClone(rawDocument);
-  const document = readDocumentArrays(isolatedDocument);
-  const constructors = Array.isArray(isolatedDocument.constructors) ? isolatedDocument.constructors.filter(isRecord10) : [];
+function sharedEvaluatorBase(rawDocument) {
+  const cached = SHARED_EVALUATOR_BASES.get(rawDocument);
+  if (cached !== void 0) return cached;
+  const document = readDocumentArrays(rawDocument);
+  const constructors = Array.isArray(rawDocument.constructors) ? rawDocument.constructors.filter(isRecord10) : [];
   const vm = {
     project: document.project,
     members: document.members,
@@ -103146,10 +104106,19 @@ function makeEvaluatorContext(rawDocument, interceptor, documentAlreadyIsolated
       }
     )
   };
-  return createNeoScriptEvaluationRuntime({
+  const created = {
     vm,
+    rootValue: buildRootValue(document)
+  };
+  SHARED_EVALUATOR_BASES.set(rawDocument, created);
+  return created;
+}
+function makeEvaluatorContext(rawDocument, interceptor) {
+  const base = sharedEvaluatorBase(rawDocument);
+  return createNeoScriptEvaluationRuntime({
+    vm: base.vm,
     thisValue: null,
-    rootValue: buildRootValue(document),
+    rootValue: base.rootValue,
     dialogueContext: null,
     callInterceptor: interceptor,
     nativeFunctionErrorCheckBehavior: "strict"
@@ -103216,14 +104185,15 @@ function preparedHookCandidate(workspace) {
       );
     }
     const documentJson = JSON.stringify(parsed.document);
-    if (createHash10("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
+    if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
       throw new NeoTestPreparedCandidateError(
         "Configured push hook candidate project document failed checksum verification."
       );
     }
     return {
       document: parsed.document,
-      sourceHash: configuredFingerprint.replace(/^sha256:/u, "")
+      sourceHash: configuredFingerprint.replace(/^sha256:/u, ""),
+      documentSha256: parsed.documentSha256
     };
   } catch (error) {
     if (error instanceof NeoTestPreparedCandidateError) throw error;
@@ -103232,11 +104202,79 @@ function preparedHookCandidate(workspace) {
     );
   }
 }
+function fingerprintTestCandidateInputs(workspace) {
+  return createHash11("sha256").update("neo-test-candidate\0").update(String(TEST_CANDIDATE_CACHE_REVISION)).update("\0").update(PROJECT_SCHEMA_CONTRACT.cliVersion).update("\0").update(String(NEOSCRIPT_COMPILER_REVISION)).update("\0").update(fingerprintPushInputs(workspace, { includeTests: false })).update("\0").update(
+    workspace.stateSourceSha256 === void 0 ? `object\0${JSON.stringify(workspace.state)}` : `source\0${workspace.stateSourceSha256}`
+  ).digest("hex");
+}
+function testCandidateCachePath(workspace, inputFingerprint) {
+  const cacheKey = createHash11("sha256").update(inputFingerprint).digest("hex");
+  return join16(
+    workspace.root,
+    ".neo",
+    "test-build",
+    "v1",
+    "project",
+    cacheKey,
+    "candidate.json"
+  );
+}
+function cachedTestCandidate(workspace, inputFingerprint) {
+  try {
+    const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
+    const parsed = JSON.parse(readFileSync16(candidatePath, "utf8"));
+    if (!isRecord10(parsed)) return null;
+    if (parsed.version !== 1) return null;
+    if (parsed.candidateRevision !== TEST_CANDIDATE_CACHE_REVISION) return null;
+    if (parsed.cliVersion !== PROJECT_SCHEMA_CONTRACT.cliVersion) return null;
+    if (parsed.compilerRevision !== NEOSCRIPT_COMPILER_REVISION) return null;
+    if (parsed.inputFingerprint !== inputFingerprint) return null;
+    if (typeof parsed.sourceHash !== "string" || parsed.sourceHash.length === 0) {
+      return null;
+    }
+    if (typeof parsed.documentSha256 !== "string") return null;
+    const documentJson = readFileSync16(
+      join16(dirname9(candidatePath), "document.json"),
+      "utf8"
+    );
+    if (createHash11("sha256").update(documentJson).digest("hex") !== parsed.documentSha256) {
+      return null;
+    }
+    const document = JSON.parse(documentJson);
+    if (!isRecord10(document)) return null;
+    return {
+      document,
+      sourceHash: parsed.sourceHash,
+      documentSha256: parsed.documentSha256
+    };
+  } catch {
+    return null;
+  }
+}
+function cacheTestCandidate(workspace, inputFingerprint, candidate) {
+  const documentJson = JSON.stringify(candidate.document);
+  const documentSha256 = createHash11("sha256").update(documentJson).digest("hex");
+  const candidatePath = testCandidateCachePath(workspace, inputFingerprint);
+  atomicWrite(join16(dirname9(candidatePath), "document.json"), documentJson);
+  atomicWrite(
+    candidatePath,
+    JSON.stringify({
+      version: 1,
+      candidateRevision: TEST_CANDIDATE_CACHE_REVISION,
+      cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
+      compilerRevision: NEOSCRIPT_COMPILER_REVISION,
+      inputFingerprint,
+      sourceHash: candidate.sourceHash,
+      documentSha256
+    }) + "\n"
+  );
+  return { ...candidate, documentSha256 };
+}
 function compileSpec(workspace, document, absolutePath, projectCompilationHash2) {
   const scriptDocument = readDocumentArrays(document);
   const path = relative5(workspace.root, absolutePath).split(sep5).join("/");
   const source = readFileSync16(absolutePath, "utf8");
-  const sourceHash = createHash10("sha256").update(source).digest("hex");
+  const sourceHash = createHash11("sha256").update(source).digest("hex");
   const artifactPath = join16(
     workspace.root,
     ".neo",
@@ -103247,7 +104285,7 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
   );
   try {
     const cached = JSON.parse(readFileSync16(artifactPath, "utf8"));
-    if (isRecord10(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord10(cached.action) && typeof cached.artifactSha256 === "string" && createHash10("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord10(cached.action.typeInfo)) {
+    if (isRecord10(cached) && cached.version === 1 && cached.compilerRevision === NEOSCRIPT_COMPILER_REVISION && cached.projectCompilationHash === projectCompilationHash2 && cached.sourceHash === sourceHash && isRecord10(cached.action) && typeof cached.artifactSha256 === "string" && createHash11("sha256").update(JSON.stringify(cached.action)).digest("hex") === cached.artifactSha256 && cached.action.compilerRevision === NEOSCRIPT_COMPILER_REVISION && Array.isArray(cached.action.parameters) && Array.isArray(cached.action.instructions) && isRecord10(cached.action.typeInfo)) {
       return {
         path,
         source,
@@ -103279,15 +104317,16 @@ function compileSpec(workspace, document, absolutePath, projectCompilationHash2)
       compilerRevision: NEOSCRIPT_COMPILER_REVISION,
       projectCompilationHash: projectCompilationHash2,
       sourceHash,
-      artifactSha256: createHash10("sha256").update(JSON.stringify(compiled.action)).digest("hex"),
+      artifactSha256: createHash11("sha256").update(JSON.stringify(compiled.action)).digest("hex"),
       action: compiled.action
     })}
 `
   );
   return compiled;
 }
-function projectCompilationHash(projectSourceHash, document) {
-  return createHash10("sha256").update(projectSourceHash).update("\0").update(JSON.stringify(document)).digest("hex");
+function projectCompilationHash(projectSourceHash, document, knownDocumentSha256) {
+  const documentSha256 = knownDocumentSha256 ?? createHash11("sha256").update(JSON.stringify(document)).digest("hex");
+  return createHash11("sha256").update(projectSourceHash).update("\0").update(documentSha256).digest("hex");
 }
 function selectedSpecPaths(workspace, selectors) {
   const all = listProjectTestFilesV1(workspace.root);
@@ -103520,7 +104559,7 @@ function registerSpec(spec, document) {
       }
       names.add(fullName);
       const test = {
-        id: `sha256:${createHash10("sha256").update(`${spec.path}\0${namePath}`).digest("hex")}`,
+        id: `sha256:${createHash11("sha256").update(`${spec.path}\0${namePath}`).digest("hex")}`,
         name: namePath,
         fullName,
         body: portableDelegate(call.args[1]),
@@ -103579,8 +104618,7 @@ function mockResponse(environment, mock, selected2, call) {
   };
 }
 function partialObjectMatch(actual, expected) {
-  if (!isRecord10(expected))
-    return stableTestValue(actual) === stableTestValue(expected);
+  if (!isRecord10(expected)) return isDeepStrictEqual(actual, expected);
   if (!isRecord10(actual)) return false;
   return Object.entries(expected).every(
     ([key, value]) => partialObjectMatch(actual[key], value)
@@ -103737,56 +104775,28 @@ function interceptTestCallCore(environment, call) {
     }
     return { handled: true, value: null };
   }
-  const matcherIds = /* @__PURE__ */ new Set([
-    NEO_TEST_IDS.toBe,
-    NEO_TEST_IDS.toEqual,
-    NEO_TEST_IDS.toBeNull,
-    NEO_TEST_IDS.toBeTrue,
-    NEO_TEST_IDS.toBeFalse,
-    NEO_TEST_IDS.toBeGreaterThan,
-    NEO_TEST_IDS.toBeGreaterThanOrEqual,
-    NEO_TEST_IDS.toBeLessThan,
-    NEO_TEST_IDS.toBeLessThanOrEqual,
-    NEO_TEST_IDS.toContain,
-    NEO_TEST_IDS.toHaveLength,
-    NEO_TEST_IDS.toMatchObject,
-    NEO_TEST_IDS.toThrow,
-    NEO_TEST_IDS.toHaveBeenCalled,
-    NEO_TEST_IDS.toHaveBeenCalledTimes,
-    NEO_TEST_IDS.toHaveBeenCalledWith
-  ]);
-  if (!matcherIds.has(call.memberId)) return { handled: false };
+  if (!MATCHER_IDS.has(call.memberId)) return { handled: false };
   const expectationValue = readExpectation(call.receiver);
   const actual = expectationValue.actual;
   if (call.memberId === NEO_TEST_IDS.toBe) {
     assertMatcher(
       Object.is(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be ${display(call.args[0])}.`,
+      "toBe",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toEqual) {
     assertMatcher(
-      stableTestValue(actual) === stableTestValue(call.args[0]),
+      isDeepStrictEqual(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to equal ${display(call.args[0])}.`,
+      "toEqual",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toBeNull) {
-    assertMatcher(
-      actual === null,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be null.`,
-      null
-    );
+    assertMatcher(actual === null, expectationValue, "toBeNull", null);
   } else if (call.memberId === NEO_TEST_IDS.toBeTrue || call.memberId === NEO_TEST_IDS.toBeFalse) {
     const expected = call.memberId === NEO_TEST_IDS.toBeTrue;
-    assertMatcher(
-      actual === expected,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to be ${String(expected)}.`,
-      expected
-    );
+    assertMatcher(actual === expected, expectationValue, "boolean", expected);
   } else if (call.memberId === NEO_TEST_IDS.toBeGreaterThan || call.memberId === NEO_TEST_IDS.toBeGreaterThanOrEqual || call.memberId === NEO_TEST_IDS.toBeLessThan || call.memberId === NEO_TEST_IDS.toBeLessThanOrEqual) {
     const left = Number(actual);
     const right = Number(call.args[0]);
@@ -103794,25 +104804,18 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       Number.isFinite(left) && Number.isFinite(right) && matches,
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to satisfy numeric comparison with ${display(call.args[0])}.`,
+      "numeric",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toContain) {
-    const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some(
-      (entry) => stableTestValue(entry) === stableTestValue(call.args[0])
-    );
-    assertMatcher(
-      contains2,
-      expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to contain ${display(call.args[0])}.`,
-      call.args[0]
-    );
+    const contains2 = typeof actual === "string" ? actual.includes(String(call.args[0])) : Array.isArray(actual) && actual.some((entry) => isDeepStrictEqual(entry, call.args[0]));
+    assertMatcher(contains2, expectationValue, "toContain", call.args[0]);
   } else if (call.memberId === NEO_TEST_IDS.toHaveLength) {
     const length = typeof actual === "string" || Array.isArray(actual) ? actual.length : isRecord10(actual) ? Object.keys(actual).length : -1;
     assertMatcher(
       length === call.args[0],
       expectationValue,
-      `Expected length ${String(call.args[0])}, received ${String(length)}.`,
+      "toHaveLength",
       call.args[0],
       length
     );
@@ -103820,7 +104823,7 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       partialObjectMatch(actual, call.args[0]),
       expectationValue,
-      `Expected ${display(actual)} ${expectationValue.negated ? "not " : ""}to match ${display(call.args[0])}.`,
+      "toMatchObject",
       call.args[0]
     );
   } else if (call.memberId === NEO_TEST_IDS.toThrow) {
@@ -103836,9 +104839,10 @@ function interceptTestCallCore(environment, call) {
     assertMatcher(
       matches,
       expectationValue,
-      `Expected callback ${expectationValue.negated ? "not " : ""}to throw${pattern === void 0 ? "" : ` a message containing ${display(pattern)}`}.`,
+      "toThrow",
       pattern ?? "a catchable NeoScript error",
-      thrown === void 0 ? "no throw" : errorMessage2(thrown)
+      thrown === void 0 ? "no throw" : errorMessage2(thrown),
+      pattern
     );
   } else {
     const handle = readMockHandle(actual);
@@ -103848,15 +104852,14 @@ function interceptTestCallCore(environment, call) {
         "Expected value is not an active mock handle."
       );
     }
-    const matches = call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? mock.calls.length > 0 : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length === call.args[0] : mock.calls.some(
-      (args) => stableTestValue(args) === stableTestValue(call.args)
-    );
+    const matches = call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? mock.calls.length > 0 : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length === call.args[0] : mock.calls.some((args) => isDeepStrictEqual(args, call.args));
     assertMatcher(
       matches,
       expectationValue,
-      `Expected mock ${expectationValue.negated ? "not " : ""}to match recorded calls ${display(mock.calls)}.`,
+      "mock",
       call.memberId === NEO_TEST_IDS.toHaveBeenCalled ? "at least one call" : call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? call.args[0] : call.args,
-      call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length : mock.calls
+      call.memberId === NEO_TEST_IDS.toHaveBeenCalledTimes ? mock.calls.length : mock.calls,
+      mock.calls
     );
   }
   return { handled: true, value: null };
@@ -103871,24 +104874,32 @@ function interceptTestCall(environment, call) {
     throw error;
   }
 }
-function createTestEnvironment(document, documentAlreadyIsolated = false) {
+function createTestEnvironment(document) {
   const environment = {
     baseDocument: document,
     context: void 0,
     mocks: /* @__PURE__ */ new Map(),
     mocksByMember: /* @__PURE__ */ new Map(),
-    nextMockId: 1
+    nextMockId: 1,
+    hasStateChanges: false
   };
   environment.context = makeEvaluatorContext(
     document,
-    (call) => interceptTestCall(environment, call),
-    documentAlreadyIsolated
+    (call) => interceptTestCall(environment, call)
   );
   return environment;
 }
 function snapshotEnvironmentDocument(environment) {
-  const snapshot = structuredClone(environment.baseDocument);
-  const values = Array.isArray(snapshot.values) ? snapshot.values : [];
+  const overlay = environment.context.__valueOverlay;
+  const runtime = environment.context.__runtimeSessionValues;
+  const bindings = new Map([
+    ...environment.context.__saveStaticBindings ?? [],
+    ...environment.context.__sessionStaticBindings ?? []
+  ]);
+  if (!environment.hasStateChanges) return environment.baseDocument;
+  const snapshot = { ...environment.baseDocument };
+  const baseValues = Array.isArray(snapshot.values) ? snapshot.values : [];
+  const values = [...baseValues];
   const byId = /* @__PURE__ */ new Map();
   values.forEach((value, index) => {
     if (isRecord10(value) && typeof value.id === "string")
@@ -103905,20 +104916,17 @@ function snapshotEnvironmentDocument(environment) {
       values[index] = cloned;
     }
   };
-  for (const row of environment.context.__valueOverlay?.values() ?? [])
-    mergeRow(row);
-  for (const row of environment.context.__runtimeSessionValues?.values() ?? [])
-    mergeRow(row);
+  for (const row of overlay?.values() ?? []) mergeRow(row);
+  for (const row of runtime?.values() ?? []) mergeRow(row);
   snapshot.values = values;
-  const members = Array.isArray(snapshot.members) ? snapshot.members : [];
-  const bindings = new Map([
-    ...environment.context.__saveStaticBindings ?? [],
-    ...environment.context.__sessionStaticBindings ?? []
-  ]);
-  for (const member of members) {
-    if (!isRecord10(member) || typeof member.id !== "string") continue;
-    if (bindings.has(member.id))
-      member.valueId = bindings.get(member.id) ?? null;
+  if (bindings.size > 0) {
+    const baseMembers = Array.isArray(snapshot.members) ? snapshot.members : [];
+    snapshot.members = baseMembers.map((member) => {
+      if (!isRecord10(member) || typeof member.id !== "string" || !bindings.has(member.id)) {
+        return member;
+      }
+      return { ...member, valueId: bindings.get(member.id) ?? null };
+    });
   }
   return snapshot;
 }
@@ -103939,10 +104947,7 @@ function copyMocks(source, target) {
   }
 }
 function cloneTestEnvironment(source) {
-  const cloned = createTestEnvironment(
-    snapshotEnvironmentDocument(source),
-    true
-  );
+  const cloned = createTestEnvironment(snapshotEnvironmentDocument(source));
   copyMocks(source, cloned);
   return cloned;
 }
@@ -103953,10 +104958,14 @@ function runCallback(environment, delegate, deadlineMs) {
     __indexes: void 0,
     wallClockDeadlineMs: deadlineMs
   });
-  evaluateNSDelegate(
-    bindNeoScriptDelegateToContext(delegate, environment.context),
-    environment.context
-  );
+  try {
+    evaluateNSDelegate(
+      bindNeoScriptDelegateToContext(delegate, environment.context),
+      environment.context
+    );
+  } finally {
+    environment.hasStateChanges ||= (environment.context.__executionState?.writes.length ?? 0) > 0 || (environment.context.__runtimeSessionValues?.size ?? 0) > 0 || (environment.context.__saveStaticBindings?.size ?? 0) > 0 || (environment.context.__sessionStaticBindings?.size ?? 0) > 0;
+  }
 }
 function failureFor(error, file, position, member = null) {
   const timeout = error instanceof NeoScriptWallClockTimeoutError;
@@ -103982,18 +104991,22 @@ function suiteHasSelectedTests(suite, selected2) {
 async function executeRegisteredSpec(registered, document, selected2, timeoutMs, interrupted) {
   const results = [];
   const fileFailures = [];
+  let testDurationMs = 0;
   const executeSuite = async (suite, parentEnvironment, inheritedFailures) => {
     if (!suiteHasSelectedTests(suite, selected2)) return;
     const fixture = cloneTestEnvironment(parentEnvironment);
     const suiteFailures = [...inheritedFailures];
     const suiteDeadline = Date.now() + timeoutMs;
     for (const hook of suite.beforeAll) {
+      const hookStarted = performance.now();
       try {
         runCallback(fixture, hook, suiteDeadline);
       } catch (error) {
         suiteFailures.push(
           failureFor(error, registered.spec.path, suite, "beforeAll")
         );
+      } finally {
+        testDurationMs += performance.now() - hookStarted;
       }
     }
     for (const test of suite.tests) {
@@ -104001,6 +105014,8 @@ async function executeRegisteredSpec(registered, document, selected2, timeoutMs,
       const started = performance.now();
       const deadline = Date.now() + timeoutMs;
       const environment = cloneTestEnvironment(fixture);
+      const startupBeforeTestMs = performance.now() - started;
+      const testStarted = performance.now();
       const failures = [...suiteFailures];
       let setupFailed = failures.length > 0;
       if (!setupFailed) {
@@ -104037,19 +105052,24 @@ async function executeRegisteredSpec(registered, document, selected2, timeoutMs,
           }
         }
       }
-      const durationMs = performance.now() - started;
+      const currentTestDurationMs = performance.now() - testStarted;
+      const schedulerStarted = performance.now();
+      await new Promise((resolvePromise) => {
+        setImmediate(resolvePromise);
+      });
+      const startupDurationMs = startupBeforeTestMs + performance.now() - schedulerStarted;
+      testDurationMs += currentTestDurationMs;
       results.push({
         id: test.id,
         file: registered.spec.path,
         name: test.name,
         fullName: test.fullName,
         status: failures.length === 0 ? "passed" : "failed",
-        durationMs,
+        durationMs: startupDurationMs + currentTestDurationMs,
+        startupDurationMs,
+        testDurationMs: currentTestDurationMs,
         failures
       });
-      await new Promise((resolvePromise) => {
-        setImmediate(resolvePromise);
-      });
       if (interrupted()) break;
     }
     for (const child of suite.suites) {
@@ -104057,12 +105077,15 @@ async function executeRegisteredSpec(registered, document, selected2, timeoutMs,
       await executeSuite(child, fixture, suiteFailures);
     }
     for (const hook of suite.afterAll) {
+      const hookStarted = performance.now();
       try {
         runCallback(fixture, hook, Date.now() + timeoutMs);
       } catch (error) {
         fileFailures.push(
           failureFor(error, registered.spec.path, suite, "afterAll")
         );
+      } finally {
+        testDurationMs += performance.now() - hookStarted;
       }
     }
   };
@@ -104073,7 +105096,7 @@ async function executeRegisteredSpec(registered, document, selected2, timeoutMs,
   results.sort(
     (left, right) => (registrationOrder.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (registrationOrder.get(right.id) ?? Number.MAX_SAFE_INTEGER)
   );
-  return { tests: results, failures: fileFailures };
+  return { tests: results, failures: fileFailures, testDurationMs };
 }
 function atomicWrite(path, content) {
   mkdirSync11(dirname9(path), { recursive: true });
@@ -104126,8 +105149,28 @@ function maintainNeoTestBuildCache(root, maxBytes = TEST_BUILD_CACHE_LIMIT_BYTES
     total -= file.size;
   }
 }
+function formatTestDuration(durationMs) {
+  if (durationMs >= 1e3) {
+    const seconds = durationMs / 1e3;
+    return `${seconds < 10 ? seconds.toFixed(2) : seconds.toFixed(1)}s`;
+  }
+  return `${durationMs < 10 ? durationMs.toFixed(2) : durationMs.toFixed(1)}ms`;
+}
+function paintTestDuration(durationMs) {
+  const formatted = formatTestDuration(durationMs);
+  return durationMs >= 300 ? color.yellow(formatted) : color.dim(formatted);
+}
+function formatStatusCounts(passed, failed, total, skipped = 0) {
+  const parts = [
+    failed > 0 ? color.red(`${failed} failed`) : null,
+    passed > 0 ? color.green(`${passed} passed`) : null,
+    skipped > 0 ? color.yellow(`${skipped} skipped`) : null
+  ].filter((part) => part !== null);
+  return `${parts.join(color.dim(" | "))} ${color.dim(`(${total})`)}`;
+}
 async function runTest(workspace, options, dependencies = {}) {
   const started = Date.now();
+  const performanceStarted = performance.now();
   const testBuildRoot = join16(workspace.root, ".neo", "test-build");
   maintainNeoTestBuildCache(testBuildRoot);
   const startedAt = new Date(started).toISOString();
@@ -104140,6 +105183,7 @@ async function runTest(workspace, options, dependencies = {}) {
   const selectedTestCountByFile = /* @__PURE__ */ new Map();
   const fileFailuresByPath = /* @__PURE__ */ new Map();
   const diagnostics = [];
+  let testDurationMs = 0;
   let exitCode = 0;
   let interrupted = false;
   const handleSigint = () => {
@@ -104153,22 +105197,77 @@ async function runTest(workspace, options, dependencies = {}) {
     }
   };
   process.on("SIGINT", handleSigint);
+  const phaseDurations = {
+    prepare: 0,
+    select: 0,
+    compile: 0,
+    register: 0,
+    execute: 0,
+    finalize: 0
+  };
   let phase = "prepare";
+  let phaseStarted = performanceStarted;
+  const enterPhase = (next, label) => {
+    const finished = performance.now();
+    phaseDurations[phase] += finished - phaseStarted;
+    phase = next;
+    phaseStarted = finished;
+    dependencies.progress?.update(label);
+  };
+  const finishPhase = () => {
+    const finished = performance.now();
+    phaseDurations[phase] += finished - phaseStarted;
+    phaseStarted = finished;
+  };
+  dependencies.progress?.update("Preparing test project\u2026");
   try {
-    const candidate = dependencies.prepareLocalCandidate === void 0 ? preparedHookCandidate(workspace) ?? await prepareLocalCandidateV4(workspace) : await dependencies.prepareLocalCandidate(workspace);
+    let candidate = dependencies.prepareLocalCandidate === void 0 ? preparedHookCandidate(workspace) : null;
+    let candidateInputFingerprint = null;
+    let shouldCacheCandidate = false;
+    if (candidate === null) {
+      const canUseCandidateCache = dependencies.prepareLocalCandidate === void 0 || dependencies.fingerprintCandidateInputs !== void 0;
+      if (canUseCandidateCache) {
+        candidateInputFingerprint = dependencies.fingerprintCandidateInputs?.(workspace) ?? fingerprintTestCandidateInputs(workspace);
+        candidate = cachedTestCandidate(workspace, candidateInputFingerprint);
+      }
+      if (candidate === null) {
+        const prepared = dependencies.prepareLocalCandidate === void 0 ? await prepareLocalCandidateV4(workspace, {
+          onPhase: (label) => {
+            dependencies.progress?.update(label);
+          }
+        }) : await dependencies.prepareLocalCandidate(workspace);
+        if (prepared.document === null) {
+          throw new NeoTestReportWriteError(
+            "Local test preparation did not produce a project document."
+          );
+        }
+        candidate = {
+          document: prepared.document,
+          sourceHash: prepared.sourceHash
+        };
+        shouldCacheCandidate = canUseCandidateCache;
+      }
+    }
     assertNotInterrupted();
-    if (candidate.document === null) {
+    if (candidate === null) {
       throw new NeoTestReportWriteError(
-        "Local test preparation did not produce a project document."
+        "Local test preparation produced no reusable candidate."
       );
     }
+    if (shouldCacheCandidate && candidateInputFingerprint !== null) {
+      candidate = cacheTestCandidate(workspace, candidateInputFingerprint, {
+        document: candidate.document,
+        sourceHash: candidate.sourceHash
+      });
+    }
     projectFingerprint = `sha256:${candidate.sourceHash}`;
     const rawDocument = documentRecord(candidate.document);
     const compilationHash = projectCompilationHash(
       candidate.sourceHash,
-      rawDocument
+      rawDocument,
+      candidate.documentSha256
     );
-    phase = "select";
+    enterPhase("select", "Selecting test files\u2026");
     let selectedPaths;
     try {
       selectedPaths = selectedSpecPaths(workspace, options.selectors);
@@ -104183,7 +105282,7 @@ async function runTest(workspace, options, dependencies = {}) {
         "No .spec.neo files matched. Pass --passWithNoTests to treat this as success."
       );
     }
-    phase = "compile";
+    enterPhase("compile", "Compiling test files\u2026");
     specs = selectedPaths.map(
       (path) => compileSpec(workspace, rawDocument, path, compilationHash)
     );
@@ -104197,7 +105296,7 @@ async function runTest(workspace, options, dependencies = {}) {
         );
       }
     }
-    phase = "register";
+    enterPhase("register", "Registering tests\u2026");
     const registered = specs.map((spec) => registerSpec(spec, rawDocument));
     const selectedTests = registered.flatMap((entry) => entry.tests).filter((test) => pattern === null || pattern.test(test.fullName));
     for (const entry of registered) {
@@ -104214,7 +105313,7 @@ async function runTest(workspace, options, dependencies = {}) {
       );
     }
     const selectedIds = new Set(selectedTests.map((test) => test.id));
-    phase = "execute";
+    enterPhase("execute", "Running tests\u2026");
     const timeoutMs = options.timeoutMs ?? workspace.config.test?.timeoutMs ?? 5e3;
     for (const entry of registered) {
       const executed = await executeRegisteredSpec(
@@ -104225,12 +105324,14 @@ async function runTest(workspace, options, dependencies = {}) {
         () => interrupted
       );
       results.push(...executed.tests);
+      testDurationMs += executed.testDurationMs;
       fileFailuresByPath.set(entry.spec.path, executed.failures);
       assertNotInterrupted();
     }
     if (results.some((result) => result.status === "failed") || [...fileFailuresByPath.values()].some((failures) => failures.length > 0)) {
       exitCode = 1;
     }
+    enterPhase("finalize", "Finalizing test report\u2026");
     const buildManifest = {
       version: 1,
       cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
@@ -104238,14 +105339,14 @@ async function runTest(workspace, options, dependencies = {}) {
       compilerRevision: NEOSCRIPT_COMPILER_REVISION,
       evaluatorRevision: 4,
       projectFingerprint,
-      configurationSha256: createHash10("sha256").update(JSON.stringify(workspace.config.test ?? {})).digest("hex"),
+      configurationSha256: createHash11("sha256").update(JSON.stringify(workspace.config.test ?? {})).digest("hex"),
       dependencyGraph: Object.fromEntries(
         specs.map((spec) => [spec.path, [projectFingerprint]])
       ),
       artifacts: specs.map((spec) => ({
         path: spec.path,
-        sourceSha256: createHash10("sha256").update(spec.source).digest("hex"),
-        artifactSha256: createHash10("sha256").update(JSON.stringify(spec.action)).digest("hex")
+        sourceSha256: createHash11("sha256").update(spec.source).digest("hex"),
+        artifactSha256: createHash11("sha256").update(JSON.stringify(spec.action)).digest("hex")
       }))
     };
     atomicWrite(
@@ -104266,6 +105367,8 @@ async function runTest(workspace, options, dependencies = {}) {
       related: []
     });
   }
+  finishPhase();
+  dependencies.progress?.stop();
   process.off("SIGINT", handleSigint);
   const failed = results.filter((result) => result.status === "failed").length;
   const selectedTestTotal = [...selectedTestCountByFile.values()].reduce(
@@ -104273,7 +105376,16 @@ async function runTest(workspace, options, dependencies = {}) {
     0
   );
   const skipped = Math.max(0, selectedTestTotal - results.length);
-  const durationMs = Date.now() - started;
+  const durationMs = performance.now() - performanceStarted;
+  const startupDurationMs = Math.max(0, durationMs - testDurationMs);
+  const perTestStartupDurationMs = results.reduce(
+    (sum, result) => sum + result.startupDurationMs,
+    0
+  );
+  const sharedStartupDurationMs = Math.max(
+    0,
+    startupDurationMs - perTestStartupDurationMs
+  );
   const testFiles = specs.map((spec) => {
     const tests = results.filter((result) => result.file === spec.path);
     const failures = fileFailuresByPath.get(spec.path) ?? [];
@@ -104290,7 +105402,7 @@ async function runTest(workspace, options, dependencies = {}) {
     success: exitCode === 0,
     projectFingerprint,
     seed: Number.parseInt(
-      createHash10("sha256").update(projectFingerprint ?? "neo-test:no-project").digest("hex").slice(0, 8),
+      createHash11("sha256").update(projectFingerprint ?? "neo-test:no-project").digest("hex").slice(0, 8),
       16
     ),
     selection: {
@@ -104305,7 +105417,18 @@ async function runTest(workspace, options, dependencies = {}) {
       failed,
       skipped,
       todo: 0,
-      durationMs
+      durationMs,
+      startupDurationMs,
+      sharedStartupDurationMs,
+      testDurationMs
+    },
+    timings: {
+      prepareMs: phaseDurations.prepare,
+      selectMs: phaseDurations.select,
+      compileMs: phaseDurations.compile,
+      registerMs: phaseDurations.register,
+      executeMs: phaseDurations.execute,
+      finalizeMs: phaseDurations.finalize
     },
     testFiles,
     diagnostics,
@@ -104330,30 +105453,63 @@ async function runTest(workspace, options, dependencies = {}) {
   if (options.reporter === "json") {
     if (options.outputFile === null) process.stdout.write(serialized);
   } else {
-    for (const result of results) {
+    console.log("");
+    console.log(
+      ` ${color.bold("RUN")} ${color.dim(`neo ${PROJECT_SCHEMA_CONTRACT.cliVersion} ${workspace.root}`)}`
+    );
+    console.log("");
+    console.log(
+      ` ${color.cyan("\u21BB")} ${color.dim("shared startup")} ${paintTestDuration(report.summary.sharedStartupDurationMs)}`
+    );
+    for (const file of testFiles) {
+      const fileDurationMs = file.tests.reduce(
+        (sum, test) => sum + test.durationMs,
+        0
+      );
+      const fileSymbol = file.status === "passed" ? color.green("\u2713") : file.status === "failed" ? color.red("\xD7") : color.yellow("!");
+      const testLabel = `${file.tests.length} ${file.tests.length === 1 ? "test" : "tests"}`;
       console.log(
-        `${result.status === "passed" ? "\u2713" : "\u2717"} ${result.file} > ${result.name} (${result.durationMs.toFixed(1)}ms)`
+        ` ${fileSymbol} ${color.bold(file.path)} ${color.dim(`(${testLabel})`)} ${paintTestDuration(fileDurationMs)}`
       );
-      for (const failure of result.failures)
-        console.log(`  ${failure.message}`);
-    }
-    for (const file of testFiles) {
+      for (const result of file.tests) {
+        const resultSymbol = result.status === "passed" ? color.green("\u2713") : color.red("\xD7");
+        console.log(
+          `   ${resultSymbol} ${result.name}  ${color.dim("total")} ${paintTestDuration(result.durationMs)} ${color.dim(`(test ${formatTestDuration(result.testDurationMs)}, startup ${formatTestDuration(result.startupDurationMs)})`)}`
+        );
+        for (const failure of result.failures) {
+          console.log(`     ${color.red(failure.message)}`);
+        }
+      }
       if (file.status === "interrupted") {
         console.log(
-          `! ${file.path} > interrupted before all selected tests ran`
+          `   ${color.yellow("!")} interrupted before all selected tests ran`
         );
       }
       for (const failure of file.failures) {
         console.log(
-          `\u2717 ${file.path} > ${failure.frames[0]?.member ?? "suite hook"}`
+          `   ${color.red("\xD7")} ${failure.frames[0]?.member ?? "suite hook"}`
         );
-        console.log(`  ${failure.message}`);
+        console.log(`     ${color.red(failure.message)}`);
       }
     }
-    for (const diagnostic of diagnostics)
-      console.log(`\u2717 ${diagnostic.message}`);
+    for (const diagnostic of diagnostics) {
+      console.log(` ${color.red("\xD7")} ${diagnostic.message}`);
+    }
+    console.log("");
+    const passedFiles = testFiles.filter(
+      (file) => file.status === "passed"
+    ).length;
+    const failedFiles = testFiles.filter(
+      (file) => file.status === "failed"
+    ).length;
+    console.log(
+      ` ${color.bold(pad("Test Files", 11))} ${formatStatusCounts(passedFiles, failedFiles, report.summary.files)}`
+    );
     console.log(
-      `${report.summary.passed} passed, ${report.summary.failed} failed (${report.summary.durationMs}ms)`
+      ` ${color.bold(pad("Tests", 11))} ${formatStatusCounts(report.summary.passed, report.summary.failed, report.summary.tests, report.summary.skipped)}`
+    );
+    console.log(
+      ` ${color.bold(pad("Duration", 11))} ${color.bold(`total ${formatTestDuration(report.summary.durationMs)}`)} ${color.dim(`(test ${formatTestDuration(report.summary.testDurationMs)}, startup ${formatTestDuration(report.summary.startupDurationMs)})`)}`
     );
   }
   if (!report.success) process.exitCode = exitCode;
@@ -104400,7 +105556,7 @@ async function inspectNeoTestCompilation(workspace, dependencies = {}) {
     errors
   };
 }
-var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, NeoTestUsageError, NeoTestNoTestsError, NeoTestRegistrationError, NeoTestReportWriteError, NeoTestPreparedCandidateError, NeoTestInterruptedError, NeoTestAssertionError, ERROR_SOURCE_POSITIONS, REGISTRATION_IDS;
+var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACHE_REVISION, NeoTestUsageError, NeoTestNoTestsError, NeoTestRegistrationError, NeoTestReportWriteError, NeoTestPreparedCandidateError, NeoTestInterruptedError, NeoTestAssertionError, ERROR_SOURCE_POSITIONS, SHARED_EVALUATOR_BASES, REGISTRATION_IDS, MATCHER_IDS;
 var init_test = __esm({
   "src/commands/test.ts"() {
     "use strict";
@@ -104413,8 +105569,10 @@ var init_test = __esm({
     init_push();
     init_registry2();
     init_push_hook();
+    init_ui();
     TEST_BUILD_CACHE_LIMIT_BYTES = 512 * 1024 * 1024;
     ABANDONED_TEMP_MAX_AGE_MS = 60 * 60 * 1e3;
+    TEST_CANDIDATE_CACHE_REVISION = 1;
     NeoTestUsageError = class extends Error {
       name = "NeoTestUsageError";
     };
@@ -104446,6 +105604,7 @@ var init_test = __esm({
       received;
     };
     ERROR_SOURCE_POSITIONS = /* @__PURE__ */ new WeakMap();
+    SHARED_EVALUATOR_BASES = /* @__PURE__ */ new WeakMap();
     REGISTRATION_IDS = /* @__PURE__ */ new Set([
       NEO_TEST_IDS.describe,
       NEO_TEST_IDS.test,
@@ -104455,6 +105614,24 @@ var init_test = __esm({
       NEO_TEST_IDS.beforeEach,
       NEO_TEST_IDS.afterEach
     ]);
+    MATCHER_IDS = /* @__PURE__ */ new Set([
+      NEO_TEST_IDS.toBe,
+      NEO_TEST_IDS.toEqual,
+      NEO_TEST_IDS.toBeNull,
+      NEO_TEST_IDS.toBeTrue,
+      NEO_TEST_IDS.toBeFalse,
+      NEO_TEST_IDS.toBeGreaterThan,
+      NEO_TEST_IDS.toBeGreaterThanOrEqual,
+      NEO_TEST_IDS.toBeLessThan,
+      NEO_TEST_IDS.toBeLessThanOrEqual,
+      NEO_TEST_IDS.toContain,
+      NEO_TEST_IDS.toHaveLength,
+      NEO_TEST_IDS.toMatchObject,
+      NEO_TEST_IDS.toThrow,
+      NEO_TEST_IDS.toHaveBeenCalled,
+      NEO_TEST_IDS.toHaveBeenCalledTimes,
+      NEO_TEST_IDS.toHaveBeenCalledWith
+    ]);
   }
 });
 
@@ -107841,7 +109018,8 @@ function loadWorkspaceForCommand(args) {
     // A reset reconstructs the working copy from the server and may therefore
     // discard an unsupported pre-cutover cache. No other command gets this
     // exception, so format 2 never becomes an active compatibility read path.
-    discardLegacyFormat2State: args.command === "pull" && boolFlag(args, "reset")
+    discardLegacyFormat2State: args.command === "pull" && boolFlag(args, "reset"),
+    fingerprintStateSource: args.command === "test"
   });
   const apiOverride = stringFlag(args, "api");
   if (apiOverride !== null) {
@@ -108019,7 +109197,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.26.1");
+    console.log("0.26.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -108303,15 +109481,25 @@ async function main() {
           "--testTimeout must be a positive number of milliseconds."
         );
       }
-      const { runTest: runTest2 } = await Promise.resolve().then(() => (init_test(), test_exports));
-      await runTest2(workspace, {
-        selectors: args.positional,
-        testNamePattern: stringFlag(args, "testNamePattern"),
-        reporter: reporterValue,
-        outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
-        passWithNoTests: boolFlag(args, "passWithNoTests"),
-        ...timeoutMs === void 0 ? {} : { timeoutMs }
-      });
+      const progress = reporterValue === "default" && process.stdout.isTTY === true ? spinner("Preparing test project\u2026") : null;
+      try {
+        const { runTest: runTest2 } = await Promise.resolve().then(() => (init_test(), test_exports));
+        await runTest2(
+          workspace,
+          {
+            selectors: args.positional,
+            testNamePattern: stringFlag(args, "testNamePattern"),
+            reporter: reporterValue,
+            outputFile: stringFlag(args, "outputFile") ?? stringFlag(args, "output-file"),
+            passWithNoTests: boolFlag(args, "passWithNoTests"),
+            ...timeoutMs === void 0 ? {} : { timeoutMs }
+          },
+          progress === null ? {} : { progress }
+        );
+      } catch (error) {
+        progress?.fail("Test run failed.");
+        throw error;
+      }
       return;
     }
     case "dev": {