JSModuleLoader.cpp

/*
 * Copyright (C) 2015-2021, 2026 Apple Inc. All rights reserved.
 * Copyright (C) 2016 Yusuke Suzuki <utatane.tea@gmail.com>.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "JSModuleLoader.h"
#include "ProgramExecutable.h"

#include "BuiltinNames.h"
#include "Completion.h"
#include "GlobalObjectMethodTable.h"
#include "JSCInlines.h"
#include "JSMicrotask.h"
#include "JSModuleNamespaceObject.h"
#include "JSModuleRecord.h"
#include "JSPromise.h"
#include "JSSourceCode.h"
#include "JSWebAssembly.h"
#include "Microtask.h"
#include "ModuleAnalyzer.h"
#include "ModuleLoadingContext.h"
#include "ModuleRegistryEntry.h"
#include "Nodes.h"
#include "ObjectConstructor.h"
#include "Parser.h"
#include "ParserError.h"
#include "Symbol.h"
#include "SyntheticModuleRecord.h"
#include "TopExceptionScope.h"
#include "VMTrapsInlines.h"
#include <wtf/text/MakeString.h>

namespace JSC {

namespace JSModuleLoaderInternal {
static constexpr unsigned maximumResolutionFailures = 128;
}

static Identifier jsValueToSpecifier(JSGlobalObject* globalObject, JSValue value)
{
    if (value.isSymbol())
        return Identifier::fromUid(uncheckedDowncast<Symbol>(value)->privateName());
    ASSERT(value.isString());
    return asString(value)->toIdentifier(globalObject);
}

bool JSModuleLoader::isFetchError(JSGlobalObject* globalObject, ErrorInstance* error)
{
    VM& vm = globalObject->vm();
    return error->hasOwnProperty(globalObject, vm.propertyNames->builtinNames().moduleFetchFailureKindPrivateName());
}

// Web Platform Tests requires that import() promises reject with difference error object instances for fetch errors.
// It also requires that errors be cached. To satisfy both requirements, it's necessary to duplicate errors.
ErrorInstance* JSModuleLoader::duplicateTypeError(JSGlobalObject* globalObject, ErrorInstance* error)
{
    ASSERT(error);

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    auto* copy = uncheckedDowncast<ErrorInstance>(createTypeErrorCopy(globalObject, error));
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto copyField = [&](const Identifier& name) -> bool {
        if (JSValue value = error->getDirect(vm, name)) {
            copy->putDirect(vm, name, value);
            RETURN_IF_EXCEPTION(scope, false);
        }

        return true;
    };

    const BuiltinNames& names = vm.propertyNames->builtinNames();

    if (!copyField(names.moduleFetchFailureKindPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleRecordPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleKeyPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleTypePrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureKindPrivateName()))
        return nullptr;

    return copy;
}

ErrorInstance* JSModuleLoader::duplicateError(JSGlobalObject* globalObject, ErrorInstance* error)
{
    ASSERT(error);

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    if (error->errorType() == ErrorType::TypeError)
        RELEASE_AND_RETURN(scope, JSModuleLoader::duplicateTypeError(globalObject, error));

    String message = error->sanitizedMessageString(globalObject);
    RETURN_IF_EXCEPTION(scope, nullptr);

    ErrorInstance* out = ErrorInstance::create(globalObject, WTF::move(message), error->errorType(), { }, { }, { });
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto copyField = [&](const Identifier& name) -> bool {
        if (JSValue value = error->getDirect(vm, name)) {
            out->putDirect(vm, name, value);
            RETURN_IF_EXCEPTION(scope, false);
        }
        return true;
    };

    const BuiltinNames& names = vm.propertyNames->builtinNames();

    if (!copyField(names.moduleFetchFailureKindPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleRecordPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleKeyPrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureModuleTypePrivateName()))
        return nullptr;

    if (!copyField(names.moduleFailureKindPrivateName()))
        return nullptr;

    return out;
}

ErrorInstance* JSModuleLoader::maybeDuplicateFetchError(JSGlobalObject* globalObject, ErrorInstance* error)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    if (error->hasOwnProperty(globalObject, vm.propertyNames->builtinNames().moduleFetchFailureKindPrivateName())) {
        error = JSModuleLoader::duplicateError(globalObject, error);
        RETURN_IF_EXCEPTION(scope, nullptr);
    }

    RELEASE_AND_RETURN(scope, error);
}

JSModuleLoader::ModuleFailure::ModuleFailure(AbstractModuleRecord* source, ScriptFetchParameters::Type type, Kind kind)
    : m_source(source)
    , m_key(source->moduleKey())
    , m_type(type)
    , m_kind(kind)
{
}

JSModuleLoader::ModuleFailure::ModuleFailure(Identifier key, ScriptFetchParameters::Type type, Kind kind)
    : m_source(nullptr)
    , m_key(WTF::move(key))
    , m_type(type)
    , m_kind(kind)
{
}

bool JSModuleLoader::ModuleFailure::isEvaluationError(const Identifier& expectedSpecifier, ScriptFetchParameters::Type expectedType) const
{
    return m_kind == ModuleFailure::Kind::Evaluation || (!m_key.isNull() && m_key != expectedSpecifier) || (m_type != ScriptFetchParameters::None && m_type != expectedType);
}

JSModuleLoader::ModuleFailure::operator bool() const
{
    return m_source != nullptr || !m_key.isNull() || m_type != ScriptFetchParameters::Type::None || m_kind != ModuleFailure::Kind::Unknown;
}

JSModuleLoader::ModuleFailure JSModuleLoader::getErrorInfo(JSGlobalObject* globalObject, ErrorInstance* error)
{
    VM& vm = globalObject->vm();
    JSModuleLoader::ModuleFailure failure;
    if (JSValue sourceValue = error->getDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleRecordPrivateName()))
        failure.m_source = dynamicDowncast<AbstractModuleRecord>(sourceValue);
    if (JSValue keyValue = error->getDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleKeyPrivateName()))
        failure.m_key = jsValueToSpecifier(globalObject, keyValue);
    if (JSValue typeValue = error->getDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleTypePrivateName()))
        failure.m_type = static_cast<ScriptFetchParameters::Type>(typeValue.asInt32());
    if (JSValue kindValue = error->getDirect(vm, vm.propertyNames->builtinNames().moduleFailureKindPrivateName()))
        failure.m_kind = static_cast<JSModuleLoader::ModuleFailure::Kind>(kindValue.asInt32());
    return failure;
}

void JSModuleLoader::attachErrorInfo(JSGlobalObject* globalObject, ErrorInstance* error, AbstractModuleRecord* source, const Identifier& key, ScriptFetchParameters::Type type, JSModuleLoader::ModuleFailure::Kind kind)
{
    VM& vm = globalObject->vm();
    if (source)
        error->putDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleRecordPrivateName(), source);
    if (!key.isNull())
        error->putDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleKeyPrivateName(), identifierToJSValue(vm, key));
    if (type != ScriptFetchParameters::Type::None)
        error->putDirect(vm, vm.propertyNames->builtinNames().moduleFailureModuleTypePrivateName(), jsNumber(std::to_underlying(type)));
    if (kind != JSModuleLoader::ModuleFailure::Kind::Unknown)
        error->putDirect(vm, vm.propertyNames->builtinNames().moduleFailureKindPrivateName(), jsNumber(std::to_underlying(kind)));
}

bool JSModuleLoader::attachErrorInfo(JSGlobalObject* globalObject, Exception* exception, AbstractModuleRecord* source, const Identifier& key, ScriptFetchParameters::Type type, ModuleFailure::Kind kind)
{
    if (auto* error = dynamicDowncast<ErrorInstance>(exception->value())) {
        attachErrorInfo(globalObject, error, source, key, type, kind);
        return true;
    }
    return false;
}

bool JSModuleLoader::attachErrorInfo(JSGlobalObject* globalObject, ThrowScope& scope, AbstractModuleRecord* source, const Identifier& key, ScriptFetchParameters::Type type, ModuleFailure::Kind kind)
{
    if (Exception* exception = scope.exception())
        return attachErrorInfo(globalObject, exception, source, key, type, kind);
    return false;
}

const ClassInfo JSModuleLoader::s_info = { "ModuleLoader"_s, nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSModuleLoader) };

JSModuleLoader::JSModuleLoader(VM& vm, Structure* structure, JSScope* moduleScope)
    : JSCell(vm, structure)
    , m_moduleScope(moduleScope, WriteBarrierEarlyInit)
{
}

JSModuleLoader* JSModuleLoader::create(JSGlobalObject* globalObject, VM& vm, JSScope* moduleScope)
{
    return create(globalObject, vm, vm.moduleLoaderStructure.get(), moduleScope);
}

void JSModuleLoader::destroy(JSCell* cell)
{
    SUPPRESS_MEMORY_UNSAFE_CAST auto* thisObject = static_cast<JSModuleLoader*>(cell);
    thisObject->JSModuleLoader::~JSModuleLoader();
}

void JSModuleLoader::finishCreation(JSGlobalObject* globalObject, VM& vm)
{
    Base::finishCreation(vm);
    ASSERT(inherits(info()));
    // JSModuleRecord::getOrMakeExecutable and CodeCache rely on this shape.
    for (JSScope* scope = moduleScope(); scope != globalObject->globalLexicalEnvironment(); scope = scope->next())
        RELEASE_ASSERT(scope && scope->type() == LexicalEnvironmentType);
}

template<typename Visitor>
void JSModuleLoader::visitChildrenImpl(JSCell* cell, Visitor& visitor)
{
    JSModuleLoader* thisObject = uncheckedDowncast<JSModuleLoader>(cell);
    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    Base::visitChildren(thisObject, visitor);
    visitor.append(thisObject->m_moduleScope);
#if USE(BUN_JSC_ADDITIONS)
    visitor.append(thisObject->m_asyncContext);
#endif
    Locker locker { thisObject->cellLock() };
    auto moduleMapValues = thisObject->m_moduleMap.values();
    visitor.append(moduleMapValues.begin(), moduleMapValues.end());
    auto resolutionFailuresValues = thisObject->m_resolutionFailures.values();
    visitor.append(resolutionFailuresValues.begin(), resolutionFailuresValues.end());
    for (auto& [key, loadedModule] : thisObject->m_loadedModules)
        visitor.append(loadedModule.m_module);
#if USE(BUN_JSC_ADDITIONS)
    visitor.append(thisObject->m_prelinkedRecords.begin(), thisObject->m_prelinkedRecords.end());
#endif
}

DEFINE_VISIT_CHILDREN(JSModuleLoader);

// ------------------------------ Functions --------------------------------

static String printableModuleKey(JSGlobalObject* globalObject, JSValue key)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_TOP_EXCEPTION_SCOPE(vm);
    if (key.isString() || key.isSymbol()) {
        auto propertyName = key.toPropertyKey(globalObject);
        scope.assertNoExceptionExceptTermination(); // This is OK since this function is just for debugging purpose.
        return propertyName.impl();
    }
    return vm.propertyNames->emptyIdentifier.impl();
}

JSArray* JSModuleLoader::dependencyKeysIfEvaluated(JSGlobalObject* globalObject, const String& key)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    Identifier ident = Identifier::fromString(vm, key);

    auto iter = m_moduleMap.find({ ident.impl(), ScriptFetchParameters::Type::JavaScript });

    if (iter == m_moduleMap.end())
        iter = m_moduleMap.find({ ident.impl(), ScriptFetchParameters::Type::WebAssembly });

    if (iter == m_moduleMap.end())
        RELEASE_AND_RETURN(scope, nullptr);

    ModuleRegistryEntry* entry = iter->value.get();
    AbstractModuleRecord* record = entry->record();

    if (record == nullptr)
        RELEASE_AND_RETURN(scope, nullptr);

    if (auto status = entry->status(); status != ModuleRegistryEntry::Status::Fetched && status != ModuleRegistryEntry::Status::EvaluationFailed)
        RELEASE_AND_RETURN(scope, nullptr);

    if (auto* cyclic = dynamicDowncast<CyclicModuleRecord>(record); cyclic && cyclic->status() != CyclicModuleRecord::Status::Evaluated)
        RELEASE_AND_RETURN(scope, nullptr);

    const Vector<AbstractModuleRecord::ModuleRequest>& requests = record->requestedModules();

    JSArray* array = constructEmptyArray(globalObject, nullptr, requests.size());
    RETURN_IF_EXCEPTION(scope, nullptr);

    for (unsigned index = 0; const AbstractModuleRecord::ModuleRequest& request : requests) {
        Identifier resolved = resolve(globalObject, request.m_specifier, ident, nullptr, /* useImportMap */ true);
        RETURN_IF_EXCEPTION(scope, nullptr);
        array->putDirectIndex(globalObject, index++, identifierToJSValue(vm, resolved));
        RETURN_IF_EXCEPTION(scope, nullptr);
    }

    RELEASE_AND_RETURN(scope, array);
}

