@neocompose/cli 0.84.4 → 0.84.5

package/dist/test-worker.mjs

@@ -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,
@@ -17571,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);
@@ -36447,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;
@@ -43931,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,
@@ -44123,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();
@@ -44149,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;
     }
@@ -44207,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,
@@ -44850,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);
             }
@@ -45783,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);
       }
@@ -46010,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,
@@ -46057,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);
@@ -46105,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(
@@ -46265,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(
@@ -46508,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,
@@ -47244,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": {
@@ -47848,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.",
@@ -47880,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);
@@ -48022,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);
@@ -48044,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);
@@ -48062,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)) {
@@ -48083,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 = {
@@ -48095,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);
         }
@@ -48104,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 ? {
@@ -48384,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,
@@ -48393,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) {
@@ -52400,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);
@@ -52452,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
@@ -52469,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,
@@ -52506,7 +52687,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         expression.pos
       );
     }
-    if (expected) {
+    if (expected && !assignmentType) {
       this.requireAssignable(
         whenTrue.type,
         expected,
@@ -53394,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 ?? {};
@@ -53407,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);
@@ -54388,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))
@@ -54401,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";
 }
@@ -59464,7 +59679,7 @@ function compileNSInitializer(code, ctx) {
       {
         ...compilerContext,
         thisClass: lexicalThisClass ?? null,
-        implicitMemberAccess: lexicalThisClass !== null,
+        implicitMemberAccess: lexicalThisClass != null || declaringClass != null,
         staticMember: false
       },
       {
@@ -59735,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 ?? []
@@ -59784,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 } : {}
@@ -59989,7 +60204,7 @@ function valueInitializerCompilationSites(document2) {
     sites.set(row.id, {
       row,
       member,
-      ownerClass: ownerContext.ownerClass,
+      ownerClass: ownerContext.declaringClass,
       lexicalThisClass: ownerContext.lexicalThisClass
     });
   }