@next2d/builder 0.1.11 → 0.2.0

package/dist/steam-upload.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { readElectronConfig, validateSteamId } from "./electron-config.js";
+import { quoteSteamValue as quote, readSteamPackage } from "./steam.js";
+export const validateSteamBranch = (branch) => {
+    if (typeof branch !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(branch)
+        || ["default", "public", "none"].includes(branch.toLowerCase())) {
+        throw new Error("Steam upload requires a named beta branch such as internal (letters, numbers, - or _). The default branch is not supported.");
+    }
+    return branch;
+};
+/** Recreate manifests from validated package records, never from stale or edited VDF files. */
+export const prepareSteamUpload = (options) => {
+    const root = path.resolve(options.root);
+    const steamRoot = path.resolve(root, options.steamRoot);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(options.environment)) {
+        throw new Error("Steam upload --env must contain only letters, numbers, - or _.");
+    }
+    const config = readElectronConfig(root);
+    const branch = validateSteamBranch(options.branch ?? config.steam?.branch ?? "internal");
+    if (!config.steam?.appId) {
+        throw new Error("Set steam.appId and steam.depots in electron.config.json before uploading.");
+    }
+    const version = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version;
+    if (typeof version !== "string" || !version) {
+        throw new Error("Set package.json version before uploading.");
+    }
+    if (options.comment !== undefined && (typeof options.comment !== "string" || !options.comment.trim()
+        || /["\\\u0000-\u001f\u007f]/.test(options.comment))) {
+        throw new Error("Steam upload --steam-comment must be nonempty single-line text without double quotes, backslashes or control characters.");
+    }
+    const comment = options.comment ?? `${config.appName} ${version} (${options.environment}, ${branch})`;
+    const quotedComment = quote(comment);
+    const groups = new Map();
+    for (const os of ["windows", "macos", "linux"]) {
+        const id = config.steam.depots[os];
+        if (id === null || id === undefined) {
+            continue;
+        }
+        const depot = validateSteamId(id);
+        try {
+            const record = readSteamPackage(steamRoot, options.environment, config, version, os);
+            groups.set(depot, [...groups.get(depot) ?? [], { os, ...record }]);
+        }
+        catch (error) {
+            throw new Error(`Steam upload: ${os} package is missing or outdated. Export/collect every configured OS first. ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    if (!groups.size) {
+        throw new Error("Set at least one Steam Depot ID in electron.config.json before uploading.");
+    }
+    // Unique scripts prevent a dry-run or another invocation from overwriting an active upload.
+    const uploads = path.join(steamRoot, "uploads", options.environment);
+    fs.mkdirSync(uploads, { "recursive": true });
+    const scripts = fs.mkdtempSync(path.join(uploads, `${branch}-`));
+    const depotFiles = [];
+    const launches = [];
+    for (const [depot, members] of groups) {
+        const mappings = members.map(({ os, content, arch, localExecutable }) => {
+            const prefix = members.length > 1 ? `${os}/` : "";
+            launches.push({ "platform": `steam:${os}`, arch, "executable": `${prefix}${localExecutable}`, "depotId": depot });
+            return `    "FileMapping"\n    {\n        "LocalPath" ${quote(`${path.relative(steamRoot, content)}/*`)}\n        "DepotPath" ${quote(prefix || ".")}\n        "Recursive" "1"\n    }`;
+        });
+        const name = `depot_${depot}.vdf`;
+        fs.writeFileSync(path.join(scripts, name), `"DepotBuild"\n{\n    "DepotID" "${depot}"\n${mappings.join("\n")}\n    "FileExclusion" "steam_appid.txt"\n    "FileExclusion" "*.pdb"\n    "FileExclusion" ".DS_Store"\n}\n`);
+        depotFiles.push(`        "${depot}" ${quote(name)}`);
+    }
+    const manifest = path.join(scripts, options.dryRun ? "app_preview.vdf" : "app_upload.vdf");
+    // A stable cache directory allows SteamPipe to reuse chunks across uploads to a branch.
+    const cache = path.join(uploads, "cache", branch);
+    fs.writeFileSync(manifest, `"AppBuild"\n{\n    "AppID" "${config.steam.appId}"\n    "Desc" ${quotedComment}\n`
+        + `    "ContentRoot" ${quote(steamRoot)}\n    "BuildOutput" ${quote(cache)}\n    "Preview" "${options.dryRun ? "1" : "0"}"\n`
+        + (options.dryRun ? "" : `    "SetLive" ${quote(branch)}\n`)
+        + `    "Depots"\n    {\n${depotFiles.join("\n")}\n    }\n}\n`);
+    const plan = { "appId": config.steam.appId, branch, version, comment, "environment": options.environment, "dryRun": !!options.dryRun, manifest, launches };
+    fs.writeFileSync(path.join(scripts, "upload-plan.json"), `${JSON.stringify(plan, null, 2)}\n`);
+    return plan;
+};
+/** Use SteamCMD's existing login session; passwords/Steam Guard codes never enter project config. */
+export const uploadSteam = async (options) => {
+    const plan = prepareSteamUpload(options);
+    console.log(`Steam App ${plan.appId} -> beta branch ${plan.branch}`);
+    console.log(`Comment: ${plan.comment}`);
+    console.log(`Manifest: ${plan.manifest}`);
+    for (const launch of plan.launches) {
+        console.log(`  Depot ${launch.depotId}: ${launch.platform}/${launch.arch} -> ${launch.executable}`);
+    }
+    if (options.dryRun) {
+        console.log("Dry run complete: SteamCMD was not started. Branch existence/password protection has not been checked on Steamworks.");
+        return;
+    }
+    const username = process.env.STEAM_USERNAME;
+    if (!username || !/^[a-zA-Z0-9_][a-zA-Z0-9_.@-]*$/.test(username)) {
+        throw new Error("Set STEAM_USERNAME to your Steam build account name. Log in with SteamCMD once before uploading; see docs/steam.md.");
+    }
+    const command = process.env.STEAMCMD || (process.platform === "win32" ? "steamcmd.exe" : "steamcmd");
+    console.log(`Uploading and requesting activation on ${plan.branch}. Configure the beta password in Steamworks to restrict access.`);
+    const buildId = await new Promise((resolve, reject) => {
+        let output = "";
+        let reportedError = false;
+        const child = spawn(command, [
+            "+@ShutdownOnFailedCommand", "1", "+@NoPromptForPassword", "1",
+            "+login", username, "+run_app_build", plan.manifest, "+quit"
+        ], { "cwd": path.resolve(options.root), "stdio": ["ignore", "pipe", "pipe"], "shell": false });
+        const collect = (chunk, stream) => {
+            stream.write(chunk);
+            output = (output + chunk.toString()).slice(-1024 * 1024);
+            reportedError || (reportedError = /ERROR[!:]|Failed to set[^\r\n]*live/i.test(output));
+        };
+        child.stdout.on("data", (chunk) => collect(chunk, process.stdout));
+        child.stderr.on("data", (chunk) => collect(chunk, process.stderr));
+        child.once("error", (error) => reject(new Error(`Cannot start SteamCMD: ${error.message}. Set STEAMCMD to the executable path; see docs/steam.md.`)));
+        child.once("close", (code, signal) => {
+            if (code !== 0) {
+                reject(new Error(`SteamCMD failed (${signal || code}). Inspect its output and SteamPipe logs; check login, app permissions and beta branch settings.`));
+                return;
+            }
+            const success = output.match(new RegExp(`(?:Success! App '${plan.appId}' fully built|Successfully finished AppID ${plan.appId} build) \\(BuildID ([0-9]+)\\)`, "i"));
+            if (reportedError || !success) {
+                reject(new Error("SteamCMD did not report a successful app build, or reported an error. Check SteamPipe logs and the branch's active BuildID in Steamworks before retrying."));
+                return;
+            }
+            resolve(success[1]);
+        });
+    });
+    fs.writeFileSync(path.join(path.dirname(plan.manifest), "upload-result.json"), `${JSON.stringify({
+        "appId": plan.appId, buildId, "requestedBranch": plan.branch, "completedAt": new Date().toISOString()
+    }, null, 2)}\n`);
+    console.log(`Uploaded BuildID ${buildId}. Verify the active ${plan.branch} build at https://partner.steamgames.com/apps/builds/${plan.appId}`);
+};

package/dist/steam.d.ts

@@ -0,0 +1,22 @@
+import type { IElectronConfig, ElectronOS } from "./electron-config.js";
+export interface ISteamConfig {
+    appId: string;
+    depotId: string | null;
+    sharedPlatforms?: ElectronOS[];
+}
+export declare const readSteamConfig: (config: IElectronConfig, platform: string) => ISteamConfig | null;
+export declare const quoteSteamValue: (value: string) => string;
+/** Discover the executable from the output, including customized executable names. */
+export declare const findSteamLaunch: (content: string, platform: string, executableName?: string) => string;
+/** Keep scripts outside the content directory so Steam never installs build metadata. */
+export declare const writeSteamMetadata: (content: string, platform: string, arch: string, config: ISteamConfig | null, executableName?: string) => void;
+/** A portable pointer to the most recently exported architecture for this OS/environment. */
+export declare const recordSteamPackage: (content: string, platform: string, arch: string, config: IElectronConfig, version: string) => void;
+/** Validate that an exported package still matches the current project and depot configuration. */
+export declare const readSteamPackage: (steamRoot: string, environment: string, config: IElectronConfig, version: string, os: ElectronOS) => {
+    content: string;
+    arch: string;
+    localExecutable: string;
+};
+/** Combine existing packages with multiple FileMappings, preserving app symlinks and permissions. */
+export declare const writeSharedSteamDepots: (steamRoot: string, environment: string, config: IElectronConfig, version: string) => string[];

package/dist/steam.js

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import path from "node:path";
+import { validateSteamId } from "./electron-config.js";
+const platforms = ["windows", "macos", "linux"];
+export const readSteamConfig = (config, platform) => {
+    if (!config.steam?.appId) {
+        return null;
+    }
+    const os = platform.replace(/^steam:/, "");
+    const depot = config.steam.depots[os];
+    const depotId = depot ? validateSteamId(depot) : null;
+    const sharedPlatforms = depotId ? platforms.filter((key) => String(config.steam?.depots[key]) === depotId) : [];
+    return { "appId": config.steam.appId, depotId, ...sharedPlatforms.length > 1 ? { sharedPlatforms } : {} };
+};
+export const quoteSteamValue = (value) => {
+    if (/["\r\n\0]/.test(value)) {
+        throw new Error("Unsupported quote or control character in SteamPipe path.");
+    }
+    return `"${value.replace(/\\/g, "/")}"`;
+};
+const quote = quoteSteamValue;
+/** Discover the executable from the output, including customized executable names. */
+export const findSteamLaunch = (content, platform, executableName) => {
+    const entries = fs.readdirSync(content, { "withFileTypes": true });
+    if (platform === "steam:macos") {
+        const apps = entries.filter((entry) => entry.isDirectory() && entry.name.endsWith(".app"));
+        if (apps.length !== 1) {
+            throw new Error("Expected exactly one macOS .app in the packaged folder.");
+        }
+        return apps[0].name;
+    }
+    if (executableName) {
+        const executable = `${executableName}${platform === "steam:windows" ? ".exe" : ""}`;
+        if (!fs.statSync(path.join(content, executable), { "throwIfNoEntry": false })?.isFile()) {
+            throw new Error(`Packaged Steam executable is missing: ${executable}`);
+        }
+        return executable;
+    }
+    const candidates = entries.filter((entry) => {
+        if (!entry.isFile()) {
+            return false;
+        }
+        if (platform === "steam:windows") {
+            return entry.name.endsWith(".exe") && entry.name !== "chrome_crashpad_handler.exe";
+        }
+        // Electron's other Linux binaries have extensions or known helper names.
+        return !entry.name.includes(".") && !["chrome-sandbox", "chrome_crashpad_handler", "LICENSE", "version"].includes(entry.name)
+            && (fs.statSync(path.join(content, entry.name)).mode & 0o111) !== 0;
+    });
+    if (candidates.length !== 1) {
+        throw new Error(`Cannot determine the Steam executable in ${content}`);
+    }
+    return candidates[0].name;
+};
+/** Keep scripts outside the content directory so Steam never installs build metadata. */
+export const writeSteamMetadata = (content, platform, arch, config, executableName) => {
+    const localExecutable = findSteamLaunch(content, platform, executableName);
+    const depotPath = config?.sharedPlatforms ? platform.replace("steam:", "") : "";
+    const executable = depotPath ? `${depotPath}/${localExecutable}` : localExecutable;
+    const scripts = `${content}-steampipe`;
+    fs.mkdirSync(scripts, { "recursive": true });
+    const metadata = {
+        platform, arch, executable,
+        localExecutable, depotPath,
+        "contentRoot": `../${path.basename(content)}`,
+        "workingDirectory": "",
+        "arguments": "",
+        "appId": config?.appId || null,
+        "depotId": config?.depotId || null
+    };
+    fs.writeFileSync(path.join(scripts, "launch.json"), `${JSON.stringify(metadata, null, 2)}\n`);
+    // Remove scripts from an earlier configured run if IDs are no longer configured.
+    for (const name of ["app_build.vdf", "app_preview.vdf", "depot_build.vdf"]) {
+        fs.rmSync(path.join(scripts, name), { "force": true });
+    }
+    if (!config?.depotId) {
+        console.log("Steam package ready. Set steam.appId and steam.depots in electron.config.json to generate SteamPipe VDFs.");
+        return;
+    }
+    // Upload a shared depot only through the combined manifest, never one OS at a time.
+    if (config.sharedPlatforms) {
+        return;
+    }
+    fs.writeFileSync(path.join(scripts, "depot_build.vdf"), `"DepotBuild"\n{\n    "DepotID" "${config.depotId}"\n    "FileMapping"\n    {\n        "LocalPath" "*"\n        "DepotPath" "."\n        "Recursive" "1"\n    }\n    "FileExclusion" "steam_appid.txt"\n    "FileExclusion" "*.pdb"\n    "FileExclusion" ".DS_Store"\n}\n`);
+    for (const preview of [false, true]) {
+        fs.writeFileSync(path.join(scripts, preview ? "app_preview.vdf" : "app_build.vdf"), `"AppBuild"\n{\n    "AppID" "${config.appId}"\n    "Desc" ${quote(`${platform} ${arch}`)}\n    "ContentRoot" ${quote(metadata.contentRoot)}\n    "BuildOutput" "cache"\n    "Preview" "${preview ? "1" : "0"}"\n    "Depots"\n    {\n        "${config.depotId}" "depot_build.vdf"\n    }\n}\n`);
+    }
+};
+/** A portable pointer to the most recently exported architecture for this OS/environment. */
+export const recordSteamPackage = (content, platform, arch, config, version) => {
+    const steam = readSteamConfig(config, platform);
+    writeSteamMetadata(content, platform, arch, steam, config.executableName);
+    const record = {
+        platform, arch, version,
+        "appId": steam?.appId ?? null, "depotId": steam?.depotId ?? null,
+        "appName": config.appName, "executableName": config.executableName,
+        "contentRoot": path.basename(content)
+    };
+    fs.writeFileSync(path.join(path.dirname(content), "steam-package.json"), `${JSON.stringify(record, null, 2)}\n`);
+};
+/** Validate that an exported package still matches the current project and depot configuration. */
+export const readSteamPackage = (steamRoot, environment, config, version, os) => {
+    const output = path.join(steamRoot, os, "build", environment);
+    const record = JSON.parse(fs.readFileSync(path.join(output, "steam-package.json"), "utf8"));
+    if (typeof record.contentRoot !== "string" || path.basename(record.contentRoot) !== record.contentRoot
+        || /[\\/*?"\r\n\0]/.test(record.contentRoot) || record.contentRoot === "." || record.contentRoot === "..") {
+        throw new Error("Invalid package path");
+    }
+    const content = path.join(output, record.contentRoot);
+    if (record.platform !== `steam:${os}` || record.appId !== config.steam?.appId
+        || record.depotId !== validateSteamId(config.steam?.depots[os])
+        || record.version !== version || record.appName !== config.appName || record.executableName !== config.executableName
+        || !(os === "macos" ? ["x64", "arm64", "universal"] : ["x64", "arm64"]).includes(record.arch)) {
+        throw new Error("Package metadata no longer matches the project configuration");
+    }
+    const relativeRealPath = path.relative(fs.realpathSync(steamRoot), fs.realpathSync(content));
+    if (path.isAbsolute(relativeRealPath) || relativeRealPath === ".." || relativeRealPath.startsWith(`..${path.sep}`)) {
+        throw new Error("Package directory must be inside the Steam output root");
+    }
+    return { content, "arch": record.arch, "localExecutable": findSteamLaunch(content, `steam:${os}`, config.executableName) };
+};
+/** Combine existing packages with multiple FileMappings, preserving app symlinks and permissions. */
+export const writeSharedSteamDepots = (steamRoot, environment, config, version) => {
+    const pending = [];
+    const groups = new Map();
+    for (const os of platforms) {
+        const id = config.steam?.depots[os];
+        if (id) {
+            const key = validateSteamId(id);
+            groups.set(key, [...groups.get(key) ?? [], os]);
+        }
+    }
+    const sharedRoot = path.join(steamRoot, "shared", environment);
+    // Remove obsolete generated VDFs after a depot's membership or IDs change.
+    if (fs.existsSync(sharedRoot)) {
+        for (const entry of fs.readdirSync(sharedRoot, { "withFileTypes": true })) {
+            if (entry.isDirectory() && /^depot-[0-9]+$/.test(entry.name)) {
+                for (const name of ["app_build.vdf", "app_preview.vdf", "depot_build.vdf", "launch.json"]) {
+                    fs.rmSync(path.join(sharedRoot, entry.name, name), { "force": true });
+                }
+            }
+        }
+    }
+    for (const [depotId, members] of groups) {
+        if (members.length < 2) {
+            continue;
+        }
+        const scripts = path.join(sharedRoot, `depot-${depotId}`);
+        fs.mkdirSync(scripts, { "recursive": true });
+        const mappings = [];
+        const launches = [];
+        const missing = [];
+        for (const os of members) {
+            const output = path.join(steamRoot, os, "build", environment);
+            // Also invalidate legacy exports created before steam-package.json existed.
+            if (fs.existsSync(output)) {
+                for (const entry of fs.readdirSync(output, { "withFileTypes": true })) {
+                    if (entry.isDirectory() && entry.name.startsWith(`${config.appName}-`) && entry.name.endsWith("-steampipe")) {
+                        for (const name of ["app_build.vdf", "app_preview.vdf", "depot_build.vdf"]) {
+                            fs.rmSync(path.join(output, entry.name, name), { "force": true });
+                        }
+                    }
+                }
+            }
+            try {
+                const { content, arch, localExecutable } = readSteamPackage(steamRoot, environment, config, version, os);
+                const relative = path.relative(steamRoot, content).replace(/\\/g, "/");
+                mappings.push(`    "FileMapping"\n    {\n        "LocalPath" ${quote(`${relative}/*`)}\n        "DepotPath" "${os}/"\n        "Recursive" "1"\n    }`);
+                launches.push({ "platform": `steam:${os}`, arch, "executable": `${os}/${localExecutable}`, "workingDirectory": "", "arguments": "" });
+                writeSteamMetadata(content, `steam:${os}`, arch, readSteamConfig(config, `steam:${os}`), config.executableName);
+            }
+            catch (error) {
+                missing.push(`${os}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        fs.writeFileSync(path.join(scripts, "launch.json"), `${JSON.stringify({
+            "appId": config.steam?.appId, depotId, "ready": !missing.length,
+            "requiredPlatforms": members, missing, "launches": launches
+        }, null, 2)}\n`);
+        if (missing.length) {
+            pending.push(`Depot ${depotId}: ${missing.join("; ")}`);
+            console.log(`Shared Steam depot ${depotId}: waiting for all OS packages. See ${path.join(scripts, "launch.json")}`);
+            continue;
+        }
+        fs.writeFileSync(path.join(scripts, "depot_build.vdf"), `"DepotBuild"\n{\n    "DepotID" "${depotId}"\n${mappings.join("\n")}\n    "FileExclusion" "steam_appid.txt"\n    "FileExclusion" "*.pdb"\n    "FileExclusion" ".DS_Store"\n}\n`);
+        const contentRoot = path.relative(scripts, steamRoot);
+        for (const preview of [false, true]) {
+            fs.writeFileSync(path.join(scripts, preview ? "app_preview.vdf" : "app_build.vdf"), `"AppBuild"\n{\n    "AppID" "${config.steam?.appId}"\n    "Desc" ${quote(`Shared depot ${depotId}: ${members.join(", ")} ${version}`)}\n    "ContentRoot" ${quote(contentRoot)}\n    "BuildOutput" "cache"\n    "Preview" "${preview ? "1" : "0"}"\n    "Depots"\n    {\n        "${depotId}" "depot_build.vdf"\n    }\n}\n`);
+        }
+        console.log(`Shared Steam depot ready: ${scripts}`);
+    }
+    return pending;
+};

package/dist/tool-packages.d.ts

@@ -0,0 +1,15 @@
+declare const packages: {
+    electron: {
+        "@electron/packager": string;
+    };
+    capacitor: {
+        "@capacitor/cli": string;
+        "@capacitor/core": string;
+        "@capacitor/ios": string;
+        "@capacitor/android": string;
+    };
+};
+type Tool = keyof typeof packages;
+/** Download only on first use; npm retains the packages after the temporary request is removed. */
+export declare const resolveToolPackages: (tool: Tool) => Promise<Record<string, string>>;
+export {};

package/dist/tool-packages.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+// Keep native SDKs together and pin tools independently of the game's dependencies.
+const packages = {
+    "electron": { "@electron/packager": "20.3.0" },
+    "capacitor": {
+        "@capacitor/cli": "8.5.2", "@capacitor/core": "8.5.2",
+        "@capacitor/ios": "8.5.2", "@capacitor/android": "8.5.2"
+    }
+};
+const pending = new Map();
+/** Launch npm's npx script with Node, avoiding cmd.exe quoting on Windows. */
+const resolveNpxCli = () => {
+    const candidates = [
+        ...process.env.npm_execpath ? [path.join(path.dirname(process.env.npm_execpath), "npx-cli.js")] : [],
+        path.join(path.dirname(process.execPath), "node_modules/npm/bin/npx-cli.js"),
+        ...(process.env.PATH ?? "").split(path.delimiter).flatMap((dir) => [
+            path.join(dir, "npx"), path.join(dir, "node_modules/npm/bin/npx-cli.js")
+        ])
+    ];
+    for (const file of candidates) {
+        if (fs.statSync(file, { "throwIfNoEntry": false })?.isFile()) {
+            const resolved = fs.realpathSync(file);
+            if (path.basename(resolved) === "npx-cli.js") {
+                return resolved;
+            }
+        }
+    }
+    throw new Error("npm/npx is required to download build tools. Install Node.js with npm and add it to PATH.");
+};
+const acquire = async (tool) => {
+    const cli = resolveNpxCli();
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "next2d-tools-"));
+    const result = path.join(dir, "packages.json");
+    const specs = Object.entries(packages[tool]).map(([name, version]) => `--package=${name}@${version}`);
+    try {
+        console.log(`Preparing ${tool} tools via npx (${specs.map((spec) => spec.slice(10)).join(", ")})`);
+        await new Promise((resolve, reject) => {
+            const child = spawn(process.execPath, [cli, "--yes", ...specs, "--call",
+                "node --input-type=module -e \"import(process.env.NEXT2D_TOOL_RESOLVER)\""
+            ], {
+                // A neutral cwd prevents project dependencies and npm hooks influencing tool acquisition.
+                "cwd": dir, "stdio": "inherit",
+                "env": {
+                    ...process.env,
+                    "NEXT2D_TOOL_RESOLVER": new URL("./resolve-tool-packages.js", import.meta.url).href,
+                    "NEXT2D_TOOL_PACKAGES": JSON.stringify(packages[tool]),
+                    "NEXT2D_TOOL_RESULT": result
+                }
+            });
+            child.once("error", reject);
+            child.once("close", (code, signal) => code === 0 ? resolve()
+                : reject(new Error(`npx could not prepare ${tool} tools (${signal || code}). Check npm connectivity/cache and retry.`)));
+        });
+        return JSON.parse(fs.readFileSync(result, "utf8"));
+    }
+    finally {
+        fs.rmSync(dir, { "recursive": true, "force": true });
+    }
+};
+/** Download only on first use; npm retains the packages after the temporary request is removed. */
+export const resolveToolPackages = (tool) => {
+    let request = pending.get(tool);
+    if (!request) {
+        request = acquire(tool).catch((error) => {
+            pending.delete(tool);
+            throw error;
+        });
+        pending.set(tool, request);
+    }
+    return request;
+};

package/dist/web.js

@@ -1,7 +1,8 @@
 // Web ビルド: vite 設定の読み込みと HTML/JavaScript の書き出し。
-import pc from "picocolors";
+import pc from "./colors.js";
 import fs from "fs";
-import { loadConfigFromFile } from "vite";
+import path from "node:path";
+import { loadProjectVite } from "./project-vite.js";
 import { ctx } from "./context.js";
 import { $spawn } from "./utils.js";
 /**
@@ -20,14 +21,15 @@ export const loadConfig = async () => {
         fs.writeFileSync(`${process.cwd()}/package.json`, JSON.stringify(packageJson, null, 2));
     }
     const ext = fs.existsSync(`${process.cwd()}/vite.config.ts`) ? "ts" : "js";
+    const { loadConfigFromFile } = await loadProjectVite();
     const config = await loadConfigFromFile({
         "command": "build",
         "mode": "build"
     }, `${process.cwd()}/vite.config.${ext}`);
     // update config
     ctx.configObject = config;
-    ctx.outDir = ctx.configObject.config?.build?.outDir || "dist";
-    ctx.buildDir = `${process.cwd()}/${ctx.outDir}/${ctx.platformDir}/${ctx.environment}`;
+    ctx.outDir = ctx.configObject?.config.build?.outDir || "dist";
+    ctx.buildDir = path.resolve(ctx.outDir, ctx.platformDir, ctx.environment);
     if (!fs.existsSync(`${ctx.buildDir}`)) {
         fs.mkdirSync(`${ctx.buildDir}`, { "recursive": true });
         console.log(pc.green(`Create build directory: ${ctx.buildDir}`));
@@ -47,9 +49,11 @@ export const buildWeb = () => {
         const stream = $spawn("npx", [
             "@next2d/vite-plugin-next2d-auto-loader"
         ], { "stdio": "inherit" });
+        stream.once("error", reject);
         stream.on("close", (code) => {
             if (code !== 0) {
                 reject("vite plugin command failed.");
+                return;
             }
             const stream = $spawn("npx", [
                 "vite",
@@ -57,9 +61,11 @@ export const buildWeb = () => {
                 ctx.buildDir,
                 "build"
             ], { "stdio": "inherit" });
+            stream.once("error", reject);
             stream.on("close", (code) => {
                 if (code !== 0) {
                     reject("Export of `HTML` and `JavaScript` failed.");
+                    return;
                 }
                 console.log();
                 console.log(pc.green("`HTML` and `JavaScript` files are written out."));

package/dist/xbox.d.ts

@@ -49,7 +49,7 @@ export declare const renderAssetsRc: (pakAbsPath: string) => string;
  * @method
  * @public
  */
-export declare const minifyJs: (name: string, code: string) => string;
+export declare const minifyJs: (name: string, code: string) => Promise<string>;
 /**
  * @description Xbox(GDKネイティブ)用アプリの書き出し関数。
  *              V8にNext2DのJSを載せ、Dawn(WebGPU/D3D12)で描画するC++ホストをビルドする。