void JSModuleLoader::provideFetch(JSGlobalObject* globalObject, const Identifier& key, ScriptFetchParameters::Type type, SourceCode&& sourceCode)
{
    ModuleRegistryEntry* entry = ensureRegistered(globalObject, key, type);
    if (entry->status() == ModuleRegistryEntry::Status::New)
        entry->provideFetch(globalObject, WTF::move(sourceCode)); // can throw
}

void JSModuleLoader::provideFetch(JSGlobalObject* globalObject, const Identifier& key, ScriptFetchParameters::Type type, JSSourceCode* jsSourceCode)
{
    ModuleRegistryEntry* entry = ensureRegistered(globalObject, key, type);
    if (entry->status() == ModuleRegistryEntry::Status::New)
        entry->provideFetch(globalObject, jsSourceCode); // can throw
}

JSPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, const Identifier& specifier, RefPtr<ScriptFetchParameters> parameters, RefPtr<ScriptFetcher> scriptFetcher, OptionSet<ModuleLoadFlag> flags, int64_t referrerAsyncOrder, const String& referrer)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    JSPromise* promise = nullptr;

    ScriptFetchParameters::Type type = parameters ? parameters->type() : ScriptFetchParameters::Type::JavaScript;
#if USE(BUN_JSC_ADDITIONS)
    // Preserve the caller's ScriptFetchParameters (HostDefined data) into the loading context
    // before `parameters` is moved into fetch() below.
    RefPtr<ScriptFetchParameters> contextParameters = parameters ? parameters : ScriptFetchParameters::create(type);
#endif

    if (ModuleRegistryEntry* entry = getRegisteredMayBeNull(specifier, type)) {
        if (entry->fetchError())
            removeFailedFetchEntry(entry);
        else {
            JSValue error = entry->error(globalObject);
            RETURN_IF_EXCEPTION(scope, nullptr);
            if (error)
                return JSPromise::rejectedPromise(globalObject, error);

            if (entry->status() != ModuleRegistryEntry::Status::New)
                promise = entry->ensureFetchPromise(globalObject);
#if USE(BUN_JSC_ADDITIONS)
            // Beneath a synchronous load (loadModuleSync), the job that hands a delivered fetch to this promise
            // can be parked in a queue that does not drain before this load has to complete (Bun: a macro's
            // import() of a module that the require(esm) above it requested).
            if (vm.m_synchronousModuleQueue)
                entry->takeSettledFetchSource(vm);
#endif
        }
    }

    if (!promise) {
        promise = fetch(globalObject, identifierToJSValue(vm, specifier), referrer, WTF::move(parameters), scriptFetcher);
        RETURN_IF_EXCEPTION(scope, nullptr);
    }

#if USE(BUN_JSC_ADDITIONS)
    AbstractModuleRecord::ModuleRequest request { specifier, WTF::move(contextParameters) };
#else
    AbstractModuleRecord::ModuleRequest request { specifier, ScriptFetchParameters::create(type) };
#endif
    auto* context = ModuleLoadingContext::create(vm, this, request, WTF::move(scriptFetcher), flags, referrerAsyncOrder);

    JSPromise* intermediatePromise = JSPromise::create(vm, globalObject->promiseStructure());
    intermediatePromise->markAsHandled();
    promise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadTopSettled, intermediatePromise, context);

    JSPromise* resultPromise = JSPromise::create(vm, globalObject->promiseStructure());
    resultPromise->markAsHandled();
    intermediatePromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadTopRejected, resultPromise, context);

    return resultPromise;
}

JSPromise* JSModuleLoader::linkAndEvaluateModule(JSGlobalObject* globalObject, const Identifier& moduleKey, RefPtr<ScriptFetchParameters> parameters, RefPtr<ScriptFetcher> scriptFetcher)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    ScriptFetchParameters::Type type = parameters ? parameters->type() : ScriptFetchParameters::Type::JavaScript;
    ModuleRegistryEntry* entry = ensureRegistered(globalObject, moduleKey, type);
    RETURN_IF_EXCEPTION(scope, nullptr);

    AbstractModuleRecord* record = entry->record();
    ASSERT(record);

    JSValue error = entry->error(globalObject);
    RETURN_IF_EXCEPTION(scope, nullptr);
    if (error) {
        scope.throwException(globalObject, error);
        return nullptr;
    }

    record->link(globalObject, WTF::move(scriptFetcher));
    if (Exception* exception = scope.exception()) {
        attachErrorInfo(globalObject, scope, record, entry->key(), entry->moduleType(), ModuleFailure::Kind::Instantiation);
        entry->setInstantiationError(globalObject, exception->value());
        if (auto* cyclic = dynamicDowncast<CyclicModuleRecord>(record))
            cyclic->setEvaluationError(vm, exception->value());
        return nullptr;
    }

    JSPromise* promise = record->evaluate(globalObject);
    RETURN_IF_EXCEPTION(scope, nullptr);

    error = entry->error(globalObject);
    RETURN_IF_EXCEPTION(scope, nullptr);
    if (error) {
        // At this point, the promise exists but won't be returned. However, it will be rejected later.
        // To prevent an unhandled promise rejection error, we have to explicitly mark the promise as handled.
        promise->markAsHandled();
        scope.throwException(globalObject, error);
        return nullptr;
    }

    return promise;
}

// The referrer of a module fetch is the referring script's base URL, i.e. its module key. An inline
// module's key is a Symbol: it has no URL of its own, so we return the empty string and let the host
// substitute its base URL. A null key means there is no referring script at all.
static String moduleReferrer(const Identifier& referrerKey)
{
    if (referrerKey.isSymbol())
        return emptyString();
    return referrerKey.string();
}

