@next2d/builder 0.1.8 → 0.1.10

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

@@ -7,9 +7,11 @@
 #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 {
@@ -117,15 +119,6 @@ bool IsImageBitmapObject(v8::Isolate* isolate, v8::Local<v8::Object> obj)
 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) {}
@@ -361,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
@@ -383,10 +400,6 @@ void WorkerSelfPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
     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 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));
     }
@@ -420,10 +433,6 @@ void MainWorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args)
     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 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));
     }
@@ -433,23 +442,22 @@ 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_);
     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();
 
     // ブラウザ相当環境一式 (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();
@@ -467,7 +475,7 @@ bool WorkerInstance::Start()
     // 入れ子 Worker を許可 (ZlibInflate 等)。
     runtime_->InstallOnGlobal(global);
 
-    // ワーカースクリプトを読み込んで評価 (クラシック。ESM worker は «EXTEND»)。
+    // ワーカースクリプトを読み込む (クラシック / ESM は module_ で分岐)。
     // Vite の `?worker&inline` は data:application/javascript;base64,... を渡す
     // (バージョンによっては blob: URL)。data: / blob: / assets の順で解決する。
     HostContext* host = HostContext::From(isolate_);
@@ -501,37 +509,23 @@ bool WorkerInstance::Start()
         }
         source = std::move(*src);
     }
-    std::cerr << "[Worker] source resolved (" << source.size() << " bytes)" << std::endl;
 
-    // «診断» レンダラ worker のフレームサイクル (frameStarted / mainTexture) を追跡する。
-    // 黒画面問題: getCurrentTexture がフレーム 3 回目以降呼ばれなくなる現象の原因特定用。
-    // minify 後も this.プロパティ名は保持されるためパターンは安定。見つからなければ無変更。
+    // 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);
-            } 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);"
@@ -542,8 +536,10 @@ bool WorkerInstance::Start()
     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: " << ShortUrl(url_) << std::endl;
         if (tc.HasCaught()) {
@@ -560,7 +556,115 @@ bool WorkerInstance::Start()
     // NOTE: ここで PerformMicrotaskCheckpoint は呼ばない。Start は JS コールバック
     // (new Worker) の最中に呼ばれるため、JS 実行中のチェックポイントは V8 の規約違反。
     // マイクロタスクはメインループの PumpMicrotasks で処理される。
-    std::cerr << "[Worker] script evaluated" << std::endl;
+    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;
+    }
     return true;
 }
 
@@ -585,16 +689,9 @@ 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).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;
@@ -619,16 +716,9 @@ 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).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;
@@ -652,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 オブジェクト
@@ -702,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

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

@@ -15,6 +15,7 @@
 
 #include <cstdint>
 #include <deque>
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -25,6 +26,10 @@ class HostContext;
 class EventLoop;
 class WorkerRuntime;
 
+// worker context の embedder slot。1 は EventLoop (kEventLoopEmbedderSlot) が使用。
+// ESM の ResolveModule コールバックが context から WorkerInstance を引くために使う。
+constexpr int kWorkerInstanceEmbedderSlot = 2;
+
 // 1 メッセージ = ValueSerializer 出力バイト列 + transfer された ArrayBuffer の実体。
 // transfer_list の ArrayBuffer は中身を bytes に埋め込まず所有権ごと移す
 // (render キューは数十 MB になるため、コピーするとフレームレートが崩壊する)。
