@next2d/builder 0.1.5 → 0.1.6

package/templates/xbox/src/v8/V8Runtime.h

@@ -0,0 +1,68 @@
+// V8Runtime: V8 プラットフォーム / Isolate / Context のライフサイクルを管理し、
+// スクリプト(クラシック/ESM)の評価とマイクロタスクのポンプを提供する。
+#pragma once
+
+#include <v8.h>
+#include <libplatform/libplatform.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+namespace next2d {
+
+class HostContext;
+
+class V8Runtime {
+public:
+    V8Runtime();
+    ~V8Runtime();
+
+    // process 全体で一度だけ呼ぶ (argv[0] を渡す)
+    static void InitializeProcess(const char* exec_path);
+    static void ShutdownProcess();
+
+    // Isolate + Context を生成し、HostContext を data slot に紐付ける
+    bool Initialize(HostContext* host);
+    void Dispose();
+
+    v8::Isolate* isolate() const { return isolate_; }
+    v8::Local<v8::Context> context() const;
+
+    // クラシックスクリプトを評価 (bootstrap.js 等)。失敗時 false。
+    bool RunScript(const std::string& source, const std::string& name);
+
+    // ES モジュールを評価 (Next2D アプリ本体)。base_dir は相対 import 解決用。
+    bool RunModule(const std::string& source, const std::string& path);
+
+    // Promise 等のマイクロタスクを処理する (タスク実行の直後に呼ぶ)
+    void PumpMicrotasks();
+
+    // 保留中のフォアグラウンドタスク(V8 プラットフォーム)を処理する
+    void PumpPlatformTasks();
+
+private:
+    // ESM 解決
+    v8::MaybeLocal<v8::Module> LoadModule(const std::string& path, const std::string& referrer_dir);
+    static v8::MaybeLocal<v8::Module> ResolveModuleCallback(
+        v8::Local<v8::Context> context,
+        v8::Local<v8::String> specifier,
+        v8::Local<v8::FixedArray> import_assertions,
+        v8::Local<v8::Module> referrer);
+
+    void ReportException(v8::TryCatch* try_catch);
+
+    static std::unique_ptr<v8::Platform> platform_;
+
+    v8::Isolate* isolate_ = nullptr;
+    v8::Isolate::CreateParams create_params_;
+    v8::Global<v8::Context> context_;
+    HostContext* host_ = nullptr;
+
+    // ESM キャッシュ: 絶対パス -> Module。resolve コールバックから参照する。
+    std::map<std::string, v8::Global<v8::Module>> module_cache_;
+    // Module identity hash -> 絶対パス (相対 import 解決の referrer 特定に使用)
+    std::map<int, std::string> module_paths_;
+};
+
+} // namespace next2d

package/templates/xbox/src/v8/V8Util.h

@@ -0,0 +1,56 @@
+// V8 バインディング用の小さなヘルパー群。
+#pragma once
+
+#include <v8.h>
+#include <string>
+#include <string_view>
+
+namespace next2d::v8util {
+
+// std::string -> v8::String (UTF-8)
+inline v8::Local<v8::String> Str(v8::Isolate* isolate, std::string_view s)
+{
+    return v8::String::NewFromUtf8(
+        isolate, s.data(), v8::NewStringType::kNormal,
+        static_cast<int>(s.size())
+    ).ToLocalChecked();
+}
+
+// v8::Value -> std::string (UTF-8)
+inline std::string ToStdString(v8::Isolate* isolate, v8::Local<v8::Value> value)
+{
+    v8::String::Utf8Value utf8(isolate, value);
+    return (*utf8) ? std::string(*utf8, utf8.length()) : std::string();
+}
+
+// object[name] = fn
+inline void SetMethod(v8::Isolate* isolate,
+                      v8::Local<v8::Object> target,
+                      std::string_view name,
+                      v8::FunctionCallback callback,
+                      v8::Local<v8::Value> data = v8::Local<v8::Value>())
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Function> fn =
+        v8::Function::New(ctx, callback, data).ToLocalChecked();
+    fn->SetName(Str(isolate, name));
+    target->Set(ctx, Str(isolate, name), fn).Check();
+}
+
+// object[name] = value
+inline void SetValue(v8::Isolate* isolate,
+                     v8::Local<v8::Object> target,
+                     std::string_view name,
+                     v8::Local<v8::Value> value)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    target->Set(ctx, Str(isolate, name), value).Check();
+}
+
+// TypeError を投げる (バインディング内の引数検証で使用)
+inline void ThrowTypeError(v8::Isolate* isolate, std::string_view message)
+{
+    isolate->ThrowException(v8::Exception::TypeError(Str(isolate, message)));
+}
+
+} // namespace next2d::v8util

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