JSPromise* JSModuleLoader::requestImportModule(JSGlobalObject* globalObject, const Identifier& moduleName, const Identifier& referrer, RefPtr<ScriptFetchParameters> parameters, RefPtr<ScriptFetcher> scriptFetcher, bool deferred, int64_t referrerAsyncOrder)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    Identifier resolved = resolve(globalObject, moduleName, referrer, scriptFetcher, /* useImportMap */ true);
    RETURN_IF_EXCEPTION(scope, nullptr);

    OptionSet<ModuleLoadFlag> flags { ModuleLoadFlag::Evaluate, ModuleLoadFlag::Dynamic };
    if (deferred)
        flags.add(ModuleLoadFlag::Deferred);
    // Per "fetch an import() module script graph", the referring script's base URL is the fetch's referrer.
    JSPromise* promise = loadModule(globalObject, resolved, WTF::move(parameters), WTF::move(scriptFetcher), flags, referrerAsyncOrder, moduleReferrer(referrer));
    RETURN_IF_EXCEPTION(scope, nullptr);

    JSPromise* resultPromise = JSPromise::create(vm, globalObject->promiseStructure());
    resultPromise->markAsHandled();
    promise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ImportModuleNamespace, resultPromise, jsUndefined());

    return resultPromise;
}

// https://html.spec.whatwg.org/multipage/webappapis.html#module-type-allowed
static bool moduleTypeIsAllowed(JSGlobalObject* globalObject, ScriptFetchParameters::Type type)
{
    switch (type) {
    case ScriptFetchParameters::JavaScript:
    case ScriptFetchParameters::WebAssembly:
    case ScriptFetchParameters::JSON:
    case ScriptFetchParameters::Text:
    case ScriptFetchParameters::None:
        return true;

    default:
        if (globalObject->globalObjectMethodTable()->moduleTypeIsAllowed)
            return globalObject->globalObjectMethodTable()->moduleTypeIsAllowed(type);

#if USE(BUN_JSC_ADDITIONS)
        // A HostDefined type is one the host said it handles (ScriptFetchParameters::parseType), so without a
        // moduleTypeIsAllowed hook the host's module loader decides, as it did before the hook existed.
        if (type == ScriptFetchParameters::HostDefined)
            return true;
#endif
        return false;
    };
}

JSPromise* JSModuleLoader::importModule(JSGlobalObject* globalObject, JSString* moduleName, JSValue parameters, const SourceOrigin& referrer, bool deferred)
{
    dataLogLnIf(Options::dumpModuleLoadingState(), "Loader [import] ", printableModuleKey(globalObject, moduleName));

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    auto attributes = retrieveImportAttributesFromDynamicImportOptions(globalObject, parameters, { vm.propertyNames->type.impl() });
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto type = retrieveTypeImportAttribute(globalObject, attributes);
    RETURN_IF_EXCEPTION(scope, nullptr);

    if (type && !moduleTypeIsAllowed(globalObject, *type)) {
        auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
        promise->reject(vm, createTypeError(globalObject, "Module type not supported by environment"_s));
        RELEASE_AND_RETURN(scope, promise);
    }

    RefPtr<ScriptFetchParameters> fetchParams;
    if (type) {
#if USE(BUN_JSC_ADDITIONS)
        if (type.value() == ScriptFetchParameters::Type::HostDefined)
            fetchParams = ScriptFetchParameters::create(attributes.get(vm.propertyNames->type.impl()));
        else
#endif
            fetchParams = ScriptFetchParameters::create(type.value());
    }
#if USE(BUN_JSC_ADDITIONS)
    if (!attributes.isEmpty()) {
        // The attributes map is per-request state: never set it on a shared per-type instance.
        if (!fetchParams || fetchParams->type() != ScriptFetchParameters::Type::HostDefined)
            fetchParams = ScriptFetchParameters::createUnique(fetchParams ? fetchParams->type() : ScriptFetchParameters::Type::None);
        fetchParams->setAttributes(WTF::move(attributes));
    }
#endif

    if (globalObject->globalObjectMethodTable()->moduleLoaderImportModule)
        RELEASE_AND_RETURN(scope, globalObject->globalObjectMethodTable()->moduleLoaderImportModule(globalObject, this, moduleName, WTF::move(fetchParams), referrer, deferred));

    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    auto moduleNameString = moduleName->value(globalObject);
    RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));

    scope.release();
    promise->reject(vm, createError(globalObject, makeString("Could not import the module '"_s, moduleNameString.data, "'."_s)));
    return promise;
}

Identifier JSModuleLoader::resolve(JSGlobalObject* globalObject, JSValue name, JSValue referrer, RefPtr<ScriptFetcher> scriptFetcher, bool useImportMap)
{
    dataLogLnIf(Options::dumpModuleLoadingState(), "Loader [resolve] ", printableModuleKey(globalObject, name));

    if (globalObject->globalObjectMethodTable()->moduleLoaderResolve)
        return globalObject->globalObjectMethodTable()->moduleLoaderResolve(globalObject, this, name, referrer, WTF::move(scriptFetcher), useImportMap);
    return name.toPropertyKey(globalObject);
}

Identifier JSModuleLoader::resolve(JSGlobalObject* globalObject, const Identifier& name, const Identifier& referrer, RefPtr<ScriptFetcher> scriptFetcher, bool useImportMap)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    JSValue nameValue = name.isSymbol() || name.isNull() ? jsUndefined() : jsString(vm, name.string());
    RETURN_IF_EXCEPTION(scope, { });

    JSValue referrerValue = referrer.isSymbol() || referrer.isNull() ? jsUndefined() : jsString(vm, referrer.string());
    RETURN_IF_EXCEPTION(scope, { });

    RELEASE_AND_RETURN(scope, resolve(globalObject, nameValue, referrerValue, WTF::move(scriptFetcher), useImportMap));
}

JSPromise* JSModuleLoader::fetch(JSGlobalObject* globalObject, JSValue key, const String& referrer, RefPtr<ScriptFetchParameters> parameters, RefPtr<ScriptFetcher> scriptFetcher)
{
    dataLogLnIf(Options::dumpModuleLoadingState(), "Loader [fetch] ", printableModuleKey(globalObject, key));

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    // https://html.spec.whatwg.org/multipage/webappapis.html#fetching-scripts:module-type-allowed
    // Assert: the result of running the module type allowed steps given moduleType and settingsObject is true.
    // Otherwise, we would not have reached this point because a failure would have been raised when inspecting
    // moduleRequest.[[Attributes]] in HostLoadImportedModule or fetch a single imported module script.
    if (parameters)
        ASSERT(moduleTypeIsAllowed(globalObject, parameters->type()));

    if (globalObject->globalObjectMethodTable()->moduleLoaderFetch)
        RELEASE_AND_RETURN(scope, globalObject->globalObjectMethodTable()->moduleLoaderFetch(globalObject, this, key, referrer, WTF::move(parameters), WTF::move(scriptFetcher)));

    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    String moduleKey = key.toWTFString(globalObject);
    RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));

    scope.release();
    promise->reject(vm, createError(globalObject, makeString("Could not open the module '"_s, moduleKey, "'."_s)));
    return promise;
}

JSObject* JSModuleLoader::createImportMetaProperties(JSGlobalObject* globalObject, JSValue key, JSModuleRecord* moduleRecord, RefPtr<ScriptFetcher> scriptFetcher)
{
    if (globalObject->globalObjectMethodTable()->moduleLoaderCreateImportMetaProperties)
        return globalObject->globalObjectMethodTable()->moduleLoaderCreateImportMetaProperties(globalObject, this, key, moduleRecord, WTF::move(scriptFetcher));
    return constructEmptyObject(globalObject->vm(), globalObject->nullPrototypeObjectStructure());
}

JSValue JSModuleLoader::evaluate(JSGlobalObject* globalObject, JSValue key, JSValue moduleRecordValue, RefPtr<ScriptFetcher> scriptFetcher, JSValue sentValue, JSValue resumeMode)
{
    dataLogLnIf(Options::dumpModuleLoadingState(), "Loader [evaluate] ", printableModuleKey(globalObject, key));

    if (globalObject->globalObjectMethodTable()->moduleLoaderEvaluate)
        return globalObject->globalObjectMethodTable()->moduleLoaderEvaluate(globalObject, this, key, moduleRecordValue, WTF::move(scriptFetcher), sentValue, resumeMode);

    return evaluateNonVirtual(globalObject, key, moduleRecordValue, nullptr, sentValue, resumeMode);
}

JSValue JSModuleLoader::evaluateNonVirtual(JSGlobalObject* globalObject, JSValue, JSValue moduleRecordValue, RefPtr<ScriptFetcher>, JSValue sentValue, JSValue resumeMode)
{
    if (auto* moduleRecord = dynamicDowncast<AbstractModuleRecord>(moduleRecordValue))
        return moduleRecord->evaluate(globalObject, sentValue, resumeMode);
    return jsUndefined();
}

JSModuleNamespaceObject* JSModuleLoader::getModuleNamespaceObject(JSGlobalObject* globalObject, JSValue moduleRecordValue)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    auto* moduleRecord = dynamicDowncast<AbstractModuleRecord>(moduleRecordValue);
    if (!moduleRecord) {
        throwTypeError(globalObject, scope);
        return nullptr;
    }

    RELEASE_AND_RETURN(scope, moduleRecord->getModuleNamespace(globalObject));
}

