@neocompose/cli 0.18.0 → 0.19.0

package/dist/neo.mjs

@@ -8664,6 +8664,7 @@ var init_strict_resolver = __esm({
               branchExitNarrowings.push(new Map(noBranchScope.narrowedPaths));
               branchExitOwnershipScopes.push(noBranchScope);
             }
+            mergeBranchInvalidations(scope, branchExitOwnershipScopes);
             if (branchExitNarrowings.length > 0) {
               for (const [path, narrowed] of mergeNarrowingMaps(
                 branchExitNarrowings
@@ -8674,7 +8675,6 @@ var init_strict_resolver = __esm({
                 }
               }
             }
-            mergeBranchInvalidations(scope, branchExitOwnershipScopes);
             mergeBranchOwnership(scope, branchExitOwnershipScopes);
             return {
               type: "if" /* If */,
@@ -9386,7 +9386,13 @@ var init_strict_resolver = __esm({
           );
         }
         const resolvedTarget = this.resolveExpression(statement.target, scope);
-        const target = local && statement.op === "=" ? { ...resolvedTarget, type: local.type } : resolvedTarget;
+        const storageType = this.assignmentStorageType(
+          statement.target,
+          resolvedTarget,
+          local,
+          scope
+        );
+        const target = statement.op === "=" ? { ...resolvedTarget, type: storageType } : resolvedTarget;
         const writability = local?.writability ?? target.writability;
         if (target.symbol?.computed === true && target.symbol.writable !== true) {
           throw new CompileError(
@@ -9441,7 +9447,15 @@ var init_strict_resolver = __esm({
         const assignedPath = canonicalPath(statement.target);
         if (assignedPath) {
           const rootEntry = scope.lookup(pathRoot(assignedPath));
-          if (rootEntry) scope.invalidate(rootEntry);
+          if (rootEntry) {
+            scope.invalidate(rootEntry);
+            if (statement.op === "=" && !isNullable(value.type)) {
+              scope.narrow(assignedPath, rootEntry, {
+                ...target.type,
+                nullable: false
+              });
+            }
+          }
         }
         return {
           type: "assign" /* Assign */,
@@ -9454,6 +9468,23 @@ var init_strict_resolver = __esm({
           pointer: value.pointer
         };
       }
+      /**
+       * The declared type of an assignment target, with any flow narrowing on the
+       * path stripped back off. Locals carry their declaration on the scope entry;
+       * a member re-resolves through `resolveMemberNatural`, which is the same
+       * lookup `resolveMember` performs before it overlays a narrowed type.
+       */
+      assignmentStorageType(targetAst, resolvedTarget, local, scope) {
+        if (targetAst.kind === "ident") return local?.type ?? resolvedTarget.type;
+        if (targetAst.kind !== "member") return resolvedTarget.type;
+        return this.resolveMemberNatural(
+          targetAst.receiver,
+          targetAst.name,
+          scope,
+          targetAst.pos,
+          targetAst.optional === true
+        ).type;
+      }
       resolveCompoundAssignment(operation, valueAst, target, scope, pos) {
         const binaryOperation = operation === "++" ? "+" : operation === "--" ? "-" : operation.slice(0, 1);
         const right = operation === "++" || operation === "--" ? literal({ kind: "primitive", name: "int" }, 1) : valueAst ? this.resolveExpression(valueAst, scope, target.type) : null;
@@ -10085,6 +10116,12 @@ var init_strict_resolver = __esm({
             pos
           );
         }
+        if (!optional && isNullable(receiver.type)) {
+          throw new CompileError(
+            `Member '${name}' is read on ${this.describe(receiver.type)}, which may be null. Handle null before reading through it \u2014 use \`!\` if it is always set, or \`?.\`, \`??\`, or a null check that narrows it.`,
+            pos
+          );
+        }
         if (receiver.staticType?.kind === "enum") {
           if (optional) {
             throw new CompileError(
@@ -17909,7 +17946,8 @@ function parseProjectRootInitializer(source) {
       name: name.text,
       type: type.text,
       storage: storage.text,
-      initializer
+      initializer,
+      start: expressionStart.pos
     });
   }
   take("}");
@@ -18398,10 +18436,20 @@ function validateProjectRootGlobal(uri, declaration, environment, diagnostics) {
       scope,
       environment,
       declaration.initializer.range,
-      diagnostics
+      diagnostics,
+      {
+        text: actual.initializer,
+        start: slotPosition(declaration.initializer.range.start, actual.start)
+      }
     );
   }
 }
+function slotPosition(start, pos) {
+  if (pos.line === 1) {
+    return { line: start.line, character: start.character + pos.column - 1 };
+  }
+  return { line: start.line + pos.line - 1, character: pos.column - 1 };
+}
 function validateMember(uri, member, documentKind, ownerScope, environment, diagnostics) {
   const memberType2 = semanticType(member.type);
   validateAnnotations(
@@ -19452,7 +19500,11 @@ function constructionSiteRange(expression, target, fallback, anchor) {
     if (!entry) return fallback;
     return anchorSpan(anchor, entry.pos, entry.name.length);
   }
-  return fallback;
+  return anchorSpan(
+    anchor,
+    expression.pos,
+    NEOSCRIPT_CONSTRUCTOR_KEYWORD.length
+  );
 }
 function namedArgumentRange(anchor, valuePos, name) {
   const prefix = anchor.text.slice(0, anchorOffset(anchor, valuePos));
@@ -20015,6 +20067,7 @@ var primitiveType, IDENTIFIER_PATTERN2, LIST_COLUMN_INHERITANCE_KEY;
 var init_project_source_semantics = __esm({
   "../packages/neoscript-language/src/project-source-semantics.ts"() {
     "use strict";
+    init_language_spec();
     init_project_schema_contract_generated();
     init_strict_compile_error();
     init_strict_parser();
@@ -26667,7 +26720,9 @@ function memberType(member, environment, visiting, field) {
       string2(member.collectionMemberId, `${field}.collectionMemberId`)
     );
     const collectionType = collection ? memberType(collection, environment, next, `${field}.collection`) : unknownType();
-    const entryType = collectionElementType2(collectionType) ?? unknownType();
+    const declared = optionalRecord(member.declaredType);
+    const declaredType = declared ? manifestType2(declared, environment, `${field}.declaredType`) : null;
+    const entryType = declaredType && !isUnknownType2(declaredType) ? declaredType : collectionElementType2(collectionType) ?? unknownType();
     return member.multiselect === true ? { kind: "set", elementType: entryType, nullable } : { ...entryType, nullable };
   }
   if (kind === "dialogueLookup") {
@@ -26995,6 +27050,9 @@ function primitive(name, nullable) {
 function unknownType() {
   return { kind: "primitive", name: "unknown" };
 }
+function isUnknownType2(type) {
+  return type.kind === "primitive" && type.name === "unknown";
+}
 function indexById(values, field) {
   const result = /* @__PURE__ */ new Map();
   values.forEach((value, index) => {
@@ -50841,6 +50899,7 @@ function drainValueReferenceObligationsV4(state, manifest, options) {
   for (const recorded of options.registry.loweringFailures) {
     failures.push({
       message: recorded.message,
+      ...recorded.code === void 0 ? {} : { code: recorded.code },
       ...composeReferenceSitePosition(recorded.site, options.sourceTextByUri)
     });
   }
@@ -52276,59 +52335,96 @@ function resolveConstructorProjectionArguments(context, schemaClass2, expression
     context.classes,
     schemaClass2.id
   );
+  const signature = describeProjectedConstructor(schemaClass2.name, projections);
   if (projections.length === 0) {
     if (expression.args.length > 0) {
-      throw new Error(
-        `Class ${schemaClass2.name} does not accept constructor arguments.`
-      );
+      context.loweringFailures.push({
+        message: `Class '${schemaClass2.name}' projects no constructor parameters, so '${schemaClass2.name}()' takes no arguments \u2014 this call passes ${expression.args.length}.`,
+        code: "unbound-constructor-argument",
+        site: referenceSite(source, expression)
+      });
     }
     return [];
   }
   const names = expression.argumentNames ?? [];
-  if (expression.args.length !== projections.length || names.length !== projections.length) {
-    throw new Error(
-      `Class ${schemaClass2.name} requires named constructor argument${projections.length === 1 ? "" : "s"} ${projections.map((entry) => entry.parameterName).join(", ")}.`
-    );
+  if (expression.args.length !== projections.length) {
+    context.loweringFailures.push({
+      message: `Constructor '${signature}' takes ${projections.length} argument${projections.length === 1 ? "" : "s"}, but this call passes ${expression.args.length} \u2014 parameters: ${describeQuotedNames(projections.map((entry) => entry.parameterName))}.`,
+      code: "missing-constructor-argument",
+      site: referenceSite(source, expression)
+    });
+    return [];
+  }
+  if (names.length !== projections.length) {
+    context.loweringFailures.push({
+      message: `Constructor '${signature}' takes named arguments only, so this call must name all ${projections.length} of them and names ${names.length} \u2014 parameters: ${describeQuotedNames(projections.map((entry) => entry.parameterName))}.`,
+      code: "unbound-constructor-argument",
+      site: referenceSite(source, expression)
+    });
+    return [];
   }
   const seen = /* @__PURE__ */ new Set();
   const resolved = [];
   for (let index = 0; index < expression.args.length; index++) {
+    const argument2 = expression.args[index];
     const parameterName = names[index];
     if (parameterName === null || parameterName === void 0) {
-      throw new Error(
-        `Class ${schemaClass2.name} constructor arguments must be named.`
-      );
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' takes named arguments only, so the argument at position ${index + 1} binds to no parameter \u2014 candidates: ${describeQuotedNames(projections.map((entry) => entry.parameterName))}.`,
+        code: "unbound-constructor-argument",
+        site: referenceSite(source, argument2)
+      });
+      continue;
     }
     if (seen.has(parameterName)) {
-      throw new Error(
-        `Class ${schemaClass2.name} constructor argument ${parameterName} is duplicated.`
-      );
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' is passed '${parameterName}' more than once, and each parameter binds exactly one argument.`,
+        code: "duplicate-constructor-argument",
+        site: namedArgumentSite(source, argument2, parameterName)
+      });
+      continue;
     }
     seen.add(parameterName);
     const projection = projections.find(
       (candidate) => candidate.parameterName === parameterName
     );
     if (projection === void 0) {
-      throw new Error(
-        `Class ${schemaClass2.name} has no constructor argument ${parameterName}.`
-      );
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' has no parameter '${parameterName}' \u2014 candidates: ${describeQuotedNames(projections.map((entry) => entry.parameterName))}.`,
+        code: "unknown-constructor-argument",
+        site: namedArgumentSite(source, argument2, parameterName)
+      });
+      continue;
     }
-    const argument2 = expression.args[index];
     if (argument2.kind !== "litString") {
-      throw new Error(
-        `Class ${schemaClass2.name} constructor argument ${parameterName} must be a value-row id string.`
-      );
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' parameter '${parameterName}' projects a row identity, so its argument must be a value-row id string literal.`,
+        code: "non-literal-constructor-argument",
+        site: referenceSite(source, argument2)
+      });
+      continue;
     }
     const schemaKey = inheritedProjectionSchemaKey(
       context.classes,
       schemaClass2.id,
       projection.memberId
     );
+    if (schemaKey === null) {
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' parameter '${parameterName}' projects member ${projection.memberId}, which no class in '${schemaClass2.name}'s inheritance chain declares under a schema key.`,
+        code: "unprojectable-constructor-argument",
+        site: referenceSite(source, argument2)
+      });
+      continue;
+    }
     const projectedMember = context.members.get(projection.memberId);
-    if (schemaKey === null || projectedMember?.kind !== "lookup") {
-      throw new Error(
-        `Class ${schemaClass2.name} constructor projection ${parameterName} does not resolve to a Lookup field.`
-      );
+    if (projectedMember?.kind !== "lookup") {
+      context.loweringFailures.push({
+        message: `Constructor '${signature}' parameter '${parameterName}' projects member ${projection.memberId}, which is ${projectedMember === void 0 ? "in no member of this project" : `a ${projectedMember.kind} member`} and not the Lookup field a projection writes.`,
+        code: "unprojectable-constructor-argument",
+        site: referenceSite(source, argument2)
+      });
+      continue;
     }
     context.referenceObligations.push({
       kind: "constructorProjection",
@@ -52349,6 +52445,14 @@ function resolveConstructorProjectionArguments(context, schemaClass2, expression
   }
   return resolved;
 }
+function describeProjectedConstructor(className, projections) {
+  return `${className}(${projections.map((entry) => entry.parameterName).join(", ")})`;
+}
+function describeQuotedNames(names) {
+  const quoted = names.map((name) => `'${name}'`);
+  if (quoted.length <= 1) return quoted.join("") || "none";
+  return `${quoted.slice(0, -1).join(", ")} and ${quoted.at(-1)}`;
+}
 function validateAnimationProjectionBinding(context, schemaClass2, environment, targetValueId) {
   if (schemaClass2.system?.worldKind !== "animationChildOverride") return;
   const parameter3 = schemaClass2.genericParameters[0];
@@ -52783,16 +52887,42 @@ function lowerReferences(context, member, expression, ownerValueId, source) {
   return ids;
 }
 function referenceSite(source, expression) {
+  return referenceSiteAt(source, expressionAnchorPos(expression));
+}
+function referenceSiteAt(source, pos) {
   return {
     uri: source.source.uri,
     declarationStart: source.source.range.start,
-    expression: {
-      initializer: source.initializer,
-      pos: expressionAnchorPos(expression)
-    },
+    expression: { initializer: source.initializer, pos },
     label: source.label
   };
 }
+function namedArgumentSite(source, argument2, name) {
+  const value = expressionAnchorPos(argument2);
+  const text = source.initializer;
+  const prefix = text.slice(0, initializerOffsetAtPos(text, value));
+  const colon = prefix.lastIndexOf(":");
+  if (colon < 0) return referenceSiteAt(source, value);
+  if (prefix.slice(colon + 1).trim().length > 0) {
+    return referenceSiteAt(source, value);
+  }
+  const beforeColon = prefix.slice(0, colon).trimEnd();
+  if (!beforeColon.endsWith(name)) return referenceSiteAt(source, value);
+  const start = sourcePositionAtOffset(text, beforeColon.length - name.length);
+  return referenceSiteAt(source, {
+    line: start.line + 1,
+    column: start.character + 1
+  });
+}
+function initializerOffsetAtPos(text, pos) {
+  let offset = 0;
+  for (let line = 1; line < pos.line; line += 1) {
+    const next = text.indexOf("\n", offset);
+    if (next < 0) return text.length;
+    offset = next + 1;
+  }
+  return Math.min(offset + pos.column - 1, text.length);
+}
 function expressionAnchorPos(expression) {
   if (expression.kind === "annotated") {
     return expressionAnchorPos(expression.expression);
@@ -53004,7 +53134,14 @@ function validateReferenceContract(context, member, target, ownerValueId) {
     const actualClassId = targetData && typeof targetData.classId === "string" ? targetData.classId : null;
     if (expectedClassId && actualClassId && !classAssignableToClass(context, actualClassId, expectedClassId)) {
       throw new Error(
-        `Lookup member ${member.name} target ${target.id} is ${context.classes.get(actualClassId)?.name ?? actualClassId}, but collection ${collectionMemberName(context, member)} holds ${context.classes.get(expectedClassId)?.name ?? expectedClassId}.`
+        `Lookup member ${member.name} target ${target.id} is ${classDisplayName(context, actualClassId)}, but collection ${collectionMemberName(context, member)} holds ${classDisplayName(context, expectedClassId)}.`
+      );
+    }
+    const declaredClassId = lookupDeclaredClassId(context, member);
+    if (declaredClassId && actualClassId && !classAssignableToClass(context, actualClassId, declaredClassId)) {
+      const narrowedFrom = expectedClassId === null ? `the collection ${collectionMemberName(context, member)}` : `the collection ${collectionMemberName(context, member)} holds ${classDisplayName(context, expectedClassId)}`;
+      throw new Error(
+        `Lookup member ${member.name} target ${target.id} is ${classDisplayName(context, actualClassId)}, but the member declares ${classDisplayName(context, declaredClassId)} \u2014 ${narrowedFrom} and this member narrows it. Point it at a ${classDisplayName(context, declaredClassId)} row.`
       );
     }
     if (target.genericTypeName && expectedTypeName && !referenceTypeNameAssignable(
@@ -53031,6 +53168,15 @@ function validateReferenceContract(context, member, target, ownerValueId) {
   }
   validateDialogueEligibility(context, member, target.id);
 }
+function lookupDeclaredClassId(context, member) {
+  const declared = member.declaredType;
+  if (declared === null) return null;
+  if (declared.kind !== "class") return null;
+  return context.classes.has(declared.classId) ? declared.classId : null;
+}
+function classDisplayName(context, classId) {
+  return context.classes.get(classId)?.name ?? classId;
+}
 function lookupEntryTypeName(context, member) {
   const collection = context.members.get(member.collectionMemberId);
   const entry = collection?.kind === "list" || collection?.kind === "dictionary" ? context.members.get(collection.entryMemberId) : null;
@@ -58886,12 +59032,14 @@ function computeWorkspaceStatus(workspace, options = {}) {
     }
   );
   for (const failure of referenceFailures) {
+    const message = failure.code === void 0 ? failure.message : `${failure.code}: ${failure.message}`;
     parseErrors.push(
       new SchemaSourceError(
-        failure.message,
+        message,
         failure.file,
         failure.line,
-        failure.column
+        failure.column,
+        failure.code
       )
     );
   }
@@ -64643,6 +64791,20 @@ function memberToSymbol(record3, schemaKey, containingClass2, ownerClassId2, ind
       writability: writable ? "setter" : "readOnly"
     };
   }
+  if (isMemberNSPropertyContractBase(resolved)) {
+    return {
+      ...common,
+      kind: "property",
+      type: toLanguageType(
+        resolved.returnTypeInfo,
+        context,
+        genericEnvironment
+      ),
+      writable: false,
+      computed: true,
+      writability: "readOnly"
+    };
+  }
   if (isMemberLookupBase(resolved)) {
     const collectionWritability = uniqueEffectiveWritability(
       resolved.collectionMemberId,
@@ -64991,27 +65153,26 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
     }
     case 9 /* Lookup */: {
       if (!isMemberLookupBase(member)) return UNKNOWN_TYPE2;
-      const collection = analyzerMemberById(
-        context.vm,
-        member.collectionMemberId
-      );
-      if (!collection) return UNKNOWN_TYPE2;
-      const collectionType = memberRuntimeType(
-        collection,
+      const declared = member.declaredTypeInfo ? toLanguageType(member.declaredTypeInfo, context, genericEnvironment) : null;
+      const narrowed = declared && !isUnknownType3(declared) ? declared : null;
+      const entry = narrowed ?? lookupCollectionEntryType(
+        member.collectionMemberId,
         context,
         nextSeen,
         genericEnvironment
       );
-      const entry = collectionEntryType(collectionType);
       if (!entry) return UNKNOWN_TYPE2;
       return member.multiselect ? {
         kind: "set",
         elementType: requiredType(entry),
         nullable: !required2
-      } : { ...entry, nullable: true };
+      } : { ...entry, nullable: !required2 };
     }
     case 10 /* NSProperty */:
-      return isMemberNSPropertyBase(member) ? toLanguageType(member.returnTypeInfo, context) : UNKNOWN_TYPE2;
+      if (isMemberNSPropertyBase(member) || isMemberNSPropertyContractBase(member)) {
+        return toLanguageType(member.returnTypeInfo, context);
+      }
+      return UNKNOWN_TYPE2;
     case 13 /* Function */:
     case 23 /* NSFunction */:
       return primitive2("void", true);
@@ -65262,6 +65423,16 @@ function collectionEntryType(type) {
   if (type.kind === "dictionary") return type.valueType;
   return null;
 }
+function lookupCollectionEntryType(collectionMemberId, context, seen, genericEnvironment) {
+  const collection = analyzerMemberById(context.vm, collectionMemberId);
+  if (!collection) return null;
+  return collectionEntryType(
+    memberRuntimeType(collection, context, new Set(seen), genericEnvironment)
+  );
+}
+function isUnknownType3(type) {
+  return type.kind === "primitive" && type.name === "unknown";
+}
 function projectLanguageVersion(context) {
   const records2 = [
     ...context.vm.classes,
@@ -65625,6 +65796,165 @@ var init_compiler_adapter = __esm({
   }
 });
 
+// src/commands/push-body-diagnostics.ts
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
+import { join as join12 } from "node:path";
+function createNeoScriptBodySourceLocator(workspace, status) {
+  const textByFile = /* @__PURE__ */ new Map();
+  return {
+    originOf(site) {
+      if (site.recordKind === "script") return null;
+      const record3 = status.reconstructed.get(
+        recordStateKey(site.recordKind, site.recordId)
+      );
+      if (record3 === void 0) return null;
+      const span2 = record3.sourceSpan;
+      if (span2 === void 0) {
+        return {
+          file: record3.file,
+          declarationStart: { line: record3.line - 1, character: 0 }
+        };
+      }
+      return { file: span2.path, declarationStart: span2.start };
+    },
+    textOf(file) {
+      const cached = textByFile.get(file);
+      if (cached !== void 0) return cached;
+      const path = join12(workspace.root, file);
+      const text = existsSync11(path) ? readFileSync10(path, "utf8") : null;
+      textByFile.set(file, text);
+      return text;
+    }
+  };
+}
+function compileNeoScriptBodyOrThrow(compile, site, locator) {
+  try {
+    return compile();
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+    throw positionNeoScriptBodyCompileError(error, site, locator);
+  }
+}
+function describeBodySite(site) {
+  if (site.recordKind === "script") {
+    return `${unitLabel(site.unit)} compiled from ${site.origin}`;
+  }
+  if (site.recordKind === "migration") {
+    if (site.ownerName === null) return `Migration '${site.memberName}'`;
+    return `Migration '${site.memberName}' (target ${site.ownerName})`;
+  }
+  const unit = unitLabel(site.unit);
+  if (site.ownerName === null) {
+    return `${unit} '${site.memberName}' (member ${site.recordId}, whose declaring class is not in this push's schema)`;
+  }
+  return `${unit} '${site.ownerName}.${site.memberName}'`;
+}
+function unitLabel(unit) {
+  return `${unit.charAt(0).toUpperCase()}${unit.slice(1)}`;
+}
+function positionNeoScriptBodyCompileError(error, site, locator) {
+  const subject = describeBodySite(site);
+  const message = error.message.replace(`${error.line}:${error.column}: `, "");
+  const inBody = `at ${error.line}:${error.column} in the compiled body`;
+  if (site.recordKind === "script") {
+    return new NeoScriptBodyCompileError(
+      `${subject}: ${message} (${inBody}; this body was handed to the CLI directly, so no declaring file exists to map it to)`,
+      error.line,
+      error.column
+    );
+  }
+  if (locator === null) {
+    return new NeoScriptBodyCompileError(
+      `${subject}: ${message} (${inBody}; no workspace source locator was supplied for this compile, so it could not be mapped to a file)`,
+      error.line,
+      error.column
+    );
+  }
+  const origin = locator.originOf(site);
+  if (origin === null) {
+    return new NeoScriptBodyCompileError(
+      `${subject}: ${message} (${inBody}; this body has no reconstructed source record in the workspace, so it could not be mapped to a file)`,
+      error.line,
+      error.column
+    );
+  }
+  const text = locator.textOf(origin.file);
+  if (text === null) {
+    return new SchemaSourceError(
+      `${subject}: ${message} (${inBody}; ${origin.file} could not be read, so the position is the declaration's)`,
+      origin.file,
+      origin.declarationStart.line + 1,
+      origin.declarationStart.character + 1
+    );
+  }
+  const composed = composeBodyPosition(text, origin, site.code, error);
+  if (composed === null) {
+    return new SchemaSourceError(
+      `${subject}: ${message} (${inBody}; the authored body text was not found in ${origin.file}, so the position is the declaration's)`,
+      origin.file,
+      origin.declarationStart.line + 1,
+      origin.declarationStart.character + 1
+    );
+  }
+  return new SchemaSourceError(
+    `${subject}: ${message}`,
+    origin.file,
+    composed.line,
+    composed.column
+  );
+}
+function composeBodyPosition(text, origin, code, error) {
+  const declarationOffset = offsetAtPosition(text, origin.declarationStart);
+  if (declarationOffset === null) return null;
+  const codeOffset = text.indexOf(code, declarationOffset);
+  if (codeOffset < 0) return null;
+  const start = positionAtOffset(text, codeOffset);
+  if (error.line === 1) {
+    return { line: start.line + 1, column: start.character + error.column };
+  }
+  return { line: start.line + error.line, column: error.column };
+}
+function offsetAtPosition(text, position) {
+  let offset = 0;
+  for (let line = 0; line < position.line; line += 1) {
+    const next = text.indexOf("\n", offset);
+    if (next < 0) return null;
+    offset = next + 1;
+  }
+  const candidate = offset + position.character;
+  return candidate > text.length ? null : candidate;
+}
+function positionAtOffset(text, offset) {
+  let line = 0;
+  let lineStart = 0;
+  for (let cursor = 0; cursor < offset; cursor += 1) {
+    if (text[cursor] === "\n") {
+      line += 1;
+      lineStart = cursor + 1;
+    }
+  }
+  return { line, character: offset - lineStart };
+}
+var NeoScriptBodyCompileError;
+var init_push_body_diagnostics = __esm({
+  "src/commands/push-body-diagnostics.ts"() {
+    "use strict";
+    init_compile_error();
+    init_source_diagnostics();
+    init_workspace();
+    NeoScriptBodyCompileError = class extends Error {
+      constructor(message, line, column) {
+        super(message);
+        this.line = line;
+        this.column = column;
+        this.name = "NeoScriptBodyCompileError";
+      }
+      line;
+      column;
+    };
+  }
+});
+
 // ../src/view-models/neoscript-evaluator/NSGetterRuntimeError.ts
 var NSGetterRuntimeError;
 var init_NSGetterRuntimeError = __esm({
@@ -72525,7 +72855,7 @@ __export(script_exports, {
   readDocumentArrays: () => readDocumentArrays,
   runScript: () => runScript
 });
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 function readDocumentArrays(raw) {
   const arrayOf2 = (field) => {
     const value = raw[field];
@@ -73037,9 +73367,9 @@ function buildRootValue(document) {
 }
 function readSource(options, fallback) {
   if (options.source !== null) return options.source;
-  if (options.file !== null) return readFileSync10(options.file, "utf8");
+  if (options.file !== null) return readFileSync11(options.file, "utf8");
   if (fallback !== void 0) return fallback;
-  const stdin = readFileSync10(0, "utf8");
+  const stdin = readFileSync11(0, "utf8");
   if (stdin.trim().length === 0) {
     throw new Error(
       "Provide NeoScript source as an argument, --file, or stdin."
@@ -73047,6 +73377,20 @@ function readSource(options, fallback) {
   }
   return stdin;
 }
+function describeScriptBodyOrigin(options, storedBodyMemberLabel) {
+  if (options.source !== null) return "the inline source argument";
+  if (options.file !== null) return `--file ${options.file}`;
+  if (storedBodyMemberLabel !== null) {
+    return `the stored body of ${storedBodyMemberLabel}`;
+  }
+  return "stdin";
+}
+function qualifiedMemberLabel(thisClass, member) {
+  const memberName = String(member.name ?? member.id);
+  if (thisClass === null) return `'${memberName}'`;
+  if (typeof thisClass.name !== "string") return `'${memberName}'`;
+  return `'${thisClass.name}.${memberName}'`;
+}
 function analyzeWorkspaceProjectManifestV4(workspace) {
   const status = computeWorkspaceStatus(workspace, {
     skipProjectBinaryInspection: true
@@ -73129,6 +73473,14 @@ async function runScript(workspace, command, options, dependencies = {}) {
     );
   }
   const thisClass = setterMember !== null ? resolveMemberContainingClass(setterMember, document) : nsFunctionTarget !== null ? nsFunctionMember?.isStatic === true ? null : nsFunctionTarget.receiverClass : resolveThisClass(options.thisRef, document);
+  const storedBodyMemberLabel = nsFunctionDefinition === null || nsFunctionMember === null ? null : qualifiedMemberLabel(thisClass, nsFunctionMember);
+  const bodyOrigin = describeScriptBodyOrigin(options, storedBodyMemberLabel);
+  const bodySite = (unit) => ({
+    recordKind: "script",
+    origin: bodyOrigin,
+    unit,
+    code: source
+  });
   const compileContext = {
     project: document.project,
     members: document.members,
@@ -73162,53 +73514,76 @@ async function runScript(workspace, command, options, dependencies = {}) {
         source,
         sharedContext
       );
-      const error = diagnostics.find(
-        (diagnostic) => diagnostic.severity === "error"
+      compileNeoScriptBodyOrThrow(
+        () => {
+          const diagnostic = diagnostics.find(
+            (candidate) => candidate.severity === "error"
+          );
+          if (diagnostic === void 0) return;
+          throw new CompileError(diagnostic.message, {
+            line: diagnostic.range.start.line + 1,
+            column: diagnostic.range.start.character + 1
+          });
+        },
+        bodySite(sharedKind),
+        null
       );
-      if (error !== void 0) {
-        throw new CompileError(error.message, {
-          line: error.range.start.line + 1,
-          column: error.range.start.character + 1
-        });
-      }
     }
     if (options.mode === "nsfunction") {
       if (nsFunctionMember === null || nsFunctionDefinition === null) {
         throw new Error("NSFunction mode requires a function target.");
       }
-      compiled = compileNSFunction(source, {
-        project: document.project,
-        members: document.members,
-        classes: document.classes,
-        enums: document.enums,
-        interfaces: document.interfaces,
-        thisClass,
-        returnTypeInfo: nsFunctionDefinition.returnTypeInfo,
-        argumentTypes: nsFunctionDefinition.argumentTypes,
-        deferred: nsFunctionDefinition.deferred,
-        functionName: String(nsFunctionMember.name ?? nsFunctionMember.id)
-      });
+      compiled = compileNeoScriptBodyOrThrow(
+        () => compileNSFunction(source, {
+          project: document.project,
+          members: document.members,
+          classes: document.classes,
+          enums: document.enums,
+          interfaces: document.interfaces,
+          thisClass,
+          returnTypeInfo: nsFunctionDefinition.returnTypeInfo,
+          argumentTypes: nsFunctionDefinition.argumentTypes,
+          deferred: nsFunctionDefinition.deferred,
+          functionName: String(nsFunctionMember.name ?? nsFunctionMember.id)
+        }),
+        bodySite("function"),
+        null
+      );
     } else if (options.mode === "setter") {
       if (setterMember === null) {
         throw new Error("Setter mode requires an NSProperty member target.");
       }
-      compiled = compileNSSetter(source, {
-        project: document.project,
-        members: document.members,
-        classes: document.classes,
-        enums: document.enums,
-        interfaces: document.interfaces,
-        thisClass,
-        valueTypeInfo: resolveScriptPropertyReturnTypeInfo(
-          setterMember,
-          document.members
-        )
-      });
+      compiled = compileNeoScriptBodyOrThrow(
+        () => compileNSSetter(source, {
+          project: document.project,
+          members: document.members,
+          classes: document.classes,
+          enums: document.enums,
+          interfaces: document.interfaces,
+          thisClass,
+          valueTypeInfo: resolveScriptPropertyReturnTypeInfo(
+            setterMember,
+            document.members
+          )
+        }),
+        bodySite("setter"),
+        null
+      );
+    } else if (command === "apply" || options.mode === "action") {
+      compiled = compileNeoScriptBodyOrThrow(
+        () => compileNSAction(source, compileContext),
+        bodySite("action"),
+        null
+      );
     } else {
-      compiled = command === "apply" || options.mode === "action" ? compileNSAction(source, compileContext) : compileNSGetter(source, compileContext);
+      compiled = compileNeoScriptBodyOrThrow(
+        () => compileNSGetter(source, compileContext),
+        bodySite("getter"),
+        null
+      );
     }
   } catch (error) {
-    if (error instanceof CompileError) {
+    if (error instanceof NeoScriptBodyCompileError) {
       const report2 = {
         ok: false,
         error: error.message,
@@ -73220,7 +73595,7 @@ async function runScript(workspace, command, options, dependencies = {}) {
       };
       const hint = options.returns === null && error.message.includes("not assignable to declared return type") ? '\n(eval defaults to an unknown return type \u2014 pass --returns, e.g. --returns "string[]")' : "";
       console.log(
-        options.json ? JSON.stringify(report2, null, 2) : `Compile error at ${error.line}:${error.column} \u2014 ${error.message}${hint}`
+        options.json ? JSON.stringify(report2, null, 2) : `Compile error \u2014 ${error.message}${hint}`
       );
       process.exitCode = 1;
       return;
@@ -74079,6 +74454,7 @@ var init_script = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_project_documents();
+    init_push_body_diagnostics();
     RETURN_SHORTHANDS = {
       // MemberKind numerics: Bool=1, Int=2, String=3, Float=4.
       bool: { type: 1, required: true },
@@ -74100,8 +74476,8 @@ __export(migrate_exports, {
   runMigrate: () => runMigrate
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join13 } from "node:path";
 async function runMigrate(workspace, subcommand, positional, targetRef, json, dependencies = {}) {
   if (subcommand === "new") {
     const name = positional[0];
@@ -74110,10 +74486,10 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
         "Usage: neo migrate new <name> [--target <ClassName|project>]"
       );
     }
-    const migrationsDir = join12(workspace.root, "Migrations");
+    const migrationsDir = join13(workspace.root, "Migrations");
     mkdirSync9(migrationsDir, { recursive: true });
     let nextOrder = 1;
-    if (existsSync11(migrationsDir)) {
+    if (existsSync12(migrationsDir)) {
       for (const entry of readdirSync5(migrationsDir)) {
         const match = /^(\d+)-/.exec(entry);
         if (match !== null) {
@@ -74122,8 +74498,8 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
       }
     }
     const relPath = migrationFileName(nextOrder, name);
-    const absolute = join12(workspace.root, relPath);
-    if (existsSync11(absolute)) {
+    const absolute = join13(workspace.root, relPath);
+    if (existsSync12(absolute)) {
       throw new Error(`"${relPath}" already exists.`);
     }
     const target = targetRef ?? "project";
@@ -74170,12 +74546,17 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     assertMigrationCheckWorkspaceIsValid(status);
     const candidate = localMigrationCheckCandidate(status);
     const compileAction = dependencies.compileAction ?? compileNSAction;
+    const bodySourceLocator = createNeoScriptBodySourceLocator(
+      workspace,
+      status
+    );
     let failures = 0;
     const results = [];
-    for (const { data: migration, file } of candidate.migrations) {
+    for (const { data: migration, file, recordId } of candidate.migrations) {
       if (typeof migration.code !== "string" || migration.code.trim().length === 0) {
         continue;
       }
+      const code = migration.code;
       const thisClass = typeof migration.targetClassId === "string" ? candidate.classes.find(
         (schemaClass2) => schemaClass2.id === migration.targetClassId
       ) ?? null : null;
@@ -74185,16 +74566,27 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
             `Migration targets unknown local class "${migration.targetClassId}". Fix its @target directive or restore the class declaration.`
           );
         }
-        compileAction(migration.code, {
-          project: raw.project,
-          members: candidate.members,
-          classes: candidate.classes,
-          enums: candidate.enums,
-          interfaces: candidate.interfaces,
-          thisClass,
-          dialogueContext: null,
-          migrationContext: true
-        });
+        compileNeoScriptBodyOrThrow(
+          () => compileAction(code, {
+            project: raw.project,
+            members: candidate.members,
+            classes: candidate.classes,
+            enums: candidate.enums,
+            interfaces: candidate.interfaces,
+            thisClass,
+            dialogueContext: null,
+            migrationContext: true
+          }),
+          {
+            recordKind: "migration",
+            recordId,
+            ownerName: migrationTargetClassName(thisClass),
+            memberName: String(migration.name ?? recordId),
+            unit: "migration",
+            code
+          },
+          bodySourceLocator
+        );
         results.push({
           id: migration.id,
           name: migration.name,
@@ -74203,7 +74595,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
         });
       } catch (error) {
         failures += 1;
-        const message = error instanceof CompileError ? `${error.line}:${error.column} ${error.message}` : error instanceof Error ? error.message : String(error);
+        const message = error instanceof Error ? error.message : String(error);
         results.push({
           id: migration.id,
           name: migration.name,
@@ -74305,7 +74697,11 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
 }
 function localMigrationCheckCandidate(status) {
   const byKind = (kind) => [...status.reconstructed.values()].filter((record3) => record3.recordKind === kind).map((record3) => record3.fullData);
-  const migrations = [...status.reconstructed.values()].filter((record3) => record3.recordKind === "migration").map((record3) => ({ data: record3.fullData, file: record3.file })).sort(
+  const migrations = [...status.reconstructed.values()].filter((record3) => record3.recordKind === "migration").map((record3) => ({
+    data: record3.fullData,
+    file: record3.file,
+    recordId: record3.recordId
+  })).sort(
     (left, right) => Number(left.data.order ?? 0) - Number(right.data.order ?? 0)
   );
   return {
@@ -74493,6 +74889,11 @@ function resolveAssignTarget(write, instanceValue, migrationName) {
   }
   return { childKey };
 }
+function migrationTargetClassName(thisClass) {
+  if (thisClass === null) return null;
+  if (typeof thisClass.name !== "string") return null;
+  return thisClass.name;
+}
 async function runPendingMigrations(workspace, client, raw, migrations, onlyRef, dryRunFlagUnused) {
   void dryRunFlagUnused;
   const dryRun = process.argv.includes("--dry-run");
@@ -74553,16 +74954,28 @@ async function runPendingMigrations(workspace, client, raw, migrations, onlyRef,
       );
     }
     const pinned = migration.action;
-    const compiled = pinned !== void 0 && pinned !== null ? pinned : compileNSAction(migration.code, {
-      project: document.project,
-      members: document.members,
-      classes: document.classes,
-      enums: document.enums,
-      interfaces: document.interfaces,
-      thisClass,
-      dialogueContext: null,
-      migrationContext: true
-    });
+    const migrationCode = migration.code;
+    const compiled = pinned !== void 0 && pinned !== null ? pinned : compileNeoScriptBodyOrThrow(
+      () => compileNSAction(migrationCode, {
+        project: document.project,
+        members: document.members,
+        classes: document.classes,
+        enums: document.enums,
+        interfaces: document.interfaces,
+        thisClass,
+        dialogueContext: null,
+        migrationContext: true
+      }),
+      {
+        recordKind: "migration",
+        recordId: String(migration.id),
+        ownerName: migrationTargetClassName(thisClass),
+        memberName: migrationName,
+        unit: "migration",
+        code: migrationCode
+      },
+      null
+    );
     const instances = targetClassId === null ? [null] : collectClassInstances(document, targetClassId, memberById, valueById);
     let instanceEditCount = 0;
     for (const instance of instances) {
@@ -75109,6 +75522,7 @@ var init_migrate = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_compiler_adapter();
+    init_push_body_diagnostics();
     init_neoscript_evaluator();
     init_script();
     init_project_migration_created_values();
@@ -76525,7 +76939,7 @@ __export(content_exports, {
   runRecords: () => runRecords,
   runValues: () => runValues
 });
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 function versionPath(workspace, suffix) {
   return `/api/projects/${workspace.config.projectId}/versions/${workspace.config.versionId}/${suffix}`;
@@ -76533,9 +76947,9 @@ function versionPath(workspace, suffix) {
 function readBatch(file) {
   let raw = null;
   if (file !== null) {
-    raw = readFileSync11(file, "utf8");
+    raw = readFileSync12(file, "utf8");
   } else if (!process.stdin.isTTY) {
-    raw = readFileSync11(0, "utf8");
+    raw = readFileSync12(0, "utf8");
     if (raw.trim().length === 0) raw = null;
   }
   if (raw === null) return null;
@@ -77692,7 +78106,7 @@ async function runFiles(context, subcommand, positional) {
         "Usage: neo files texture-settings <fileId> --file <settings.json>"
       );
     }
-    const payload = JSON.parse(readFileSync11(payloadPath, "utf8"));
+    const payload = JSON.parse(readFileSync12(payloadPath, "utf8"));
     const result = await context.client.post(
       versionPath(context.workspace, `files/${fileId}/unity-texture-settings`),
       payload
@@ -77721,7 +78135,7 @@ __export(export_exports, {
   runExportUnity: () => runExportUnity
 });
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function runExportUnity(workspace, outDir) {
   if (outDir === null) {
     throw new Error(
@@ -77733,23 +78147,23 @@ async function runExportUnity(workspace, outDir) {
     `/api/projects/${workspace.config.projectId}/export`,
     { versionId: workspace.config.versionId }
   );
-  const resourcesDir = join13(outDir, "Resources", "Neo");
-  const localizationDir = join13(resourcesDir, "Localization");
-  const scriptsDir = join13(outDir, "Scripts", "Neo");
+  const resourcesDir = join14(outDir, "Resources", "Neo");
+  const localizationDir = join14(resourcesDir, "Localization");
+  const scriptsDir = join14(outDir, "Scripts", "Neo");
   mkdirSync10(localizationDir, { recursive: true });
   mkdirSync10(scriptsDir, { recursive: true });
-  writeFileSync10(join13(resourcesDir, "project.json"), response.projectJson);
+  writeFileSync10(join14(resourcesDir, "project.json"), response.projectJson);
   writeFileSync10(
-    join13(scriptsDir, "NeoGeneratedTypes.cs"),
+    join14(scriptsDir, "NeoGeneratedTypes.cs"),
     response.generatedTypes
   );
   for (const file of response.localizationFiles ?? []) {
-    writeFileSync10(join13(localizationDir, file.fileName), file.content);
+    writeFileSync10(join14(localizationDir, file.fileName), file.content);
   }
-  console.log(`wrote ${join13(resourcesDir, "project.json")}`);
-  console.log(`wrote ${join13(scriptsDir, "NeoGeneratedTypes.cs")}`);
+  console.log(`wrote ${join14(resourcesDir, "project.json")}`);
+  console.log(`wrote ${join14(scriptsDir, "NeoGeneratedTypes.cs")}`);
   for (const file of response.localizationFiles ?? []) {
-    console.log(`wrote ${join13(localizationDir, file.fileName)}`);
+    console.log(`wrote ${join14(localizationDir, file.fileName)}`);
   }
   const diagnostics = response.diagnostics ?? [];
   for (const diagnostic of diagnostics) {
@@ -77895,8 +78309,8 @@ var init_project_source_bundle = __esm({
 });
 
 // src/project-source/project-file-push.ts
-import { basename as basename2, join as join14 } from "node:path";
-import { readFileSync as readFileSync12 } from "node:fs";
+import { basename as basename2, join as join15 } from "node:path";
+import { readFileSync as readFileSync13 } from "node:fs";
 function ensureProjectFileBinaryChangesV4(args) {
   for (const binary of args.binaryChanges) {
     if (binary.action !== "upload") continue;
@@ -77941,8 +78355,8 @@ function prepareProjectFilePushesV4(args) {
         `Project file ${recordId} has upload bytes but its source change has no record data.`
       );
     }
-    const absolute = join14(args.workspace.root, binary.path);
-    const bytes = new Uint8Array(readFileSync12(absolute));
+    const absolute = join15(args.workspace.root, binary.path);
+    const bytes = new Uint8Array(readFileSync13(absolute));
     const digest = sha256Bytes(bytes);
     if (binary.localSha256 !== null && digest !== binary.localSha256) {
       throw new Error(
@@ -78274,9 +78688,9 @@ var init_project_file_push = __esm({
 // src/project-source/trusted-commit-verification.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function verifyProjectSourceCommitAgainstStateV4(args) {
-  const root = join15(tmpdir(), `neo-source-verify-virtual-${randomUUID5()}`);
+  const root = join16(tmpdir(), `neo-source-verify-virtual-${randomUUID5()}`);
   const workspace = {
     root,
     config: {
@@ -78763,10 +79177,10 @@ import {
   mkdirSync as mkdirSync11,
   writeFileSync as writeFileSync11,
   rmSync as rmSync6,
-  existsSync as existsSync12,
-  readFileSync as readFileSync13
+  existsSync as existsSync13,
+  readFileSync as readFileSync14
 } from "node:fs";
-import { dirname as dirname7, join as join16, relative as relative5, sep as sep5 } from "node:path";
+import { dirname as dirname7, join as join17, relative as relative5, sep as sep5 } from "node:path";
 function assignPendingIds(changes, staticValueSeeds, reconstructed3) {
   const assigned = /* @__PURE__ */ new Map();
   const assign = (pendingId2) => {
@@ -79331,9 +79745,11 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     (change) => change.recordKind === "member" || change.recordKind === "class" || change.recordKind === "enum" || change.recordKind === "interface" || change.nextData !== void 0 && change.recordKind === "migration" && typeof change.nextData.code === "string" && change.nextData.code.trim().length > 0
   );
   const compileSchema = needsNeoScriptCompilation ? await buildPostPushCompileSchema(workspace, status) : null;
+  const bodySourceLocator = createNeoScriptBodySourceLocator(workspace, status);
   if (compileSchema !== null) {
     prepareCompleteNeoScriptBodyChanges(workspace, status, compileSchema, {
-      completeSweep: workspaceChangesRequireCompleteBodySweep(status.changes)
+      completeSweep: workspaceChangesRequireCompleteBodySweep(status.changes),
+      bodySourceLocator
     });
   }
   const now = Date.now();
@@ -79342,19 +79758,25 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     if (change.recordKind === "migration" && typeof change.nextData.code === "string" && change.nextData.code.trim().length > 0) {
       change.nextData = {
         ...change.nextData,
-        action: compileMigrationAction(compileSchema, change.nextData)
+        action: compileMigrationAction(
+          compileSchema,
+          change.nextData,
+          bodySourceLocator
+        )
       };
     }
     if (change.recordKind === "member" && change.nextData.kind === 10) {
       change.nextData = compileNSPropertyChange(
         compileSchema,
-        change.nextData
+        change.nextData,
+        bodySourceLocator
       );
     }
     if (change.recordKind === "member" && change.nextData.kind === 23) {
       change.nextData = compileNSFunctionChange(
         compileSchema,
-        change.nextData
+        change.nextData,
+        bodySourceLocator
       );
     }
     if (change.kind === "create") {
@@ -80269,13 +80691,13 @@ ${finalErrors.map(
   for (const recordState of Object.values(workspace.state.records)) {
     const previousPath = recordState.file;
     if (previousPath === void 0 || emittedPaths.has(previousPath)) continue;
-    const absolute = join16(workspace.root, previousPath);
-    if (existsSync12(absolute)) rmSync6(absolute);
+    const absolute = join17(workspace.root, previousPath);
+    if (existsSync13(absolute)) rmSync6(absolute);
   }
   for (const file of files) {
-    const absolute = join16(workspace.root, file.path);
+    const absolute = join17(workspace.root, file.path);
     mkdirSync11(dirname7(absolute), { recursive: true });
-    const existing = existsSync12(absolute) ? readFileSync13(absolute, "utf8") : null;
+    const existing = existsSync13(absolute) ? readFileSync14(absolute, "utf8") : null;
     if (existing !== file.content)
       writeFileSync11(absolute, file.content, "utf8");
   }
@@ -80312,7 +80734,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements) {
       return {
         uri,
         kind,
-        text: readFileSync13(absolutePath, "utf8")
+        text: readFileSync14(absolutePath, "utf8")
       };
     }
   );
@@ -80502,72 +80924,107 @@ function containingClass(schema, memberId) {
     return isObjectRecord2(classSchema) && Object.values(classSchema).includes(memberId);
   }) ?? null;
 }
-function compileNSPropertyChange(schema, memberData) {
+function bodyOwnerName(thisClass) {
+  if (thisClass === null) return null;
+  if (typeof thisClass.name !== "string") return null;
+  return thisClass.name;
+}
+function compileNSPropertyChange(schema, memberData, locator) {
   const memberId = memberData.id;
   const thisClass = containingClass(schema, memberId);
   const returnTypeInfo = resolveNSPropertyReturnTypeInfo(
     memberData,
     schema.members
   );
+  const bodyIdentity = {
+    recordKind: "member",
+    recordId: String(memberId),
+    ownerName: bodyOwnerName(thisClass),
+    memberName: String(memberData.name ?? memberId)
+  };
   const next = { ...memberData };
   if (typeof memberData.code === "string") {
-    next.getter = compileNSGetter2(memberData.code, {
-      project: schema.project,
-      members: schema.members,
-      classes: schema.classes,
-      enums: schema.enums,
-      interfaces: schema.interfaces,
-      thisClass,
-      returnTypeInfo,
-      dialogueContext: null,
-      implicitMemberAccess: true,
-      staticMember: memberData.isStatic === true
-    });
+    const code = memberData.code;
+    next.getter = compileNeoScriptBodyOrThrow(
+      () => compileNSGetter2(code, {
+        project: schema.project,
+        members: schema.members,
+        classes: schema.classes,
+        enums: schema.enums,
+        interfaces: schema.interfaces,
+        thisClass,
+        returnTypeInfo,
+        dialogueContext: null,
+        implicitMemberAccess: true,
+        staticMember: memberData.isStatic === true
+      }),
+      { ...bodyIdentity, unit: "getter", code },
+      locator
+    );
   } else {
     delete next.getter;
   }
   if (typeof memberData.setterCode === "string") {
-    next.setter = compileNSSetter2(memberData.setterCode, {
-      project: schema.project,
-      members: schema.members,
-      classes: schema.classes,
-      enums: schema.enums,
-      interfaces: schema.interfaces,
-      thisClass,
-      valueTypeInfo: returnTypeInfo,
-      implicitMemberAccess: true,
-      staticMember: memberData.isStatic === true
-    });
+    const setterCode = memberData.setterCode;
+    next.setter = compileNeoScriptBodyOrThrow(
+      () => compileNSSetter2(setterCode, {
+        project: schema.project,
+        members: schema.members,
+        classes: schema.classes,
+        enums: schema.enums,
+        interfaces: schema.interfaces,
+        thisClass,
+        valueTypeInfo: returnTypeInfo,
+        implicitMemberAccess: true,
+        staticMember: memberData.isStatic === true
+      }),
+      { ...bodyIdentity, unit: "setter", code: setterCode },
+      locator
+    );
   } else {
     delete next.setter;
   }
   return next;
 }
-function compileNSFunctionChange(schema, memberData) {
+function compileNSFunctionChange(schema, memberData, locator) {
   const next = { ...memberData };
   if (typeof memberData.code !== "string") {
     delete next.action;
     return next;
   }
+  const code = memberData.code;
   const contract = resolveNSFunctionContract(memberData, schema.members);
-  next.action = compileNSFunction2(memberData.code, {
-    project: schema.project,
-    members: schema.members,
-    classes: schema.classes,
-    enums: schema.enums,
-    interfaces: schema.interfaces,
-    thisClass: containingClass(schema, memberData.id),
-    returnTypeInfo: contract.returnTypeInfo,
-    argumentTypes: contract.argumentTypes,
-    deferred: contract.deferred,
-    functionName: String(memberData.name ?? memberData.id),
-    implicitMemberAccess: true,
-    staticMember: memberData.isStatic === true
-  });
+  const thisClass = containingClass(schema, memberData.id);
+  next.action = compileNeoScriptBodyOrThrow(
+    () => compileNSFunction2(code, {
+      project: schema.project,
+      members: schema.members,
+      classes: schema.classes,
+      enums: schema.enums,
+      interfaces: schema.interfaces,
+      thisClass,
+      returnTypeInfo: contract.returnTypeInfo,
+      argumentTypes: contract.argumentTypes,
+      deferred: contract.deferred,
+      functionName: String(memberData.name ?? memberData.id),
+      implicitMemberAccess: true,
+      staticMember: memberData.isStatic === true
+    }),
+    {
+      recordKind: "member",
+      recordId: String(memberData.id),
+      ownerName: bodyOwnerName(thisClass),
+      memberName: String(memberData.name ?? memberData.id),
+      unit: "function",
+      code
+    },
+    locator
+  );
   return next;
 }
 function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options = {}) {
   const completeSweep = options.completeSweep ?? true;
+  const locator = options.bodySourceLocator ?? createNeoScriptBodySourceLocator(workspace, status);
   const changesById = new Map(
     status.changes.filter((change) => change.recordKind === "member").map((change) => [change.recordId, change])
   );
@@ -80577,10 +81034,10 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
       return member;
     }
     if (member.kind === 10) {
-      return compileNSPropertyChange(schema, member);
+      return compileNSPropertyChange(schema, member, locator);
     }
     if (member.kind === 23) {
-      return compileNSFunctionChange(schema, member);
+      return compileNSFunctionChange(schema, member, locator);
     }
     return member;
   });
@@ -80919,21 +81376,33 @@ function resolveNSFunctionContract(member, members) {
   }
   return { returnTypeInfo, argumentTypes, deferred };
 }
-function compileMigrationAction(schema, migrationData) {
+function compileMigrationAction(schema, migrationData, locator) {
   const targetClassId = migrationData.targetClassId;
   const thisClass = typeof targetClassId === "string" ? schema.classes.find(
     (schemaClass2) => schemaClass2.id === targetClassId
   ) ?? null : null;
-  return compileNSAction2(String(migrationData.code), {
-    project: schema.project,
-    members: schema.members,
-    classes: schema.classes,
-    enums: schema.enums,
-    interfaces: schema.interfaces,
-    thisClass,
-    dialogueContext: null,
-    migrationContext: true
-  });
+  const code = String(migrationData.code);
+  return compileNeoScriptBodyOrThrow(
+    () => compileNSAction2(code, {
+      project: schema.project,
+      members: schema.members,
+      classes: schema.classes,
+      enums: schema.enums,
+      interfaces: schema.interfaces,
+      thisClass,
+      dialogueContext: null,
+      migrationContext: true
+    }),
+    {
+      recordKind: "migration",
+      recordId: String(migrationData.id),
+      ownerName: bodyOwnerName(thisClass),
+      memberName: String(migrationData.name ?? migrationData.id),
+      unit: "migration",
+      code
+    },
+    locator
+  );
 }
 var compileNSAction2, compileNSFunction2, compileNSGetter2, compileNSSetter2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PROJECT_TRANSACTION_POLL_DELAYS_MS;
 var init_push = __esm({
@@ -80962,6 +81431,7 @@ var init_push = __esm({
     init_project_manifest();
     init_merge();
     init_push_change_intent();
+    init_push_body_diagnostics();
     ({ compileNSAction: compileNSAction2, compileNSFunction: compileNSFunction2, compileNSGetter: compileNSGetter2, compileNSSetter: compileNSSetter2 } = compiler_adapter_exports);
     ProjectTransactionInterruptedError = class extends Error {
       constructor(transactionId) {
@@ -81000,7 +81470,7 @@ __export(dev_exports, {
   runDev: () => runDev
 });
 import { watch } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 import { ConvexClient } from "convex/browser";
 function isSchemaSignal(value) {
@@ -81110,7 +81580,7 @@ async function runDev(workspace, options) {
   };
   for (const dir of ["Classes", "Enums"]) {
     try {
-      watch(join17(workspace.root, dir), { persistent: true }, onFileChange);
+      watch(join18(workspace.root, dir), { persistent: true }, onFileChange);
     } catch {
     }
   }
@@ -81165,12 +81635,12 @@ __export(resolve_exports, {
   runResolve: () => runResolve,
   workspaceFilePath: () => workspaceFilePath
 });
-import { readFileSync as readFileSync14, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join18 } from "node:path";
+import { readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join19 } from "node:path";
 function runResolve(workspace, side) {
   let resolvedFiles = 0;
   for (const filePath of listProjectSourceFilesV4(workspace.root)) {
-    const source = readFileSync14(filePath, "utf8");
+    const source = readFileSync15(filePath, "utf8");
     if (detectConflictMarkers(source) === null) continue;
     const resolved = resolveMarkers(source, side);
     writeFileSync12(filePath, resolved, "utf8");
@@ -81181,12 +81651,12 @@ function runResolve(workspace, side) {
     const binary = state.projectBinary;
     const conflict2 = binary?.conflict;
     if (binary === void 0 || conflict2 === void 0) continue;
-    const destination = join18(workspace.root, binary.path);
+    const destination = join19(workspace.root, binary.path);
     if (side === "theirs") {
       if (conflict2.remoteSha256 !== null && conflict2.artifactPath !== void 0) {
         writeVerifiedBinaryDownloadV4(
           destination,
-          readFileSync14(join18(workspace.root, conflict2.artifactPath)),
+          readFileSync15(join19(workspace.root, conflict2.artifactPath)),
           conflict2.remoteSha256
         );
         binary.sha256 = conflict2.remoteSha256;
@@ -81196,7 +81666,7 @@ function runResolve(workspace, side) {
       }
     }
     if (conflict2.artifactPath !== void 0) {
-      rmSync7(join18(workspace.root, conflict2.artifactPath), { force: true });
+      rmSync7(join19(workspace.root, conflict2.artifactPath), { force: true });
     }
     delete binary.conflict;
     resolvedBinaries += 1;
@@ -81249,7 +81719,7 @@ function resolveMarkers(source, side) {
   return output.join("\n");
 }
 function workspaceFilePath(workspace, file) {
-  return join18(workspace.root, file);
+  return join19(workspace.root, file);
 }
 var init_resolve = __esm({
   "src/commands/resolve.ts"() {