@neocompose/cli 0.84.1 → 0.84.3

package/dist/test-worker.mjs

@@ -15965,6 +15965,22 @@ function neoScriptMemberLookupType(type) {
   }
   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)
+    return primary;
+  const declaration = project.typeById.get(primary.typeId);
+  if (declaration?.kind === "class" && (memberName === NEOSCRIPT_CLASS_ID_MEMBER || memberName === "Clone"))
+    return primary;
+  if (declaration?.members.some((member) => member.name === memberName))
+    return primary;
+  for (const bound of Object.values(primary.narrowedInterfaces)) {
+    if (project.typeById.get(bound.typeId)?.members.some((member) => member.name === memberName)) {
+      return { ...bound, nullable: primary.nullable === true };
+    }
+  }
+  return primary;
+}
 function isNeoScriptHandleReferenceTarget(target, isValueType) {
   switch (target.kind) {
     case "list":
@@ -16288,6 +16304,20 @@ 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) {
+    for (const bound of Object.values(target.narrowedInterfaces)) {
+      if (!isNeoScriptTypeAssignable(source, bound, project)) return false;
+    }
+  }
+  if (source.kind === "named" && 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;
+    for (const bound of Object.values(source.narrowedInterfaces)) {
+      if (bound !== direct && isNeoScriptTypeAssignable(bound, target, project))
+        return true;
+    }
+  }
   if (source.kind === "primitive" && target.kind === "primitive") {
     if (source.name === target.name) return true;
     return source.name === "int" && (target.name === "float" || target.name === "decimal");
@@ -16372,9 +16402,40 @@ function isNeoScriptTypeAssignable(source, target, project) {
   }
   return false;
 }
+function withoutNeoScriptInterfaceProofs(type) {
+  if (type.kind !== "named" || type.narrowedInterfaces === void 0)
+    return type;
+  const { narrowedInterfaces: _proofs, ...declared } = type;
+  return declared;
+}
 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)) {
+    const declaredLeft = withoutNeoScriptInterfaceProofs(left);
+    const declaredRight = withoutNeoScriptInterfaceProofs(right);
+    const common = commonNeoScriptAssignableType(
+      declaredLeft,
+      declaredRight,
+      project
+    );
+    if (common?.kind !== "named") return null;
+    const proofs = {};
+    for (const [source, other] of [
+      [left, right],
+      [right, left]
+    ]) {
+      for (const [id, proof] of Object.entries(
+        source.narrowedInterfaces ?? {}
+      )) {
+        if (proofs[id] !== void 0) continue;
+        const opposite = other.narrowedInterfaces?.[id] ?? other;
+        if (isNeoScriptTypeAssignable(opposite, proof, project))
+          proofs[id] = proof;
+      }
+    }
+    return { ...common, narrowedInterfaces: proofs };
+  }
   return null;
 }
 function isNeoVariantTypeId(typeId, project) {
@@ -21196,6 +21257,7 @@ function createdSessionValuesSince(ctx, checkpoint) {
   return created;
 }
 function exportInitializerCollections(created, writes, ctx) {
+  const inPlace = (value) => value instanceof RuntimeSet ? exportRuntimeSetValue(value, ctx) : value;
   const assignedValues = /* @__PURE__ */ new Set();
   const mutatedIds = /* @__PURE__ */ new Set();
   for (const write of writes) {
@@ -21203,83 +21265,134 @@ function exportInitializerCollections(created, writes, ctx) {
     if (destination !== void 0 && "containerValueId" in destination)
       mutatedIds.add(destination.containerValueId);
     if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
-      assignedValues.add(write.value);
+      assignedValues.add(inPlace(write.value));
     }
   }
   const candidates = /* @__PURE__ */ new Set();
+  const inlineFieldsByRowId = /* @__PURE__ */ new Map();
   for (const row of created) {
-    if (assignedValues.has(row.value) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+    const inlineFields = inlineCollectionFields(row, ctx);
+    if (inlineFields !== null) inlineFieldsByRowId.set(row.id, inlineFields);
+    if (inlineFields !== null || assignedValues.has(inPlace(row.value)) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
       candidates.add(row.id);
     }
   }
   if (candidates.size === 0) return created;
   invalidateEvaluatorIndexes(ctx, null);
   const extra = [];
-  const exported = created.map((row) => {
-    if (!candidates.has(row.id)) return row;
-    const member = memberForValueRow(row, ctx);
-    if (member === null) return row;
-    if (!isMemberWithEntries(member)) return row;
-    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
-      return { ...row, value: [] };
-    }
-    if (!assignedValues.has(row.value) && !mutatedIds.has(row.id)) return row;
-    const values = [];
+  const encode = (member, value, genericEnv, collectionOwnerId) => {
+    const rows = [];
     const declarations = /* @__PURE__ */ new Map();
-    const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
-    overlayConcreteGenericEntries(
-      genericEnv,
-      envFromStamp(row.genericBindings)
-    );
-    const materialized = materializeConstructorArgumentValue({
+    const root = materializeConstructorArgumentValue({
       member,
-      value: row.value,
+      value,
       genericEnv,
       ctx,
-      createdValues: values,
+      createdValues: rows,
       createdById: /* @__PURE__ */ new Map(),
       storageKeyDeclarations: declarations,
-      collectionEntriesAreReferences: assignedValues.has(row.value) ? false : void 0,
-      collectionOwnerId: row.id
+      collectionEntriesAreReferences: assignedValues.has(value) ? false : void 0,
+      collectionOwnerId
     });
-    const encoded = { ...row, value: materialized.value };
-    const children = values.filter((value) => value !== materialized);
-    declarations.delete(materialized.id);
-    const groupId = constructorGroupForRow(row.id, ctx);
-    retargetConstructorGroupDependencies(
-      materialized.id,
-      groupId ?? row.id,
-      ctx
-    );
+    const children = rows.filter((row) => row !== root);
+    return { root, children, declarations };
+  };
+  const adopt = (owner, rootId, rows, declarations) => {
+    const groupId = constructorGroupForRow(owner.id, ctx);
+    retargetConstructorGroupDependencies(rootId, groupId ?? owner.id, ctx);
     if (groupId !== null) {
       const state = ctx.__executionState;
       const group = state?.constructorGroups.get(groupId);
-      for (const child of children) {
-        retargetConstructorGroupDependencies(child.id, groupId, ctx);
-        group?.add(child.id);
-        state?.constructorGroupByRowId.set(child.id, groupId);
+      for (const row of rows) {
+        retargetConstructorGroupDependencies(row.id, groupId, ctx);
+        group?.add(row.id);
+        state?.constructorGroupByRowId.set(row.id, groupId);
       }
     }
-    stampCreatedValuesMapKey(children, row.mapKey);
+    stampCreatedValuesMapKey(rows, owner.mapKey);
     applyDeclaredStorageKeyOverrides({
-      createdValues: [encoded, ...children],
+      createdValues: [owner, ...rows],
       declarationByValueId: declarations
     });
-    for (const child of children) {
-      if (!isLiteralValueContent(child)) {
+    for (const row of rows) {
+      if (!isLiteralValueContent(row)) {
         throw new NSGetterRuntimeError(
           "Initializer collection produced an unevaluated row."
         );
       }
-      extra.push(child);
+      extra.push(row);
     }
     for (const [id, declaration] of declarations) {
       ctx.__createdStorageKeyDeclarations?.set(id, declaration);
     }
+  };
+  const exported = created.map((row) => {
+    if (!candidates.has(row.id)) return row;
+    const inlineFields = inlineFieldsByRowId.get(row.id);
+    if (inlineFields !== void 0) {
+      const record4 = { ...inlineFields.record };
+      const encoded2 = { ...row, value: record4 };
+      for (const [key, member2] of inlineFields.members) {
+        const { root: root2, children: children2, declarations: declarations2 } = encode(
+          member2,
+          inPlace(record4[key]),
+          inlineFields.genericEnv
+        );
+        record4[key] = root2.id;
+        adopt(encoded2, root2.id, [root2, ...children2], declarations2);
+      }
+      return encoded2;
+    }
+    const member = memberForValueRow(row, ctx);
+    if (member === null) return row;
+    if (!isMemberWithEntries(member)) return row;
+    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
+      return { ...row, value: [] };
+    }
+    const value = inPlace(row.value);
+    if (!assignedValues.has(value) && !mutatedIds.has(row.id)) return row;
+    const { root, children, declarations } = encode(
+      member,
+      value,
+      rowGenericEnv(row, ctx),
+      row.id
+    );
+    const encoded = { ...row, value: root.value };
+    declarations.delete(root.id);
+    adopt(encoded, root.id, children, declarations);
     return encoded;
   });
   return [...exported, ...extra];
 }
+function inlineCollectionFields(row, ctx) {
+  if (typeof row.classId !== "string") return null;
+  if (!isPlainRecord(row.value)) return null;
+  let fields = null;
+  for (const key in row.value) {
+    const value = row.value[key];
+    if (typeof value !== "object" || value === null) continue;
+    const rawMember = memberForCustomSchemaValue(row.classId, key, ctx);
+    if (rawMember === null) continue;
+    fields ??= {
+      record: row.value,
+      members: /* @__PURE__ */ new Map(),
+      genericEnv: rowGenericEnv(row, ctx)
+    };
+    const member = substituteMember(
+      rawMember,
+      fields.genericEnv,
+      ctx.vm.members,
+      cachedResolvedMember(rawMember, ctx)
+    );
+    if (isMemberWithEntries(member)) fields.members.set(key, member);
+  }
+  return fields === null || fields.members.size === 0 ? null : fields;
+}
+function rowGenericEnv(row, ctx) {
+  const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  overlayConcreteGenericEntries(genericEnv, envFromStamp(row.genericBindings));
+  return genericEnv;
+}
 function prepareSessionValueExport(ctx, checkpoint, writes) {
   const created = createdSessionValuesSince(ctx, checkpoint);
   if (created.length === 0) return;
@@ -32814,6 +32927,7 @@ function clonedConstructorProvenance(source) {
 }
 function cloneConstructorLiteralValue(value) {
   if (typeof value !== "object" || value === null) return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   if (Array.isArray(value)) {
     return value.map((entry) => cloneConstructorLiteralValue(entry));
   }
@@ -35539,7 +35653,8 @@ var Parser = class _Parser {
     }
     if (isIdentifier(t) && t.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD) {
       this.next();
-      const className = isIdentifier(this.peek()) ? this.next().text : null;
+      const classToken = isIdentifier(this.peek()) ? this.next() : null;
+      const className = classToken?.text ?? null;
       const typeArguments = [];
       if (this.eat("operator", "<")) {
         if (className === null) {
@@ -35573,6 +35688,7 @@ var Parser = class _Parser {
       return {
         kind: "new",
         className,
+        ...classToken ? { classNamePos: at(classToken) } : {},
         ...typeArguments.length > 0 ? { typeArguments } : {},
         args,
         ...hasArgumentList ? { hasArgumentList: true } : {},
@@ -37073,7 +37189,7 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
           const typeInfo = parameterTypes.get(parameterId);
           return [
             parameterId,
-            typeInfo !== void 0 && isAggregateTypeInfo(typeInfo) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+            typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
           ];
         }
       )
@@ -37109,6 +37225,41 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       ids.push(edge.targetValueId);
     return ids;
   }
+  /** The targets a row's Reference creation data names (P112 §1.1). */
+  referenceArgumentIds(row) {
+    if (!isLiteralValueContent(row)) return [];
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return [];
+    const ids = [];
+    for (const parameterId of this.referenceParameterIds(row)) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 === "string") ids.push(argument2);
+    }
+    return ids;
+  }
+  /** Creation data with each Reference argument's target remapped (P112 §1.1). */
+  remapReferenceArguments(row, remap, contextualMember) {
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return args;
+    let remapped;
+    for (const parameterId of this.referenceParameterIds(
+      row,
+      contextualMember
+    )) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 !== "string") continue;
+      const target = remap(argument2);
+      if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
+    }
+    return remapped ?? args;
+  }
+  *referenceParameterIds(row, contextualMember) {
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(
+      row,
+      contextualMember
+    ))
+      if (typeInfo.type === 29 /* Reference */) yield parameterId;
+  }
   slotEntries(row) {
     const value = row.value;
     switch (this.referenceSlots(row.id, void 0, value)) {
@@ -38130,7 +38281,11 @@ function resolveVirtualInstanceGraph(args) {
         }
       }
     }
-    const virtualRow = rewriteExpandedRow(indexed, expansion);
+    const virtualRow = rewriteExpandedRow(
+      indexed,
+      expansion,
+      materializedGraph
+    );
     const location = {
       id: effectiveId2,
       instanceRootId: args.instanceRoot.id,
@@ -39384,7 +39539,7 @@ function indexExpansion(args) {
     membersById
   };
 }
-function rewriteExpandedRow(node, expansion) {
+function rewriteExpandedRow(node, expansion, graph) {
   const rewrite = (id) => expansion.nodesByExpandedId.get(id)?.virtualId ?? id;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
@@ -39406,6 +39561,12 @@ function rewriteExpandedRow(node, expansion) {
   if (node.member.kind === 9 /* Lookup */) {
     row.value = remapLookupSelection(row.value, rewrite);
   }
+  if (isLiteralValueContent(row) && row.constructorArgs !== void 0)
+    row.constructorArgs = graph.remapReferenceArguments(
+      row,
+      rewrite,
+      node.member
+    );
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -44500,7 +44661,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             statement.init.pos
           );
         }
-        const localType = declared ?? initial.type;
+        const localType = declared ?? withoutNeoScriptInterfaceProofs(initial.type);
         if (declared) {
           this.requireAssignable(
             initial.type,
@@ -44515,16 +44676,18 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           initial.pointer,
           this.project
         );
-        scope.define(
-          scopeVariable(
-            statement.name,
-            local,
-            localType,
-            "local" /* Local */,
-            localOwnership(initial),
-            this.localWriteTargetRoot(initial, scope)
-          )
+        const entry = scopeVariable(
+          statement.name,
+          local,
+          localType,
+          "local" /* Local */,
+          localOwnership(initial),
+          this.localWriteTargetRoot(initial, scope)
         );
+        scope.define(entry);
+        if (inferred && localType !== initial.type) {
+          scope.narrow(statement.name, entry, initial.type);
+        }
         return { type: "variable" /* Variable */, variable: local };
       }
       case "if": {
@@ -44579,7 +44742,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         mergeBranchInvalidations(scope, branchExitOwnershipScopes);
         if (branchExitNarrowings.length > 0) {
           for (const [path, narrowed] of mergeNarrowingMaps(
-            branchExitNarrowings
+            branchExitNarrowings,
+            this.project
           )) {
             const rootEntry = scope.lookup(pathRoot(path));
             if (rootEntry === narrowed.rootEntry) {
@@ -45505,7 +45669,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   mergeLoopNarrowings(parent, exitPaths) {
     if (exitPaths.length === 0) return;
-    const merged = mergeNarrowingMaps(exitPaths);
+    const merged = mergeNarrowingMaps(exitPaths, this.project);
     for (const [path, narrowed] of parent.effectiveNarrowedPaths()) {
       const common = merged.get(path);
       if (parent.containsEntry(narrowed.rootEntry) && (common?.rootEntry !== narrowed.rootEntry || !typeRefsEqual(common.type, narrowed.type))) {
@@ -47258,8 +47422,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           expression.receiver,
           scope
         );
-        if (receiverExpression.type.kind !== "named") return null;
-        owner = this.project.typeById.get(receiverExpression.type.typeId);
+        const memberType2 = neoScriptMemberReceiverType(
+          receiverExpression.type,
+          expression.name,
+          this.project
+        );
+        if (memberType2.kind !== "named") return null;
+        owner = this.project.typeById.get(memberType2.typeId);
         symbol = owner?.members.find(
           (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
         );
@@ -47270,7 +47439,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
             expression.pos
           );
         }
-        receiver = { kind: "instance", expression: receiverExpression };
+        receiver = {
+          kind: "instance",
+          expression: { ...receiverExpression, type: memberType2 }
+        };
       }
     } else {
       return null;
@@ -47347,9 +47519,13 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         if (symbol === void 0 || symbol.static !== true) return null;
       } else {
         const receiver2 = this.resolveExpression(expression.receiver, scope);
-        if (receiver2.type.kind !== "named") return null;
-        receiverType = receiver2.type;
-        owner = this.project.typeById.get(receiver2.type.typeId);
+        receiverType = neoScriptMemberReceiverType(
+          receiver2.type,
+          expression.name,
+          this.project
+        );
+        if (receiverType.kind !== "named") return null;
+        owner = this.project.typeById.get(receiverType.typeId);
         symbol = owner?.members.find(
           (candidate) => candidate.name === expression.name && (candidate.kind === "function" || candidate.kind === "method")
         );
@@ -47427,6 +47603,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
+    entryType = withoutNeoScriptInterfaceProofs(entryType);
     for (const item of resolved) {
       const common = commonNeoScriptAssignableType(
         entryType,
@@ -47451,7 +47628,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     const type = {
       kind: "list",
-      elementType: entryType
+      elementType: withoutNeoScriptInterfaceProofs(entryType)
     };
     const wire = toWireType(type, this.project);
     if (wire.type !== 6 /* List */) {
@@ -47517,6 +47694,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (!keyType || !valueType) {
       throw new CompileError("Dictionary literal type inference failed.", pos);
     }
+    valueType = withoutNeoScriptInterfaceProofs(valueType);
     for (const entry of resolved) {
       if (expectedDictionary) {
         this.requireAssignable(
@@ -47543,7 +47721,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const type = {
       kind: "dictionary",
       keyType,
-      valueType
+      valueType: withoutNeoScriptInterfaceProofs(valueType)
     };
     const wire = toWireType(type, this.project);
     if (wire.type !== 5 /* Dictionary */) {
@@ -47799,8 +47977,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         const target = this.resolveType(fact.targetType);
         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;
-        const retainConcreteClass = !fact.bindingName && naturalDefinition?.kind === "class" && targetDefinition?.kind === "interface";
-        const narrowed = retainConcreteClass ? { ...natural.type, nullable: false } : { ...target, nullable: false };
+        let narrowed = { ...target, nullable: false };
+        if (!fact.bindingName && 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 = {
+              ...narrowed,
+              narrowedInterfaces: {
+                ...natural.type.narrowedInterfaces,
+                [target.typeId]: target
+              }
+            };
+          }
+        }
         if (mode === "all" && fact.path !== null && rootEntry !== null && place.type.kind !== "reference") {
           targetScope.narrow(fact.path, rootEntry, narrowed);
         }
@@ -48393,7 +48582,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     if (receiver.dialogues !== void 0) {
       return this.resolveDialogueGroupRead(receiver, name, pos);
     }
-    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+    const memberReceiverType = neoScriptMemberReceiverType(
+      receiver.type,
+      name,
+      this.project
+    );
     if (memberReceiverType.kind === "named") {
       const type = this.project.typeById.get(memberReceiverType.typeId);
       if (!type) {
@@ -49205,7 +49398,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     const type = {
       kind: "list",
-      elementType: entryType
+      elementType: withoutNeoScriptInterfaceProofs(entryType)
     };
     const wire = toWireType(type, this.project);
     if (wire.type !== 6 /* List */) {
@@ -49446,7 +49639,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         pos
       );
     }
-    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+    const memberReceiverType = neoScriptMemberReceiverType(
+      receiver.type,
+      callee.name,
+      this.project
+    );
     const namedType2 = memberReceiverType.kind === "named" ? this.project.typeById.get(memberReceiverType.typeId) : void 0;
     const member = namedType2?.members.find(
       (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
@@ -51871,7 +52068,11 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     }
     const receiver = receiverValue();
     if (receiver.dialogues !== void 0) return null;
-    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+    const memberReceiverType = neoScriptMemberReceiverType(
+      receiver.type,
+      memberName,
+      this.project
+    );
     if (memberReceiverType.kind !== "named") return null;
     const type = this.project.typeById.get(memberReceiverType.typeId);
     const symbol = type?.members.find(
@@ -53032,17 +53233,22 @@ function mergeFactSets(sets) {
     )
   );
 }
-function mergeNarrowingMaps(maps) {
+function mergeNarrowingMaps(maps, project) {
   const first = maps[0];
   if (!first) return /* @__PURE__ */ new Map();
   const result = /* @__PURE__ */ new Map();
   for (const [path, narrowed] of first) {
-    if (maps.slice(1).every((map) => {
-      const candidate = map.get(path);
-      return candidate?.rootEntry === narrowed.rootEntry && typeRefsEqual(candidate.type, narrowed.type);
-    })) {
-      result.set(path, narrowed);
+    let common = narrowed.type;
+    for (let index = 1; index < maps.length; index++) {
+      const candidate = maps[index].get(path);
+      if (candidate?.rootEntry !== narrowed.rootEntry) {
+        common = null;
+        break;
+      }
+      common = commonNeoScriptAssignableType(common, candidate.type, project);
+      if (common === null) break;
     }
+    if (common !== null) result.set(path, { ...narrowed, type: common });
   }
   return result;
 }
@@ -53071,6 +53277,16 @@ function typeRefsEqual(left, right) {
   if (left.kind === "named" && right.kind === "named") {
     const leftArgs = left.typeArguments ?? [];
     const rightArgs = right.typeArguments ?? [];
+    if (left.narrowedInterfaces !== right.narrowedInterfaces) {
+      const leftBounds = Object.entries(left.narrowedInterfaces ?? {});
+      const rightBounds = right.narrowedInterfaces ?? {};
+      if (leftBounds.length !== Object.keys(rightBounds).length) return false;
+      for (const [id, leftBound] of leftBounds) {
+        const rightBound = rightBounds[id];
+        if (rightBound === void 0 || !typeRefsEqual(leftBound, rightBound))
+          return false;
+      }
+    }
     return left.typeId === right.typeId && leftArgs.length === rightArgs.length && leftArgs.every((item, index) => {
       const other = rightArgs[index];
       return other !== void 0 && typeRefsEqual(item, other);
@@ -54050,6 +54266,10 @@ function typesOverlap(left, right, project) {
   if (isUnknown(left) || isUnknown(right)) return true;
   if (isNull(left)) return isNullable(right);
   if (isNull(right)) return isNullable(left);
+  left = neoScriptMemberLookupType(left);
+  right = neoScriptMemberLookupType(right);
+  if (left.kind === "typeParameter" || right.kind === "typeParameter")
+    return true;
   if (isNeoScriptTypeAssignable(left, right, project) || isNeoScriptTypeAssignable(right, left, project))
     return true;
   if (left.kind === "named" && right.kind === "named") {
@@ -63988,13 +64208,29 @@ function memberSavedForStorage(ctx, memberId, contextSaved, declarationClassId)
     if (isWritableConstraint(classStorage)) return true;
     if (classStorage === 1 /* Immutable */) return false;
   }
-  const effective = ctx.storageResolver.effectiveStorages(memberId);
+  let effective = ctx.storageResolver.effectiveStorages(memberId);
+  const visited = /* @__PURE__ */ new Set([memberId]);
+  let currentId = memberId;
+  let baseId = member?.extendsMemberId;
+  while (effective.size === 0 && baseId !== void 0 && !visited.has(baseId)) {
+    if (!isResolvedAbstract(ctx, currentId) && !isResolvedAbstract(ctx, baseId))
+      break;
+    visited.add(baseId);
+    effective = ctx.storageResolver.effectiveStorages(baseId);
+    currentId = baseId;
+    baseId = ctx.exportData.members[baseId]?.extendsMemberId;
+  }
   const hasWritable = effective.has(2 /* Save */) || effective.has(3 /* Session */);
   const hasStatic = effective.has(1 /* Immutable */);
   if (hasWritable && !hasStatic) return true;
   if (hasStatic && !hasWritable) return false;
   return contextSaved;
 }
+function isResolvedAbstract(ctx, memberId) {
+  return isAbstractMember(
+    resolveMemberById(ctx, memberId, `members.${memberId}`)
+  );
+}
 function classAllowedStorage(ctx, classId) {
   return ctx.storageResolver.allowedStorage(classId);
 }
@@ -64876,7 +65112,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
     const argType = csharpTypeInfoValueType(
       ctx,
       argInfo,
-      saved,
+      true,
       genericEnv,
       genericBindingSaved
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.84.1",
+  "version": "0.84.3",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",