AbstractModuleRecord* JSModuleLoader::getImportedModule(AbstractModuleRecord* referrer, const AbstractModuleRecord::ModuleRequest& request)
{
    // GetImportedModule(referrer, request)
    // https://tc39.es/ecma262/#sec-GetImportedModule

#if USE(BUN_JSC_ADDITIONS)
    if (AbstractModuleRecord* loaded = referrer->prelinkedRequestedModule(request))
        return loaded;
#endif
    // 1. Let records be a List consisting of each LoadedModuleRequest Record r of referrer.[[LoadedModules]] such that ModuleRequestsEqual(r, request) is true.
    auto iter = referrer->loadedModules().find(ModuleMapKey { request.m_specifier.impl(), request.type() });
    // 2. Assert: records has exactly one element, since LoadRequestedModules has completed successfully on referrer prior to invoking this abstract operation.
    ASSERT(iter != referrer->loadedModules().end());
    // 3. Let record be the sole element of records.
    // 4. Return record.[[Module]].
    return iter->value.m_module.get();
}

JSPromise* JSModuleLoader::hostLoadImportedModule(JSGlobalObject* globalObject, const ModuleReferrer& referrer, const ModuleRequest& moduleRequest, JSCell* payload, RefPtr<ScriptFetcher> scriptFetcher, bool useImportMap)
{
    // HostLoadImportedModule(referrer, moduleRequest, loadState, payload)
    // https://html.spec.whatwg.org/multipage/webappapis.html#hostloadimportedmodule

    ASSERT(isModuleLoaderHostDefinedPayload(payload));

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    Identifier referrerKey;
    CyclicModuleRecord* record = referrer.getModule();

    if (record)
        referrerKey = record->moduleKey();

    ModuleRegistryEntry* mapEntry = nullptr;
    const Identifier& specifier = moduleRequest.m_specifier;
    auto type = moduleRequest.type();

    // Step 14 calls for calling "fetch a single imported module script"
    // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-imported-module-script
    // 3. If the result of running the module type allowed steps given moduleType and settingsObject is false,
    //    then run onComplete given null, and return.
    if (!moduleTypeIsAllowed(globalObject, type)) {
        JSPromise* promise = JSPromise::create(vm, globalObject->promiseStructure());

        auto error = createTypeError(globalObject, "Module type not supported by environment"_s);
        promise->reject(vm, error);

        auto exception = Exception::create(vm, error);
        finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, exception, scriptFetcher);

        RELEASE_AND_RETURN(scope, promise);
    }

    ModuleMapKey moduleMapKey { specifier.impl(), type };

#if USE(BUN_JSC_ADDITIONS)
    // An entry that has its record gets FinishLoadingImportedModule at once, and the caller gets the entry's
    // load promise, which only the load that created the entry fulfills. Beneath a synchronous load
    // (loadModuleSync), the reactions that do so can be parked in a queue that does not drain before this
    // caller's load has to complete (Bun: a macro on the main thread waits for its import() inside
    // require(esm)). A dynamic import does not need that promise: ContinueDynamicImport runs
    // LoadRequestedModules on the record, then links and evaluates it. A top-level graph load (loadModule with
    // a ModuleGraphLoadingState) links when that promise is fulfilled, so it keeps it.
    auto loadPromiseAfterFinish = [&](JSPromise* entryLoadPromise, AbstractModuleRecord* loaded) -> JSPromise* {
        if (!vm.m_synchronousModuleQueue || entryLoadPromise->status() != JSPromise::Status::Pending || !payload->inherits<ModuleLoaderPayload>())
            return entryLoadPromise;
        JSPromise* fulfilled = JSPromise::create(vm, globalObject->promiseStructure());
        fulfilled->markAsHandled();
        fulfilled->fulfill(vm, loaded);
        return fulfilled;
    };
#endif

    // HostLoadImportedModule is required to be idempotent for the same
    // (referrer, moduleRequest) pair. referrer.[[LoadedModules]] is that cache;
    // FinishLoadingImportedModule populates it, and innerModuleLoading consults it,
    // but top-level loadModule (dynamic import) reaches here without checking.
    // Consult it now so we can skip the host resolve() hook for repeat imports.
    {
        auto& loadedModules = record ? record->loadedModules() : m_loadedModules;
        if (auto iter = loadedModules.find(moduleMapKey); iter != loadedModules.end()) {
            AbstractModuleRecord* loaded = iter->value.m_module.get();
            ModuleRegistryEntry* loadedEntry = getRegisteredMayBeNull(loaded->moduleKey(), type);
            ASSERT(loadedEntry);
            ASSERT(loadedEntry->record() == loaded);
#if USE(BUN_JSC_ADDITIONS)
            JSPromise* loadedPromise = loadedEntry->loadedPromise(globalObject);
#else
            JSPromise* loadedPromise = loadedEntry->loadPromise();
#endif
            ASSERT(loadedPromise);
            finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, loaded, scriptFetcher);
            RETURN_IF_EXCEPTION(scope, nullptr);
#if USE(BUN_JSC_ADDITIONS)
            return loadPromiseAfterFinish(loadedPromise, loaded);
#else
            return loadedPromise;
#endif
        }
    }

    if (specifier.isSymbol())
        mapEntry = getRegisteredMayBeNull(specifier, type);

    ResolutionMapKey resolutionKey { referrerKey.impl(), specifier.impl() };

    if (auto error = m_resolutionFailures.get(resolutionKey)) {
        JSValue errorValue = error.get();
        ASSERT(errorValue);
        JSPromise* promise = JSPromise::create(vm, globalObject->promiseStructure());
        promise->reject(vm, errorValue);
        // 9.1. If loadState is not undefined and loadState.[[ErrorToRethrow]] is null, set loadState.[[ErrorToRethrow]] to resolutionError.
        // (Unused.)
        // 9.2. Perform FinishLoadingImportedModule(referrer, moduleRequest, payload, ThrowCompletion(resolutionError)).
        finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, Exception::create(vm, errorValue), scriptFetcher);
        // 9.3. Return.
        RELEASE_AND_RETURN(scope, promise);
    }

    Identifier resolved;

    if (!mapEntry) {
        // 8. Let url be the result of resolving a module specifier given referencingScript and moduleRequest.[[Specifier]], catching any exceptions. If they throw an exception, let resolutionError be the thrown exception.
        resolved = resolve(globalObject, specifier, referrerKey, scriptFetcher, useImportMap);
        // 9. If the previous step threw an exception, then:
        if (Exception* resolutionError = scope.exception()) {
            // A TerminationException is not a resolution failure: it can be neither cleared
            // (rejectWithCaughtException leaves it pending) nor cached, so let it propagate
            // instead of continuing into FinishLoadingImportedModule with it still set.
            if (vm.isTerminationException(resolutionError)) [[unlikely]]
                RELEASE_AND_RETURN(scope, nullptr);
            attachErrorInfo(globalObject, resolutionError, nullptr, specifier, moduleRequest.type(), ModuleFailure::Kind::Instantiation);
            // Cache the resolution error so subsequent calls for the same specifier return the same error object.
            JSValue errorValue = resolutionError->value();
            addResolutionFailure(vm, resolutionKey, errorValue);

            JSPromise* promise = JSPromise::create(vm, globalObject->promiseStructure());
            promise->rejectWithCaughtException(vm, scope);
            // 9.1. If loadState is not undefined and loadState.[[ErrorToRethrow]] is null, set loadState.[[ErrorToRethrow]] to resolutionError.
            // (Unused.)
            // 9.2. Perform FinishLoadingImportedModule(referrer, moduleRequest, payload, ThrowCompletion(resolutionError)).
            finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, Exception::create(vm, errorValue), scriptFetcher);
            // 9.3. Return.
            RELEASE_AND_RETURN(scope, promise);
        }

        moduleMapKey.first = resolved.impl();

        if (auto iter = m_moduleMap.find(moduleMapKey); iter != m_moduleMap.end())
            mapEntry = iter->value.get();
    } else
        resolved = specifier;

    if (mapEntry) {
        ASSERT(mapEntry->status() != ModuleRegistryEntry::Status::New);

        // Only fetching errors should be checked here, not instantiation or evaluation errors.
        // This allows fetch errors to propagate first because they're required to have priority.
        // To avoid a race condition, instantiation errors need to be checked later, not here.
        if (JSValue fetchError = mapEntry->fetchError()) {
            if (auto* errorInstance = dynamicDowncast<ErrorInstance>(fetchError)) {
                fetchError = JSModuleLoader::duplicateError(globalObject, errorInstance);
                RETURN_IF_EXCEPTION(scope, nullptr);
            }

            finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, Exception::create(vm, fetchError), scriptFetcher);
            RETURN_IF_EXCEPTION(scope, nullptr);
            return JSPromise::rejectedPromise(globalObject, fetchError);
        }

