@next2d/builder 0.1.6 → 0.1.8

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

@@ -4,6 +4,8 @@
 #include "EventLoop.h"
 #include "AssetLoader.h"
 #include "bindings/Bindings.h"
+#include "bindings/ImageSource.h"
+#include "platform/ImageTypes.h"
 #include "v8/V8Util.h"
 
 #include <cstdlib>
@@ -22,14 +24,108 @@ 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;
+
+// メッセージトレース: 定常時のログ洪水を防ぐため、最初の 120 件のあとは
+// 200 件ごとに 1 回だけ出力する (render は 60fps で双方向に流れる)。
+bool TraceMessage()
+{
+    static uint64_t count = 0;
+    ++count;
+    return count <= 120 || count % 200 == 0;
+}
+
 class SerializerDelegate : public v8::ValueSerializer::Delegate {
 public:
     explicit SerializerDelegate(v8::Isolate* isolate) : isolate_(isolate) {}
@@ -39,18 +135,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 +193,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 +228,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 +317,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 +329,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");
             }
         }
     }
@@ -203,9 +382,13 @@ 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 (TraceMessage()) {
+        std::cerr << "[Worker] worker->main postMessage: " << message.data.size()
+                  << " bytes (+" << message.transfers.size() << " transfers)" << std::endl;
+    }
+    if (!message.data.empty()) {
+        instance->PostToMain(std::move(message));
     }
 }
 
@@ -236,9 +419,13 @@ 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 (TraceMessage()) {
+        std::cerr << "[Worker] main->worker postMessage: " << message.data.size()
+                  << " bytes (+" << message.transfers.size() << " transfers)" << std::endl;
+    }
+    if (!message.data.empty()) {
+        instance->PostToWorker(std::move(message));
     }
 }
 
@@ -246,10 +433,12 @@ void MainWorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
 
 bool WorkerInstance::Start()
 {
+    std::cerr << "[Worker] start: " << ShortUrl(url_) << std::endl;
     v8::HandleScope handle_scope(isolate_);
 
     v8::Local<v8::Context> context = v8::Context::New(isolate_);
     context_.Reset(isolate_, context);
+    std::cerr << "[Worker] context created" << std::endl;
 
     // worker 専用 EventLoop を Context の embedder slot に登録
     loop_ = std::make_unique<EventLoop>(isolate_);
@@ -260,6 +449,7 @@ bool WorkerInstance::Start()
 
     // ブラウザ相当環境一式 (console/timers/fetch/image/audio/webgpu/canvas/dom)
     InstallGlobalBindings(isolate_, global, HostContext::From(isolate_));
+    std::cerr << "[Worker] bindings installed" << std::endl;
 
     // worker スコープには document/window を出さない (ライブラリの環境判定対策)。
     global->Delete(context, Str(isolate_, "document")).Check();
@@ -278,46 +468,112 @@ bool WorkerInstance::Start()
     runtime_->InstallOnGlobal(global);
 
     // ワーカースクリプトを読み込んで評価 (クラシック。ESM worker は «EXTEND»)。
-    // Vite の `?worker&inline` は blob: URL(= URL.createObjectURL(new Blob([code]))) を渡すため、
-    // まず object URL レジストリ、次に assets を参照する。
+    // 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);
     }
