diff --git a/ets2panda/compiler/core/ETSCompiler.cpp b/ets2panda/compiler/core/ETSCompiler.cpp
index 75fd7d3de505e7bba5f6d34adae7e5d6b9110aeb..c9cd08f04cfaeee81fe493e404600cde859d02b0 100644
--- a/ets2panda/compiler/core/ETSCompiler.cpp
+++ b/ets2panda/compiler/core/ETSCompiler.cpp
@@ -828,9 +828,13 @@ void ETSCompiler::Compile(const ir::Identifier *expr) const
     }
 
     if (smartType->IsETSReferenceType()) {
+        // #28038: there is a hidden bug in LoadVar when a smart-cast was applied on a previous store
+        etsg->SetAccumulatorType(expr->Variable()->TsType());
+        // #28038: incorrect smart-cast interferes with broken `union as undefined` conversion
+        auto fixupTarget = smartType->IsETSUndefinedType() ? etsg->GetAccumulatorType() : smartType;
         //  In case when smart cast type of identifier differs from initial variable type perform cast if required
-        if (!etsg->Checker()->AsETSChecker()->Relation()->IsSupertypeOf(smartType, etsg->GetAccumulatorType())) {
-            etsg->CastToReftype(expr, smartType, false);
+        if (!etsg->Checker()->AsETSChecker()->Relation()->IsSupertypeOf(fixupTarget, etsg->GetAccumulatorType())) {
+            etsg->CastToReftype(expr, fixupTarget, false);
         }
     } else if (smartType->IsETSPrimitiveType()) {
         etsg->ApplyConversionCast(expr, smartType);
diff --git a/ets2panda/compiler/core/ETSGen.cpp b/ets2panda/compiler/core/ETSGen.cpp
index 0a724cf0d7e6f21d80a75d3dfc640b4b1a9d6e4e..7fa5f683506ebccf2e5841f5b6411565277920ed 100644
--- a/ets2panda/compiler/core/ETSGen.cpp
+++ b/ets2panda/compiler/core/ETSGen.cpp
@@ -606,6 +606,8 @@ void ETSGen::TestIsInstanceType(const ir::AstNode *const node, std::tuple<Label
     LoadAccumulator(node, srcReg);
 
     switch (checker::ETSChecker::ETSType(target)) {
+        case checker::TypeFlag::ETS_NEVER:
+            break;
         case checker::TypeFlag::ETS_UNDEFINED:
         case checker::TypeFlag::ETS_VOID:
             BranchIfUndefined(node, ifTrue);
@@ -632,6 +634,10 @@ void ETSGen::TestIsInstanceType(const ir::AstNode *const node, std::tuple<Label
             break;
         }
         case checker::TypeFlag::ETS_UNION: {
+            if (target->PossiblyETSUndefined()) {
+                LoadAccumulator(node, srcReg);
+                BranchIfUndefined(node, ifTrue);
+            }
             if (!target->PossiblyETSNull() && IsNullUnsafeObjectType(target)) {
                 BranchIfNull(node, ifFalse);
             }
@@ -655,17 +661,12 @@ void ETSGen::BranchIfIsInstance(const ir::AstNode *const node, const VReg srcReg
     if (!target->PossiblyETSUndefined()) {
         LoadAccumulator(node, srcReg);
         BranchIfUndefined(node, ifFalse);
-    } else if (target->IsETSUnionType()) {
-        LoadAccumulator(node, srcReg);
-        BranchIfUndefined(node, ifTrue);
     }
 
-    if (!target->IsETSNeverType()) {
-        // #21835: type-alias in ApparentType
-        TestIsInstanceType(node, std::tie(ifTrue, ifFalse),
-                           target->IsETSTypeAliasType() ? target->AsETSTypeAliasType()->GetTargetType() : target,
-                           srcReg, target->PossiblyETSNull());
-    }
+    // #21835: type-alias in ApparentType
+    TestIsInstanceType(node, std::tie(ifTrue, ifFalse),
+                       target->IsETSTypeAliasType() ? target->AsETSTypeAliasType()->GetTargetType() : target, srcReg,
+                       target->PossiblyETSNull());
 
     SetLabel(node, ifFalse);
     SetAccumulatorType(nullptr);
@@ -735,77 +736,70 @@ void ETSGen::EmitAnyCheckCast(const ir::AstNode *node, const checker::Type *targ
 // optimized specialization for object and [] targets
 void ETSGen::CheckedReferenceNarrowingObject(const ir::AstNode *node, const checker::Type *target)
 {
-    ES2PANDA_ASSERT(target->IsETSObjectType() || target->IsETSArrayType() || target->IsETSTupleType());
+    (void)node;
+    (void)target;
+}
+
+// Implemented on top of the runtime type system, do not relax checks, do not introduce new types
+void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::Type *target)
+{
+    target = Checker()->GetApparentType(target);
+    auto const source = GetAccumulatorType();
+    ES2PANDA_ASSERT(target != nullptr && source != nullptr);
+    ES2PANDA_ASSERT(target->IsETSReferenceType());
+
     const RegScope rs(this);
     const auto srcReg = AllocReg();
+    auto end = AllocLabel();
+
     StoreAccumulator(node, srcReg);
+    if (target->IsETSVoidType() || target->IsETSAnyType()) {  // NOTE(vpukhov): #19701 void refactoring
+        SetAccumulatorType(target);
+        return;
+    }
+    if (target->IsETSNeverType()) {
+        EmitFailedTypeCastException(node, srcReg, target);
+        SetAccumulatorType(target);
+        return;
+    }
+    if (target->DefinitelyETSNullish()) {
+        if (target->PossiblyETSUndefined()) {
+            BranchIfUndefined(node, end);
+        }
+        if (target->PossiblyETSNull()) {
+            BranchIfNull(node, end);
+        }
+        EmitFailedTypeCastException(node, srcReg, target);
+        SetLabel(node, end);
+        LoadAccumulator(node, srcReg);
+        SetAccumulatorType(target);
+        return;
+    }
 
     auto isNullish = AllocLabel();
-    auto end = AllocLabel();
     bool nullishCheck = false;
 
-    auto *source = GetAccumulatorType();
-    ES2PANDA_ASSERT(source != nullptr);
-    if (source->PossiblyETSUndefined()) {
+    if (source->PossiblyETSUndefined() && !target->PossiblyETSUndefined()) {
         nullishCheck = true;
         BranchIfUndefined(node, isNullish);
     }
-    if (source->PossiblyETSNull() && IsNullUnsafeObjectType(target)) {
+    if (source->PossiblyETSNull() && !target->PossiblyETSNull() && IsNullUnsafeObjectType(target)) {
         nullishCheck = true;
         BranchIfNull(node, isNullish);
     }
 
     if (!nullishCheck) {
-        InternalCheckCast(node, target);
+        EmitCheckCast(node, ToAssemblerType(target));
     } else {
         LoadAccumulator(node, srcReg);
-        InternalCheckCast(node, target);
+        EmitCheckCast(node, ToAssemblerType(target));
         JumpTo(node, end);
 
         SetLabel(node, isNullish);
         EmitFailedTypeCastException(node, srcReg, target);
 
         SetLabel(node, end);
-        SetAccumulatorType(target);
-    }
-}
-
-// Implemented on top of the runtime type system, do not relax checks, do not introduce new types
-void ETSGen::CheckedReferenceNarrowing(const ir::AstNode *node, const checker::Type *target)
-{
-    // NOTE(vpukhov): #19701 void refactoring
-    if (target->IsETSVoidType()) {
-        SetAccumulatorType(target);
-        return;
-    }
-
-    target = Checker()->GetApparentType(target);
-    ES2PANDA_ASSERT(target != nullptr);
-    ES2PANDA_ASSERT(target->IsETSReferenceType());
-
-    if (target->IsETSAnyType()) {  // should be IsSupertypeOf(target, source)
-        SetAccumulatorType(target);
-        return;
     }
-    if (target->HasTypeFlag(checker::TypeFlag::ETS_ARRAY_OR_OBJECT | checker::TypeFlag::ETS_TUPLE) &&
-        !target->IsConstantType()) {
-        CheckedReferenceNarrowingObject(node, target);
-        return;
-    }
-
-    const RegScope rs(this);
-    const auto srcReg = AllocReg();
-    auto ifTrue = AllocLabel();
-
-    StoreAccumulator(node, srcReg);
-    BranchIfIsInstance(node, srcReg, target, ifTrue);
-
-    EmitFailedTypeCastException(node, srcReg, target);
-
-    SetLabel(node, ifTrue);
-    LoadAccumulator(node, srcReg);
-    // Verifier can't infer type if isinstance met, help him
-    EmitCheckCast(node, ToAssemblerType(target));
     SetAccumulatorType(target);
 }
 
@@ -825,21 +819,29 @@ void ETSGen::GuardUncheckedType(const ir::AstNode *node, const checker::Type *un
     SetAccumulatorType(target);
 }
 
-void ETSGen::EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target,
-                                         bool isUndef)
+void ETSGen::EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target)
 {
     const RegScope rs(this);
     const auto errorReg = AllocReg();
 
-    if (isUndef) {
-        Sa().Emit<Movi>(node, errorReg, 1.0);
+    if (target->DefinitelyETSNullish() || target->IsETSNeverType()) {
+        Sa().Emit<Movi>(node, errorReg, 0);
+        LoadAccumulatorUndefined(node);
     } else {
-        Sa().Emit<Movi>(node, errorReg, 0.0);
+        if (const_cast<checker::ETSChecker *>(Checker())->Relation()->IsSupertypeOf(
+                target, Checker()->GlobalETSUndefinedType())) {
+            Sa().Emit<Movi>(node, errorReg, 1);
+        } else {
+            Sa().Emit<Movi>(node, errorReg, 0);
+        }
+        EmitLdaType(node, ToAssemblerType(target));
     }
     SetVRegType(errorReg, Checker()->GlobalETSBooleanType());
-    LoadAccumulatorString(node, util::UString(target->ToString(), Allocator()).View());
-    Ra().Emit<CallAcc, 2U>(node, Signatures::BUILTIN_RUNTIME_FAILED_TYPE_CAST_EXCEPTION, src, errorReg, dummyReg_, 1);
-    StoreAccumulator(node, errorReg);
+    constexpr auto BUILTIN_RUNTIME_FAILED_TYPE_CAST_STUB =
+        "std.core.Runtime.failedTypeCastStub:std.core.Object;{Ustd.core.Class,std.core.String};"
+        "i32;std.core.ClassCastError;";
+    Ra().Emit<CallAcc, 2U>(node, BUILTIN_RUNTIME_FAILED_TYPE_CAST_STUB, src, errorReg, dummyReg_, 1);
+    Ra().Emit<StaObj>(node, errorReg);
     EmitThrow(node, errorReg);
     SetAccumulatorType(nullptr);
 }
diff --git a/ets2panda/compiler/core/ETSGen.h b/ets2panda/compiler/core/ETSGen.h
index 71ce602b2cb96500fec0689a1ffb17d324e71db5..ad0754a0564c32b2115ac9abe279182e8ba5db3c 100644
--- a/ets2panda/compiler/core/ETSGen.h
+++ b/ets2panda/compiler/core/ETSGen.h
@@ -96,8 +96,7 @@ public:
     void BranchIfIsInstance(const ir::AstNode *node, VReg srcReg, const checker::Type *target, Label *ifTrue);
     void BranchIfIsInstanceUnion(const ir::AstNode *node, VReg srcReg, const checker::Type *target, Label *ifTrue);
     void IsInstance(const ir::AstNode *node, VReg srcReg, checker::Type const *target);
-    void EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target,
-                                     bool isUndef = false);
+    void EmitFailedTypeCastException(const ir::AstNode *node, const VReg src, checker::Type const *target);
 
     void EmitNullcheck([[maybe_unused]] const ir::AstNode *node)
     {
diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml
index 623d21e1f9414f8a71b6ce90acbf654cb97f7aec..683041badcb5eb64651c2d83d0c4c41ed586efe8 100644
--- a/ets2panda/compiler/scripts/signatures.yaml
+++ b/ets2panda/compiler/scripts/signatures.yaml
@@ -786,12 +786,6 @@ signatures:
     return_type: PRIMITIVE_VOID
     ref: BUILTIN_ASSERTION_ERROR_CTOR
 
-  - callee: BUILTIN_RUNTIME
-    method_name: failedTypeCastException
-    params: [BUILTIN_OBJECT, BUILTIN_STRING, PRIMITIVE_BOOLEAN]
-    return_type: BUILTIN_CLASS_CAST_ERROR
-    ref: BUILTIN_RUNTIME_FAILED_TYPE_CAST_EXCEPTION
-
   - callee: BUILTIN_ERROR
     method_name: $CTOR
     params: [BUILTIN_STRING]
diff --git a/ets2panda/test/runtime/ets/UncheckedCasts.ets b/ets2panda/test/runtime/ets/UncheckedCasts.ets
index 5e220a3f8f0cb555bfd2727bc40f70b8d121ec0b..3feb4697361cdd0687d508a6419a05b43b361194 100644
--- a/ets2panda/test/runtime/ets/UncheckedCasts.ets
+++ b/ets2panda/test/runtime/ets/UncheckedCasts.ets
@@ -31,6 +31,11 @@ class X<T> { }
 function erase<T>(x: Object | null | undefined): T { return x as T; }
 
 function test_substitution() {
+    assert_ccexc(() => { erase<undefined>(new Object()); })
+    assert_ccexc(() => { erase<null>(new Object()); })
+    assert_ccexc(() => { erase<undefined | null>(new Object()); })
+    assert_ccexc(() => { erase<string>(new Object()); })
+
     assert_ccexc(() => { erase<Object>(null); })
     assert_ccexc(() => { erase<Object>(undefined); })
     assert_ccexc(() => { erase<A>(null); })
diff --git a/ets2panda/test/runtime/ets/fields_with_late_initialization/class_late_initialization_with_generic_field_02.ets b/ets2panda/test/runtime/ets/fields_with_late_initialization/class_late_initialization_with_generic_field_02.ets
index d1478f1f5f330868429d21399d8ffc1ee07717ca..f02efb12141c67aa3194878ed84c2395c86a793c 100644
--- a/ets2panda/test/runtime/ets/fields_with_late_initialization/class_late_initialization_with_generic_field_02.ets
+++ b/ets2panda/test/runtime/ets/fields_with_late_initialization/class_late_initialization_with_generic_field_02.ets
@@ -39,7 +39,7 @@ function main(): void {
   try {
     console.log(gen.genericField);
   } catch (e) {
-    arktest.assertTrue(e instanceof ClassCastError)
+    arktest.assertTrue(e instanceof NullPointerError)
   }
   gen.genericField = "1"
   arktest.assertEQ(gen.genericField, "1")
diff --git a/ets2panda/test/unit/union_emit_test.cpp b/ets2panda/test/unit/union_emit_test.cpp
index 47134d0b4f4334d4d2d230d68aca808426e9e267..ddcfc2819cac227df71441c9ad5d6ce55b9eb9c7 100644
--- a/ets2panda/test/unit/union_emit_test.cpp
+++ b/ets2panda/test/unit/union_emit_test.cpp
@@ -215,12 +215,8 @@ TEST_F(UnionAsmTest, union_test_generic_checkcast)
 
     CheckInsInFunction("dummy.ETSGLOBAL.test1:dummy.X;{Ustd.core.Double,std.core.String};",
                        "checkcast {Ustd.core.Double,std.core.String}", true);
-    CheckInsInFunction("dummy.ETSGLOBAL.test1:dummy.X;{Ustd.core.Double,std.core.String};",
-                       "std.core.Runtime.failedTypeCastException", true);
     CheckInsInFunction("dummy.ETSGLOBAL.test2:dummy.X;{Ustd.core.Double,std.core.String};",
                        "checkcast {Ustd.core.Double,std.core.String}", true);
-    CheckInsInFunction("dummy.ETSGLOBAL.test2:dummy.X;{Ustd.core.Double,std.core.String};",
-                       "std.core.Runtime.failedTypeCastException", true);
 }
 
 TEST_F(UnionAsmTest, union_test_as)
@@ -231,7 +227,6 @@ TEST_F(UnionAsmTest, union_test_as)
 
     CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "checkcast {Ustd.core.Double,std.core.String}",
                        true);
-    CheckInsInFunction("dummy.ETSGLOBAL.test1:std.core.String;void;", "std.core.Runtime.failedTypeCastException", true);
 }
 
 }  // namespace ark::es2panda::compiler::test