#if USE(BUN_JSC_ADDITIONS)
        if (vm.m_synchronousModuleQueue && mapEntry->status() == ModuleRegistryEntry::Status::Fetching) {
            // require(esm) hit a dependency that the surrounding async graph
            // already started loading. Force the fetch+makeModule chain through
            // synchronously so this graph can complete without yielding; the
            // outer async path will see the entry as Fetched when it eventually
            // drains and short-circuit.
            JSPromise* fetchPromise = mapEntry->ensureFetchPromise(globalObject);
            JSPromise* modulePromise = mapEntry->ensureModulePromise(globalObject);
            if (modulePromise->status() == JSPromise::Status::Pending) {
                if (fetchPromise->status() == JSPromise::Status::Pending) {
                    // The host has often delivered this fetch already: beneath a synchronous load it
                    // fetches synchronously, and only the pipeFrom() job that hands the result to
                    // fetchPromise is parked in a queue. Fetch a second time only if it has not.
                    if (!mapEntry->takeSettledFetchSource(vm)) {
                        // Transpilation still in flight — re-issue through the
                        // embedder's synchronous fetch. fetchPromise was already
                        // pipeFrom()'d by the async path which set
                        // isFirstResolvingFunctionCalledFlag, so use the unguarded
                        // fulfill/reject. The ModuleRegistryFetchSettled reaction on
                        // fetchPromise lands on the sync queue and drives the rest of
                        // the chain (including loadPromise).
                        JSPromise* promise = fetch(globalObject, identifierToJSValue(vm, resolved), moduleReferrer(referrerKey), nullptr, scriptFetcher.copyRef());
                        RETURN_IF_EXCEPTION(scope, nullptr);
                        if (promise->status() == JSPromise::Status::Fulfilled)
                            fetchPromise->fulfillPromise(vm, promise->result());
                        else if (promise->status() == JSPromise::Status::Rejected)
                            fetchPromise->rejectPromise(vm, promise->result());
                    }
                } else if (fetchPromise->status() == JSPromise::Status::Fulfilled) {
                    // fetchPromise already settled but its
                    // ModuleRegistryFetchSettled reaction is sitting on the
                    // *normal* microtask queue (it fired before we entered sync
                    // mode). Replay that step inline. The queued
                    // normal-microtask copy will see modulePromise already
                    // settled and bail in moduleRegistryFetchSettled's handler.
                    JSPromise* makePromise = makeModule(globalObject, resolved, uncheckedDowncast<JSSourceCode>(fetchPromise->result()));
                    RETURN_IF_EXCEPTION(scope, nullptr);
                    if (makePromise->status() == JSPromise::Status::Fulfilled) {
                        mapEntry->fetchComplete(globalObject, uncheckedDowncast<AbstractModuleRecord>(makePromise->result()));
                        modulePromise->fulfillPromise(vm, makePromise->result());
                    } else if (makePromise->status() == JSPromise::Status::Rejected)
                        modulePromise->rejectPromise(vm, makePromise->result());
                }
                // The reactions above were diverted to the sync queue but
                // haven't *run* yet — they'll run when the caller's
                // drainSynchronousModuleQueue loop reaches them. The
                // loadPromise()/record() reads below therefore still see the
                // pre-advance state, so fall through to the modulePromise path
                // instead of returning the (still-Pending) cached loadPromise.
            }
        }
#endif

#if USE(BUN_JSC_ADDITIONS)
        JSPromise* promise = mapEntry->loadedPromise(globalObject);
#else
        JSPromise* promise = mapEntry->loadPromise();
#endif
        if (promise) {
            if (AbstractModuleRecord* loaded = mapEntry->record()) {
                finishLoadingImportedModule(globalObject, referrer, moduleRequest, payload, loaded, scriptFetcher);
                RETURN_IF_EXCEPTION(scope, nullptr);
#if USE(BUN_JSC_ADDITIONS)
                promise = loadPromiseAfterFinish(promise, loaded);
#endif
            } else {
                auto* context = ModuleLoadingContext::create(vm, this, ModuleLoadingContext::Step::Cached, referrer, moduleRequest, payload, mapEntry, scriptFetcher);
                JSPromise* resultPromise = JSPromise::create(vm, globalObject->promiseStructure());
                resultPromise->markAsHandled();
                promise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadStep, resultPromise, context);
                promise = resultPromise;
            }

            return promise;
        }
    } else {
        mapEntry = ModuleRegistryEntry::create(vm, this, resolved, type, scriptFetcher);
        Locker locker { cellLock() };
        m_moduleMap.add(moduleMapKey, WriteBarrier<ModuleRegistryEntry>(vm, this, mapEntry));
        didAddModuleMapEntry(type);
    }

    if (mapEntry->status() == ModuleRegistryEntry::Status::New) {
        // Per "fetch the descendants of a module script", the referrer is the referring module's base URL.
        JSPromise* promise = fetch(globalObject, identifierToJSValue(vm, resolved), moduleReferrer(referrerKey), moduleRequest.m_attributes, scriptFetcher);
        RETURN_IF_EXCEPTION(scope, nullptr);

        mapEntry->setStatus(ModuleRegistryEntry::Status::Fetching);
        mapEntry->ensureFetchPromise(globalObject)->pipeFrom(vm, promise);
#if USE(BUN_JSC_ADDITIONS)
        mapEntry->setFetchSource(vm, promise);
#endif
    }
    JSPromise* modulePromise = mapEntry->ensureModulePromise(globalObject);
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto* context = ModuleLoadingContext::create(vm, this, ModuleLoadingContext::Step::Main, referrer, moduleRequest, payload, mapEntry, scriptFetcher);
    JSPromise* loadPromise = JSPromise::create(vm, globalObject->promiseStructure());
    loadPromise->markAsHandled();

    modulePromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadStep, loadPromise, context);

    mapEntry->setLoadPromise(vm, loadPromise);

    return loadPromise;
}

JSPromise* JSModuleLoader::loadModule(JSGlobalObject* globalObject, const ModuleReferrer& referrer, const ModuleRequest& moduleRequest, JSCell* payload, RefPtr<ScriptFetcher> scriptFetcher, OptionSet<ModuleLoadFlag> flags)
{
    ASSERT(isModuleLoaderHostDefinedPayload(payload));
    ASSERT(!flags.contains(ModuleLoadFlag::Dynamic));

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    JSPromise* promise = hostLoadImportedModule(globalObject, referrer, moduleRequest, payload, scriptFetcher, flags.contains(ModuleLoadFlag::UseImportMap));
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto* context = ModuleLoadingContext::create(vm, this, moduleRequest, WTF::move(scriptFetcher), flags);
    JSPromise* resultPromise = JSPromise::create(vm, globalObject->promiseStructure());
    resultPromise->markAsHandled();

    promise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadLinkEvaluateSettled, resultPromise, context);
    resultPromise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleLoadStoreError, nullptr, context);

    return resultPromise;
}