@@ -35,7 +40,8 @@ struct WorkerMessage {
 
 class WorkerInstance {
 public:
-    WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url);
+    WorkerInstance(WorkerRuntime* runtime, v8::Isolate* isolate, std::string url,
+                   bool is_module = false);
     ~WorkerInstance();
 
     bool Start();                 // Context 生成 + ワーカースクリプト評価
@@ -62,14 +68,28 @@ private:
     void DeliverToWorker(double now_ms);
     void DeliverToMain();
 
+    // ESM worker (type: "module")。分類スクリプトは Script、モジュールは Module として評価。
+    bool EvaluateModule(v8::Local<v8::Context> context, const std::string& source);
+    v8::MaybeLocal<v8::Module> LoadModule(const std::string& url);
+    static v8::MaybeLocal<v8::Module> ResolveModule(
+        v8::Local<v8::Context> context,
+        v8::Local<v8::String> specifier,
+        v8::Local<v8::FixedArray> import_attributes,
+        v8::Local<v8::Module> referrer);
+
     WorkerRuntime* runtime_;
     v8::Isolate* isolate_;
     std::string url_;
+    bool module_ = false;
     v8::Global<v8::Context> context_;
     std::unique_ptr<EventLoop> loop_;
     std::deque<WorkerMessage> to_worker_;
     std::deque<WorkerMessage> to_main_;
     bool terminated_ = false;
+
+    // ESM 解決: url -> Module、Module identity hash -> url (referrer 特定用)。
+    std::map<std::string, v8::Global<v8::Module>> modules_;
+    std::map<int, std::string> module_paths_;
 };
 
 class WorkerRuntime {
@@ -83,8 +103,8 @@ public:
     // main / worker グローバルに Worker コンストラクタ等を設置する。
     void InstallOnGlobal(v8::Local<v8::Object> global);
 
-    // new Worker(url) の実体
-    v8::Local<v8::Object> CreateWorker(const std::string& url);
+    // new Worker(url, { type }) の実体
+    v8::Local<v8::Object> CreateWorker(const std::string& url, bool is_module = false);
 
     // 全 worker のメッセージ配送とイベントループ前進
     void Pump(double now_ms);

package/templates/xbox/tests/check_local.sh

@@ -47,9 +47,13 @@ FILES=(
     src/bindings/Canvas.cpp
     src/bindings/Audio.cpp
     src/bindings/Gamepad.cpp
+    src/platform/DecodeQueue.cpp
+    src/platform/AudioDecoder.cpp
+    src/platform/ImageDecoder.cpp
+    src/platform/StbTextRasterizer.cpp
 )
 for f in "${FILES[@]}"; do
-    c++ -fsyntax-only -std=c++20 -Isrc -isystem "${V8INC}" \
+    c++ -fsyntax-only -std=c++20 -Isrc -I. -isystem "${V8INC}" \
         -DV8_COMPRESS_POINTERS "$f"
     echo "OK   $f"
 done

package/templates/xbox/tests/gamecore_api_probe.cpp

@@ -0,0 +1,172 @@
+// Game Core (Xbox コンソール) API パーティション監査プローブ。
+//
+// Windows SDK (19041+) は各 API 宣言を WINAPI_PARTITION_* でガードしており、
+// `cl /DWINAPI_FAMILY=WINAPI_FAMILY_GAMES` でコンパイルすると GAMES パーティションに
+// 属さない API は「未宣言」エラーになる。= NDA 資料なしで、公開 SDK だけを使って
+// 「コンソールで使えない API」を正確に列挙できる (プリプロセッサが公式のゲート
+// ロジックそのものを評価するため、テキスト解析より確実)。
+//
+// 使い方 (xbox-host-ci の gamecore-api-audit ジョブが実行):
+//   cl /c /DWINAPI_FAMILY=WINAPI_FAMILY_GAMES tests\gamecore_api_probe.cpp
+//     -> ホストがコンソールで使う API の存在検証 (エラー = 直ちに修正が必要)
+//   cl /c /DWINAPI_FAMILY=WINAPI_FAMILY_GAMES /DPROBE_V8 tests\gamecore_api_probe.cpp
+//     -> V8 の platform 層 (src/base/platform/*-win32) が使う API の存在検証
+//        (エラー = V8 Game Core 移植時に置換が必要な TODO リスト。情報提供扱い)
+//
+// 注意: これは「宣言がパーティションに含まれるか」の静的検査。実機での挙動
+// (リンク先 lib の有無・実行時の権限) は devkit での検証が別途必要。
+//
+// WIN32_LEAN_AND_MEAN は必須: GAMES ファミリではフル Windows.h が引き込む
+// 周辺ヘッダ (mmsystem/ole2/winsock 等) に GAMES 非対応部分があり
+// コンパイルが壊れる (vcpkg の Xbox トリプレットも同様の前提)。
+// 必要なヘッダは個別に include する。
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <Windows.h>
+
+#include <objbase.h>      // CoInitializeEx (DecodeQueue のスレッド COM 初期化)
+#include <bcrypt.h>       // BCryptGenRandom (crypto.getRandomValues)
+#include <xaudio2.h>      // XAudio2Create (音声出力)
+
+#ifdef PROBE_V8
+#include <timeapi.h>      // timeGetTime (V8 time.cc — GAMES 外の想定 = TODO 検出対象)
+#include <psapi.h>        // GetProcessMemoryInfo (V8 OS::GetPeakMemoryUsageKb)
+#include <process.h>      // _beginthreadex (V8 Thread)
+#endif
+
+// 関数アドレスを取るだけの配列。宣言が無ければコンパイルエラーになる。
+#define PROBE(fn) reinterpret_cast<void*>(&fn)
+
+// ---------------------------------------------------------------------------
+// ホストがコンソールビルドでも使う API (NEXT2D_XBOX_CONSOLE ガード外のもの)。
+// ここのエラーはホスト側の修正が必要 (ジョブを fail させる)。
+// ---------------------------------------------------------------------------
+void* const g_host_apis[] = {
+    // ウィンドウ / メッセージループ (main.cpp。GDK コンソールサンプルも同構成)
+    PROBE(RegisterClassExW),
+    PROBE(CreateWindowExW),
+    PROBE(DefWindowProcW),
+    PROBE(PeekMessageW),
+    PROBE(TranslateMessage),
+    PROBE(DispatchMessageW),
+    PROBE(PostQuitMessage),
+    PROBE(LoadCursorW),
+    PROBE(GetClientRect),
+
+    // 時刻 / ペーシング (EventLoop::Now, メインループ)
+    PROBE(QueryPerformanceCounter),
+    PROBE(QueryPerformanceFrequency),
+    PROBE(Sleep),
+
+    // モジュール / 環境 (ExeDir, DomShims の storage パス解決)
+    PROBE(GetModuleFileNameW),
+    PROBE(GetModuleHandleW),
+    PROBE(GetEnvironmentVariableW),
+    PROBE(GetLastError),
+
+    // COM (DecodeQueue プールスレッド。コンソールでは WIC/MF は使わないが
+    // CoInitializeEx 自体は呼ぶ)
+    PROBE(CoInitializeEx),
+    PROBE(CoUninitialize),
+
+    // 乱数 (crypto.getRandomValues)
+    PROBE(BCryptGenRandom),
+
+    // 音声 (XAudio2 はコンソールでは xaudio2_9)
+    PROBE(XAudio2Create),
+
+    // リソース (EmbeddedAssets の RCDATA 読み込み)
+    PROBE(FindResourceW),
+    PROBE(LoadResource),
+    PROBE(LockResource),
+    PROBE(SizeofResource),
+};
+
+#ifdef PROBE_V8
+// ---------------------------------------------------------------------------
+// V8 13.7 の platform 層 (src/base/platform/{platform-win32,time,mutex,
+// condition-variable,semaphore}.cc) から機械抽出した Win32 API。
+// ここのエラー = V8 Game Core 移植時の置換 TODO (情報提供、ジョブは fail しない)。
+// ---------------------------------------------------------------------------
+void* const g_v8_apis[] = {
+    // 仮想メモリ (焦点: コンソールでは XMemVirtualAlloc への置換が推奨とされる)
+    PROBE(VirtualAlloc),
+    PROBE(VirtualFree),
+    PROBE(VirtualProtect),
+    PROBE(VirtualQuery),
+    PROBE(DiscardVirtualMemory),
+    // VirtualAlloc2 / MapViewOfFile3 / UnmapViewOfFile2 は V8 が GetProcAddress で
+    // 動的解決するが、宣言の有無がパーティション対応の指標になるため含める
+    PROBE(VirtualAlloc2),
+    PROBE(MapViewOfFile3),
+    PROBE(UnmapViewOfFile2),
+
+    // ファイルマッピング (OS::MemoryMappedFile)
+    PROBE(CreateFileMappingW),
+    PROBE(CreateFileW),
+    PROBE(MapViewOfFile),
+    PROBE(MapViewOfFileEx),
+    PROBE(UnmapViewOfFile),
+    PROBE(GetFileSize),
+    PROBE(GetFileType),
+    PROBE(DeleteFileA),
+    PROBE(GetTempPathA),
+    PROBE(GetTempFileNameA),
+
+    // スレッド / TLS / 同期
+    PROBE(GetCurrentThread),
+    PROBE(GetCurrentThreadId),
+    PROBE(SetThreadPriority),
+    PROBE(TlsAlloc),
+    PROBE(TlsFree),
+    PROBE(TlsGetValue),
+    PROBE(TlsSetValue),
+    PROBE(CreateSemaphoreA),
+    PROBE(ReleaseSemaphore),
+    PROBE(WaitForSingleObject),
+    PROBE(CloseHandle),
+    PROBE(CreateWaitableTimerExW),
+    PROBE(SetWaitableTimer),
+
+    // 時刻 (焦点: timeGetTime は winmm — デスクトップ専用の可能性が高い)
+    PROBE(timeGetTime),
+    PROBE(GetSystemTime),
+    PROBE(GetSystemTimeAsFileTime),
+    PROBE(SystemTimeToFileTime),
+    PROBE(GetThreadTimes),
+    PROBE(GetTimeZoneInformation),
+
+    // プロセス / システム情報
+    PROBE(GetCurrentProcess),
+    PROBE(GetCurrentProcessId),
+    PROBE(GetSystemInfo),
+    PROBE(ExitProcess),
+    PROBE(TerminateProcess),
+    PROBE(GetProcessMemoryInfo),
+    PROBE(SetErrorMode),
+    PROBE(GetStdHandle),
+
+    // 文字列変換 / デバッグ / モジュール
+    PROBE(MultiByteToWideChar),
+    PROBE(WideCharToMultiByte),
+    PROBE(OutputDebugStringA),
+    PROBE(DebugBreak),
+    PROBE(IsDebuggerPresent),
+    PROBE(LoadLibraryW),
+    PROBE(GetProcAddress),
+    PROBE(VerifyVersionInfoW),   // IsWindows10OrGreater (versionhelpers) の実体
+
+    // CRT (参考: パーティション対象外のはずだが確認)
+    reinterpret_cast<void*>(&_beginthreadex),
+};
+#endif // PROBE_V8
+
+// リンク不要 (cl /c のみ)。配列が最適化で消えないよう参照を残す。
+void* GameCoreApiProbeAnchor()
+{
+    void* acc = const_cast<void**>(g_host_apis)[0];
+#ifdef PROBE_V8
+    acc = const_cast<void**>(g_v8_apis)[0];
+#endif
+    return acc;
+}