@@ -0,0 +1,453 @@
+#include "WorkerRuntime.h"
+
+#include "HostContext.h"
+#include "EventLoop.h"
+#include "AssetLoader.h"
+#include "bindings/Bindings.h"
+#include "v8/V8Util.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+
+namespace next2d {
+
+using v8util::Str;
+using v8util::SetMethod;
+using v8util::SetValue;
+using v8util::ToStdString;
+
+// ===========================================================================
+// structured clone (ValueSerializer / ValueDeserializer)
+// ===========================================================================
+namespace {
+
+bool IsOffscreen(v8::Isolate* isolate, v8::Local<v8::Object> obj)
+{
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Value> v;
+    return obj->Get(ctx, Str(isolate, "__isOffscreenCanvas")).ToLocal(&v) &&
+           v->IsBoolean() && v.As<v8::Boolean>()->Value();
+}
+
+class SerializerDelegate : public v8::ValueSerializer::Delegate {
+public:
+    explicit SerializerDelegate(v8::Isolate* isolate) : isolate_(isolate) {}
+
+    void ThrowDataCloneError(v8::Local<v8::String> message) override
+    {
+        isolate_->ThrowException(v8::Exception::Error(message));
+    }
+
+    // OffscreenCanvas をホストオブジェクトとして扱い WriteHostObject に回す。
+    v8::Maybe<bool> IsHostObject(v8::Isolate*, v8::Local<v8::Object> object) override
+    {
+        return v8::Just(IsOffscreen(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);
+        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);
+    }
+
+    v8::ValueSerializer* serializer = nullptr;
+
+private:
+    v8::Isolate* isolate_;
+};
+
+class DeserializerDelegate : public v8::ValueDeserializer::Delegate {
+public:
+    DeserializerDelegate(v8::Isolate* isolate, HostContext* host)
+        : isolate_(isolate), host_(host) {}
+
+    v8::MaybeLocal<v8::Object> ReadHostObject(v8::Isolate*) override
+    {
+        uint32_t w = 0, h = 0;
+        deserializer->ReadUint32(&w);
+        deserializer->ReadUint32(&h);
+        return CreateOffscreenCanvas(isolate_, host_, static_cast<int>(w), static_cast<int>(h));
+    }
+
+    v8::ValueDeserializer* deserializer = nullptr;
+
+private:
+    v8::Isolate* isolate_;
+    HostContext* host_;
+};
+
+} // 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*/)
+{
+    v8::Context::Scope scope(source_ctx);
+    SerializerDelegate delegate(isolate);
+    v8::ValueSerializer serializer(isolate, &delegate);
+    delegate.serializer = &serializer;
+
+    serializer.WriteHeader();
+    // 通常の ArrayBuffer は値としてシリアライズされる (transfer は将来最適化)。
+    if (serializer.WriteValue(source_ctx, message).IsNothing()) {
+        return {};
+    }
+    std::pair<uint8_t*, size_t> buffer = serializer.Release();
+    std::vector<uint8_t> bytes(buffer.first, buffer.first + buffer.second);
+    free(buffer.first);
+    return bytes;
+}
+
+v8::MaybeLocal<v8::Value> DeserializeMessage(v8::Isolate* isolate,
+                                             v8::Local<v8::Context> target_ctx,
+                                             const std::vector<uint8_t>& bytes)
+{
+    v8::Context::Scope scope(target_ctx);
+    HostContext* host = HostContext::From(isolate);
+    DeserializerDelegate delegate(isolate, host);
+    v8::ValueDeserializer deserializer(isolate, bytes.data(), bytes.size(), &delegate);
+    delegate.deserializer = &deserializer;
+
+    if (deserializer.ReadHeader(target_ctx).IsNothing()) {
+        return v8::MaybeLocal<v8::Value>();
+    }
+    return deserializer.ReadValue(target_ctx);
+}
+
+// ===========================================================================
+// メッセージ配送ヘルパー
+// ===========================================================================
+namespace {
+
+// target(self / worker) の onmessage と addEventListener('message') 登録分へ配送する。
+void DispatchMessage(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
+                     v8::Local<v8::Object> target, v8::Local<v8::Value> data)
+{
+    v8::Context::Scope scope(ctx);
+    v8::Local<v8::Object> event = v8::Object::New(isolate);
+    SetValue(isolate, event, "data", data);
+    SetValue(isolate, event, "type", Str(isolate, "message"));
+    v8::Local<v8::Value> args[1] = { event };
+
+    // onmessage プロパティ
+    v8::Local<v8::Value> on;
+    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);
+    }
+    // __messageListeners 配列
+    v8::Local<v8::Value> listeners;
+    if (target->Get(ctx, Str(isolate, "__messageListeners")).ToLocal(&listeners) &&
+        listeners->IsArray()) {
+        auto arr = listeners.As<v8::Array>();
+        for (uint32_t i = 0; i < arr->Length(); ++i) {
+            v8::Local<v8::Value> fn;
+            if (arr->Get(ctx, i).ToLocal(&fn) && fn->IsFunction()) {
+                v8::TryCatch tc(isolate);
+                (void) fn.As<v8::Function>()->Call(ctx, target, 1, args);
+            }
+        }
+    }
+}
+
+// addEventListener(type, fn): type=='message' のみ __messageListeners へ蓄積。
+void AddEventListener(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    if (args.Length() < 2 || !args[1]->IsFunction()) return;
+    if (ToStdString(isolate, args[0]) != "message") return;
+
+    v8::Local<v8::Object> self = args.This();
+    v8::Local<v8::Value> listeners;
+    v8::Local<v8::Array> arr;
+    if (self->Get(ctx, Str(isolate, "__messageListeners")).ToLocal(&listeners) &&
+        listeners->IsArray()) {
+        arr = listeners.As<v8::Array>();
+    } else {
+        arr = v8::Array::New(isolate, 0);
+        SetValue(isolate, self, "__messageListeners", arr);
+    }
+    arr->Set(ctx, arr->Length(), args[1]).Check();
+}
+
+} // namespace
+
+// ===========================================================================
+// WorkerInstance
+// ===========================================================================
+WorkerInstance::WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url)
+    : runtime_(runtime), isolate_(isolate), url_(std::move(url))
+{
+}
+
+WorkerInstance::~WorkerInstance() = default;
+
+v8::Local<v8::Context> WorkerInstance::context() const
+{
+    return context_.Get(isolate_);
+}
+
+namespace {
+
+// worker 側 self.postMessage: worker→main へ投函する。
+void WorkerSelfPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    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));
+    }
+}
+
+// worker 側 importScripts(url...): 同期でクラシックスクリプトを評価する。
+void WorkerImportScripts(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    HostContext* host = HostContext::From(isolate);
+    for (int i = 0; i < args.Length(); ++i) {
+        const std::string url = ToStdString(isolate, args[i]);
+        auto src = host->assets->ReadText(url);
+        if (!src) continue;
+        v8::TryCatch tc(isolate);
+        v8::ScriptOrigin origin(Str(isolate, url));
+        v8::Local<v8::String> code = Str(isolate, *src);
+        v8::Local<v8::Script> script;
+        if (v8::Script::Compile(ctx, code, &origin).ToLocal(&script)) {
+            (void) script->Run(ctx);
+        }
+    }
+}
+
+// main 側 worker.postMessage: main→worker へ投函する。
+void MainWorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    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));
+    }
+}
+
+} // namespace
+
+bool WorkerInstance::Start()
+{
+    v8::HandleScope handle_scope(isolate_);
+
+    v8::Local<v8::Context> context = v8::Context::New(isolate_);
+    context_.Reset(isolate_, context);
+
+    // worker 専用 EventLoop を Context の embedder slot に登録
+    loop_ = std::make_unique<EventLoop>(isolate_);
+    context->SetAlignedPointerInEmbedderData(kEventLoopEmbedderSlot, loop_.get());
+
+    v8::Context::Scope context_scope(context);
+    v8::Local<v8::Object> global = context->Global();
+
+    // ブラウザ相当環境一式 (console/timers/fetch/image/audio/webgpu/canvas/dom)
+    InstallGlobalBindings(isolate_, global, HostContext::From(isolate_));
+
+    // worker スコープには document/window を出さない (ライブラリの環境判定対策)。
+    global->Delete(context, Str(isolate_, "document")).Check();
+    global->Delete(context, Str(isolate_, "window")).Check();
+
+    // worker 固有: self / postMessage / importScripts / close / addEventListener
+    v8::Local<v8::External> self_ext = v8::External::New(isolate_, this);
+    SetValue(isolate_, global, "self", global);
+    global->Set(context, Str(isolate_, "postMessage"),
+        v8::Function::New(context, WorkerSelfPostMessage, self_ext).ToLocalChecked()).Check();
+    SetMethod(isolate_, global, "importScripts", WorkerImportScripts);
+    SetMethod(isolate_, global, "addEventListener", AddEventListener);
+    SetMethod(isolate_, global, "close", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
+
+    // 入れ子 Worker を許可 (ZlibInflate 等)。
+    runtime_->InstallOnGlobal(global);
+
+    // ワーカースクリプトを読み込んで評価 (クラシック。ESM worker は «EXTEND»)。
+    // Vite の `?worker&inline` は blob: URL(= URL.createObjectURL(new Blob([code]))) を渡すため、
+    // まず object URL レジストリ、次に assets を参照する。
+    HostContext* host = HostContext::From(isolate_);
+    std::string source;
+    if (url_.rfind("blob:", 0) == 0) {
+        if (!ResolveObjectURL(url_, &source)) {
+            std::cerr << "[Worker] blob url not found: " << url_ << std::endl;
+            return false;
+        }
+    } else {
+        auto src = host->assets->ReadText(url_);
+        if (!src) {
+            std::cerr << "[Worker] script not found: " << url_ << std::endl;
+            return false;
+        }
+        source = std::move(*src);
+    }
+    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;
+        return false;
+    }
+    isolate_->PerformMicrotaskCheckpoint();
+    return true;
+}
+
+void WorkerInstance::Terminate() { terminated_ = true; }
+
+void WorkerInstance::PostToWorker(std::vector<uint8_t> bytes)
+{
+    to_worker_.push_back(WorkerMessage{std::move(bytes)});
+}
+
+void WorkerInstance::PostToMain(std::vector<uint8_t> bytes)
+{
+    to_main_.push_back(WorkerMessage{std::move(bytes)});
+}
+
+void WorkerInstance::DeliverToWorker(double now_ms)
+{
+    if (terminated_) { to_worker_.clear(); return; }
+    v8::HandleScope hs(isolate_);
+    v8::Local<v8::Context> ctx = context();
+
+    while (!to_worker_.empty()) {
+        WorkerMessage m = std::move(to_worker_.front());
+        to_worker_.pop_front();
+        v8::Local<v8::Value> data;
+        if (DeserializeMessage(isolate_, ctx, m.data).ToLocal(&data)) {
+            DispatchMessage(isolate_, ctx, ctx->Global(), data);
+        }
+    }
+
+    // worker のタイマー / rAF (レンダラ worker はここで描画コマンドを積む)
+    v8::Context::Scope cs(ctx);
+    loop_->PumpTimers();
+    isolate_->PerformMicrotaskCheckpoint();
+    loop_->RunAnimationFrame(now_ms);
+    isolate_->PerformMicrotaskCheckpoint();
+}
+
+void WorkerInstance::DeliverToMain()
+{
+    if (main_worker_object.IsEmpty()) { to_main_.clear(); return; }
+    v8::HandleScope hs(isolate_);
+    v8::Local<v8::Object> worker_obj = main_worker_object.Get(isolate_);
+    v8::Local<v8::Context> main_ctx = worker_obj->GetCreationContextChecked();
+
+    while (!to_main_.empty()) {
+        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)) {
+            DispatchMessage(isolate_, main_ctx, worker_obj, data);
+        }
+    }
+}
+
+void WorkerInstance::Deliver(double now_ms)
+{
+    DeliverToWorker(now_ms);
+    DeliverToMain();
+}
+
+// ===========================================================================
+// WorkerRuntime
+// ===========================================================================
+WorkerRuntime::WorkerRuntime(v8::Isolate* isolate, HostContext* host)
+    : isolate_(isolate), host_(host)
+{
+}
+
+WorkerRuntime::~WorkerRuntime() = default;
+
+v8::Local<v8::Object> WorkerRuntime::CreateWorker(const std::string& url)
+{
+    v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
+
+    auto instance = std::make_unique<WorkerInstance>(this, isolate_, url);
+    WorkerInstance* ptr = instance.get();
+
+    // main 側 Worker オブジェクト
+    v8::Local<v8::Object> worker = v8::Object::New(isolate_);
+    v8::Local<v8::External> ext = v8::External::New(isolate_, ptr);
+    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();
+        });
+
+    ptr->main_worker_object.Reset(isolate_, worker);
+
+    if (!ptr->Start()) {
+        // 起動失敗でも Worker オブジェクトは返す (エラーは配送されない)
+    }
+    workers_.push_back(std::move(instance));
+    return worker;
+}
+
+namespace {
+
+// new Worker(url, options)
+void WorkerConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (!args.IsConstructCall()) {
+        v8util::ThrowTypeError(isolate, "Worker must be called with new");
+        return;
+    }
+    auto* runtime = static_cast<WorkerRuntime*>(args.Data().As<v8::External>()->Value());
+    std::string url;
+    if (args.Length() > 0) {
+        // new Worker(new URL(...)) にも対応するため toString で URL 文字列化
+        url = ToStdString(isolate, args[0]);
+    }
+    args.GetReturnValue().Set(runtime->CreateWorker(url));
+}
+
+} // namespace
+
+void WorkerRuntime::InstallOnGlobal(v8::Local<v8::Object> global)
+{
+    v8::Local<v8::Context> ctx = isolate_->GetCurrentContext();
+    v8::Local<v8::External> ext = v8::External::New(isolate_, this);
+    v8::Local<v8::Function> ctor =
+        v8::Function::New(ctx, WorkerConstructor, ext).ToLocalChecked();
+    ctor->SetName(Str(isolate_, "Worker"));
+    global->Set(ctx, Str(isolate_, "Worker"), ctor).Check();
+}
+
+void WorkerRuntime::Pump(double now_ms)
+{
+    for (auto& w : workers_) {
+        w->Deliver(now_ms);
+    }
+}
+
+// Bindings.h の InstallWorker: WorkerRuntime を使って Worker を設置する。
+void InstallWorker(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContext* host)
+{
+    if (host->workers) {
+        host->workers->InstallOnGlobal(global);
+    }
+}
+
+} // namespace next2d

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