void JSModuleLoader::innerModuleLoading(JSGlobalObject* globalObject, ModuleGraphLoadingState *state, AbstractModuleRecord* startModule)
{
    // InnerModuleLoading(state, module)
    // https://tc39.es/ecma262/#sec-InnerModuleLoading
    //
    // The spec phrases this recursively, with HostLoadImportedModule re-entering
    // via FinishLoadingImportedModule -> ContinueModuleLoading. That re-entry
    // happens once per import edge, but only one-per-module actually enters the
    // step-2 loop body — the rest hit the visited check, decrement the counter
    // and return. With dense `export * from` graphs (E >> V) the per-edge
    // function entry / throw-scope / dynamicDowncast dominates. We instead drain
    // a worklist on the state: ContinueModuleLoading enqueues, and the outermost
    // call drains. Same observable [[Visited]] / [[PendingModulesCount]].

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    state->enqueueInnerLoad(startModule);
    if (state->drainingInnerLoad())
        RELEASE_AND_RETURN(scope, void());
    state->setDrainingInnerLoad(true);

    AbstractModuleRecord* module;
    while ((module = state->takeInnerLoad())) {
        // 1. Assert: state.[[IsLoading]] is true.
        ASSERT(state->isLoading());
        // 2. If module is a Cyclic Module Record, module.[[Status]] is NEW, and state.[[Visited]] does not contain module, then
        // (containsVisited first — it's the cheap pointer-hash check that fails
        //  fast for the common already-seen case before we pay for the dyncast.)
        if (!state->containsVisited(module)) {
            if (auto* cyclic = dynamicDowncast<CyclicModuleRecord>(module); cyclic && cyclic->status() == CyclicModuleRecord::Status::New) {
                // 2.a. Append module to state.[[Visited]].
                state->appendVisited(vm, cyclic);
                // 2.b. Let requestedModulesCount be the number of elements in module.[[RequestedModules]].
                size_t requestedModulesCount = module->requestedModules().size();
                // 2.c. Set state.[[PendingModulesCount]] to state.[[PendingModulesCount]] + requestedModulesCount.
                state->setPendingModulesCount(state->pendingModulesCount() + requestedModulesCount);
                // 2.d. For each ModuleRequest Record request of module.[[RequestedModules]], do
                for (const AbstractModuleRecord::ModuleRequest& request : module->requestedModules()) {
                    // 2.d.i. If AllImportAttributesSupported(request.[[Attributes]]) is false, then
                    // 2.d.i.1. Let error be ThrowCompletion(a newly created SyntaxError object).
                    // 2.d.i.2. Perform ContinueModuleLoading(state, error).
                    // (Not possible.)
                    // 2.d.ii. Else if module.[[LoadedModules]] contains a LoadedModuleRequest Record record such that ModuleRequestsEqual(record, request) is true, then
                    AbstractModuleRecord* loaded = nullptr;
#if USE(BUN_JSC_ADDITIONS)
                    loaded = module->prelinkedRequestedModule(request);
#endif
                    if (!loaded) {
                        if (auto iter = module->loadedModules().find(ModuleMapKey { request.m_specifier.impl(), request.type() }); iter != module->loadedModules().end())
                            loaded = iter->value.m_module.get();
                    }
                    if (loaded) {
                        // 2.d.ii.1. Perform InnerModuleLoading(state, record.[[Module]]).
                        if (state->containsVisited(loaded))
                            state->setPendingModulesCount(state->pendingModulesCount() - 1);
                        else
                            state->enqueueInnerLoad(loaded);
                        if (!state->isLoading())
                            break;
                        continue;
                    }
                    // 2.d.iii. Else,
                    // 2.d.iii.1. Perform HostLoadImportedModule(module, request, state.[[HostDefined]], state).
                    JSPromise* promise = hostLoadImportedModule(globalObject, cyclic, request, state, state->scriptFetcher(), true);
                    if (scope.exception()) [[unlikely]] {
                        state->setDrainingInnerLoad(false);
                        return;
                    }
                    // 2.d.iii.2. NOTE: HostLoadImportedModule will call FinishLoadingImportedModule, which re-enters the graph loading process through ContinueModuleLoading.
                    //
                    // If the requested module is in module.[[LoadedModules]] after the
                    // HostLoadImportedModule call, it was loaded synchronously and
                    // FinishLoadingImportedModule already continued this state, so no
                    // ModuleGraphLoadingError reaction is needed. Membership — not a
                    // loadedModules size delta — is the test: a require(esm) nested
                    // inside the host hook (a CommonJS module evaluated during
                    // makeModule requiring a sibling of this graph) drains the
                    // synchronous module queue, which can run this module's pending
                    // ModuleLoadStep reactions for OTHER requests during the call, so
                    // the size can grow without THIS request having completed — and
                    // grow by more than one.
                    bool needsErrorReaction = !module->loadedModules().contains(ModuleMapKey { request.m_specifier.impl(), request.type() });
                    if (needsErrorReaction)
                        promise->performPromiseThenWithInternalMicrotask(vm, InternalMicrotask::ModuleGraphLoadingError, nullptr, state);
                    // 2.d.iv. If state.[[IsLoading]] is false, return UNUSED.
                    if (!state->isLoading())
                        break;
                }
                if (!state->isLoading()) {
                    state->setDrainingInnerLoad(false);
                    RELEASE_AND_RETURN(scope, void());
                }
            }
        }
        // 3. Assert: state.[[PendingModulesCount]] ≥ 1.
        ASSERT(state->pendingModulesCount() >= 1);
        // 4. Set state.[[PendingModulesCount]] to state.[[PendingModulesCount]] - 1.
        state->setPendingModulesCount(state->pendingModulesCount() - 1);
        // 5. If state.[[PendingModulesCount]] = 0, then
        if (!state->pendingModulesCount()) {
            // 5.a. Set state.[[IsLoading]] to false.
            state->setIsLoading(false);
            // 5.b. For each Cyclic Module Record loaded of state.[[Visited]], do
            state->iterateVisited([](CyclicModuleRecord* loaded) {
                // 5.b.i. If loaded.[[Status]] is NEW, set loaded.[[Status]] to UNLINKED.
                if (loaded->status() == CyclicModuleRecord::Status::New)
                    loaded->setStatus(CyclicModuleRecord::Status::Unlinked);
            });
            // 5.c. Perform ! Call(state.[[PromiseCapability]].[[Resolve]], undefined, « undefined »).
            state->promise()->fulfill(vm, module);
            break;
        }
    }
    // 6. Return UNUSED.
    state->setDrainingInnerLoad(false);
    scope.release();
}

void JSModuleLoader::finishLoadingImportedModule(JSGlobalObject* globalObject, const ModuleReferrer& referrer, const ModuleRequest& moduleRequest, JSCell* payload, ModuleCompletion result, RefPtr<ScriptFetcher> scriptFetcher)
{
    // FinishLoadingImportedModule(referrer, moduleRequest, payload, result)
    // https://tc39.es/ecma262/#sec-FinishLoadingImportedModule

    ASSERT(isModuleLoaderHostDefinedPayload(payload));

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    // 1. If result is a normal completion, then
    if (auto* resultRecord = std::get_if<AbstractModuleRecord*>(&result)) {
        JSCell* owner = nullptr;

        auto& loadedModules = [&] -> ModuleMap<AbstractModuleRecord::LoadedModuleRequest> & {
            if (CyclicModuleRecord* module = referrer.getModule()) {
                owner = module;
                return module->loadedModules();
            }
            ASSERT(referrer.isRealm());
            owner = this;
            return m_loadedModules;
        }();

        ASSERT(owner);

        // 1.a. If referrer.[[LoadedModules]] contains a LoadedModuleRequest Record record such that ModuleRequestsEqual(record, moduleRequest) is true, then
        if (auto iter = loadedModules.find(ModuleMapKey { moduleRequest.m_specifier.impl(), moduleRequest.type() }); iter != loadedModules.end()) {
            // 1.a.i. Assert: record.[[Module]] and result.[[Value]] are the same Module Record.
            ASSERT(iter->value.m_module.get() == *resultRecord);
        // 1.b. Else,
        } else {
            // 1.b.i. Append the LoadedModuleRequest Record { [[Specifier]]: moduleRequest.[[Specifier]], [[Attributes]]: moduleRequest.[[Attributes]], [[Module]]: result.[[Value]] } to referrer.[[LoadedModules]].
            ModuleMapKey key { moduleRequest.m_specifier.impl(), moduleRequest.type() };
            Locker locker { owner->cellLock() };
            AbstractModuleRecord::LoadedModuleRequest value { vm, moduleRequest, *resultRecord, owner };
            loadedModules.add(WTF::move(key), WTF::move(value));
        }
    }

    // 2. If payload is a GraphLoadingState Record, then
    if (auto* state = dynamicDowncast<ModuleGraphLoadingState>(payload)) {
        // 2.a. Perform ContinueModuleLoading(payload, result).
        continueModuleLoading(globalObject, state, result);
        RETURN_IF_EXCEPTION(scope, void());
    // 3. Else,
    } else {
        // 3.a. Perform ContinueDynamicImport(payload, result).
        auto* dynamicPayload = uncheckedDowncast<ModuleLoaderPayload>(payload);
        continueDynamicImport(globalObject, dynamicPayload, result, WTF::move(scriptFetcher));
        RETURN_IF_EXCEPTION(scope, void());
    }

    // 4. Return UNUSED.
    scope.release();
}

void JSModuleLoader::continueModuleLoading(JSGlobalObject* globalObject, ModuleGraphLoadingState *state, ModuleCompletion moduleCompletion)
{
    // ContinueModuleLoading(state, moduleCompletion)
    // https://tc39.es/ecma262/#sec-ContinueModuleLoading

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    // 1. If state.[[IsLoading]] is false, return UNUSED.
    if (!state->isLoading())
        RELEASE_AND_RETURN(scope, void());
    // 2. If moduleCompletion is a normal completion, then
    if (auto* module = std::get_if<AbstractModuleRecord*>(&moduleCompletion)) {
        // 2.a. Perform InnerModuleLoading(state, moduleCompletion.[[Value]]).
        // Per-edge fast path: most calls land here with a module that's already
        // visited (E >> V); skip the dyncast+enqueue and just decrement.
        if (state->containsVisited(*module)) {
            ASSERT(state->pendingModulesCount() > 1 || !state->drainingInnerLoad());
            state->setPendingModulesCount(state->pendingModulesCount() - 1);
            if (!state->pendingModulesCount()) {
                state->setIsLoading(false);
                state->iterateVisited([](CyclicModuleRecord* loaded) {
                    if (loaded->status() == CyclicModuleRecord::Status::New)
                        loaded->setStatus(CyclicModuleRecord::Status::Unlinked);
                });
                state->promise()->fulfill(vm, *module);
            }
        } else if (state->drainingInnerLoad())
            state->enqueueInnerLoad(*module);
        else {
            innerModuleLoading(globalObject, state, *module);
            RETURN_IF_EXCEPTION(scope, void());
        }
    // 3. Else,
    } else {
        // 3.a. Set state.[[IsLoading]] to false.
        state->setIsLoading(false);
        // 3.b. Perform ! Call(state.[[PromiseCapability]].[[Reject]], undefined, « moduleCompletion.[[Value]] »).
        state->promise()->reject(vm, std::get<Exception*>(moduleCompletion)->value());
    }
    // 4. Return UNUSED.
    scope.release();
}