+    std::cerr << "[Worker] source resolved (" << source.size() << " bytes)" << std::endl;
+
+    // «診断» レンダラ worker のフレームサイクル (frameStarted / mainTexture) を追跡する。
+    // 黒画面問題: getCurrentTexture がフレーム 3 回目以降呼ばれなくなる現象の原因特定用。
+    // minify 後も this.プロパティ名は保持されるためパターンは安定。見つからなければ無変更。
+    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);
+            } else {
+                std::cerr << "[Worker] trace patch not applied: " << from.substr(0, 40) << std::endl;
+            }
+        };
+        source.insert(0,
+            "var __n2dT={};function __n2dTrace(k,s){var n=(__n2dT[k]=(__n2dT[k]||0)+1);"
+            "if(n<=30||n%300===0)console.info(\"[trace]\",k,\"#\"+n,s||\"\")}\n");
+        patch("clearTransferBounds(){this.beginFrame()}",
+              "clearTransferBounds(){__n2dTrace(\"CTB\",\"fs=\"+this.frameStarted+\" mt=\"+!!this.mainTexture);this.beginFrame()}");
+        patch("ensureMainTexture(){this.mainTexture||",
+              "ensureMainTexture(){__n2dTrace(\"EMT\",\"mt=\"+!!this.mainTexture+\" rc=\"+this.$needsReconfigure);this.mainTexture||");
+        patch("endFrame(){if(this.frameStarted){",
+              "endFrame(){__n2dTrace(\"EF\",\"fs=\"+this.frameStarted+\" enc=\"+!!this.commandEncoder);if(this.frameStarted){");
+        patch("transferMainCanvas(){if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)",
+              "transferMainCanvas(){__n2dTrace(\"TMC\",\"att=\"+!!(this.$mainAttachmentObject&&this.$mainAttachmentObject.texture));if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)");
+        // «診断/自己修復» CommandController.execute() は try/catch を持たないため、
+        // 描画中の例外が 1 度起きると this.state が "active" のまま固まり、
+        // 以後 onmessage は queue に積むだけで execute を再開せず worker が永久停止する
+        // (画面が ~15 フレームで凍結する現象の直接原因)。元の execute をリネームし、
+        // 例外を捕捉して message+stack を出力しつつ state を戻すラッパを被せる。
+        // これで「実際に何が throw しているか」を CI ログで確定でき、かつ凍結も防げる。
+        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);
     v8::Local<v8::Script> script;
     if (!v8::Script::Compile(context, code, &origin).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;
     }
-    isolate_->PerformMicrotaskCheckpoint();
+    // NOTE: ここで PerformMicrotaskCheckpoint は呼ばない。Start は JS コールバック
+    // (new Worker) の最中に呼ばれるため、JS 実行中のチェックポイントは V8 の規約違反。
+    // マイクロタスクはメインループの PumpMicrotasks で処理される。
+    std::cerr << "[Worker] script evaluated" << std::endl;
     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)
@@ -329,9 +585,19 @@ void WorkerInstance::DeliverToWorker(double now_ms)
     while (!to_worker_.empty()) {
         WorkerMessage m = std::move(to_worker_.front());
         to_worker_.pop_front();
+        const bool trace = TraceMessage();
+        if (trace) {
+            std::cerr << "[Worker] deliver main->worker (" << m.data.size() << " bytes)" << std::endl;
+        }
         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);
+            if (trace) {
+                std::cerr << "[Worker] worker onmessage done" << std::endl;
+            }
+        } else {
+            std::cerr << "[Worker] main->worker deserialize failed ("
+                      << m.data.size() << " bytes)" << std::endl;
         }
     }
 
@@ -353,9 +619,19 @@ void WorkerInstance::DeliverToMain()
     while (!to_main_.empty()) {
         WorkerMessage m = std::move(to_main_.front());
         to_main_.pop_front();
+        const bool trace = TraceMessage();
+        if (trace) {
+            std::cerr << "[Worker] deliver worker->main (" << m.data.size() << " bytes)" << std::endl;
+        }
         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);
+            if (trace) {
+                std::cerr << "[Worker] main onmessage done" << std::endl;
+            }
+        } else {
+            std::cerr << "[Worker] worker->main deserialize failed ("
+                      << m.data.size() << " bytes)" << std::endl;
         }
     }
 }
@@ -389,11 +665,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);
 
@@ -437,8 +719,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);
     }
 }
 

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

@@ -25,9 +25,12 @@ class HostContext;
 class EventLoop;
 class WorkerRuntime;
 
