@next2d/builder 0.1.7 → 0.1.10

package/templates/xbox/src/worker/WorkerRuntime.cpp

@@ -4,10 +4,14 @@
 #include "EventLoop.h"
 #include "AssetLoader.h"
 #include "bindings/Bindings.h"
+#include "bindings/ImageSource.h"
+#include "platform/ImageTypes.h"
 #include "v8/V8Util.h"
+#include "v8/CodeCache.h"
 
 #include <cstdlib>
 #include <cstring>
+#include <filesystem>
 #include <iostream>
 
 namespace next2d {
@@ -22,14 +26,99 @@ using v8util::ToStdString;
 // ===========================================================================
 namespace {
 
-bool IsOffscreen(v8::Isolate* isolate, v8::Local<v8::Object> obj)
+// ログ用: data:/blob: URL は長大になるため先頭だけに切り詰める
+std::string ShortUrl(const std::string& url)
+{
+    if (url.size() <= 64) {
+        return url;
+    }
+    return url.substr(0, 64) + "... (" + std::to_string(url.size()) + " chars)";
+}
+
+// base64 デコード (data: URL 用)。不正文字があれば false。
+bool DecodeBase64(const std::string& in, std::string* out)
+{
+    auto val6 = [](unsigned char c) -> int {
+        if (c >= 'A' && c <= 'Z') return c - 'A';
+        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+        if (c >= '0' && c <= '9') return c - '0' + 52;
+        if (c == '+') return 62;
+        if (c == '/') return 63;
+        return -1;
+    };
+    out->clear();
+    out->reserve(in.size() * 3 / 4);
+    int val = 0;
+    int bits = -8;
+    for (unsigned char c : in) {
+        if (c == '=') {
+            break;
+        }
+        if (c == '\r' || c == '\n' || c == ' ') {
+            continue;
+        }
+        const int d = val6(c);
+        if (d < 0) {
+            return false;
+        }
+        val = (val << 6) | d;
+        bits += 6;
+        if (bits >= 0) {
+            out->push_back(static_cast<char>((val >> bits) & 0xFF));
+            bits -= 8;
+        }
+    }
+    return true;
+}
+
+// %xx パーセントデコード (非 base64 の data: URL 用)
+std::string PercentDecode(const std::string& s)
+{
+    std::string out;
+    out.reserve(s.size());
+    for (size_t i = 0; i < s.size(); ++i) {
+        if (s[i] == '%' && i + 2 < s.size()) {
+            const auto hex = [](char c) -> int {
+                if (c >= '0' && c <= '9') return c - '0';
+                if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+                if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+                return -1;
+            };
+            const int hi = hex(s[i + 1]);
+            const int lo = hex(s[i + 2]);
+            if (hi >= 0 && lo >= 0) {
+                out.push_back(static_cast<char>((hi << 4) | lo));
+                i += 2;
+                continue;
+            }
+        }
+        out.push_back(s[i]);
+    }
+    return out;
+}
+
+bool HasBoolMarker(v8::Isolate* isolate, v8::Local<v8::Object> obj, const char* name)
 {
     v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
     v8::Local<v8::Value> v;
-    return obj->Get(ctx, Str(isolate, "__isOffscreenCanvas")).ToLocal(&v) &&
+    return obj->Get(ctx, Str(isolate, name)).ToLocal(&v) &&
            v->IsBoolean() && v.As<v8::Boolean>()->Value();
 }
 
+bool IsOffscreen(v8::Isolate* isolate, v8::Local<v8::Object> obj)
+{
+    return HasBoolMarker(isolate, obj, "__isOffscreenCanvas");
+}
+
+bool IsImageBitmapObject(v8::Isolate* isolate, v8::Local<v8::Object> obj)
+{
+    return HasBoolMarker(isolate, obj, "__isImageBitmap");
+}
+
+// WriteHostObject / ReadHostObject のタグ
+constexpr uint32_t kHostObjectOffscreenCanvas = 1;
+constexpr uint32_t kHostObjectImageBitmap = 2;
+
 class SerializerDelegate : public v8::ValueSerializer::Delegate {
 public:
     explicit SerializerDelegate(v8::Isolate* isolate) : isolate_(isolate) {}
@@ -39,18 +128,46 @@ public:
         isolate_->ThrowException(v8::Exception::Error(message));
     }
 
-    // OffscreenCanvas をホストオブジェクトとして扱い WriteHostObject に回す。
+    // すべてのオブジェクトで IsHostObject を照会させる。
+    // OffscreenCanvas は ObjectTemplate 由来ではない plain object のため、
+    // これが無いと V8 は IsHostObject を呼ばず、getContext 等の関数プロパティで
+    // 「could not be cloned」になる。
+    bool HasCustomHostObject(v8::Isolate*) override { return true; }
+
+    // OffscreenCanvas / ImageBitmap をホストオブジェクトとして WriteHostObject に回す。
     v8::Maybe<bool> IsHostObject(v8::Isolate*, v8::Local<v8::Object> object) override
     {
-        return v8::Just(IsOffscreen(isolate_, object));
+        return v8::Just(IsOffscreen(isolate_, object) ||
+                        IsImageBitmapObject(isolate_, object));
     }
 
     v8::Maybe<bool> WriteHostObject(v8::Isolate*, v8::Local<v8::Object> object) override
     {
         v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
-        v8::Local<v8::Value> w, h;
-        object->Get(ctx, Str(isolate_, "width")).ToLocal(&w);
-        object->Get(ctx, Str(isolate_, "height")).ToLocal(&h);
+
+        // ImageBitmap: ピクセルごと複製する (render メッセージの imageBitmaps 用)
+        if (IsImageBitmapObject(isolate_, object)) {
+            const uint8_t* px = nullptr;
+            uint32_t w = 0, h = 0;
+            if (!GetImageSourcePixels(isolate_, object, &px, &w, &h) || !px) {
+                isolate_->ThrowException(v8::Exception::Error(
+                    Str(isolate_, "ImageBitmap clone failed")));
+                return v8::Nothing<bool>();
+            }
+            serializer->WriteUint32(kHostObjectImageBitmap);
+            serializer->WriteUint32(w);
+            serializer->WriteUint32(h);
+            serializer->WriteRawBytes(px, static_cast<size_t>(w) * h * 4);
+            return v8::Just(true);
+        }
+
+        // OffscreenCanvas
+        // Get 失敗時に空 Local を触らないようフォールバックを入れる
+        v8::Local<v8::Value> w = v8::Undefined(isolate_);
+        v8::Local<v8::Value> h = v8::Undefined(isolate_);
+        (void) object->Get(ctx, Str(isolate_, "width")).ToLocal(&w);
+        (void) object->Get(ctx, Str(isolate_, "height")).ToLocal(&h);
+        serializer->WriteUint32(kHostObjectOffscreenCanvas);
         serializer->WriteUint32(w->IsNumber() ? static_cast<uint32_t>(w.As<v8::Number>()->Value()) : 0);
         serializer->WriteUint32(h->IsNumber() ? static_cast<uint32_t>(h.As<v8::Number>()->Value()) : 0);
         return v8::Just(true);
@@ -69,6 +186,26 @@ public:
 
     v8::MaybeLocal<v8::Object> ReadHostObject(v8::Isolate*) override
     {
+        uint32_t tag = 0;
+        if (!deserializer->ReadUint32(&tag)) {
+            return v8::MaybeLocal<v8::Object>();
+        }
+
+        if (tag == kHostObjectImageBitmap) {
+            uint32_t w = 0, h = 0;
+            const void* px = nullptr;
+            if (!deserializer->ReadUint32(&w) || !deserializer->ReadUint32(&h) ||
+                !deserializer->ReadRawBytes(static_cast<size_t>(w) * h * 4, &px)) {
+                return v8::MaybeLocal<v8::Object>();
+            }
+            auto* img = new DecodedImage();
+            img->width = w;
+            img->height = h;
+            img->rgba.assign(static_cast<const uint8_t*>(px),
+                             static_cast<const uint8_t*>(px) + static_cast<size_t>(w) * h * 4);
+            return WrapImageBitmap(isolate_, img);
+        }
+
         uint32_t w = 0, h = 0;
         deserializer->ReadUint32(&w);
         deserializer->ReadUint32(&h);
@@ -84,36 +221,69 @@ private:
 
 } // namespace
 
-std::vector<uint8_t> SerializeMessage(v8::Isolate* isolate, v8::Local<v8::Context> source_ctx,
-                                      v8::Local<v8::Value> message,
-                                      v8::Local<v8::Value> /*transfer_list*/)
+WorkerMessage SerializeMessage(v8::Isolate* isolate, v8::Local<v8::Context> source_ctx,
+                               v8::Local<v8::Value> message,
+                               v8::Local<v8::Value> transfer_list)
 {
     v8::Context::Scope scope(source_ctx);
     SerializerDelegate delegate(isolate);
     v8::ValueSerializer serializer(isolate, &delegate);
     delegate.serializer = &serializer;
 
+    // transfer_list の ArrayBuffer は中身を埋め込まず所有権を移譲する
+    // (player の render キューは数十 MB — 毎フレームのコピーは不可)。
+    std::vector<v8::Local<v8::ArrayBuffer>> transfer_abs;
+    if (!transfer_list.IsEmpty() && transfer_list->IsArray()) {
+        auto arr = transfer_list.As<v8::Array>();
+        for (uint32_t i = 0; i < arr->Length(); ++i) {
+            v8::Local<v8::Value> item;
+            if (arr->Get(source_ctx, i).ToLocal(&item) && item->IsArrayBuffer()) {
+                auto ab = item.As<v8::ArrayBuffer>();
+                if (ab->IsDetachable()) {
+                    serializer.TransferArrayBuffer(
+                        static_cast<uint32_t>(transfer_abs.size()), ab);
+                    transfer_abs.push_back(ab);
+                }
+            }
+        }
+    }
+
     serializer.WriteHeader();
-    // 通常の ArrayBuffer は値としてシリアライズされる (transfer は将来最適化)。
     if (serializer.WriteValue(source_ctx, message).IsNothing()) {
         return {};
     }
+
+    WorkerMessage result;
     std::pair<uint8_t*, size_t> buffer = serializer.Release();
-    std::vector<uint8_t> bytes(buffer.first, buffer.first + buffer.second);
+    result.data.assign(buffer.first, buffer.first + buffer.second);
     free(buffer.first);
-    return bytes;
+
+    // 成功後に detach (ブラウザの transferable と同じく送信側では使えなくなる)
+    for (auto& ab : transfer_abs) {
+        result.transfers.push_back(ab->GetBackingStore());
+        (void) ab->Detach(v8::Local<v8::Value>());
+    }
+    return result;
 }
 
 v8::MaybeLocal<v8::Value> DeserializeMessage(v8::Isolate* isolate,
                                              v8::Local<v8::Context> target_ctx,
-                                             const std::vector<uint8_t>& bytes)
+                                             const WorkerMessage& message)
 {
     v8::Context::Scope scope(target_ctx);
     HostContext* host = HostContext::From(isolate);
     DeserializerDelegate delegate(isolate, host);
-    v8::ValueDeserializer deserializer(isolate, bytes.data(), bytes.size(), &delegate);
+    v8::ValueDeserializer deserializer(isolate, message.data.data(),
+                                       message.data.size(), &delegate);
     delegate.deserializer = &deserializer;
 
+    // transfer された ArrayBuffer を同じ backing store で再装着する (ゼロコピー)
+    for (size_t i = 0; i < message.transfers.size(); ++i) {
+        v8::Local<v8::ArrayBuffer> ab =
+            v8::ArrayBuffer::New(isolate, message.transfers[i]);
+        deserializer.TransferArrayBuffer(static_cast<uint32_t>(i), ab);
+    }
+
     if (deserializer.ReadHeader(target_ctx).IsNothing()) {
         return v8::MaybeLocal<v8::Value>();
     }
@@ -140,6 +310,7 @@ void DispatchMessage(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
     if (target->Get(ctx, Str(isolate, "onmessage")).ToLocal(&on) && on->IsFunction()) {
         v8::TryCatch tc(isolate);
         (void) on.As<v8::Function>()->Call(ctx, target, 1, args);
+        v8util::ReportCaught(isolate, &tc, "onmessage");
     }
     // __messageListeners 配列
     v8::Local<v8::Value> listeners;
@@ -151,6 +322,7 @@ void DispatchMessage(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
             if (arr->Get(ctx, i).ToLocal(&fn) && fn->IsFunction()) {
                 v8::TryCatch tc(isolate);
                 (void) fn.As<v8::Function>()->Call(ctx, target, 1, args);
+                v8util::ReportCaught(isolate, &tc, "message listener");
             }
         }
     }
@@ -182,11 +354,35 @@ void AddEventListener(const v8::FunctionCallbackInfo<v8::Value>& args)
 // ===========================================================================
 // WorkerInstance
 // ===========================================================================
-WorkerInstance::WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url)
-    : runtime_(runtime), isolate_(isolate), url_(std::move(url))
+WorkerInstance::WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url,
+                               bool is_module)
+    : runtime_(runtime), isolate_(isolate), url_(std::move(url)), module_(is_module)
 {
 }
 
+namespace {
+
+// import 指定子を referrer の URL からの相対で解決する。
+// data:/blob: の referrer(インライン worker)は基準ディレクトリを持たないため
+// 指定子をそのまま返す(assets 参照は失敗するが、インライン ESM は import を持たない)。
+std::string ResolveModulePath(const std::string& referrer_url, const std::string& specifier)
+{
+    // 絶対 URL / bare specifier はそのまま
+    if (specifier.rfind("/", 0) == 0 ||
+        specifier.rfind("http:", 0) == 0 || specifier.rfind("https:", 0) == 0 ||
+        specifier.rfind("data:", 0) == 0 || specifier.rfind("blob:", 0) == 0) {
+        return specifier;
+    }
+    if (referrer_url.rfind("data:", 0) == 0 || referrer_url.rfind("blob:", 0) == 0) {
+        return specifier;
+    }
+    namespace fs = std::filesystem;
+    const fs::path dir = fs::path(referrer_url).parent_path();
+    return (dir / specifier).lexically_normal().generic_string();
+}
+
+} // namespace
+
 WorkerInstance::~WorkerInstance() = default;
 
 v8::Local<v8::Context> WorkerInstance::context() const
@@ -203,9 +399,9 @@ void WorkerSelfPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
     auto* instance = static_cast<WorkerInstance*>(args.Data().As<v8::External>()->Value());
     v8::Local<v8::Value> msg = args.Length() > 0 ? args[0] : v8::Undefined(isolate).As<v8::Value>();
     v8::Local<v8::Value> transfer = args.Length() > 1 ? args[1] : v8::Undefined(isolate).As<v8::Value>();
-    auto bytes = SerializeMessage(isolate, isolate->GetCurrentContext(), msg, transfer);
-    if (!bytes.empty()) {
-        instance->PostToMain(std::move(bytes));
+    auto message = SerializeMessage(isolate, isolate->GetCurrentContext(), msg, transfer);
+    if (!message.data.empty()) {
+        instance->PostToMain(std::move(message));
     }
 }
 
@@ -236,9 +432,9 @@ void MainWorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
     auto* instance = static_cast<WorkerInstance*>(args.Data().As<v8::External>()->Value());
     v8::Local<v8::Value> msg = args.Length() > 0 ? args[0] : v8::Undefined(isolate).As<v8::Value>();
     v8::Local<v8::Value> transfer = args.Length() > 1 ? args[1] : v8::Undefined(isolate).As<v8::Value>();
-    auto bytes = SerializeMessage(isolate, isolate->GetCurrentContext(), msg, transfer);
-    if (!bytes.empty()) {
-        instance->PostToWorker(std::move(bytes));
+    auto message = SerializeMessage(isolate, isolate->GetCurrentContext(), msg, transfer);
+    if (!message.data.empty()) {
+        instance->PostToWorker(std::move(message));
     }
 }
 
@@ -254,6 +450,8 @@ bool WorkerInstance::Start()
     // worker 専用 EventLoop を Context の embedder slot に登録
     loop_ = std::make_unique<EventLoop>(isolate_);
     context->SetAlignedPointerInEmbedderData(kEventLoopEmbedderSlot, loop_.get());
+    // ESM の ResolveModule コールバックが context から自身を引けるように登録
+    context->SetAlignedPointerInEmbedderData(kWorkerInstanceEmbedderSlot, this);
 
     v8::Context::Scope context_scope(context);
     v8::Local<v8::Object> global = context->Global();
@@ -277,47 +475,209 @@ bool WorkerInstance::Start()
     // 入れ子 Worker を許可 (ZlibInflate 等)。
     runtime_->InstallOnGlobal(global);
 
-    // ワーカースクリプトを読み込んで評価 (クラシック。ESM worker は «EXTEND»)。
-    // Vite の `?worker&inline` は blob: URL(= URL.createObjectURL(new Blob([code]))) を渡すため、
-    // まず object URL レジストリ、次に assets を参照する。
+    // ワーカースクリプトを読み込む (クラシック / ESM は module_ で分岐)。
+    // Vite の `?worker&inline` は data:application/javascript;base64,... を渡す
+    // (バージョンによっては blob: URL)。data: / blob: / assets の順で解決する。
     HostContext* host = HostContext::From(isolate_);
     std::string source;
-    if (url_.rfind("blob:", 0) == 0) {
+    if (url_.rfind("data:", 0) == 0) {
+        const auto comma = url_.find(',');
+        if (comma == std::string::npos) {
+            std::cerr << "[Worker] malformed data url: " << ShortUrl(url_) << std::endl;
+            return false;
+        }
+        const std::string meta = url_.substr(5, comma - 5);   // 例: application/javascript;base64
+        const std::string payload = url_.substr(comma + 1);
+        if (meta.find(";base64") != std::string::npos) {
+            if (!DecodeBase64(payload, &source)) {
+                std::cerr << "[Worker] base64 decode failed: " << ShortUrl(url_) << std::endl;
+                return false;
+            }
+        } else {
+            source = PercentDecode(payload);
+        }
+    } else if (url_.rfind("blob:", 0) == 0) {
         if (!ResolveObjectURL(url_, &source)) {
-            std::cerr << "[Worker] blob url not found: " << url_ << std::endl;
+            std::cerr << "[Worker] blob url not found: " << ShortUrl(url_) << std::endl;
             return false;
         }
     } else {
         auto src = host->assets->ReadText(url_);
         if (!src) {
-            std::cerr << "[Worker] script not found: " << url_ << std::endl;
+            std::cerr << "[Worker] script not found: " << ShortUrl(url_) << std::endl;
             return false;
         }
         source = std::move(*src);
     }
+
+    // ESM worker (new Worker(url, { type: "module" }))。モジュールとして評価する。
+    if (module_) {
+        return EvaluateModule(context, source);
+    }
+
+    // «自己修復» CommandController.execute() は try/catch を持たないため、描画中の例外が
+    // 1 度起きると this.state が "active" のまま固まり、以後 onmessage は queue に積むだけで
+    // execute を再開せず worker が永久停止する。元の execute をリネームし、例外を捕捉して
+    // state を戻すラッパを被せて凍結を防ぐ (例外は [rendererr] で出力)。安全網として残す。
+    if (source.find("getCurrentTexture") != std::string::npos) {
+        const auto patch = [&source](const std::string& from, const std::string& to) {
+            const auto pos = source.find(from);
+            if (pos != std::string::npos) {
+                source.replace(pos, from.size(), to);
+            }
+        };
+        patch("async execute(){for(this.state=\"active\"",
+              "async execute(){try{await this.__n2dExec()}catch(__ee){"
+              "var __n=(globalThis.__rerr=(globalThis.__rerr||0)+1);"
+              "if(__n<=8)console.error(\"[rendererr] #\"+__n+\" \"+(__ee&&__ee.message||__ee)+"
+              "\"\\n\"+(__ee&&__ee.stack||\"\"));this.state=\"deactivate\"}}"
+              "async __n2dExec(){for(this.state=\"active\"");
+    }
     v8::TryCatch tc(isolate_);
     v8::ScriptOrigin origin(Str(isolate_, url_));
     v8::Local<v8::String> code = Str(isolate_, source);
+    // バイトコードキャッシュ込みでコンパイル。レンダラ worker (player の描画バンドル)
+    // が最大のパース対象。キーは自己修復パッチ適用後のソースなので整合する。
     v8::Local<v8::Script> script;
-    if (!v8::Script::Compile(context, code, &origin).ToLocal(&script) ||
+    if (!codecache::Compile(context, code, origin, url_, source).ToLocal(&script) ||
         script->Run(context).IsEmpty()) {
-        std::cerr << "[Worker] script eval failed: " << url_ << std::endl;
+        std::cerr << "[Worker] script eval failed: " << ShortUrl(url_) << std::endl;
+        if (tc.HasCaught()) {
+            v8::String::Utf8Value exception(isolate_, tc.Exception());
+            std::cerr << "[Worker]   exception: " << (*exception ? *exception : "?") << std::endl;
+            v8::Local<v8::Message> message = tc.Message();
+            if (!message.IsEmpty()) {
+                std::cerr << "[Worker]   at line "
+                          << message->GetLineNumber(context).FromMaybe(0) << std::endl;
+            }
+        }
+        return false;
+    }
+    // NOTE: ここで PerformMicrotaskCheckpoint は呼ばない。Start は JS コールバック
+    // (new Worker) の最中に呼ばれるため、JS 実行中のチェックポイントは V8 の規約違反。
+    // マイクロタスクはメインループの PumpMicrotasks で処理される。
+    return true;
+}
+
+// --- ESM worker ------------------------------------------------------------
+// 依存モジュールを assets から読み、コンパイルして再帰ロードする。
+v8::MaybeLocal<v8::Module> WorkerInstance::LoadModule(const std::string& url)
+{
+    auto cached = modules_.find(url);
+    if (cached != modules_.end()) {
+        return cached->second.Get(isolate_);
+    }
+    HostContext* host = HostContext::From(isolate_);
+    auto src = host->assets->ReadText(url);
+    if (!src) {
+        std::cerr << "[Worker] module not found: " << ShortUrl(url) << std::endl;
+        return v8::MaybeLocal<v8::Module>();
+    }
+
+    v8::ScriptOrigin origin(Str(isolate_, url), 0, 0, false, -1,
+        v8::Local<v8::Value>(), false, false, /*is_module*/ true);
+    v8::Local<v8::Module> module;
+    if (!codecache::CompileModule(isolate_, Str(isolate_, *src), origin, url, *src)
+             .ToLocal(&module)) {
+        std::cerr << "[Worker] module compile failed: " << ShortUrl(url) << std::endl;
+        return v8::MaybeLocal<v8::Module>();
+    }
+    modules_[url].Reset(isolate_, module);
+    module_paths_[module->GetIdentityHash()] = url;
+
+    v8::Local<v8::Context> ctx = context();
+    v8::Local<v8::FixedArray> requests = module->GetModuleRequests();
+    for (int i = 0; i < requests->Length(); ++i) {
+        v8::Local<v8::ModuleRequest> request =
+            requests->Get(ctx, i).As<v8::ModuleRequest>();
+        const std::string specifier = ToStdString(isolate_, request->GetSpecifier());
+        if (LoadModule(ResolveModulePath(url, specifier)).IsEmpty()) {
+            return v8::MaybeLocal<v8::Module>();
+        }
+    }
+    return module;
+}
+
+v8::MaybeLocal<v8::Module> WorkerInstance::ResolveModule(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::String> specifier,
+    v8::Local<v8::FixedArray> /*import_attributes*/,
+    v8::Local<v8::Module> referrer)
+{
+    v8::Isolate* isolate = context->GetIsolate();
+    auto* self = static_cast<WorkerInstance*>(
+        context->GetAlignedPointerFromEmbedderData(kWorkerInstanceEmbedderSlot));
+    if (!self) {
+        return v8::MaybeLocal<v8::Module>();
+    }
+    auto it = self->module_paths_.find(referrer->GetIdentityHash());
+    const std::string referrer_url =
+        (it != self->module_paths_.end()) ? it->second : self->url_;
+    const std::string spec = ToStdString(isolate, specifier);
+    return self->LoadModule(ResolveModulePath(referrer_url, spec));
+}
+
+bool WorkerInstance::EvaluateModule(v8::Local<v8::Context> context, const std::string& source)
+{
+    v8::TryCatch tc(isolate_);
+
+    // 入口モジュールはインライン(data:/blob:)の可能性があるため、渡された source を
+    // 直接コンパイルする(assets 経由の LoadModule は依存モジュール用)。
+    v8::ScriptOrigin origin(Str(isolate_, url_), 0, 0, false, -1,
+        v8::Local<v8::Value>(), false, false, /*is_module*/ true);
+    v8::Local<v8::Module> module;
+    if (!codecache::CompileModule(isolate_, Str(isolate_, source), origin, url_, source)
+             .ToLocal(&module)) {
+        std::cerr << "[Worker] module compile failed: " << ShortUrl(url_) << std::endl;
+        return false;
+    }
+    modules_[url_].Reset(isolate_, module);
+    module_paths_[module->GetIdentityHash()] = url_;
+
+    // 静的 import を再帰ロード(インライン worker は import 無しでスキップ)。
+    v8::Local<v8::FixedArray> requests = module->GetModuleRequests();
+    for (int i = 0; i < requests->Length(); ++i) {
+        v8::Local<v8::ModuleRequest> request =
+            requests->Get(context, i).As<v8::ModuleRequest>();
+        const std::string specifier = ToStdString(isolate_, request->GetSpecifier());
+        if (LoadModule(ResolveModulePath(url_, specifier)).IsEmpty()) {
+            return false;
+        }
+    }
+
+    if (module->InstantiateModule(context, ResolveModule).IsNothing()) {
+        std::cerr << "[Worker] module instantiate failed: " << ShortUrl(url_) << std::endl;
+        if (tc.HasCaught()) {
+            v8::String::Utf8Value ex(isolate_, tc.Exception());
+            std::cerr << "[Worker]   exception: " << (*ex ? *ex : "?") << std::endl;
+        }
+        return false;
+    }
+
+    // NOTE: Start と同じく PerformMicrotaskCheckpoint は呼ばない(new Worker の JS 実行中)。
+    // トップレベル await が返す Promise はメインループの PumpMicrotasks で解決される。
+    v8::Local<v8::Value> result;
+    if (!module->Evaluate(context).ToLocal(&result)) {
+        std::cerr << "[Worker] module evaluate failed: " << ShortUrl(url_) << std::endl;
+        if (tc.HasCaught()) {
+            v8::String::Utf8Value ex(isolate_, tc.Exception());
+            std::cerr << "[Worker]   exception: " << (*ex ? *ex : "?") << std::endl;
+        }
         return false;
     }
-    isolate_->PerformMicrotaskCheckpoint();
     return true;
 }
 
 void WorkerInstance::Terminate() { terminated_ = true; }
 
-void WorkerInstance::PostToWorker(std::vector<uint8_t> bytes)
+void WorkerInstance::PostToWorker(WorkerMessage message)
 {
-    to_worker_.push_back(WorkerMessage{std::move(bytes)});
+    to_worker_.push_back(std::move(message));
 }
 
-void WorkerInstance::PostToMain(std::vector<uint8_t> bytes)
+void WorkerInstance::PostToMain(WorkerMessage message)
 {
-    to_main_.push_back(WorkerMessage{std::move(bytes)});
+    to_main_.push_back(std::move(message));
 }
 
 void WorkerInstance::DeliverToWorker(double now_ms)
@@ -330,8 +690,11 @@ void WorkerInstance::DeliverToWorker(double now_ms)
         WorkerMessage m = std::move(to_worker_.front());
         to_worker_.pop_front();
         v8::Local<v8::Value> data;
-        if (DeserializeMessage(isolate_, ctx, m.data).ToLocal(&data)) {
+        if (DeserializeMessage(isolate_, ctx, m).ToLocal(&data)) {
             DispatchMessage(isolate_, ctx, ctx->Global(), data);
+        } else {
+            std::cerr << "[Worker] main->worker deserialize failed ("
+                      << m.data.size() << " bytes)" << std::endl;
         }
     }
 
@@ -354,8 +717,11 @@ void WorkerInstance::DeliverToMain()
         WorkerMessage m = std::move(to_main_.front());
         to_main_.pop_front();
         v8::Local<v8::Value> data;
-        if (DeserializeMessage(isolate_, main_ctx, m.data).ToLocal(&data)) {
+        if (DeserializeMessage(isolate_, main_ctx, m).ToLocal(&data)) {
             DispatchMessage(isolate_, main_ctx, worker_obj, data);
+        } else {
+            std::cerr << "[Worker] worker->main deserialize failed ("
+                      << m.data.size() << " bytes)" << std::endl;
         }
     }
 }
@@ -376,11 +742,11 @@ WorkerRuntime::WorkerRuntime(v8::Isolate* isolate, HostContext* host)
 
 WorkerRuntime::~WorkerRuntime() = default;
 
-v8::Local<v8::Object> WorkerRuntime::CreateWorker(const std::string& url)
+v8::Local<v8::Object> WorkerRuntime::CreateWorker(const std::string& url, bool is_module)
 {
     v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
 
-    auto instance = std::make_unique<WorkerInstance>(this, isolate_, url);
+    auto instance = std::make_unique<WorkerInstance>(this, isolate_, url, is_module);
     WorkerInstance* ptr = instance.get();
 
     // main 側 Worker オブジェクト
@@ -389,11 +755,17 @@ v8::Local<v8::Object> WorkerRuntime::CreateWorker(const std::string& url)
     worker->Set(ctx, Str(isolate_, "postMessage"),
         v8::Function::New(ctx, MainWorkerPostMessage, ext).ToLocalChecked()).Check();
     SetMethod(isolate_, worker, "addEventListener", AddEventListener);
-    SetMethod(isolate_, worker, "terminate",
-        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
-            auto* w = static_cast<WorkerInstance*>(a.Data().As<v8::External>()->Value());
-            w->Terminate();
-        });
+    // terminate は WorkerInstance* を data (External) で受け取る必要があるため
+    // SetMethod (data なし) ではなく Function::New で設置する。
+    worker->Set(ctx, Str(isolate_, "terminate"),
+        v8::Function::New(ctx,
+            [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+                if (!a.Data()->IsExternal()) {
+                    return;
+                }
+                auto* w = static_cast<WorkerInstance*>(a.Data().As<v8::External>()->Value());
+                w->Terminate();
+            }, ext).ToLocalChecked()).Check();
 
     ptr->main_worker_object.Reset(isolate_, worker);
 
@@ -420,7 +792,17 @@ void WorkerConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
         // new Worker(new URL(...)) にも対応するため toString で URL 文字列化
         url = ToStdString(isolate, args[0]);
     }
-    args.GetReturnValue().Set(runtime->CreateWorker(url));
+    // new Worker(url, { type: "module" }) → ESM として評価する
+    bool is_module = false;
+    if (args.Length() > 1 && args[1]->IsObject()) {
+        v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+        v8::Local<v8::Value> type;
+        if (args[1].As<v8::Object>()->Get(ctx, Str(isolate, "type")).ToLocal(&type) &&
+            type->IsString()) {
+            is_module = (ToStdString(isolate, type) == "module");
+        }
+    }
+    args.GetReturnValue().Set(runtime->CreateWorker(url, is_module));
 }
 
 } // namespace
@@ -437,8 +819,10 @@ void WorkerRuntime::InstallOnGlobal(v8::Local<v8::Object> global)
 
 void WorkerRuntime::Pump(double now_ms)
 {
-    for (auto& w : workers_) {
-        w->Deliver(now_ms);
+    // 配送中の JS が new Worker() を呼ぶと workers_ に push_back され
+    // vector が再割当されるため、イテレータではなく添字で回す。
+    for (size_t i = 0; i < workers_.size(); ++i) {
+        workers_[i]->Deliver(now_ms);
     }
 }