@neocompose/cli 0.85.0 → 0.86.0

package/dist/test-worker.mjs

@@ -1333,6 +1333,34 @@ function compareGroupIds(left, right) {
   return 0;
 }
 
+// ../packages/neoscript-language/src/bitwise.ts
+var ARITIES = {
+  and: 2,
+  or: 2,
+  xor: 2,
+  not: 1,
+  shiftLeft: 2,
+  shiftRight: 2,
+  shiftRightUnsigned: 2
+};
+function isNeoScriptBitwiseOp(value) {
+  return typeof value === "string" && Object.hasOwn(ARITIES, value);
+}
+function neoScriptBitwiseOpArity(op) {
+  return ARITIES[op];
+}
+var BITWISE_BINARY_OPERATORS = {
+  "&": "and",
+  "|": "or",
+  "^": "xor",
+  "<<": "shiftLeft",
+  ">>": "shiftRight",
+  ">>>": "shiftRightUnsigned"
+};
+function isBitwiseBinaryOperator(value) {
+  return Object.hasOwn(BITWISE_BINARY_OPERATORS, value);
+}
+
 // ../packages/neoscript-language/src/dialogue-types.ts
 var NEOSCRIPT_DIALOGUES_MEMBER_NAME = "Dialogues";
 var NEOSCRIPT_DIALOGUES_TYPE_ID = "builtin:Dialogues";