void JSModuleLoader::continueDynamicImport(JSGlobalObject* globalObject, ModuleLoaderPayload* payload, ModuleCompletion completion, RefPtr<ScriptFetcher> scriptFetcher)
{
    // ContinueDynamicImport(promiseCapability, moduleCompletion)
    // https://tc39.es/ecma262/#sec-ContinueDynamicImport

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    JSPromise* promise = payload->promise();

    // 1. If moduleCompletion is an abrupt completion, then
    if (Exception** exception = std::get_if<Exception*>(&completion)) {
        // 1.a. Perform ! Call(promiseCapability.[[Reject]], undefined, « moduleCompletion.[[Value]] »).
        promise->reject(vm, (*exception)->value());
        // 1.b. Return UNUSED.
        scope.assertNoException();
        return;
    }
    // 2. Let module be moduleCompletion.[[Value]].
    auto* module = std::get<AbstractModuleRecord*>(completion);
    // 3. Let loadPromise be module.LoadRequestedModules().
    JSPromise* loadPromise = loadRequestedModules(globalObject, module, WTF::move(scriptFetcher));
    RETURN_IF_EXCEPTION(scope, void());
    // 4-8. Link and evaluate using microtask dispatch instead of closures.
    loadPromise->performPromiseThenWithInternalMicrotask(vm, payload->deferred() ? InternalMicrotask::DynamicImportDeferLoadSettled : InternalMicrotask::DynamicImportLoadSettled, module, payload);
    // 9. Return UNUSED.
    scope.release();
}

JSPromise* JSModuleLoader::loadRequestedModules(JSGlobalObject* globalObject, AbstractModuleRecord* module, RefPtr<ScriptFetcher> scriptFetcher)
{
    // LoadRequestedModules([hostDefined])
    // https://tc39.es/ecma262/#sec-LoadRequestedModules

    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    // 1. If hostDefined is not present, let hostDefined be empty.
    // 2. Let pc be ! NewPromiseCapability(%Promise%).
    JSPromise* pc = JSPromise::create(vm, globalObject->promiseStructure()); // This will eventually be resolved with an AbstractModuleRecord*.
    pc->markAsHandled();
    // 3. Let state be the GraphLoadingState Record { [[IsLoading]]: true, [[PendingModulesCount]]: 1, [[Visited]]: « », [[PromiseCapability]]: pc, [[HostDefined]]: hostDefined }.
    auto state = ModuleGraphLoadingState::create(vm, pc, WTF::move(scriptFetcher));
    RETURN_IF_EXCEPTION(scope, nullptr);
    // 4. Perform InnerModuleLoading(state, module).
    innerModuleLoading(globalObject, state, module);
    RETURN_IF_EXCEPTION(scope, nullptr);
    // 5. Return pc.[[Promise]].
    return pc;
}

ModuleRegistryEntry* JSModuleLoader::ensureRegistered(JSGlobalObject* globalObject, const Identifier& key, ScriptFetchParameters::Type type)
{
    VM& vm = globalObject->vm();

    ModuleMapKey moduleMapKey { key.impl(), type };

    if (auto iter = m_moduleMap.find(moduleMapKey); iter != m_moduleMap.end())
        return iter->value.get();

    ModuleRegistryEntry* entry = ModuleRegistryEntry::create(vm, this, key, type, nullptr);

    Locker locker { cellLock() };
    m_moduleMap.add(moduleMapKey, WriteBarrier<ModuleRegistryEntry>(vm, this, entry));
    didAddModuleMapEntry(type);

    return entry;
}

ModuleRegistryEntry* JSModuleLoader::getRegisteredMayBeNull(const Identifier& key, ScriptFetchParameters::Type type)
{
    if (auto iter = m_moduleMap.find({ key.impl(), type }); iter != m_moduleMap.end())
        return iter->value.get();
    return nullptr;
}

#if USE(BUN_JSC_ADDITIONS)
void JSModuleLoader::setPrelinkedModuleGraph(Ref<PrelinkedModuleGraph>&& graph)
{
    ASSERT(Options::usePrelinkedModuleInfo());
    ASSERT(!m_prelinkedGraph || m_prelinkedGraph == graph.ptr());
    if (m_prelinkedGraph)
        return;
    Locker locker { cellLock() };
    m_prelinkedGraph = WTF::move(graph);
    m_prelinkedRecords.grow(m_prelinkedGraph->moduleCount());
}

void JSModuleLoader::setPrelinkedRecord(VM& vm, uint32_t moduleIndex, AbstractModuleRecord* record)
{
    RELEASE_ASSERT(m_prelinkedGraph && moduleIndex < m_prelinkedRecords.size(), moduleIndex, m_prelinkedRecords.size());
    ASSERT(record->isPrelinked() && record->prelinkedGraph() == m_prelinkedGraph && record->prelinkedIndex() == moduleIndex);
    ASSERT(!m_prelinkedRecords[moduleIndex] || m_prelinkedRecords[moduleIndex].get() == record);
    if (moduleIndex < m_prelinkedRecordRemoved.size() && m_prelinkedRecordRemoved.quickGet(moduleIndex)) [[unlikely]]
        return; // prelinkedRecordForResolution stays null for it; the record itself still works by its own edges
    m_prelinkedRecords[moduleIndex].set(vm, this, record);
}

// A graph edge importer -> target is normally held only by this table (AbstractModuleRecord::prelinkedRequestedModule).
// Before a slot is cleared, put the edges that touch it into the records' own [[LoadedModules]], as they would be for
// ordinary records: the leaving record keeps its targets, and its importers keep it (their memoized import resolutions
// and later GetImportedModule calls name it).
void JSModuleLoader::pinPrelinkedEdges(uint32_t moduleIndex)
{
    AbstractModuleRecord* leaving = m_prelinkedRecords[moduleIndex].get();
    if (!leaving)
        return;
    pinPrelinkedEdgesOf(leaving, PrelinkedModuleGraph::noModule);
    for (auto& slot : m_prelinkedRecords) {
        if (slot && slot.get() != leaving)
            pinPrelinkedEdgesOf(slot.get(), moduleIndex);
    }
}

// importer's edges to onlyTarget (noModule: to every module) whose target is still in the table.
void JSModuleLoader::pinPrelinkedEdgesOf(AbstractModuleRecord* importer, uint32_t onlyTarget)
{
    auto requests = m_prelinkedGraph->requests(importer->prelinkedModule());
    for (unsigned i = 0; i < requests.size(); ++i) {
        uint32_t target = requests[i].moduleIndex;
        if (target == PrelinkedModuleGraph::noModule || (onlyTarget != PrelinkedModuleGraph::noModule && target != onlyTarget))
            continue;
        if (AbstractModuleRecord* record = prelinkedRecordForResolution(target))
            importer->setImportedModule(importer->globalObject(), importer->requestedModules()[i], record);
    }
}

void JSModuleLoader::forgetPrelinkedRecord(uint32_t moduleIndex)
{
    RELEASE_ASSERT(moduleIndex < m_prelinkedRecords.size(), moduleIndex, m_prelinkedRecords.size());
    pinPrelinkedEdges(moduleIndex);
    m_prelinkedRecords[moduleIndex].clear();
    m_prelinkedRecordRemoved.ensureSize(m_prelinkedRecords.size());
    m_prelinkedRecordRemoved.quickSet(moduleIndex);
}

void JSModuleLoader::forgetPrelinkedRecordsWithKey(UniquedStringImpl* keyOrNullForAll)
{
    if (!keyOrNullForAll) {
        // Every slot leaves: pin each edge once, from its importer, while all the targets are still in the table.
        for (auto& slot : m_prelinkedRecords) {
            if (slot)
                pinPrelinkedEdgesOf(slot.get(), PrelinkedModuleGraph::noModule);
        }
    }
    for (unsigned i = 0; i < m_prelinkedRecords.size(); ++i) {
        auto& slot = m_prelinkedRecords[i];
        if (slot && (!keyOrNullForAll || slot->moduleKey().impl() == keyOrNullForAll)) {
            if (keyOrNullForAll)
                pinPrelinkedEdges(i);
            slot.clear();
            m_prelinkedRecordRemoved.ensureSize(m_prelinkedRecords.size());
            m_prelinkedRecordRemoved.quickSet(i);
        }
    }
}

int64_t JSModuleLoader::asyncEvaluationOrderForKey(const Identifier& key)
{
    if (key.isNull() || key.isEmpty())
        return -1;
    auto* entry = getRegisteredMayBeNull(key, ScriptFetchParameters::Type::JavaScript);
    if (!entry)
        return -1;
    auto* cyclic = dynamicDowncast<CyclicModuleRecord>(entry->record());
    if (!cyclic)
        return -1;
    auto order = cyclic->asyncEvaluationOrder();
    return order.hasOrder() ? order.order() : -1;
}
#endif

void JSModuleLoader::removeFailedFetchEntry(ModuleRegistryEntry* entry)
{
    // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script step 13.1.2.
    ASSERT(entry->status() == ModuleRegistryEntry::Status::FetchFailed);
    ModuleMapKey moduleMapKey { entry->key().impl(), entry->moduleType() };
    auto iter = m_moduleMap.find(moduleMapKey);
    if (iter == m_moduleMap.end() || iter->value.get() != entry)
        return;
    Locker locker { cellLock() };
    m_moduleMap.remove(iter);
    didRemoveModuleMapEntry(moduleMapKey.second);
}

void JSModuleLoader::addResolutionFailure(VM& vm, const ResolutionMapKey& key, JSValue error)
{
    Locker locker { cellLock() };
    if (m_resolutionFailures.size() >= JSModuleLoaderInternal::maximumResolutionFailures)
        m_resolutionFailures.remove(m_resolutionFailures.begin());
    m_resolutionFailures.add(key, WriteBarrier<Unknown>(vm, this, error));
}

