@neocompose/cli 0.84.3 → 0.84.5

package/dist/test-worker.mjs

@@ -3302,14 +3302,14 @@ function isNSFunctionContains(value) {
   if (v?.type !== "contains" /* contains */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionIndexOf(value) {
   const v = value;
   if (v?.type !== "indexOf" /* indexOf */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 var NS_STRING_OPS = [
   "toLower",
@@ -3483,7 +3483,7 @@ function isNSFunctionCollectionQuery(value) {
     case "Reverse":
       return true;
     case "ToSet":
-      return info.reference === void 0 || info.reference === true;
+      return (info.reference === void 0 || info.reference === true) && (info.decimalEntries === void 0 || info.decimalEntries === true);
     default:
       return false;
   }
@@ -15963,13 +15963,22 @@ function neoScriptMemberLookupType(type) {
     nullable2 ||= current.constraint.nullable === true;
     current = current.constraint;
   }
+  if (current.kind === "named" && type.narrowedInterfaces !== void 0) {
+    current = {
+      ...current,
+      narrowedInterfaces: {
+        ...current.narrowedInterfaces,
+        ...type.narrowedInterfaces
+      }
+    };
+  }
   return nullable2 && current.nullable !== true ? { ...current, nullable: true } : current;
 }
 function neoScriptMemberReceiverType(type, memberName, project) {
   const primary = neoScriptMemberLookupType(type);
-  if (primary.kind !== "named" || primary.narrowedInterfaces === void 0)
+  if (primary.kind !== "named" && primary.kind !== "typeParameter" || primary.narrowedInterfaces === void 0)
     return primary;
-  const declaration = project.typeById.get(primary.typeId);
+  const declaration = primary.kind === "named" ? project.typeById.get(primary.typeId) : void 0;
   if (declaration?.kind === "class" && (memberName === NEOSCRIPT_CLASS_ID_MEMBER || memberName === "Clone"))
     return primary;
   if (declaration?.members.some((member) => member.name === memberName))
@@ -16304,12 +16313,12 @@ function isNeoScriptTypeAssignable(source, target, project) {
   if (isUnknownType(source) || isUnknownType(target)) return false;
   if (isNullType(source)) return isNullableType2(target);
   if (isNullableType2(source) && !isNullableType2(target)) return false;
-  if (target.kind === "named" && target.narrowedInterfaces !== void 0) {
+  if ((target.kind === "named" || target.kind === "typeParameter") && target.narrowedInterfaces !== void 0) {
     for (const bound of Object.values(target.narrowedInterfaces)) {
       if (!isNeoScriptTypeAssignable(source, bound, project)) return false;
     }
   }
-  if (source.kind === "named" && source.narrowedInterfaces !== void 0) {
+  if ((source.kind === "named" || source.kind === "typeParameter") && source.narrowedInterfaces !== void 0) {
     const direct = target.kind === "named" ? source.narrowedInterfaces[target.typeId] : void 0;
     if (direct !== void 0 && isNeoScriptTypeAssignable(direct, target, project))
       return true;
@@ -16337,7 +16346,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
         project
       );
     }
-    if (!target.typeArguments?.length || project.typeById.get(target.typeId)?.kind !== "interface") {
+    if (!target.typeArguments?.length) {
       return isTypeDerivedFrom(
         project.typeById.get(source.typeId),
         target.typeId,
@@ -16345,7 +16354,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
         /* @__PURE__ */ new Set()
       );
     }
-    const construction = interfaceConstruction(source, target.typeId, project);
+    const construction = supertypeConstruction(source, target.typeId, project);
     return construction !== void 0 && invariantTypeArguments(construction, target.typeArguments, project);
   }
   if (source.kind === "typeParameter" && target.kind === "typeParameter") {
@@ -16403,7 +16412,7 @@ function isNeoScriptTypeAssignable(source, target, project) {
   return false;
 }
 function withoutNeoScriptInterfaceProofs(type) {
-  if (type.kind !== "named" || type.narrowedInterfaces === void 0)
+  if (type.kind !== "named" && type.kind !== "typeParameter" || type.narrowedInterfaces === void 0)
     return type;
   const { narrowedInterfaces: _proofs, ...declared } = type;
   return declared;
@@ -16411,7 +16420,7 @@ function withoutNeoScriptInterfaceProofs(type) {
 function commonNeoScriptAssignableType(left, right, project) {
   if (isNeoScriptTypeAssignable(left, right, project)) return right;
   if (isNeoScriptTypeAssignable(right, left, project)) return left;
-  if (left.kind === "named" && right.kind === "named" && (left.narrowedInterfaces !== void 0 || right.narrowedInterfaces !== void 0)) {
+  if ((left.kind === "named" || left.kind === "typeParameter") && (right.kind === "named" || right.kind === "typeParameter") && (left.narrowedInterfaces !== void 0 || right.narrowedInterfaces !== void 0)) {
     const declaredLeft = withoutNeoScriptInterfaceProofs(left);
     const declaredRight = withoutNeoScriptInterfaceProofs(right);
     const common = commonNeoScriptAssignableType(
@@ -16419,7 +16428,8 @@ function commonNeoScriptAssignableType(left, right, project) {
       declaredRight,
       project
     );
-    if (common?.kind !== "named") return null;
+    if (common?.kind !== "named" && common?.kind !== "typeParameter")
+      return null;
     const proofs = {};
     for (const [source, other] of [
       [left, right],
@@ -16472,41 +16482,53 @@ function interfaceInstantiationMessage(declared, expected, project) {
   }
   return message;
 }
-function interfaceConstruction(source, interfaceId, project, seen = /* @__PURE__ */ new Set()) {
-  if (source.typeId === interfaceId) return source.typeArguments ?? [];
-  const type = project.typeById.get(source.typeId);
-  if (type === void 0 || seen.has(type.id)) return void 0;
-  seen.add(type.id);
-  const bindings = /* @__PURE__ */ new Map();
-  type.typeParameters?.forEach((parameter3, index) => {
-    const argument2 = source.typeArguments?.[index];
-    if (argument2 !== void 0)
-      bindings.set(parameter3.id ?? parameter3.name, argument2);
-  });
-  for (const id of [
-    ...type.baseTypeIds ?? [],
-    ...type.interfaceTypeIds ?? []
-  ]) {
-    const supertype = {
-      kind: "named",
-      typeId: id,
-      typeArguments: (type.supertypeArguments?.[id] ?? []).map(
-        (argument2) => substituteNeoScriptTypeParameters(
-          argument2,
-          (parameter3) => bindings.get(parameter3.id),
-          project
-        )
-      )
-    };
-    const found = interfaceConstruction(supertype, interfaceId, project, seen);
-    if (found !== void 0) return found;
+function supertypeConstruction(source, supertypeId, project) {
+  for (const type of constructedSupertypes(source, project)) {
+    if (type.typeId === supertypeId) return type.typeArguments ?? [];
   }
   return void 0;
 }
+function* constructedSupertypes(source, project) {
+  const pending = [source];
+  const seen = /* @__PURE__ */ new Set();
+  while (true) {
+    const current = pending.pop();
+    if (current === void 0) return;
+    if (seen.has(current.typeId)) continue;
+    seen.add(current.typeId);
+    yield current;
+    const type = project.typeById.get(current.typeId);
+    if (type === void 0) continue;
+    const bindings = /* @__PURE__ */ new Map();
+    type.typeParameters?.forEach((parameter3, index) => {
+      const argument2 = current.typeArguments?.[index];
+      if (argument2 !== void 0)
+        bindings.set(parameter3.id ?? parameter3.name, argument2);
+    });
+    const parents = [
+      ...type.baseTypeIds ?? [],
+      ...type.interfaceTypeIds ?? []
+    ];
+    for (const id of parents.reverse()) {
+      if (seen.has(id)) continue;
+      pending.push({
+        kind: "named",
+        typeId: id,
+        typeArguments: (type.supertypeArguments?.[id] ?? []).map(
+          (argument2) => substituteNeoScriptTypeParameters(
+            argument2,
+            (parameter3) => bindings.get(parameter3.id),
+            project
+          )
+        )
+      });
+    }
+  }
+}
 function interfaceUndeterminedReason(classType, interfaceType2, project) {
   const params = classType.typeParameters ?? [];
   if (params.length === 0) return null;
-  const construction = interfaceConstruction(
+  const construction = supertypeConstruction(
     {
       kind: "named",
       typeId: classType.id,
@@ -17029,16 +17051,18 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
 
 // ../packages/neoscript-runtime/src/neoscript/runtime-set.ts
 var RuntimeSet = class {
-  constructor(source, reference, enumEntries, slotReferences = null) {
+  constructor(source, reference, enumEntries, slotReferences = null, decimalEntries = false) {
     this.source = source;
     this.reference = reference;
     this.enumEntries = enumEntries;
     this.slotReferences = slotReferences;
+    this.decimalEntries = decimalEntries;
   }
   source;
   reference;
   enumEntries;
   slotReferences;
+  decimalEntries;
   entries = /* @__PURE__ */ new Map();
   validations = /* @__PURE__ */ new Map();
   snapshot;
@@ -17048,6 +17072,9 @@ var RuntimeSet = class {
   has(key) {
     return this.entries.has(key);
   }
+  *values() {
+    for (const entry of this.entries.values()) yield entry.raw;
+  }
   add(key, raw, reference) {
     if (this.entries.has(key)) return;
     this.entries.set(key, { raw, reference });
@@ -17566,12 +17593,15 @@ function initializerOwnerContext(document2, valueId, rootOwners, valuesById, rec
     currentId = sourceValueId;
     lexicalRoot = rootOwners.get(sourceValueId) ?? lexicalRoot;
   }
-  if (lexicalRoot === void 0 || isStaticMember(lexicalRoot)) {
-    return { ownerClass: null, lexicalThisClass: null };
+  if (lexicalRoot === void 0) {
+    return { declaringClass: null, lexicalThisClass: null };
   }
   const lexicalRootId = getField(lexicalRoot, "id");
   const ownerClass = typeof lexicalRootId === "string" ? findSchemaPlacement(lexicalRootId, document2.classes)?.ownerClass ?? null : null;
-  return { ownerClass, lexicalThisClass: ownerClass };
+  return {
+    declaringClass: ownerClass,
+    lexicalThisClass: isStaticMember(lexicalRoot) ? null : ownerClass
+  };
 }
 function isClassRecordValue(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -21440,7 +21470,14 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
   for (let index = 0; index < argumentValues.length; index += 1) {
     const parameter3 = parameters[index];
     if (parameter3 === void 0) continue;
-    scope.setLocal(parameter3.id, argumentValues[index]);
+    scope.setLocal(
+      parameter3.id,
+      coerceAssignmentValue(
+        argumentValues[index],
+        parameter3.typeInfo,
+        "getter argument"
+      )
+    );
   }
   try {
     const result = evalBody(
@@ -21450,9 +21487,11 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       evaluationOptions(runtimeCtx, false)
     );
     if (result.kind === "return") {
-      if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
-        result.value = coerceDecimalOperand(result.value, "return");
-      }
+      result.value = coerceAssignmentValue(
+        result.value,
+        getter.typeInfo,
+        "return"
+      );
       if (ownsInvocationState) {
         flushRuntimeSets(runtimeCtx);
         result.value = exportRuntimeSetValue(result.value, runtimeCtx);
@@ -22324,7 +22363,11 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     const parameter3 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
     const value2 = asDeclaredRuntimeSet(
-      restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+      coerceAssignmentValue(
+        restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+        runtimeTypeInfo,
+        "function argument"
+      ),
       runtimeTypeInfo,
       ctx
     );
@@ -22358,9 +22401,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     }
     return null;
   }
-  if (runtimeReturnType.type === 20 /* Decimal */ && typeof value === "number") {
-    value = coerceDecimalOperand(value, "function return");
-  }
+  value = coerceAssignmentValue(value, runtimeReturnType, "function return");
   if (!runtimeValueMatchesType(value, runtimeReturnType, ctx)) {
     throw new NSGetterRuntimeError(
       "NSFunction returned a value that does not match its compiled return type."
@@ -22702,9 +22743,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "variable" /* variable */: {
           let value = evalPointer(ins.variable.pointer, scope, ctx);
-          if (ins.variable.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "variable initialization");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.variable.typeInfo,
+            "variable initialization"
+          );
           value = asDeclaredRuntimeSet(value, ins.variable.typeInfo, ctx);
           scope.setLocal(ins.variable.id, value);
           break;
@@ -22740,9 +22783,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "assign" /* assign */: {
           let value = evalPointer(ins.pointer, scope, ctx);
-          if (ins.target.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "assignment");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.target.typeInfo,
+            "assignment"
+          );
           if (ins.target.pointer.type === "variable" /* variable */) {
             assertVariableBindingWritable(scope, ins.target.pointer.variableId);
             scope.setLocal(ins.target.pointer.variableId, value);
@@ -24524,6 +24569,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
+  const decimalEntries = "entryTypeInfo" in ins.target.typeInfo && ins.target.typeInfo.entryTypeInfo.type === 20 /* Decimal */;
+  let entryArgumentIndex = null;
+  const dictionary = ins.target.typeInfo.type === 5 /* Dictionary */;
+  if (ins.mutation === "Add" /* Add */)
+    entryArgumentIndex = dictionary ? 1 : 0;
+  if (ins.mutation === "Insert" /* Insert */) entryArgumentIndex = 1;
+  if (ins.mutation === "Remove" /* Remove */ && !dictionary)
+    entryArgumentIndex = 0;
+  if (entryArgumentIndex !== null && "entryTypeInfo" in ins.target.typeInfo) {
+    args[entryArgumentIndex] = coerceAssignmentValue(
+      args[entryArgumentIndex],
+      ins.target.typeInfo.entryTypeInfo,
+      "collection mutation entry"
+    );
+  }
   const setEntryMember = mutatesLocalVariable ? null : storedSetEntryMember(targetValue, ctx);
   const isLookupSet = setEntryMember === null && ins.target.typeInfo.type === 9 /* Lookup */;
   if (isLookupSet && Array.isArray(targetValue)) {
@@ -24531,7 +24591,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       targetValue,
       ins.reference === true,
       ins.target.typeInfo.type === 9 /* Lookup */ && (ins.target.typeInfo.entryTypeInfo.type === 8 /* Enum */ || ins.target.typeInfo.entryTypeInfo.type === 18 /* DialogueLookup */),
-      ctx
+      ctx,
+      decimalEntries
     );
   }
   const setMatch = setEntryMember !== null && Array.isArray(targetValue) && (ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) ? findStoredSetEntry(targetValue, args[0], setEntryMember, ctx) : null;
@@ -24550,7 +24611,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx,
       isLookupSet,
       false,
-      ins.reference === true
+      ins.reference === true,
+      decimalEntries
     );
     updateCollectionReferenceProvenance(
       targetValue,
@@ -24628,7 +24690,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     ctx,
     isLookupSet,
     ins.reference !== true && ins.mutation === "Remove" /* Remove */ && isArrayCollection(targetValue) && setEntryMember === null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
-    ins.reference === true
+    ins.reference === true,
+    setEntryMember === null && decimalEntries
   );
   updateCollectionReferenceProvenance(
     targetValue,
@@ -24904,21 +24967,28 @@ function asDeclaredRuntimeSet(value, type, ctx) {
     value,
     entry === 7 /* Class */ || entry === 22 /* Interface */ || entry === 6 /* List */ || entry === 5 /* Dictionary */ || entry === 9 /* Lookup */,
     entry === 8 /* Enum */ || entry === 18 /* DialogueLookup */,
-    ctx
+    ctx,
+    entry === 20 /* Decimal */
   );
 }
 function runtimeSetKey(value, set, ctx) {
   if (set.slotReferences !== null) return slotReferenceKey(value);
   if (set.enumEntries && Array.isArray(value) && value.length === 1)
     value = value[0];
-  return toSetEntryKey(value, null, set.reference, ctx);
+  return toSetEntryKey(value, null, set.reference, ctx, set.decimalEntries);
 }
-function runtimeSet(array2, reference, enumEntries, ctx) {
+function runtimeSet(array2, reference, enumEntries, ctx, decimalEntries = false) {
   const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
   ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
   const existing = sets.get(array2);
   if (existing !== void 0) return existing;
-  const set = new RuntimeSet(array2, reference, enumEntries);
+  const set = new RuntimeSet(
+    array2,
+    reference,
+    enumEntries,
+    null,
+    decimalEntries
+  );
   const references = collectionReferences(array2, ctx);
   for (let index = 0; index < array2.length; index++) {
     const raw = array2[index];
@@ -25037,7 +25107,7 @@ function removableEntryRowIds(targetValue, mutation, args, ctx) {
   }
   return rowIds;
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false, decimal = false) {
   if (targetValue instanceof RuntimeSet) {
     (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
     switch (mutation) {
@@ -25089,6 +25159,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
         const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
+        const targetKey = decimal ? decimalCollectionKey(args[0]) : args[0];
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -25099,10 +25170,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          if (jsEqual(
-            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
-            args[0]
-          )) {
+          const value = typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry;
+          if (jsEqual(decimal ? decimalCollectionKey(value) : value, targetKey)) {
             index = candidate;
             break;
           }
@@ -25589,12 +25658,22 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "function" /* function */:
       return evalFunction(pointer.function, scope, ctx);
     case "listLiteral" /* listLiteral */:
-      return pointer.entries.map((e) => evalPointer(e, scope, ctx));
+      return pointer.entries.map(
+        (entry) => coerceAssignmentValue(
+          evalPointer(entry, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "list entry"
+        )
+      );
     case "dictLiteral" /* dictLiteral */: {
       const out = {};
       for (const e of pointer.entries) {
         const k = evalPointer(e.key, scope, ctx);
-        out[String(k)] = evalPointer(e.value, scope, ctx);
+        out[String(k)] = coerceAssignmentValue(
+          evalPointer(e.value, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "dictionary entry"
+        );
       }
       return out;
     }
@@ -27257,9 +27336,9 @@ function readRecordKey(receiver, k, memberId, ctx) {
     if (receiver === ctx.thisValue && typeof ctx.thisValueRowId === "string") {
       return ctx.thisValueRowId;
     }
-    const rowId = findKnownRowIdByValueReference(receiver, ctx);
-    if (rowId) return rowId;
-    throw new NSGetterRuntimeError("Class value has no backing row id.");
+    const row = trackedRowForValueReference(receiver, ctx);
+    if (row !== null && classIdForValueRow(row, ctx) !== void 0)
+      return row.id;
   }
   const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
   if (assetMember.kind === "ok") return assetMember.value;
@@ -28690,7 +28769,11 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
   }
 }
 function evalListRepeat(info, scope, ctx) {
-  const value = evalPointer(info.valuePointer, scope, ctx);
+  const value = coerceAssignmentValue(
+    evalPointer(info.valuePointer, scope, ctx),
+    info.entryTypeInfo,
+    "List.Repeat entry"
+  );
   const count = numberArg(
     evalPointer(info.countPointer, scope, ctx),
     "List.Repeat count"
@@ -28778,13 +28861,18 @@ function jsEqual(a, b) {
     return a instanceof NSSlotReference && b instanceof NSSlotReference && a.targetId === b.targetId;
   }
   if (a === b) return true;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!jsEqual(a[i], b[i])) return false;
+  if (Array.isArray(a) || a instanceof RuntimeSet) {
+    if (!Array.isArray(b) && !(b instanceof RuntimeSet)) return false;
+    const aSize = a instanceof RuntimeSet ? a.size : a.length;
+    const bSize = b instanceof RuntimeSet ? b.size : b.length;
+    if (aSize !== bSize) return false;
+    const other = b.values();
+    for (const entry of a.values()) {
+      if (!jsEqual(entry, other.next().value)) return false;
     }
     return true;
   }
+  if (b instanceof RuntimeSet) return false;
   if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
@@ -29220,7 +29308,8 @@ function evalCollectionQuery(info, scope, ctx) {
       output,
       info.reference === true,
       info.enumEntries === true,
-      ctx
+      ctx,
+      info.decimalEntries === true
     ) : output;
   };
   if (info.op === "OrderBy" || info.op === "OrderByDescending") {
@@ -29272,7 +29361,8 @@ function evalCollectionQuery(info, scope, ctx) {
           entry,
           valueId,
           info.reference === true,
-          ctx
+          ctx,
+          info.decimalEntries === true
         );
         if (seenSetKeys.has(setKey)) return 0 /* Continue */;
         seenSetKeys.add(setKey);
@@ -29327,10 +29417,15 @@ function evalCollectionQuery(info, scope, ctx) {
   }
   return finish();
 }
-function toSetEntryKey(entry, valueId, reference, ctx) {
+function toSetEntryKey(entry, valueId, reference, ctx, decimal = false) {
   if (reference) return valueId ?? referenceIdOf(entry, ctx) ?? entry;
+  if (decimal) return decimalCollectionKey(entry);
   return typeof entry === "object" && entry !== null ? canonicalJsonStringify(entry) : entry;
 }
+function decimalCollectionKey(value) {
+  if (value === null) return null;
+  return decimalKey(coerceDecimalOperand(value, "decimal collection entry"));
+}
 function compareCollectionKeys(left, right, keyType) {
   if (left === null) return right === null ? 0 : -1;
   if (right === null) return 1;
@@ -29448,7 +29543,11 @@ function evalFunction(fn, scope, ctx) {
     }
     case "contains" /* contains */: {
       let c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
+      if (fn.info.decimal === true && target !== null)
+        target = coerceDecimalOperand(target, "collection search");
       if (typeof c === "string") {
         if (typeof target !== "string") {
           throw new NSGetterRuntimeError(
@@ -29481,9 +29580,13 @@ function evalFunction(fn, scope, ctx) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           containsResolvedEntry = true;
           return 1 /* Break */;
         }
@@ -29496,15 +29599,21 @@ function evalFunction(fn, scope, ctx) {
         evalPointer(fn.info.collectionPointer, scope, ctx),
         "IndexOf receiver"
       );
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
       if (fn.info.reference === true) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           found = numberArg(key, "IndexOf index");
           return 1 /* Break */;
         }
@@ -29712,7 +29821,19 @@ function evalFunction(fn, scope, ctx) {
         );
         iterateCollection(c, ctx, callback);
       }
-      if (found !== sentinel) return found;
+      if (found !== sentinel) {
+        if (typeof found === "string") {
+          if (c instanceof RuntimeSet) {
+            if (c.enumEntries) return [found];
+          } else {
+            const row = trackedRowForValueReference(c, ctx);
+            const member = row === null ? null : memberForValueRow(row, ctx);
+            if (member?.kind === 8 /* Enum */ || member?.kind === 18 /* DialogueLookup */)
+              return [found];
+          }
+        }
+        return found;
+      }
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
           innerFn ? "First() found no matching entry. Use FirstOrDefault() and handle null if no match is expected." : "First() called on an empty collection. Check that it has entries, or use FirstOrDefault() and handle null."
@@ -30926,10 +31047,19 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
+  const defaultScopeMemberId = (memberId) => walkExtendsMemberChain(
+    memberId,
+    ctx.vm.members,
+    (declaration) => declaration.defaultValue === void 0 ? void 0 : declaration.id,
+    {
+      memberById: (id) => indexes4.schemaIndex.member(id) ?? null,
+      maxHops: ctx.vm.members.length
+    }
+  );
   return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
-    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
+    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? (sourceValueId === void 0 && effectiveMemberId !== null ? defaultScopeMemberId(effectiveMemberId) : void 0) ?? effectiveMemberId;
     const compiled = ensureInitializerCompiled({
       init,
       member,
@@ -36342,7 +36472,7 @@ function materializeMemberDefaultValue(args) {
       rootOwners,
       valuesById,
       (id) => args.readTracking?.valueIds.add(id)
-    ).ownerClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
+    ).lexicalThisClass : typeof Reflect.get(member, "id") === "string" && !isStaticMember(member) ? findSchemaPlacement(
       String(Reflect.get(member, "id")),
       args.document.classes
     )?.ownerClass ?? null : null;
@@ -43826,7 +43956,7 @@ function implementerConstruction(implementer, slotInterface, slot, project) {
     );
     if (reason !== null) return void 0;
   }
-  const implemented = interfaceConstruction(
+  const implemented = supertypeConstruction(
     {
       kind: "named",
       typeId: implementer.id,
@@ -44018,10 +44148,12 @@ var Scope = class {
   constructor(parent, probe = parent?.probe ?? false) {
     this.parent = parent;
     this.probe = probe;
+    this.externalRoots = parent?.externalRoots ?? /* @__PURE__ */ new Map();
     this.patternBindings = parent?.patternBindings ?? null;
   }
   parent;
   probe;
+  externalRoots;
   entries = /* @__PURE__ */ new Map();
   invalidatedRoots = /* @__PURE__ */ new Set();
   hiddenNarrowingRoots = /* @__PURE__ */ new Set();
@@ -44044,7 +44176,15 @@ var Scope = class {
   lookup(name) {
     return this.entries.get(name) ?? this.parent?.lookup(name) ?? null;
   }
+  registerExternalRoot(name, type) {
+    if (!this.externalRoots.has(name))
+      this.externalRoots.set(name, { name, type, variableId: name });
+  }
+  lookupFlowRoot(name) {
+    return this.lookup(name) ?? this.externalRoots.get(name) ?? null;
+  }
   containsEntry(entry) {
+    if (this.externalRoots.get(entry.name) === entry) return true;
     for (const candidate of this.entries.values()) {
       if (candidate === entry) return true;
     }
@@ -44102,6 +44242,7 @@ var Scope = class {
     if (path === rootEntry.name) this.updatePatternType(rootEntry, type);
   }
   updatePatternType(entry, type) {
+    if (this.externalRoots.get(entry.name) === entry) return;
     if (this.probe || entry.patternBinding)
       this.patternBindings = {
         name: entry.name,
@@ -44745,7 +44886,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             branchExitNarrowings,
             this.project
           )) {
-            const rootEntry = scope.lookup(pathRoot(path));
+            const rootEntry = scope.lookupFlowRoot(pathRoot(path));
             if (rootEntry === narrowed.rootEntry) {
               scope.narrow(path, rootEntry, narrowed.type);
             }
@@ -45678,7 +45819,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     for (const [path, narrowed] of merged) {
       if (!parent.containsEntry(narrowed.rootEntry)) continue;
-      const rootEntry = parent.lookup(pathRoot(path));
+      const rootEntry = parent.lookupFlowRoot(pathRoot(path));
       if (rootEntry === narrowed.rootEntry) {
         parent.narrow(path, rootEntry, narrowed.type);
       }
@@ -45905,7 +46046,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     if (assignedPath) {
-      const rootEntry = scope.lookup(pathRoot(assignedPath));
+      const rootEntry = scope.lookupFlowRoot(pathRoot(assignedPath));
       if (rootEntry) {
         const retainedFacts = unaffectedNarrowings(
           assignedPath,
@@ -45952,11 +46093,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   referenceAssignment(statement, place, storageType, scope) {
     const source = statement.op === "=" ? statement.value ?? void 0 : void 0;
     const nullLiteral = source?.kind === "litNull";
-    const assigned = source === void 0 ? void 0 : this.resolveReferenceExpression(
-      source,
-      scope,
-      nullLiteral ? void 0 : neoScriptReadType(storageType)
-    );
+    const assigned = source === void 0 ? void 0 : this.resolveReferenceAssignmentValue(source, scope, storageType);
     const valueAt = (type) => {
       if (source === void 0 || assigned === void 0) return void 0;
       return nullLiteral ? this.resolveReferenceExpression(source, scope, type) : this.readReferences(assigned, type);
@@ -46000,6 +46137,30 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     return { target: layer, value: valueAt(layer.type), through };
   }
+  resolveReferenceAssignmentValue(expression, scope, storageType) {
+    if (expression.kind === "conditional") {
+      return this.resolveConditionalExpression(
+        expression,
+        scope,
+        neoScriptReadType(storageType),
+        storageType
+      );
+    }
+    if (expression.kind === "coalesce") {
+      return this.resolveCoalesceExpression(
+        expression,
+        scope,
+        void 0,
+        storageType
+      );
+    }
+    const expected = neoScriptReadType(storageType);
+    return this.resolveReferenceExpression(
+      expression,
+      scope,
+      expression.kind === "litNull" ? void 0 : expected
+    );
+  }
   /** `Reference<target>` as an expression type (P112 §3.1). */
   referenceType(target, nullable2) {
     return neoScriptReferenceType(
@@ -46160,7 +46321,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           false
         ).type;
       }
-      return resolvedTarget.type;
+      return this.resolveIdentifierNatural(targetAst.name, scope, targetAst.pos).type;
     }
     if (targetAst.kind !== "member") return resolvedTarget.type;
     return this.resolveMemberNatural(
@@ -46403,7 +46564,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     if (assignedPath) {
-      const rootEntry = scope.lookup(pathRoot(assignedPath));
+      const rootEntry = scope.lookupFlowRoot(pathRoot(assignedPath));
       if (rootEntry) {
         const retainedFacts = unaffectedNarrowings(
           assignedPath,
@@ -47139,34 +47300,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           ...operand.writeRoot ? { writeRoot: operand.writeRoot } : {}
         };
       }
-      case "coalesce": {
-        const left = this.resolveExpression(expression.left, scope);
-        const leftOptional = { ...left.type, nullable: true };
-        const nullLeft = isNull(left.type);
-        const right = this.resolveExpression(
-          expression.right,
-          scope,
-          nullLeft ? expected : leftOptional
-        );
-        if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
-          throw new CompileError(
-            `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
-            expression.pos
-          );
-        }
-        const resultType = nullLeft ? right.type : {
-          ...left.type,
-          nullable: isNullable(left.type) && isNullable(right.type)
-        };
-        return {
-          pointer: {
-            type: "coalesce" /* Coalesce */,
-            left: left.pointer,
-            right: right.pointer
-          },
-          type: resultType
-        };
-      }
+      case "coalesce":
+        return this.resolveCoalesceExpression(expression, scope, expected);
       case "conditional":
         return this.resolveConditionalExpression(expression, scope, expected);
       case "is": {
@@ -47743,6 +47878,21 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveIdentifier(name, scope, pos, usage = "value") {
+    const natural = this.resolveIdentifierNatural(name, scope, pos, usage);
+    if (scope.lookup(name)) return natural;
+    const path = this.narrowingPath(name, scope);
+    const root = path === null ? null : scope.lookupFlowRoot(pathRoot(path));
+    const narrowed = root && path ? scope.lookupNarrowedType(path, root) : null;
+    const resolved = narrowed ? { ...natural, type: narrowed } : natural;
+    this.options.onFlowScope?.({
+      name,
+      position: pos,
+      type: resolved.type,
+      bindings: scope.patternBindings
+    });
+    return resolved;
+  }
+  resolveIdentifierNatural(name, scope, pos, usage = "value") {
     if (name === "this" && this.context.kind === "initializer" && this.delegateCaptureContexts.length === 0 && usage === "value") {
       throw new CompileError(
         "'this' is unavailable while an initializer runs. Defer instance access with a lambda or method group.",
@@ -47775,7 +47925,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     const global = this.context.project.globals.find(
-      (candidate) => candidate.name === name
+      (symbol) => symbol.name === name
     );
     if (global) return this.symbolValue(global);
     const implicit = this.implicitMember(name);
@@ -47917,11 +48067,29 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (path === null) return null;
     const root = pathRoot(path);
     if (scope.lookup(root)) return path;
-    if (this.context.project.globals.some((symbol) => symbol.name === root)) {
-      return path;
+    const global = this.context.project.globals.find(
+      (symbol) => symbol.name === root
+    );
+    if (global) {
+      const key = `global:${root}`;
+      scope.registerExternalRoot(key, global.type);
+      return key + path.slice(root.length);
     }
     const implicit = this.implicitMember(root);
-    return implicit && implicit.symbol.static !== true ? `this.${path}` : path;
+    if (implicit && implicit.symbol.static !== true) return `this.${path}`;
+    const owner = implicit?.owner ?? this.project.typeByName.get(root);
+    if (owner) {
+      const memberName = implicit?.symbol.name ?? path.slice(root.length + 1).split(".")[0];
+      const member = implicit?.symbol ?? owner.members.find((candidate) => candidate.name === memberName);
+      const declaring = member?.inheritedFrom;
+      const key = `static:${declaring?.typeName ?? owner.name}`;
+      scope.registerExternalRoot(key, {
+        kind: "named",
+        typeId: declaring?.typeId ?? owner.id
+      });
+      return implicit ? `${key}.${path}` : key + path.slice(root.length);
+    }
+    return path;
   }
   conditionFacts(expression, scope, whenTrue) {
     const pathOf = (value) => this.narrowingPath(canonicalPath(value), scope);
@@ -47939,7 +48107,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       locals
     )) {
       const path = this.narrowingPath(assignedPath, outerScope);
-      const outerEntry = path === null ? null : outerScope.lookup(pathRoot(path));
+      const outerEntry = path === null ? null : outerScope.lookupFlowRoot(pathRoot(path));
       if (outerEntry && path !== null) {
         const retained = unaffectedNarrowings(path, outerEntry, loopEntryScope);
         loopEntryScope.hideInheritedNarrowing(outerEntry);
@@ -47957,7 +48125,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         targetScope
       );
       const natural = this.readReferences(place, void 0);
-      const rootEntry = fact.path === null ? null : targetScope.lookup(pathRoot(fact.path));
+      const rootEntry = fact.path === null ? null : targetScope.lookupFlowRoot(pathRoot(fact.path));
       if (fact.nullValue) {
         if (fact.path === null || rootEntry === null) continue;
         if (place.type.kind === "reference" && !isNullable(place.type)) {
@@ -47978,7 +48146,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const targetDefinition = target.kind === "named" ? this.project.typeById.get(target.typeId) : void 0;
         const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
         let narrowed = { ...target, nullable: false };
-        if (!fact.bindingName && natural.type.kind === "named" && (naturalDefinition?.kind === "class" || naturalDefinition?.kind === "interface") && target.kind === "named" && targetDefinition?.kind === "interface") {
+        if ((natural.type.kind === "typeParameter" || natural.type.kind === "named" && (naturalDefinition?.kind === "class" || naturalDefinition?.kind === "interface")) && target.kind === "named" && targetDefinition?.kind === "interface") {
           narrowed = { ...natural.type, nullable: false };
           if (!isNeoScriptTypeAssignable(narrowed, target, this.project)) {
             narrowed = {
@@ -47990,6 +48158,22 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             };
           }
         }
+        if (target.kind === "named" && targetDefinition?.kind === "class") {
+          const lookup = neoScriptMemberLookupType(natural.type);
+          if (lookup.kind === "named" || lookup.kind === "typeParameter") {
+            const { narrowedInterfaces, ...declared } = lookup;
+            const proofs = declared.kind === "named" && this.project.typeById.get(declared.typeId)?.kind === "interface" ? {
+              ...narrowedInterfaces,
+              [declared.typeId]: declared
+            } : narrowedInterfaces;
+            if (proofs !== void 0)
+              narrowed = {
+                ...target,
+                nullable: false,
+                narrowedInterfaces: proofs
+              };
+          }
+        }
         if (mode === "all" && fact.path !== null && rootEntry !== null && place.type.kind !== "reference") {
           targetScope.narrow(fact.path, rootEntry, narrowed);
         }
@@ -47999,7 +48183,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           }
           targetScope.definePattern({
             name: fact.bindingName,
-            type: narrowed,
+            type: { ...target, nullable: false },
             variableId: fact.bindingTest ? this.patternBindingId(fact.bindingTest) : fact.bindingName,
             writeRoot: this.expressionWriteRoot(natural, targetScope),
             pointer: fact.bindingTest ? {
@@ -48279,7 +48463,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return wire;
   }
   resolveMember(receiverAst, name, scope, pos, optional2, receiverValue) {
-    const resolved = this.resolveMemberNatural(
+    let resolved = this.resolveMemberNatural(
       receiverAst,
       name,
       scope,
@@ -48288,21 +48472,25 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       receiverValue
     );
     if (!optional2) {
-      const receiverPath = this.narrowingPath(
-        canonicalPath(receiverAst),
+      const receiverPath = canonicalPath(receiverAst);
+      const path = this.narrowingPath(
+        receiverPath === null ? null : `${receiverPath}.${name}`,
         scope
       );
-      if (receiverPath) {
-        const rootEntry = scope.lookup(pathRoot(receiverPath));
+      if (path) {
+        const rootEntry = scope.lookupFlowRoot(pathRoot(path));
         if (rootEntry) {
-          const narrowed = scope.lookupNarrowedType(
-            `${receiverPath}.${name}`,
-            rootEntry
-          );
-          if (narrowed) return { ...resolved, type: narrowed };
+          const narrowed = scope.lookupNarrowedType(path, rootEntry);
+          if (narrowed) resolved = { ...resolved, type: narrowed };
         }
       }
     }
+    this.options.onFlowScope?.({
+      name,
+      position: pos,
+      type: resolved.type,
+      bindings: scope.patternBindings
+    });
     return resolved;
   }
   resolveStaticMemberValue(staticType, member, pos) {
@@ -50069,7 +50257,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         scope
       )
     );
-    const schemaClassInfo = toWireType(targetType, this.project);
+    const schemaClassInfo = this.constructorWireType(targetType, expression);
     if (schemaClassInfo.type !== 7 /* Class */) {
       throw new Error(
         `NeoScript constructor ${className} has non-Class return type ${this.describe(signature.returnType)}.`
@@ -50087,6 +50275,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       writability: "session" /* Session */
     };
   }
+  /** Constructor storage arguments stay distinct from their expression read types. */
+  constructorWireType(target, expression) {
+    const typeArguments = expression.typeArguments?.map(
+      (argument2) => resolveStoredReferenceTarget(argument2, this.context, this.project)
+    );
+    return toWireType(
+      typeArguments === void 0 ? target : { ...target, typeArguments },
+      this.project
+    );
+  }
   constructorTargetType(schemaClass2, expression, expected) {
     const typeArguments = expression.typeArguments?.map(
       (argument2) => this.resolveType(argument2)
@@ -50217,7 +50415,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     const classType = targetType;
-    const schemaClassInfo = toWireType(classType, this.project);
+    const schemaClassInfo = this.constructorWireType(classType, expression);
     if (schemaClassInfo.type !== 7 /* Class */) {
       throw new Error(
         `NeoScript declared constructor ${className} projected a non-Class wire type.`
@@ -51080,6 +51278,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         {
           collectionPointer: receiver.pointer,
           valuePointer: value.pointer,
+          ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+          ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         },
         { kind: "primitive", name: "int" }
@@ -51109,6 +51309,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         {
           collectionPointer: receiver.pointer,
           valuePointer: value.pointer,
+          ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+          ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         },
         { kind: "primitive", name: "bool" }
@@ -51341,6 +51543,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         info = {
           ...base,
           op: name,
+          ...isPrimitive(collection.valueType, "decimal") ? { decimalEntries: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         };
         resultType = {
@@ -52280,7 +52483,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     if (path) {
-      const rootEntry = scope.lookup(pathRoot(path));
+      const rootEntry = scope.lookupFlowRoot(pathRoot(path));
       if (rootEntry) scope.invalidate(rootEntry);
     }
     const actionTypeInfo = receiver.wireType ?? toWireType(receiver.type, this.project);
@@ -52332,7 +52535,74 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
-  resolveConditionalExpression(expression, scope, expected) {
+  referenceAssignmentBranches(left, right, storageType, operator) {
+    let layer = storageType;
+    while (true) {
+      const expected = operator === "coalesce" ? { ...layer, nullable: true } : layer;
+      const resolvedLeft = this.readReferences(left, expected);
+      const resolvedRight = this.readReferences(right, expected);
+      if (isNeoScriptTypeAssignable(resolvedLeft.type, expected, this.project) && isNeoScriptTypeAssignable(resolvedRight.type, expected, this.project)) {
+        return { left: resolvedLeft, right: resolvedRight, type: expected };
+      }
+      if (layer.kind !== "reference") break;
+      layer = layer.target;
+    }
+    return { left, right, type: neoScriptReadType(storageType) };
+  }
+  resolveCoalesceExpression(expression, scope, expected, assignmentType) {
+    let left;
+    let right;
+    if (assignmentType) {
+      const branches = this.referenceAssignmentBranches(
+        this.resolveReferenceAssignmentValue(
+          expression.left,
+          scope,
+          assignmentType
+        ),
+        this.resolveReferenceAssignmentValue(
+          expression.right,
+          scope,
+          assignmentType
+        ),
+        assignmentType,
+        "coalesce"
+      );
+      left = branches.left;
+      right = branches.right;
+    } else {
+      left = this.resolveExpression(
+        expression.left,
+        scope,
+        expected?.kind === "reference" ? { ...expected, nullable: true } : void 0
+      );
+      right = this.resolveExpression(
+        expression.right,
+        scope,
+        isNull(left.type) ? expected : { ...left.type, nullable: true }
+      );
+    }
+    const leftOptional = { ...left.type, nullable: true };
+    const nullLeft = isNull(left.type);
+    if (!nullLeft && !isNeoScriptTypeAssignable(right.type, leftOptional, this.project)) {
+      throw new CompileError(
+        `\`??\` right operand ${this.describe(right.type)} is not assignable to ${this.describe(leftOptional)}`,
+        expression.pos
+      );
+    }
+    const resultType = nullLeft ? right.type : {
+      ...left.type,
+      nullable: isNullable(left.type) && isNullable(right.type)
+    };
+    return {
+      pointer: {
+        type: "coalesce" /* Coalesce */,
+        left: left.pointer,
+        right: right.pointer
+      },
+      type: resultType
+    };
+  }
+  resolveConditionalExpression(expression, scope, expected, assignmentType) {
     const condition = this.toBool(
       this.resolveExpression(expression.condition, scope),
       expression.condition.pos
@@ -52349,7 +52619,38 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
     let whenTrue;
     let whenFalse;
-    if (expected) {
+    if (assignmentType) {
+      whenTrue = this.resolveReferenceAssignmentValue(
+        expression.whenTrue,
+        trueScope,
+        assignmentType
+      );
+      whenFalse = this.resolveReferenceAssignmentValue(
+        expression.whenFalse,
+        falseScope,
+        assignmentType
+      );
+      let common2 = commonNeoScriptAssignableType(
+        whenTrue.type,
+        whenFalse.type,
+        this.project
+      );
+      if (isNull(whenTrue.type)) common2 = { ...whenFalse.type, nullable: true };
+      if (isNull(whenFalse.type)) common2 = { ...whenTrue.type, nullable: true };
+      if (common2) {
+        expected = common2;
+      } else {
+        const branches = this.referenceAssignmentBranches(
+          whenTrue,
+          whenFalse,
+          assignmentType,
+          "conditional"
+        );
+        whenTrue = branches.left;
+        whenFalse = branches.right;
+        expected = branches.type;
+      }
+    } else if (expected) {
       whenTrue = this.resolveExpression(
         expression.whenTrue,
         trueScope,
@@ -52386,7 +52687,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.pos
       );
     }
-    if (expected) {
+    if (expected && !assignmentType) {
       this.requireAssignable(
         whenTrue.type,
         expected,
@@ -53274,9 +53575,7 @@ function typeRefsEqual(left, right) {
   if (left.kind === "primitive" && right.kind === "primitive") {
     return left.name === right.name;
   }
-  if (left.kind === "named" && right.kind === "named") {
-    const leftArgs = left.typeArguments ?? [];
-    const rightArgs = right.typeArguments ?? [];
+  if ((left.kind === "named" || left.kind === "typeParameter") && (right.kind === "named" || right.kind === "typeParameter")) {
     if (left.narrowedInterfaces !== right.narrowedInterfaces) {
       const leftBounds = Object.entries(left.narrowedInterfaces ?? {});
       const rightBounds = right.narrowedInterfaces ?? {};
@@ -53287,6 +53586,10 @@ function typeRefsEqual(left, right) {
           return false;
       }
     }
+  }
+  if (left.kind === "named" && right.kind === "named") {
+    const leftArgs = left.typeArguments ?? [];
+    const rightArgs = right.typeArguments ?? [];
     return left.typeId === right.typeId && leftArgs.length === rightArgs.length && leftArgs.every((item, index) => {
       const other = rightArgs[index];
       return other !== void 0 && typeRefsEqual(item, other);
@@ -54268,6 +54571,20 @@ function typesOverlap(left, right, project) {
   if (isNull(right)) return isNullable(left);
   left = neoScriptMemberLookupType(left);
   right = neoScriptMemberLookupType(right);
+  const declaredLeft = withoutNeoScriptInterfaceProofs(left);
+  const declaredRight = withoutNeoScriptInterfaceProofs(right);
+  if (left.kind === "named" || left.kind === "typeParameter") {
+    for (const proof of Object.values(left.narrowedInterfaces ?? {})) {
+      if (!typesOverlap(proof, declaredRight, project)) return false;
+    }
+  }
+  if (right.kind === "named" || right.kind === "typeParameter") {
+    for (const proof of Object.values(right.narrowedInterfaces ?? {})) {
+      if (!typesOverlap(declaredLeft, proof, project)) return false;
+    }
+  }
+  left = declaredLeft;
+  right = declaredRight;
   if (left.kind === "typeParameter" || right.kind === "typeParameter")
     return true;
   if (isNeoScriptTypeAssignable(left, right, project) || isNeoScriptTypeAssignable(right, left, project))
@@ -54281,11 +54598,29 @@ function typesOverlap(left, right, project) {
     const classDeclaration = leftDeclaration?.kind === "class" ? leftDeclaration : rightDeclaration?.kind === "class" ? rightDeclaration : null;
     const interfaceDeclaration = leftDeclaration?.kind === "interface" ? leftDeclaration : rightDeclaration?.kind === "interface" ? rightDeclaration : null;
     if (classDeclaration !== null && interfaceDeclaration !== null) {
+      if (conflictingInterfaceConstructions(left, right, project)) return false;
       return classDeclaration.sealed !== true;
     }
   }
   return isNumeric(left) && isNumeric(right);
 }
+function conflictingInterfaceConstructions(left, right, project) {
+  const constructions = /* @__PURE__ */ new Map();
+  for (const type of constructedSupertypes(left, project)) {
+    if (project.typeById.get(type.typeId)?.kind === "interface" && type.typeArguments?.length)
+      constructions.set(type.typeId, type.typeArguments);
+  }
+  for (const type of constructedSupertypes(right, project)) {
+    const argumentsList2 = constructions.get(type.typeId);
+    if (!argumentsList2) continue;
+    if (argumentsList2.some((argument2, index) => {
+      const other = type.typeArguments?.[index];
+      return other !== void 0 && !containsTypeParameter(argument2) && !containsTypeParameter(other) && !(isNeoScriptTypeAssignable(argument2, other, project) && isNeoScriptTypeAssignable(other, argument2, project));
+    }))
+      return true;
+  }
+  return false;
+}
 function isUnknown(type) {
   return type.kind === "primitive" && type.name === "unknown";
 }
@@ -59344,7 +59679,7 @@ function compileNSInitializer(code, ctx) {
       {
         ...compilerContext,
         thisClass: lexicalThisClass ?? null,
-        implicitMemberAccess: lexicalThisClass !== null,
+        implicitMemberAccess: lexicalThisClass != null || declaringClass != null,
         staticMember: false
       },
       {
@@ -59615,7 +59950,7 @@ function compileMemberInitializerBody(args) {
         returnTypeInfo,
         initializerName: args.member.name,
         lexicalThisClass: parseExpression(defaultValue.init.code).kind === "lambda" ? instanceClass : null,
-        declaringClass: instanceClass,
+        declaringClass: args.thisClass,
         argumentTypes: initializerArgumentTypes(
           instanceClass,
           args.constructors ?? []
@@ -59664,7 +59999,7 @@ function compileValueRowInitializerBody(args) {
         lexicalThisClass: args.lexicalThisClass ?? null,
         declaringClass: args.initializerOwnerClass,
         argumentTypes: initializerArgumentTypes(
-          args.initializerOwnerClass,
+          args.lexicalThisClass === null ? null : args.initializerOwnerClass,
           args.constructors ?? []
         ),
         ...args.storedConstructionReplay === true ? { storedConstructionReplay: true } : {}
@@ -59869,7 +60204,7 @@ function valueInitializerCompilationSites(document2) {
     sites.set(row.id, {
       row,
       member,
-      ownerClass: ownerContext.ownerClass,
+      ownerClass: ownerContext.declaringClass,
       lexicalThisClass: ownerContext.lexicalThisClass
     });
   }