@neocompose/cli 0.17.0 → 0.18.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(
@@ -7529,6 +8674,7 @@ var init_strict_resolver = __esm({
                 }
               }
             }
+            mergeBranchInvalidations(scope, branchExitOwnershipScopes);
             mergeBranchOwnership(scope, branchExitOwnershipScopes);
             return {
               type: "if" /* If */,
@@ -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,6 +9378,13 @@ 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 writability = local?.writability ?? target.writability;
@@ -8120,7 +9879,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(
@@ -8485,6 +10245,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 +10266,8 @@ var init_strict_resolver = __esm({
             ),
             symbol: member,
             ...writability ? { writability } : {},
-            ...lookupWire ? { wireType: lookupWire } : {}
+            ...lookupWire ? { wireType: lookupWire } : {},
+            ...entryWritability ? { entryWritability } : {}
           };
         }
         throw new CompileError(
@@ -8583,6 +10345,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 +11146,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 +11174,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 +11182,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 +11195,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 +11209,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 +11384,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 +11406,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 +11430,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 +11481,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 +11942,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 +12299,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 +12333,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 +12357,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;
@@ -16398,11 +18279,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 +18336,9 @@ function collectIdentifierReads(expression, names) {
       case "exprStmt":
         walk(statement.expr, visible);
         return;
+      case "break":
+      case "continue":
+        return;
     }
   };
   walk(expression, names);
@@ -17098,7 +19026,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 +19036,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(
@@ -33513,6 +35475,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 +35746,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 +36017,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);
@@ -63744,6 +65874,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 +66091,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 +66117,7 @@ function evaluateNSAction(action, ctx) {
         );
       }
     }
+    rejectEscapedLoopTransfer(result, "NeoScript action");
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
   } catch (error) {
     finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
@@ -64052,7 +66187,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 +66438,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 +66482,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 +66503,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 +66559,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 +66761,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 +66785,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 +66826,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 +68747,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 +71012,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 +71070,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 +71086,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 +71154,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 +71908,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,