@next2d/builder 0.1.7 → 0.1.10

package/templates/xbox/src/bindings/DomShims.cpp

@@ -5,6 +5,10 @@
 #include "v8/V8Util.h"
 
 #include <Windows.h>
+#include <bcrypt.h>
+#include <cstdio>
+
+#pragma comment(lib, "bcrypt.lib")
 
 namespace next2d {
 
@@ -107,6 +111,116 @@ void ClipboardWriteText(const v8::FunctionCallbackInfo<v8::Value>& args)
     resolver->Resolve(ctx, v8::Undefined(isolate)).Check();
 }
 
+// crypto.getRandomValues(typedArray): OS 乱数で埋めて同じ view を返す
+void CryptoGetRandomValues(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() < 1 || !args[0]->IsArrayBufferView()) {
+        v8util::ThrowTypeError(isolate, "getRandomValues requires a TypedArray");
+        return;
+    }
+    auto view = args[0].As<v8::ArrayBufferView>();
+    std::vector<uint8_t> bytes(view->ByteLength());
+    if (!bytes.empty()) {
+        BCryptGenRandom(nullptr, bytes.data(), static_cast<ULONG>(bytes.size()),
+                        BCRYPT_USE_SYSTEM_PREFERRED_RNG);
+        // view のバッキングへ書き戻す
+        auto ab = view->Buffer();
+        auto* dst = static_cast<uint8_t*>(ab->GetBackingStore()->Data()) + view->ByteOffset();
+        memcpy(dst, bytes.data(), bytes.size());
+    }
+    args.GetReturnValue().Set(args[0]);
+}
+
+// crypto.randomUUID(): RFC 4122 v4
+void CryptoRandomUUID(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    uint8_t b[16] = {};
+    BCryptGenRandom(nullptr, b, sizeof(b), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
+    b[6] = static_cast<uint8_t>((b[6] & 0x0f) | 0x40);   // version 4
+    b[8] = static_cast<uint8_t>((b[8] & 0x3f) | 0x80);   // variant
+    char buf[37];
+    std::snprintf(buf, sizeof(buf),
+        "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+        b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
+        b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]);
+    args.GetReturnValue().Set(Str(isolate, buf));
+}
+
+// --- 名前付きストレージの永続化バックエンド ---------------------------------
+// localStorage / indexedDB のセマンティクスは Polyfills.cpp の JS 側が実装し、
+// ここは名前ごとのファイル I/O のみを担う。
+// 保存先: %LOCALAPPDATA%\Next2D\<name>.json (PC / Gaming.Desktop / CI)。
+//
+// コンソール実機 (Gaming.Xbox.*) のストレージ対応 (要 devkit 検証):
+//   - localStorage / indexedDB のようなタイトルローカル永続化は XPersistentLocalStorage
+//     (XPersistentLocalStorageGetPath で得たパス配下へ同じファイル I/O) が対応先。
+//     同期 API のため現行の同期ストレージ契約 (StorageLoad/StorageSave) にそのまま載る。
+//   - ユーザー毎のクラウド同期セーブが要る場合のみ XGameSave (非同期・XUser 必須) を使う。
+// いずれも console GDK ヘッダと signed-in user / SCID 構成が必要で、devkit 実機でしか
+// コンパイル・実行検証できないため未実装 (現状はファイルパスのフォールバックで動作)。
+std::wstring StorageFilePath(const std::string& name)
+{
+    // ファイル名として安全な文字だけを残す
+    std::wstring safe;
+    for (char c : name) {
+        const bool ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                        (c >= '0' && c <= '9') || c == '_' || c == '-';
+        safe.push_back(ok ? static_cast<wchar_t>(c) : L'_');
+    }
+    if (safe.empty()) {
+        safe = L"storage";
+    }
+    wchar_t base[MAX_PATH] = {};
+    if (!GetEnvironmentVariableW(L"LOCALAPPDATA", base, MAX_PATH)) {
+        return safe + L".json";   // フォールバック: カレント
+    }
+    std::wstring dir = std::wstring(base) + L"\\Next2D";
+    CreateDirectoryW(dir.c_str(), nullptr);
+    return dir + L"\\" + safe + L".json";
+}
+
+// __next2d_storage_load(name) -> string
+void StorageLoad(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    v8::Isolate* isolate = args.GetIsolate();
+    const std::string name = args.Length() > 0
+        ? v8util::ToStdString(isolate, args[0]) : "localStorage";
+    HANDLE h = CreateFileW(StorageFilePath(name).c_str(), GENERIC_READ, FILE_SHARE_READ,
+                           nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (h == INVALID_HANDLE_VALUE) {
+        args.GetReturnValue().Set(Str(isolate, ""));
+        return;
+    }
+    DWORD size = GetFileSize(h, nullptr);
+    std::string data(size, '\0');
+    DWORD read = 0;
+    ReadFile(h, data.data(), size, &read, nullptr);
+    CloseHandle(h);
+    data.resize(read);
+    args.GetReturnValue().Set(Str(isolate, data));
+}
+
+// __next2d_storage_save(name, data)
+void StorageSave(const v8::FunctionCallbackInfo<v8::Value>& args)
+{
+    if (args.Length() < 2) {
+        return;
+    }
+    v8::Isolate* isolate = args.GetIsolate();
+    const std::string name = v8util::ToStdString(isolate, args[0]);
+    const std::string data = v8util::ToStdString(isolate, args[1]);
+    HANDLE h = CreateFileW(StorageFilePath(name).c_str(), GENERIC_WRITE, 0,
+                           nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (h == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    DWORD written = 0;
+    WriteFile(h, data.data(), static_cast<DWORD>(data.size()), &written, nullptr);
+    CloseHandle(h);
+}
+
 // new OffscreenCanvas(width, height)
 void OffscreenCanvasConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
@@ -144,6 +258,19 @@ void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostCon
     SetValue(isolate, global, "self", global);
     NoopEventTarget(isolate, global);
 
+    // crypto (getRandomValues / randomUUID — OS 乱数)。
+    // player の WebGLUtil が ID 生成に crypto.randomUUID を使う。
+    {
+        v8::Local<v8::Object> crypto = v8::Object::New(isolate);
+        SetMethod(isolate, crypto, "getRandomValues", CryptoGetRandomValues);
+        SetMethod(isolate, crypto, "randomUUID", CryptoRandomUUID);
+        SetValue(isolate, global, "crypto", crypto);
+    }
+
+    // localStorage のファイル I/O バックエンド (Polyfills.cpp の JS が利用)
+    SetMethod(isolate, global, "__next2d_storage_load", StorageLoad);
+    SetMethod(isolate, global, "__next2d_storage_save", StorageSave);
+
     // devicePixelRatio
     SetValue(isolate, global, "devicePixelRatio",
              v8::Number::New(isolate, host->device_pixel_ratio));
@@ -158,6 +285,15 @@ void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostCon
     SetValue(isolate, global, "innerWidth", v8::Integer::New(isolate, host->viewport_width));
     SetValue(isolate, global, "innerHeight", v8::Integer::New(isolate, host->viewport_height));
 
+    // scrollX / scrollY (非スクロールの全画面アプリでは常に 0)。
+    // 未定義だと player の PlayerSetCurrentMousePointService 冒頭
+    // `let x = window.scrollX;` が undefined になり、以降 x が NaN 化して
+    // stage.pointer 全体が NaN → ヒットテストが全 miss → ボタンが一切反応しない。
+    SetValue(isolate, global, "scrollX", v8::Integer::New(isolate, 0));
+    SetValue(isolate, global, "scrollY", v8::Integer::New(isolate, 0));
+    SetValue(isolate, global, "pageXOffset", v8::Integer::New(isolate, 0));
+    SetValue(isolate, global, "pageYOffset", v8::Integer::New(isolate, 0));
+
     // navigator (gpu/getGamepads は後段のバインディングが付与)
     v8::Local<v8::Object> navigator = v8::Object::New(isolate);
     SetValue(isolate, navigator, "userAgent",
@@ -176,6 +312,8 @@ void InstallDomShims(v8::Isolate* isolate, v8::Local<v8::Object> global, HostCon
     // document
     v8::Local<v8::Object> document = v8::Object::New(isolate);
     SetMethod(isolate, document, "createElement", CreateElement);
+    // 起動時点で読み込み完了扱い (ゲームの boot 分岐が readyState === "loading" で待機しないように)
+    SetValue(isolate, document, "readyState", Str(isolate, "complete"));
     SetMethod(isolate, document, "getElementById",
         [](const v8::FunctionCallbackInfo<v8::Value>& a) { a.GetReturnValue().SetNull(); });
     SetMethod(isolate, document, "querySelector",
@@ -216,6 +354,11 @@ void InstallGlobalBindings(v8::Isolate* isolate, v8::Local<v8::Object> global, H
     InstallAudio(isolate, global, host);
     InstallWebGPU(isolate, global, host);   // navigator.gpu
     InstallGamepad(isolate, global, host);  // navigator.getGamepads
+
+    // TextEncoder/TextDecoder/queueMicrotask。bootstrap.js はメインコンテキスト
+    // でのみ実行されるため、worker を含む全コンテキストにはここで注入する
+    // (Vite バンドルの worker は評価時に TextDecoder を要求する)。
+    InstallPolyfills(isolate, isolate->GetCurrentContext());
 }
 
 } // namespace next2d

package/templates/xbox/src/bindings/EventTarget.cpp

@@ -96,6 +96,15 @@ void DispatchEvent(v8::Isolate* isolate, v8::Local<v8::Object> target,
         return;
     }
     const std::string type = ToStdString(isolate, type_val);
+
+    // event.target / currentTarget を配送先に設定する。
+    // player のポインタハンドラは `let t = e.target; t && (…, t.setPointerCapture(…), …)`
+    // のように先頭で event.target をガードするため、未設定だと pointerdown/move が
+    // 丸ごと no-op になり「ボタンが全く反応しない」。DOM 準拠でここで設定する。
+    (void) event->Set(ctx, Str(isolate, "target"), target);
+    (void) event->Set(ctx, Str(isolate, "currentTarget"), target);
+    (void) event->Set(ctx, Str(isolate, "srcElement"), target);
+
     v8::Local<v8::Value> args1[1] = { event };
 
     // on<type> プロパティ
@@ -104,6 +113,7 @@ void DispatchEvent(v8::Isolate* isolate, v8::Local<v8::Object> target,
     if (target->Get(ctx, Str(isolate, onname.c_str())).ToLocal(&on) && on->IsFunction()) {
         v8::TryCatch tc(isolate);
         (void) on.As<v8::Function>()->Call(ctx, target, 1, args1);
+        v8util::ReportCaught(isolate, &tc, onname.c_str());
     }
 
     // __listeners[type]
@@ -118,6 +128,7 @@ void DispatchEvent(v8::Isolate* isolate, v8::Local<v8::Object> target,
                 if (arr->Get(ctx, i).ToLocal(&fn) && fn->IsFunction()) {
                     v8::TryCatch tc(isolate);
                     (void) fn.As<v8::Function>()->Call(ctx, target, 1, args1);
+                    v8util::ReportCaught(isolate, &tc, ("listener:" + type).c_str());
                 }
             }
         }

package/templates/xbox/src/bindings/Fetch.cpp

@@ -3,6 +3,7 @@
 #include "HostContext.h"
 #include "AssetLoader.h"
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
 
 #include <cstring>
 #include <vector>
@@ -84,12 +85,6 @@ void ResponseJson(const v8::FunctionCallbackInfo<v8::Value>& args)
     args.GetReturnValue().Set(resolver->GetPromise());
 }
 
-// External に持たせた vector を解放するための弱参照コールバック
-void ReleaseResponseData(const v8::WeakCallbackInfo<std::vector<uint8_t>>& info)
-{
-    delete info.GetParameter();
-}
-
 v8::Local<v8::Object> MakeResponse(v8::Isolate* isolate, v8::Local<v8::Context> ctx,
                                    std::vector<uint8_t>&& bytes, bool ok, int status)
 {
@@ -101,8 +96,7 @@ v8::Local<v8::Object> MakeResponse(v8::Isolate* isolate, v8::Local<v8::Context>
     response->SetInternalField(0, v8::External::New(isolate, data));
 
     // GC 時に解放
-    auto* handle = new v8::Global<v8::Object>(isolate, response);
-    handle->SetWeak(data, ReleaseResponseData, v8::WeakCallbackType::kParameter);
+    v8util::AttachWeak(isolate, response, data);
 
     v8util::SetValue(isolate, response, "ok", v8::Boolean::New(isolate, ok));
     v8util::SetValue(isolate, response, "status", v8::Integer::New(isolate, status));

package/templates/xbox/src/bindings/Image.cpp

@@ -2,13 +2,19 @@
 
 #include "HostContext.h"
 #include "AssetLoader.h"
+#include "EventTarget.h"
 #include "ImageSource.h"
-#include "platform/WicDecoder.h"
+#include "platform/DecodeQueue.h"
+#include "platform/ImageDecoder.h"
 #include "v8/V8Util.h"
+#include "v8/WeakHandle.h"
 
 #include <objbase.h>
 
 #include <cstring>
+#include <iostream>
+#include <memory>
+#include <utility>
 #include <vector>
 
 namespace next2d {
@@ -18,12 +24,112 @@ using v8util::ToStdString;
 
 namespace {
 
-void ReleaseDecoded(const v8::WeakCallbackInfo<DecodedImage>& info)
+// base64 デコード (data: URL 用。Vite は小さい画像をインライン化する)
+bool ImageDecodeBase64(const std::string& in, std::vector<uint8_t>* out)
 {
-    delete info.GetParameter();
+    auto val = [](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() / 4 * 3);
+    int buf = 0, bits = 0;
+    for (char c : in) {
+        if (c == '=' || c == '\r' || c == '\n') continue;
+        const int v = val(c);
+        if (v < 0) return false;
+        buf = buf << 6 | v;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out->push_back(static_cast<uint8_t>(buf >> bits & 0xFF));
+        }
+    }
+    return true;
+}
+
+// src に指定された URL (assets 相対 / data:) を読み込み、WIC デコードを
+// バックグラウンドスレッド (DecodeQueue) へ逃がす。完了はメインループの
+// decodequeue::Pump() から反映される (ブラウザ同様、src 設定後に非同期で
+// load イベントが届く。img.src = url; img.onload = fn の順でも拾える)。
+// 同期デコードは画面遷移時に 1 秒超のフレームヒッチになる (--perf で計測済み)。
+void LoadImageFromSrc(v8::Isolate* isolate, v8::Local<v8::Object> self, const std::string& url)
+{
+    std::vector<uint8_t> input;
+    if (url.rfind("data:", 0) == 0) {
+        const auto comma = url.find(',');
+        if (comma != std::string::npos) {
+            const std::string meta = url.substr(5, comma - 5);
+            const std::string payload = url.substr(comma + 1);
+            if (meta.find(";base64") != std::string::npos) {
+                ImageDecodeBase64(payload, &input);
+            }
+        }
+    } else {
+        // pak (メモリ) 読みなので同期で問題ない。重いのはデコードのみ。
+        AssetLoader* assets = HostContext::From(isolate)->assets;
+        auto bytes = assets->ReadBinary(url);
+        if (bytes) {
+            input = std::move(*bytes);
+        }
+    }
+
+    auto image_ref = std::make_shared<v8::Global<v8::Object>>(isolate, self);
+    auto decoded = std::make_shared<DecodedImage>();
+    auto ok = std::make_shared<bool>(false);
+
+    decodequeue::Submit(
+        // プールスレッド: WIC デコードのみ (V8 に触れない)
+        [input = std::move(input), decoded, ok]() {
+            *ok = DecodeImage(input, *decoded);
+        },
+        // メインスレッド: 結果を image オブジェクトへ反映し load を発火
+        [isolate, image_ref, decoded, ok]() {
+            v8::HandleScope hs(isolate);
+            v8::Local<v8::Object> img_obj = image_ref->Get(isolate);
+            v8::Local<v8::Context> ctx = img_obj->GetCreationContextChecked();
+            v8::Context::Scope cs(ctx);
+
+            // «堅牢化» デコード失敗時の扱い。
+            // player の ShapeLoadSrcUseCase は image に "load" ハンドラのみ登録し
+            // "error" を監視しない。"error" だと Event.COMPLETE が来ず ImageShapeAtom
+            // .load() の Promise が永久未解決になり、ページ build (=画面遷移) が
+            // ローディングのままフリーズする。失敗時は 1x1 透明のプレースホルダを
+            // 割り当てて "load" として扱う (該当画像だけが空になる)。
+            auto* img = new DecodedImage(std::move(*decoded));
+            if (!*ok) {
+                img->width = 1;
+                img->height = 1;
+                img->rgba.assign(4, 0);
+            }
+
+            img_obj->SetInternalField(0, v8::External::New(isolate, img));
+            v8util::AttachWeak(isolate, img_obj, img);
+            v8util::SetValue(isolate, img_obj, "width",
+                             v8::Integer::NewFromUnsigned(isolate, img->width));
+            v8util::SetValue(isolate, img_obj, "height",
+                             v8::Integer::NewFromUnsigned(isolate, img->height));
+            v8util::SetValue(isolate, img_obj, "naturalWidth",
+                             v8::Integer::NewFromUnsigned(isolate, img->width));
+            v8util::SetValue(isolate, img_obj, "naturalHeight",
+                             v8::Integer::NewFromUnsigned(isolate, img->height));
+            v8util::SetValue(isolate, img_obj, "complete", v8::Boolean::New(isolate, true));
+
+            // 常に "load" を発火し、遷移を進行させる
+            v8::Local<v8::Object> ev = v8::Object::New(isolate);
+            v8util::SetValue(isolate, ev, "type", Str(isolate, "load"));
+            v8util::SetValue(isolate, ev, "target", img_obj);
+            DispatchEvent(isolate, img_obj, ev);
+
+            image_ref->Reset();
+        });
 }
 
-// Image コンストラクタ: src セッターで読み込み+デコードし onload を発火する。
+// Image コンストラクタ: src セッターで読み込み+デコードし load イベントを発火する。
 void ImageConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
@@ -31,11 +137,46 @@ void ImageConstructor(const v8::FunctionCallbackInfo<v8::Value>& args)
         v8util::ThrowTypeError(isolate, "Image must be called with new");
         return;
     }
-    // 実体は通常オブジェクト。src セッターで decode をトリガする。
-    args.This()->Set(isolate->GetCurrentContext(),
-                     Str(isolate, "complete"),
-                     v8::Boolean::New(isolate, false)).Check();
-    args.GetReturnValue().Set(args.This());
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::Object> self = args.This();
+
+    v8util::SetValue(isolate, self, "__isImageElement", v8::Boolean::New(isolate, true));
+    v8util::SetValue(isolate, self, "tagName", Str(isolate, "IMG"));
+    v8util::SetValue(isolate, self, "localName", Str(isolate, "img"));
+    v8util::SetValue(isolate, self, "complete", v8::Boolean::New(isolate, false));
+    v8util::SetValue(isolate, self, "width", v8::Integer::New(isolate, 0));
+    v8util::SetValue(isolate, self, "height", v8::Integer::New(isolate, 0));
+    v8util::SetValue(isolate, self, "naturalWidth", v8::Integer::New(isolate, 0));
+    v8util::SetValue(isolate, self, "naturalHeight", v8::Integer::New(isolate, 0));
+    InstallEventTarget(isolate, self);   // addEventListener("load"/"error")
+
+    self->SetNativeDataProperty(ctx, Str(isolate, "src"),
+        [](v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>& info) {
+            v8::Local<v8::Value> v;
+            if (info.This()->Get(info.GetIsolate()->GetCurrentContext(),
+                Str(info.GetIsolate(), "__src")).ToLocal(&v) && !v->IsUndefined()) {
+                info.GetReturnValue().Set(v);
+            } else {
+                info.GetReturnValue().Set(Str(info.GetIsolate(), ""));
+            }
+        },
+        [](v8::Local<v8::Name>, v8::Local<v8::Value> value,
+           const v8::PropertyCallbackInfo<void>& info) {
+            v8::Isolate* iso = info.GetIsolate();
+            v8util::SetValue(iso, info.This(), "__src", value);
+            LoadImageFromSrc(iso, info.This(), ToStdString(iso, value));
+        }).Check();
+
+    // decode(): 読み込み済みなら resolve、未読み込みでも resolve (簡易)
+    v8util::SetMethod(isolate, self, "decode",
+        [](const v8::FunctionCallbackInfo<v8::Value>& a) {
+            v8::Isolate* iso = a.GetIsolate();
+            auto r = v8::Promise::Resolver::New(iso->GetCurrentContext()).ToLocalChecked();
+            r->Resolve(iso->GetCurrentContext(), v8::Undefined(iso)).Check();
+            a.GetReturnValue().Set(r->GetPromise());
+        });
+
+    args.GetReturnValue().Set(self);
 }
 
 // createImageBitmap(source) -> Promise<ImageBitmap>
@@ -71,16 +212,83 @@ void CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value>& args)
         if (bytes) {
             input = std::move(*bytes);
         }
+    } else if (args[0]->IsObject()) {
+        v8::Local<v8::Object> obj = args[0].As<v8::Object>();
+
+        // 1) ImageData ({ data: Uint8ClampedArray, width, height }):
+        //    デコード不要でそのまま RGBA として取り込む
+        //    (webgpu レンダラのキャプチャ/フィルタ→ImageBitmap 化の経路)。
+        v8::Local<v8::Value> data_v, w_v, h_v;
+        if (obj->Get(ctx, Str(isolate, "data")).ToLocal(&data_v) && data_v->IsArrayBufferView() &&
+            obj->Get(ctx, Str(isolate, "width")).ToLocal(&w_v) && w_v->IsNumber() &&
+            obj->Get(ctx, Str(isolate, "height")).ToLocal(&h_v) && h_v->IsNumber()) {
+            const auto w = static_cast<uint32_t>(w_v.As<v8::Number>()->Value());
+            const auto h = static_cast<uint32_t>(h_v.As<v8::Number>()->Value());
+            auto view = data_v.As<v8::ArrayBufferView>();
+            if (view->ByteLength() < static_cast<size_t>(w) * h * 4) {
+                resolver->Reject(ctx, v8::Exception::TypeError(
+                    Str(isolate, "ImageData size mismatch"))).Check();
+                return;
+            }
+            auto* raw = new DecodedImage();
+            raw->width = w;
+            raw->height = h;
+            raw->rgba.resize(static_cast<size_t>(w) * h * 4);
+            view->CopyContents(raw->rgba.data(), raw->rgba.size());
+            resolver->Resolve(ctx, WrapImageBitmap(isolate, raw)).Check();
+            return;
+        }
+
+        // 2) ImageBitmap / 2D 済み canvas / video: ピクセルを複製して新規 ImageBitmap
+        const uint8_t* px = nullptr;
+        uint32_t sw = 0, sh = 0;
+        if (GetImageSourcePixels(isolate, obj, &px, &sw, &sh) && px) {
+            auto* raw = new DecodedImage();
+            raw->width = sw;
+            raw->height = sh;
+            raw->rgba.assign(px, px + static_cast<size_t>(sw) * sh * 4);
+            resolver->Resolve(ctx, WrapImageBitmap(isolate, raw)).Check();
+            return;
+        }
+
+        // 3) Blob: 内包バイト列 (エンコード済み画像) を WIC デコードへ回す
+        v8::Local<v8::Value> blob_v;
+        if (obj->Get(ctx, Str(isolate, "__blobData")).ToLocal(&blob_v) && blob_v->IsArrayBuffer()) {
+            auto store = blob_v.As<v8::ArrayBuffer>()->GetBackingStore();
+            input.assign(static_cast<uint8_t*>(store->Data()),
+                         static_cast<uint8_t*>(store->Data()) + store->ByteLength());
+        }
     }
 
-    auto* img = new DecodedImage();
-    if (input.empty() || !DecodeImageWithWIC(input, *img)) {
-        delete img;
+    if (input.empty()) {
         resolver->Reject(ctx, v8::Exception::Error(Str(isolate, "Image decode failed"))).Check();
         return;
     }
 
-    resolver->Resolve(ctx, WrapImageBitmap(isolate, img)).Check();
+    // WIC デコードはバックグラウンドスレッドへ (Promise なので元々非同期契約)
+    auto resolver_ref =
+        std::make_shared<v8::Global<v8::Promise::Resolver>>(isolate, resolver);
+    auto decoded = std::make_shared<DecodedImage>();
+    auto ok = std::make_shared<bool>(false);
+
+    decodequeue::Submit(
+        [input = std::move(input), decoded, ok]() {
+            *ok = DecodeImage(input, *decoded);
+        },
+        [isolate, resolver_ref, decoded, ok]() {
+            v8::HandleScope hs(isolate);
+            v8::Local<v8::Promise::Resolver> r = resolver_ref->Get(isolate);
+            v8::Local<v8::Context> c = r->GetCreationContextChecked();
+            v8::Context::Scope cs(c);
+            if (*ok) {
+                auto* img = new DecodedImage(std::move(*decoded));
+                r->Resolve(c, WrapImageBitmap(isolate, img)).Check();
+            } else {
+                r->Reject(c, v8::Exception::Error(
+                    Str(isolate, "Image decode failed"))).Check();
+            }
+            resolver_ref->Reset();
+        });
 }
 
 } // namespace
@@ -99,8 +307,7 @@ v8::Local<v8::Object> WrapImageBitmap(v8::Isolate* isolate, DecodedImage* image)
     v8util::SetValue(isolate, obj, "height", v8::Integer::NewFromUnsigned(isolate, image->height));
     v8util::SetMethod(isolate, obj, "close", [](const v8::FunctionCallbackInfo<v8::Value>&) {});
 
-    auto* handle = new v8::Global<v8::Object>(isolate, obj);
-    handle->SetWeak(image, ReleaseDecoded, v8::WeakCallbackType::kParameter);
+    v8util::AttachWeak(isolate, obj, image);
     return obj;
 }
 
@@ -126,6 +333,25 @@ bool GetImageSourcePixels(v8::Isolate* isolate, v8::Local<v8::Value> source,
         return true;
     }
 
+    // Image 要素 (new Image() + src): 読み込み完了後は内部フィールドに DecodedImage
+    v8::Local<v8::Value> is_image;
+    if (obj->Get(ctx, Str(isolate, "__isImageElement")).ToLocal(&is_image) &&
+        is_image->IsBoolean() && is_image.As<v8::Boolean>()->Value()) {
+        if (obj->InternalFieldCount() < 1) {
+            return false;
+        }
+        v8::Local<v8::Data> field = obj->GetInternalField(0);
+        if (!field->IsValue() || !field.As<v8::Value>()->IsExternal()) {
+            return false;   // 未読み込み
+        }
+        auto* img = static_cast<DecodedImage*>(
+            field.As<v8::Value>().As<v8::External>()->Value());
+        *out_rgba = img->rgba.data();
+        *out_width = img->width;
+        *out_height = img->height;
+        return true;
+    }
+
     // video 要素: 現在フレームを返す
     v8::Local<v8::Value> is_video;
     if (obj->Get(ctx, Str(isolate, "__isVideoElement")).ToLocal(&is_video) &&
@@ -151,6 +377,8 @@ void InstallImage(v8::Isolate* isolate, v8::Local<v8::Object> global, HostContex
     v8::Local<v8::FunctionTemplate> image_tmpl =
         v8::FunctionTemplate::New(isolate, ImageConstructor);
     image_tmpl->SetClassName(Str(isolate, "Image"));
+    // 内部フィールド0: デコード済み DecodedImage* (src セッターが設定)
+    image_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
     global->Set(ctx, Str(isolate, "Image"),
                 image_tmpl->GetFunction(ctx).ToLocalChecked()).Check();