@@ -0,0 +1,108 @@
+// WorkerRuntime: Web Worker を「同一 Isolate 内の別 Context を協調スケジューリング」する
+// 単一スレッドモデルで実装する。
+//
+// player はレンダラを Worker + transferControlToOffscreen(OffscreenCanvas) で動かし、
+// メインスレッドから postMessage で描画コマンドを送る。真のマルチスレッド化は
+// Dawn/GPU のスレッド安全性を要するため、まず GPU を 1 スレッドに保てる協調モデルを採る。
+//
+// - new Worker(url)         : 別 Context を生成しワーカースクリプトを評価
+// - worker.postMessage(m,t) : main→worker のメッセージキューへ (ValueSerializer)
+// - self.postMessage(m,t)   : worker→main のメッセージキューへ
+// - Pump()                  : 双方向のメッセージ配送 + 各 worker の EventLoop 前進
+#pragma once
+
+#include <v8.h>
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace next2d {
+
+class HostContext;
+class EventLoop;
+class WorkerRuntime;
+
+// 1 メッセージ = ValueSerializer 出力バイト列。
+struct WorkerMessage {
+    std::vector<uint8_t> data;
+};
+
+class WorkerInstance {
+public:
+    WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url);
+    ~WorkerInstance();
+
+    bool Start();                 // Context 生成 + ワーカースクリプト評価
+    void Terminate();
+
+    // main→worker / worker→main の投函
+    void PostToWorker(std::vector<uint8_t> bytes);
+    void PostToMain(std::vector<uint8_t> bytes);
+
+    // 配送 + タイマー/rAF 前進 (WorkerRuntime::Pump から呼ぶ)
+    void Deliver(double now_ms);
+
+    v8::Local<v8::Context> context() const;
+    EventLoop* event_loop() const { return loop_.get(); }
+
+    // main 側の Worker オブジェクト (onmessage を保持)
+    v8::Global<v8::Object> main_worker_object;
+    // worker 側 self.onmessage
+    v8::Global<v8::Function> worker_onmessage;
+    // main 側 worker.onmessage
+    v8::Global<v8::Function> main_onmessage;
+
+private:
+    void DeliverToWorker(double now_ms);
+    void DeliverToMain();
+
+    WorkerRuntime* runtime_;
+    v8::Isolate* isolate_;
+    std::string url_;
+    v8::Global<v8::Context> context_;
+    std::unique_ptr<EventLoop> loop_;
+    std::deque<WorkerMessage> to_worker_;
+    std::deque<WorkerMessage> to_main_;
+    bool terminated_ = false;
+};
+
+class WorkerRuntime {
+public:
+    WorkerRuntime(v8::Isolate* isolate, HostContext* host);
+    ~WorkerRuntime();
+
+    v8::Isolate* isolate() const { return isolate_; }
+    HostContext* host() const { return host_; }
+
+    // main / worker グローバルに Worker コンストラクタ等を設置する。
+    void InstallOnGlobal(v8::Local<v8::Object> global);
+
+    // new Worker(url) の実体
+    v8::Local<v8::Object> CreateWorker(const std::string& url);
+
+    // 全 worker のメッセージ配送とイベントループ前進
+    void Pump(double now_ms);
+
+    bool HasWorkers() const { return !workers_.empty(); }
+
+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);
+
+// bytes を target_ctx で復元する。
+v8::MaybeLocal<v8::Value> DeserializeMessage(v8::Isolate* isolate,
+                                             v8::Local<v8::Context> target_ctx,
+                                             const std::vector<uint8_t>& bytes);
+
+} // namespace next2d