ProgramExecutable* JSModuleLoader::ModuleReferrer::getScript() const
{
    auto option = std::get_if<ProgramExecutable*>(this);
    return option ? *option : nullptr;
}

CyclicModuleRecord* JSModuleLoader::ModuleReferrer::getModule() const
{
    auto option = std::get_if<CyclicModuleRecord*>(this);
    return option ? *option : nullptr;
}

JSGlobalObject* JSModuleLoader::ModuleReferrer::getRealm() const
{
    auto option = std::get_if<JSGlobalObject*>(this);
    return option ? *option : nullptr;
}

bool JSModuleLoader::ModuleReferrer::isScript() const
{
    return std::holds_alternative<ProgramExecutable*>(*this);
}

bool JSModuleLoader::ModuleReferrer::isModule() const
{
    return std::holds_alternative<CyclicModuleRecord*>(*this);
}

bool JSModuleLoader::ModuleReferrer::isRealm() const
{
    return std::holds_alternative<JSGlobalObject*>(*this);
}

JSValue JSModuleLoader::ModuleReferrer::toJSValue() const
{
    if (auto executable = std::get_if<ProgramExecutable*>(this))
        return *executable;
    if (auto module = std::get_if<CyclicModuleRecord*>(this))
        return *module;
    ASSERT(isRealm());
    return std::get<JSGlobalObject*>(*this);
}

#if USE(BUN_JSC_ADDITIONS)
void JSModuleLoader::drainSynchronousModuleQueue(JSGlobalObject* globalObject)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);
    auto* queue = vm.m_synchronousModuleQueue;
    ASSERT(queue);
    auto& tasks = queue->tasks;
    // FIFO drain. Tasks may append while we iterate, so index by position and
    // never shrink mid-loop. Clear afterwards so the next caller starts fresh.
    size_t i = 0;
    while (i < tasks.size()) {
        auto t = tasks[i++];
        std::array<const JSValue, maxMicrotaskArguments> args { { t.arg0, t.arg1, t.arg2, t.arg3 } };
        runInternalMicrotask(globalObject, vm, t.task, t.payload, args);
        if (scope.exception()) [[unlikely]] {
            // The remaining entries are reactions that performPromiseThen…/
            // triggerPromiseReactions diverted off the global microtask queue.
            // Dropping them would leave their loadPromise/modulePromise pending
            // forever, so hand them back to the global queue (where they would
            // have gone without the synchronous diversion) before propagating
            // the exception. They run on the next normal microtask drain.
            while (i < tasks.size()) {
                auto rest = tasks[i++];
                globalObject->queueMicrotask(vm, rest.task, rest.payload, rest.arg0, rest.arg1, rest.arg2, rest.arg3);
            }
            tasks.shrink(0);
            return;
        }
    }
    tasks.shrink(0);
}

JSPromise* JSModuleLoader::loadModuleSync(JSGlobalObject* globalObject, const Identifier& moduleName, RefPtr<ScriptFetchParameters>&& parameters, RefPtr<ScriptFetcher>&& scriptFetcher)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    VM::SynchronousModuleQueue queue;
    queue.prev = vm.m_synchronousModuleQueue;
    vm.m_synchronousModuleQueue = &queue;
    auto cleanup = WTF::makeScopeExit([&] {
        vm.m_synchronousModuleQueue = queue.prev;
    });

    JSPromise* result = loadModule(globalObject, moduleName, WTF::move(parameters), WTF::move(scriptFetcher), { ModuleLoadFlag::Evaluate });
    RETURN_IF_EXCEPTION(scope, result);

    scope.release();
    drainSynchronousModuleQueue(globalObject);
    return result;
}

extern "C" __attribute__((weak)) EncodedJSValue Bun__analyzeTranspiledModule(JSGlobalObject* globalObject, JSModuleLoader*, const Identifier& moduleKey, const SourceCode& sourceCode, JSPromise* promise)
{
    (void)moduleKey;
    (void)sourceCode;

    VM& vm = globalObject->vm();
    promise->reject(vm, createError(globalObject, makeString("Bun__analyzeTranspiledModule is not implemented"_s)));
    return JSValue::encode(promise);
}
#endif

JSPromise* JSModuleLoader::makeModule(JSGlobalObject* globalObject, const Identifier& moduleKey, JSSourceCode* jsSourceCode)
{
    VM& vm = globalObject->vm();
    auto scope = DECLARE_THROW_SCOPE(vm);

    const SourceCode& sourceCode = jsSourceCode->sourceCode();

    JSPromise* promise = JSPromise::create(vm, globalObject->promiseStructure());
    promise->markAsHandled();

    SourceProviderSourceType sourceType = sourceCode.provider()->sourceType();
    switch (sourceType) {
#if ENABLE(WEBASSEMBLY)
    case SourceProviderSourceType::WebAssembly:
        RELEASE_AND_RETURN(scope, uncheckedDowncast<JSPromise>(JSWebAssembly::instantiate(globalObject, promise, this, sourceCode.provider(), moduleKey, jsSourceCode)));
#endif

    // https://tc39.es/proposal-json-modules/#sec-parse-json-module
    case SourceProviderSourceType::JSON: {
        auto* moduleRecord = SyntheticModuleRecord::parseJSONModule(globalObject, this, moduleKey, SourceCode { sourceCode });
        attachErrorInfo(globalObject, scope, moduleRecord, moduleKey, ScriptFetchParameters::Type::JSON, ModuleFailure::Kind::Evaluation);
        RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));
        scope.release();
        promise->fulfill(vm, moduleRecord);
        return promise;
    }
    case SourceProviderSourceType::Text: {
        auto* moduleRecord = SyntheticModuleRecord::createTextModule(globalObject, this, moduleKey, SourceCode { sourceCode });
        attachErrorInfo(globalObject, scope, moduleRecord, moduleKey, ScriptFetchParameters::Type::Text, ModuleFailure::Kind::Evaluation);
        RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));
        scope.release();
        promise->fulfill(vm, moduleRecord);
        return promise;
    }

#if USE(BUN_JSC_ADDITIONS)
    case SourceProviderSourceType::Synthetic: {
        SyntheticSourceProvider* syntheticSourceProvider = reinterpret_cast<SyntheticSourceProvider*>(sourceCode.provider());
        MarkedArgumentBuffer args;
        Vector<Identifier, 4> exportNames;
        JSObject* lazyExportsSource = syntheticSourceProvider->generate(globalObject, moduleKey, exportNames, args);
        RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));

        auto* moduleRecord = SyntheticModuleRecord::tryCreateWithExportNamesAndValues(globalObject, this, moduleKey, exportNames, args, lazyExportsSource);
        RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));

        scope.release();
        promise->fulfill(vm, moduleRecord);
        return promise;
    }
    case SourceProviderSourceType::BunTranspiledModule: {
        RELEASE_AND_RETURN(scope, uncheckedDowncast<JSPromise>(JSValue::decode(Bun__analyzeTranspiledModule(globalObject, this, moduleKey, sourceCode, promise))));
    }
#endif
    default:
        break;
    }

    ParserError error;
    std::unique_ptr<ModuleProgramNode> moduleProgramNode = parseRootNode<ModuleProgramNode>(
        vm, sourceCode, ImplementationVisibility::Public, JSParserBuiltinMode::NotBuiltin,
        StrictModeLexicallyScopedFeature, JSParserScriptMode::Module, SourceParseMode::ModuleAnalyzeMode, error);
    if (error.isValid()) {
        auto* errorObject = error.toErrorObject(globalObject, sourceCode);
        RETURN_IF_EXCEPTION(scope, promise->rejectWithCaughtException(vm, scope));
        auto* errorInstance = uncheckedDowncast<ErrorInstance>(errorObject);
        attachErrorInfo(globalObject, errorInstance, nullptr, moduleKey, ScriptFetchParameters::JavaScript, ModuleFailure::Kind::Evaluation);
        promise->reject(vm, errorInstance);
        RELEASE_AND_RETURN(scope, promise);
    }
    ASSERT(moduleProgramNode);

    ModuleAnalyzer moduleAnalyzer(globalObject, this, moduleKey, sourceCode, moduleProgramNode->features());
    RETURN_IF_EXCEPTION(scope, nullptr);

    auto result = moduleAnalyzer.analyze(*moduleProgramNode);
    if (!result) {
        auto [errorType, message] = WTF::move(result.error());
        auto* errorInstance = uncheckedDowncast<ErrorInstance>(createError(globalObject, errorType, message));
        attachErrorInfo(globalObject, errorInstance, nullptr, moduleKey, ScriptFetchParameters::JavaScript, ModuleFailure::Kind::Evaluation);
        promise->reject(vm, errorInstance);
        RELEASE_AND_RETURN(scope, promise);
    }

#if USE(BUN_JSC_ADDITIONS)
    size_t memoryCost = result.value()->sourceCode().memoryCost();
    vm.heap.reportExtraMemoryAllocated(result.value(), memoryCost);
#endif
    promise->fulfill(vm, result.value());
    RELEASE_AND_RETURN(scope, promise);
}

} // namespace JSC