.

Author: rogeralsing

continue.md

@@ -32,6 +32,7 @@
 - Parameter environments now hang off their function environments so default-parameter `super`/`this` lookups see the right bindings, and sloppy generator methods coerce `this` to the realm global object; the object method definition default-super/sloppy-this generators are passing.
 - Named generator function expressions now skip the internal const name binding when a function-name environment already exists, so sloppy reassignments of the generator name are ignored instead of throwing (covers the generator `reassign-fn-name` and `scope-name-var-open` tests).
 - `yield*` now treats a delegated iterator's `throw` result with `done: true` as a normal completion, propagating the returned `value` and finalizing delegation instead of yielding again (fixes the `star-rhs-iter-thrw-res-*` throw/done cases).
+- GlobalDeclarationInstantiation now resolves restricted globals against the root global object (so `let undefined` is rejected even in strict wrappers), deletable direct-eval bindings no longer block later global lexical declarations, and function hoists on non-extensible globals throw a proper TypeError instead of null-refing in DefineFunctionScoped.
 
 ## Next Iteration Plan
 1. When resuming broader work, run a narrow Language filter outside `ArgumentsObject`/`Array_fromAsync` to find the next hot cluster (avoid full 43k sweep).

src/Asynkron.JsEngine/JsEnvironment.cs

@@ -221,8 +221,11 @@ public void DefineFunctionScoped(
 
             if (!canDeclareFunction)
             {
+                var existingConfig = existingDescriptor?.Configurable;
+                var existingWritable = existingDescriptor?.Writable;
+                var existingEnumerable = existingDescriptor?.Enumerable;
                 LogRealm("DefineFunctionScoped cannot declare global function name={Name} existingConfig={Config} writable={Writable} enumerable={Enumerable}",
-                    name.Name, existingDescriptor.Configurable, existingDescriptor.Writable, existingDescriptor.Enumerable);
+                    name.Name, existingConfig, existingWritable, existingEnumerable);
                 throw StandardLibrary.ThrowTypeError("Cannot redeclare non-configurable global function",
                     context, context?.RealmState);
             }
@@ -907,13 +910,12 @@ internal bool HasRestrictedGlobalProperty(Symbol name)
             return false;
         }
 
-        if (!scope._values.TryGetValue(Symbol.This, out var thisBinding) ||
-            thisBinding.Value is not JsObject globalObject)
+        var descriptor = scope.GetGlobalOwnPropertyDescriptor(name, out var globalObject);
+        if (globalObject is null)
         {
             return false;
         }
 
-        var descriptor = globalObject.GetOwnPropertyDescriptor(name.Name);
         if (descriptor is not null && !descriptor.Configurable)
         {
             return true;
@@ -999,6 +1001,13 @@ public bool HasVarDeclaration(Symbol name)
         // Check if there's a non-lexical binding in _values
         if (_values.TryGetValue(name, out var binding) && !binding.IsLexical)
         {
+            if (binding.CanDelete && IsGlobalFunctionScope)
+            {
+                // Non-strict direct eval creates deletable global var bindings (configurable properties)
+                // which should not block future lexical declarations in GlobalDeclarationInstantiation.
+                return false;
+            }
+
             return true;
         }