@ttmg/cli 0.3.6-beta.3 → 0.3.6-beta.wasmcode.split

package/dist/index.js

@@ -38,9 +38,12 @@ var FormData$1 = require('form-data');
 var ttmgPack = require('ttmg-pack');
 var expressStaticGzip = require('express-static-gzip');
 var fileUpload = require('express-fileupload');
+var ttmgWasmtool = require('@anrans001/ttmg-wasmtool');
+var crypto$1 = require('node:crypto');
 var fs$1 = require('node:fs');
 var path$1 = require('node:path');
 var zlib = require('zlib');
+var crypto = require('crypto');
 var promises = require('fs/promises');
 var qs = require('qs');
 
@@ -69,6 +72,8 @@ var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
 var dns__namespace = /*#__PURE__*/_interopNamespaceDefault(dns);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var glob__namespace = /*#__PURE__*/_interopNamespaceDefault(glob);
+var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
+var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
 
 async function openUrl(url) {
     const { launch } = await import('chrome-launcher');
@@ -6504,7 +6509,19 @@ const getCurrentUser = () => {
     }
 };
 
-// ppe_dev_tool
+/**
+ * PPE / 测试环境开关。
+ *
+ * 所有 CLI 接口（`stark_wasm/v4/*`, `wasm-collect/v1/*`, portal 鉴权等）
+ * 都共用本文件的 `request()`，所以在这里统一注入 PPE header 就能覆盖全量。
+ * 不在 `DEV_HEADERS` 里改是因为那份常量只被 `remotePipeline.ts` 里的老
+ * 远程分包接口 spread 用；新加的 `startSession.ts` / `finishSession.ts` /
+ * `getCollectedFuncIds.ts` 都没 spread，漏一处就会绕开 PPE。
+ *
+ * 要切回线上环境，直接把 `CLI_PPE_ENV` 设成空串即可（下方条件 spread 会
+ * 自动不带这两个 header）。
+ */
+const CLI_PPE_ENV = 'ppe_wasm_test';
 function getAxiosProxyConfig() {
     const config = getTTMGRC();
     // 优先级: http-proxy > socks-proxy > proxy (老字段兼容)
@@ -6542,6 +6559,8 @@ async function request({ url, method, data, headers, params, }) {
     console.log('Method:', method);
     console.log('Headers:', JSON.stringify({
         Cookie: cookie,
+        ...({ 'x-use-ppe': '1', 'x-tt-env': CLI_PPE_ENV }
+            ),
         ...(headers || {}),
     }, null, 2));
     if (params) {
@@ -6559,8 +6578,11 @@ async function request({ url, method, data, headers, params, }) {
             params,
             headers: {
                 Cookie: cookie,
-                // 'x-use-ppe': '1',
-                // 'x-tt-env': 'ppe_upgrade_script',
+                // 注入 PPE header — 放在 caller headers 之前，允许单个调用点通过
+                // 显式传 `x-tt-env` 来覆盖本次请求（例如某个接口还没在 PPE 上发布）。
+                ...(CLI_PPE_ENV
+                    ? { 'x-use-ppe': '1', 'x-tt-env': CLI_PPE_ENV }
+                    : {}),
                 ...(headers || {}),
             },
             ...proxyConfig,
@@ -6600,7 +6622,6 @@ async function request({ url, method, data, headers, params, }) {
     }
 }
 async function download(url, filePath) {
-    // 清理旧文件
     if (fs.existsSync(filePath)) {
         try {
             fs.unlinkSync(filePath);
@@ -6608,16 +6629,31 @@ async function download(url, filePath) {
         catch { }
     }
     const proxyConfig = getAxiosProxyConfig();
+    console.log('[download] start', { url: url.slice(0, 120), filePath, hasProxy: !!proxyConfig.httpsAgent });
     try {
         const res = await axios.get(url, {
             responseType: 'stream',
-            // 让非 2xx 进入 catch
             validateStatus: s => s >= 200 && s < 300,
+            // Bail out if the server doesn't start responding within 30s instead of
+            // hanging forever (e.g. proxy misrouting a CDN signed URL).
+            timeout: 30000,
             ...proxyConfig,
         });
-        // 关键：把“流事件”封装为 Promise，并 await 它
+        const total = Number(res.headers['content-length'] || 0);
+        let received = 0;
+        let lastLoggedPct = -1;
+        const startedAt = Date.now();
         await new Promise((resolve, reject) => {
             const writer = fs.createWriteStream(filePath);
+            // Inactivity watchdog: if no bytes arrive for 60s mid-stream, abort.
+            let inactivityTimer = null;
+            const resetInactivity = () => {
+                if (inactivityTimer)
+                    clearTimeout(inactivityTimer);
+                inactivityTimer = setTimeout(() => {
+                    onError(new Error('download stalled: no data for 60s'));
+                }, 60000);
+            };
             const onError = (e) => {
                 cleanup();
                 try {
@@ -6629,28 +6665,42 @@ async function download(url, filePath) {
             };
             const onClose = () => {
                 cleanup();
+                console.log(`[download] done: ${received} bytes in ${Date.now() - startedAt}ms`);
                 resolve();
             };
             const cleanup = () => {
+                if (inactivityTimer)
+                    clearTimeout(inactivityTimer);
                 writer.off('error', onError);
                 writer.off('close', onClose);
                 res.data.off('error', onError);
+                res.data.off('data', onData);
+            };
+            const onData = (chunk) => {
+                received += chunk.length;
+                resetInactivity();
+                if (total > 0) {
+                    const pct = Math.floor((received / total) * 10) * 10;
+                    if (pct !== lastLoggedPct) {
+                        lastLoggedPct = pct;
+                        console.log(`[download] ${pct}% (${received}/${total})`);
+                    }
+                }
             };
             res.data.on('error', onError);
+            res.data.on('data', onData);
             writer.on('error', onError);
             writer.on('close', onClose);
+            resetInactivity();
             res.data.pipe(writer);
         });
-        // 成功
         return { ok: true };
     }
     catch (err) {
-        // 403 等受控处理
+        console.log('[download] failed:', err?.message);
         if (isAxiosError(err) && err.response?.status === 403) {
-            // 不抛出，让上层自行决定
             throw new Error('下载链接已过期，请重新进行分包后重试');
         }
-        // 其他错误抛出或返回
         throw err;
     }
 }
@@ -8899,7 +8949,12 @@ const gameUploadRoute = {
     },
 };
 
+// 历史遗留：`remotePipeline.ts` 里的老远程分包接口 spread 了 `DEV_HEADERS`。
+// 目前全局 PPE 走的是 `libs/api/request.ts` 里的 `CLI_PPE_ENV`，这里保持
+// 相同的值是为了：一旦以后需要按接口粒度覆盖 PPE（例如远程走 PPE、本地
+// 走线上），只需在这里填回 header、两处值天然一致。
 const BASE_URL = 'https://developers.tiktok.com';
+const WASM_COLLECT_BASE_URL = `${BASE_URL}/api/wasm-collect/v1`;
 const DEV_HEADERS = {
 // 'x-use-ppe': '1',
 // 'x-tt-env': UNITY_PPE_ENV,
@@ -8922,6 +8977,8 @@ const UNITY_WASM_SPLIT_CONFIG_FIELD_SCHEME = {
     WASMSPLITVERSION: `"$WASMSPLITVERSION"`,
     ENABLEWASMSPLIT: `"$ENABLEWASMSPLIT"`,
     IOS_SUB_JS_FILE_CONFIG: `"$IOS_SUB_JS_FILE_CONFIG"`,
+    ENABLEARCHIVEMODE: `"$ENABLEARCHIVEMODE"`,
+    ARCHIVE_CODE_FILE_MD5: `$ARCHIVE_CODE_FILE_MD5`,
 };
 
 const DIR_SPLIT = 'split';
@@ -8960,69 +9017,6 @@ const CONCURRENCY_LIMIT = 2;
 const DOWNLOAD_RETRY = 3;
 const WASM_SPLIT_CONFIG_FILE_NAME = 'webgl-wasm-split.js';
 
-// prepare.ts
-// 若你的 request 是 axios：你可以添加 maxBodyLength/ maxContentLength 等参数
-// 若是 got：可直接传 form 实例
-async function startPrepare(params) {
-    const form = new FormData$1();
-    form.append('desc', params.desc);
-    form.append('wasm_md5', params.wasm_md5);
-    form.append('with_ios', 'true');
-    // 二进制字段：用 ReadStream（推荐）或 Buffer
-    form.append('wasm_file', fs$1.createReadStream(path$1.join(process.cwd(), params.wasm_file_path)), {
-        filename: path$1.basename(params.wasm_file_path),
-        // 部分后端会依赖 content-type；如果不确定就用 application/octet-stream
-        contentType: 'application/wasm',
-    });
-    /**
-     * 兼容 WASM_SYMBOL_FILE_NAME
-     * case 1：项目根目录有 webgl.symbols.json 文件
-     * case 2：项目根目录没有 webgl.symbols.json 文件，但 TTMG_TEMP_DIR 有
-     * 优先读 2
-     */
-    let symbolFilePath = path$1.join(process.cwd(), TTMG_TEMP_DIR, WASM_SYMBOL_FILE_NAME);
-    if (!fs$1.existsSync(symbolFilePath)) {
-        symbolFilePath = path$1.join(process.cwd(), WASM_SYMBOL_FILE_NAME);
-    }
-    /**
-     * 判断是否有 symbol 文件，有则上传，没有直接接口报错
-     */
-    if (!fs$1.existsSync(symbolFilePath)) {
-        return {
-            error: {
-                code: 400,
-                message: `${WASM_SYMBOL_FILE_NAME} not found at ${path$1.join(process.cwd())}，use unity plugin to rebuild`,
-                client_key: params.client_key,
-            },
-            data: null,
-            ctx: {
-                logid: '',
-                httpStatusCode: 400,
-            },
-        };
-    }
-    form.append('wasm_symbol_file', fs$1.createReadStream(symbolFilePath), {
-        filename: WASM_SYMBOL_FILE_NAME,
-        contentType: 'application/octet-stream',
-    });
-    // 关键：用 form.getHeaders() 获取带 boundary 的 Content-Type
-    const formHeaders = form.getHeaders();
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/prepare`,
-        method: 'POST',
-        headers: {
-            ...DEV_HEADERS,
-            ...formHeaders, // 包含正确的 multipart/form-data; boundary=...
-        },
-        params: {
-            client_key: params.client_key,
-            with_ios: true,
-        },
-        data: form,
-        // 若 request 基于 axios，建议加上以下两项以支持大文件：
-    });
-}
-
 async function withRetry(fn, retries = 3) {
     let lastErr;
     for (let i = 0; i < retries; i++) {
@@ -9039,18 +9033,26 @@ async function withRetry(fn, retries = 3) {
 }
 
 function updateWasmSplitConfig(fields) {
+    const configFilePath = path.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME);
+    let config = fs.readFileSync(configFilePath, 'utf-8');
     for (const field in fields) {
         const value = fields[field];
-        const isString = typeof value === 'string';
-        const valueStr = isString ? value : String(value);
-        const configFilePath = path.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME);
         const placeholder = UNITY_WASM_SPLIT_CONFIG_FIELD_SCHEME[field];
-        const config = fs.readFileSync(configFilePath, 'utf-8');
-        // 将占位符替换为 true/false 字面量
-        // 用正则？因为 placeholder 是一个字符串，可能包含特殊字符
-        const updated = config.replace(placeholder, valueStr);
-        fs.writeFileSync(configFilePath, updated, 'utf-8');
+        if (!placeholder)
+            continue;
+        let replacement;
+        if (typeof value === 'boolean' || typeof value === 'number') {
+            replacement = String(value);
+        }
+        else if (typeof value === 'string') {
+            replacement = value;
+        }
+        else {
+            replacement = String(value);
+        }
+        config = config.replace(placeholder, replacement);
     }
+    fs.writeFileSync(configFilePath, config, 'utf-8');
 }
 
 async function compressWasmFile(wasmFilePath, compressedFilePath) {
@@ -9062,7 +9064,11 @@ async function compressWasmFile(wasmFilePath, compressedFilePath) {
 }
 function compressArrayBuffer(arrayBuffer) {
     return new Promise((resolve, reject) => {
-        const compressStream = zlib.createBrotliCompress();
+        const compressStream = zlib.createBrotliCompress({
+            params: {
+                [zlib.constants.BROTLI_PARAM_QUALITY]: 9,
+            },
+        });
         compressStream.write(Buffer.from(arrayBuffer));
         compressStream.end();
         const compressedChunks = [];
@@ -9098,176 +9104,899 @@ function keepCacheSync({ entryDir, originalWasmPath, originalSplitConfigPath, })
     };
 }
 
-async function downloadPrepared(data) {
-    wsServer.sendUnitySplitStatus({
-        status: 'star_fetch_prepared_wasm_url',
-    });
-    const res = await request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/download_prepared`,
-        method: 'POST',
-        headers: DEV_HEADERS,
-        data,
-    });
-    wsServer.sendUnitySplitStatus({
-        status: 'fetch_prepared_wasm_url_done',
+/**
+ * Restore webgl-wasm-split.js from the cached original (with placeholders).
+ * Called at the start of each prepare so that pipeline-specific values can be
+ * applied deterministically, regardless of previous runs.
+ * No-op if the cache does not yet exist (first run).
+ */
+function restoreSplitConfigFromCache(entryDir = process.cwd()) {
+    const cachedConfigPath = path.join(entryDir, WASM_SPLIT_CACHE_DIR, path.basename(WASM_SPLIT_CONFIG_FILE_NAME));
+    const targetConfigPath = path.join(entryDir, WASM_SPLIT_CONFIG_FILE_NAME);
+    if (fs.existsSync(cachedConfigPath)) {
+        fs.copyFileSync(cachedConfigPath, targetConfigPath);
+    }
+}
+
+/**
+ * Restore the project from the backup cache:
+ * - original (unmodified) wasm file back into its `wasmcode/<file>.br` location
+ * - webgl-wasm-split.js back to its template (with placeholders)
+ * - game.json back to its pre-split version
+ * - remove generated sub-package directories (wasmcode-android, wasmcode1-android, wasmcode-ios, etc.)
+ *
+ * Shared by both local and remote reset/rollback flows.
+ */
+function restoreFromCache(entryDir = process.cwd()) {
+    const cacheDir = path.join(entryDir, WASM_SPLIT_CACHE_DIR);
+    if (fs.existsSync(cacheDir)) {
+        const targetWasmBrPath = fs
+            .readdirSync(cacheDir)
+            .find(item => item.endsWith('.br'));
+        if (targetWasmBrPath) {
+            const destWasmBrPath = path.join(entryDir, WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root, path.basename(targetWasmBrPath));
+            ensureDirSync(path.dirname(destWasmBrPath));
+            fs.copyFileSync(path.join(cacheDir, targetWasmBrPath), destWasmBrPath);
+        }
+    }
+    const splitConfigCachePath = path.join(cacheDir, WASM_SPLIT_CONFIG_FILE_NAME);
+    if (fs.existsSync(splitConfigCachePath)) {
+        fs.copyFileSync(splitConfigCachePath, path.join(entryDir, WASM_SPLIT_CONFIG_FILE_NAME));
+    }
+    const gameJsonCachePath = path.join(cacheDir, 'game.json');
+    if (fs.existsSync(gameJsonCachePath)) {
+        fs.copyFileSync(gameJsonCachePath, path.join(entryDir, 'game.json'));
+    }
+    const subDirs = [
+        WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain.root,
+        WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub.root,
+        WASM_SPLIT_SUBPACKAGE_CONFIG.ios.root,
+    ];
+    for (const subDir of subDirs) {
+        const full = path.join(entryDir, subDir);
+        if (fs.existsSync(full)) {
+            fs.rmSync(full, { recursive: true });
+        }
+    }
+}
+
+async function decompressWasmFile(inputPath, outputPath) {
+    const compressed = await fs.promises.readFile(inputPath);
+    const decompressed = await new Promise((resolve, reject) => {
+        zlib.brotliDecompress(compressed, (err, result) => {
+            if (err)
+                reject(err);
+            else
+                resolve(result);
+        });
     });
+    await fs.promises.writeFile(outputPath, decompressed);
+}
+
+function computeFileMd5Sync(filePath) {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+
+let cached = null;
+function getGameJson() {
+    if (cached)
+        return cached;
+    const filePath = path$1.join(process.cwd(), 'game.json');
+    if (fs$1.existsSync(filePath)) {
+        try {
+            cached = JSON.parse(fs$1.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            cached = {};
+        }
+    }
+    else {
+        cached = {};
+    }
+    return cached;
+}
+
+function metaFilePath(entryDir = process.cwd()) {
+    return path__namespace$1.join(entryDir, TTMG_TEMP_DIR, 'prepared-meta.json');
+}
+function writePreparedMeta(meta, entryDir = process.cwd()) {
+    const target = metaFilePath(entryDir);
+    fs__namespace$1.mkdirSync(path__namespace$1.dirname(target), { recursive: true });
+    const payload = {
+        ...meta,
+        preparedAt: new Date().toISOString(),
+    };
+    fs__namespace$1.writeFileSync(target, JSON.stringify(payload, null, 2), 'utf-8');
+}
+function readPreparedMeta(entryDir = process.cwd()) {
+    const target = metaFilePath(entryDir);
+    if (!fs__namespace$1.existsSync(target))
+        return null;
     try {
-        const downloadUrl = res?.data?.result?.download_url;
-        const willReplaceWasmPath = path.join(process.cwd(), data.wasm_path);
-        if (downloadUrl) {
-            const { cacheDir } = keepCacheSync({
-                entryDir: process.cwd(),
-                originalWasmPath: data.wasm_path,
-                originalSplitConfigPath: WASM_SPLIT_CONFIG_FILE_NAME,
-            });
-            if (downloadUrl.includes('.br')) {
-                const tempWasmPath = path.join(cacheDir, '__temp__.wasm.br');
-                wsServer.sendUnitySplitStatus({
-                    status: 'start_download_prepared_wasm',
-                    url: downloadUrl,
-                });
-                await download(downloadUrl, tempWasmPath);
-                /**
-                 * 下载完成后需要进行 br 并替换 codePath 对应的文件后再返回成功
-                 */
-                fs$1.copyFileSync(tempWasmPath, willReplaceWasmPath);
-                wsServer.sendUnitySplitStatus({
-                    status: 'download_prepared_wasm_done',
-                    url: downloadUrl,
-                });
-            }
-            else {
-                const tempWasmPath = path.join(cacheDir, '__temp__.wasm');
-                wsServer.sendUnitySplitStatus({
-                    status: 'start_download_prepared_wasm',
-                    url: downloadUrl,
-                });
-                await download(downloadUrl, tempWasmPath);
-                wsServer.sendUnitySplitStatus({
-                    status: 'download_prepared_wasm_done',
-                    url: downloadUrl,
-                });
-                /**
-                 * 下载完成后需要进行 br 并替换 codePath 对应的文件后再返回成功
-                 */
-                wsServer.sendUnitySplitStatus({
-                    status: 'start_compress_prepared_wasm',
-                });
-                await compressWasmFile(tempWasmPath, willReplaceWasmPath);
-                wsServer.sendUnitySplitStatus({
-                    status: 'compress_prepared_wasm_done',
-                    url: downloadUrl,
-                });
-                wsServer.sendUnitySplitStatus({
-                    status: 'write_compress_prepared_wasm_done',
-                });
-            }
-            wsServer.sendUnitySplitStatus({
-                status: 'start_update_wasm_split_config',
-            });
-            /**
-             * 读取 webgl-wasm-split.js内容，将 enableWasmCollect 设为 true
-             */
-            updateWasmSplitConfig({
-                ENABLEWASMCOLLECT: true,
-            });
-            wsServer.sendUnitySplitStatus({
-                status: 'update_wasm_split_config_done',
-            });
-            return {
-                isSuccess: true,
-                ctx: res?.ctx,
-            };
+        const raw = fs__namespace$1.readFileSync(target, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.preparedWasmMd5 === 'string' &&
+            typeof parsed?.codePath === 'string' &&
+            parsed.preparedWasmMd5.length === 32) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Return the current md5 of the wasm file referenced by `prepared-meta.json`
+ * or null if the file is missing / meta isn't present. Caller compares the
+ * result to `meta.preparedWasmMd5` — mismatch means the project's wasm
+ * has drifted from the prepared output (Unity re-build etc.) and the
+ * project should be walked back through the prepare step before collect
+ * can produce useful data.
+ */
+function computeCurrentProjectWasmMd5(entryDir = process.cwd()) {
+    const meta = readPreparedMeta(entryDir);
+    if (!meta)
+        return null;
+    const absolutePath = path__namespace$1.join(entryDir, meta.codePath);
+    if (!fs__namespace$1.existsSync(absolutePath))
+        return null;
+    const currentMd5 = crypto$1
+        .createHash('md5')
+        .update(fs__namespace$1.readFileSync(absolutePath))
+        .digest('hex');
+    return { meta, currentMd5 };
+}
+
+const state = {
+    pipelineMode: 'local',
+    originalWasmPath: '',
+    preparedWasmPath: '',
+    codePath: '',
+    splitOutputDir: '',
+    splitMeta: null,
+    totalWasmFuncCount: 0,
+    wasmSize: 0,
+    isArchiveMode: true,
+};
+function getLocalState() {
+    return state;
+}
+function setLocalState(partial) {
+    Object.assign(state, partial);
+}
+
+async function startPrepare$1(params) {
+    const tempDir = path$1.join(process.cwd(), TTMG_TEMP_DIR);
+    ensureDirSync(tempDir);
+    const inputPath = path$1.join(process.cwd(), params.wasm_file_path);
+    let rawWasmPath = path$1.join(tempDir, 'original.wasm');
+    if (inputPath.endsWith('.br')) {
+        await decompressWasmFile(inputPath, rawWasmPath);
+    }
+    else {
+        fs$1.copyFileSync(inputPath, rawWasmPath);
+    }
+    const preparedWasmPath = path$1.join(tempDir, 'prepared.wasm');
+    try {
+        const result = ttmgWasmtool.prepare(rawWasmPath, preparedWasmPath);
+        console.log(`[wasmtool] prepare done: ${result.outputSize} bytes, ${result.timeCost}s`);
+        const gameJson = getGameJson();
+        const totalWasmFuncCount = gameJson.wasmFuncCount ?? 0;
+        const wasmSize = fs$1.existsSync(inputPath)
+            ? fs$1.statSync(inputPath).size
+            : 0;
+        setLocalState({
+            originalWasmPath: rawWasmPath,
+            preparedWasmPath,
+            codePath: params.wasm_file_path,
+            totalWasmFuncCount,
+            wasmSize,
+        });
+        keepCacheSync({
+            entryDir: process.cwd(),
+            originalWasmPath: params.wasm_file_path,
+            originalSplitConfigPath: WASM_SPLIT_CONFIG_FILE_NAME,
+        });
+        // Start from cached (placeholder) config so pipeline switching is deterministic
+        restoreSplitConfigFromCache();
+        const willReplaceWasmPath = path$1.join(process.cwd(), params.wasm_file_path);
+        // Diagnostic: prove prepare actually produced a different binary
+        // (size should grow noticeably because every function body is prefixed
+        // with a scwebgl.logCall(funcIndex) call).
+        const rawSize = fs$1.existsSync(rawWasmPath) ? fs$1.statSync(rawWasmPath).size : 0;
+        const preparedSize = fs$1.existsSync(preparedWasmPath)
+            ? fs$1.statSync(preparedWasmPath).size
+            : 0;
+        const rawMd5 = fs$1.existsSync(rawWasmPath)
+            ? crypto$1.createHash('md5').update(fs$1.readFileSync(rawWasmPath)).digest('hex')
+            : '<missing>';
+        const preparedMd5 = fs$1.existsSync(preparedWasmPath)
+            ? crypto$1.createHash('md5').update(fs$1.readFileSync(preparedWasmPath)).digest('hex')
+            : '<missing>';
+        console.log(`[wasmtool] prepare sanity: raw(size=${rawSize} md5=${rawMd5}) -> prepared(size=${preparedSize} md5=${preparedMd5}) delta=${preparedSize - rawSize}`);
+        if (preparedSize <= rawSize || preparedMd5 === rawMd5) {
+            console.warn('[wasmtool] WARNING: prepared wasm is not larger / md5 is unchanged vs raw wasm. Instrumentation likely did not happen.');
+        }
+        console.log('[wasmtool] compressing prepared wasm (quality=9)...');
+        await compressWasmFile(preparedWasmPath, willReplaceWasmPath);
+        console.log('[wasmtool] compressed and written to project');
+        // Diagnostic: confirm the file the client actually fetches was overwritten,
+        // and compare to the cached original brotli so we can prove on-disk replacement.
+        const replacedSize = fs$1.existsSync(willReplaceWasmPath)
+            ? fs$1.statSync(willReplaceWasmPath).size
+            : 0;
+        const replacedMd5 = fs$1.existsSync(willReplaceWasmPath)
+            ? crypto$1.createHash('md5').update(fs$1.readFileSync(willReplaceWasmPath)).digest('hex')
+            : '<missing>';
+        const cachedOriginalBr = path$1.join(process.cwd(), TTMG_TEMP_DIR, 'wasmcode', path$1.basename(params.wasm_file_path));
+        const cachedOriginalSize = fs$1.existsSync(cachedOriginalBr)
+            ? fs$1.statSync(cachedOriginalBr).size
+            : 0;
+        const cachedOriginalMd5 = fs$1.existsSync(cachedOriginalBr)
+            ? crypto$1
+                .createHash('md5')
+                .update(fs$1.readFileSync(cachedOriginalBr))
+                .digest('hex')
+            : '<missing>';
+        console.log(`[wasmtool] on-disk replace check: project=${params.wasm_file_path} size=${replacedSize} md5=${replacedMd5} | cached-original size=${cachedOriginalSize} md5=${cachedOriginalMd5}`);
+        if (replacedMd5 === cachedOriginalMd5) {
+            console.warn('[wasmtool] WARNING: project wasm md5 matches cached-original md5. The file was not actually replaced with the instrumented build.');
         }
         else {
-            return {
-                isSuccess: false,
-                error: {
-                    code: res.data?.code,
-                    message: res.data?.message,
-                },
-                ctx: res?.ctx,
-            };
+            console.log('[wasmtool] OK: project wasm differs from cached-original — instrumented wasm is on disk.');
         }
+        // Local pipeline uses the new wasm-collect/v1/report API + archive sub-wasm.
+        // ORIGINALWASMMD5 must be set now (not only at split time) so the plugin
+        // reports the correct wasm_md5 during the collect phase.
+        updateWasmSplitConfig({
+            ENABLEWASMCOLLECT: true,
+            ENABLEARCHIVEMODE: true,
+            ORIGINALWASMMD5: params.wasm_md5,
+        });
+        console.log('[wasmtool] wasm split config updated (local pipeline: archive=true)');
+        // Disk-persisted anchor for "wasm drift" detection in
+        // `game-wasm-split-config` route. Stores the md5 that prepare just
+        // wrote into the project alongside the project-relative path. The
+        // route reads this back on every Modal open, recomputes the md5 of
+        // the file on disk, and if they differ (Unity re-build, git
+        // checkout, etc.) suppresses `enableWasmCollect=true` in the
+        // response so the IDE goes back through prepare instead of dropping
+        // the user straight into Collect with an un-instrumented wasm on
+        // the device. See `preparedMeta.ts` for full rationale.
+        writePreparedMeta({
+            preparedWasmMd5: replacedMd5,
+            codePath: params.wasm_file_path,
+        });
+        console.log(`[wasmtool] prepared-meta written: md5=${replacedMd5} codePath=${params.wasm_file_path}`);
+        return {
+            data: {
+                code: 0,
+                message: 'success',
+                result: { md5: params.wasm_md5 },
+            },
+            error: null,
+            ctx: { logid: 'local', httpStatusCode: 200 },
+        };
     }
-    catch (error) {
+    catch (err) {
         return {
-            isSuccess: false,
+            data: null,
             error: {
-                code: res.data?.code,
-                message: error.message,
+                code: 500,
+                message: err instanceof Error ? err.message : String(err),
             },
-            ctx: res?.ctx,
+            ctx: { logid: 'local', httpStatusCode: 500 },
         };
     }
 }
 
-async function getCollectedFuncIds({ client_key, wasm_md5, }) {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/get/collectedfuncids`,
+/**
+ * Local pipeline: startPrepareLocal already compressed/replaced the wasm and
+ * updated webgl-wasm-split.js, so this step is a no-op that just emits UI
+ * status events for parity with the remote flow.
+ */
+async function downloadPrepared$1(_data) {
+    const { preparedWasmPath } = getLocalState();
+    if (!preparedWasmPath) {
+        return {
+            isSuccess: false,
+            error: { code: 404, message: 'Prepared wasm not found. Run prepare first.' },
+        };
+    }
+    wsServer.sendUnitySplitStatus({ status: 'update_wasm_split_config_done' });
+    return { isSuccess: true, ctx: { logid: 'local' } };
+}
+
+async function getCollectedFuncIds$1({ client_key, wasm_md5, }) {
+    const res = await request({
+        url: `${WASM_COLLECT_BASE_URL}/progress`,
         method: 'GET',
-        headers: DEV_HEADERS,
         params: {
-            client_key,
+            app_id: client_key,
             wasm_md5,
         },
     });
+    const funcCount = res?.data?.func_count ?? 0;
+    return {
+        data: {
+            code: res?.data?.code ?? 0,
+            message: 'success',
+            result: {
+                collected_func_count: funcCount,
+                data_size: funcCount,
+                real_data_size: funcCount,
+                collect_state: res?.data?.collect_state,
+            },
+        },
+        error: res.error,
+        ctx: res.ctx,
+    };
 }
 
-async function setCollect({ client_key, wasm_md5, }) {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/set_collecting`,
+/**
+ * POST /start — opens a collect session (Portal-authenticated).
+ *
+ * Idempotent on the server: re-opening an already-open session just refreshes
+ * `started_at`; only `reset: true` wipes history.
+ *
+ * Default `reset` is `false` to mirror the server-side default documented in
+ * `wasm_api.md` §5.1 — "页面刷新 / 恢复" must NOT silently destroy data. The
+ * "fresh run" semantic (e.g. user clicks "重新开始分包") is the responsibility
+ * of the caller, which must explicitly pass `reset: true`. See `setCollect`
+ * for the CLI-level wiring of those two paths.
+ *
+ * NOTE on naming: the server route is flat (`/start`, not `/session/start`).
+ * Our local symbol stays `startWasmSession` because it's the "start collect
+ * session" lifecycle primitive from the IDE's perspective.
+ */
+async function startWasmSession({ client_key, wasm_md5, reset, }) {
+    const res = await request({
+        url: `${WASM_COLLECT_BASE_URL}/start`,
         method: 'POST',
         data: {
-            client_key,
+            app_id: client_key,
             wasm_md5,
+            reset: reset ?? false,
         },
-        headers: DEV_HEADERS,
     });
+    return {
+        data: res.data
+            ? {
+                code: res.data.code ?? 0,
+                message: res.data.message || 'success',
+                result: {
+                    collect_state: res.data.collect_state,
+                    started_at: res.data.started_at,
+                },
+            }
+            : null,
+        error: res.error,
+        ctx: res.ctx,
+    };
 }
 
-async function getCollecttingInfo({ client_key, wasm_md5, }) {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/get/funccollect`,
+/**
+ * "开始收集" 的本地 pipeline 实现。语义上等价于老远程流程的
+ * `stark_wasm/v4/post/set_collecting`：**打开 server 端的 collect 窗口**，
+ * 让 plugin 之后的 `/report` 请求能落库。
+ *
+ * 做三件事（顺序敏感）：
+ *   1. `POST /start` 打开 session —— 失败必须立即返回给 IDE，
+ *      否则 UI 会让用户进"正在收集"但实际 plugin 所有上报都会被 fail-close
+ *      丢弃，场面非常悲伤。
+ *   2. 成功后上传符号表（`/symbols`）。这一步故意不 await、错误仅 warn —
+ *      符号表只是给 server 端后续调试用的 debug 信息，丢了也不影响分包主链路。
+ *   3. 返回 `{code: 0}`。
+ *
+ * 两种调用语义（与 `wasm_api.md` §5.1 对齐）：
+ *   - 默认（`resume` 缺省 / false）—— 用户点"开始收集 / 重新开始分包"，
+ *     发 `reset: true`，服务端清空历史。这是历史行为，对应 IDE 上的
+ *     "willCollect → startCollect" 主入口。
+ *   - `resume: true` —— 页面刷新 / 恢复继续，发 `reset: false`，幂等
+ *     打开 session、保留已有 func_ids。需要这条路径的 caller（如 IDE
+ *     重新挂载组件检测到 server `collect_state: "open"` 想接续）必须
+ *     显式传，避免误清。
+ *
+ * Session 生命周期对前端透明——IDE 只知道"开始收集 / 完成收集"两个动作，
+ * `/start` 和 `/finish` 都被封在本地 dispatcher 内。这样远程 pipeline（没有
+ * session 概念）和本地 pipeline（有 session）在 IDE 层看起来是对称的。
+ */
+async function setCollect$1({ client_key, wasm_md5, resume, }) {
+    const startRes = await startWasmSession({
+        client_key,
+        wasm_md5,
+        reset: !resume,
+    });
+    if (startRes.error || !startRes.data || startRes.data.code !== 0) {
+        // /start is invoked internally by setCollect now; IDE only sees this
+        // bubbled up as a generic "开始收集失败" toast, so dump a structured
+        // one-liner here with logid — the single most useful field when
+        // asking backend to look up what happened on their side.
+        const code = startRes.error?.code ?? startRes.data?.code ?? -1;
+        const message = startRes.error?.message ||
+            startRes.data?.message ||
+            'Open collect session failed';
+        const logid = startRes.ctx?.logid || 'n/a';
+        console.error(`[wasm-collect] /start failed: code=${code} message=${message} logid=${logid}`);
+        return {
+            data: startRes.data ?? null,
+            error: startRes.error ?? { code, message },
+            ctx: startRes.ctx,
+        };
+    }
+    let symbolPath = path$1.join(process.cwd(), WASM_SYMBOL_FILE_NAME);
+    if (!fs$1.existsSync(symbolPath)) {
+        symbolPath = path$1.join(process.cwd(), TTMG_TEMP_DIR, WASM_SYMBOL_FILE_NAME);
+    }
+    if (fs$1.existsSync(symbolPath)) {
+        const symbols = fs$1.readFileSync(symbolPath, 'utf-8');
+        request({
+            url: `${WASM_COLLECT_BASE_URL}/symbols`,
+            method: 'POST',
+            data: {
+                app_id: client_key,
+                wasm_md5,
+                symbols,
+            },
+        }).catch(err => {
+            console.warn('[wasmtool] Failed to upload symbols:', err);
+        });
+    }
+    return {
+        data: { code: 0, message: 'success', result: {} },
+        error: null,
+        ctx: { logid: 'local', httpStatusCode: 200 },
+    };
+}
+
+async function getCollecttingInfo$1({ client_key, wasm_md5, }) {
+    const res = await request({
+        url: `${WASM_COLLECT_BASE_URL}/progress`,
         method: 'GET',
-        headers: DEV_HEADERS,
         params: {
-            client_key,
+            app_id: client_key,
             wasm_md5,
         },
     });
+    const { totalWasmFuncCount } = getLocalState();
+    // Fall back to game.json.wasmFuncCount so the total survives CLI restarts.
+    const gameJsonFuncCount = Number(getGameJson()?.wasmFuncCount) || 0;
+    return {
+        data: {
+            code: res?.data?.code ?? 0,
+            message: 'success',
+            result: {
+                app_id: client_key,
+                wasm_md5,
+                collected_func_count: res?.data?.func_count ?? 0,
+                total_wasm_func_count: gameJsonFuncCount || totalWasmFuncCount || 0,
+                collect_state: res?.data?.collect_state,
+            },
+        },
+        error: res.error,
+        ctx: res.ctx,
+    };
 }
 
-// /api/stark_wasm/v4/post/split
-async function startSplit({ client_key, wasm_md5, }) {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/split`,
+/**
+ * POST /finish — closes a collect session and returns the final `func_count`
+ * so the IDE can surface "本次共收集 N 个函数" in the success dialog.
+ * Idempotent on the server.
+ *
+ * NOTE on naming: the server route is flat (`/finish`, not `/session/finish`).
+ * The local symbol keeps `finishWasmSession` for symmetry with `startWasmSession`.
+ */
+async function finishWasmSession({ client_key, wasm_md5, }) {
+    const res = await request({
+        url: `${WASM_COLLECT_BASE_URL}/finish`,
         method: 'POST',
-        headers: {
-            ...DEV_HEADERS,
-        },
         data: {
-            client_key,
+            app_id: client_key,
             wasm_md5,
         },
     });
+    return {
+        data: res.data
+            ? {
+                code: res.data.code ?? 0,
+                message: res.data.message || 'success',
+                result: {
+                    collect_state: res.data.collect_state,
+                    func_count: res.data.func_count ?? 0,
+                    finished_at: res.data.finished_at,
+                },
+            }
+            : null,
+        error: res.error,
+        ctx: res.ctx,
+    };
 }
 
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
-
-class Node {
-	value;
-	next;
-
-	constructor(value) {
-		this.value = value;
-	}
-}
-
-class Queue {
+async function startSplit$1({ client_key, wasm_md5, }) {
+    const tempDir = path$1.join(process.cwd(), TTMG_TEMP_DIR);
+    const splitOutputDir = path$1.join(tempDir, 'split-output');
+    if (fs$1.existsSync(splitOutputDir)) {
+        fs$1.rmSync(splitOutputDir, { recursive: true, force: true });
+    }
+    ensureDirSync(splitOutputDir);
+    const { originalWasmPath, isArchiveMode: archive } = getLocalState();
+    const rawWasmPath = originalWasmPath || path$1.join(tempDir, 'original.wasm');
+    if (!fs$1.existsSync(rawWasmPath)) {
+        return {
+            data: null,
+            error: {
+                code: 404,
+                message: 'Original wasm not found. Run prepare first.',
+            },
+            ctx: { logid: 'local', httpStatusCode: 404 },
+        };
+    }
+    const exportRes = await request({
+        url: `${WASM_COLLECT_BASE_URL}/export`,
+        method: 'GET',
+        params: {
+            app_id: client_key,
+            wasm_md5,
+            strategy: 'union',
+        },
+    });
+    const funcIds = exportRes?.data?.func_ids;
+    const bootFuncIds = exportRes?.data?.boot_func_ids ?? [];
+    if (!funcIds?.length) {
+        return {
+            data: null,
+            error: {
+                code: 400,
+                message: 'No collected func IDs found.',
+            },
+            ctx: { logid: 'local', httpStatusCode: 400 },
+        };
+    }
+    console.log(`[wasmtool] splitting with ${funcIds.length} func IDs` +
+        (bootFuncIds.length > 0
+            ? `, ${bootFuncIds.length} boot-phase func IDs (→ alwaysInclude)`
+            : ', no boot-phase info (legacy server, falling back to callClosure only)') +
+        `, archive=${archive}`);
+    try {
+        const result = ttmgWasmtool.split({
+            input: rawWasmPath,
+            funcIds,
+            // Boot-phase func ids → `alwaysInclude`. They are a subset of
+            // `funcIds` so this doesn't grow `collect_count`, but it DOES seed
+            // the direct-call closure BFS with the exact set needed for first
+            // frame, and the split tool's `alwaysIncludeAdded` counter is the
+            // observability signal when zero (= server didn't return boot info).
+            alwaysInclude: bootFuncIds.length > 0 ? bootFuncIds : undefined,
+            // Always-on direct-call closure over (collect ∪ alwaysInclude ∪
+            // start_func). Folds in func ids that collect missed (untaken
+            // branches, race conditions during collect) so first-screen code
+            // paths don't trap on archive trampolines. See the split tool's
+            // `closure_added` counter for the per-build size impact.
+            callClosure: true,
+            // Always-on indirect-call type-closure scoped to the boot subset.
+            // Catches IL2CPP virtual / interface / delegate dispatch which is
+            // the dominant source of remaining `firstFrame=BEFORE` archive
+            // trampoline hits after the runtime collect + direct closure
+            // passes (see `indirectClosureAdded` for the per-build size
+            // impact). Defaults to `true` in the wasmtool but we set it
+            // explicitly so a future tool default change can't silently turn
+            // it off in our pipeline.
+            callIndirectClosure: true,
+            outputDir: splitOutputDir,
+            archive,
+            compress: true,
+            quality: 9,
+        });
+        if (result.code !== 0) {
+            return {
+                data: null,
+                error: { code: result.code, message: result.errMsg },
+                ctx: { logid: 'local', httpStatusCode: 500 },
+            };
+        }
+        const mainBrPath = result.mainWasmPath + '.br';
+        const actualMainPath = fs$1.existsSync(mainBrPath)
+            ? mainBrPath
+            : result.mainWasmPath;
+        const mainWasmMd5 = computeFileMd5Sync(actualMainPath);
+        const subBrPath = result.subWasmPath ? result.subWasmPath + '.br' : '';
+        const actualSubPath = subBrPath && fs$1.existsSync(subBrPath)
+            ? subBrPath
+            : result.subWasmPath;
+        const subWasmMd5 = actualSubPath
+            ? computeFileMd5Sync(actualSubPath)
+            : '';
+        let archiveMd5 = '';
+        if (archive && result.archivePath) {
+            const archiveBrPath = result.archivePath + '.br';
+            const actualArchivePath = fs$1.existsSync(archiveBrPath)
+                ? archiveBrPath
+                : result.archivePath;
+            console.log(`[wasmtool] archivePath=${result.archivePath}, brExists=${fs$1.existsSync(archiveBrPath)}, actualExists=${fs$1.existsSync(actualArchivePath)}`);
+            if (fs$1.existsSync(actualArchivePath)) {
+                archiveMd5 = computeFileMd5Sync(actualArchivePath);
+                console.log(`[wasmtool] archive_md5=${archiveMd5}`);
+            }
+        }
+        else {
+            console.log(`[wasmtool] skip archive md5: archive=${archive}, archivePath=${result.archivePath}`);
+        }
+        const globalVarList = result.globalVarList
+            .split(';')
+            .filter(Boolean)
+            .map((entry) => {
+            const [name, type, mutable] = entry.trim().split(',');
+            return { name, type, mutable: mutable === '1' };
+        });
+        const splitMeta = {
+            original_wasm_md5: wasm_md5,
+            main_wasm_md5: mainWasmMd5,
+            main_wasm_h5_md5: mainWasmMd5,
+            sub_wasm_md5: subWasmMd5,
+            archive_md5: archiveMd5,
+            table_size: result.tableSize,
+            global_var_list: globalVarList,
+            version: Date.now(),
+            total_wasm_count: result.totalWasmCount,
+            main_wasm_count: result.mainWasmCount,
+            time_cost: result.timeCost,
+            archive,
+            local_main_wasm_path: result.mainWasmPath,
+            local_sub_wasm_path: result.subWasmPath,
+            local_func_meta_path: result.funcMetaPath,
+            local_archive_path: result.archivePath,
+            // Composition breakdown of main_funcs — the single most useful
+            // piece of information when triaging "why is my main package X MB"
+            // (or, conversely, "why are first-screen sub-package batches still
+            // loading"). collect = runtime-observed, always_include =
+            // boot_func_ids, closure = BFS direct callees, indirect_closure =
+            // type-matching pass scoped to boot funcs (covers IL2CPP virtual
+            // dispatch), export = wasm exports. These sum with imports to
+            // main_wasm_count.
+            collect_func_count: result.collectFuncCount,
+            always_include_added: result.alwaysIncludeAdded,
+            closure_added: result.closureAdded,
+            indirect_closure_added: result.indirectClosureAdded,
+            indirect_closure_types: result.indirectClosureTypes,
+            export_added: result.exportAdded,
+        };
+        setLocalState({ splitOutputDir, splitMeta });
+        console.log(`[wasmtool] split done: total=${result.totalWasmCount}, main=${result.mainWasmCount} ` +
+            `(collect=${result.collectFuncCount}, +alwaysInclude=${result.alwaysIncludeAdded}, ` +
+            `+closure=${result.closureAdded}, +indirectClosure=${result.indirectClosureAdded}` +
+            `[types=${result.indirectClosureTypes}], +exports=${result.exportAdded}), ` +
+            `time=${result.timeCost}s`);
+        // Split landed — close the collect session so the plugin stops reporting.
+        // Awaited (not fire-and-forget) so IDE can rely on "wasm-split returned
+        // success" meaning "session definitively closed". If /finish itself
+        // fails (e.g. portal cookie expired mid-run) we still return split
+        // success to the IDE — the plugin already has the MD5-bound session
+        // state from the earlier /report responses and will time out on TTL
+        // anyway; failing split for a finalizer hiccup would be worse UX.
+        let funcCount;
+        try {
+            const finishRes = await finishWasmSession({ client_key, wasm_md5 });
+            if (finishRes.error || !finishRes.data || finishRes.data.code !== 0) {
+                // Soft failure: split already succeeded from the user's POV, but
+                // this is the main diagnostic breadcrumb if someone later reports
+                // "plugin kept uploading after 分包完成". Always include logid so
+                // backend can cross-reference without having to know our build.
+                const code = finishRes.error?.code ?? finishRes.data?.code ?? -1;
+                const message = finishRes.error?.message ||
+                    finishRes.data?.message ||
+                    'finish session non-success';
+                const logid = finishRes.ctx?.logid || 'n/a';
+                console.error(`[wasm-split] /finish failed (split still succeeded): code=${code} message=${message} logid=${logid}`);
+            }
+            else {
+                funcCount = finishRes.data.result?.func_count;
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[wasm-split] /finish threw (split still succeeded): ${msg}`);
+        }
+        return {
+            data: { code: 0, message: 'success', func_count: funcCount },
+            error: null,
+            ctx: { logid: 'local', httpStatusCode: 200 },
+        };
+    }
+    catch (err) {
+        return {
+            data: null,
+            error: {
+                code: 500,
+                message: err instanceof Error ? err.message : String(err),
+            },
+            ctx: { logid: 'local', httpStatusCode: 500 },
+        };
+    }
+}
+
+const ARCHIVE_SUBPACKAGE_CONFIG = [
+    { name: 'wasmcode', root: 'wasmcode/' },
+    { name: 'wasmcode1', root: 'wasmcode1/' },
+    { name: 'wasmcode-archive', root: 'wasmcode-archive/' },
+];
+function updateSubpackageConfigSync(archive = false) {
+    const gameJsonPath = path__namespace.join(process.cwd(), SUBPACKAGE_CONFIG_FILE_NAME);
+    const raw = fs__namespace.readFileSync(gameJsonPath, 'utf-8');
+    const gameJson = JSON.parse(raw);
+    delete gameJson.wasmFuncCount;
+    const fieldName = SUBPACKAGE_FIELD_NAMES.find(k => k in gameJson) ??
+        SUBPACKAGE_FIELD_NAMES[0];
+    if (!gameJson[fieldName])
+        gameJson[fieldName] = [];
+    const subpackages = gameJson[fieldName];
+    const filtered = subpackages.filter(s => s.name !== WASM_SPLIT_SUBPACKAGE_CONFIG.origin.name);
+    if (archive) {
+        ARCHIVE_SUBPACKAGE_CONFIG.forEach(pkg => filtered.push(pkg));
+    }
+    else {
+        filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain);
+        filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub);
+        filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain);
+        filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub);
+    }
+    const map = new Map(filtered.map(s => [s.name, s]));
+    gameJson[fieldName] = Array.from(map.values());
+    fs__namespace.writeFileSync(gameJsonPath, JSON.stringify(gameJson, null, JSON_INDENT) + JSON_EOL);
+}
+
+async function downloadSplited$1(_context) {
+    const cwd = process.cwd();
+    const { splitMeta } = getLocalState();
+    if (!splitMeta) {
+        return {
+            data: { isSuccess: false },
+            error: { message: 'No local split result found. Run split first.' },
+            ctx: _context,
+        };
+    }
+    const splitTempDir = path.join(cwd, WASM_SPLIT_CACHE_DIR, DIR_SPLIT);
+    ensureDirSync(splitTempDir);
+    const isArchive = splitMeta.archive;
+    const mainAndroidDir = path.join(splitTempDir, isArchive ? 'wasmcode' : WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain.root);
+    const subAndroidDir = path.join(splitTempDir, isArchive ? 'wasmcode1' : WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub.root);
+    const mainIosDir = isArchive
+        ? mainAndroidDir
+        : path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain.root);
+    const subIosDir = path.join(splitTempDir, isArchive ? 'wasmcode-archive' : WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub.root);
+    const dirs = [...new Set([mainAndroidDir, subAndroidDir, mainIosDir, subIosDir])];
+    dirs.forEach(ensureDirSync);
+    try {
+        console.log('[wasmtool] organizing split output...');
+        const mainWasmMd5 = splitMeta.main_wasm_md5;
+        const subWasmMd5 = splitMeta.sub_wasm_md5;
+        const mainWasmH5Md5 = splitMeta.main_wasm_h5_md5;
+        const localMainPath = splitMeta.local_main_wasm_path;
+        const mainBrPath = localMainPath + BR_SUFFIX;
+        const actualMainPath = fs.existsSync(mainBrPath) ? mainBrPath : localMainPath;
+        if (actualMainPath && fs.existsSync(actualMainPath)) {
+            const isBr = actualMainPath.endsWith(BR_SUFFIX);
+            const ext = isBr
+                ? `${WASM_FILENAME_SUFFIX}${BR_SUFFIX}`
+                : WASM_FILENAME_SUFFIX;
+            const mainAndroidDest = path.join(mainAndroidDir, `${mainWasmMd5}${ext}`);
+            fs.copyFileSync(actualMainPath, mainAndroidDest);
+            wsServer.sendUnitySplitStatus({
+                status: 'download_android_main_wasm_done',
+            });
+            if (mainIosDir !== mainAndroidDir) {
+                const mainIosDest = path.join(mainIosDir, `${mainWasmH5Md5}${ext}`);
+                fs.copyFileSync(actualMainPath, mainIosDest);
+            }
+            wsServer.sendUnitySplitStatus({
+                status: 'download_ios_main_wasm_done',
+            });
+        }
+        const localSubPath = splitMeta.local_sub_wasm_path;
+        const subBrPath = localSubPath + BR_SUFFIX;
+        const actualSubPath = fs.existsSync(subBrPath) ? subBrPath : localSubPath;
+        if (actualSubPath && fs.existsSync(actualSubPath)) {
+            const isBr = actualSubPath.endsWith(BR_SUFFIX);
+            const ext = isBr
+                ? `${WASM_FILENAME_SUFFIX}${BR_SUFFIX}`
+                : WASM_FILENAME_SUFFIX;
+            const subAndroidDest = path.join(subAndroidDir, `${subWasmMd5}${ext}`);
+            fs.copyFileSync(actualSubPath, subAndroidDest);
+            wsServer.sendUnitySplitStatus({
+                status: 'download_android_sub_wasm_code_done',
+            });
+        }
+        const localArchivePath = splitMeta.local_archive_path;
+        if (isArchive && localArchivePath) {
+            const archiveBrPath = localArchivePath + BR_SUFFIX;
+            const actualArchivePath = fs.existsSync(archiveBrPath) ? archiveBrPath : localArchivePath;
+            console.log(`[wasmtool] archive copy: archive_md5=${splitMeta.archive_md5}, localPath=${localArchivePath}, brExists=${fs.existsSync(archiveBrPath)}, actual=${actualArchivePath}`);
+            if (fs.existsSync(actualArchivePath)) {
+                const archiveMd5 = splitMeta.archive_md5 || '';
+                const archiveBaseName = path.basename(actualArchivePath);
+                const destName = archiveMd5 ? `${archiveMd5}.${archiveBaseName}` : archiveBaseName;
+                const archiveDest = path.join(subIosDir, destName);
+                console.log(`[wasmtool] archive dest: ${archiveDest}`);
+                fs.copyFileSync(actualArchivePath, archiveDest);
+            }
+        }
+        dirs.forEach((dir) => {
+            fs.writeFileSync(path.join(dir, 'game.js'), '', { encoding: 'utf-8' });
+        });
+        console.log('[wasmtool] copy split output to root...');
+        wsServer.sendUnitySplitStatus({ status: 'start_write_splited_wasm_br' });
+        for (const file of fs.readdirSync(splitTempDir)) {
+            const srcPath = path.join(splitTempDir, file);
+            const destPath = path.join(cwd, file);
+            if (fs.existsSync(destPath)) {
+                await promises.rm(destPath, { recursive: true, force: true });
+            }
+            await promises.cp(srcPath, destPath, { recursive: true, force: true });
+        }
+        wsServer.sendUnitySplitStatus({ status: 'write_splited_wasm_done' });
+        console.log('[wasmtool] updating subpackage config...');
+        updateSubpackageConfigSync(isArchive);
+        console.log('[wasmtool] updating wasm split config...');
+        wsServer.sendUnitySplitStatus({ status: 'start_update_wasm_split_config' });
+        updateWasmSplitConfig({
+            ENABLEWASMCOLLECT: true,
+            ORIGINALWASMMD5: `${splitMeta.original_wasm_md5}`,
+            WASMTABLESIZE: splitMeta.table_size,
+            GLOBALVARLIST: JSON.stringify(splitMeta.global_var_list ?? []),
+            SUBJSURL: '',
+            IOS_CODE_FILE_MD5: `${splitMeta.main_wasm_h5_md5}`,
+            ANDROID_CODE_FILE_MD5: `${splitMeta.main_wasm_md5}`,
+            ANDROID_SUB_CODE_FILE_MD5: `${splitMeta.sub_wasm_md5}`,
+            ARCHIVE_CODE_FILE_MD5: `${splitMeta.archive_md5 || ''}`,
+            WASMSPLITVERSION: `${splitMeta.version}`,
+            USINGWASMH5: Boolean(splitMeta.main_wasm_h5_md5),
+            ENABLEWASMSPLIT: true,
+            ENABLEARCHIVEMODE: isArchive,
+        });
+        wsServer.sendUnitySplitStatus({ status: 'update_wasm_split_config_done' });
+        return {
+            data: { isSuccess: true },
+            ctx: splitMeta,
+        };
+    }
+    catch (err) {
+        wsServer.sendUnitySplitStatus({
+            status: 'wasm_split_failed',
+            errorMsg: err instanceof Error ? err.message : String(err),
+        });
+        return {
+            data: { isSuccess: false },
+            error: { message: err instanceof Error ? err.message : String(err) },
+            ctx: splitMeta,
+        };
+    }
+    finally {
+        await promises.rm(splitTempDir, { recursive: true, force: true });
+        if (!isArchive) {
+            await promises.rm(path.join(cwd, WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root), {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+}
+
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+class Queue {
 	#head;
 	#tail;
 	#size;
@@ -9419,70 +10148,28 @@ function pLimit(concurrency) {
 	return generator;
 }
 
-function updateSubpackageConfigSync() {
-    const gameJsonPath = path__namespace.join(process.cwd(), SUBPACKAGE_CONFIG_FILE_NAME);
-    const raw = fs__namespace.readFileSync(gameJsonPath, 'utf-8');
-    const gameJson = JSON.parse(raw);
-    const fieldName = SUBPACKAGE_FIELD_NAMES.find(k => k in gameJson) ??
-        SUBPACKAGE_FIELD_NAMES[0];
-    if (!gameJson[fieldName])
-        gameJson[fieldName] = [];
-    const subpackages = gameJson[fieldName];
-    // 删除老的 'wasmcode'
-    const filtered = subpackages.filter(s => s.name !== WASM_SPLIT_SUBPACKAGE_CONFIG.origin.name);
-    /**
-     * 基于 SUBPACKAGE_CONFIG_FILE_NAME 更新 subpackages
-     */
-    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain);
-    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.androidSub);
-    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain);
-    filtered.push(WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub);
-    // 合并去重：存在则更新 root，不存在则新增
-    const map = new Map(filtered.map(s => [s.name, s]));
-    gameJson[fieldName] = Array.from(map.values());
-    fs__namespace.writeFileSync(gameJsonPath, JSON.stringify(gameJson, null, JSON_INDENT) + JSON_EOL);
-}
-
-async function downloadAndCompress(opts) {
-    const { startDownloadStatus, downloadDoneStatus, startCompressStatus, compressDoneStatus, url, out, enableCompress = false, } = opts;
+async function downloadOne(opts) {
+    const { startStatus, doneStatus, url, out } = opts;
     if (!url)
         return;
     const willDownloadedFileIsBr = url.includes(BR_SUFFIX);
-    const wasmBrOutName = willDownloadedFileIsBr ? out + BR_SUFFIX : out;
-    // 下载
-    wsServer.sendUnitySplitStatus({ status: startDownloadStatus });
-    console.log(`download url: ${url}`);
+    const finalOut = willDownloadedFileIsBr && !out.endsWith(BR_SUFFIX) ? out + BR_SUFFIX : out;
+    wsServer.sendUnitySplitStatus({ status: startStatus });
+    console.log(`[remote-split-download] fetching -> ${finalOut}`);
     const t0 = Date.now();
-    await withRetry(() => download(url, wasmBrOutName), DOWNLOAD_RETRY);
-    try {
-        const st = await promises.stat(wasmBrOutName);
-        if (!st.size)
-            throw new Error(`Empty download: ${wasmBrOutName}`);
-        wsServer.sendUnitySplitStatus({ status: downloadDoneStatus, url });
-        console.log(`download done: ${path.basename(wasmBrOutName)} size=${st.size}B time=${Date.now() - t0}ms`);
-    }
-    catch (e) {
-        await promises.rm(wasmBrOutName);
-        throw e;
-    }
-    if (enableCompress) {
-        console.log(`compress start: ${path.basename(out)}${BR_SUFFIX}`);
-        // 压缩
-        wsServer.sendUnitySplitStatus({ status: startCompressStatus });
-        const t1 = Date.now();
-        await compressWasmFile(out, wasmBrOutName);
-        wsServer.sendUnitySplitStatus({ status: compressDoneStatus });
-        console.log(`compress done: ${path.basename(wasmBrOutName)} time=${Date.now() - t1}ms`);
-    }
-    /**
-     * 在当前文件所在目录下写入一个空的 game.js
-     */
-    fs__namespace.writeFileSync(path.join(path.dirname(out), 'game.js'), '', {
-        encoding: 'utf-8',
-    });
+    await withRetry(() => download(url, finalOut), DOWNLOAD_RETRY);
+    const st = await promises.stat(finalOut);
+    if (!st.size) {
+        await promises.rm(finalOut, { force: true });
+        throw new Error(`Empty download: ${finalOut}`);
+    }
+    console.log(`[remote-split-download] done: ${path.basename(finalOut)} size=${st.size}B time=${Date.now() - t0}ms`);
+    wsServer.sendUnitySplitStatus({ status: doneStatus, url });
+    // Legacy behaviour: write an empty game.js next to each downloaded artifact
+    // so the subpackage loader doesn't complain about missing js entries.
+    fs.writeFileSync(path.join(path.dirname(out), 'game.js'), '', 'utf-8');
 }
-
-async function downloadSplited(context) {
+async function downloadSplitedRemote(context) {
     const cwd = process.cwd();
     const splitTempDir = path.join(cwd, WASM_SPLIT_CACHE_DIR, DIR_SPLIT);
     ensureDirSync(splitTempDir);
@@ -9491,144 +10178,124 @@ async function downloadSplited(context) {
     const mainIosDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.iosMain.root);
     const subIosDir = path.join(splitTempDir, WASM_SPLIT_SUBPACKAGE_CONFIG.iosSub.root);
     [mainAndroidDir, subAndroidDir, mainIosDir, subIosDir].forEach(ensureDirSync);
-    const mainAndroidWasmCodeTempPath = path.join(mainAndroidDir, `${context.main_wasm_md5}${WASM_FILENAME_SUFFIX}`);
-    const subAndroidWasmCodeTempPath = path.join(subAndroidDir, `${context.sub_wasm_md5}${WASM_FILENAME_SUFFIX}`);
-    const mainIosWasmCodeTempPath = path.join(mainIosDir, `${context.main_wasm_h5_md5}${WASM_FILENAME_SUFFIX}`);
+    const mainAndroidOut = path.join(mainAndroidDir, `${context.main_wasm_md5}${WASM_FILENAME_SUFFIX}`);
+    const subAndroidOut = path.join(subAndroidDir, `${context.sub_wasm_md5}${WASM_FILENAME_SUFFIX}`);
+    const mainIosOut = path.join(mainIosDir, `${context.main_wasm_h5_md5}${WASM_FILENAME_SUFFIX}`);
     const limit = pLimit(CONCURRENCY_LIMIT);
     try {
-        console.log('downloadWasmSplit', context);
-        // 原有状态文案，按你之前的写法
-        wsServer.sendUnitySplitStatus({
-            status: 'start_download_android_main_wasm',
-        });
-        wsServer.sendUnitySplitStatus({
-            status: 'start_download_android_sub_wasm_code',
+        console.log('[remote-split-download] start', {
+            original_wasm_md5: context.original_wasm_md5,
+            main_wasm_md5: context.main_wasm_md5,
+            sub_wasm_md5: context.sub_wasm_md5,
+            main_wasm_h5_md5: context.main_wasm_h5_md5,
         });
-        wsServer.sendUnitySplitStatus({ status: 'start_download_ios_main_wasm' });
-        /**
-         * 需要做个保护，只有 有 URL 时才下载
-         */
-        // 并发下载 + 压缩（带重试）
         await Promise.all([
-            limit(() => downloadAndCompress({
-                startDownloadStatus: 'start_download_android_main_wasm',
-                downloadDoneStatus: 'download_android_main_wasm_done',
-                startCompressStatus: 'start_compress_android_main_wasm',
-                compressDoneStatus: 'compress_android_main_wasm_done',
+            limit(() => downloadOne({
+                startStatus: 'start_download_android_main_wasm',
+                doneStatus: 'download_android_main_wasm_done',
                 url: context.main_wasm_download_url,
-                out: mainAndroidWasmCodeTempPath,
+                out: mainAndroidOut,
             })),
-            limit(() => downloadAndCompress({
-                startDownloadStatus: 'start_download_android_sub_wasm_code',
-                downloadDoneStatus: 'download_android_sub_wasm_code_done',
-                startCompressStatus: 'start_compress_android_sub_wasm_code',
-                compressDoneStatus: 'compress_android_sub_wasm_code_done',
+            limit(() => downloadOne({
+                startStatus: 'start_download_android_sub_wasm_code',
+                doneStatus: 'download_android_sub_wasm_code_done',
                 url: context.sub_wasm_download_url,
-                out: subAndroidWasmCodeTempPath,
+                out: subAndroidOut,
             })),
-            limit(() => downloadAndCompress({
-                startDownloadStatus: 'start_download_ios_main_wasm',
-                downloadDoneStatus: 'download_ios_main_wasm_done',
-                startCompressStatus: 'start_compress_ios_main_wasm',
-                compressDoneStatus: 'compress_ios_main_wasm_done',
+            limit(() => downloadOne({
+                startStatus: 'start_download_ios_main_wasm',
+                doneStatus: 'download_ios_main_wasm_done',
                 url: context.main_wasm_h5_download_url,
-                out: mainIosWasmCodeTempPath,
+                out: mainIosOut,
             })),
-            // 下载 ios sub js range  json
-            limit(() => downloadAndCompress({
-                startDownloadStatus: 'start_download_ios_range_json',
-                downloadDoneStatus: 'download_ios_range_json_done',
+            limit(() => downloadOne({
+                startStatus: 'start_download_ios_range_json',
+                doneStatus: 'download_ios_range_json_done',
                 url: context.sub_js_range_download_url,
                 out: path.join(subIosDir, 'func_bytes_range.json'),
             })),
-            // 下载 ios sub js data br
-            limit(() => downloadAndCompress({
-                startDownloadStatus: 'start_download_ios_js_data_br',
-                downloadDoneStatus: 'download_ios_js_data_br_done',
+            limit(() => downloadOne({
+                startStatus: 'start_download_ios_js_data_br',
+                doneStatus: 'download_ios_js_data_br_done',
                 url: context.sub_js_data_download_url,
                 out: path.join(subIosDir, 'subjs.data'),
             })),
         ]);
-        // 复制 split/* 到项目根目录（递归、覆盖）——避免 EISDIR
-        console.log('copy splitTempDir to root start');
+        console.log('[remote-split-download] copying split output to project root...');
         wsServer.sendUnitySplitStatus({ status: 'start_write_splited_wasm_br' });
         for (const file of fs.readdirSync(splitTempDir)) {
             const srcPath = path.join(splitTempDir, file);
             const destPath = path.join(cwd, file);
-            // 如果目标路径有文件或目录，先删除
             if (fs.existsSync(destPath)) {
                 await promises.rm(destPath, { recursive: true, force: true });
             }
             await promises.cp(srcPath, destPath, { recursive: true, force: true });
         }
         wsServer.sendUnitySplitStatus({ status: 'write_splited_wasm_done' });
-        console.log('copy splitTempDir to root end');
-        // 更新分包配置（幂等）
-        console.log('updateSubpackageConfigSync start');
-        updateSubpackageConfigSync();
-        console.log('updateSubpackageConfigSync end');
-        // 更新 wasm split 配置（保持原始状态文案）
-        console.log('updateWasmSplitConfig start');
+        console.log('[remote-split-download] updating subpackage config...');
+        updateSubpackageConfigSync(false);
+        console.log('[remote-split-download] updating webgl-wasm-split.js...');
         wsServer.sendUnitySplitStatus({ status: 'start_update_wasm_split_config' });
         updateWasmSplitConfig({
             ENABLEWASMCOLLECT: true,
-            ORIGINALWASMMD5: `${context.original_wasm_md5}`,
+            ENABLEWASMSPLIT: true,
+            ENABLEARCHIVEMODE: false,
+            ORIGINALWASMMD5: `${context.original_wasm_md5 ?? ''}`,
             WASMTABLESIZE: context.table_size,
             GLOBALVARLIST: JSON.stringify(context.global_var_list ?? []),
-            SUBJSURL: `${context.sub_js_download_url}`,
-            IOS_CODE_FILE_MD5: `${context.main_wasm_h5_md5}`,
-            ANDROID_CODE_FILE_MD5: `${context.main_wasm_md5}`,
-            ANDROID_SUB_CODE_FILE_MD5: `${context.sub_wasm_md5}`,
-            WASMSPLITVERSION: `${context.version}`,
+            SUBJSURL: `${context.sub_js_download_url ?? ''}`,
+            IOS_CODE_FILE_MD5: `${context.main_wasm_h5_md5 ?? ''}`,
+            ANDROID_CODE_FILE_MD5: `${context.main_wasm_md5 ?? ''}`,
+            ANDROID_SUB_CODE_FILE_MD5: `${context.sub_wasm_md5 ?? ''}`,
+            WASMSPLITVERSION: `${context.version ?? ''}`,
             USINGWASMH5: Boolean(context.main_wasm_h5_md5),
-            ENABLEWASMSPLIT: true,
-            // IOS_SUB_JS_FILE_CONFIG: JSON.stringify(context.merged_js ?? {}),
         });
         wsServer.sendUnitySplitStatus({ status: 'update_wasm_split_config_done' });
-        console.log('updateWasmSplitConfig end');
-        return {
-            data: {
-                isSuccess: true,
-            },
-            ctx: context,
-        };
+        console.log('[remote-split-download] all done');
+        return { data: { isSuccess: true }, ctx: context };
     }
     catch (err) {
-        wsServer.sendUnitySplitStatus({
-            status: 'wasm_split_failed',
-            errorMsg: err instanceof Error ? err.message : String(err),
-        });
+        const message = err instanceof Error ? err.message : String(err);
+        console.log('[remote-split-download] failed:', message);
+        wsServer.sendUnitySplitStatus({ status: 'wasm_split_failed', errorMsg: message });
         return {
-            data: {
-                isSuccess: false,
-            },
-            error: {
-                message: err instanceof Error ? err.message : String(err),
-            },
+            data: { isSuccess: false },
+            error: { message },
             ctx: context,
         };
     }
     finally {
-        // 清理临时目录与旧 wasmcode 目录
-        console.log('delete splitTempDir start');
         await promises.rm(splitTempDir, { recursive: true, force: true });
-        console.log('delete splitTempDir end');
-        console.log('delete wasmcode start');
+        // Legacy flow: the server-produced `wasmcode/` placeholder at the project
+        // root is no longer needed once we've laid down the 4 platform dirs.
         await promises.rm(path.join(cwd, WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root), {
             recursive: true,
             force: true,
         });
-        console.log('delete wasmcode end');
     }
 }
 
-async function getSplitResult({ client_key, wasm_md5, wasm_path, }) {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/download`,
-        method: 'POST',
-        headers: { ...DEV_HEADERS },
-        data: { client_key, wasm_md5, wasm_path },
-    });
+async function getSplitResult$1(_params) {
+    const { splitMeta } = getLocalState();
+    if (!splitMeta) {
+        return {
+            data: null,
+            error: {
+                code: 404,
+                message: 'No local split result found. Run split first.',
+            },
+            ctx: { logid: 'local', httpStatusCode: 404 },
+        };
+    }
+    return {
+        data: {
+            code: 0,
+            message: 'success',
+            result: splitMeta,
+        },
+        error: null,
+        ctx: { logid: 'local', httpStatusCode: 200 },
+    };
 }
 
 function cancelSplit(params) {
@@ -9668,60 +10335,34 @@ function cancelSplit(params) {
     }
 }
 
-async function resetWasmSplit(data) {
+async function resetWasmSplit$1(data) {
     const res = await request({
-        url: `${BASE_URL}/api/stark_wasm/v4/post/reset`,
+        url: `${WASM_COLLECT_BASE_URL}/reset`,
         method: 'POST',
-        headers: {
-            ...DEV_HEADERS,
-        },
         data: {
-            client_key: data.clientkey,
+            app_id: data.clientkey,
             wasm_md5: data.wasmMd5,
         },
     });
-    /**
-     * 把— __TTMG_TEMP__/wasmcode/ 目录下的所有文件恢复到原本的位置，进行重置
-     */
     const cacheDir = path.join(process.cwd(), WASM_SPLIT_CACHE_DIR);
-    /**
-     * 恢复 br 文件
-     */
     if (fs.existsSync(cacheDir)) {
-        /**
-         * 判断是否有缓存的 br 文件
-         */
-        /**
-         * 判断 cache 文件夹下有没有 .br 文件
-         *
-         */
         const targetWasmBrPath = fs
             .readdirSync(cacheDir)
             .find(item => item.endsWith('.br'));
         if (targetWasmBrPath) {
             const destWasmBrPath = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.origin.root, path.basename(targetWasmBrPath));
-            // 规避没有文件夹的情况
             ensureDirSync(path.dirname(destWasmBrPath));
             fs.copyFileSync(path.join(cacheDir, targetWasmBrPath), destWasmBrPath);
         }
     }
-    /**
-     * 恢复 webgl-wasm-split.js 文件
-     */
     const splitConfigCachePath = path.join(cacheDir, WASM_SPLIT_CONFIG_FILE_NAME);
     if (fs.existsSync(splitConfigCachePath)) {
         fs.copyFileSync(splitConfigCachePath, path.join(process.cwd(), WASM_SPLIT_CONFIG_FILE_NAME));
     }
-    /**
-     * 恢复 game.json 文件
-     */
     const gameJsonCachePath = path.join(cacheDir, 'game.json');
     if (fs.existsSync(gameJsonCachePath)) {
         fs.copyFileSync(gameJsonCachePath, path.join(process.cwd(), 'game.json'));
     }
-    /**
-     * 删除历史分包产物
-     */
     const androidSubpackageDir = path.join(process.cwd(), WASM_SPLIT_SUBPACKAGE_CONFIG.androidMain.root);
     if (fs.existsSync(androidSubpackageDir)) {
         fs.rmSync(androidSubpackageDir, { recursive: true });
@@ -9734,6 +10375,15 @@ async function resetWasmSplit(data) {
     if (fs.existsSync(iosSubpackageDir)) {
         fs.rmSync(iosSubpackageDir, { recursive: true });
     }
+    // Drop the prepared-meta anchor as well — rollback restores the
+    // original wasm into the project, so any md5 we previously recorded
+    // for the prepared build is no longer valid. Leaving it behind would
+    // make the split-config drift guard fire on the very next Modal open
+    // and force the user through a redundant prepare cycle.
+    const preparedMetaPath = path.join(process.cwd(), TTMG_TEMP_DIR, 'prepared-meta.json');
+    if (fs.existsSync(preparedMetaPath)) {
+        fs.rmSync(preparedMetaPath, { force: true });
+    }
     return res;
 }
 
@@ -9769,23 +10419,291 @@ function getSplitConfig() {
     }
 }
 
-const getTaskStatus = (params) => {
-    return request({
-        url: `${BASE_URL}/api/stark_wasm/v4/get/status`,
+var WasmStatus;
+(function (WasmStatus) {
+    WasmStatus[WasmStatus["IdleStatus"] = 0] = "IdleStatus";
+    WasmStatus[WasmStatus["WasmPreparingStatus"] = 1] = "WasmPreparingStatus";
+    WasmStatus[WasmStatus["WasmPreparedStatus"] = 2] = "WasmPreparedStatus";
+    WasmStatus[WasmStatus["WasmSplitStatus"] = 3] = "WasmSplitStatus";
+    WasmStatus[WasmStatus["WasmSplittingStatus"] = 4] = "WasmSplittingStatus";
+    WasmStatus[WasmStatus["WasmSplitDoneStatus"] = 5] = "WasmSplitDoneStatus";
+    WasmStatus[WasmStatus["WasmSplitReadyToPrepareStatus"] = 6] = "WasmSplitReadyToPrepareStatus";
+    WasmStatus[WasmStatus["WasmSplitPreparingStatus"] = 7] = "WasmSplitPreparingStatus";
+    WasmStatus[WasmStatus["WasmSplitPreparedStatus"] = 8] = "WasmSplitPreparedStatus";
+    WasmStatus[WasmStatus["WasmCollectingStatus"] = 9] = "WasmCollectingStatus";
+    WasmStatus[WasmStatus["WasmUploadFailStatus"] = -1] = "WasmUploadFailStatus";
+    WasmStatus[WasmStatus["WasmDownloadFailStatus"] = -2] = "WasmDownloadFailStatus";
+    WasmStatus[WasmStatus["WasmFileNotExistStatus"] = -3] = "WasmFileNotExistStatus";
+    WasmStatus[WasmStatus["WasmSplitFailStatus"] = -4] = "WasmSplitFailStatus";
+    WasmStatus[WasmStatus["WasmSplitUpdateDBFailedStatus"] = -5] = "WasmSplitUpdateDBFailedStatus";
+    WasmStatus[WasmStatus["WasmSplitPrepareFailedStatus"] = -6] = "WasmSplitPrepareFailedStatus";
+})(WasmStatus || (WasmStatus = {}));
+
+const getTaskStatus$1 = async (params) => {
+    const { preparedWasmPath, splitMeta } = getLocalState();
+    let status = WasmStatus.IdleStatus;
+    if (splitMeta) {
+        status = WasmStatus.WasmSplitDoneStatus;
+    }
+    else if (preparedWasmPath) {
+        status = WasmStatus.WasmSplitPreparedStatus;
+    }
+    return {
+        data: {
+            code: 0,
+            message: 'success',
+            result: {
+                status,
+                wasm_md5: params.wasm_md5,
+            },
+        },
+        error: null,
+        ctx: { logid: 'local', httpStatusCode: 200 },
+    };
+};
+
+const getTaskInfo$1 = async (params) => {
+    const res = await request({
+        url: `${WASM_COLLECT_BASE_URL}/progress`,
         method: 'GET',
-        headers: DEV_HEADERS,
-        params,
+        params: {
+            app_id: params.client_key,
+            wasm_md5: params.wasm_md5,
+        },
     });
+    const { totalWasmFuncCount, preparedWasmPath, wasmSize } = getLocalState();
+    // Prefer game.json as the source of truth so wasm_size / total_wasm_func_count
+    // survive CLI restarts. localState values are only populated during the
+    // prepare step of the current session; after a restart they default to 0.
+    // game.json carries wasmCodeSize/wasmFuncCount emitted at build time, so
+    // re-entering the collect step still shows the correct totals.
+    const gameJson = getGameJson();
+    const gameJsonWasmSize = Number(gameJson?.wasmCodeSize) || 0;
+    const gameJsonFuncCount = Number(gameJson?.wasmFuncCount) || 0;
+    return {
+        data: {
+            code: res?.data?.code ?? 0,
+            message: 'success',
+            result: {
+                app_id: params.client_key,
+                wasm_md5: params.wasm_md5,
+                is_prepared: Boolean(preparedWasmPath),
+                collected_func_count: res?.data?.func_count ?? 0,
+                total_wasm_func_count: gameJsonFuncCount || totalWasmFuncCount || 0,
+                wasm_size: gameJsonWasmSize || wasmSize || 0,
+            },
+        },
+        error: res.error,
+        ctx: res.ctx,
+    };
 };
 
-const getTaskInfo = async (params) => {
+async function startPrepareRemote(params) {
+    // Back up the original wasm + split config on the first run so cancel/rollback
+    // works even if the user aborts before the server-side prepare finishes.
+    keepCacheSync({
+        entryDir: process.cwd(),
+        originalWasmPath: params.wasm_file_path,
+        originalSplitConfigPath: WASM_SPLIT_CONFIG_FILE_NAME,
+    });
+    const form = new FormData$1();
+    form.append('desc', params.desc);
+    form.append('wasm_md5', params.wasm_md5);
+    form.append('with_ios', 'true');
+    form.append('wasm_file', fs$1.createReadStream(path$1.join(process.cwd(), params.wasm_file_path)), { filename: path$1.basename(params.wasm_file_path), contentType: 'application/wasm' });
+    let symbolFilePath = path$1.join(process.cwd(), TTMG_TEMP_DIR, WASM_SYMBOL_FILE_NAME);
+    if (!fs$1.existsSync(symbolFilePath)) {
+        symbolFilePath = path$1.join(process.cwd(), WASM_SYMBOL_FILE_NAME);
+    }
+    if (!fs$1.existsSync(symbolFilePath)) {
+        return {
+            error: { code: 400, message: `${WASM_SYMBOL_FILE_NAME} not found`, client_key: params.client_key },
+            data: null,
+            ctx: { logid: '', httpStatusCode: 400 },
+        };
+    }
+    form.append('wasm_symbol_file', fs$1.createReadStream(symbolFilePath), {
+        filename: WASM_SYMBOL_FILE_NAME,
+        contentType: 'application/octet-stream',
+    });
+    const formHeaders = form.getHeaders();
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/prepare`,
+        method: 'POST',
+        headers: { ...DEV_HEADERS, ...formHeaders },
+        params: { client_key: params.client_key, with_ios: true },
+        data: form,
+    });
+}
+async function setCollectRemote({ client_key, wasm_md5 }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/set_collecting`,
+        method: 'POST',
+        data: { client_key, wasm_md5 },
+        headers: DEV_HEADERS,
+    });
+}
+async function getCollectedFuncIdsRemote({ client_key, wasm_md5 }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/collectedfuncids`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params: { client_key, wasm_md5 },
+    });
+}
+async function getCollecttingInfoRemote({ client_key, wasm_md5 }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/funccollect`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params: { client_key, wasm_md5 },
+    });
+}
+async function startSplitRemote({ client_key, wasm_md5 }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/split`,
+        method: 'POST',
+        headers: { ...DEV_HEADERS },
+        data: { client_key, wasm_md5 },
+    });
+}
+async function getTaskInfoRemote(params) {
     return request({
         url: `${BASE_URL}/api/stark_wasm/v4/get/taskinfo`,
         method: 'GET',
         headers: DEV_HEADERS,
         params,
     });
-};
+}
+async function getTaskStatusRemote(params) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/get/status`,
+        method: 'GET',
+        headers: DEV_HEADERS,
+        params,
+    });
+}
+async function resetWasmSplitRemote(data) {
+    const res = await request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/reset`,
+        method: 'POST',
+        headers: { ...DEV_HEADERS },
+        data: { client_key: data.clientkey, wasm_md5: data.wasmMd5 },
+    });
+    // Restore project files (wasm / webgl-wasm-split.js / game.json) so the
+    // next prepare starts from the original placeholders.
+    restoreFromCache();
+    return res;
+}
+async function getSplitResultRemote({ client_key, wasm_md5, wasm_path }) {
+    return request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/download`,
+        method: 'POST',
+        headers: { ...DEV_HEADERS },
+        data: { client_key, wasm_md5, wasm_path },
+    });
+}
+/**
+ * Remote pipeline: after the server finishes preparing (instrumenting) the wasm,
+ * fetch the download URL, download the prepared wasm, replace the project file,
+ * and update webgl-wasm-split.js for the LEGACY reporting flow.
+ */
+async function downloadPreparedRemote(data) {
+    wsServer.sendUnitySplitStatus({ status: 'star_fetch_prepared_wasm_url' });
+    const res = await request({
+        url: `${BASE_URL}/api/stark_wasm/v4/post/download_prepared`,
+        method: 'POST',
+        headers: DEV_HEADERS,
+        data,
+    });
+    wsServer.sendUnitySplitStatus({ status: 'fetch_prepared_wasm_url_done' });
+    try {
+        const downloadUrl = res?.data?.result?.download_url;
+        if (!downloadUrl) {
+            console.log('[remote-download-prepared] no download_url in response');
+            return {
+                isSuccess: false,
+                error: { code: res.data?.code, message: res.data?.message || 'No download_url returned' },
+                ctx: res?.ctx,
+            };
+        }
+        const willReplaceWasmPath = path$1.join(process.cwd(), data.wasm_path);
+        const { cacheDir } = keepCacheSync({
+            entryDir: process.cwd(),
+            originalWasmPath: data.wasm_path,
+            originalSplitConfigPath: WASM_SPLIT_CONFIG_FILE_NAME,
+        });
+        console.log(`[remote-download-prepared] target=${willReplaceWasmPath}`);
+        if (downloadUrl.includes('.br')) {
+            const tempWasmPath = path$1.join(cacheDir, '__temp__.wasm.br');
+            console.log('[remote-download-prepared] downloading (br) ->', tempWasmPath);
+            wsServer.sendUnitySplitStatus({ status: 'start_download_prepared_wasm', url: downloadUrl });
+            const startedAt = Date.now();
+            await download(downloadUrl, tempWasmPath);
+            console.log(`[remote-download-prepared] download done in ${Date.now() - startedAt}ms, size=${fs$1.statSync(tempWasmPath).size}`);
+            fs$1.copyFileSync(tempWasmPath, willReplaceWasmPath);
+            wsServer.sendUnitySplitStatus({ status: 'download_prepared_wasm_done', url: downloadUrl });
+        }
+        else {
+            const tempWasmPath = path$1.join(cacheDir, '__temp__.wasm');
+            console.log('[remote-download-prepared] downloading (raw) ->', tempWasmPath);
+            wsServer.sendUnitySplitStatus({ status: 'start_download_prepared_wasm', url: downloadUrl });
+            const startedAt = Date.now();
+            await download(downloadUrl, tempWasmPath);
+            console.log(`[remote-download-prepared] download done in ${Date.now() - startedAt}ms, size=${fs$1.statSync(tempWasmPath).size}`);
+            wsServer.sendUnitySplitStatus({ status: 'download_prepared_wasm_done', url: downloadUrl });
+            wsServer.sendUnitySplitStatus({ status: 'start_compress_prepared_wasm' });
+            await compressWasmFile(tempWasmPath, willReplaceWasmPath);
+            console.log('[remote-download-prepared] compressed and written to project');
+            wsServer.sendUnitySplitStatus({ status: 'compress_prepared_wasm_done', url: downloadUrl });
+            wsServer.sendUnitySplitStatus({ status: 'write_compress_prepared_wasm_done' });
+        }
+        wsServer.sendUnitySplitStatus({ status: 'start_update_wasm_split_config' });
+        // Remote (legacy) pipeline: enable collect but disable archive mode so the
+        // plugin reports to the legacy stark_wasm/v4 collect API.
+        // ORIGINALWASMMD5 must be set now (not only at split time) so the plugin
+        // sends the correct wasm_md5 in every collect report.
+        restoreSplitConfigFromCache();
+        updateWasmSplitConfig({
+            ENABLEWASMCOLLECT: true,
+            ENABLEARCHIVEMODE: false,
+            ORIGINALWASMMD5: res?.data?.result?.original_wasm_md5 ||
+                res?.data?.result?.md5 ||
+                data.wasm_md5,
+        });
+        wsServer.sendUnitySplitStatus({ status: 'update_wasm_split_config_done' });
+        console.log('[remote-download-prepared] split config updated, returning success');
+        return { isSuccess: true, ctx: res?.ctx };
+    }
+    catch (error) {
+        console.log('[remote-download-prepared] error:', error);
+        return {
+            isSuccess: false,
+            error: { code: res.data?.code, message: error instanceof Error ? error.message : String(error) },
+            ctx: res?.ctx,
+        };
+    }
+}
+
+function isLocal() {
+    return getLocalState().pipelineMode === 'local';
+}
+const startPrepare = (params) => isLocal() ? startPrepare$1(params) : startPrepareRemote(params);
+const downloadPrepared = (params) => isLocal() ? downloadPrepared$1() : downloadPreparedRemote(params);
+const setCollect = (params) => isLocal() ? setCollect$1(params) : setCollectRemote(params);
+const getCollectedFuncIds = (params) => isLocal() ? getCollectedFuncIds$1(params) : getCollectedFuncIdsRemote(params);
+const getCollecttingInfo = (params) => isLocal() ? getCollecttingInfo$1(params) : getCollecttingInfoRemote(params);
+const startSplit = (params) => isLocal() ? startSplit$1(params) : startSplitRemote(params);
+const downloadSplited = (context) => isLocal() ? downloadSplited$1(context) : downloadSplitedRemote(context);
+const getSplitResult = (params) => isLocal() ? getSplitResult$1() : getSplitResultRemote(params);
+const getTaskInfo = (params) => isLocal() ? getTaskInfo$1(params) : getTaskInfoRemote(params);
+const getTaskStatus = (params) => isLocal() ? getTaskStatus$1(params) : getTaskStatusRemote(params);
+const resetWasmSplit = (data) => isLocal() ? resetWasmSplit$1(data) : resetWasmSplitRemote(data);
+// Collect session (`/start` / `/finish`) is an implementation detail of the
+// local `wasm-collect/v1` pipeline — it's invoked inside `setCollectLocal`
+// and `startSplitLocal` respectively. The remote `stark_wasm/v4` pipeline
+// has no session concept. IDE never calls these directly, so there is no
+// dispatcher exposed here.
 
 const gameWasmCancelRoute = {
     method: 'post',
@@ -9889,26 +10807,35 @@ const gameWasmPrepareResultRoute = {
     method: 'post',
     path: '/game/wasm-prepare-result',
     handler: async (req, res) => {
-        console.log('wasm-prepare-result-request', req.body);
-        const { clientKey, codeMd5 } = req.body;
-        const response = await getTaskStatus({
-            client_key: clientKey,
-            wasm_md5: codeMd5,
-        });
-        if (response.error) {
-            res.send({
-                code: errorCode,
-                error: response.error,
-                ctx: response.ctx,
-            });
-        }
-        else {
+        const { pipelineMode } = getLocalState();
+        if (pipelineMode === 'local') {
             res.send({
                 code: successCode,
-                data: response.data?.result || {},
-                ctx: response.ctx,
+                data: { status: WasmStatus.WasmSplitPreparedStatus },
+                ctx: { logid: 'local' },
             });
+            return;
+        }
+        const { codeMd5, clientKey } = req.body;
+        const result = await getTaskStatus({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
+        });
+        // For the remote pipeline, forward the full `result` payload so the IDE
+        // gets both `status` and the accompanying `package` info, matching the
+        // legacy behaviour that the UI was written against.
+        if (result?.error) {
+            console.log('[wasm-prepare-result] remote error', result.error);
+            res.send({ code: errorCode, error: result.error, ctx: result?.ctx });
+            return;
         }
+        const data = result?.data?.result ?? { status: WasmStatus.IdleStatus };
+        console.log(`[wasm-prepare-result] remote status=${data?.status}`);
+        res.send({
+            code: successCode,
+            data,
+            ctx: result?.ctx ?? { logid: 'remote' },
+        });
     },
 };
 
@@ -9917,7 +10844,8 @@ const gameWasmPrepareRoute = {
     path: '/game/wasm-prepare',
     handler: async (req, res) => {
         const { codePath, desc, codeMd5, clientKey } = req.body;
-        console.log('wasm-prepare-start', req.body);
+        const { pipelineMode } = getLocalState();
+        console.log(`wasm-prepare-start [mode=${pipelineMode}]`, req.body);
         const result = await startPrepare({
             client_key: clientKey,
             desc,
@@ -9956,11 +10884,19 @@ const gameWasmSetCollectRoute = {
     method: 'post',
     path: '/game/wasm-set-collect',
     handler: async (req, res) => {
-        const { clientKey, codeMd5 } = req.body;
+        // `resume` is optional and only meaningful for the local pipeline:
+        // when the IDE detects an existing open session (e.g. user refreshed
+        // the page mid-collect) and wants to "继续收集" without nuking the
+        // already-uploaded func_ids, it POSTs `{ resume: true }`. Default
+        // (omitted / false) keeps the historical "fresh run" behaviour on
+        // /start (server gets `reset: true`). See `setCollect` jsdoc for the
+        // two-path contract; remote pipeline ignores the field outright.
+        const { clientKey, codeMd5, resume } = req.body;
         console.log('wasm-set-collect', req.body);
         const response = await setCollect({
             client_key: clientKey,
             wasm_md5: codeMd5,
+            resume,
         });
         if (response.error) {
             res.send({
@@ -9983,50 +10919,42 @@ const gameWasmSplitDownloadResultRoute = {
     method: 'post',
     path: '/game/wasm-split-download-result',
     handler: async (req, res) => {
+        const { pipelineMode, splitMeta } = getLocalState();
+        if (pipelineMode === 'local') {
+            if (!splitMeta) {
+                res.send({
+                    code: errorCode,
+                    error: { message: 'No local split result found. Run split first.' },
+                });
+                return;
+            }
+            res.send({
+                code: successCode,
+                data: { result: splitMeta },
+                msg: 'download success',
+                ctx: { logid: 'local' },
+            });
+            return;
+        }
         const { clientKey, codeMd5, codePath } = req.body;
-        console.log('game/wasm-split-download-result-start', req.body);
-        const response = await getSplitResult({
+        const result = await getSplitResult({
             client_key: clientKey,
             wasm_md5: codeMd5,
             wasm_path: codePath,
         });
-        if (response.error) {
+        if (result.error) {
             res.send({
                 code: errorCode,
-                error: response.error,
-                ctx: response.ctx,
+                error: result.error,
+                ctx: result.ctx,
             });
         }
         else {
-            const splitResult = (response.data?.result || {});
-            const requiredDownloadFields = [
-                'main_wasm_download_url',
-                'main_wasm_h5_download_url',
-                // 'sub_wasm_download_url',
-                // 'sub_js_download_url',
-                // 'sub_js_data_download_url',
-                // 'sub_js_range_download_url',
-            ];
-            const missingFields = requiredDownloadFields.filter(field => {
-                const value = splitResult[field];
-                return typeof value !== 'string' || value.trim() === '';
-            });
-            if (missingFields.length > 0) {
-                res.send({
-                    code: errorCode,
-                    error: {
-                        message: `Missing required wasm split fields: ${missingFields.join(', ')}`,
-                    },
-                    data: response.data || {},
-                    ctx: response.ctx,
-                });
-                return;
-            }
             res.send({
                 code: successCode,
-                data: response.data || {},
+                data: result.data || {},
                 msg: 'download success',
-                ctx: response.ctx,
+                ctx: result.ctx,
             });
         }
     },
@@ -10115,26 +11043,32 @@ const gameWasmSplitResultRoute = {
     method: 'post',
     path: '/game/wasm-split-result',
     handler: async (req, res) => {
-        const { codeMd5, clientKey } = req.body;
-        console.log('wasm-split-result', req.body);
-        const response = await getTaskStatus({
-            client_key: clientKey,
-            wasm_md5: codeMd5,
-        });
-        if (response.error) {
-            res.send({
-                code: errorCode,
-                error: response.error,
-                ctx: response.ctx,
-            });
-        }
-        else {
+        const { pipelineMode } = getLocalState();
+        if (pipelineMode === 'local') {
             res.send({
                 code: successCode,
-                data: response.data?.result || {},
-                ctx: response.ctx,
+                data: { status: WasmStatus.WasmSplitDoneStatus },
+                ctx: { logid: 'local' },
             });
+            return;
         }
+        const { clientKey, codeMd5 } = req.body;
+        const result = await getTaskStatus({
+            client_key: clientKey,
+            wasm_md5: codeMd5,
+        });
+        if (result?.error) {
+            console.log('[wasm-split-result] remote error', result.error);
+            res.send({ code: errorCode, error: result.error, ctx: result?.ctx });
+            return;
+        }
+        const data = result?.data?.result ?? { status: WasmStatus.IdleStatus };
+        console.log(`[wasm-split-result] remote status=${data?.status}`);
+        res.send({
+            code: successCode,
+            data,
+            ctx: result?.ctx ?? { logid: 'remote' },
+        });
     },
 };
 
@@ -10145,10 +11079,52 @@ const gameWasmSplitConfigRoute = {
         const config = getSplitConfig();
         if (!config) {
             res.send({ code: errorCode, data: 'Failed to parse split config' });
+            return;
         }
-        else {
-            res.send({ code: successCode, data: config });
+        // When the CLI is restarted mid-session, localState.pipelineMode resets to
+        // 'local' even though the project on disk may have been prepared in remote
+        // mode. Re-infer it from the persisted split config so subsequent
+        // dispatches (taskinfo / collect / split download) pick the right backend.
+        // Heuristic: the local pipeline always writes enableArchiveMode=true, the
+        // legacy remote pipeline always writes enableArchiveMode=false.
+        if (config.enableWasmCollect) {
+            const inferredMode = config.enableArchiveMode === true ? 'local' : 'remote';
+            const current = getLocalState().pipelineMode;
+            if (current !== inferredMode) {
+                setLocalState({ pipelineMode: inferredMode });
+                console.log(`[pipeline] inferred mode=${inferredMode} from webgl-wasm-split.js (was ${current})`);
+            }
         }
+        // ── wasm drift guard ─────────────────────────────────────────────
+        //
+        // `webgl-wasm-split.js` is persisted state about "which stage was
+        // last completed", but it can desync from reality: the user's Unity
+        // build re-emits `wasmcode/<file>.br` with a fresh, un-instrumented
+        // binary while the config still claims `enableWasmCollect=true`. The
+        // IDE's `canCollect()` then returns true, the prepare step gets
+        // skipped, and the device loads a wasm that has no `scwebgl.logCall`
+        // import — the `[wasmcollect] FATAL: no scwebgl.logCall import`
+        // failure.
+        //
+        // To guard: compare the wasm file currently on disk to the md5 that
+        // startPrepare wrote into `.ttmg-temp/prepared-meta.json`. If they
+        // differ, demote `enableWasmCollect` back to its placeholder string
+        // in the response so `canCollect()` → false and the IDE walks the
+        // user through prepare again. We never touch the real config file
+        // on disk — this is a transient correction at the read boundary, so
+        // the next successful prepare seamlessly re-aligns everything.
+        if (config.enableWasmCollect === true) {
+            const wasmMeta = computeCurrentProjectWasmMd5();
+            if (wasmMeta && wasmMeta.currentMd5 !== wasmMeta.meta.preparedWasmMd5) {
+                console.warn(`[wasmtool] wasm drift detected: project wasm md5=${wasmMeta.currentMd5} but prepared meta expected ${wasmMeta.meta.preparedWasmMd5} (path=${wasmMeta.meta.codePath}). Forcing IDE back to prepare.`);
+                // Mirror the string-placeholder shape the template uses before
+                // prepare writes a real boolean — matches what `canCollect`
+                // expects and is indistinguishable from "never prepared" from
+                // the IDE's perspective.
+                config.enableWasmCollect = '$ENABLEWASMCOLLECT';
+            }
+        }
+        res.send({ code: successCode, data: config });
     },
 };
 
@@ -10216,6 +11192,59 @@ function getGameFallbackRoute(publicPath) {
     };
 }
 
+/**
+ * Explicit "user clicked a lang toggle in the IDE" endpoint. Unlike
+ * `/game/config-fillback` — which intentionally no-ops when the CLI
+ * already has a lang configured — this route always writes the incoming
+ * lang to TTMGRC so the next IDE bootstrap's `setCurrentLang(cliLang)`
+ * call won't stomp the user's fresh choice.
+ */
+const gameLanguageRoute = {
+    method: 'post',
+    path: '/game/language',
+    handler: async (req, res) => {
+        const incomingLang = req.body?.lang;
+        const nextLang = resolveSupportedLanguage(incomingLang);
+        if (!nextLang) {
+            res.send({
+                code: successCode,
+                data: {
+                    lang: null,
+                    updated: false,
+                },
+            });
+            return;
+        }
+        setTTMGRC({ lang: nextLang });
+        res.send({
+            code: successCode,
+            data: {
+                lang: nextLang,
+                updated: true,
+            },
+        });
+    },
+};
+
+const gamePipelineModeRoute = {
+    method: 'post',
+    path: '/game/pipeline-mode',
+    handler: (req, res) => {
+        const { mode } = req.body;
+        setLocalState({ pipelineMode: mode });
+        console.log(`[pipeline] mode set to: ${mode}`);
+        res.send({ code: successCode, data: { mode } });
+    },
+};
+const gamePipelineModeGetRoute = {
+    method: 'get',
+    path: '/game/pipeline-mode',
+    handler: (_req, res) => {
+        const { pipelineMode } = getLocalState();
+        res.send({ code: successCode, data: { mode: pipelineMode } });
+    },
+};
+
 const routes = [
     gameConfigRoute,
     gameConfigFillbackRoute,
@@ -10237,6 +11266,9 @@ const routes = [
     gameWasmSplitDownloadRoute,
     gameWasmCancelRoute,
     gameWasmSplitResetRoute,
+    gamePipelineModeRoute,
+    gamePipelineModeGetRoute,
+    gameLanguageRoute,
 ];
 function registerRoutes(app, options) {
     const allRoutes = [...routes, getGameFallbackRoute(options.publicPath)];
@@ -10679,7 +11711,7 @@ async function upload({ clientKey, note = '--', dir, }) {
     }
 }
 
-var version = "0.3.6-beta.3";
+var version = "0.3.6-beta.wasmcode.split";
 var pkg = {
 	version: version};