@neocompose/cli 0.17.0 → 0.19.0

package/dist/neo.mjs

@@ -1502,7 +1502,7 @@ function vectorTypes() {
     members: structuredLeafFieldProperties(name)
   }));
 }
-var NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_TYPES, NEOSCRIPT_OPERATORS, STRING_TYPE, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, IMAGE_REF_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
+var NEOSCRIPT_KEYWORDS, NEOSCRIPT_INFERRED_LOCAL_KEYWORD, NEOSCRIPT_CONSTRUCTOR_KEYWORD, NEOSCRIPT_PRIMITIVE_TYPES, NEOSCRIPT_BUILTIN_TYPES, NEOSCRIPT_OPERATORS, NEOSCRIPT_STATEMENT_SNIPPETS, STRING_TYPE, INT_TYPE, FLOAT_TYPE, BOOL_TYPE, IMAGE_REF_TYPE, FLOAT_OPTIONAL_TYPE, NEOSCRIPT_STRUCTURED_LEAF_FIELDS, NEOSCRIPT_IMAGE_REGISTRY_TYPE, NEOSCRIPT_AUDIO_CLIP_REGISTRY_TYPE, NEOSCRIPT_PENDING_SYMBOL_ID_PREFIX, REGISTRY_ENTRY_TYPES, NEOSCRIPT_GLOBALS, NEOSCRIPT_BUILTIN_TYPE_SYMBOLS;
 var init_language_spec = __esm({
   "../packages/neoscript-language/src/language-spec.ts"() {
     "use strict";
@@ -1513,6 +1513,16 @@ var init_language_spec = __esm({
       "enum",
       "if",
       "else",
+      "try",
+      "catch",
+      "for",
+      "foreach",
+      "in",
+      "break",
+      "continue",
+      "switch",
+      "case",
+      "default",
       "extends",
       "interface",
       "native",
@@ -1595,6 +1605,58 @@ var init_language_spec = __esm({
       "<",
       ">"
     ];
+    NEOSCRIPT_STATEMENT_SNIPPETS = [
+      {
+        label: "if",
+        insertText: "if (${1:condition}) {\n	${0}\n}",
+        detail: "Conditional statement"
+      },
+      {
+        label: "try / catch",
+        insertText: "try {\n	${1}\n}\ncatch (string ${2:message}) {\n	${0}\n}",
+        detail: "Handle a string error"
+      },
+      {
+        label: "for",
+        insertText: "for (${1:int} ${2:i} = ${3:0}; ${2:i} < ${4:count}; ${2:i}++) {\n	${0}\n}",
+        detail: "Counted loop"
+      },
+      {
+        label: "foreach",
+        insertText: "foreach (var ${1:item} in ${2:collection}) {\n	${0}\n}",
+        detail: "Collection loop"
+      },
+      {
+        label: "switch",
+        insertText: "switch (${1:value}) {\n	case ${2:constant}:\n		${3}\n		break;\n	default:\n		${0}\n		break;\n}",
+        detail: "Scalar or enum switch statement"
+      },
+      {
+        label: "break",
+        insertText: "break;",
+        detail: "Exit the nearest loop or switch"
+      },
+      {
+        label: "continue",
+        insertText: "continue;",
+        detail: "Advance the nearest loop"
+      },
+      {
+        label: "if / else",
+        insertText: "if (${1:condition}) {\n	${2}\n} else {\n	${0}\n}",
+        detail: "Conditional statement with fallback"
+      },
+      {
+        label: "return",
+        insertText: "return ${0:value};",
+        detail: "Return from the current script"
+      },
+      {
+        label: "throw",
+        insertText: 'throw "${0:message}";',
+        detail: "Stop execution with an error"
+      }
+    ];
     STRING_TYPE = { kind: "primitive", name: "string" };
     INT_TYPE = { kind: "primitive", name: "int" };
     FLOAT_TYPE = { kind: "primitive", name: "float" };
@@ -2287,7 +2349,29 @@ function complete(snapshot, position) {
   const tokens = significantTokensBefore(snapshot.lexed.tokens, word.start);
   const tail = tokens[tokens.length - 1];
   let candidates;
-  if (tail && (tail.kind === "punctuation" && tail.text === "." || tail.kind === "operator" && tail.text === "?.")) {
+  const catchFilterCandidates = catchFilterCompletionItems(
+    snapshot,
+    word.start,
+    word
+  );
+  const catchClauseCandidates = catchClauseCompletionItems(
+    snapshot,
+    word.start,
+    word
+  );
+  const switchCaseCandidates = switchCaseCompletionItems(
+    snapshot,
+    word.start,
+    prefix,
+    word
+  );
+  if (catchFilterCandidates) {
+    candidates = catchFilterCandidates;
+  } else if (catchClauseCandidates) {
+    candidates = catchClauseCandidates;
+  } else if (switchCaseCandidates) {
+    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);
@@ -2503,13 +2587,28 @@ function semanticTokens(snapshot) {
     }
     if (token.kind !== "identifier") continue;
     if (snapshot.parsed.locals.some(
-      (local) => local.inferred && local.contextualKeywordRange?.start.line === token.range.start.line && local.contextualKeywordRange.start.character === token.range.start.character
+      (local) => local.contextualKeywordRange?.start.line === token.range.start.line && local.contextualKeywordRange.start.character === token.range.start.character
     ) || snapshot.parsed.calls.some(
       (call) => call.kind === "constructor" && call.contextualKeywordRange?.start.line === token.range.start.line && call.contextualKeywordRange.start.character === token.range.start.character
     )) {
       result.push({ range: token.range, type: "keyword", modifiers: [] });
       continue;
     }
+    const declaredLocal = snapshot.parsed.locals.find(
+      (local) => local.nameRange.start.line === token.range.start.line && local.nameRange.start.character === token.range.start.character
+    );
+    if (declaredLocal) {
+      const symbol2 = localSymbol(declaredLocal, snapshot);
+      result.push({
+        range: token.range,
+        type: semanticSymbolKind(symbol2),
+        modifiers: [
+          "declaration",
+          ...symbol2.writable === false ? ["readonly"] : []
+        ]
+      });
+      continue;
+    }
     const reference2 = snapshot.parsed.references.find(
       (candidate) => candidate.start === token.start
     );
@@ -2572,6 +2671,19 @@ function isValidRenameIdentifier(name) {
 }
 function topLevelCompletionItems(snapshot, offset, word) {
   const items = [];
+  if (insideCatchBody(snapshot, offset)) {
+    items.push(
+      completion(
+        "throw;",
+        "snippet",
+        "throw;",
+        "Rethrow the current catch message",
+        word,
+        snapshot,
+        "snippet"
+      )
+    );
+  }
   for (const keyword of NEOSCRIPT_KEYWORDS) {
     items.push(
       completion(
@@ -2584,6 +2696,19 @@ function topLevelCompletionItems(snapshot, offset, word) {
       )
     );
   }
+  for (const snippet of NEOSCRIPT_STATEMENT_SNIPPETS) {
+    items.push(
+      completion(
+        snippet.label,
+        "snippet",
+        snippet.insertText,
+        snippet.detail,
+        word,
+        snapshot,
+        "snippet"
+      )
+    );
+  }
   items.push(
     completion(
       NEOSCRIPT_INFERRED_LOCAL_KEYWORD,
@@ -2638,6 +2763,135 @@ function topLevelCompletionItems(snapshot, offset, word) {
   }
   return items;
 }
+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)) {
+    return null;
+  }
+  return [
+    completion(
+      "when",
+      "snippet",
+      "when (${1:condition})",
+      "Filter this catch clause",
+      word,
+      snapshot,
+      "snippet"
+    )
+  ];
+}
+function catchClauseCompletionItems(snapshot, offset, word) {
+  if (!catchClauseCanFollow(snapshot, offset)) return null;
+  return [
+    completion(
+      "catch",
+      "snippet",
+      "catch (string ${1:message}) {\n	${0}\n}",
+      "Handle another string error",
+      word,
+      snapshot,
+      "snippet"
+    )
+  ];
+}
+function catchClauseCanFollow(snapshot, offset) {
+  const tokens = significantTokensBefore(snapshot.lexed.tokens, offset);
+  const closeIndex = tokens.length - 1;
+  const close = tokens[closeIndex];
+  if (close?.kind !== "punctuation" || close.text !== "}") return false;
+  const closedCatch = catchEndingAt(snapshot, close.start);
+  if (closedCatch && closedCatch.contextualKeywordRange === void 0) {
+    return false;
+  }
+  return closesTryOrCatchChain(snapshot, tokens, closeIndex);
+}
+function closesTryOrCatchChain(snapshot, tokens, closeIndex) {
+  const close = tokens[closeIndex];
+  if (close?.kind !== "punctuation" || close.text !== "}") return false;
+  const closedCatch = catchEndingAt(snapshot, close.start);
+  if (closedCatch) {
+    const catchKeywordStart = closedCatch.catchKeywordStart;
+    if (catchKeywordStart === void 0) return false;
+    const catchIndex = tokens.findIndex(
+      (token) => token.start === catchKeywordStart
+    );
+    if (catchIndex <= 0) return false;
+    const precedingClose = tokens[catchIndex - 1];
+    if (precedingClose?.kind !== "punctuation" || precedingClose.text !== "}") {
+      return false;
+    }
+    return closesTryOrCatchChain(snapshot, tokens, catchIndex - 1);
+  }
+  const openIndex = matchingOpenBraceIndex(tokens, closeIndex);
+  if (openIndex === null) return false;
+  const keyword = tokens[openIndex - 1];
+  return keyword?.kind === "keyword" && keyword.text === "try";
+}
+function catchEndingAt(snapshot, closeStart) {
+  return snapshot.parsed.locals.find(
+    (local) => local.catchParameter && local.scopeEnd === closeStart
+  );
+}
+function matchingOpenBraceIndex(tokens, closeIndex) {
+  let depth = 0;
+  for (let index = closeIndex; index >= 0; index--) {
+    const token = tokens[index];
+    if (token?.kind !== "punctuation") continue;
+    if (token.text === "}") depth++;
+    if (token.text !== "{") continue;
+    depth--;
+    if (depth === 0) return index;
+  }
+  return null;
+}
+function insideCatchBody(snapshot, offset) {
+  let clause;
+  for (const local of snapshot.parsed.locals) {
+    if (!local.catchParameter || local.catchBodyStart === void 0 || local.catchBodyStart > offset || offset > local.scopeEnd) {
+      continue;
+    }
+    if (clause?.catchBodyStart === void 0 || local.catchBodyStart > clause.catchBodyStart) {
+      clause = local;
+    }
+  }
+  if (clause?.catchBodyStart === void 0) return false;
+  return !insideLambdaBlock(
+    snapshot.lexed.tokens,
+    clause.catchBodyStart,
+    offset
+  );
+}
+function insideLambdaBlock(tokens, catchBodyStart, offset) {
+  const significant = tokens.filter(
+    (token) => token.kind !== "comment" && token.kind !== "eof"
+  );
+  for (let index = 0; index < significant.length; index++) {
+    const arrow = significant[index];
+    if (arrow?.kind !== "operator" || arrow.text !== "=>" || arrow.start < catchBodyStart || arrow.start >= offset) {
+      continue;
+    }
+    const open = significant[index + 1];
+    if (open?.kind !== "punctuation" || open.text !== "{") continue;
+    const closeIndex = matchingCloseBraceIndex(significant, index + 1);
+    const close = closeIndex === null ? void 0 : significant[closeIndex];
+    if (open.end <= offset && (close === void 0 || offset <= close.start)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchingCloseBraceIndex(tokens, openIndex) {
+  let depth = 0;
+  for (let index = openIndex; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token?.kind !== "punctuation") continue;
+    if (token.text === "{") depth++;
+    if (token.text !== "}") continue;
+    depth--;
+    if (depth === 0) return index;
+  }
+  return null;
+}
 function typeCompletionItems(snapshot, word) {
   const items = NEOSCRIPT_PRIMITIVE_TYPES.map(
     (name) => completion(name, "keyword", name, "Primitive type", word, snapshot)
@@ -2753,9 +3007,62 @@ function resolveReference(snapshot, reference2) {
   const dotIndex = tokenIndex - 1;
   const chainTokens = expressionTokensBefore(tokens, dotIndex);
   const receiver = resolveChain(snapshot, chainTokens, reference2.start);
-  if (!receiver) return null;
+  if (!receiver) {
+    return resolveContextualSwitchEnumReference(snapshot, reference2);
+  }
   return resolveMember(snapshot, receiver, reference2.name);
 }
+function switchCaseCompletionItems(snapshot, offset, prefix, word) {
+  const context = switchCaseEnumContext(snapshot, offset);
+  if (!context) return null;
+  const preceding = snapshot.source.text[word.start - 1];
+  const authoredDot = context.label.expressionTokens.some(
+    (token) => token.kind === "punctuation" && token.text === "."
+  );
+  if (prefix.length > 0 && preceding !== "." && !authoredDot) return null;
+  const needsContextualDot = !authoredDot && preceding !== ".";
+  return context.type.members.filter((member) => member.kind === "enumMember").map((member) => {
+    const item = symbolCompletion(member, word, snapshot);
+    if (!needsContextualDot) return item;
+    const insertText = `.${member.name}`;
+    return {
+      ...item,
+      label: insertText,
+      insertText,
+      textEdit: {
+        range: snapshot.source.range(word.start, word.end),
+        newText: insertText
+      }
+    };
+  });
+}
+function resolveContextualSwitchEnumReference(snapshot, reference2) {
+  const context = switchCaseEnumContext(snapshot, reference2.start);
+  if (!context) return null;
+  const symbol = context.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) {
+      for (const label of section.labels) {
+        if (label.kind !== "case") continue;
+        if (offset < label.start || offset > label.end) continue;
+        const selectorType = inferExpressionType(
+          statement.selectorTokens,
+          snapshot,
+          statement.start
+        );
+        if (selectorType.kind !== "named") return null;
+        const type = snapshot.project.typeById.get(selectorType.typeId);
+        return type?.kind === "enum" ? { type, label } : null;
+      }
+    }
+  }
+  return null;
+}
 function resolveChain(snapshot, tokens, offset) {
   if (tokens.length === 0) return null;
   const constructorType = tokens[0]?.kind === "identifier" && tokens[0].text === NEOSCRIPT_CONSTRUCTOR_KEYWORD && tokens[1]?.kind === "identifier" ? snapshot.project.typeByName.get(tokens[1].text) : void 0;
@@ -3058,11 +3365,17 @@ function resolveDeclaredType(local, snapshot) {
 function inferLocalType(local, snapshot) {
   const tokens = local.initializerTokens ?? [];
   if (tokens.length === 0) return UNKNOWN_TYPE;
-  return inferExpressionType(
+  const inferred = inferExpressionType(
     tokens,
     snapshot,
     tokens[0]?.start ?? snapshot.source.offsetAt(local.nameRange.end)
   );
+  if (!local.collectionIteration) return inferred;
+  if (inferred.kind === "dictionary") return inferred.valueType;
+  if (inferred.kind === "list" || inferred.kind === "set") {
+    return inferred.elementType;
+  }
+  return UNKNOWN_TYPE;
 }
 function inferExpressionType(rawTokens, snapshot, offset) {
   const tokens = unwrapExpressionTokens(rawTokens);
@@ -3467,7 +3780,8 @@ function localSymbol(local, snapshot) {
       name: local.name,
       kind: local.lambdaParameter ? "parameter" : "local",
       type: local.lambdaParameter ? inferLambdaParameterType(local, snapshot) : resolveDeclaredType(local, snapshot),
-      location: { uri: snapshot.uri, range: local.nameRange }
+      location: { uri: snapshot.uri, range: local.nameRange },
+      ...local.collectionIteration || local.catchParameter ? { writable: false } : {}
     },
     local.scopeStart,
     local.scopeEnd
@@ -4217,14 +4531,20 @@ function parseNeoScript(lexed, kind) {
   const locals = [];
   const references = [];
   const calls = [];
+  const switches = [];
   for (const executable of executableRegions) {
     const executablePairs = pairBrackets(executable);
-    const regionLocals = parseLocals(
+    const regionSwitches = parseSwitchStatements(
       executable,
       executablePairs,
       lexed,
       diagnostics
     );
+    const regionLocals = applySwitchSectionScopes(
+      parseLocals(executable, executablePairs, lexed, diagnostics),
+      regionSwitches,
+      lexed
+    );
     const regionCalls = parseCalls(executable, executablePairs, lexed);
     const declarations = new Set(
       regionLocals.map(
@@ -4246,9 +4566,10 @@ function parseNeoScript(lexed, kind) {
       ...parseReferences(executable, declarations, contextualKeywords)
     );
     calls.push(...regionCalls);
+    switches.push(...regionSwitches);
     validateTerminatedStatements(executable, diagnostics);
   }
-  return { units, locals, references, calls, diagnostics };
+  return { units, locals, references, calls, switches, diagnostics };
 }
 function parseUnits(tokens, pairs, kind, lexed) {
   if (kind !== "property") {
@@ -4413,6 +4734,158 @@ function pairBrackets(tokens) {
   }
   return pairs;
 }
+function parseSwitchStatements(tokens, pairs, lexed, diagnostics) {
+  const switches = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const keyword = tokens[index];
+    const openParen = tokens[index + 1];
+    if (keyword?.kind !== "keyword" || keyword.text !== "switch") continue;
+    if (!openParen || openParen.kind !== "punctuation" || openParen.text !== "(") {
+      continue;
+    }
+    const closeParenIndex = pairs.get(index + 1);
+    if (closeParenIndex === void 0) continue;
+    const openBraceIndex = closeParenIndex + 1;
+    const openBrace = tokens[openBraceIndex];
+    if (!openBrace || openBrace.kind !== "punctuation" || openBrace.text !== "{") {
+      continue;
+    }
+    const closeBraceIndex = pairs.get(openBraceIndex);
+    const limit = closeBraceIndex ?? tokens.length;
+    const closeBrace = closeBraceIndex === void 0 ? void 0 : tokens[closeBraceIndex];
+    const selectorTokens = tokens.slice(index + 2, closeParenIndex);
+    const selectorStart = selectorTokens[0]?.start ?? openParen.end;
+    const selectorEnd = selectorTokens.at(-1)?.end ?? selectorStart;
+    const sections = [];
+    let cursor = openBraceIndex + 1;
+    while (cursor < limit) {
+      const firstLabelIndex = findNextSwitchLabel(tokens, cursor, limit, pairs);
+      if (firstLabelIndex === null) break;
+      cursor = firstLabelIndex;
+      const labels = [];
+      while (cursor < limit) {
+        const labelKeyword = tokens[cursor];
+        if (labelKeyword?.kind !== "keyword" || labelKeyword.text !== "case" && labelKeyword.text !== "default") {
+          break;
+        }
+        const nextLabelIndex = findNextSwitchLabel(
+          tokens,
+          cursor + 1,
+          limit,
+          pairs
+        );
+        const labelLimit = nextLabelIndex ?? limit;
+        const colonIndex = findSwitchLabelColon(
+          tokens,
+          cursor + 1,
+          labelLimit,
+          pairs
+        );
+        const colon = colonIndex === null ? void 0 : tokens[colonIndex];
+        const expressionEndIndex = colonIndex ?? labelLimit;
+        const expressionTokens = labelKeyword.text === "case" ? tokens.slice(cursor + 1, expressionEndIndex) : [];
+        if (!colon) {
+          diagnostics.push({
+            range: labelKeyword.range,
+            severity: "error",
+            source: "neoscript",
+            code: "missing-switch-label-colon",
+            message: `The \`${labelKeyword.text}\` label must end with \`:\`.`,
+            suggestions: ["Add `:` after the switch label."]
+          });
+        }
+        const labelEnd = colon?.end ?? tokens[labelLimit]?.start ?? closeBrace?.start ?? lexed.source.text.length;
+        labels.push({
+          kind: labelKeyword.text,
+          keywordRange: labelKeyword.range,
+          expressionTokens,
+          start: labelKeyword.start,
+          end: labelEnd,
+          colonEnd: colon?.end ?? labelEnd
+        });
+        cursor = colonIndex === null ? labelLimit : colonIndex + 1;
+        if (labelKeyword.text === "default") break;
+        const adjacent = tokens[cursor];
+        if (adjacent?.kind !== "keyword" || adjacent.text !== "case") break;
+      }
+      const lastLabel = labels.at(-1);
+      if (!lastLabel) {
+        cursor++;
+        continue;
+      }
+      const nextSectionIndex = findNextSwitchLabel(
+        tokens,
+        cursor,
+        limit,
+        pairs
+      );
+      sections.push({
+        labels,
+        bodyStart: lastLabel.colonEnd,
+        bodyEnd: nextSectionIndex === null ? closeBrace?.start ?? lexed.source.text.length : tokens[nextSectionIndex]?.start ?? lexed.source.text.length
+      });
+      cursor = nextSectionIndex ?? limit;
+    }
+    switches.push({
+      selectorTokens,
+      selectorRange: lexed.source.range(selectorStart, selectorEnd),
+      sections,
+      start: keyword.start,
+      end: closeBrace?.end ?? lexed.source.text.length
+    });
+  }
+  return switches;
+}
+function findNextSwitchLabel(tokens, start, limit, pairs) {
+  let cursor = start;
+  while (cursor < limit) {
+    const token = tokens[cursor];
+    if (!token) return null;
+    if (token.kind === "keyword" && (token.text === "case" || token.text === "default")) {
+      return cursor;
+    }
+    if (token.kind === "punctuation" && (token.text === "(" || token.text === "[" || token.text === "{")) {
+      const close = pairs.get(cursor);
+      if (close !== void 0 && close < limit) {
+        cursor = close + 1;
+        continue;
+      }
+    }
+    cursor++;
+  }
+  return null;
+}
+function findSwitchLabelColon(tokens, start, limit, pairs) {
+  let cursor = start;
+  while (cursor < limit) {
+    const token = tokens[cursor];
+    if (!token) return null;
+    if (token.kind === "punctuation" && token.text === ":") return cursor;
+    if (token.kind === "punctuation" && (token.text === "(" || token.text === "[" || token.text === "{")) {
+      const close = pairs.get(cursor);
+      if (close !== void 0 && close < limit) {
+        cursor = close + 1;
+        continue;
+      }
+    }
+    cursor++;
+  }
+  return null;
+}
+function applySwitchSectionScopes(locals, switches, lexed) {
+  return locals.map((local) => {
+    const declaration = lexed.source.offsetAt(local.nameRange.start);
+    let scopeEnd = local.scopeEnd;
+    for (const statement of switches) {
+      for (const section of statement.sections) {
+        if (declaration >= section.bodyStart && declaration < section.bodyEnd) {
+          scopeEnd = Math.min(scopeEnd, section.bodyEnd);
+        }
+      }
+    }
+    return scopeEnd === local.scopeEnd ? local : { ...local, scopeEnd };
+  });
+}
 function validatePropertyUnits(units, diagnostics, lexed) {
   const getters = units.filter((unit) => unit.kind === "getter");
   const setters = units.filter((unit) => unit.kind === "setter");
@@ -4450,6 +4923,18 @@ function duplicateUnitDiagnostic(label, units, diagnostics) {
 function parseLocals(tokens, pairs, lexed, diagnostics) {
   const locals = [];
   for (let index = 0; index < tokens.length; index++) {
+    const caught = tryParseCatchParameter(tokens, index, pairs, lexed);
+    if (caught) {
+      locals.push(caught.local);
+      index = caught.resumeTokenIndex;
+      continue;
+    }
+    const loop = tryParseLoopLocal(tokens, index, pairs, lexed, diagnostics);
+    if (loop) {
+      locals.push(loop.local);
+      index = loop.resumeTokenIndex;
+      continue;
+    }
     const lambda = tryParseLambdaParameters(tokens, index, pairs, lexed);
     if (lambda) {
       locals.push(...lambda.locals);
@@ -4711,13 +5196,17 @@ function validateTerminatedStatements(tokens, diagnostics) {
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
     if (!token || token.kind !== "keyword") continue;
-    if (token.text !== "return" && token.text !== "throw") continue;
+    if (token.text !== "return" && token.text !== "throw" && token.text !== "break" && token.text !== "continue")
+      continue;
     let cursor = index + 1;
     let nested = 0;
     let terminated = false;
     while (cursor < tokens.length) {
       const current = tokens[cursor];
       if (!current) break;
+      if (nested === 0 && current.kind === "keyword" && (current.text === "case" || current.text === "default")) {
+        break;
+      }
       if (current.kind === "punctuation" && ["(", "[", "{"].includes(current.text))
         nested++;
       if (current.kind === "punctuation" && current.text === "}") {
@@ -4778,6 +5267,126 @@ function containingBraceRange(tokens, tokenIndex, documentEnd) {
   }
   return { start, end };
 }
+function tryParseCatchParameter(tokens, start, pairs, lexed) {
+  const keyword = tokens[start];
+  const open = tokens[start + 1];
+  if (keyword?.kind !== "keyword" || keyword.text !== "catch" || open?.kind !== "punctuation" || open.text !== "(") {
+    return null;
+  }
+  const closeIndex = pairs.get(start + 1);
+  if (closeIndex === void 0) return null;
+  const type = tokens[start + 2];
+  const name = tokens[start + 3];
+  if (closeIndex !== start + 4 || type?.kind !== "type" || type.text !== "string" || name?.kind !== "identifier") {
+    return null;
+  }
+  const possibleWhen = tokens[closeIndex + 1];
+  const when = possibleWhen?.kind === "identifier" && possibleWhen.text === "when" ? possibleWhen : void 0;
+  let bodyIndex = closeIndex + 1;
+  if (when) {
+    const filterOpen = tokens[closeIndex + 2];
+    if (filterOpen?.kind === "punctuation" && filterOpen.text === "(") {
+      const filterCloseIndex = pairs.get(closeIndex + 2);
+      bodyIndex = filterCloseIndex === void 0 ? tokens.length : filterCloseIndex + 1;
+    } else {
+      bodyIndex = closeIndex + 2;
+    }
+  }
+  const scopeEnd = loopBodyScopeEnd(
+    tokens,
+    bodyIndex,
+    pairs,
+    lexed.source.text.length
+  );
+  const body = tokens[bodyIndex];
+  const catchBodyStart = body?.kind === "punctuation" && body.text === "{" ? body.end : body?.start;
+  return {
+    local: {
+      name: name.text,
+      nameRange: name.range,
+      typeTokens: [type],
+      inferred: false,
+      ...when ? { contextualKeywordRange: when.range } : {},
+      catchParameter: true,
+      catchKeywordStart: keyword.start,
+      ...catchBodyStart === void 0 ? {} : { catchBodyStart },
+      declarationRange: lexed.source.range(type.start, name.end),
+      scopeStart: name.start,
+      scopeEnd,
+      lambdaParameter: false
+    },
+    resumeTokenIndex: closeIndex
+  };
+}
+function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
+  const keyword = tokens[start];
+  if (!keyword || keyword.kind !== "keyword" || keyword.text !== "for" && keyword.text !== "foreach") {
+    return null;
+  }
+  const open = tokens[start + 1];
+  if (!open || open.kind !== "punctuation" || open.text !== "(") return null;
+  const closeIndex = pairs.get(start + 1);
+  if (closeIndex === void 0) return null;
+  const scopeEnd = loopBodyScopeEnd(
+    tokens,
+    closeIndex + 1,
+    pairs,
+    lexed.source.text.length
+  );
+  if (keyword.text === "for") {
+    const declaration = tryParseVariableDeclaration(tokens, start + 2, lexed);
+    if (!declaration || declaration.endTokenIndex >= closeIndex) return null;
+    if (declaration.missingInitializer) {
+      diagnostics.push({
+        range: declaration.local.nameRange,
+        severity: "error",
+        source: "neoscript",
+        code: "missing-var-initializer",
+        message: `Cannot infer the type of \`${declaration.local.name}\` without an initializer; use \`var ${declaration.local.name} = ...;\` or an explicit type.`
+      });
+    }
+    return {
+      local: { ...declaration.local, scopeEnd },
+      resumeTokenIndex: declaration.endTokenIndex
+    };
+  }
+  const header = tokens.slice(start + 2, closeIndex);
+  const inOffset = header.findIndex(
+    (token) => token.kind === "keyword" && token.text === "in"
+  );
+  if (inOffset < 2) return null;
+  const inIndex = start + 2 + inOffset;
+  const name = tokens[inIndex - 1];
+  const first = tokens[start + 2];
+  if (!name || name.kind !== "identifier" || !first) return null;
+  const inferred = first.kind === "identifier" && first.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
+  return {
+    local: {
+      name: name.text,
+      nameRange: name.range,
+      typeTokens: inferred ? [] : tokens.slice(start + 2, inIndex - 1),
+      inferred,
+      ...inferred ? { contextualKeywordRange: first.range } : {},
+      initializerTokens: tokens.slice(inIndex + 1, closeIndex),
+      collectionIteration: true,
+      declarationRange: lexed.source.range(first.start, name.end),
+      scopeStart: tokens[closeIndex]?.end ?? name.end,
+      scopeEnd,
+      lambdaParameter: false
+    },
+    resumeTokenIndex: inIndex - 1
+  };
+}
+function loopBodyScopeEnd(tokens, bodyStart, pairs, documentEnd) {
+  const first = tokens[bodyStart];
+  if (!first) return documentEnd;
+  if (first.kind === "punctuation" && first.text === "{") {
+    const closeIndex = pairs.get(bodyStart);
+    return closeIndex === void 0 ? documentEnd : tokens[closeIndex]?.start ?? documentEnd;
+  }
+  const endIndex = statementEndTokenIndex(tokens, bodyStart);
+  return tokens[endIndex]?.end ?? documentEnd;
+}
 var OPEN_TO_CLOSE, CLOSE_TO_OPEN;
 var init_parser = __esm({
   "../packages/neoscript-language/src/parser.ts"() {
@@ -5285,6 +5894,16 @@ var init_strict_lexer = __esm({
       // statement keywords
       "if",
       "else",
+      "for",
+      "foreach",
+      "in",
+      "break",
+      "continue",
+      "switch",
+      "case",
+      "default",
+      "try",
+      "catch",
       "abstract",
       "async",
       "class",
@@ -5436,12 +6055,34 @@ var init_strict_parser = __esm({
         if (t.kind === "keyword" && t.text === "if") {
           return this.parseIf();
         }
+        if (t.kind === "keyword" && t.text === "try") {
+          return this.parseTry();
+        }
+        if (t.kind === "keyword" && t.text === "for") {
+          return this.parseFor();
+        }
+        if (t.kind === "keyword" && t.text === "foreach") {
+          return this.parseForEach();
+        }
+        if (t.kind === "keyword" && t.text === "switch") {
+          return this.parseSwitch();
+        }
         if (t.kind === "keyword" && t.text === "return") {
           return this.parseReturn();
         }
         if (t.kind === "keyword" && t.text === "throw") {
           return this.parseThrow();
         }
+        if (t.kind === "keyword" && t.text === "break") {
+          this.next();
+          this.expect("punct", ";");
+          return { kind: "break", pos: t.pos };
+        }
+        if (t.kind === "keyword" && t.text === "continue") {
+          this.next();
+          this.expect("punct", ";");
+          return { kind: "continue", pos: t.pos };
+        }
         if (this.looksLikeVarDecl()) {
           return this.parseVarDecl();
         }
@@ -5505,6 +6146,226 @@ var init_strict_parser = __esm({
         const body = this.parseStatementBody();
         return { cond, body, pos };
       }
+      parseFor() {
+        const token = this.expect("keyword", "for");
+        this.expect("punct", "(");
+        if (!this.looksLikeVarDecl()) {
+          throw new CompileError(
+            "NeoScript for loops require one initialized local declaration.",
+            this.peek().pos
+          );
+        }
+        const initializer = this.parseVarDecl(false);
+        this.expectSingleForClause(";");
+        if (this.peek().kind === "punct" && this.peek().text === ";") {
+          throw new CompileError(
+            "NeoScript for loops require a condition.",
+            this.peek().pos
+          );
+        }
+        const condition = this.parseExpr();
+        this.expectSingleForClause(";");
+        if (this.peek().kind === "punct" && this.peek().text === ")") {
+          throw new CompileError(
+            "NeoScript for loops require one iterator.",
+            this.peek().pos
+          );
+        }
+        const iterator = this.parseForIterator();
+        this.expectSingleForClause(")");
+        return {
+          kind: "for",
+          initializer,
+          condition,
+          iterator,
+          body: this.parseStatementBody(),
+          pos: token.pos
+        };
+      }
+      parseForEach() {
+        const token = this.expect("keyword", "foreach");
+        this.expect("punct", "(");
+        const inferred = this.peek().kind === "ident" && this.peek().text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
+        let type;
+        if (inferred) {
+          this.next();
+          type = null;
+        } else {
+          type = this.parseType();
+        }
+        const name = this.expect("ident");
+        this.expect("keyword", "in");
+        const collection = this.parseExpr();
+        this.expect("punct", ")");
+        return {
+          kind: "forEach",
+          type,
+          name: name.text,
+          collection,
+          body: this.parseStatementBody(),
+          pos: token.pos
+        };
+      }
+      parseTry() {
+        const token = this.expect("keyword", "try");
+        const body = this.parseBlock();
+        const catches = [];
+        while (this.peek().kind === "keyword" && this.peek().text === "catch") {
+          catches.push(this.parseCatchClause());
+        }
+        if (catches.length === 0) {
+          throw new CompileError(
+            "`try` must be followed by at least one `catch` clause.",
+            token.pos
+          );
+        }
+        return { kind: "try", body, catches, pos: token.pos };
+      }
+      parseCatchClause() {
+        const token = this.expect("keyword", "catch");
+        const open = this.peek();
+        if (open.kind !== "punct" || open.text !== "(") {
+          throw new CompileError(
+            "NeoScript catch parameters must have the form `catch (string name)`.",
+            open.pos
+          );
+        }
+        this.next();
+        const type = this.peek();
+        const name = this.peek(1);
+        const close = this.peek(2);
+        if (type.kind !== "keyword" || type.text !== "string" || name.kind !== "ident" || close.kind !== "punct" || close.text !== ")") {
+          throw new CompileError(
+            "NeoScript catch parameters must have the form `catch (string name)`.",
+            type.pos
+          );
+        }
+        this.next();
+        this.next();
+        this.next();
+        let filter = null;
+        if (this.peek().kind === "ident" && this.peek().text === "when") {
+          this.next();
+          this.expect("punct", "(");
+          filter = this.parseExpr();
+          this.expect("punct", ")");
+        }
+        return {
+          name: name.text,
+          filter,
+          body: this.parseBlock(),
+          pos: token.pos
+        };
+      }
+      parseSwitch() {
+        const token = this.expect("keyword", "switch");
+        this.expect("punct", "(");
+        const selector = this.parseExpr();
+        this.expect("punct", ")");
+        this.expect("punct", "{");
+        const sections = [];
+        while (!(this.peek().kind === "punct" && this.peek().text === "}")) {
+          const sectionStart = this.peek();
+          if (sectionStart.kind === "eof") {
+            throw new CompileError(
+              "Unexpected end of input \u2014 missing `}`?",
+              sectionStart.pos
+            );
+          }
+          if (sectionStart.kind !== "keyword" || sectionStart.text !== "case" && sectionStart.text !== "default") {
+            throw new CompileError(
+              "Expected `case` or `default` in switch statement.",
+              sectionStart.pos
+            );
+          }
+          if (sectionStart.text === "default") {
+            this.next();
+            this.expect("punct", ":");
+            sections.push({
+              labels: [{ kind: "default", pos: sectionStart.pos }],
+              body: this.parseSwitchSectionBody(),
+              pos: sectionStart.pos
+            });
+            continue;
+          }
+          const labels = [];
+          while (this.peek().kind === "keyword" && this.peek().text === "case") {
+            const caseToken = this.next();
+            labels.push({
+              kind: "case",
+              expression: this.parseExpr(),
+              pos: caseToken.pos
+            });
+            this.expect("punct", ":");
+          }
+          sections.push({
+            labels,
+            body: this.parseSwitchSectionBody(),
+            pos: sectionStart.pos
+          });
+        }
+        this.expect("punct", "}");
+        return { kind: "switch", selector, sections, pos: token.pos };
+      }
+      parseSwitchSectionBody() {
+        const body = [];
+        while (true) {
+          const token = this.peek();
+          if (token.kind === "punct" && token.text === "}") return body;
+          if (token.kind === "keyword" && (token.text === "case" || token.text === "default")) {
+            return body;
+          }
+          body.push(this.parseStatement());
+        }
+      }
+      parseForIterator() {
+        const start = this.peek();
+        if (isIncrementOp(start)) {
+          const op = this.next();
+          return {
+            kind: "assign",
+            target: this.parseExpr(),
+            op: op.text,
+            value: null,
+            pos: start.pos
+          };
+        }
+        const target = this.parseExpr();
+        const operator = this.peek();
+        if (isIncrementOp(operator)) {
+          this.next();
+          return {
+            kind: "assign",
+            target,
+            op: operator.text,
+            value: null,
+            pos: start.pos
+          };
+        }
+        if (!isAssignmentOp(operator)) {
+          throw new CompileError(
+            "NeoScript for loop iterator must be an assignment, increment, or decrement.",
+            operator.pos
+          );
+        }
+        this.next();
+        return {
+          kind: "assign",
+          target,
+          op: operator.text,
+          value: this.parseExpr(),
+          pos: start.pos
+        };
+      }
+      expectSingleForClause(terminator) {
+        if (this.peek().kind === "punct" && this.peek().text === ",") {
+          throw new CompileError(
+            "NeoScript for loops support one initializer and one iterator.",
+            this.peek().pos
+          );
+        }
+        this.expect("punct", terminator);
+      }
       parseStatementBody() {
         if (this.peek().kind === "punct" && this.peek().text === "{") {
           return this.parseBlock();
@@ -5528,11 +6389,11 @@ var init_strict_parser = __esm({
       }
       parseThrow() {
         const thrTok = this.expect("keyword", "throw");
-        const expr = this.parseExpr();
+        const expr = this.peek().kind === "punct" && this.peek().text === ";" ? null : this.parseExpr();
         this.expect("punct", ";");
         return { kind: "throw", expr, pos: thrTok.pos };
       }
-      parseVarDecl() {
+      parseVarDecl(terminated = true) {
         const startPos = this.peek().pos;
         const inferred = this.peek().kind === "ident" && this.peek().text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
         let type;
@@ -5550,7 +6411,7 @@ var init_strict_parser = __esm({
           );
         }
         const init = this.parseExpr();
-        this.expect("punct", ";");
+        if (terminated) this.expect("punct", ";");
         return {
           kind: "varDecl",
           type,
@@ -5925,7 +6786,7 @@ var init_strict_parser = __esm({
         }
         while (true) {
           let name = null;
-          if (this.peek().kind === "ident" && this.peek(1).kind === "punct" && this.peek(1).text === ":") {
+          if ((this.peek().kind === "ident" || this.peek().kind === "keyword" && this.peek().text === "default") && this.peek(1).kind === "punct" && this.peek(1).text === ":") {
             name = this.next().text;
             this.next();
           }
@@ -6369,7 +7230,7 @@ var NEOSCRIPT_COMPILER_REVISION;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
-    NEOSCRIPT_COMPILER_REVISION = 3;
+    NEOSCRIPT_COMPILER_REVISION = 6;
   }
 });
 
@@ -6555,16 +7416,176 @@ function callMatchesDeclaredOverloadNames(declared, expression) {
     ) === callKey
   );
 }
-function scopeVariable(name, value, sourceType, writability, ownership, writeRoot) {
+function scopeVariable(name, value, sourceType, writability, ownership, writeRoot, readonlyBinding) {
   return {
     name,
     type: sourceType ?? fromWireType(value.typeInfo),
     variableId: value.id,
     ...writability ? { writability } : {},
     ...ownership ? { ownership } : {},
-    ...writeRoot ? { writeRoot } : {}
+    ...writeRoot ? { writeRoot } : {},
+    ...readonlyBinding ? { readonlyBinding } : {}
   };
 }
+function invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, outerScope, statements) {
+  for (const rootName of collectAssignedPathRoots(statements)) {
+    const outerEntry = outerScope.lookup(rootName);
+    if (outerEntry) {
+      loopEntryScope.hideInheritedNarrowing(outerEntry);
+    }
+  }
+}
+function collectAssignedPathRoots(statements, roots = /* @__PURE__ */ new Set()) {
+  for (const statement of statements) {
+    if (statement.kind === "assign") {
+      const assignedPath = canonicalPath(statement.target);
+      if (assignedPath) roots.add(pathRoot(assignedPath));
+      collectAssignedPathRootsInExpression(statement.target, roots);
+      if (statement.value)
+        collectAssignedPathRootsInExpression(statement.value, roots);
+      continue;
+    }
+    if (statement.kind === "varDecl") {
+      collectAssignedPathRootsInExpression(statement.init, roots);
+      continue;
+    }
+    if (statement.kind === "if") {
+      for (const branch of statement.branches) {
+        collectAssignedPathRootsInExpression(branch.cond, roots);
+        collectAssignedPathRoots(branch.body, roots);
+      }
+      if (statement.elseBody) {
+        collectAssignedPathRoots(statement.elseBody, roots);
+      }
+      continue;
+    }
+    if (statement.kind === "try") {
+      collectAssignedPathRoots(statement.body, roots);
+      for (const clause of statement.catches) {
+        if (clause.filter) {
+          collectAssignedPathRootsInExpression(clause.filter, roots);
+        }
+        collectAssignedPathRoots(clause.body, roots);
+      }
+      continue;
+    }
+    if (statement.kind === "for") {
+      collectAssignedPathRootsInExpression(statement.initializer.init, roots);
+      collectAssignedPathRootsInExpression(statement.condition, roots);
+      collectAssignedPathRoots([statement.iterator], roots);
+      collectAssignedPathRoots(statement.body, roots);
+      continue;
+    }
+    if (statement.kind === "forEach") {
+      collectAssignedPathRootsInExpression(statement.collection, roots);
+      collectAssignedPathRoots(statement.body, roots);
+      continue;
+    }
+    if (statement.kind === "switch") {
+      collectAssignedPathRootsInExpression(statement.selector, roots);
+      for (const section of statement.sections) {
+        for (const label of section.labels) {
+          if (label.kind === "case") {
+            collectAssignedPathRootsInExpression(label.expression, roots);
+          }
+        }
+        collectAssignedPathRoots(section.body, roots);
+      }
+      continue;
+    }
+    if (statement.kind === "return" || statement.kind === "throw") {
+      if (statement.expr)
+        collectAssignedPathRootsInExpression(statement.expr, roots);
+      continue;
+    }
+    if (statement.kind === "exprStmt") {
+      collectAssignedPathRootsInExpression(statement.expr, roots);
+    }
+  }
+  return roots;
+}
+function collectAssignedPathRootsInExpression(expression, roots) {
+  switch (expression.kind) {
+    case "litInterp":
+      for (const part of expression.parts) {
+        if (part.kind === "expr") {
+          collectAssignedPathRootsInExpression(part.expr, roots);
+        }
+      }
+      return;
+    case "litList":
+      for (const element of expression.elements) {
+        collectAssignedPathRootsInExpression(element, roots);
+      }
+      return;
+    case "litDict":
+      for (const entry of expression.entries) {
+        collectAssignedPathRootsInExpression(entry.key, roots);
+        collectAssignedPathRootsInExpression(entry.value, roots);
+      }
+      return;
+    case "member":
+      collectAssignedPathRootsInExpression(expression.receiver, roots);
+      return;
+    case "index":
+      collectAssignedPathRootsInExpression(expression.receiver, roots);
+      collectAssignedPathRootsInExpression(expression.index, roots);
+      return;
+    case "call":
+      collectAssignedPathRootsInExpression(expression.callee, roots);
+      for (const argument2 of expression.args) {
+        collectAssignedPathRootsInExpression(argument2, roots);
+      }
+      return;
+    case "new":
+      for (const argument2 of expression.args) {
+        collectAssignedPathRootsInExpression(argument2, roots);
+      }
+      for (const initializer of expression.initializer ?? []) {
+        collectAssignedPathRootsInExpression(initializer.value, roots);
+      }
+      return;
+    case "annotated":
+      for (const annotation2 of expression.annotations) {
+        for (const argument2 of annotation2.args) {
+          collectAssignedPathRootsInExpression(argument2, roots);
+        }
+      }
+      collectAssignedPathRootsInExpression(expression.expression, roots);
+      return;
+    case "binary":
+    case "coalesce":
+      collectAssignedPathRootsInExpression(expression.left, roots);
+      collectAssignedPathRootsInExpression(expression.right, roots);
+      return;
+    case "unary":
+    case "force":
+      collectAssignedPathRootsInExpression(expression.operand, roots);
+      return;
+    case "is":
+      collectAssignedPathRootsInExpression(expression.operand, roots);
+      return;
+    case "lambda":
+      collectAssignedPathRoots(expression.body, roots);
+      return;
+    case "litNull":
+    case "litBool":
+    case "litInt":
+    case "litFloat":
+    case "litString":
+    case "litTripleString":
+    case "contextualEnum":
+    case "ident":
+      return;
+  }
+}
+function mergeBranchInvalidations(parent, branches) {
+  for (const branch of branches) {
+    for (const entry of branch.invalidatedRootEntries()) {
+      if (parent.containsEntry(entry)) parent.invalidate(entry);
+    }
+  }
+}
 function mergeBranchOwnership(parent, branches) {
   if (branches.length === 0) return;
   const changed = /* @__PURE__ */ new Set();
@@ -7094,8 +8115,19 @@ function isAssignmentTarget(expression) {
 }
 function instructionsTerminate(instructions) {
   for (const instruction of instructions) {
-    if (instruction.type === "return" /* Return */ || instruction.type === "throw" /* Throw */)
+    if (instruction.type === "return" /* Return */ || instruction.type === "throw" /* Throw */ || instruction.type === "break" /* Break */ || instruction.type === "continue" /* Continue */)
       return true;
+    if (instruction.type === "try" /* Try */ && instructionsTerminate(instruction.instructions) && instruction.catches.every(
+      (clause) => instructionsTerminate(clause.instructions)
+    )) {
+      return true;
+    }
+    if (instruction.type === "switch" /* Switch */) {
+      if (instruction.defaultInstructions !== void 0 && instruction.defaultInstructions !== null && instruction.sections.every(
+        (section) => instructionsPropagatePastSwitch(section.instructions)
+      ) && instructionsPropagatePastSwitch(instruction.defaultInstructions))
+        return true;
+    }
     if (instruction.type === "if" /* If */) {
       if (!instruction.else) continue;
       if (instruction.branches.every(
@@ -7106,6 +8138,35 @@ function instructionsTerminate(instructions) {
   }
   return false;
 }
+function instructionsPropagatePastSwitch(instructions) {
+  for (const instruction of instructions) {
+    if (instruction.type === "return" /* Return */ || instruction.type === "throw" /* Throw */ || instruction.type === "continue" /* Continue */) {
+      return true;
+    }
+    if (instruction.type === "break" /* Break */) return false;
+    if (instruction.type === "try" /* Try */ && instructionsPropagatePastSwitch(instruction.instructions) && instruction.catches.every(
+      (clause) => instructionsPropagatePastSwitch(clause.instructions)
+    )) {
+      return true;
+    }
+    if (instruction.type === "switch" /* Switch */) {
+      if (instruction.defaultInstructions !== void 0 && instruction.defaultInstructions !== null && instruction.sections.every(
+        (section) => instructionsPropagatePastSwitch(section.instructions)
+      ) && instructionsPropagatePastSwitch(instruction.defaultInstructions)) {
+        return true;
+      }
+    }
+    if (instruction.type === "if" /* If */) {
+      if (!instruction.else) continue;
+      if (instruction.branches.every(
+        (branch) => instructionsPropagatePastSwitch(branch.instructions)
+      ) && instructionsPropagatePastSwitch(instruction.else)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function collectReturns(statements) {
   const result = [];
   for (const statement of statements) {
@@ -7116,6 +8177,18 @@ function collectReturns(statements) {
       if (statement.elseBody)
         result.push(...collectReturns(statement.elseBody));
     }
+    if (statement.kind === "for" || statement.kind === "forEach") {
+      result.push(...collectReturns(statement.body));
+    }
+    if (statement.kind === "switch") {
+      for (const section of statement.sections)
+        result.push(...collectReturns(section.body));
+    }
+    if (statement.kind === "try") {
+      result.push(...collectReturns(statement.body));
+      for (const clause of statement.catches)
+        result.push(...collectReturns(clause.body));
+    }
   }
   return result;
 }
@@ -7152,6 +8225,13 @@ function canonicalDecimal(raw, pos) {
   const zero = whole === "0" && /^0*$/.test(fractionalRaw);
   return `${negative && !zero ? "-" : ""}${whole}${fractionalRaw ? `.${fractionalRaw}` : ""}`;
 }
+function isSwitchSelectorType(type, project) {
+  return isPrimitive(type, "int") || isPrimitive(type, "string") || isPrimitive(type, "bool") || isNamedEnum(type, project);
+}
+function switchValueKey(value) {
+  const enumId = value.typeInfo.type === 8 /* Enum */ ? value.typeInfo.enumId : null;
+  return JSON.stringify([value.typeInfo.type, enumId, value.value]);
+}
 var CONSTRUCTING_FUNCTION_KINDS, WRITE_TARGET_DESCRIPTIONS, FALLTHROUGH_LABELS, Scope, StrictNeoScriptResolver, SPRITE_DERIVED_MEMBERS;
 var init_strict_resolver = __esm({
   "../packages/neoscript-language/src/strict-resolver.ts"() {
@@ -7189,6 +8269,7 @@ var init_strict_resolver = __esm({
       parent;
       entries = /* @__PURE__ */ new Map();
       invalidatedRoots = /* @__PURE__ */ new Set();
+      hiddenNarrowingRoots = /* @__PURE__ */ new Set();
       narrowedPaths = /* @__PURE__ */ new Map();
       ownershipOverrides = /* @__PURE__ */ new Map();
       define(entry) {
@@ -7197,10 +8278,19 @@ var init_strict_resolver = __esm({
       lookup(name) {
         return this.entries.get(name) ?? this.parent?.lookup(name) ?? null;
       }
+      containsEntry(entry) {
+        for (const candidate of this.entries.values()) {
+          if (candidate === entry) return true;
+        }
+        return this.parent?.containsEntry(entry) ?? false;
+      }
       /**
        * P43 §7.1. The write-target root recorded for the binding a pointer names.
        * Innermost scope wins, so a shadowing declaration governs its own block.
        */
+      parentScope() {
+        return this.parent;
+      }
       writeRootOf(variableId) {
         for (const entry of this.entries.values()) {
           if (entry.variableId === variableId) return entry.writeRoot;
@@ -7216,15 +8306,34 @@ var init_strict_resolver = __esm({
       ownershipChanges() {
         return this.ownershipOverrides;
       }
+      invalidatedRootEntries() {
+        return this.invalidatedRoots;
+      }
+      effectiveNarrowedPaths() {
+        const effective = this.parent ? new Map(this.parent.effectiveNarrowedPaths()) : /* @__PURE__ */ new Map();
+        for (const invalidated of this.invalidatedRoots) {
+          for (const [path, narrowed] of effective) {
+            if (narrowed.rootEntry === invalidated) effective.delete(path);
+          }
+        }
+        for (const [path, narrowed] of this.narrowedPaths) {
+          effective.set(path, narrowed);
+        }
+        return effective;
+      }
       lookupNarrowedType(path, rootEntry) {
-        if (this.invalidatedRoots.has(rootEntry)) return null;
         const local = this.narrowedPaths.get(path);
         if (local?.rootEntry === rootEntry) return local.type;
+        if (this.hiddenNarrowingRoots.has(rootEntry)) return null;
+        if (this.invalidatedRoots.has(rootEntry)) return null;
         return this.parent?.lookupNarrowedType(path, rootEntry) ?? null;
       }
       narrow(path, rootEntry, type) {
         this.narrowedPaths.set(path, { type, rootEntry });
       }
+      hideInheritedNarrowing(rootEntry) {
+        this.hiddenNarrowingRoots.add(rootEntry);
+      }
       invalidate(rootEntry) {
         this.invalidatedRoots.add(rootEntry);
         for (const [path, narrowed] of this.narrowedPaths) {
@@ -7280,7 +8389,15 @@ var init_strict_resolver = __esm({
       argumentVariables;
       callSiteCounter = 0;
       lambdaDepth = 0;
+      unreachableControlEffectDepth = 0;
+      catchBindingCounter = 0;
+      catchContexts = [];
       expectedReturnStack = [];
+      controlContexts = [];
+      loopFlowContexts = [];
+      switchFlowContexts = [];
+      tryMutationContexts = [];
+      functionControlBoundaries = [];
       compile(body) {
         const scope = new Scope(null);
         scope.define(
@@ -7424,9 +8541,36 @@ var init_strict_resolver = __esm({
         }
       }
       resolveStatements(statements, scope) {
-        return statements.map(
-          (statement) => this.resolveStatement(statement, scope)
-        );
+        const instructions = [];
+        let reachable = true;
+        let unreachableScope = null;
+        for (const statement of statements) {
+          const statementScope = reachable ? scope : unreachableScope ??= new Scope(scope);
+          const instruction = this.resolveSequencedStatement(
+            statement,
+            statementScope,
+            reachable
+          );
+          instructions.push(instruction);
+          if (reachable && instructionsTerminate([instruction])) reachable = false;
+          if (reachable) {
+            for (const context of this.tryMutationContexts) {
+              context.effects.push(
+                this.captureScopeEffects(statementScope, context.boundary)
+              );
+            }
+          }
+        }
+        return instructions;
+      }
+      resolveSequencedStatement(statement, scope, reachable) {
+        if (reachable) return this.resolveStatement(statement, scope);
+        this.unreachableControlEffectDepth++;
+        try {
+          return this.resolveStatement(statement, scope);
+        } finally {
+          this.unreachableControlEffectDepth--;
+        }
       }
       resolveStatement(statement, scope) {
         switch (statement.kind) {
@@ -7437,6 +8581,7 @@ var init_strict_resolver = __esm({
                 statement.pos
               );
             }
+            this.assertLocalNameAvailable(statement.name, scope, statement.pos);
             const inferred = statement.type === null;
             if (inferred && (statement.init.kind === "litList" || statement.init.kind === "litDict") && (statement.init.kind === "litList" ? statement.init.elements.length === 0 : statement.init.entries.length === 0)) {
               throw new CompileError(
@@ -7519,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
@@ -7536,6 +8682,332 @@ var init_strict_resolver = __esm({
               else: otherwise
             };
           }
+          case "try":
+            return this.resolveTryStatement(statement, scope);
+          case "switch": {
+            const selector = this.resolveExpression(statement.selector, scope);
+            if (!isSwitchSelectorType(selector.type, this.project)) {
+              throw new CompileError(
+                `switch selector must be int, string, bool, enum, or an optional form; got ${this.describe(selector.type)}`,
+                statement.selector.pos
+              );
+            }
+            const switchFlow = {
+              boundary: scope,
+              breakEffects: []
+            };
+            const sections = [];
+            let defaultInstructions;
+            const normalizedLabels = /* @__PURE__ */ new Set();
+            this.controlContexts.push("switch");
+            this.switchFlowContexts.push(switchFlow);
+            try {
+              for (const section of statement.sections) {
+                const defaultLabels = section.labels.filter(
+                  (label) => label.kind === "default"
+                );
+                if (defaultLabels.length > 0 && section.labels.length !== 1) {
+                  throw new CompileError(
+                    "`default` must be a switch section of its own.",
+                    defaultLabels[0]?.pos ?? section.pos
+                  );
+                }
+                if (defaultLabels.length > 0 && defaultInstructions !== void 0) {
+                  throw new CompileError(
+                    "A switch statement can contain only one default section.",
+                    defaultLabels[0]?.pos ?? section.pos
+                  );
+                }
+                const labels = section.labels.flatMap((label) => {
+                  if (label.kind === "default") return [];
+                  const normalized = this.resolveSwitchCaseLabel(
+                    label.expression,
+                    selector.type,
+                    scope
+                  );
+                  const key = switchValueKey(normalized);
+                  if (normalizedLabels.has(key)) {
+                    throw new CompileError(
+                      "Duplicate switch case label.",
+                      label.pos
+                    );
+                  }
+                  normalizedLabels.add(key);
+                  return [normalized];
+                });
+                const sectionScope = new Scope(scope);
+                const instructions = this.resolveStatements(
+                  section.body,
+                  sectionScope
+                );
+                if (!instructionsTerminate(instructions)) {
+                  throw new CompileError(
+                    "Switch section can reach its end; add break, return, or throw.",
+                    section.pos
+                  );
+                }
+                if (defaultLabels.length > 0) {
+                  defaultInstructions = instructions;
+                } else {
+                  sections.push({ labels, instructions });
+                }
+              }
+            } finally {
+              this.switchFlowContexts.pop();
+              this.controlContexts.pop();
+            }
+            const exitNarrowings = switchFlow.breakEffects.map(
+              (effect) => effect.narrowedPaths
+            );
+            const exitEffects = [...switchFlow.breakEffects];
+            if (defaultInstructions === void 0) {
+              exitEffects.push({
+                invalidatedRoots: /* @__PURE__ */ new Set(),
+                ownershipOverrides: /* @__PURE__ */ new Map(),
+                narrowedPaths: scope.effectiveNarrowedPaths()
+              });
+              exitNarrowings.push(scope.effectiveNarrowedPaths());
+            }
+            this.applyMergedScopeEffects(scope, exitEffects);
+            this.mergeLoopNarrowings(scope, exitNarrowings);
+            return {
+              type: "switch" /* Switch */,
+              selector: selector.pointer,
+              selectorTypeInfo: toWireType(selector.type, this.project),
+              sections,
+              ...defaultInstructions !== void 0 ? { defaultInstructions } : {}
+            };
+          }
+          case "for": {
+            const loopScope = new Scope(scope);
+            const initializer = this.resolveStatement(
+              statement.initializer,
+              loopScope
+            );
+            if (initializer.type !== "variable" /* Variable */) {
+              throw new Error(
+                "NeoScript for-loop initializer did not resolve to a variable instruction."
+              );
+            }
+            const loopEntryScope = new Scope(loopScope);
+            invalidateLoopEntryNarrowingsAssignedBy(loopEntryScope, scope, [
+              ...statement.body,
+              statement.iterator
+            ]);
+            const condition = this.toBool(
+              this.resolveExpression(statement.condition, loopEntryScope),
+              statement.condition.pos
+            );
+            const iterationScope = new Scope(loopEntryScope);
+            this.applyFactsToScope(loopEntryScope, iterationScope, [
+              ...factsWhenTrue(statement.condition)
+            ]);
+            const bodyScope = new Scope(iterationScope);
+            const loopFlow = {
+              boundary: iterationScope,
+              continueEffects: [],
+              breakEffects: []
+            };
+            this.controlContexts.push("loop");
+            this.loopFlowContexts.push(loopFlow);
+            let instructions;
+            try {
+              instructions = this.resolveStatements(statement.body, bodyScope);
+            } finally {
+              this.loopFlowContexts.pop();
+              this.controlContexts.pop();
+            }
+            const iteratorEffects = [...loopFlow.continueEffects];
+            if (!instructionsTerminate(instructions)) {
+              iteratorEffects.push(
+                this.captureScopeEffects(bodyScope, iterationScope)
+              );
+            }
+            this.applyMergedScopeEffects(iterationScope, iteratorEffects);
+            const iteratorScope = new Scope(iterationScope);
+            const iterator = this.resolveAssignment(
+              statement.iterator,
+              iteratorScope
+            );
+            const initialConditionFalseScope = new Scope(loopScope);
+            this.applyFactsToScope(loopScope, initialConditionFalseScope, [
+              ...factsWhenFalse(statement.condition)
+            ]);
+            const effectScopes = [loopScope];
+            const normalExitScopes = [initialConditionFalseScope];
+            if (iteratorEffects.length > 0) {
+              const postIterationScope = new Scope(loopScope);
+              this.applyMergedScopeEffects(postIterationScope, [
+                this.captureScopeEffects(iteratorScope, loopScope)
+              ]);
+              effectScopes.push(postIterationScope);
+              const subsequentConditionFalseScope = new Scope(postIterationScope);
+              this.applyFactsToScope(
+                postIterationScope,
+                subsequentConditionFalseScope,
+                [...factsWhenFalse(statement.condition)]
+              );
+              normalExitScopes.push(subsequentConditionFalseScope);
+            }
+            this.mergeLoopEffects(scope, effectScopes, loopFlow.breakEffects);
+            this.mergeLoopNarrowings(scope, [
+              ...normalExitScopes.map((exit) => exit.effectiveNarrowedPaths()),
+              ...loopFlow.breakEffects.map((exit) => exit.narrowedPaths)
+            ]);
+            return {
+              type: "for" /* For */,
+              initializer: initializer.variable,
+              condition: pointerToBooleanExpression(condition.pointer),
+              iterator,
+              instructions
+            };
+          }
+          case "forEach": {
+            const collection = this.resolveExpression(statement.collection, scope);
+            if (isNullable(collection.type)) {
+              throw new CompileError(
+                `foreach requires a non-optional collection, got ${this.describe(collection.type)}`,
+                statement.collection.pos
+              );
+            }
+            const parts = collectionPartsFor(collection);
+            if (!parts) {
+              throw new CompileError(
+                `foreach requires a List, Dictionary, Set, lookup, or derived collection, got ${this.describe(collection.type)}`,
+                statement.collection.pos
+              );
+            }
+            this.assertLocalNameAvailable(statement.name, scope, statement.pos);
+            const inferredType = parts.valueType;
+            const bindingType = statement.type ? this.resolveType(statement.type) : inferredType;
+            if (statement.type) {
+              this.requireAssignable(
+                inferredType,
+                bindingType,
+                statement.pos,
+                "foreach iterator"
+              );
+            }
+            const binding = variable(
+              statement.name,
+              bindingType,
+              void 0,
+              this.project
+            );
+            const bindingWritability = collection.entryWritability ?? collection.writability ?? "runtime" /* Runtime */;
+            const loopScope = new Scope(scope);
+            loopScope.define(
+              scopeVariable(
+                statement.name,
+                binding,
+                bindingType,
+                bindingWritability,
+                bindingWritability,
+                collection.writeRoot ?? this.writeThroughRoot(collection.pointer, scope),
+                "foreach"
+              )
+            );
+            const iterationScope = new Scope(loopScope);
+            invalidateLoopEntryNarrowingsAssignedBy(
+              iterationScope,
+              scope,
+              statement.body
+            );
+            const bodyScope = new Scope(iterationScope);
+            const loopFlow = {
+              boundary: iterationScope,
+              continueEffects: [],
+              breakEffects: []
+            };
+            this.controlContexts.push("loop");
+            this.loopFlowContexts.push(loopFlow);
+            let instructions;
+            try {
+              instructions = this.resolveStatements(statement.body, bodyScope);
+            } finally {
+              this.loopFlowContexts.pop();
+              this.controlContexts.pop();
+            }
+            const nextItemEffects = [...loopFlow.continueEffects];
+            if (!instructionsTerminate(instructions)) {
+              nextItemEffects.push(
+                this.captureScopeEffects(bodyScope, iterationScope)
+              );
+            }
+            const nextItemScope = new Scope(loopScope);
+            this.applyMergedScopeEffects(nextItemScope, nextItemEffects);
+            this.mergeLoopEffects(
+              scope,
+              [loopScope, nextItemScope],
+              [...loopFlow.breakEffects]
+            );
+            this.mergeLoopNarrowings(scope, [
+              loopScope.effectiveNarrowedPaths(),
+              nextItemScope.effectiveNarrowedPaths(),
+              ...loopFlow.breakEffects.map((exit) => exit.narrowedPaths)
+            ]);
+            return {
+              type: "forEach" /* ForEach */,
+              binding: {
+                id: binding.id,
+                typeInfo: binding.typeInfo,
+                readonly: true,
+                writability: bindingWritability
+              },
+              collectionPointer: collection.pointer,
+              collectionTypeInfo: collection.wireType ?? toWireType(collection.type, this.project),
+              instructions
+            };
+          }
+          case "break": {
+            const functionBoundary = this.functionControlBoundaries.at(-1);
+            const controlDepth = functionBoundary?.controlDepth ?? 0;
+            if (this.controlContexts.length <= controlDepth) {
+              throw new CompileError(
+                "`break;` is only valid inside a loop or switch.",
+                statement.pos
+              );
+            }
+            const control = this.controlContexts.at(-1);
+            if (control === "switch") {
+              const switchFlow = this.switchFlowContexts.at(-1);
+              if (!switchFlow) {
+                throw new Error("NeoScript switch flow stack is unbalanced.");
+              }
+              if (this.unreachableControlEffectDepth === 0) {
+                switchFlow.breakEffects.push(
+                  this.captureScopeEffects(scope, switchFlow.boundary)
+                );
+              }
+            } else {
+              const loopFlow = this.loopFlowContexts.at(-1);
+              if (!loopFlow) {
+                throw new Error("NeoScript loop flow stack is unbalanced.");
+              }
+              if (this.unreachableControlEffectDepth === 0) {
+                loopFlow.breakEffects.push(
+                  this.captureScopeEffects(scope, loopFlow.boundary)
+                );
+              }
+            }
+            return { type: "break" /* Break */ };
+          }
+          case "continue": {
+            const functionBoundary = this.functionControlBoundaries.at(-1);
+            const loopFlow = this.loopFlowContexts.length > (functionBoundary?.loopFlowDepth ?? 0) ? this.loopFlowContexts.at(-1) : void 0;
+            if (loopFlow === void 0) {
+              throw new CompileError(
+                "`continue;` is only valid inside a loop.",
+                statement.pos
+              );
+            }
+            if (this.unreachableControlEffectDepth === 0) {
+              loopFlow.continueEffects.push(
+                this.captureScopeEffects(scope, loopFlow.boundary)
+              );
+            }
+            return { type: "continue" /* Continue */ };
+          }
           case "return": {
             const expected = this.currentExpectedReturn();
             if (statement.expr === null) {
@@ -7580,6 +9052,21 @@ var init_strict_resolver = __esm({
             };
           }
           case "throw": {
+            if (statement.expr === null) {
+              const functionBoundary = this.functionControlBoundaries.at(-1);
+              const catchDepth = functionBoundary?.catchDepth ?? 0;
+              const rethrowPointer = this.catchContexts.length > catchDepth ? this.catchContexts.at(-1) : void 0;
+              if (!rethrowPointer) {
+                throw new CompileError(
+                  "`throw;` is only valid inside a catch body.",
+                  statement.pos
+                );
+              }
+              return {
+                type: "throw" /* Throw */,
+                pointer: rethrowPointer
+              };
+            }
             const message = this.resolveExpression(statement.expr, scope);
             if (!isPrimitive(message.type, "string") || isNullable(message.type)) {
               throw new CompileError(
@@ -7618,6 +9105,271 @@ var init_strict_resolver = __esm({
           }
         }
       }
+      resolveTryStatement(statement, scope) {
+        const tryScope = new Scope(scope);
+        const mutations = {
+          boundary: scope,
+          effects: []
+        };
+        this.tryMutationContexts.push(mutations);
+        let instructions;
+        try {
+          instructions = this.resolveStatements(statement.body, tryScope);
+        } finally {
+          this.tryMutationContexts.pop();
+        }
+        const normalEffects = [];
+        const normalNarrowings = [];
+        if (!instructionsTerminate(instructions)) {
+          const exitEffect = this.captureScopeEffects(tryScope, scope);
+          normalEffects.push(exitEffect);
+          normalNarrowings.push(exitEffect.narrowedPaths);
+        }
+        const baseline = {
+          invalidatedRoots: /* @__PURE__ */ new Set(),
+          ownershipOverrides: /* @__PURE__ */ new Map(),
+          narrowedPaths: scope.effectiveNarrowedPaths()
+        };
+        const incomingCatchEffects = [baseline, ...mutations.effects];
+        const catches = statement.catches.map((clause, index) => {
+          const resolved = this.resolveCatchClause(
+            clause,
+            scope,
+            incomingCatchEffects,
+            index,
+            statement.catches.length
+          );
+          if (resolved.exitEffect) {
+            normalEffects.push(resolved.exitEffect);
+            normalNarrowings.push(resolved.exitEffect.narrowedPaths);
+          }
+          return resolved.catch;
+        });
+        this.applyMergedScopeEffects(scope, normalEffects);
+        this.mergeLoopNarrowings(scope, normalNarrowings);
+        return {
+          type: "try" /* Try */,
+          instructions,
+          catches
+        };
+      }
+      resolveCatchClause(clause, outerScope, incomingEffects, index, catchCount) {
+        if (clause.filter === null && index !== catchCount - 1) {
+          throw new CompileError(
+            "An unfiltered catch clause must be the final catch clause.",
+            clause.pos
+          );
+        }
+        const catchScope = new Scope(outerScope);
+        this.applyMergedScopeEffects(catchScope, incomingEffects);
+        this.assertLocalNameAvailable(clause.name, catchScope, clause.pos);
+        const catchType = {
+          kind: "primitive",
+          name: "string"
+        };
+        const bindingId = `__catch:${this.catchBindingCounter++}:${clause.name}`;
+        const binding = variable(bindingId, catchType, void 0, this.project);
+        catchScope.define(
+          scopeVariable(
+            clause.name,
+            binding,
+            catchType,
+            "local" /* Local */,
+            "local" /* Local */,
+            void 0,
+            "catch"
+          )
+        );
+        let filter;
+        if (clause.filter) {
+          const condition = this.toBool(
+            this.resolveExpression(clause.filter, catchScope),
+            clause.filter.pos
+          );
+          filter = pointerToBooleanExpression(condition.pointer);
+        }
+        const bodyScope = new Scope(catchScope);
+        if (clause.filter) {
+          this.applyFactsToScope(catchScope, bodyScope, [
+            ...factsWhenTrue(clause.filter)
+          ]);
+        }
+        const catchPointer = {
+          type: "variable" /* Variable */,
+          variableId: bindingId
+        };
+        this.catchContexts.push(catchPointer);
+        let instructions;
+        try {
+          instructions = this.resolveStatements(clause.body, bodyScope);
+        } finally {
+          this.catchContexts.pop();
+        }
+        const exitEffect = instructionsTerminate(instructions) ? null : this.captureScopeEffects(bodyScope, outerScope);
+        return {
+          catch: {
+            binding: {
+              id: bindingId,
+              typeInfo: binding.typeInfo,
+              readonly: true
+            },
+            ...filter ? { filter } : {},
+            instructions
+          },
+          exitEffect
+        };
+      }
+      assertLocalNameAvailable(name, scope, pos) {
+        if (!scope.lookup(name)) return;
+        throw new CompileError(
+          `Cannot declare local '${name}' because that name is already used in an enclosing or current scope.`,
+          pos
+        );
+      }
+      captureScopeEffects(effect, boundary) {
+        const invalidatedRoots = /* @__PURE__ */ new Set();
+        const ownershipOverrides = /* @__PURE__ */ new Map();
+        let current = effect;
+        while (current !== null && current !== boundary) {
+          for (const entry of current.invalidatedRootEntries()) {
+            invalidatedRoots.add(entry);
+          }
+          for (const [entry, ownership] of current.ownershipChanges()) {
+            if (!ownershipOverrides.has(entry)) {
+              ownershipOverrides.set(entry, ownership);
+            }
+          }
+          current = current.parentScope();
+        }
+        return {
+          invalidatedRoots,
+          ownershipOverrides,
+          narrowedPaths: effect.effectiveNarrowedPaths()
+        };
+      }
+      applyMergedScopeEffects(target, effects) {
+        const invalidatedRoots = /* @__PURE__ */ new Set();
+        const changedOwnership = /* @__PURE__ */ new Set();
+        for (const effect of effects) {
+          for (const entry of effect.invalidatedRoots) {
+            if (target.containsEntry(entry)) invalidatedRoots.add(entry);
+          }
+          for (const entry of effect.ownershipOverrides.keys()) {
+            if (target.containsEntry(entry)) changedOwnership.add(entry);
+          }
+        }
+        for (const entry of invalidatedRoots) target.invalidate(entry);
+        for (const entry of changedOwnership) {
+          const original = target.ownership(entry) ?? "runtime" /* Runtime */;
+          const ownerships = effects.map(
+            (effect) => effect.ownershipOverrides.get(entry) ?? original
+          );
+          const first = ownerships[0] ?? original;
+          target.setOwnership(
+            entry,
+            ownerships.every((ownership) => ownership === first) ? first : "runtime" /* Runtime */
+          );
+        }
+      }
+      mergeLoopEffects(parent, effects, capturedEffects = []) {
+        const changedOwnership = /* @__PURE__ */ new Set();
+        const invalidated = /* @__PURE__ */ new Set();
+        for (const effect of effects) {
+          for (const entry of effect.ownershipChanges().keys()) {
+            if (parent.containsEntry(entry)) changedOwnership.add(entry);
+          }
+          for (const entry of effect.invalidatedRootEntries()) {
+            if (parent.containsEntry(entry)) invalidated.add(entry);
+          }
+        }
+        for (const effect of capturedEffects) {
+          for (const entry of effect.ownershipOverrides.keys()) {
+            if (parent.containsEntry(entry)) changedOwnership.add(entry);
+          }
+          for (const entry of effect.invalidatedRoots) {
+            if (parent.containsEntry(entry)) invalidated.add(entry);
+          }
+        }
+        for (const entry of invalidated) parent.invalidate(entry);
+        for (const entry of changedOwnership) {
+          const entryOwnership = parent.ownership(entry) ?? "runtime" /* Runtime */;
+          const ownerships = [
+            entryOwnership,
+            ...effects.map((effect) => effect.ownership(entry) ?? entryOwnership),
+            ...capturedEffects.map(
+              (effect) => effect.ownershipOverrides.get(entry) ?? entryOwnership
+            )
+          ];
+          const first = ownerships[0] ?? "runtime" /* Runtime */;
+          parent.setOwnership(
+            entry,
+            ownerships.every((ownership) => ownership === first) ? first : "runtime" /* Runtime */
+          );
+        }
+      }
+      mergeLoopNarrowings(parent, exitPaths) {
+        if (exitPaths.length === 0) return;
+        const merged = mergeNarrowingMaps(exitPaths);
+        for (const [path, narrowed] of parent.effectiveNarrowedPaths()) {
+          const common = merged.get(path);
+          if (parent.containsEntry(narrowed.rootEntry) && (common?.rootEntry !== narrowed.rootEntry || !typeRefsEqual(common.type, narrowed.type))) {
+            parent.invalidate(narrowed.rootEntry);
+          }
+        }
+        for (const [path, narrowed] of merged) {
+          if (!parent.containsEntry(narrowed.rootEntry)) continue;
+          const rootEntry = parent.lookup(pathRoot(path));
+          if (rootEntry === narrowed.rootEntry) {
+            parent.narrow(path, rootEntry, narrowed.type);
+          }
+        }
+      }
+      resolveSwitchCaseLabel(expression, selectorType, scope) {
+        if (expression.kind === "litNull") {
+          if (!isNullable(selectorType)) {
+            throw new CompileError(
+              `Cannot use null as switch case of required type ${this.describe(selectorType)}`,
+              expression.pos
+            );
+          }
+          return {
+            typeInfo: { type: 0 /* Null */, required: true },
+            value: null
+          };
+        }
+        const expected = { ...selectorType, nullable: false };
+        const integerValue = expression.kind === "litInt" ? expression.value : expression.kind === "unary" && expression.op === "-" && expression.operand.kind === "litInt" ? -expression.operand.value : null;
+        if (integerValue !== null && !Number.isSafeInteger(integerValue)) {
+          throw new CompileError(
+            "Switch integer case labels must be safe integers.",
+            expression.pos
+          );
+        }
+        let resolved;
+        if (integerValue !== null) {
+          resolved = literal({ kind: "primitive", name: "int" }, integerValue);
+        } else if (expression.kind === "litString" || expression.kind === "litBool" || expression.kind === "contextualEnum" || expression.kind === "member" && expression.receiver.kind === "ident") {
+          resolved = this.resolveExpression(expression, scope, expected);
+        } else {
+          throw new CompileError(
+            "Switch case labels must be compile-time int, string, bool, enum, or null constants.",
+            expression.pos
+          );
+        }
+        this.requireAssignable(
+          resolved.type,
+          expected,
+          expression.pos,
+          "switch case"
+        );
+        if (resolved.pointer.type !== "value" /* Value */) {
+          throw new CompileError(
+            "Switch case labels must be compile-time int, string, bool, enum, or null constants.",
+            expression.pos
+          );
+        }
+        return resolved.pointer.value;
+      }
       resolveAssignment(statement, scope) {
         if (!isAssignmentTarget(statement.target)) {
           throw new CompileError(
@@ -7626,8 +9378,21 @@ var init_strict_resolver = __esm({
           );
         }
         const local = statement.target.kind === "ident" ? scope.lookup(statement.target.name) : null;
+        if (local?.readonlyBinding) {
+          const label = local.readonlyBinding === "catch" ? "catch parameter" : "foreach iterator";
+          throw new CompileError(
+            `Cannot assign to ${label} '${local.name}' because it is read-only.`,
+            statement.pos
+          );
+        }
         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(
@@ -7682,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 */,
@@ -7695,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;
@@ -8120,7 +9910,8 @@ var init_strict_resolver = __esm({
               variableId: entry.variableId
             },
             type: scope.lookupNarrowedType(name, entry) ?? entry.type,
-            ...ownership ? { writability: ownership } : {}
+            ...ownership ? { writability: ownership } : {},
+            ...entry.writeRoot ? { writeRoot: entry.writeRoot } : {}
           };
         }
         const global = this.context.project.globals.find(
@@ -8325,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(
@@ -8485,6 +10282,7 @@ var init_strict_resolver = __esm({
             };
           }
           const writability = this.memberWritability(member, receiver);
+          const entryWritability = member.lookup?.multiselect === true ? this.lookupEntryWritability(member, receiver) : void 0;
           const lookupWire = member.lookup?.multiselect === true && memberType2.kind === "set" ? {
             type: 9 /* Lookup */,
             required: !isNullable(memberType2),
@@ -8505,7 +10303,8 @@ var init_strict_resolver = __esm({
             ),
             symbol: member,
             ...writability ? { writability } : {},
-            ...lookupWire ? { wireType: lookupWire } : {}
+            ...lookupWire ? { wireType: lookupWire } : {},
+            ...entryWritability ? { entryWritability } : {}
           };
         }
         throw new CompileError(
@@ -8583,6 +10382,10 @@ var init_strict_resolver = __esm({
         if (member.lookup.multiselect) {
           return member.writability ? toWritability(member.writability) : receiver.writability ?? "save" /* Save */;
         }
+        return this.lookupEntryWritability(member, receiver);
+      }
+      lookupEntryWritability(member, receiver) {
+        if (!member.lookup) return "readOnly" /* ReadOnly */;
         const target = this.project.symbolById.get(
           member.lookup.collectionMemberId
         );
@@ -9380,11 +11183,18 @@ var init_strict_resolver = __esm({
             pos
           );
           const filteredType = receiver.type.kind === "list" || receiver.type.kind === "dictionary" || receiver.type.kind === "set" ? { ...receiver.type, readOnly: true } : receiver.type;
-          return intrinsic(
+          const filtered = intrinsic(
             "where" /* Where */,
             { collectionPointer: receiver.pointer, function: fn },
             filteredType
           );
+          return {
+            ...filtered,
+            ...receiver.writability ? { writability: receiver.writability } : {},
+            ...receiver.wireType ? { wireType: receiver.wireType } : {},
+            writeRoot: receiver.writeRoot ?? this.writeThroughRoot(receiver.pointer, scope),
+            ...receiver.entryWritability ? { entryWritability: receiver.entryWritability } : {}
+          };
         }
         if (name === "First" || name === "FirstOrDefault" || name === "Find") {
           if (args.length > 1) {
@@ -9401,7 +11211,7 @@ var init_strict_resolver = __esm({
             pos
           ) : void 0;
           const result = name === "FirstOrDefault" || name === "Find" ? { ...collection.valueType, nullable: true } : collection.valueType;
-          return intrinsic(
+          const first = intrinsic(
             name === "First" ? "first" /* First */ : "firstOrDefault" /* FirstOrDefault */,
             {
               collectionPointer: receiver.pointer,
@@ -9409,6 +11219,12 @@ var init_strict_resolver = __esm({
             },
             result
           );
+          const entryWritability = receiver.entryWritability ?? receiver.writability ?? "runtime" /* Runtime */;
+          return {
+            ...first,
+            writability: entryWritability,
+            writeRoot: this.expressionWriteRoot(receiver, scope)
+          };
         }
         if (name === "Select") {
           requireArgCount(name, args, 1, pos);
@@ -9416,7 +11232,13 @@ var init_strict_resolver = __esm({
           if (lambda.kind !== "lambda") {
             throw new CompileError("Select requires a lambda argument.", pos);
           }
-          const resultType = this.inferLambdaReturnType(lambda, collection, scope);
+          const inferredReturn = this.inferLambdaReturn(
+            lambda,
+            collection,
+            receiver,
+            scope
+          );
+          const resultType = inferredReturn.type;
           const fn = this.resolveCollectionLambda(
             lambda,
             collection,
@@ -9424,11 +11246,16 @@ var init_strict_resolver = __esm({
             scope,
             pos
           );
-          return intrinsic(
+          const selected2 = intrinsic(
             "select" /* Select */,
             { collectionPointer: receiver.pointer, function: fn },
             { kind: "list", elementType: resultType, readOnly: true }
           );
+          return {
+            ...selected2,
+            entryWritability: inferredReturn.writability,
+            writeRoot: inferredReturn.writeRoot
+          };
         }
         return null;
       }
@@ -9594,6 +11421,7 @@ var init_strict_resolver = __esm({
         const scope = new Scope(outerScope);
         const parameterTypes = collection.kind === "dictionary" ? [collection.keyType, collection.valueType] : [collection.valueType];
         const parameters = ast.params.map((parameter3, index) => {
+          this.assertLocalNameAvailable(parameter3.name, scope, parameter3.pos);
           const inferred = requiredAt(parameterTypes, index);
           const declared = parameter3.type ? this.resolveType(parameter3.type) : inferred;
           if (parameter3.type)
@@ -9615,6 +11443,11 @@ var init_strict_resolver = __esm({
           );
           return item;
         });
+        this.functionControlBoundaries.push({
+          controlDepth: this.controlContexts.length,
+          loopFlowDepth: this.loopFlowContexts.length,
+          catchDepth: this.catchContexts.length
+        });
         this.lambdaDepth++;
         this.expectedReturnStack.push(returnType);
         try {
@@ -9634,31 +11467,42 @@ var init_strict_resolver = __esm({
         } finally {
           this.expectedReturnStack.pop();
           this.lambdaDepth--;
+          this.functionControlBoundaries.pop();
         }
       }
-      inferLambdaReturnType(lambda, collection, outerScope) {
+      inferLambdaReturn(lambda, collection, source, outerScope) {
         const returns = collectReturns(lambda.body);
         if (returns.length === 0) {
           throw new CompileError("Select lambda must return a value.", lambda.pos);
         }
         const scope = new Scope(outerScope);
         const parameterTypes = collection.kind === "dictionary" ? [collection.keyType, collection.valueType] : [collection.valueType];
+        const valueParameterIndex = collection.kind === "dictionary" ? 1 : 0;
+        const sourceWritability = source.entryWritability ?? source.writability ?? "runtime" /* Runtime */;
+        const sourceWriteRoot = this.expressionWriteRoot(source, outerScope);
         lambda.params.forEach((parameter3, index) => {
+          this.assertLocalNameAvailable(parameter3.name, scope, parameter3.pos);
           const type = parameter3.type ? this.resolveType(parameter3.type) : requiredAt(parameterTypes, index);
+          const isValueParameter = index === valueParameterIndex;
           scope.define(
             scopeVariable(
               parameter3.name,
               variable(parameter3.name, type, void 0, this.project),
               type,
-              void 0,
-              "runtime" /* Runtime */
+              isValueParameter ? sourceWritability : "runtime" /* Runtime */,
+              isValueParameter ? sourceWritability : "runtime" /* Runtime */,
+              isValueParameter ? sourceWriteRoot : "local"
             )
           );
         });
         let inferred = null;
+        let inferredWritability = null;
+        let inferredWriteRoot = null;
         for (const returned of returns) {
           if (!returned.expr) continue;
           const current = this.resolveExpression(returned.expr, scope);
+          const currentWritability = current.writability ?? "runtime" /* Runtime */;
+          const currentWriteRoot = this.expressionWriteRoot(current, scope);
           if (!inferred) inferred = current.type;
           else {
             const common = commonNeoScriptAssignableType(
@@ -9674,8 +11518,14 @@ var init_strict_resolver = __esm({
             }
             inferred = common;
           }
+          inferredWritability = inferredWritability === null ? currentWritability : inferredWritability === currentWritability ? inferredWritability : "runtime" /* Runtime */;
+          inferredWriteRoot = inferredWriteRoot === null ? currentWriteRoot : inferredWriteRoot === currentWriteRoot ? inferredWriteRoot : "unknown";
         }
-        return inferred ?? { kind: "primitive", name: "null", nullable: true };
+        return {
+          type: inferred ?? { kind: "primitive", name: "null", nullable: true },
+          writability: inferredWritability ?? "runtime" /* Runtime */,
+          writeRoot: inferredWriteRoot ?? "unknown"
+        };
       }
       resolveFunctionStatement(expression, scope) {
         if (expression.kind !== "call" || expression.callee.kind !== "member")
@@ -10129,6 +11979,14 @@ var init_strict_resolver = __esm({
         }
         return this.writeTargetRoot(pointer, scope);
       }
+      expressionWriteRoot(expression, scope) {
+        if (expression.writeRoot) return expression.writeRoot;
+        if (expression.pointer.type === "value" /* Value */) return "local";
+        if (expression.pointer.type === "function" /* Function */ && CONSTRUCTING_FUNCTION_KINDS.has(expression.pointer.function.type)) {
+          return "local";
+        }
+        return this.writeThroughRoot(expression.pointer, scope);
+      }
       /**
        * P43 §7.1. The write-target root a newly declared local inherits.
        *
@@ -10478,10 +12336,17 @@ function formatNeoScript(text, options = {}) {
   const tabSize = options.tabSize ?? 2;
   const indentUnit = options.insertSpaces === false ? "	" : " ".repeat(tabSize);
   const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const normalizedText = lines.join("\n");
   const syntax = analyzeNeoScriptSyntax(
-    lines.join("\n"),
+    normalizedText,
     options.kind ?? inferDocumentKind(text)
   );
+  const splitCatchText = splitSameLineCatchClauses(
+    normalizedText,
+    syntax.lexed.tokens
+  );
+  if (splitCatchText !== normalizedText)
+    return formatNeoScript(splitCatchText, options);
   const delimiterTokensByLine = /* @__PURE__ */ new Map();
   for (const token of syntax.lexed.tokens) {
     if (token.kind !== "punctuation" || !isDelimiter(token.text)) continue;
@@ -10505,8 +12370,14 @@ function formatNeoScript(text, options = {}) {
       lineTokens,
       firstContentCharacter
     );
-    const lineDepth = Math.max(0, depth - leadingClosers);
-    formatted.push(`${indentUnit.repeat(lineDepth)}${content}`);
+    const contentOffset = syntax.lexed.source.offsetAt({
+      line: lineIndex,
+      character: firstContentCharacter
+    });
+    const sectionDepth = switchSectionIndentDepth(syntax.parsed, contentOffset);
+    const lineDepth = Math.max(0, depth - leadingClosers) + sectionDepth;
+    const normalized = normalizeControlHeaderSpacing(content);
+    formatted.push(`${indentUnit.repeat(lineDepth)}${normalized}`);
     for (const token of lineTokens) {
       depth = isOpeningDelimiter(token.text) ? depth + 1 : Math.max(0, depth - 1);
     }
@@ -10523,6 +12394,53 @@ function formattingEdit(text, options) {
   const source = new SourceText(text);
   return [{ range: source.fullRange(), newText: formatted }];
 }
+function normalizeControlHeaderSpacing(content) {
+  const withKeywordSpace = content.replace(
+    /^(for|foreach|switch|catch)\s*\(/,
+    "$1 ("
+  );
+  const withCatchFilterSpace = withKeywordSpace.replace(
+    /\)\s*when\s*\(/,
+    ") when ("
+  );
+  if (!withCatchFilterSpace.startsWith("foreach ("))
+    return withCatchFilterSpace;
+  return withCatchFilterSpace.replace(/\s+in\s+/, " in ");
+}
+function splitSameLineCatchClauses(text, tokens) {
+  const boundaries = [];
+  for (let index = 1; index < tokens.length; index++) {
+    const catchKeyword = tokens[index];
+    const preceding = tokens[index - 1];
+    if (catchKeyword?.kind !== "keyword" || catchKeyword.text !== "catch" || preceding?.kind !== "punctuation" || preceding.text !== "}" || preceding.range.end.line !== catchKeyword.range.start.line) {
+      continue;
+    }
+    if (!/^\s*$/.test(text.slice(preceding.end, catchKeyword.start))) continue;
+    boundaries.push({ start: preceding.end, end: catchKeyword.start });
+  }
+  if (boundaries.length === 0) return text;
+  let result = "";
+  let cursor = 0;
+  for (const boundary of boundaries) {
+    result += `${text.slice(cursor, boundary.start)}
+`;
+    cursor = boundary.end;
+  }
+  return result + text.slice(cursor);
+}
+function switchSectionIndentDepth(parsed, contentOffset) {
+  let depth = 0;
+  for (const statement of parsed.switches) {
+    for (const section of statement.sections) {
+      const lastLabel = section.labels.at(-1);
+      if (!lastLabel) continue;
+      if (contentOffset > lastLabel.colonEnd && contentOffset < section.bodyEnd) {
+        depth++;
+      }
+    }
+  }
+  return depth;
+}
 function countLeadingClosers(lineTokens, firstContentCharacter) {
   let count = 0;
   let expectedCharacter = firstContentCharacter;
@@ -16028,7 +17946,8 @@ function parseProjectRootInitializer(source) {
       name: name.text,
       type: type.text,
       storage: storage.text,
-      initializer
+      initializer,
+      start: expressionStart.pos
     });
   }
   take("}");
@@ -16398,11 +18317,55 @@ function collectIdentifierReads(expression, names) {
         for (const inner of statement.elseBody ?? [])
           walkStatement(inner, visible);
         return;
+      case "for": {
+        walk(statement.initializer.init, visible);
+        const inner = new Set(visible);
+        inner.delete(statement.initializer.name);
+        walk(statement.condition, inner);
+        walkStatement(statement.iterator, inner);
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, inner);
+        }
+        return;
+      }
+      case "forEach": {
+        walk(statement.collection, visible);
+        const inner = new Set(visible);
+        inner.delete(statement.name);
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, inner);
+        }
+        return;
+      }
+      case "switch":
+        walk(statement.selector, visible);
+        for (const section of statement.sections) {
+          for (const label of section.labels) {
+            if (label.kind === "case") walk(label.expression, visible);
+          }
+          for (const bodyStatement of section.body) {
+            walkStatement(bodyStatement, visible);
+          }
+        }
+        return;
+      case "try":
+        for (const bodyStatement of statement.body) {
+          walkStatement(bodyStatement, visible);
+        }
+        for (const clause of statement.catches) {
+          const catchScope = new Set(visible);
+          catchScope.delete(clause.name);
+          if (clause.filter) walk(clause.filter, catchScope);
+          for (const bodyStatement of clause.body) {
+            walkStatement(bodyStatement, catchScope);
+          }
+        }
+        return;
       case "return":
         if (statement.expr) walk(statement.expr, visible);
         return;
       case "throw":
-        walk(statement.expr, visible);
+        if (statement.expr) walk(statement.expr, visible);
         return;
       case "assign":
         walk(statement.target, visible);
@@ -16411,6 +18374,9 @@ function collectIdentifierReads(expression, names) {
       case "exprStmt":
         walk(statement.expr, visible);
         return;
+      case "break":
+      case "continue":
+        return;
     }
   };
   walk(expression, names);
@@ -16470,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(
@@ -17098,7 +19074,7 @@ function validateStatements(statements, returnType, scope, environment, uri, ran
         range2,
         diagnostics
       );
-    } else if (statement.kind === "throw") {
+    } else if (statement.kind === "throw" && statement.expr) {
       validateExpression(
         statement.expr,
         primitiveType("string"),
@@ -17108,6 +19084,40 @@ function validateStatements(statements, returnType, scope, environment, uri, ran
         range2,
         diagnostics
       );
+    } else if (statement.kind === "try") {
+      validateStatements(
+        statement.body,
+        returnType,
+        new Map(scope),
+        environment,
+        uri,
+        range2,
+        diagnostics
+      );
+      for (const clause of statement.catches) {
+        const catchScope = new Map(scope);
+        catchScope.set(clause.name, primitiveType("string"));
+        if (clause.filter) {
+          validateExpression(
+            clause.filter,
+            primitiveType("bool"),
+            catchScope,
+            environment,
+            uri,
+            range2,
+            diagnostics
+          );
+        }
+        validateStatements(
+          clause.body,
+          returnType,
+          catchScope,
+          environment,
+          uri,
+          range2,
+          diagnostics
+        );
+      }
     } else if (statement.kind === "if") {
       for (const branch of statement.branches) {
         validateExpression(
@@ -17490,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));
@@ -18053,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();
@@ -24705,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") {
@@ -25033,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) => {
@@ -33513,6 +35533,9 @@ function isNSTypeInfoCollectionInternal(value, ancestors) {
   }
   return true;
 }
+function isNSTypeInfoLookup(value) {
+  return isNSTypeInfoLookupInternal(value, /* @__PURE__ */ new Set());
+}
 function isNSTypeInfoLookupInternal(value, ancestors) {
   if (!isNSTypeInfoBase(value)) return false;
   if (value.type !== 9 /* Lookup */) return false;
@@ -33781,6 +35804,20 @@ function isNSFunctionWithReturnType(value) {
   if (!Array.isArray(v.parameters)) return false;
   if (!v.parameters.every(isNSVariable)) return false;
   if (!isNSInstructions(v.instructions)) return false;
+  if ([
+    "for" /* for */,
+    "forEach" /* forEach */,
+    "break" /* break */,
+    "continue" /* continue */
+  ].some((type) => nsInstructionsContainType(v.instructions ?? [], type)) && (v.compilerRevision ?? 1) < 4) {
+    return false;
+  }
+  if (nsInstructionsContainType(v.instructions, "switch" /* switch */) && (v.compilerRevision ?? 1) < 5) {
+    return false;
+  }
+  if (nsInstructionsContainType(v.instructions, "try" /* try */) && (v.compilerRevision ?? 1) < 6) {
+    return false;
+  }
   if (!isNSTypeInfo(v.typeInfo)) return false;
   return true;
 }
@@ -34038,8 +36075,159 @@ function isNSInstructionFunctionCall(value) {
   if (v?.type !== "functionCall" /* functionCall */) return false;
   return isNSPointerCallFunction(v.call);
 }
+function isNSLoopBinding(value) {
+  const binding = value;
+  if (typeof binding !== "object" || binding === null) return false;
+  if (typeof binding.id !== "string" || binding.id.length === 0) return false;
+  if (!isNSTypeInfo(binding.typeInfo)) return false;
+  if (binding.readonly !== true) return false;
+  if (binding.writability === void 0) return true;
+  return Object.values(NSWritability).includes(binding.writability);
+}
+function isNSInstructionFor(value) {
+  const instruction = value;
+  if (instruction?.type !== "for" /* for */) return false;
+  if (!isNSVariable(instruction.initializer)) return false;
+  if (!isNSBooleanExpression(instruction.condition)) return false;
+  if (!isNSInstructionAssign(instruction.iterator)) return false;
+  return isNSInstructions(instruction.instructions);
+}
+function isNSInstructionForEach(value) {
+  const instruction = value;
+  if (instruction?.type !== "forEach" /* forEach */) return false;
+  if (!isNSLoopBinding(instruction.binding)) return false;
+  if (!isNSPointer(instruction.collectionPointer)) return false;
+  if (!isNSTypeInfoCollection(instruction.collectionTypeInfo) && !isNSTypeInfoLookup(instruction.collectionTypeInfo)) {
+    return false;
+  }
+  if (instruction.collectionTypeInfo.required !== true) return false;
+  return isNSInstructions(instruction.instructions);
+}
+function isNSInstructionBreak(value) {
+  const instruction = value;
+  return instruction?.type === "break" /* break */;
+}
+function isNSInstructionContinue(value) {
+  const instruction = value;
+  return instruction?.type === "continue" /* continue */;
+}
+function isNSSwitchSelectorType(value) {
+  if (!isNSTypeInfo(value)) return false;
+  return value.type === 2 /* Int */ || value.type === 3 /* String */ || value.type === 1 /* Bool */ || value.type === 8 /* Enum */;
+}
+function nsSwitchLabelKey(value, selectorTypeInfo) {
+  if (!isNSValue(value)) return null;
+  if (value.typeInfo.required !== true) return null;
+  if (value.typeInfo.type === 0 /* Null */) {
+    return value.value === null && selectorTypeInfo.required === false ? "null" : null;
+  }
+  if (value.typeInfo.type !== selectorTypeInfo.type) return null;
+  switch (value.typeInfo.type) {
+    case 2 /* Int */:
+      return typeof value.value === "number" && Number.isSafeInteger(value.value) ? `int:${String(value.value)}` : null;
+    case 3 /* String */:
+      return typeof value.value === "string" ? `string:${JSON.stringify(value.value)}` : null;
+    case 1 /* Bool */:
+      return typeof value.value === "boolean" ? `bool:${String(value.value)}` : null;
+    case 8 /* Enum */:
+      if (selectorTypeInfo.type !== 8 /* Enum */ || value.typeInfo.enumId !== selectorTypeInfo.enumId || !Array.isArray(value.value) || value.value.length !== 1 || typeof value.value[0] !== "string" || value.value[0].length === 0) {
+        return null;
+      }
+      return `enum:${value.typeInfo.enumId}:${JSON.stringify(value.value[0])}`;
+    default:
+      return null;
+  }
+}
+function isNSSwitchSection(value, selectorTypeInfo, seenLabels) {
+  const section = value;
+  if (typeof section !== "object" || section === null) return false;
+  if (!Array.isArray(section.labels) || section.labels.length === 0) {
+    return false;
+  }
+  for (const label of section.labels) {
+    const key = nsSwitchLabelKey(label, selectorTypeInfo);
+    if (key === null || seenLabels.has(key)) return false;
+    seenLabels.add(key);
+  }
+  return isNSInstructions(section.instructions);
+}
+function isNSInstructionSwitch(value) {
+  const instruction = value;
+  if (instruction?.type !== "switch" /* switch */) return false;
+  if (!isNSPointer(instruction.selector)) return false;
+  if (!isNSSwitchSelectorType(instruction.selectorTypeInfo)) return false;
+  if (!Array.isArray(instruction.sections)) return false;
+  const selectorTypeInfo = instruction.selectorTypeInfo;
+  const seenLabels = /* @__PURE__ */ new Set();
+  if (!instruction.sections.every(
+    (section) => isNSSwitchSection(section, selectorTypeInfo, seenLabels)
+  )) {
+    return false;
+  }
+  return instruction.defaultInstructions === void 0 || instruction.defaultInstructions === null || isNSInstructions(instruction.defaultInstructions);
+}
+function isNSCatchClause(value, bindingIds, isFinal) {
+  const clause = value;
+  if (typeof clause !== "object" || clause === null) return false;
+  const binding = clause.binding;
+  if (typeof binding !== "object" || binding === null) return false;
+  if (typeof binding.id !== "string" || binding.id.length === 0) return false;
+  if (bindingIds.has(binding.id)) return false;
+  bindingIds.add(binding.id);
+  if (!isNSTypeInfo(binding.typeInfo)) return false;
+  if (binding.typeInfo.type !== 3 /* String */) return false;
+  if (binding.typeInfo.required !== true) return false;
+  if (binding.readonly !== true) return false;
+  const hasFilter = clause.filter !== void 0 && clause.filter !== null;
+  if (!hasFilter && !isFinal) return false;
+  if (hasFilter && !isNSBooleanExpression(clause.filter)) return false;
+  return isNSInstructions(clause.instructions);
+}
+function isNSInstructionTry(value) {
+  const instruction = value;
+  if (instruction?.type !== "try" /* try */) return false;
+  if (!isNSInstructions(instruction.instructions)) return false;
+  if (!Array.isArray(instruction.catches)) return false;
+  if (instruction.catches.length === 0) return false;
+  const bindingIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < instruction.catches.length; index += 1) {
+    const clause = instruction.catches[index];
+    if (!isNSCatchClause(
+      clause,
+      bindingIds,
+      index === instruction.catches.length - 1
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
 function isNSInstruction(value) {
-  return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value);
+  return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value);
+}
+function nsInstructionsContainType(instructions, type) {
+  return instructions.some((instruction) => {
+    if (instruction.type === type) return true;
+    if (instruction.type === "if" /* if */) {
+      return instruction.branches.some(
+        (branch) => nsInstructionsContainType(branch.instructions, type)
+      ) || instruction.else !== null && instruction.else !== void 0 && nsInstructionsContainType(instruction.else, type);
+    }
+    if (instruction.type === "for" /* for */ || instruction.type === "forEach" /* forEach */) {
+      return nsInstructionsContainType(instruction.instructions, type);
+    }
+    if (instruction.type === "switch" /* switch */) {
+      return instruction.sections.some(
+        (section) => nsInstructionsContainType(section.instructions, type)
+      ) || instruction.defaultInstructions !== null && instruction.defaultInstructions !== void 0 && nsInstructionsContainType(instruction.defaultInstructions, type);
+    }
+    if (instruction.type === "try" /* try */) {
+      return nsInstructionsContainType(instruction.instructions, type) || instruction.catches.some(
+        (clause) => nsInstructionsContainType(clause.instructions, type)
+      );
+    }
+    return false;
+  });
 }
 function isNSInstructions(value) {
   return Array.isArray(value) && value.every(isNSInstruction);
@@ -48711,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)
     });
   }
@@ -50146,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",
@@ -50219,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];
@@ -50653,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);
@@ -50874,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(
@@ -50901,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;
@@ -56756,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
       )
     );
   }
@@ -62513,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,
@@ -62861,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);
@@ -63132,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,
@@ -63495,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({
@@ -63744,6 +66204,9 @@ var init_decimal = __esm({
 });
 
 // ../src/view-models/neoscript-evaluator/evaluateNSGetter.ts
+function isCatchableNSRuntimeError(error) {
+  return error instanceof NSGetterRuntimeError && !(error instanceof NonCatchableNSGetterRuntimeError);
+}
 function makeEvaluatorLookups(members, values) {
   const attrMap = /* @__PURE__ */ new Map();
   for (const a of members) attrMap.set(a.id, a);
@@ -63958,6 +66421,7 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
       );
       return createdSessionValues.length === 0 ? { value: result.value, writes } : { value: result.value, writes, createdSessionValues };
     }
+    rejectEscapedLoopTransfer(result, "NeoScript getter");
   } catch (error) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
     throw error;
@@ -63983,6 +66447,7 @@ function evaluateNSAction(action, ctx) {
         );
       }
     }
+    rejectEscapedLoopTransfer(result, "NeoScript action");
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
   } catch (error) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
@@ -64052,7 +66517,8 @@ function withEvaluationRuntime(ctx, writes) {
       functionStack: [],
       constructorGroups: /* @__PURE__ */ new Map(),
       ownedValueAttachments: /* @__PURE__ */ new Map(),
-      constructionStack: []
+      constructionStack: [],
+      loopIterations: 0
     },
     __indexes: ctx.__executionState === void 0 || ctx.__valueOverlay === void 0 ? void 0 : ctx.__indexes
   };
@@ -64302,6 +66768,7 @@ function evaluateNSSetter(setter, ctx, value, writes) {
       `Setter returned a non-null value: ${String(result.value)}`
     );
   }
+  rejectEscapedLoopTransfer(result, "NeoScript setter");
 }
 function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runtimeSignature) {
   if (action.parameters.length < 2) {
@@ -64345,6 +66812,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
       "NSFunction ended without returning its declared value."
     );
   }
+  rejectEscapedLoopTransfer(result, "NeoScript function");
   let value = result.value;
   const runtimeReturnType = runtimeSignature?.returnTypeInfo ?? action.typeInfo;
   if (runtimeReturnType.type === NS_TYPE_VOID) {
@@ -64365,6 +66833,40 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
   }
   return value;
 }
+function createChildScope(parent) {
+  const child = new Map(parent);
+  const inherited = readonlyBindingErrorsByScope.get(parent);
+  if (inherited !== void 0 && inherited.size > 0) {
+    readonlyBindingErrorsByScope.set(child, new Map(inherited));
+  }
+  return child;
+}
+function markReadonlyBinding(scope, bindingId, errorMessage3) {
+  const existing = readonlyBindingErrorsByScope.get(scope);
+  if (existing === void 0) {
+    readonlyBindingErrorsByScope.set(
+      scope,
+      /* @__PURE__ */ new Map([[bindingId, errorMessage3]])
+    );
+    return;
+  }
+  readonlyBindingErrorsByScope.set(
+    scope,
+    new Map([...existing, [bindingId, errorMessage3]])
+  );
+}
+function assertVariableBindingWritable(scope, bindingId) {
+  const errorMessage3 = readonlyBindingErrorsByScope.get(scope)?.get(bindingId);
+  if (errorMessage3 === void 0) return;
+  throw new NSGetterRuntimeError(errorMessage3);
+}
+function rejectEscapedLoopTransfer(result, bodyLabel) {
+  if (result.kind === "break" || result.kind === "continue") {
+    throw new NSGetterRuntimeError(
+      `Corrupt ${bodyLabel} IR: '${result.kind}' escaped the nearest loop.`
+    );
+  }
+}
 function evaluationOptions(ctx, allowFallthroughReturn) {
   const writes = ctx.__executionState?.writes;
   if (writes === void 0) {
@@ -64387,6 +66889,186 @@ function createTopLevelScope(ctx) {
   );
   return scope;
 }
+function consumeLoopIteration(ctx) {
+  const state = ctx.__executionState;
+  if (state === void 0) {
+    throw new NSGetterRuntimeError(
+      "NeoScript loop executed without a shared execution state."
+    );
+  }
+  if (state.loopIterations >= MAX_LOOP_ITERATIONS) {
+    throw new NSGetterRuntimeError(
+      `NeoScript loop iteration limit of ${MAX_LOOP_ITERATIONS} exceeded.`
+    );
+  }
+  state.loopIterations += 1;
+}
+function synchronizeExistingBindings(parent, child, bindingIds) {
+  for (const bindingId of bindingIds) {
+    parent.set(bindingId, child.get(bindingId));
+  }
+}
+function evalInstructionsInChildScope(instructions, parent, ctx, options) {
+  const parentBindingIds = [...parent.keys()];
+  const child = createChildScope(parent);
+  try {
+    return evalInstructions(instructions, child, ctx, options);
+  } finally {
+    synchronizeExistingBindings(parent, child, parentBindingIds);
+  }
+}
+function switchSelectorTypeSupported(typeInfo) {
+  return typeInfo.type === 2 /* Int */ || typeInfo.type === 3 /* String */ || typeInfo.type === 1 /* Bool */ || typeInfo.type === 8 /* Enum */;
+}
+function switchLabelKeyOrThrow(label, selectorTypeInfo) {
+  if (label.typeInfo.required !== true) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript switch IR: case labels must use canonical required type information."
+    );
+  }
+  if (label.typeInfo.type === 0 /* Null */) {
+    if (label.value !== null || selectorTypeInfo.required !== false) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript switch IR: a null case label requires an optional selector."
+      );
+    }
+    return "null";
+  }
+  if (label.typeInfo.type !== selectorTypeInfo.type) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript switch IR: case label type does not match the selector type."
+    );
+  }
+  switch (label.typeInfo.type) {
+    case 2 /* Int */:
+      if (typeof label.value !== "number" || !Number.isSafeInteger(label.value)) {
+        throw new CorruptNeoScriptIRError(
+          "Corrupt NeoScript switch IR: int case label is not a safe integer."
+        );
+      }
+      return `int:${String(label.value)}`;
+    case 3 /* String */:
+      if (typeof label.value !== "string") {
+        throw new CorruptNeoScriptIRError(
+          "Corrupt NeoScript switch IR: string case label has a non-string value."
+        );
+      }
+      return `string:${JSON.stringify(label.value)}`;
+    case 1 /* Bool */:
+      if (typeof label.value !== "boolean") {
+        throw new CorruptNeoScriptIRError(
+          "Corrupt NeoScript switch IR: bool case label has a non-boolean value."
+        );
+      }
+      return `bool:${String(label.value)}`;
+    case 8 /* Enum */:
+      if (selectorTypeInfo.type !== 8 /* Enum */ || label.typeInfo.enumId !== selectorTypeInfo.enumId || !Array.isArray(label.value) || label.value.length !== 1 || typeof label.value[0] !== "string" || label.value[0].length === 0) {
+        throw new CorruptNeoScriptIRError(
+          "Corrupt NeoScript switch IR: enum case label does not match the selector enum."
+        );
+      }
+      return `enum:${label.typeInfo.enumId}:${JSON.stringify(label.value[0])}`;
+    default:
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript switch IR: unsupported case label type."
+      );
+  }
+}
+function validateSwitchInstruction(instruction) {
+  if (!switchSelectorTypeSupported(instruction.selectorTypeInfo)) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript switch IR: selector type must be int, string, bool, or enum."
+    );
+  }
+  const labels = /* @__PURE__ */ new Set();
+  for (const section of instruction.sections) {
+    if (section.labels.length === 0) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript switch IR: case section has no labels."
+      );
+    }
+    for (const label of section.labels) {
+      const key = switchLabelKeyOrThrow(label, instruction.selectorTypeInfo);
+      if (labels.has(key)) {
+        throw new CorruptNeoScriptIRError(
+          "Corrupt NeoScript switch IR: duplicate case label."
+        );
+      }
+      labels.add(key);
+    }
+  }
+}
+function assertSwitchSelectorValue(value, typeInfo, ctx) {
+  const matchesType = runtimeValueMatchesType(value, typeInfo, ctx) && (typeInfo.type !== 2 /* Int */ || value === null || typeof value === "number" && Number.isSafeInteger(value));
+  if (!matchesType) {
+    throw new NSGetterRuntimeError(
+      "NeoScript switch selector does not match its compiled type."
+    );
+  }
+}
+function validateTryInstruction(instruction) {
+  if (!Array.isArray(instruction.catches)) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript try IR: catch clause list is missing."
+    );
+  }
+  if (instruction.catches.length === 0) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript try IR: at least one catch clause is required."
+    );
+  }
+  const bindingIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < instruction.catches.length; index += 1) {
+    const clause = instruction.catches[index];
+    if (typeof clause?.binding !== "object" || clause.binding === null) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch clause is missing its binding."
+      );
+    }
+    if (typeof clause.binding.id !== "string") {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding id must be a string."
+      );
+    }
+    if (clause.binding.id.length === 0) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding id must be non-empty."
+      );
+    }
+    if (bindingIds.has(clause.binding.id)) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding ids must be unique."
+      );
+    }
+    bindingIds.add(clause.binding.id);
+    if (clause.binding.typeInfo?.type !== 3 /* String */) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding type must be string."
+      );
+    }
+    if (clause.binding.typeInfo.required !== true) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding string must be required."
+      );
+    }
+    if (clause.binding.readonly !== true) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: catch binding must be read-only."
+      );
+    }
+    const unfiltered = clause.filter === void 0 || clause.filter === null;
+    if (unfiltered && index !== instruction.catches.length - 1) {
+      throw new CorruptNeoScriptIRError(
+        "Corrupt NeoScript try IR: an unfiltered catch must be the final clause."
+      );
+    }
+  }
+  if (!isNSInstructionTry(instruction)) {
+    throw new CorruptNeoScriptIRError(
+      "Corrupt NeoScript try IR: catch filter or child instructions are malformed."
+    );
+  }
+}
 function evalInstructions(instructions, scope, ctx, options) {
   for (const ins of instructions) {
     switch (ins.type) {
@@ -64409,13 +67091,13 @@ function evalInstructions(instructions, scope, ctx, options) {
               ctx,
               options
             );
-            if (r.kind === "return") return r;
+            if (r.kind !== "fallthrough") return r;
             break;
           }
         }
         if (!matched && ins.else) {
           const r = evalInstructions(ins.else, scope, ctx, options);
-          if (r.kind === "return") return r;
+          if (r.kind !== "fallthrough") return r;
         }
         break;
       }
@@ -64433,6 +67115,7 @@ function evalInstructions(instructions, scope, ctx, options) {
           value = coerceDecimalOperand(value, "assignment");
         }
         if (ins.target.pointer.type === "variable" /* variable */) {
+          assertVariableBindingWritable(scope, ins.target.pointer.variableId);
           scope.set(ins.target.pointer.variableId, value);
           break;
         }
@@ -64473,6 +67156,174 @@ function evalInstructions(instructions, scope, ctx, options) {
         evalPointer(ins.call, scope, ctx);
         break;
       }
+      case "for" /* for */: {
+        const parentBindingIds = [...scope.keys()];
+        const loopScope = createChildScope(scope);
+        try {
+          const initialValue = coerceAssignmentValue(
+            evalPointer(ins.initializer.pointer, loopScope, ctx),
+            ins.initializer.typeInfo,
+            "variable initialization"
+          );
+          loopScope.set(ins.initializer.id, initialValue);
+          while (evalBooleanExpression(ins.condition, loopScope, ctx)) {
+            consumeLoopIteration(ctx);
+            const result = evalInstructionsInChildScope(
+              ins.instructions,
+              loopScope,
+              ctx,
+              options
+            );
+            if (result.kind === "return") return result;
+            if (result.kind === "break") break;
+            evalInstructions([ins.iterator], loopScope, ctx, options);
+          }
+        } finally {
+          synchronizeExistingBindings(scope, loopScope, parentBindingIds);
+        }
+        break;
+      }
+      case "forEach" /* forEach */: {
+        const collection = evalPointer(ins.collectionPointer, scope, ctx);
+        const membership = snapshotCollectionMembership(collection);
+        const parentBindingIds = [...scope.keys()];
+        const loopScope = createChildScope(scope);
+        markReadonlyBinding(
+          loopScope,
+          ins.binding.id,
+          READONLY_FOREACH_BINDING_ERROR
+        );
+        try {
+          for (const rawEntry of membership) {
+            consumeLoopIteration(ctx);
+            loopScope.set(
+              ins.binding.id,
+              coerceAssignmentValue(
+                resolveValueIfId(rawEntry, ctx),
+                ins.binding.typeInfo,
+                "foreach binding"
+              )
+            );
+            const result = evalInstructionsInChildScope(
+              ins.instructions,
+              loopScope,
+              ctx,
+              options
+            );
+            if (result.kind === "return") return result;
+            if (result.kind === "break") break;
+          }
+        } finally {
+          synchronizeExistingBindings(scope, loopScope, parentBindingIds);
+        }
+        break;
+      }
+      case "switch" /* switch */: {
+        validateSwitchInstruction(ins);
+        const selector = evalPointer(ins.selector, scope, ctx);
+        assertSwitchSelectorValue(selector, ins.selectorTypeInfo, ctx);
+        const matchedSection = ins.sections.find(
+          (section) => section.labels.some((label) => jsEqual(selector, label.value))
+        );
+        const selectedInstructions = matchedSection?.instructions ?? ins.defaultInstructions;
+        if (selectedInstructions === void 0 || selectedInstructions === null) {
+          break;
+        }
+        const parentBindingIds = [...scope.keys()];
+        const sectionScope = createChildScope(scope);
+        const result = (() => {
+          try {
+            return evalInstructions(
+              selectedInstructions,
+              sectionScope,
+              ctx,
+              options
+            );
+          } finally {
+            synchronizeExistingBindings(scope, sectionScope, parentBindingIds);
+          }
+        })();
+        if (result.kind === "break") break;
+        if (result.kind === "fallthrough") {
+          throw new CorruptNeoScriptIRError(
+            "Corrupt NeoScript switch IR: selected section reached its end."
+          );
+        }
+        return result;
+      }
+      case "try" /* try */: {
+        validateTryInstruction(ins);
+        const parentBindingIds = [...scope.keys()];
+        const tryScope = createChildScope(scope);
+        let tryResult;
+        try {
+          try {
+            tryResult = evalInstructions(
+              ins.instructions,
+              tryScope,
+              ctx,
+              options
+            );
+          } finally {
+            synchronizeExistingBindings(scope, tryScope, parentBindingIds);
+          }
+        } catch (error) {
+          if (!isCatchableNSRuntimeError(error)) throw error;
+          let matched = false;
+          for (const clause of ins.catches) {
+            const catchScope = createChildScope(scope);
+            catchScope.set(clause.binding.id, error.message);
+            markReadonlyBinding(
+              catchScope,
+              clause.binding.id,
+              READONLY_CATCH_BINDING_ERROR
+            );
+            const filter = clause.filter;
+            let filterMatches = filter === null || filter === void 0;
+            if (filter !== null && filter !== void 0) {
+              try {
+                filterMatches = evalBooleanExpression(filter, catchScope, ctx);
+              } catch (filterError) {
+                if (!isCatchableNSRuntimeError(filterError)) {
+                  synchronizeExistingBindings(
+                    scope,
+                    catchScope,
+                    parentBindingIds
+                  );
+                  throw filterError;
+                }
+                filterMatches = false;
+              }
+            }
+            if (!filterMatches) {
+              synchronizeExistingBindings(scope, catchScope, parentBindingIds);
+              continue;
+            }
+            matched = true;
+            let catchResult;
+            try {
+              catchResult = evalInstructions(
+                clause.instructions,
+                catchScope,
+                ctx,
+                options
+              );
+            } finally {
+              synchronizeExistingBindings(scope, catchScope, parentBindingIds);
+            }
+            if (catchResult.kind !== "fallthrough") return catchResult;
+            break;
+          }
+          if (!matched) throw error;
+          break;
+        }
+        if (tryResult.kind !== "fallthrough") return tryResult;
+        break;
+      }
+      case "break" /* break */:
+        return { kind: "break" };
+      case "continue" /* continue */:
+        return { kind: "continue" };
     }
     void touchUnknown(ins);
   }
@@ -66226,6 +69077,9 @@ function applyArithmetic(op, operands, decimal2) {
       });
   }
 }
+function coerceAssignmentValue(value, targetTypeInfo, context) {
+  return targetTypeInfo.type === 20 /* Decimal */ && typeof value === "number" ? coerceDecimalOperand(value, context) : value;
+}
 function coerceDecimalOperand(value, context) {
   if (typeof value === "string") {
     if (!isDecimalString(value)) {
@@ -68488,33 +71342,55 @@ function collectionLength(c) {
     `Cannot Count() ${typeof c}; expected list, dictionary, or string`
   );
 }
-function collectionEntries(c, ctx) {
-  if (Array.isArray(c)) {
-    return c.map((entry) => resolveValueIfId(entry, ctx));
-  }
-  if (typeof c === "object" && c !== null) {
-    return Object.values(c).map((entry) => resolveValueIfId(entry, ctx));
-  }
-  return [];
+function snapshotCollectionMembership(collection) {
+  const membership = [];
+  const valid = forEachRawCollectionEntry(collection, ({ raw }) => {
+    membership.push(raw);
+  });
+  if (valid) return membership;
+  throw new NSGetterRuntimeError(
+    "NeoScript foreach requires a present collection."
+  );
 }
-function iterateCollection(c, ctx, callback) {
+function forEachRawCollectionEntry(c, callback) {
   if (Array.isArray(c)) {
-    for (let i = 0; i < c.length; i++) {
-      const raw = c[i];
-      const entry = resolveValueIfId(raw, ctx);
-      callback(entry, i, typeof raw === "string" ? raw : null);
+    for (let key = 0; key < c.length; key += 1) {
+      const raw = c[key];
+      callback({
+        raw,
+        key,
+        valueId: typeof raw === "string" ? raw : null
+      });
     }
-    return;
+    return true;
   }
   if (typeof c === "object" && c !== null) {
-    for (const [k, raw] of Object.entries(c)) {
-      const entry = resolveValueIfId(raw, ctx);
-      callback(entry, k, typeof raw === "string" ? raw : null);
+    for (const [key, raw] of Object.entries(c)) {
+      callback({
+        raw,
+        key,
+        valueId: typeof raw === "string" ? raw : null
+      });
     }
+    return true;
   }
+  return false;
+}
+function collectionEntries(c, ctx) {
+  const entries = [];
+  forEachRawCollectionEntry(c, ({ raw }) => {
+    entries.push(resolveValueIfId(raw, ctx));
+  });
+  return entries;
+}
+function iterateCollection(c, ctx, callback) {
+  forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
+    const entry = resolveValueIfId(raw, ctx);
+    callback(entry, key, valueId);
+  });
 }
 function pushParams(parent, parameters, positional, isList) {
-  const child = new Map(parent);
+  const child = createChildScope(parent);
   if (parameters.length === 1) {
     child.set(parameters[0].id, positional[1]);
   } else if (parameters.length === 2) {
@@ -68524,7 +71400,7 @@ function pushParams(parent, parameters, positional, isList) {
   }
   return child;
 }
-var NativeFunctionDelegateUnavailableError, liveListIndexesByProject, MAX_CONSTRUCTION_DEPTH, LazyValueOverlay;
+var NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, liveListIndexesByProject, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
     "use strict";
@@ -68540,10 +71416,15 @@ var init_evaluateNSGetter = __esm({
     init_core();
     init_member_storage_key();
     init_project2();
-    NativeFunctionDelegateUnavailableError = class extends NSGetterRuntimeError {
+    NonCatchableNSGetterRuntimeError = class extends NSGetterRuntimeError {
+    };
+    NativeFunctionDelegateUnavailableError = class extends NonCatchableNSGetterRuntimeError {
+    };
+    CorruptNeoScriptIRError = class extends NonCatchableNSGetterRuntimeError {
     };
     liveListIndexesByProject = /* @__PURE__ */ new WeakMap();
     MAX_CONSTRUCTION_DEPTH = 64;
+    MAX_LOOP_ITERATIONS = 1e4;
     LazyValueOverlay = class extends Map {
       constructor(vm) {
         super();
@@ -68603,6 +71484,9 @@ var init_evaluateNSGetter = __esm({
         return indexes;
       }
     };
+    readonlyBindingErrorsByScope = /* @__PURE__ */ new WeakMap();
+    READONLY_FOREACH_BINDING_ERROR = "Cannot assign to a read-only foreach iterator binding.";
+    READONLY_CATCH_BINDING_ERROR = "Cannot assign to a read-only catch message binding.";
   }
 });
 
@@ -69354,6 +72238,49 @@ function stringifyReturnInstructions(instructions, sourceType) {
         pointer: stringifyTextVariablePointer(instruction.pointer, sourceType)
       };
     }
+    if (instruction.type === "switch" /* switch */) {
+      return {
+        ...instruction,
+        sections: instruction.sections.map((section) => ({
+          ...section,
+          instructions: stringifyReturnInstructions(
+            section.instructions,
+            sourceType
+          )
+        })),
+        ...instruction.defaultInstructions === void 0 ? {} : {
+          defaultInstructions: instruction.defaultInstructions === null ? null : stringifyReturnInstructions(
+            instruction.defaultInstructions,
+            sourceType
+          )
+        }
+      };
+    }
+    if (instruction.type === "try" /* try */) {
+      return {
+        ...instruction,
+        instructions: stringifyReturnInstructions(
+          instruction.instructions,
+          sourceType
+        ),
+        catches: instruction.catches.map((clause) => ({
+          ...clause,
+          instructions: stringifyReturnInstructions(
+            clause.instructions,
+            sourceType
+          )
+        }))
+      };
+    }
+    if (instruction.type === "for" /* for */ || instruction.type === "forEach" /* forEach */) {
+      return {
+        ...instruction,
+        instructions: stringifyReturnInstructions(
+          instruction.instructions,
+          sourceType
+        )
+      };
+    }
     if (instruction.type !== "if" /* if */) return instruction;
     return {
       ...instruction,
@@ -69928,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];
@@ -70440,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."
@@ -70450,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
@@ -70532,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,
@@ -70565,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,
@@ -70623,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;
@@ -71482,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 },
@@ -71503,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];
@@ -71513,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) {
@@ -71525,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";
@@ -71573,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;
@@ -71588,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,
@@ -71606,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,
@@ -71708,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 {
@@ -71896,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");
@@ -71956,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) {
@@ -72512,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();
@@ -73928,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}`;
@@ -73936,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;
@@ -75095,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
@@ -75124,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(
@@ -75136,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) {
@@ -75298,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;
@@ -75344,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(
@@ -75677,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: {
@@ -76166,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) => {
@@ -76734,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();
@@ -76745,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") {
@@ -77672,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");
   }
@@ -77715,7 +80734,7 @@ function materializeAssignedSchemaIdsInAuthoredSource(workspace, replacements) {
       return {
         uri,
         kind,
-        text: readFileSync13(absolutePath, "utf8")
+        text: readFileSync14(absolutePath, "utf8")
       };
     }
   );
@@ -77905,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])
   );
@@ -77980,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;
   });
@@ -78322,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({
@@ -78365,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) {
@@ -78403,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) {
@@ -78513,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 {
     }
   }
@@ -78568,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");
@@ -78584,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;
@@ -78599,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;
@@ -78652,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"() {