-// 1 メッセージ = ValueSerializer 出力バイト列。
+// 1 メッセージ = ValueSerializer 出力バイト列 + transfer された ArrayBuffer の実体。
+// transfer_list の ArrayBuffer は中身を bytes に埋め込まず所有権ごと移す
+// (render キューは数十 MB になるため、コピーするとフレームレートが崩壊する)。
 struct WorkerMessage {
     std::vector<uint8_t> data;
+    std::vector<std::shared_ptr<v8::BackingStore>> transfers;
 };
 
 class WorkerInstance {
@@ -39,8 +42,8 @@ public:
     void Terminate();
 
     // main→worker / worker→main の投函
-    void PostToWorker(std::vector<uint8_t> bytes);
-    void PostToMain(std::vector<uint8_t> bytes);
+    void PostToWorker(WorkerMessage message);
+    void PostToMain(WorkerMessage message);
 
     // 配送 + タイマー/rAF 前進 (WorkerRuntime::Pump から呼ぶ)
     void Deliver(double now_ms);
@@ -88,21 +91,28 @@ public:
 
     bool HasWorkers() const { return !workers_.empty(); }
 
+    // 全 WorkerInstance を破棄する。WorkerInstance は v8::Global (context_ /
+    // main_worker_object 等) を保持するため、Isolate::Dispose より前に必ず呼ぶこと
+    // (呼ばずにスタック巻き戻しで破棄されると Isolate 破棄後の Global::Reset で fail-fast)。
+    void Shutdown() { workers_.clear(); }
+
 private:
     v8::Isolate* isolate_;
     HostContext* host_;
     std::vector<std::unique_ptr<WorkerInstance>> workers_;
 };
 
-// ValueSerializer/Deserializer による structured clone (OffscreenCanvas transfer 対応)。
-// 失敗時は空を返す。source_ctx で直列化し、bytes を得る。
-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);
+// ValueSerializer/Deserializer による structured clone
+// (OffscreenCanvas / ImageBitmap のホストオブジェクト対応 + ArrayBuffer transfer)。
+// 失敗時は data が空の WorkerMessage を返す。transfer_list 内の ArrayBuffer は
+// detach され、backing store が message.transfers へ移る。
+WorkerMessage SerializeMessage(v8::Isolate* isolate, v8::Local<v8::Context> source_ctx,
+                               v8::Local<v8::Value> message,
+                               v8::Local<v8::Value> transfer_list);
 
-// bytes を target_ctx で復元する。
+// message を target_ctx で復元する (transfer された ArrayBuffer は同一実体を再装着)。
 v8::MaybeLocal<v8::Value> DeserializeMessage(v8::Isolate* isolate,
                                              v8::Local<v8::Context> target_ctx,
-                                             const std::vector<uint8_t>& bytes);
+                                             const WorkerMessage& message);
 
 } // namespace next2d

package/templates/xbox/tests/check_local.sh

@@ -10,7 +10,7 @@
 set -euo pipefail
 cd "$(dirname "$0")/.."
 
-V8_TAG="13.6.233.17"
+V8_TAG="13.7.152.19"
 V8INC="${1:-}"
 
 echo "== 1/3 RasterCore unit tests =="
@@ -41,6 +41,7 @@ FILES=(
     src/bindings/Console.cpp
     src/bindings/Timers.cpp
     src/bindings/EventTarget.cpp
+    src/bindings/Polyfills.cpp
     src/bindings/Network.cpp
     src/bindings/Fetch.cpp
     src/bindings/Canvas.cpp
@@ -49,7 +50,7 @@ FILES=(
 )
 for f in "${FILES[@]}"; do
     c++ -fsyntax-only -std=c++20 -Isrc -isystem "${V8INC}" \
-        -DV8_COMPRESS_POINTERS -DV8_ENABLE_SANDBOX "$f"
+        -DV8_COMPRESS_POINTERS "$f"
     echo "OK   $f"
 done