@@ -1480,17 +1508,17 @@ var KIND_LABELS = {
 };
 function neoScriptDialogueTypes(groups) {
   const names = dialogueGroupPropertyNames(groups);
-  const children = /* @__PURE__ */ new Map();
+  const children3 = /* @__PURE__ */ new Map();
   for (const group of groups) {
-    const siblings = children.get(group.parentId);
-    if (siblings === void 0) children.set(group.parentId, [group]);
+    const siblings = children3.get(group.parentId);
+    if (siblings === void 0) children3.set(group.parentId, [group]);
     else siblings.push(group);
   }
   const rootPath = `root.${NEOSCRIPT_DIALOGUES_MEMBER_NAME}`;
   const types = [];
   const typeFor = (parentId, path) => {
     const members2 = [];
-    for (const group of children.get(parentId) ?? []) {
+    for (const group of children3.get(parentId) ?? []) {
       const name = names.get(group.id);
       const groupPath = `${path}.${name}`;
       const typeId = `${NEOSCRIPT_DIALOGUES_TYPE_ID}:${group.id}`;
@@ -1552,7 +1580,7 @@ function neoScriptDialogueTypes(groups) {
 }
 
 // ../packages/neoscript-language/src/vector-math.ts
-var ARITIES = {
+var ARITIES2 = {
   add: 2,
   subtract: 2,
   negate: 1,
@@ -1574,10 +1602,10 @@ function isNeoScriptVectorKind(value) {
   return value === "Vector2" || value === "Vector2Int" || value === "Vector3" || value === "Vector3Int" || value === "Color";
 }
 function neoScriptVectorOpArity(op) {
-  return ARITIES[op];
+  return ARITIES2[op];
 }
 function isNeoScriptVectorOpForKind(kind, op) {
-  if (typeof op !== "string" || !Object.hasOwn(ARITIES, op)) return false;
+  if (typeof op !== "string" || !Object.hasOwn(ARITIES2, op)) return false;
   if (kind === "Color") return op === "lerp";
   if (op === "cross") return kind === "Vector3";
   if (kind.endsWith("Int")) {
@@ -1812,6 +1840,19 @@ function isNeoVariantTypeName(name) {
   return name === NEO_VARIANT_TYPE_NAME || name === NEO_LOOKUP_VARIANT_TYPE_NAME;
 }
 var NEOSCRIPT_OPERATORS = [
+  ">>>=",
+  ">>=",
+  "<<=",
+  ">>>",
+  ">>",
+  "<<",
+  "&=",
+  "|=",
+  "^=",
+  "&",
+  "|",
+  "^",
+  "~",
   "===",
   "!==",
   "==",
@@ -3455,7 +3496,7 @@ function isNSPointerMemberTarget(value) {
   return isNSCallReceiver(pointer.receiver);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerRowOf(value) || isNSPointerDeref(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerMemberTarget(value) || isNSPointerDelegateClosure(value) || isNSPointerObjectInitializer(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerRowOf(value) || isNSPointerDeref(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerConditional(value) || isNSPointerSwitchExpression(value) || isNSPointerMemberTarget(value) || isNSPointerDelegateClosure(value) || isNSPointerObjectInitializer(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerTileConvert(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerVariant(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -3784,6 +3825,20 @@ function isNSFunctionTextOp(value) {
   if (!NS_TEXT_NUMBER_OPS.includes(info.op)) return false;
   return NS_TEXT_NUMBERS.includes(info.number);
 }
+function isNSFunctionBitwiseOp(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value) || value.type !== "bitwiseOp" /* bitwiseOp */)
+    return false;
+  if (!("info" in value) || typeof value.info !== "object" || value.info === null)
+    return false;
+  const info = value.info;
+  if (!("op" in info) || !isNeoScriptBitwiseOp(info.op)) return false;
+  if (!("argPointers" in info) || !Array.isArray(info.argPointers))
+    return false;
+  if (info.argPointers.length !== neoScriptBitwiseOpArity(info.op))
+    return false;
+  return info.argPointers.every(isNSPointer);
+}
 function isNSFunctionVectorOp(value) {
   if (typeof value !== "object" || value === null) return false;
   if (!("type" in value) || value.type !== "vectorOp" /* vectorOp */)
@@ -3941,7 +3996,7 @@ function isNSFunction(value) {
   return isNSFunctionClassConstructor(value) || isNSFunctionClassClone(value) || isNSFunctionListIndex(value) || isNSFunctionSelect(value) || isNSFunctionCollectionQuery(value) || isNSFunctionFirst(value) || isNSFunctionFirstOrDefault(value) || isNSFunctionWhere(value) || isNSFunctionContains(value) || isNSFunctionIndexOf(value) || // stringOp was missing from this chain since its introduction — a
   // compiled getter using ToLower()/StartsWith() would fail pointer
   // validation anywhere isNSFunction gates. Fixed alongside decimalOp.
-  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionVectorOp(value) || isNSFunctionListRepeat(value) || isNSFunctionTextOp(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionDialogueGroup(value) || isNSFunctionDialogue(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
+  isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionBitwiseOp(value) || isNSFunctionVectorOp(value) || isNSFunctionListRepeat(value) || isNSFunctionTextOp(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionDialogueGroup(value) || isNSFunctionDialogue(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
 }
 function isNSInstructionVariable(value) {
   const v = value;
@@ -4210,6 +4265,35 @@ function isNSVoidBody(value) {
   if (value.typeInfo.type !== 0 /* Null */) return false;
   return value.typeInfo.required === true;
 }
+function isNSPointerSwitchExpression(value) {
+  if (typeof value !== "object" || value === null || !("type" in value) || value.type !== "switchExpression" /* switchExpression */)
+    return false;
+  if (!("selectorTypeInfo" in value) || !isNSTypeInfo(value.selectorTypeInfo))
+    return false;
+  if (!("selector" in value) || !isNSPointer(value.selector)) return false;
+  if (!("selectorId" in value) || typeof value.selectorId !== "string" || value.selectorId.length === 0)
+    return false;
+  if (!("arms" in value) || !Array.isArray(value.arms) || value.arms.length === 0)
+    return false;
+  const selectorTypeInfo = value.selectorTypeInfo;
+  return value.arms.every((arm) => {
+    if (typeof arm !== "object" || arm === null) return false;
+    if (!("value" in arm) || !isNSPointer(arm.value)) return false;
+    if ("guard" in arm && !isNSPointer(arm.guard)) return false;
+    if (!("pattern" in arm) || typeof arm.pattern !== "object" || arm.pattern === null)
+      return false;
+    const pattern = arm.pattern;
+    if (!("kind" in pattern)) return false;
+    if (pattern.kind === "discard") return true;
+    if (pattern.kind === "constant")
+      return "constant" in pattern && nsSwitchLabelKey(pattern.constant, selectorTypeInfo) !== null;
+    if (pattern.kind !== "type") return false;
+    if (!("checkType" in pattern) || !isNSTypeInfo(pattern.checkType))
+      return false;
+    if (pattern.checkType.required !== true) return false;
+    return !("bindingId" in pattern) || typeof pattern.bindingId === "string" && pattern.bindingId.length > 0;
+  });
+}
 
 // ../packages/models/src/neoscript/parameter-defaults.ts
 function parameterHasDefault(argument2) {
@@ -5447,9 +5531,9 @@ function isMemberChangeListenerEntry(value) {
     const identities = /* @__PURE__ */ new Set();
     for (const target of targets) {
       if (!isMemberDelegateTarget(target)) return false;
-      const identity = nsActionListenerIdentity(target);
-      if (identities.has(identity)) return false;
-      identities.add(identity);
+      const identity2 = nsActionListenerIdentity(target);
+      if (identities.has(identity2)) return false;
+      identities.add(identity2);
     }
   }
   return true;
@@ -5550,9 +5634,9 @@ function isNSActionValue(value) {
   const identities = /* @__PURE__ */ new Set();
   for (const listener of record4.listeners) {
     if (!isMemberDelegateTarget(listener)) return false;
-    const identity = nsActionListenerIdentity(listener);
-    if (identities.has(identity)) return false;
-    identities.add(identity);
+    const identity2 = nsActionListenerIdentity(listener);
+    if (identities.has(identity2)) return false;
+    identities.add(identity2);
   }
   return true;
 }
@@ -6599,7 +6683,10 @@ async function forEachConcurrently(items, limit, work) {
 
 // ../packages/models/src/classes/classes.ts
 function isAbstractClass(value) {
-  return value?.modifier === 1 /* Abstract */;
+  return value?.modifier === 1 /* Abstract */ || value?.modifier === 3 /* Closed */;
+}
+function isClosedHierarchyClass(value) {
+  return value?.modifier === 3 /* Closed */;
 }
 function isSealedClass(value) {
   return value?.modifier === 2 /* Sealed */;
@@ -6691,7 +6778,7 @@ function isNeoSchemaClassBase(value) {
   const v = value;
   return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
     (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
-  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */) && (v.allowedStorage === void 0 || isClassAllowedStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.implementsInterfaceArguments === void 0 || isInterfaceArgumentsById(v.implementsInterfaceArguments)) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
+  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */ || v.modifier === 3 /* Closed */) && (v.allowedStorage === void 0 || isClassAllowedStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.implementsInterfaceArguments === void 0 || isInterfaceArgumentsById(v.implementsInterfaceArguments)) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
     (constructorId) => typeof constructorId === "string" && constructorId.length > 0
   ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || isSystemMetadata(v.system));
 }
@@ -7294,8 +7381,8 @@ function derivedMemberValueId(memberId) {
   );
 }
 function virtualValueId(instanceRootId, sourceIdentity2) {
-  const identity = `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`;
-  const bytes = SURROGATE_CODE_UNIT.test(identity) ? identity : virtualIdentityEncoder.encode(identity);
+  const identity2 = `${withoutSystemRecordIdPrefix(instanceRootId)}:${sourceIdentity2}`;
+  const bytes = SURROGATE_CODE_UNIT.test(identity2) ? identity2 : virtualIdentityEncoder.encode(identity2);
   return inSystemRecordNamespaceOf(
     instanceRootId,
     v5_default(bytes, virtualNamespaceBytes)
@@ -7416,23 +7503,23 @@ function decodePackedValueRow(row) {
     projectId: row.projectId,
     mapKey: row.mapKey
   };
-  const children = [];
+  const children3 = [];
   const scope = {
     state,
     ownerId: row.id,
     ownerLabel: `value "${row.id}"`,
     constructionRootId: isCollapseStampedInstanceRoot(row) ? row.id : null
   };
-  const value = decodeContentField(row.value, "value", scope, children);
+  const value = decodeContentField(row.value, "value", scope, children3);
   const constructorArgs = decodeContentField(
     isLiteralValueContent(row) ? row.constructorArgs : void 0,
     "constructorArgs",
     scope,
-    children
+    children3
   );
   return {
     row: withDecodedContent(row, value, constructorArgs),
-    children,
+    children: children3,
     packedChildIdsByParentId: state.edges
   };
 }
@@ -7442,12 +7529,12 @@ function canonicalPackedChildId(args) {
   if (args.sourceValueId.length === 0) return null;
   return virtualValueId(args.constructionRootId, args.sourceValueId);
 }
-function decodeContentField(container, field, scope, children) {
+function decodeContentField(container, field, scope, children3) {
   if (!containerHoldsPackedEntry(container)) return null;
   if (Array.isArray(container)) {
     return {
       content: container.map(
-        (entry, index) => isPackedValueEnvelope(entry) ? decodeEnvelope(entry, `${field}[${index}]`, scope, children) : entry
+        (entry, index) => isPackedValueEnvelope(entry) ? decodeEnvelope(entry, `${field}[${index}]`, scope, children3) : entry
       )
     };
   }
@@ -7459,12 +7546,12 @@ function decodeContentField(container, field, scope, children) {
       entry,
       `${field}[${JSON.stringify(key)}]`,
       scope,
-      children
+      children3
     ) : entry;
   }
   return { content: decoded };
 }
-function decodeEnvelope(envelope, position, scope, children) {
+function decodeEnvelope(envelope, position, scope, children3) {
   const label = `Packed value entry at ${scope.ownerLabel}.${position}`;
   const entry = envelope[PACKED_VALUE_ENTRY_KEY];
   assertDecodableEntry(entry, label);
@@ -7483,11 +7570,11 @@ function decodeEnvelope(envelope, position, scope, children) {
     constructionRootId: isCollapseStampedInstanceRoot(entry) ? id : scope.constructionRootId
   };
   const nested = [];
-  children.push(logicalChildRow(entry, id, childScope, nested));
-  children.push(...nested);
+  children3.push(logicalChildRow(entry, id, childScope, nested));
+  children3.push(...nested);
   return id;
 }
-function logicalChildRow(entry, id, scope, children) {
+function logicalChildRow(entry, id, scope, children3) {
   const rowFields = {
     id,
     projectId: scope.state.projectId,
@@ -7498,12 +7585,12 @@ function logicalChildRow(entry, id, scope, children) {
     ...entry.sourceValueId === void 0 ? {} : { sourceValueId: entry.sourceValueId }
   };
   if (isInitValueContent(entry)) return { ...rowFields, init: entry.init };
-  const value = decodeContentField(entry.value, "value", scope, children);
+  const value = decodeContentField(entry.value, "value", scope, children3);
   const constructorArgs = decodeContentField(
     entry.constructorArgs,
     "constructorArgs",
     scope,
-    children
+    children3
   );
   return {
     ...rowFields,
@@ -7799,9 +7886,9 @@ function editChangeListenerSet(explicit, inherited, edit, options = { inheritedC
   if (edit.kind === "replace") {
     next = edit.targets;
   } else {
-    const identity = nsActionListenerIdentity(edit.target);
+    const identity2 = nsActionListenerIdentity(edit.target);
     const index = current.findIndex(
-      (target) => nsActionListenerIdentity(target) === identity
+      (target) => nsActionListenerIdentity(target) === identity2
     );
     if (edit.kind === "add") {
       if (index !== -1) return { changed: false };
@@ -7814,10 +7901,10 @@ function editChangeListenerSet(explicit, inherited, edit, options = { inheritedC
   const targets = [];
   const seen = /* @__PURE__ */ new Set();
   for (const target of next) {
-    const identity = nsActionListenerIdentity(target);
-    if (seen.has(identity))
+    const identity2 = nsActionListenerIdentity(target);
+    if (seen.has(identity2))
       throw new Error("A listener set cannot repeat a handler identity.");
-    seen.add(identity);
+    seen.add(identity2);
     targets.push({ memberId: target.memberId, valueId: target.valueId });
   }
   if (targets.length === 0 && inherited.length === 0 && options.inheritedComplete) {
@@ -10501,11 +10588,11 @@ function openBindingTypeInfo(member, env, classes, members2) {
     for (const [parameterId, argument2] of Object.entries(
       declaredSlotArguments(resolved) ?? {}
     )) {
-      const argumentType = isForwardedGenericBinding(argument2) ? param(argument2.genericParamId) : nested(argument2.memberId);
-      if (argumentType === null) {
+      const argumentType2 = isForwardedGenericBinding(argument2) ? param(argument2.genericParamId) : nested(argument2.memberId);
+      if (argumentType2 === null) {
         return genericBindingTypeInfo(resolved, env, members2);
       }
-      typeArguments[parameterId] = argumentType;
+      typeArguments[parameterId] = argumentType2;
     }
     const typeArgumentsField = Object.keys(typeArguments).length === 0 ? {} : { typeArguments };
     if (isInterfaceTypedMember(resolved)) {
@@ -11450,9 +11537,9 @@ function isNeoInterfaceMember(value) {
   };
   if (containsForbiddenMemberTypeInfo(fn.returnTypeInfo, own)) return false;
   if (!Array.isArray(fn.argumentTypes)) return false;
-  for (const argumentType of fn.argumentTypes) {
-    if (!isNSFunctionArgumentTypeInfo(argumentType)) return false;
-    if (containsForbiddenMemberTypeInfo(argumentType, own)) return false;
+  for (const argumentType2 of fn.argumentTypes) {
+    if (!isNSFunctionArgumentTypeInfo(argumentType2)) return false;
+    if (containsForbiddenMemberTypeInfo(argumentType2, own)) return false;
   }
   if (fn.dispatch !== void 0 && fn.dispatch !== 0 /* Synchronous */ && fn.dispatch !== 1 /* Asynchronous */)
     return false;
@@ -17513,6 +17600,57 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
   valueId;
 };
 
+// ../packages/neoscript-runtime/src/neoscript/bitwise.ts
+function evaluateBitwiseOp(info, evaluate) {
+  const { op, argPointers } = info;
+  if (!isNeoScriptBitwiseOp(op))
+    throw new NSGetterRuntimeError(
+      `Unknown bitwise operation '${String(op)}'.`
+    );
+  if (!Array.isArray(argPointers))
+    throw new NSGetterRuntimeError(
+      `Bitwise ${op} requires an argument pointer array.`
+    );
+  const arity = neoScriptBitwiseOpArity(op);
+  if (argPointers.length !== arity)
+    throw new NSGetterRuntimeError(
+      `Bitwise ${op} requires ${arity} arguments; got ${argPointers.length}.`
+    );
+  const operand = (index) => {
+    const value = evaluate(argPointers[index]);
+    if (typeof value !== "number")
+      throw new NSGetterRuntimeError(
+        `Bitwise ${op} operand ${index + 1} must be a number.`
+      );
+    if (!Number.isFinite(value))
+      throw new NSGetterRuntimeError(
+        `Bitwise ${op} operand ${index + 1} must be finite.`
+      );
+    if (!Number.isInteger(value))
+      throw new NSGetterRuntimeError(
+        `Bitwise ${op} operand ${index + 1} must be an integer.`
+      );
+    return value | 0;
+  };
+  const left = operand(0);
+  if (op === "not") return ~left;
+  const right = operand(1);
+  switch (op) {
+    case "and":
+      return left & right;
+    case "or":
+      return left | right;
+    case "xor":
+      return left ^ right;
+    case "shiftLeft":
+      return left << right;
+    case "shiftRight":
+      return left >> right;
+    case "shiftRightUnsigned":
+      return left >>> right | 0;
+  }
+}
+
 // ../packages/neoscript-runtime/src/neoscript/vector-math.ts
 function evaluateVectorOp(info, evaluate) {
   if (!isNeoScriptVectorKind(info.kind)) {
@@ -19984,11 +20122,11 @@ function createEffectiveClassRelationResolver(args) {
   const childrenByClassId = /* @__PURE__ */ new Map();
   for (const schemaClass2 of args.classes) {
     if (schemaClass2.extendsClassId === void 0) continue;
-    const children = childrenByClassId.get(schemaClass2.extendsClassId);
-    if (children === void 0) {
+    const children3 = childrenByClassId.get(schemaClass2.extendsClassId);
+    if (children3 === void 0) {
       childrenByClassId.set(schemaClass2.extendsClassId, [schemaClass2.id]);
     } else {
-      children.push(schemaClass2.id);
+      children3.push(schemaClass2.id);
     }
   }
   const ancestry = (classId) => {
@@ -22423,8 +22561,8 @@ function exportInitializerCollections(created, writes, ctx) {
       collectionEntriesAreReferences: assignedValues.has(value) ? false : void 0,
       collectionOwnerId
     });
-    const children = rows.filter((row) => row !== root);
-    return { root, children, declarations };
+    const children3 = rows.filter((row) => row !== root);
+    return { root, children: children3, declarations };
   };
   const adopt = (owner, rootId, rows, declarations) => {
     const groupId = constructorGroupForRow(owner.id, ctx);
@@ -22462,13 +22600,13 @@ function exportInitializerCollections(created, writes, ctx) {
       const record4 = { ...inlineFields.record };
       const encoded2 = { ...row, value: record4 };
       for (const [key, member2] of inlineFields.members) {
-        const { root: root2, children: children2, declarations: declarations2 } = encode(
+        const { root: root2, children: children4, declarations: declarations2 } = encode(
           member2,
           inPlace(record4[key]),
           inlineFields.genericEnv
         );
         record4[key] = root2.id;
-        adopt(encoded2, root2.id, [root2, ...children2], declarations2);
+        adopt(encoded2, root2.id, [root2, ...children4], declarations2);
       }
       return encoded2;
     }
@@ -22480,7 +22618,7 @@ function exportInitializerCollections(created, writes, ctx) {
     }
     const value = inPlace(row.value);
     if (!assignedValues.has(value) && !mutatedIds.has(row.id)) return row;
-    const { root, children, declarations } = encode(
+    const { root, children: children3, declarations } = encode(
       member,
       value,
       rowGenericEnv(row, ctx),
@@ -22488,7 +22626,7 @@ function exportInitializerCollections(created, writes, ctx) {
     );
     const encoded = { ...row, value: root.value };
     declarations.delete(root.id);
-    adopt(encoded, root.id, children, declarations);
+    adopt(encoded, root.id, children3, declarations);
     return encoded;
   });
   return [...exported, ...extra];
@@ -22899,9 +23037,9 @@ function ownedConstructorArgumentValues(row, ctx, readRow) {
   };
   for (let index = 0; index < constructor.argumentTypes.length; index += 1) {
     const parameterId = constructor.action.parameters[index + 2]?.id;
-    const argumentType = constructor.argumentTypes[index];
-    if (parameterId === void 0 || argumentType === void 0) continue;
-    collect(row.constructorArgs[parameterId], argumentType, parameterId);
+    const argumentType2 = constructor.argumentTypes[index];
+    if (parameterId === void 0 || argumentType2 === void 0) continue;
+    collect(row.constructorArgs[parameterId], argumentType2, parameterId);
   }
   return owned;
 }
@@ -24627,9 +24765,9 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
     destination = resolved;
   }) : evalPointer(target, scope, ctx);
   const current = actionListenersOf(currentValue, () => `'${operator}' target`);
-  const identity = nsActionListenerIdentity(listener);
+  const identity2 = nsActionListenerIdentity(listener);
   const present = current.some(
-    (entry) => nsActionListenerIdentity(entry) === identity
+    (entry) => nsActionListenerIdentity(entry) === identity2
   );
   let listeners;
   if (ins.type === "addActionListener" /* addActionListener */) {
@@ -24641,7 +24779,7 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
   } else {
     if (!present) return;
     listeners = current.filter(
-      (entry) => nsActionListenerIdentity(entry) !== identity
+      (entry) => nsActionListenerIdentity(entry) !== identity2
     );
   }
   const value = { listeners };
@@ -27124,6 +27262,30 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       if (left !== null && left !== void 0) return left;
       return evalPointer(pointer.right, scope, ctx);
     }
+    case "switchExpression" /* switchExpression */: {
+      const selected = evalPointer(pointer.selector, scope, ctx);
+      for (const arm of pointer.arms) {
+        checkDeadline(ctx);
+        const pattern = arm.pattern;
+        let matches = pattern.kind === "discard";
+        if (pattern.kind === "constant") {
+          const constant = pattern.constant.value;
+          matches = Array.isArray(constant) ? Array.isArray(selected) && constant.length === selected.length && constant.every((item, index) => item === selected[index]) : selected === constant;
+        }
+        if (pattern.kind === "type")
+          matches = selected != null && runtimeTypeCheck(selected, pattern.checkType, ctx);
+        if (!matches) continue;
+        const child = createChildScope(scope);
+        child.setLocal(pointer.selectorId, selected);
+        if (pattern.kind === "type" && pattern.bindingId)
+          child.setLocal(pattern.bindingId, selected);
+        if (arm.guard && evalPointer(arm.guard, child, ctx) !== true) continue;
+        return evalPointer(arm.value, child, ctx);
+      }
+      throw new NSGetterRuntimeError(
+        "Switch expression is not exhaustive for the runtime value."
+      );
+    }
     case "conditional" /* conditional */: {
       const condition = evalPointer(pointer.condition, scope, ctx);
       return evalPointer(
@@ -28486,16 +28648,16 @@ function evalKeyOf(pointer, scope, ctx, onDestination) {
   if (Array.isArray(receiver)) {
     if (typeof key === "string") {
       const indexes4 = evaluatorIndexes(ctx);
-      let identity = indexes4.listIdentityByArray.get(receiver);
-      if (identity === void 0) {
-        identity = /* @__PURE__ */ new Map();
+      let identity2 = indexes4.listIdentityByArray.get(receiver);
+      if (identity2 === void 0) {
+        identity2 = /* @__PURE__ */ new Map();
         for (let i = 0; i < receiver.length; i += 1) {
           const valueId = receiver[i];
-          if (typeof valueId === "string") identity.set(valueId, i);
+          if (typeof valueId === "string") identity2.set(valueId, i);
         }
-        indexes4.listIdentityByArray.set(receiver, identity);
+        indexes4.listIdentityByArray.set(receiver, identity2);
       }
-      const position = identity.get(key);
+      const position = identity2.get(key);
       if (position === void 0) {
         throw new NSGetterRuntimeError(`List value id not found: ${key}`);
       }
@@ -31114,6 +31276,11 @@ function evalFunction(fn, scope, ctx) {
     }
     case "mathOp" /* mathOp */:
       return evalMathOp(fn.info, scope, ctx);
+    case "bitwiseOp" /* bitwiseOp */:
+      return evaluateBitwiseOp(
+        fn.info,
+        (pointer) => evalPointer(pointer, scope, ctx)
+      );
     case "vectorOp" /* vectorOp */:
       return evaluateVectorOp(
         fn.info,
@@ -32648,10 +32815,10 @@ function runtimeValueReferencesVariable(value, variableId, visited = /* @__PURE_
   if (Reflect.get(value, "type") === "variable" /* variable */ && Reflect.get(value, "variableId") === variableId) {
     return true;
   }
-  const children = Object.values(Object.getOwnPropertyDescriptors(value)).filter(
+  const children3 = Object.values(Object.getOwnPropertyDescriptors(value)).filter(
     (descriptor) => "value" in descriptor
   ).map((descriptor) => descriptor.value);
-  return children.some(
+  return children3.some(
     (child) => runtimeValueReferencesVariable(child, variableId, visited)
   );
 }
@@ -33925,14 +34092,14 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
           `Constructor '${record4.id}' has no compiled parameter for argument ${index}.`
         );
       }
-      const argumentType = record4.argumentTypes[index];
-      if (argumentType === void 0) {
+      const argumentType2 = record4.argumentTypes[index];
+      if (argumentType2 === void 0) {
         throw new NSGetterRuntimeError(
           `Constructor '${record4.id}' has no declared type for argument ${index}.`
         );
       }
       const resolvedArgumentType = substituteRuntimeTypeInfo(
-        argumentType,
+        argumentType2,
         descriptor.instanceEnv,
         ctx
       );
@@ -33946,7 +34113,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record4, info, scope
         // Only collection rows carry a stamp from the settled member.
         member: resolvedArgumentType.type === 6 /* List */ || resolvedArgumentType.type === 28 /* Set */ || resolvedArgumentType.type === 5 /* Dictionary */ ? settledConstructorParameterMember(
           classId,
-          argumentType.name,
+          argumentType2.name,
           record4.id,
           ctx
         ) : void 0,
@@ -34148,8 +34315,8 @@ function currentOwnedValueAttachments(valueId, ctx) {
   }
   const directlyBoundMembers = directlyBoundMembersOf(valueId, ctx);
   for (const member of directlyBoundMembers) {
-    const identity = isStaticMember(member) ? `static:${member.id}` : `member:${member.id}`;
-    add({ identity, label: identity });
+    const identity2 = isStaticMember(member) ? `static:${member.id}` : `member:${member.id}`;
+    add({ identity: identity2, label: identity2 });
   }
   if (row !== null) {
     const rootMember = rootMemberForValueRow(row, ctx);
@@ -34834,9 +35001,9 @@ function retainOnlyCreatedRowsReachableFrom(rootId, createdValues, ctx) {
   const childrenByContainerId = /* @__PURE__ */ new Map();
   for (const row of createdValues) {
     if (typeof row.containerId !== "string") continue;
-    const children = childrenByContainerId.get(row.containerId) ?? [];
-    children.push(row.id);
-    childrenByContainerId.set(row.containerId, children);
+    const children3 = childrenByContainerId.get(row.containerId) ?? [];
+    children3.push(row.id);
+    childrenByContainerId.set(row.containerId, children3);
   }
   const reachable = /* @__PURE__ */ new Set();
   const visit = (id) => {
@@ -35524,6 +35691,40 @@ function recordWrittenEntry(collection, key, reference, ctx) {
   else keys.delete(String(key));
 }
 
+// ../packages/neoscript-language/src/type-tokens.ts
+function scanNeoScriptType(tokens, start) {
+  const token = tokens[start];
+  if (!token) return null;
+  const primitive3 = (token.kind === "type" || token.kind === "keyword") && ["int", "float", "decimal", "bool", "string", "null"].includes(token.text);
+  const collection = token.kind === "type" && ["Dictionary", "List", "Set"].includes(token.text);
+  if (!primitive3 && !collection && !isExecutableIdentifier(token)) return null;
+  let index = start + 1;
+  if ((collection || isExecutableIdentifier(token)) && tokens[index]?.kind === "operator" && tokens[index]?.text === "<") {
+    index = scanNeoScriptType(tokens, index + 1) ?? -1;
+    if (index < 0) return null;
+    while (tokens[index]?.kind === "punctuation" && tokens[index]?.text === ",") {
+      index = scanNeoScriptType(tokens, index + 1) ?? -1;
+      if (index < 0) return null;
+    }
+    if (tokens[index]?.kind !== "operator" || tokens[index]?.text !== ">") {
+      return null;
+    }
+    index++;
+  } else if (collection) {
+    return null;
+  }
+  while (tokens[index]?.kind === "punctuation" && tokens[index]?.text === "[" && tokens[index + 1]?.kind === "punctuation" && tokens[index + 1]?.text === "]") {
+    index += 2;
+  }
+  if (tokens[index]?.kind === "operator" && tokens[index]?.text === "?") {
+    index++;
+  }
+  return index;
+}
+function isExecutableIdentifier(token) {
+  return token.kind === "identifier" || token.kind === "type" && token.text !== "int" && token.text !== "float" && token.text !== "decimal" && token.text !== "bool" && token.text !== "string" && token.text !== "Dictionary" && token.text !== "List" && token.text !== "Set";
+}
+
 // ../packages/neoscript-language/src/strict-ast.ts
 function expressionBodyStatements(body, voidContext) {
   const pos = body.start;
@@ -35640,14 +35841,36 @@ function clamp(value, minimum, maximum) {
 }
 
 // ../packages/neoscript-language/src/lexer.ts
+function expressionOperator(tokens, index) {
+  const first = tokens[index];
+  if (first?.text !== "<" && first?.text !== ">") return first;
+  let text = first.text;
+  let end = first;
+  let result = first;
+  for (let offset = 1; offset <= 2; offset++) {
+    const next = tokens[index + offset];
+    if (!next || next.kind !== "operator" || next.start !== end.end) break;
+    text += next.text;
+    if (!["<<", ">>", ">>>", "<<=", ">>=", ">>>="].includes(text)) break;
+    end = next;
+    result = {
+      ...first,
+      text,
+      raw: text,
+      end: next.end,
+      range: { start: first.range.start, end: next.range.end }
+    };
+  }
+  return result;
+}
 var KEYWORD_SET = new Set(NEOSCRIPT_KEYWORDS);
 var TYPE_SET = /* @__PURE__ */ new Set([
   ...NEOSCRIPT_PRIMITIVE_TYPES,
   ...NEOSCRIPT_BUILTIN_TYPES
 ]);
-var OPERATORS = [...NEOSCRIPT_OPERATORS].sort(
-  (left, right) => right.length - left.length
-);
+var OPERATORS = NEOSCRIPT_OPERATORS.filter(
+  (op) => !/^(?:<<|>>)/.test(op)
+).sort((left, right) => right.length - left.length);
 var OPERATORS_BY_FIRST_CHARACTER = /* @__PURE__ */ new Map();
 for (const operator of OPERATORS) {
   const first = operator[0];
@@ -35836,7 +36059,7 @@ function lex(sourceValue) {
   function scanInterpolatedString(start, endOffset, grammarTokens2) {
     let cursor = start + 2;
     let segmentStart = start;
-    const children = [];
+    const children3 = [];
     while (cursor < endOffset) {
       const char = sourceValue[cursor] ?? "";
       const next = sourceValue[cursor + 1] ?? "";
@@ -35855,7 +36078,7 @@ function lex(sourceValue) {
       if (char === '"') {
         cursor++;
         tokens.push(makeToken("string", segmentStart, cursor));
-        emitInterpolation(start, cursor, children, grammarTokens2);
+        emitInterpolation(start, cursor, children3, grammarTokens2);
         return cursor;
       }
       if (char === "\n" || char === "\r") break;
@@ -35865,12 +36088,12 @@ function lex(sourceValue) {
         }
         const open = interpolationHoleToken(cursor);
         tokens.push(open);
-        children.push(open);
+        children3.push(open);
         const expressionStart = cursor + 1;
         const expressionEnd = findInterpolationEnd(expressionStart, endOffset);
         if (expressionEnd === null) {
-          scanRange(expressionStart, endOffset, true, children);
-          emitInterpolation(start, endOffset, children, grammarTokens2);
+          scanRange(expressionStart, endOffset, true, children3);
+          emitInterpolation(start, endOffset, children3, grammarTokens2);
           diagnostics.push({
             range: source.range(cursor, endOffset),
             severity: "error",
@@ -35881,10 +36104,10 @@ function lex(sourceValue) {
           });
           return endOffset;
         }
-        scanRange(expressionStart, expressionEnd, true, children);
+        scanRange(expressionStart, expressionEnd, true, children3);
         const close = interpolationHoleToken(expressionEnd);
         tokens.push(close);
-        children.push(close);
+        children3.push(close);
         cursor = expressionEnd + 1;
         segmentStart = cursor;
         continue;
@@ -35894,7 +36117,7 @@ function lex(sourceValue) {
     if (segmentStart < cursor) {
       tokens.push(makeToken("string", segmentStart, cursor));
     }
-    emitInterpolation(start, cursor, children, grammarTokens2);
+    emitInterpolation(start, cursor, children3, grammarTokens2);
     diagnostics.push({
       range: source.range(start, cursor),
       severity: "error",
@@ -35905,10 +36128,10 @@ function lex(sourceValue) {
     });
     return cursor;
   }
-  function emitInterpolation(start, end, children, grammarTokens2) {
+  function emitInterpolation(start, end, children3, grammarTokens2) {
     grammarTokens2.push({
       ...makeToken("string", start, end, void 0, "interpolated"),
-      children
+      children: children3
     });
   }
   function scanTripleString(start, endOffset, grammarTokens2) {
@@ -36122,6 +36345,16 @@ var Parser = class _Parser {
     if (!token) throw new Error("NeoScript parser received no EOF token.");
     return token;
   }
+  peekOperator() {
+    return expressionOperator(this.tokens, this.i) ?? this.peek();
+  }
+  nextOperator() {
+    const operator = this.peekOperator();
+    do {
+      this.next();
+    } while (this.peek().start < operator.end);
+    return operator;
+  }
   /** Consume and return the current token. */
   next() {
     const t = this.tokens[this.i];
@@ -36136,7 +36369,7 @@ var Parser = class _Parser {
   expect(kind, text) {
     const t = this.peek();
     if (!tokenMatches(t, kind, text)) {
-      if (this.recoverFlow && kind === "punctuation" && (text === ";" || text === "}" && t.kind === "eof")) {
+      if (this.recoverFlow && kind === "punctuation" && (text === ";" || text === "}" && t.kind === "eof" || text === ")" && (t.kind === "eof" || t.text === "}" || t.text === ";"))) {
         return {
           ...t,
           kind,
@@ -36161,7 +36394,7 @@ var Parser = class _Parser {
     const token = this.peek();
     const afterLineBreak = token.range.start.line > this.peek(-1).range.end.line;
     const nextStatement = token.text === "var" && this.peek(1).kind === "identifier" || afterLineBreak && this.peek(1).text === "=";
-    if (this.recoverFlow && (nextStatement || !isIdentifier(token) && token.kind !== "type" && token.kind !== "keyword" || token.text === "return")) {
+    if (this.recoverFlow && (nextStatement || !isExecutableIdentifier(token) && token.kind !== "type" && token.kind !== "keyword" || token.text === "return")) {
       const previous = this.peek(-1);
       return {
         ...previous,
@@ -36173,7 +36406,7 @@ var Parser = class _Parser {
         range: { start: previous.range.end, end: previous.range.end }
       };
     }
-    if (isIdentifier(token) || (token.kind === "keyword" || token.kind === "type") && (token.text === "native" || isValidNeoProjectMemberIdentifier(token.text))) {
+    if (isExecutableIdentifier(token) || (token.kind === "keyword" || token.kind === "type") && (token.text === "native" || isValidNeoProjectMemberIdentifier(token.text))) {
       return this.next();
     }
     throw new CompileError(
@@ -36312,8 +36545,8 @@ var Parser = class _Parser {
         pos: at(t)
       };
     }
-    if (isAssignmentOp(this.peek())) {
-      const opTok = this.next();
+    if (isAssignmentOp(this.peekOperator())) {
+      const opTok = this.nextOperator();
       const value = this.parseExpr();
       this.expect("punctuation", ";");
       return {
@@ -36463,7 +36696,7 @@ var Parser = class _Parser {
     const type2 = this.peek();
     const name = this.peek(1);
     const close = this.peek(2);
-    if (type2.kind !== "type" || type2.text !== "string" || !isIdentifier(name) || close.kind !== "punctuation" || close.text !== ")") {
+    if (type2.kind !== "type" || type2.text !== "string" || !isExecutableIdentifier(name) || close.kind !== "punctuation" || close.text !== ")") {
       throw new CompileError(
         "NeoScript catch parameters must have the form `catch (string name)`.",
         at(type2)
@@ -36560,7 +36793,7 @@ var Parser = class _Parser {
       };
     }
     const target = this.parseExpr();
-    const operator = this.peek();
+    const operator = this.peekOperator();
     if (isIncrementOp(operator)) {
       this.next();
       return {
@@ -36577,7 +36810,7 @@ var Parser = class _Parser {
         at(operator)
       );
     }
-    this.next();
+    this.nextOperator();
     return {
       kind: "assign",
       target,
@@ -36628,7 +36861,7 @@ var Parser = class _Parser {
   }
   parseVarDecl(terminated = true) {
     const startPos = at(this.peek());
-    const inferred = isIdentifier(this.peek()) && this.peek().text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
+    const inferred = isExecutableIdentifier(this.peek()) && this.peek().text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
     let type2;
     if (inferred) {
       this.next();
@@ -36663,8 +36896,8 @@ var Parser = class _Parser {
    */
   looksLikeVarDecl() {
     const t = this.peek();
-    if (isIdentifier(t) && t.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD) {
-      return isIdentifier(this.peek(1));
+    if (isExecutableIdentifier(t) && t.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD) {
+      return isExecutableIdentifier(this.peek(1));
     }
     if (t.kind === "type" && (t.text === "int" || t.text === "float" || t.text === "decimal" || t.text === "bool" || t.text === "string")) {
       return true;
@@ -36675,11 +36908,11 @@ var Parser = class _Parser {
     if (t.kind === "type" && (t.text === "List" || t.text === "Set") && this.peek(1).kind === "operator" && this.peek(1).text === "<") {
       return true;
     }
-    if (!isIdentifier(t)) return false;
+    if (!isExecutableIdentifier(t)) return false;
     const end = this.typeEnd();
     const name = this.tokens[end];
     const equals = this.tokens[end + 1];
-    return end >= 0 && name !== void 0 && isIdentifier(name) && equals?.kind === "operator" && equals.text === "=";
+    return end >= 0 && name !== void 0 && isExecutableIdentifier(name) && equals?.kind === "operator" && equals.text === "=";
   }
   /**
    * Token index just past the type that starts at the cursor, or -1 when the
@@ -36765,7 +36998,7 @@ var Parser = class _Parser {
           pos: startPos
         };
       }
-    } else if (isIdentifier(t)) {
+    } else if (isExecutableIdentifier(t)) {
       this.next();
       const typeArguments = [];
       if (this.eat("operator", "<")) {
@@ -36899,14 +37132,44 @@ var Parser = class _Parser {
     return left;
   }
   parseLogicalAnd() {
-    let left = this.parseEquality();
+    let left = this.parseBitwiseOr();
     while (this.peek().kind === "operator" && this.peek().text === "&&") {
       const opTok = this.next();
-      const right = this.parseEquality();
+      const right = this.parseBitwiseOr();
       left = makeBinary("&&", left, right, at(opTok));
     }
     return left;
   }
+  parseBitwiseOr() {
+    return this.parseBitwiseLevel("|", () => this.parseBitwiseXor());
+  }
+  parseBitwiseXor() {
+    return this.parseBitwiseLevel("^", () => this.parseBitwiseAnd());
+  }
+  parseBitwiseAnd() {
+    return this.parseBitwiseLevel("&", () => this.parseEquality());
+  }
+  parseBitwiseLevel(operator, operand) {
+    let left = operand();
+    while (this.peek().text === operator) {
+      const token = this.next();
+      left = makeBinary(operator, left, operand(), at(token));
+    }
+    return left;
+  }
+  parseShift() {
+    let left = this.parseAdditive();
+    while (["<<", ">>", ">>>"].includes(this.peekOperator().text)) {
+      const token = this.nextOperator();
+      left = makeBinary(
+        asASTBinaryOp(token.text),
+        left,
+        this.parseAdditive(),
+        at(token)
+      );
+    }
+    return left;
+  }
   parseEquality() {
     let left = this.parseComparison();
     while (true) {
@@ -36940,10 +37203,10 @@ var Parser = class _Parser {
     }
   }
   parseComparison() {
-    let left = this.parseAdditive();
-    while (this.peek().kind === "operator" && (this.peek().text === "<" || this.peek().text === ">" || this.peek().text === "<=" || this.peek().text === ">=")) {
-      const opTok = this.next();
-      const right = this.parseAdditive();
+    let left = this.parseShift();
+    while (this.peekOperator().kind === "operator" && (this.peekOperator().text === "<" || this.peekOperator().text === ">" || this.peekOperator().text === "<=" || this.peekOperator().text === ">=")) {
+      const opTok = this.nextOperator();
+      const right = this.parseShift();
       left = makeBinary(asASTBinaryOp(opTok.text), left, right, at(opTok));
     }
     return left;
@@ -36958,17 +37221,65 @@ var Parser = class _Parser {
     return left;
   }
   parseMultiplicative() {
-    let left = this.parseUnary();
+    let left = this.parseSwitchExpression();
     while (this.peek().kind === "operator" && (this.peek().text === "*" || this.peek().text === "/" || this.peek().text === "%")) {
       const opTok = this.next();
-      const right = this.parseUnary();
+      const right = this.parseSwitchExpression();
       left = makeBinary(asASTBinaryOp(opTok.text), left, right, at(opTok));
     }
     return left;
   }
+  parseSwitchExpression() {
+    let selector = this.parseUnary();
+    while (this.peek().text === "switch") {
+      const token = this.next();
+      this.expect("punctuation", "{");
+      const arms = [];
+      while (this.peek().text !== "}") {
+        const start = this.peek();
+        let pattern;
+        if (start.text === "_") {
+          this.next();
+          pattern = { kind: "discard", pos: at(start) };
+        } else {
+          const saved = this.i;
+          const type2 = start.text !== "null" && this.typeEnd() >= 0 ? this.parseType() : null;
+          if (type2 && this.peek().text !== "." && (this.peek().text === "=>" || this.peek().text === "when" || this.peek().kind === "identifier")) {
+            const binding = this.peek().kind === "identifier" && this.peek().text !== "when" ? this.next().text : null;
+            pattern = {
+              kind: "type",
+              type: type2,
+              bindingName: binding === "_" ? null : binding,
+              pos: at(start)
+            };
+          } else {
+            this.i = saved;
+            pattern = {
+              kind: "constant",
+              expression: this.parseUnary(),
+              pos: at(start)
+            };
+          }
+        }
+        let guard = null;
+        if (this.peek().text === "when") {
+          this.next();
+          guard = this.parseExpr();
+        }
+        this.expect("operator", "=>");
+        const value = this.parseExpr();
+        arms.push({ pattern, guard, value, pos: at(start) });
+        if (this.peek().text !== ",") break;
+        this.next();
+      }
+      this.expect("punctuation", "}");
+      selector = { kind: "switchExpression", selector, arms, pos: at(token) };
+    }
+    return selector;
+  }
   parseUnary() {
     const t = this.peek();
-    if (t.kind === "operator" && (t.text === "!" || t.text === "-")) {
+    if (t.kind === "operator" && (t.text === "!" || t.text === "-" || t.text === "~")) {
       this.next();
       const operand = this.parseUnary();
       return { kind: "unary", op: t.text, operand, pos: at(t) };
@@ -37099,10 +37410,10 @@ var Parser = class _Parser {
   genericStaticMemberName() {
     const open = this.tokens[this.i];
     if (open?.kind !== "operator" || open.text !== "<") return null;
-    let index = this.scanType(this.i + 1);
+    let index = scanNeoScriptType(this.tokens, this.i + 1);
     if (index === null) return null;
     while (this.tokens[index]?.kind === "punctuation" && this.tokens[index]?.text === ",") {
-      index = this.scanType(index + 1);
+      index = scanNeoScriptType(this.tokens, index + 1);
       if (index === null) return null;
     }
     const close = this.tokens[index];
@@ -37110,53 +37421,21 @@ var Parser = class _Parser {
     const member = this.tokens[index + 2];
     if (close?.kind !== "operator" || close.text !== ">") return null;
     if (dot?.kind !== "punctuation" || dot.text !== ".") return null;
-    return member && isIdentifier(member) ? member.text : null;
+    return member && isExecutableIdentifier(member) ? member.text : null;
   }
   looksLikeGenericCall() {
     const open = this.tokens[this.i];
     if (open?.kind !== "operator" || open.text !== "<") return false;
-    let index = this.scanType(this.i + 1);
+    let index = scanNeoScriptType(this.tokens, this.i + 1);
     if (index === null) return false;
     while (this.tokens[index]?.kind === "punctuation" && this.tokens[index]?.text === ",") {
-      index = this.scanType(index + 1);
+      index = scanNeoScriptType(this.tokens, index + 1);
       if (index === null) return false;
     }
     const close = this.tokens[index];
     const call = this.tokens[index + 1];
     return close?.kind === "operator" && close.text === ">" && call?.kind === "punctuation" && call.text === "(";
   }
-  /** Returns the first token after one syntactically complete type. */
-  scanType(start) {
-    const token = this.tokens[start];
-    if (!token) return null;
-    const primitive3 = (token.kind === "type" || token.kind === "keyword") && ["int", "float", "decimal", "bool", "string", "null"].includes(
-      token.text
-    );
-    const collection = token.kind === "type" && ["Dictionary", "List", "Set"].includes(token.text);
-    if (!primitive3 && !collection && !isIdentifier(token)) return null;
-    let index = start + 1;
-    if ((collection || isIdentifier(token)) && this.tokens[index]?.kind === "operator" && this.tokens[index]?.text === "<") {
-      index = this.scanType(index + 1) ?? -1;
-      if (index < 0) return null;
-      while (this.tokens[index]?.kind === "punctuation" && this.tokens[index]?.text === ",") {
-        index = this.scanType(index + 1) ?? -1;
-        if (index < 0) return null;
-      }
-      if (this.tokens[index]?.kind !== "operator" || this.tokens[index]?.text !== ">") {
-        return null;
-      }
-      index++;
-    } else if (collection) {
-      return null;
-    }
-    while (this.tokens[index]?.kind === "punctuation" && this.tokens[index]?.text === "[" && this.tokens[index + 1]?.kind === "punctuation" && this.tokens[index + 1]?.text === "]") {
-      index += 2;
-    }
-    if (this.tokens[index]?.kind === "operator" && this.tokens[index]?.text === "?") {
-      index++;
-    }
-    return index;
-  }
   parseCallArgs() {
     const args = [];
     const argumentNames = [];
@@ -37223,9 +37502,9 @@ var Parser = class _Parser {
         pos: at(t)
       };
     }
-    if (isIdentifier(t) && t.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD) {
+    if (isExecutableIdentifier(t) && t.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD) {
       this.next();
-      const classToken = isIdentifier(this.peek()) ? this.next() : null;
+      const classToken = isExecutableIdentifier(this.peek()) ? this.next() : null;
       const className = classToken?.text ?? null;
       const typeArguments = [];
       if (this.eat("operator", "<")) {
@@ -37334,7 +37613,7 @@ var Parser = class _Parser {
       this.expect("punctuation", ")");
       return inner;
     }
-    if (t.text === "base" || isIdentifier(t) || (t.kind === "keyword" || t.kind === "type") && isValidNeoProjectIdentifier(t.text)) {
+    if (t.text === "base" || isExecutableIdentifier(t) || (t.kind === "keyword" || t.kind === "type") && isValidNeoProjectIdentifier(t.text)) {
       this.next();
       return { kind: "ident", name: t.text, pos: at(t) };
     }
@@ -37461,8 +37740,8 @@ var Parser = class _Parser {
         value: null
       });
     }
-    if (isAssignmentOp(this.peek())) {
-      const opTok = this.next();
+    if (isAssignmentOp(this.peekOperator())) {
+      const opTok = this.nextOperator();
       return this.expressionBody(start, expr, {
         op: opTok.text,
         value: this.parseExpr()
@@ -37484,8 +37763,8 @@ var Parser = class _Parser {
    */
   parseLambdaParam() {
     const startPos = at(this.peek());
-    const afterType = this.scanType(this.i);
-    if (afterType !== null && this.tokens[afterType] !== void 0 && isIdentifier(this.tokens[afterType])) {
+    const afterType = scanNeoScriptType(this.tokens, this.i);
+    if (afterType !== null && this.tokens[afterType] !== void 0 && isExecutableIdentifier(this.tokens[afterType])) {
       const type2 = this.parseType();
       const name2 = this.expect("identifier");
       return { type: type2, name: name2.text, pos: startPos };
@@ -37536,17 +37815,17 @@ var Parser = class _Parser {
     return { key, value, pos };
   }
   buildInterpLiteral(token) {
-    const children = token.children ?? [];
+    const children3 = token.children ?? [];
     const parts = [];
     let literalStart = token.start + 2;
-    for (let index = 0; index < children.length; index++) {
-      const open = children[index];
+    for (let index = 0; index < children3.length; index++) {
+      const open = children3[index];
       if (!open?.interpolationHole || open.text !== "{") continue;
       let closeIndex = index + 1;
-      while (closeIndex < children.length && (children[closeIndex]?.interpolationHole !== true || children[closeIndex]?.text !== "}")) {
+      while (closeIndex < children3.length && (children3[closeIndex]?.interpolationHole !== true || children3[closeIndex]?.text !== "}")) {
         closeIndex++;
       }
-      const close = children[closeIndex];
+      const close = children3[closeIndex];
       if (!close) {
         throw new CompileError(
           "Unterminated interpolation expression",
@@ -37554,7 +37833,7 @@ var Parser = class _Parser {
         );
       }
       pushInterpolationText(parts, token, literalStart, open.start);
-      const expressionTokens = children.slice(index + 1, closeIndex).filter((candidate) => candidate.kind !== "comment");
+      const expressionTokens = children3.slice(index + 1, closeIndex).filter((candidate) => candidate.kind !== "comment");
       const inner = new _Parser([
         ...expressionTokens,
         eofToken(close.start, close.range.start)
@@ -37595,6 +37874,12 @@ function asASTBinaryOp(text) {
     case ">":
     case "<=":
     case ">=":
+    case "&":
+    case "|":
+    case "^":
+    case "<<":
+    case ">>":
+    case ">>>":
     case "&&":
     case "||":
       return text;
@@ -37648,13 +37933,10 @@ function at(token) {
   };
 }
 function tokenMatches(token, kind, text) {
-  return (kind === "identifier" ? isIdentifier(token) : token.kind === kind) && (text === void 0 || token.text === text);
+  return (kind === "identifier" ? isExecutableIdentifier(token) : token.kind === kind) && (text === void 0 || token.text === text);
 }
 function isCallArgumentLabelToken(token) {
-  return isIdentifier(token) || token.kind === "keyword" && (token.text === "default" || isValidNeoProjectIdentifier(token.text));
-}
-function isIdentifier(token) {
-  return token.kind === "identifier" || token.kind === "type" && token.text !== "int" && token.text !== "float" && token.text !== "decimal" && token.text !== "bool" && token.text !== "string" && token.text !== "Dictionary" && token.text !== "List" && token.text !== "Set";
+  return isExecutableIdentifier(token) || token.kind === "keyword" && (token.text === "default" || isValidNeoProjectIdentifier(token.text));
 }
 function pushInterpolationText(parts, token, start, end) {
   if (start >= end) return;
@@ -37683,7 +37965,7 @@ function positionWithinToken(token, offset) {
   return { line, column };
 }
 function isAssignmentOp(token) {
-  return token.kind === "operator" && (token.text === "=" || token.text === "+=" || token.text === "-=" || token.text === "*=" || token.text === "/=" || token.text === "%=");
+  return token.kind === "operator" && (token.text === "=" || token.text === "+=" || token.text === "-=" || token.text === "*=" || token.text === "/=" || token.text === "%=" || token.text === "&=" || token.text === "|=" || token.text === "^=" || token.text === "<<=" || token.text === ">>=" || token.text === ">>>=");
 }
 function isIncrementOp(token) {
   return token.kind === "operator" && (token.text === "++" || token.text === "--");
@@ -38383,7 +38665,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
             (candidate) => candidate.id === binding.memberId
           );
           if (argumentMember === void 0) return [];
-          const argumentType = resolveMemberDeclaredTypeInfoInternal(
+          const argumentType2 = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members2,
             nextSeen,
@@ -38391,7 +38673,7 @@ function resolveMemberDeclaredTypeInfoInternal(member, members2, seen, ownerClas
             env,
             isClassConstrained
           );
-          return argumentType === null ? [] : [[genericParamId, argumentType]];
+          return argumentType2 === null ? [] : [[genericParamId, argumentType2]];
         }
       )
     );
@@ -39185,11 +39467,11 @@ function indexChildrenByContainerId(rows) {
   const childrenByContainerId = /* @__PURE__ */ new Map();
   for (const row of rows.values()) {
     if (typeof row.containerId !== "string") continue;
-    const children = childrenByContainerId.get(row.containerId);
-    if (children === void 0) {
+    const children3 = childrenByContainerId.get(row.containerId);
+    if (children3 === void 0) {
       childrenByContainerId.set(row.containerId, [row]);
     } else {
-      children.push(row);
+      children3.push(row);
     }
   }
   return childrenByContainerId;
@@ -39259,10 +39541,10 @@ function derivesContentFromMemberDefault(args) {
 }
 function projectNestedListenerEndpoint(id, descriptor, sourceRoot, targetRoot) {
   const raw = descriptor.sourceValueId ?? `path:${descriptor.memberId}:${descriptor.pathKey}`;
-  const derive = (root, identity) => claimVirtualIdentity({
+  const derive = (root, identity2) => claimVirtualIdentity({
     claimedVirtualIds: /* @__PURE__ */ new Map(),
     instanceRootId: root,
-    rawSourceIdentity: identity,
+    rawSourceIdentity: identity2,
     pathKey: descriptor.pathKey
   }).virtualId;
   if (derive(sourceRoot, raw) === id) return derive(targetRoot, raw);
@@ -39629,9 +39911,9 @@ function resolveVirtualInstanceGraph(args) {
   const locationsById = /* @__PURE__ */ new Map();
   const locationsByPath = /* @__PURE__ */ new Map();
   const childPathsByParentPath = new Map(
-    [...expansion.childPathsByParentPath].map(([path, children]) => [
+    [...expansion.childPathsByParentPath].map(([path, children3]) => [
       path,
-      [...children]
+      [...children3]
     ])
   );
   const visiting = /* @__PURE__ */ new Set();
@@ -39948,9 +40230,9 @@ function resolveVirtualInstanceGraph(args) {
           }
           spans.set(current.path, { start: sequence++, end: 0 });
           pending.push({ path: current.path, exit: true });
-          const children = expansion.childPathsByParentPath.get(current.path) ?? [];
-          for (let i = children.length - 1; i >= 0; i--)
-            pending.push({ path: children[i], exit: false });
+          const children3 = expansion.childPathsByParentPath.get(current.path) ?? [];
+          for (let i = children3.length - 1; i >= 0; i--)
+            pending.push({ path: children3[i], exit: false });
         }
         ancestry = spans;
       }
@@ -44503,6 +44785,27 @@ function indexReferences(tokens, pairs, declarations, contextualKeywords, negati
       }
       continue;
     }
+    if (token.text === "switch" && tokens[index + 1]?.text === "{") {
+      const close = pairs.get(index + 1);
+      if (close !== void 0) {
+        let armStart = index + 2;
+        for (let cursor = armStart; cursor < close; cursor++) {
+          const nestedClose = pairs.get(cursor);
+          if (nestedClose !== void 0 && nestedClose > cursor) {
+            cursor = nestedClose;
+            continue;
+          }
+          if (tokens[cursor]?.text !== ",") continue;
+          const end2 = new Parser(tokens, armStart).typeEnd();
+          if (end2 >= 0 && tokens[end2]?.kind === "identifier" && (tokens[end2 + 1]?.text === "=>" || tokens[end2 + 1]?.text === "when"))
+            patternBindings.add(end2);
+          armStart = cursor + 1;
+        }
+        const end = new Parser(tokens, armStart).typeEnd();
+        if (end >= 0 && tokens[end]?.kind === "identifier" && (tokens[end + 1]?.text === "=>" || tokens[end + 1]?.text === "when"))
+          patternBindings.add(end);
+      }
+    }
     if (token.kind !== "identifier" && token.text !== "base") continue;
     const previous = tokens[index - 1];
     const next = tokens[index + 1];
@@ -44850,6 +45153,500 @@ function analyzeNeoScriptSyntax(source, kind, lexed = lex(source)) {
   return { lexed, parsed: buildNeoScriptEditorIndex(lexed, kind) };
 }
 
+// ../packages/neoscript-language/src/switch-coverage.ts
+var childrenByProject = /* @__PURE__ */ new WeakMap();
+function children(project) {
+  const cached = childrenByProject.get(project);
+  if (cached) return cached;
+  const result = /* @__PURE__ */ new Map();
+  for (const type2 of project.typeById.values()) {
+    if (type2.kind !== "class") continue;
+    for (const base of type2.baseTypeIds ?? []) {
+      const list = result.get(base);
+      if (list) list.push(type2);
+      else result.set(base, [type2]);
+    }
+  }
+  childrenByProject.set(project, result);
+  return result;
+}
+function combine(results) {
+  if (results.includes("mismatch")) return "mismatch";
+  return results.includes("unknown") ? "unknown" : "match";
+}
+function containsParameter(type2) {
+  switch (type2.kind) {
+    case "typeParameter":
+      return true;
+    case "named":
+      return type2.typeArguments?.some(containsParameter) ?? false;
+    case "list":
+    case "set":
+      return containsParameter(type2.elementType);
+    case "dictionary":
+      return containsParameter(type2.keyType) || containsParameter(type2.valueType);
+    case "reference":
+      return containsParameter(type2.target);
+    default:
+      return false;
+  }
+}
+function unify(template, actual, bindings, project) {
+  if (template.kind === "typeParameter") {
+    const previous = bindings.get(template.id);
+    if (template.nullable === true) {
+      if (actual.nullable !== true) return "mismatch";
+      if (!previous) return "unknown";
+      const nullablePrevious = { ...previous, nullable: true };
+      return isNeoScriptTypeAssignable(nullablePrevious, actual, project) && isNeoScriptTypeAssignable(actual, nullablePrevious, project) ? "match" : "mismatch";
+    }
+    if (!previous) {
+      bindings.set(template.id, actual);
+      return "match";
+    }
+    if (isNeoScriptTypeAssignable(previous, actual, project) && isNeoScriptTypeAssignable(actual, previous, project))
+      return "match";
+    return containsParameter(previous) || containsParameter(actual) ? "unknown" : "mismatch";
+  }
+  if (actual.kind === "typeParameter") return "unknown";
+  if (template.kind !== actual.kind) return "mismatch";
+  if (template.nullable === true !== (actual.nullable === true))
+    return "mismatch";
+  if (template.kind === "named" && actual.kind === "named") {
+    if (template.typeId !== actual.typeId) return "mismatch";
+    const left = template.typeArguments ?? [];
+    const right = actual.typeArguments ?? [];
+    if (left.length !== right.length) return "mismatch";
+    return combine(
+      left.map((item, index) => unify(item, right[index], bindings, project))
+    );
+  }
+  if (template.kind === "list" && actual.kind === "list" || template.kind === "set" && actual.kind === "set")
+    return unify(template.elementType, actual.elementType, bindings, project);
+  if (template.kind === "dictionary" && actual.kind === "dictionary")
+    return combine([
+      unify(template.keyType, actual.keyType, bindings, project),
+      unify(template.valueType, actual.valueType, bindings, project)
+    ]);
+  if (template.kind === "reference" && actual.kind === "reference")
+    return unify(template.target, actual.target, bindings, project);
+  return isNeoScriptTypeAssignable(template, actual, project) && isNeoScriptTypeAssignable(actual, template, project) ? "match" : "mismatch";
+}
+function typeShape(type2) {
+  const nullable2 = type2.nullable === true;
+  switch (type2.kind) {
+    case "named":
+      return [
+        type2.kind,
+        type2.typeId,
+        nullable2,
+        (type2.typeArguments ?? []).map(typeShape)
+      ];
+    case "primitive":
+      return [type2.kind, type2.name, nullable2];
+    case "typeParameter":
+      return [type2.kind, type2.id, nullable2];
+    case "list":
+    case "set":
+      return [
+        type2.kind,
+        nullable2,
+        type2.ordered === true,
+        typeShape(type2.elementType)
+      ];
+    case "dictionary":
+      return [
+        type2.kind,
+        nullable2,
+        typeShape(type2.keyType),
+        typeShape(type2.valueType)
+      ];
+    case "reference":
+      return [type2.kind, nullable2, typeShape(type2.target)];
+    case "delegate":
+      return [
+        type2.kind,
+        nullable2,
+        typeShape(type2.returnType),
+        type2.parameterTypes.map(typeShape)
+      ];
+    case "action":
+      return [type2.kind, nullable2, type2.parameterTypes.map(typeShape)];
+  }
+}
+function typeKey(type2) {
+  return JSON.stringify(typeShape(type2));
+}
+var SwitchCoverage = class {
+  constructor(project) {
+    this.project = project;
+  }
+  project;
+  constants = /* @__PURE__ */ new Set();
+  types = /* @__PURE__ */ new Set();
+  compoundPatterns = /* @__PURE__ */ new Map();
+  discarded = false;
+  add(pattern) {
+    if (pattern.kind === "discard") this.discarded = true;
+    else if (pattern.kind === "constant") this.constants.add(pattern.value);
+    else {
+      this.types.add(typeKey(pattern.type));
+      const type2 = pattern.type;
+      const variant2 = type2.kind === "named" && this.project.typeById.get(type2.typeId)?.name === "NeoVariant";
+      if (type2.kind !== "named" || variant2) {
+        const key = variant2 && type2.kind === "named" ? type2.typeId : type2.kind;
+        const bucket = this.compoundPatterns.get(key);
+        if (bucket) bucket.push(type2);
+        else this.compoundPatterns.set(key, [type2]);
+      }
+    }
+  }
+  coversType(input) {
+    if (this.discarded) return true;
+    if (this.types.size === 0) return false;
+    const type2 = { ...input, nullable: false };
+    if (this.types.has(typeKey(type2))) return true;
+    if (type2.kind === "typeParameter") {
+      const bound = neoScriptMemberLookupType(type2);
+      return bound.kind !== "typeParameter" && this.coversType(bound);
+    }
+    if (type2.kind === "named") {
+      for (const ancestor of constructedSupertypes(type2, this.project)) {
+        if (this.types.has(typeKey(ancestor))) return true;
+      }
+      for (const narrowed of Object.values(type2.narrowedInterfaces ?? {})) {
+        if (this.coversType(narrowed)) return true;
+      }
+    }
+    if (type2.kind === "primitive") {
+      return type2.name === "int" && this.types.has(typeKey({ kind: "primitive", name: "float" }));
+    }
+    const bucket = type2.kind === "named" ? type2.typeId : type2.kind;
+    for (const pattern of this.compoundPatterns.get(bucket) ?? []) {
+      if (isNeoScriptTypeAssignable(type2, pattern, this.project)) return true;
+    }
+    if (type2.kind !== "reference") {
+      for (const pattern of this.compoundPatterns.get("reference") ?? []) {
+        if (isNeoScriptTypeAssignable(type2, pattern, this.project)) return true;
+      }
+    }
+    return false;
+  }
+  subsumes(pattern, selector) {
+    if (this.discarded) return true;
+    if (pattern.kind === "discard") return false;
+    if (pattern.kind === "constant")
+      return this.constants.has(pattern.value) || pattern.value !== null && this.coversType(selector);
+    return missingSwitchCases(pattern.type, this, this.project).length === 0;
+  }
+};
+function missingSwitchCases(selector, coverage, project) {
+  if (coverage.discarded) return [];
+  const constants = coverage.constants;
+  const missing = [];
+  if (selector.nullable && !constants.has(null)) missing.push("null");
+  const active = /* @__PURE__ */ new Set();
+  const visit = (input) => {
+    const type2 = { ...neoScriptMemberLookupType(input), nullable: false };
+    if (coverage.coversType(type2)) return;
+    if (type2.kind === "primitive" && type2.name === "bool") {
+      if (!constants.has(false)) missing.push("false");
+      if (!constants.has(true)) missing.push("true");
+      return;
+    }
+    const definition = type2.kind === "named" ? project.typeById.get(type2.typeId) : void 0;
+    if (definition?.kind === "enum") {
+      for (const option of definition.members) {
+        if (!constants.has(option.id))
+          missing.push(`${definition.name}.${option.name}`);
+      }
+      return;
+    }
+    if (type2.kind !== "named" || !definition?.closed || active.has(type2.typeId)) {
+      missing.push(`${formatType(type2, project)} (use a type or '_' fallback)`);
+      return;
+    }
+    active.add(type2.typeId);
+    const descendants = children(project).get(type2.typeId) ?? [];
+    if (descendants.length === 0) missing.push(formatType(type2, project));
+    for (const child of descendants) {
+      const baseArguments = child.supertypeArguments?.[type2.typeId] ?? [];
+      const actualArguments = type2.typeArguments ?? [];
+      const bindings = /* @__PURE__ */ new Map();
+      if (baseArguments.length !== actualArguments.length) {
+        missing.push(formatType(type2, project));
+        continue;
+      }
+      const matchArguments = () => combine(
+        baseArguments.map(
+          (argument2, index) => unify(argument2, actualArguments[index], bindings, project)
+        )
+      );
+      let match = matchArguments();
+      if (match === "unknown") match = matchArguments();
+      if (match !== "match") {
+        if (match === "unknown") missing.push(formatType(type2, project));
+        continue;
+      }
+      const argumentsList2 = [];
+      let nameable = true;
+      for (const parameter3 of child.typeParameters ?? []) {
+        const argument2 = bindings.get(parameter3.id ?? parameter3.name);
+        if (!argument2) {
+          nameable = false;
+          break;
+        }
+        if (parameter3.type.kind === "typeParameter" && parameter3.type.constraint) {
+          const bound = substituteNeoScriptTypeParameters(
+            parameter3.type.constraint,
+            (parameter4) => bindings.get(parameter4.id),
+            project
+          );
+          if (!isNeoScriptTypeAssignable(argument2, bound, project)) {
+            nameable = false;
+            break;
+          }
+        }
+        argumentsList2.push(argument2);
+      }
+      if (!nameable) {
+        missing.push(formatType(type2, project));
+        continue;
+      }
+      visit({
+        kind: "named",
+        typeId: child.id,
+        ...argumentsList2.length ? { typeArguments: argumentsList2 } : {}
+      });
+    }
+    active.delete(type2.typeId);
+  };
+  visit(selector);
+  return [...new Set(missing)];
+}
+
+// ../packages/neoscript-language/src/function-type-inference.ts
+function identity(type2) {
+  const nullable2 = type2.nullable === true ? "?" : "";
+  switch (type2.kind) {
+    case "primitive":
+      return `p:${type2.name}${nullable2}`;
+    case "typeParameter":
+      return `t:${type2.id}${nullable2}`;
+    case "named":
+      return `n:${type2.typeId}<${(type2.typeArguments ?? []).map(identity).join(",")}>${nullable2}`;
+    case "list":
+    case "set":
+      return `${type2.kind}<${identity(type2.elementType)}>${nullable2}`;
+    case "dictionary":
+      return `d<${identity(type2.keyType)},${identity(type2.valueType)}>${nullable2}`;
+    case "reference":
+      return `r<${identity(type2.target)}>${nullable2}`;
+    case "delegate":
+      return `f<${identity(type2.returnType)};${type2.parameterTypes.map(identity).join(",")}>${nullable2}`;
+    case "action":
+      return `a<${type2.parameterTypes.map(identity).join(",")}>${nullable2}`;
+  }
+}
+var FunctionTypeInference = class {
+  constructor(parameters, project) {
+    this.parameters = parameters;
+    this.project = project;
+    parameters.forEach((parameter3, index) => {
+      if (parameter3.type.kind === "typeParameter")
+        this.slots.set(parameter3.type.id, index);
+    });
+    this.bounds = parameters.map(() => /* @__PURE__ */ new Map());
+  }
+  parameters;
+  project;
+  slots = /* @__PURE__ */ new Map();
+  bounds;
+  fixed = /* @__PURE__ */ new Map();
+  bind(type2) {
+    return substituteNeoScriptTypeParameters(
+      type2,
+      (parameter3) => this.fixed.get(parameter3.id),
+      this.project
+    );
+  }
+  unresolved(type2) {
+    const result = /* @__PURE__ */ new Set();
+    const visit = (value) => {
+      if (value.kind === "typeParameter") {
+        const index = this.slots.get(value.id);
+        if (index !== void 0 && !this.fixed.has(value.id)) result.add(index);
+      } else {
+        for (const child of children2(value)) visit(child);
+      }
+    };
+    visit(type2);
+    return result;
+  }
+  get pending() {
+    return this.parameters.flatMap(
+      (parameter3, index) => this.fixed.has(
+        parameter3.type.kind === "typeParameter" ? parameter3.type.id : ""
+      ) ? [] : [index]
+    );
+  }
+  hasBounds(index) {
+    return (this.bounds[index]?.size ?? 0) > 0;
+  }
+  add(actual, pattern, kind = "lower") {
+    if (actual.kind === "primitive" && (actual.name === "null" || actual.name === "unknown" || actual.name === "void"))
+      return;
+    if (pattern.kind === "typeParameter") {
+      const index = this.slots.get(pattern.id);
+      if (index === void 0 || this.fixed.has(pattern.id)) return;
+      const type2 = argumentType(
+        pattern.nullable === true ? { ...actual, nullable: false } : actual
+      );
+      this.bounds[index]?.set(`${kind}:${identity(type2)}`, { type: type2, kind });
+      return;
+    }
+    if (pattern.kind === "named") {
+      const source = actual.kind === "typeParameter" ? actual.constraint : actual;
+      if (source?.kind !== "named") return;
+      const construction = supertypeConstruction(
+        source,
+        pattern.typeId,
+        this.project
+      );
+      pattern.typeArguments?.forEach((expected, index) => {
+        const value = construction?.[index];
+        if (value !== void 0) this.add(value, expected, "exact");
+      });
+      return;
+    }
+    if (pattern.kind === "list" && actual.kind === "list" || pattern.kind === "set" && actual.kind === "set") {
+      this.add(actual.elementType, pattern.elementType, "exact");
+    } else if (pattern.kind === "dictionary" && actual.kind === "dictionary") {
+      this.add(actual.keyType, pattern.keyType, "exact");
+      this.add(actual.valueType, pattern.valueType, "exact");
+    } else if (pattern.kind === "delegate" && actual.kind === "delegate") {
+      this.add(actual.returnType, pattern.returnType, kind);
+      pattern.parameterTypes.forEach((expected, index) => {
+        const value = actual.parameterTypes[index];
+        if (value !== void 0) this.add(value, expected, "exact");
+      });
+    } else if (pattern.kind === "action" && actual.kind === "action") {
+      pattern.parameterTypes.forEach((expected, index) => {
+        const value = actual.parameterTypes[index];
+        if (value !== void 0) this.add(value, expected, "exact");
+      });
+    } else if (pattern.kind === "reference" && actual.kind === "reference") {
+      this.add(actual.target, pattern.target, "exact");
+    }
+  }
+  fix(index) {
+    const parameter3 = this.parameters[index];
+    if (parameter3?.type.kind !== "typeParameter")
+      throw new Error("Missing function type parameter.");
+    const bounds = [...this.bounds[index]?.values() ?? []];
+    if (bounds.length === 0) {
+      if (parameter3.type.defaultType === void 0)
+        return `Cannot infer type argument '${parameter3.name}'; specify it explicitly.`;
+      this.fixed.set(parameter3.type.id, parameter3.type.defaultType);
+      return;
+    }
+    const exact = bounds.find((bound) => bound.kind === "exact");
+    let candidate = exact?.type ?? bounds[0].type;
+    if (!exact) {
+      for (const bound of bounds)
+        if (!isNeoScriptTypeAssignable(bound.type, candidate, this.project))
+          candidate = bound.type;
+    }
+    const key = identity(candidate);
+    const valid = bounds.every(
+      (bound) => bound.kind === "exact" ? identity(bound.type) === key : isNeoScriptTypeAssignable(bound.type, candidate, this.project)
+    );
+    const ambiguous = !exact && bounds.some(
+      (bound) => identity(bound.type) !== key && isNeoScriptTypeAssignable(candidate, bound.type, this.project)
+    );
+    if (!valid || ambiguous)
+      return `Cannot infer type argument '${parameter3.name}' from conflicting types ${[...new Set(bounds.map((bound) => formatType(bound.type, this.project)))].join(", ")}; specify it explicitly.`;
+    this.fixed.set(parameter3.type.id, candidate);
+  }
+  arguments() {
+    return this.parameters.map((parameter3) => this.bind(parameter3.type));
+  }
+};
+function children2(type2) {
+  switch (type2.kind) {
+    case "named":
+      return type2.typeArguments ?? [];
+    case "list":
+    case "set":
+      return [type2.elementType];
+    case "dictionary":
+      return [type2.keyType, type2.valueType];
+    case "reference":
+      return [type2.target];
+    case "delegate":
+      return [...type2.parameterTypes, type2.returnType];
+    case "action":
+      return type2.parameterTypes;
+    default:
+      return [];
+  }
+}
+function argumentType(type2) {
+  const optional2 = type2.nullable === true ? { nullable: true } : {};
+  switch (type2.kind) {
+    case "primitive":
+      return { kind: type2.kind, name: type2.name, ...optional2 };
+    case "typeParameter": {
+      const declared = { ...type2 };
+      delete declared.narrowedInterfaces;
+      return declared;
+    }
+    case "named":
+      return {
+        kind: type2.kind,
+        typeId: type2.typeId,
+        ...type2.typeArguments ? { typeArguments: type2.typeArguments.map(argumentType) } : {},
+        ...optional2
+      };
+    case "list":
+    case "set":
+      return {
+        kind: type2.kind,
+        elementType: argumentType(type2.elementType),
+        ...optional2
+      };
+    case "dictionary":
+      return {
+        kind: type2.kind,
+        keyType: argumentType(type2.keyType),
+        valueType: argumentType(type2.valueType),
+        ...optional2
+      };
+    case "reference":
+      return {
+        kind: type2.kind,
+        target: argumentType(type2.target),
+        ...optional2
+      };
+    case "delegate":
+      return {
+        kind: type2.kind,
+        returnType: argumentType(type2.returnType),
+        parameterTypes: type2.parameterTypes.map(argumentType),
+        ...optional2
+      };
+    case "action":
+      return {
+        kind: type2.kind,
+        parameterTypes: type2.parameterTypes.map(argumentType),
+        ...optional2
+      };
+  }
+}
+function sameInferredType(left, right) {
+  return identity(left) === identity(right);
+}
+
 // ../packages/neoscript-language/src/source-map.ts
 function sourcePositionMapper(source) {
   if (!source?.mapping) return (position) => position;
@@ -45809,6 +46606,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   debugPosition;
   unreachableControlEffectDepth = 0;
   catchBindingCounter = 0;
+  switchExpressionCounter = 0;
   catchContexts = [];
   expectedReturnStack = [];
   controlContexts = [];
@@ -46896,6 +47694,17 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const inference = this.lambdaReturnInference.at(-1);
         const inferring = inference?.depth === this.lambdaDepth;
         const inferExpression = this.options.inferExpressionReturnType && this.lambdaDepth === 0;
+        if (inferring && inference.contextualReturns && !hasIndependentTypeEvidence(statement.expr)) {
+          inference.contextualReturns.push(statement.expr);
+          return {
+            type: "return" /* Return */,
+            pointer: literal(
+              { kind: "primitive", name: "unknown" },
+              null,
+              this.project
+            ).pointer
+          };
+        }
         const value = this.resolveExpression(
           statement.expr,
           scope,
@@ -47461,12 +48270,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     const bindings = [];
-    const capturedTarget = statement.op !== "=" && vectorTypeName(target.type) !== null ? {
+    const capturedTarget = statement.op !== "=" && (vectorTypeName(target.type) !== null || isBitwiseBinaryOperator(statement.op.slice(0, -1))) ? {
       ...target,
-      pointer: this.captureVectorAssignmentTarget(
-        target.pointer,
-        bindings
-      )
+      pointer: this.captureAssignmentTarget(target.pointer, bindings)
     } : target;
     let value;
     if (reference?.value !== void 0) {
@@ -47550,7 +48356,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pointer: value.pointer
     };
   }
-  captureVectorAssignmentTarget(pointer, bindings) {
+  captureAssignmentTarget(pointer, bindings) {
     const capture = (value) => {
       if (value.type === "value" /* Value */) return value;
       const id = `$assignment_${this.assignmentBindingCounter++}`;
@@ -47639,6 +48445,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return { target: layer, value: valueAt(layer.type), through };
   }
   resolveReferenceAssignmentValue(expression, scope, storageType) {
+    if (expression.kind === "switchExpression") {
+      return this.resolveSwitchExpression(
+        expression,
+        scope,
+        void 0,
+        storageType
+      );
+    }
     if (expression.kind === "conditional") {
       return this.resolveConditionalExpression(
         expression,
@@ -47834,7 +48648,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     ).type;
   }
   resolveCompoundAssignment(operation, valueAst, target, scope, pos) {
-    const binaryOperation = operation === "++" ? "+" : operation === "--" ? "-" : operation.slice(0, 1);
+    const binaryOperation = operation === "++" ? "+" : operation === "--" ? "-" : operation.slice(0, -1);
     const right = operation === "++" || operation === "--" ? literal({ kind: "primitive", name: "int" }, 1) : valueAst ? this.resolveExpression(valueAst, scope, target.type) : null;
     if (!right) {
       throw new CompileError(
@@ -48773,6 +49587,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           );
           return this.booleanComparison("==", bool, falseValue, expression.pos);
         }
+        if (expression.op === "~") {
+          this.requireBitwiseInt(operand, expression.pos);
+          return bitwiseIntrinsic("not", [operand.pointer]);
+        }
         const operandVector = vectorTypeName(operand.type);
         if (operandVector !== null && !isNullable(operand.type)) {
           return vectorIntrinsic(
@@ -48812,6 +49630,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       case "coalesce":
         return this.resolveCoalesceExpression(expression, scope, expected);
+      case "switchExpression":
+        return this.resolveSwitchExpression(expression, scope, expected);
       case "conditional":
         return this.resolveConditionalExpression(expression, scope, expected);
       case "is": {
@@ -48862,7 +49682,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
     }
   }
-  resolveDelegateLambda(ast, expected, outerScope) {
+  resolveDelegateLambda(ast, expected, outerScope, inferReturn = false) {
     if (ast.params.length !== expected.parameterTypes.length) {
       throw new CompileError(
         `Delegate lambda expects ${expected.parameterTypes.length} parameter${expected.parameterTypes.length === 1 ? "" : "s"}, got ${ast.params.length}.`,
@@ -48916,6 +49736,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           "runtime" /* Runtime */
         )
       );
+      this.options.onFlowScope?.({
+        name: parameter3.name,
+        position: parameter3.pos,
+        type: declared,
+        bindings: scope.patternBindings
+      });
       return item;
     });
     const captureContext = {
@@ -48933,6 +49759,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     });
     this.lambdaDepth++;
     this.expectedReturnStack.push(expected.returnType);
+    const inference = {
+      depth: this.lambdaDepth,
+      contextualReturns: [],
+      returns: []
+    };
+    if (inferReturn) this.lambdaReturnInference.push(inference);
     try {
       const returnsVoid = isVoid(expected.returnType);
       const instructions = this.resolveStatements(
@@ -48945,6 +49777,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           ast.pos
         );
       }
+      if (inferReturn) {
+        let inferred;
+        for (const returned of inference.returns) {
+          const joined = inferred === void 0 ? returned.value.type : commonNeoScriptAssignableType(
+            inferred,
+            returned.value.type,
+            this.project
+          );
+          if (joined === null)
+            throw new CompileError(
+              "Lambda returns incompatible types for function type inference.",
+              returned.pos
+            );
+          inferred = joined;
+        }
+        expected = {
+          ...expected,
+          returnType: inferred ?? { kind: "primitive", name: "unknown" }
+        };
+      }
       const action = {
         compilerRevision: NEOSCRIPT_COMPILER_REVISION,
         source: {
@@ -48977,19 +49829,24 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             captures: captureContext.captures.map((capture) => capture.source),
             ...code === void 0 ? {} : { code }
           },
-          type: expected
+          type: expected,
+          needsReturnContext: inference.contextualReturns.length > 0
         };
       }
-      return literal(
-        expected,
-        code === void 0 ? { action } : { code, action },
-        this.project
-      );
+      return {
+        ...literal(
+          expected,
+          code === void 0 ? { action } : { code, action },
+          this.project
+        ),
+        needsReturnContext: inference.contextualReturns.length > 0
+      };
     } finally {
       this.expectedReturnStack.pop();
       this.lambdaDepth--;
       this.functionControlBoundaries.pop();
       this.delegateCaptureContexts.pop();
+      if (inferReturn) this.lambdaReturnInference.pop();
     }
   }
   delegateLambdaSource(ast) {
@@ -49143,7 +50000,9 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
   }
   /** Derives the exact expected delegate signature for a test mock target. */
-  inferDelegateMethodGroupType(expression, scope) {
+  inferDelegateMethodGroupType(expression, scope, mockTarget = true) {
+    if (expression.kind === "ident" && scope.lookup(expression.name))
+      return null;
     let symbol;
     let owner;
     let receiverType;
@@ -49181,7 +50040,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     const mockArguments = methodGroupTypeArguments(
       symbol,
-      true,
+      mockTarget,
       expression.pos
     );
     const receiver = callReceiver(receiverType, owner);
@@ -49216,6 +50075,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     });
     if (pointers.length === 0) return literal(stringType, "");
+    if (parts[0]?.kind !== "lit")
+      pointers.unshift(literal(stringType, "").pointer);
     return {
       pointer: {
         type: "operation" /* Operation */,
@@ -52507,12 +53368,33 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * cases are unreachable unless the host injected the test prelude.
    */
   resolveCallableArguments(symbol, receiver, argumentsList2, scope, pos, typeArguments) {
+    const inferred = typeArguments === void 0 && symbol.typeParameters?.length ? this.inferFunctionTypeArguments(
+      symbol,
+      receiver,
+      argumentsList2,
+      scope,
+      pos
+    ) : void 0;
     const signature = this.callableSignatureForReceiver(
       symbol,
       receiver,
       typeArguments,
-      pos
-    );
+      pos,
+      inferred?.typeArguments
+    );
+    if (signature.typeArguments.length > 0)
+      this.options.onCallResolved?.(pos, {
+        ...symbol,
+        type: signature.returnType,
+        returnType: signature.returnType,
+        parameters: signature.parameters,
+        typeParameters: (symbol.typeParameters ?? []).map(
+          (parameter3, index) => ({
+            ...parameter3,
+            type: requiredAt(signature.typeArguments, index)
+          })
+        )
+      });
     const wireTypeArguments = signature.typeArguments.length ? {
       typeArguments: signature.typeArguments.map(
         (argument2) => toWireType(argument2, this.project)
@@ -52719,7 +53601,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           receiver.expression.type
         ) ?? expected;
       }
-      const resolved = isUnknown(expected) ? this.resolveExpression(argument2, scope) : this.resolveExpression(argument2, scope, expected);
+      const cached = inferred?.resolved.get(argument2);
+      const resolved = cached && (sameInferredType(cached.type, expected) || cached.pointer.type === "callFunction" /* CallFunction */) ? cached : isUnknown(expected) ? this.resolveExpression(argument2, scope) : this.resolveExpression(argument2, scope, expected);
       if (!isUnknown(expected)) {
         this.requireReferenceArgument(
           resolved.type,
@@ -52749,13 +53632,134 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     return { args, returnType: signature.returnType, ...wireTypeArguments };
   }
-  callableSignatureForReceiver(symbol, receiver, typeArguments, pos) {
+  inferFunctionTypeArguments(symbol, receiver, argumentsList2, scope, pos) {
+    const inference = new FunctionTypeInference(
+      symbol.typeParameters ?? [],
+      this.project
+    );
+    const bound = this.genericCallReceiver(receiver);
+    const parameters = (symbol.parameters ?? []).map(
+      (parameter3) => substituteCallTypeArguments(
+        parameter3.type,
+        [],
+        void 0,
+        bound,
+        this.project
+      )
+    );
+    const callbacks = [];
+    const probe = new Scope(scope);
+    const resolvedArguments = /* @__PURE__ */ new Map();
+    argumentsList2.forEach((argument2, index) => {
+      const pattern = parameters[index];
+      if (pattern === void 0) return;
+      if (inference.unresolved(pattern).size === 0) return;
+      if (argument2.kind === "lambda" && pattern.kind === "delegate") {
+        argument2.params.forEach((parameter3, parameterIndex) => {
+          const expected = pattern.parameterTypes[parameterIndex];
+          if (parameter3.type && expected)
+            inference.add(this.resolveType(parameter3.type), expected, "exact");
+        });
+        callbacks.push({ ast: argument2, type: pattern });
+        return;
+      }
+      if (!hasIndependentTypeEvidence(argument2)) return;
+      const method2 = pattern.kind === "delegate" ? this.inferDelegateMethodGroupType(argument2, probe, false) : null;
+      if (method2 !== null) inference.add(method2, pattern);
+      else {
+        const resolved = this.resolveExpression(argument2, probe);
+        resolvedArguments.set(argument2, resolved);
+        inference.add(resolved.type, pattern);
+      }
+    });
+    while (inference.pending.length > 0) {
+      for (let index = callbacks.length - 1; index >= 0; index--) {
+        const callback = callbacks[index];
+        if (callback.type.parameterTypes.some(
+          (type2) => inference.unresolved(type2).size > 0
+        ))
+          continue;
+        if (inference.unresolved(callback.type.returnType).size === 0) {
+          callbacks.splice(index, 1);
+          continue;
+        }
+        const inputs = callback.type.parameterTypes.map(
+          (type2) => inference.bind(type2)
+        );
+        const resolved = this.resolveDelegateLambda(
+          callback.ast,
+          {
+            kind: "delegate",
+            parameterTypes: inputs,
+            returnType: { kind: "primitive", name: "unknown" }
+          },
+          probe,
+          true
+        );
+        if (resolved.type.kind === "delegate")
+          inference.add(resolved.type.returnType, callback.type.returnType);
+        if (!resolved.needsReturnContext)
+          resolvedArguments.set(callback.ast, resolved);
+        callbacks.splice(index, 1);
+      }
+      const dependencies = /* @__PURE__ */ new Map();
+      const producers = /* @__PURE__ */ new Set();
+      for (const callback of callbacks) {
+        const inputs = new Set(
+          callback.type.parameterTypes.flatMap((type2) => [
+            ...inference.unresolved(type2)
+          ])
+        );
+        for (const output of inference.unresolved(callback.type.returnType)) {
+          producers.add(output);
+          const entry = dependencies.get(output) ?? /* @__PURE__ */ new Set();
+          for (const input of inputs) entry.add(input);
+          dependencies.set(output, entry);
+        }
+      }
+      const pending = inference.pending;
+      let fix = pending.filter(
+        (index) => inference.hasBounds(index) && !dependencies.get(index)?.size
+      );
+      if (fix.length === 0) {
+        const dependedOn = new Set(
+          [...dependencies.values()].flatMap((entry) => [...entry])
+        );
+        fix = pending.filter(
+          (index) => inference.hasBounds(index) && dependedOn.has(index)
+        );
+      }
+      if (fix.length === 0)
+        fix = pending.filter((index) => {
+          const type2 = inference.parameters[index]?.type;
+          return !inference.hasBounds(index) && !producers.has(index) && type2?.kind === "typeParameter" && type2.defaultType !== void 0;
+        });
+      if (fix.length === 0) {
+        const names = pending.map((index) => `'${inference.parameters[index]?.name}'`).join(", ");
+        throw new CompileError(
+          `Cannot infer type argument ${names} for '${symbol.name}'; specify it explicitly.`,
+          pos
+        );
+      }
+      for (const index of fix) {
+        const error = inference.fix(index);
+        if (error)
+          throw new CompileError(`${error} Function '${symbol.name}'.`, pos);
+      }
+    }
+    return {
+      typeArguments: inference.arguments(),
+      resolved: resolvedArguments
+    };
+  }
+  callableSignatureForReceiver(symbol, receiver, typeArguments, pos, inferred) {
     const bound = this.genericCallReceiver(receiver);
     const functionArguments = this.resolveFunctionTypeArguments(
       symbol,
       typeArguments,
       (type2) => substituteCallTypeArguments(type2, [], void 0, bound, this.project),
-      pos
+      pos,
+      inferred
     );
     const bind = (type2) => substituteCallTypeArguments(
       type2,
@@ -52789,7 +53793,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * arguments, then defaults. Each written argument is non-nullable and
    * satisfies its param's constraint.
    */
-  resolveFunctionTypeArguments(symbol, typeArguments, substitute, pos) {
+  resolveFunctionTypeArguments(symbol, typeArguments, substitute, pos, inferred) {
     const parameters = symbol.typeParameters ?? [];
     if (parameters.length === 0) {
       if (typeArguments === void 0) return [];
@@ -52813,31 +53817,32 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
       const authored = written[index];
-      if (authored === void 0) {
+      if (authored === void 0 && inferred?.[index] === void 0) {
         if (declared.defaultType !== void 0) return declared.defaultType;
         throw new CompileError(
           `'${symbol.name}' needs a type argument for '${parameter3.name}'.`,
           pos
         );
       }
-      const argument2 = this.resolveType(authored);
+      const argument2 = authored === void 0 ? requiredAt(inferred ?? [], index) : this.resolveType(authored);
+      const argumentPosition = authored?.pos ?? pos;
       if (argument2.nullable === true) {
         throw new CompileError(
           `Type argument '${this.describe(argument2)}' cannot be nullable; declare '${parameter3.name}?' in the signature instead.`,
-          authored.pos
+          argumentPosition
         );
       }
       if (symbol.native === true && !symbol.id.startsWith(SYSTEM_RECORD_ID_PREFIX2) && argument2.kind === "named" && (argument2.typeArguments?.length ?? 0) > 0) {
         throw new CompileError(
           `Native function '${symbol.name}' takes a non-generic class type argument; '${this.describe(argument2)}' is generic.`,
-          authored.pos
+          argumentPosition
         );
       }
       const constraint = declared.constraint === void 0 ? void 0 : substitute(declared.constraint);
       if (constraint !== void 0 && !isNeoScriptTypeAssignable(argument2, constraint, this.project)) {
         throw new CompileError(
           `Type argument '${this.describe(argument2)}' does not satisfy '${parameter3.name} extends ${this.describe(constraint)}' on '${symbol.name}'.`,
-          authored.pos
+          argumentPosition
         );
       }
       return argument2;
@@ -54754,6 +55759,210 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       type: resultType
     };
   }
+  resolveSwitchExpression(expression, scope, expected, assignmentType) {
+    const selector = this.resolveExpression(expression.selector, scope);
+    const selectorId = `__switch:${this.switchExpressionCounter++}`;
+    if (expression.arms.length === 0)
+      throw new CompileError(
+        "A switch expression needs at least one arm.",
+        expression.pos
+      );
+    const coverage = new SwitchCoverage(this.project);
+    const arms = [];
+    for (let index = 0; index < expression.arms.length; index++) {
+      const source = expression.arms[index];
+      const armScope = new Scope(scope);
+      let pattern;
+      let covered;
+      if (source.pattern.kind === "discard") {
+        pattern = { kind: "discard" };
+        covered = pattern;
+      } else if (source.pattern.kind === "constant") {
+        const constant = this.resolveSwitchCaseLabel(
+          source.pattern.expression,
+          selector.type,
+          scope
+        );
+        pattern = { kind: "constant", constant };
+        covered = {
+          kind: "constant",
+          value: Array.isArray(constant.value) ? constant.value[0] : constant.value
+        };
+      } else {
+        const check2 = this.resolveType(source.pattern.type);
+        if (isNullable(check2))
+          throw new CompileError(
+            "A switch type pattern must be non-nullable; use a null arm separately.",
+            source.pos
+          );
+        if (!typesOverlap(selector.type, check2, this.project))
+          throw new CompileError(
+            `Pattern ${this.describe(check2)} cannot match ${this.describe(selector.type)}.`,
+            source.pos
+          );
+        const bindingId = `${selectorId}_arm_${index}`;
+        pattern = { kind: "type", checkType: toWireType(check2, this.project) };
+        covered = { kind: "type", type: check2 };
+        if (source.pattern.bindingName) {
+          this.assertLocalNameAvailable(
+            source.pattern.bindingName,
+            scope,
+            source.pos
+          );
+          pattern = { ...pattern, bindingId };
+          armScope.definePattern({
+            name: source.pattern.bindingName,
+            type: check2,
+            variableId: bindingId,
+            pointer: {
+              type: "variable" /* Variable */,
+              variableId: bindingId
+            },
+            ...selector.writability ? { writability: selector.writability } : {},
+            ...selector.writeRoot ? { writeRoot: selector.writeRoot } : {}
+          });
+        }
+      }
+      if (coverage.subsumes(covered, selector.type))
+        throw new CompileError(
+          "This switch arm is already covered by earlier arms.",
+          source.pos
+        );
+      if (source.guard?.kind === "litBool" && !source.guard.value)
+        throw new CompileError(
+          "A switch arm with a false guard is unreachable.",
+          source.guard.pos
+        );
+      const guard = source.guard ? this.resolveExpression(source.guard, armScope) : void 0;
+      if (guard)
+        this.requireAssignable(
+          guard.type,
+          { kind: "primitive", name: "bool" },
+          source.guard.pos,
+          "switch guard"
+        );
+      if (source.guard)
+        this.applyFactsToScope(
+          armScope,
+          this.conditionFacts(source.guard, armScope, true)
+        );
+      arms.push({
+        source,
+        scope: armScope,
+        pattern,
+        ...guard ? { guard: guard.pointer } : {}
+      });
+      if (!source.guard || source.guard.kind === "litBool" && source.guard.value)
+        coverage.add(covered);
+    }
+    const missing = missingSwitchCases(selector.type, coverage, this.project);
+    if (missing.length)
+      throw new CompileError(
+        `Switch expression over ${this.describe(selector.type)} is not exhaustive. Missing: ${missing.join(", ")}.`,
+        expression.pos
+      );
+    let assignmentResults;
+    if (assignmentType) {
+      assignmentResults = arms.map(
+        (arm) => this.resolveReferenceAssignmentValue(
+          arm.source.value,
+          arm.scope,
+          assignmentType
+        )
+      );
+      let common = assignmentResults[0].type;
+      for (const value of assignmentResults.slice(1)) {
+        if (!common) break;
+        if (isNull(value.type)) common = { ...common, nullable: true };
+        else if (isNull(common)) common = { ...value.type, nullable: true };
+        else
+          common = commonNeoScriptAssignableType(
+            common,
+            value.type,
+            this.project
+          );
+      }
+      if (common) expected = common;
+      else {
+        let layer = assignmentType;
+        while (true) {
+          const atLayer = assignmentResults.map(
+            (value) => this.readReferences(value, layer)
+          );
+          if (atLayer.every(
+            (value) => isNeoScriptTypeAssignable(value.type, layer, this.project)
+          )) {
+            assignmentResults = atLayer;
+            expected = layer;
+            break;
+          }
+          if (layer.kind !== "reference") {
+            expected = layer;
+            break;
+          }
+          layer = layer.target;
+        }
+      }
+    }
+    let resultType = expected;
+    const inferredResults = /* @__PURE__ */ new Map();
+    if (!resultType) {
+      for (const arm of arms) {
+        if (!hasIndependentTypeEvidence(arm.source.value)) continue;
+        const resolved = this.resolveExpression(arm.source.value, arm.scope);
+        inferredResults.set(arm.source.value, resolved);
+        const common = resultType ? commonNeoScriptAssignableType(
+          resultType,
+          resolved.type,
+          this.project
+        ) : resolved.type;
+        if (!common)
+          throw new CompileError(
+            "Switch results have no common assignable type; specify a target type.",
+            arm.source.value.pos
+          );
+        resultType = common;
+      }
+      if (resultType && arms.some(
+        (arm) => !inferredResults.has(arm.source.value) && hasNullResult(arm.source.value)
+      ))
+        resultType = { ...resultType, nullable: true };
+    }
+    if (!resultType)
+      throw new CompileError(
+        "Cannot infer switch result type; specify a target type.",
+        expression.pos
+      );
+    if (resultType.kind === "primitive" && resultType.name === "void")
+      throw new CompileError(
+        "A switch expression cannot return void.",
+        expression.pos
+      );
+    const compiled = arms.map((arm, index) => {
+      const value = assignmentResults?.[index] ?? inferredResults.get(arm.source.value) ?? this.resolveExpression(arm.source.value, arm.scope, resultType);
+      this.requireAssignable(
+        value.type,
+        resultType,
+        arm.source.value.pos,
+        "switch result"
+      );
+      return {
+        pattern: arm.pattern,
+        ...arm.guard ? { guard: arm.guard } : {},
+        value: value.pointer
+      };
+    });
+    return {
+      pointer: {
+        type: "switchExpression" /* SwitchExpression */,
+        selectorTypeInfo: toWireType(selector.type, this.project),
+        selector: selector.pointer,
+        selectorId,
+        arms: compiled
+      },
+      type: resultType
+    };
+  }
   resolveConditionalExpression(expression, scope, expected, assignmentType) {
     const condition = this.toBool(
       this.resolveExpression(expression.condition, scope),
@@ -54916,6 +56125,18 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     return this.resolveBinaryValues(expression.op, left, right, expression.pos);
   }
+  requireBitwiseInt(value, pos) {
+    if (!isPrimitive(value.type, "int"))
+      throw new CompileError(
+        `Bitwise operators require int operands; got ${this.describe(value.type)}.`,
+        pos
+      );
+    if (isNullable(value.type))
+      throw new CompileError(
+        "Bitwise operators require non-optional int operands.",
+        pos
+      );
+  }
   resolveBinaryValues(operator, left, right, pos) {
     if (isNullable(left.type) || isNullable(right.type)) {
       throw new CompileError(
@@ -54923,6 +56144,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
+    if (isBitwiseBinaryOperator(operator)) {
+      this.requireBitwiseInt(left, pos);
+      this.requireBitwiseInt(right, pos);
+      return bitwiseIntrinsic(BITWISE_BINARY_OPERATORS[operator], [
+        left.pointer,
+        right.pointer
+      ]);
+    }
     let result;
     if (operator === "+" && (isPrimitive(left.type, "string") || isPrimitive(right.type, "string"))) {
       result = { kind: "primitive", name: "string" };
@@ -56266,6 +57495,19 @@ function collectAssignedPathsInExpression(expression, roots, locals, flowCache)
         flowCache
       );
       return;
+    case "switchExpression":
+      collectAssignedPathsInExpression(
+        expression.selector,
+        roots,
+        locals,
+        flowCache
+      );
+      for (const arm of expression.arms) {
+        if (arm.guard)
+          collectAssignedPathsInExpression(arm.guard, roots, locals, flowCache);
+        collectAssignedPathsInExpression(arm.value, roots, locals, flowCache);
+      }
+      return;
     case "conditional":
       collectAssignedPathsInExpression(
         expression.condition,
@@ -56982,6 +58224,12 @@ function comparisonOperator(operator) {
 }
 function assignmentOperator(operator) {
   switch (operator) {
+    case "&=":
+    case "|=":
+    case "^=":
+    case "<<=":
+    case ">>=":
+    case ">>>=":
     case "=":
       return "=" /* Assign */;
     case "+=":
@@ -57493,6 +58741,71 @@ function callReceiver(receiverType, declaring) {
   if (declaring === void 0) return void 0;
   return { type: receiverType, declaring };
 }
+function hasNullResult(expression) {
+  switch (expression.kind) {
+    case "litNull":
+      return true;
+    case "conditional":
+      return hasNullResult(expression.whenTrue) || hasNullResult(expression.whenFalse);
+    case "switchExpression":
+      return expression.arms.some((arm) => hasNullResult(arm.value));
+    case "coalesce":
+      return hasNullResult(expression.right);
+    default:
+      return false;
+  }
+}
+function hasIndependentTypeEvidence(expression) {
+  switch (expression.kind) {
+    case "litNull":
+    case "contextualEnum":
+    case "lambda":
+      return false;
+    case "new":
+      return expression.className !== null;
+    case "conditional":
+      return hasIndependentTypeEvidence(
+        expression.whenTrue.kind === "litNull" || expression.whenTrue.kind === "contextualEnum" ? expression.whenFalse : expression.whenTrue
+      );
+    case "coalesce":
+      return hasIndependentTypeEvidence(
+        expression.left.kind === "litNull" ? expression.right : expression.left
+      );
+    case "switchExpression":
+      return expression.arms.some(
+        (arm) => hasIndependentTypeEvidence(arm.value)
+      );
+    case "litList":
+      return independentlyTypedElements(expression.elements);
+    case "litDict":
+      return independentlyTypedElements(
+        expression.entries.flatMap((entry) => [entry.key, entry.value])
+      );
+    default:
+      return true;
+  }
+}
+function independentlyTypedElements(expressions) {
+  let hasEvidence = false;
+  for (const expression of expressions) {
+    if (expression.kind === "litNull") continue;
+    if (!hasIndependentTypeEvidence(expression)) return false;
+    hasEvidence = true;
+  }
+  return hasEvidence;
+}
+function bitwiseIntrinsic(op, argPointers) {
+  return {
+    pointer: {
+      type: "function" /* Function */,
+      function: {
+        type: "bitwiseOp" /* BitwiseOp */,
+        info: { op, argPointers }
+      }
+    },
+    type: { kind: "primitive", name: "int" }
+  };
+}
 
 // ../packages/neoscript-language/src/map-ir.ts
 function mapNeoScriptIR(root, visitor) {
@@ -57586,6 +58899,7 @@ function compileNeoScriptStrict(document2, context, options = {}) {
       {
         source: options.source,
         onFlowScope: options.onFlowScope,
+        onCallResolved: options.onCallResolved,
         sourceUri: document2.uri,
         inferExpressionReturnType: options.inferExpressionReturnType
       }
@@ -57661,7 +58975,8 @@ function compileUnit(syntax, unit, context, label, projectIndex, options = {}) {
     return attachDependencyManifest(
       new StrictNeoScriptResolver(context, indexedProject, syntax, {
         source: options.source,
-        onFlowScope: options.onFlowScope
+        onFlowScope: options.onFlowScope,
+        onCallResolved: options.onCallResolved
       }).compile(ast),
       syntax,
       indexedProject,
@@ -58245,7 +59560,8 @@ function schemaClass(value, environment, field) {
       environment,
       field
     ),
-    ...value.declarationModifier === "abstract" ? { abstract: true } : {},
+    ...value.declarationModifier === "abstract" || value.declarationModifier === "closed" ? { abstract: true } : {},
+    ...value.declarationModifier === "closed" ? { closed: true } : {},
     ...value.declarationModifier === "sealed" ? { sealed: true } : {},
     ...allowedStorageField(resolvedAllowedStorage(id, environment)),
     ...sourceLocation(value.source, environment, `${field}.source`),
@@ -60426,6 +61742,7 @@ function classToLanguageType(schemaClass2, context) {
     ...schemaClass2.docsText ? { documentation: schemaClass2.docsText } : {},
     kind: "class",
     abstract: isAbstractClass(schemaClass2),
+    closed: isClosedHierarchyClass(schemaClass2),
     ...allowedStorageField2(
       resolveAllowedStorage(schemaClass2.id, context.vm.classes)
     ),
@@ -62110,9 +63427,9 @@ function compileStrict(code, context, sourceInfo, inferExpressionReturnType = fa
 function compilationProjectIdentity(project) {
   const cached = neoScriptProjectIdentityCache.get(project);
   if (cached !== void 0) return cached;
-  const identity = nextNeoScriptProjectIdentity++;
-  neoScriptProjectIdentityCache.set(project, identity);
-  return identity;
+  const identity2 = nextNeoScriptProjectIdentity++;
+  neoScriptProjectIdentityCache.set(project, identity2);
+  return identity2;
 }
 function compilationProjectIndex(project) {
   return cachedProjectIndex(project);
@@ -65669,7 +66986,8 @@ var COLUMN_OVERFLOW_KINDS = [
 var CLASS_MODIFIER_KINDS = [
   0 /* Open */,
   1 /* Abstract */,
-  2 /* Sealed */
+  2 /* Sealed */,
+  3 /* Closed */
 ];
 var CLASS_VISIBILITY_KINDS = [
   0 /* Visible */,
@@ -66117,12 +67435,12 @@ function createGenerationContext(exportData, diagnostics, docs = EMPTY_UNITY_COD
   const dialogueGroupsByParent = /* @__PURE__ */ new Map();
   for (const group of dialogueGroups) {
     const parentId = group.parentDialogueGroupId ?? null;
-    let children = dialogueGroupsByParent.get(parentId);
-    if (children === void 0) {
-      children = [];
-      dialogueGroupsByParent.set(parentId, children);
+    let children3 = dialogueGroupsByParent.get(parentId);
+    if (children3 === void 0) {
+      children3 = [];
+      dialogueGroupsByParent.set(parentId, children3);
     }
-    children.push(group);
+    children3.push(group);
   }
   const projectClassName = toCSharpTypeName(
     `${exportData.project.name}Neo`,
@@ -67211,28 +68529,28 @@ function csharpDelegateType(ctx, member, genericBindingSaved, genericEnv) {
   if (returnType === null) return null;
   const argumentTypes = [];
   for (const argument2 of member.argumentTypes) {
-    const argumentType = csharpFunctionTypeInfoValueType(
+    const argumentType2 = csharpFunctionTypeInfoValueType(
       ctx,
       argument2,
       genericBindingSaved,
       genericEnv
     );
-    if (argumentType === null) return null;
-    argumentTypes.push(argumentType);
+    if (argumentType2 === null) return null;
+    argumentTypes.push(argumentType2);
   }
   return `NeoDelegate<${[returnType, ...argumentTypes].join(", ")}>`;
 }
 function csharpActionType(ctx, member, genericBindingSaved, genericEnv) {
   const argumentTypes = [];
   for (const argument2 of member.argumentTypes) {
-    const argumentType = csharpFunctionTypeInfoValueType(
+    const argumentType2 = csharpFunctionTypeInfoValueType(
       ctx,
       argument2,
       genericBindingSaved,
       genericEnv
     );
-    if (argumentType === null) return null;
-    argumentTypes.push(argumentType);
+    if (argumentType2 === null) return null;
+    argumentTypes.push(argumentType2);
   }
   if (argumentTypes.length === 0) return "NeoAction";
   return `NeoAction<${argumentTypes.join(", ")}>`;
@@ -68284,6 +69602,36 @@ function pointerSource(ctx, pointer, variables, visitedGetterMemberIds) {
         variables,
         visitedGetterMemberIds
       );
+    case "switchExpression" /* switchExpression */: {
+      const selector = pointerSource(
+        ctx,
+        pointer.selector,
+        variables,
+        visitedGetterMemberIds
+      );
+      const sources2 = pointer.arms.map((arm) => {
+        const armVariables = new Map(variables);
+        armVariables.set(pointer.selectorId, selector);
+        if (arm.pattern.kind === "type" && arm.pattern.bindingId)
+          armVariables.set(arm.pattern.bindingId, selector);
+        if (arm.guard)
+          visitPointerPatternBindings(
+            arm.guard,
+            (id, value) => armVariables.set(
+              id,
+              pointerSource(ctx, value, armVariables, visitedGetterMemberIds)
+            )
+          );
+        return pointerSource(
+          ctx,
+          arm.value,
+          armVariables,
+          visitedGetterMemberIds
+        );
+      });
+      const first = sources2[0];
+      return first && sources2.every((source) => source.ownership === first.ownership) ? first : unknownSource();
+    }
     case "conditional" /* conditional */: {
       visitPointerPatternBindings(
         pointer.condition,
@@ -73383,7 +74731,7 @@ function schemaClassFromDocument(record4, context) {
     ...optionalDocsTextProperty(data.docsText, record4),
     declarationModifier: ordinalValue(
       data.modifier ?? 0,
-      ["concrete", "abstract", "sealed"],
+      ["concrete", "abstract", "sealed", "closed"],
       record4,
       "modifier"
     ),
@@ -73433,7 +74781,7 @@ function schemaClassToDocument(schemaClass2) {
       schemaClass2.implementsInterfaceArguments
     ),
     uiVisibility: schemaClass2.hiddenInMemberSelector ? 1 : void 0,
-    modifier: schemaClass2.declarationModifier === "abstract" ? 1 : schemaClass2.declarationModifier === "sealed" ? 2 : void 0,
+    modifier: { concrete: void 0, abstract: 1, sealed: 2, closed: 3 }[schemaClass2.declarationModifier],
     system: systemToDocument(schemaClass2.system),
     allowedStorage: schemaClass2.allowedStorage === null ? void 0 : CLASS_ALLOWED_STORAGE.indexOf(schemaClass2.allowedStorage),
     allowedStorageKeys: schemaClass2.allowedStorageKeys,