@next2d/builder 0.1.11 → 0.3.0

package/dist/electron-native.js

@@ -0,0 +1,73 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+export const validateNativeBridge = (value) => {
+    if (value === undefined) {
+        return;
+    }
+    if (value && value.prepare !== undefined && (typeof value.prepare !== "string" || !value.prepare.trim()
+        || path.isAbsolute(value.prepare) || value.prepare.includes("\0") || !/\.[cm]?js$/.test(value.prepare))) {
+        throw new Error("nativeBridge.prepare must be a project-relative Node.js script.");
+    }
+    if (!value || !Array.isArray(value.methods) || !value.methods.length
+        || value.methods.some((method) => typeof method !== "string" || !/^[a-zA-Z][a-zA-Z0-9_.]{0,63}$/.test(method))
+        || !value.targets || typeof value.targets !== "object" || Array.isArray(value.targets)
+        || value.backgroundThrottling !== undefined && typeof value.backgroundThrottling !== "boolean") {
+        throw new Error("Invalid nativeBridge methods/targets.");
+    }
+    for (const [target, entry] of Object.entries(value.targets)) {
+        if (!/^(windows|linux)-(x64|arm64)$|^macos-(x64|arm64|universal)$/.test(target)
+            || !entry || typeof entry.directory !== "string" || !entry.directory.trim()
+            || typeof entry.executable !== "string" || !/^[a-zA-Z0-9_-][a-zA-Z0-9_.-]*$/.test(entry.executable)) {
+            throw new Error(`Invalid nativeBridge target: ${target}`);
+        }
+    }
+};
+export const stageNativeBridge = (root, host, config, target) => {
+    validateNativeBridge(config);
+    const entry = config.targets[target];
+    if (!entry) {
+        throw new Error(`nativeBridge requires a ${target} target (universal builds require universal native binaries).`);
+    }
+    const source = path.resolve(root, entry.directory);
+    const check = (file) => {
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink() || !stat.isFile() && !stat.isDirectory()) {
+            throw new Error(`Native bridge bundles must contain only regular files/directories: ${file}`);
+        }
+        if (stat.isDirectory()) {
+            for (const child of fs.readdirSync(file)) {
+                check(path.join(file, child));
+            }
+        }
+    };
+    const destination = path.join(host, "native");
+    if (config.prepare) {
+        const script = fs.realpathSync(path.resolve(root, config.prepare));
+        const relative = path.relative(fs.realpathSync(root), script);
+        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new Error("nativeBridge.prepare must stay inside the project.");
+        }
+        fs.mkdirSync(destination, { "mode": 0o700 });
+        const result = spawnSync(process.execPath, [script, "--target", target, "--source", source, "--destination", destination], { "cwd": root, "stdio": "inherit", "shell": false, "timeout": 120000 });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(`Native preparation failed (${result.status}).`);
+        }
+    }
+    else {
+        check(source);
+        fs.cpSync(source, destination, { "recursive": true });
+    }
+    check(destination);
+    if (!fs.statSync(path.join(destination, entry.executable), { "throwIfNoEntry": false })?.isFile()) {
+        throw new Error(`Native bridge executable is missing: ${entry.executable}`);
+    }
+    if (!target.startsWith("windows-")) {
+        fs.chmodSync(path.join(destination, entry.executable), 0o755);
+    }
+    return { "executable": entry.executable, "methods": config.methods,
+        ...config.backgroundThrottling !== undefined ? { "backgroundThrottling": config.backgroundThrottling } : {} };
+};

package/dist/electron.d.ts

@@ -1,10 +1,5 @@
-/**
- * @description Electron ベースのデスクトップアプリ書き出し関数
- *              (Windows / macOS / Linux、Steam・Epic Games Store 等の配布に共通)。
- *              Export function for Electron-based desktop apps.
- *
- * @return {Promise}
- * @method
- * @public
- */
+export declare const resolveElectronTarget: (platform: string, arch?: string, preview?: boolean) => {
+    platform: "win32" | "darwin" | "linux";
+    arch: "x64" | "arm64" | "universal";
+};
 export declare const buildElectron: () => Promise<void>;

package/dist/electron.js

@@ -1,142 +1,94 @@
-// Electron ベースのデスクトップ配布 (Steam / Epic Games Store など)。
-import pc from "picocolors";
-import fs from "fs";
-import cp from "child_process";
-import { api } from "@electron-forge/core";
+// Electron desktop packages are unpacked application folders, ready for SteamPipe.
+import pc from "./colors.js";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { createElectronPackagerOptions, readElectronConfig } from "./electron-config.js";
 import { ctx } from "./context.js";
 import { $spawn } from "./utils.js";
-/**
- * @description electronがインストールされてなければインストールを実行
- *              If electron is not installed, run install.
- *
- * @return {Promise}
- * @method
- * @private
- */
-const installElectron = () => {
-    return new Promise((resolve, reject) => {
-        if (fs.existsSync(`${process.cwd()}/electron/node_modules`)) {
-            return resolve();
-        }
-        const stream = $spawn("npm", [
-            "--prefix",
-            `${process.cwd()}/electron`,
-            "install",
-            `${process.cwd()}/electron`
-        ], { "stdio": "inherit" });
-        stream.on("close", (code) => {
-            if (code !== 0) {
-                reject("`Electron` installation failed.");
-            }
-            console.log(pc.green("`Electron` successfully installed."));
-            resolve();
-        });
-    });
-};
-/**
- * @description electronに含むリソースを初期化
- *              Initialize resources included in electron
- *
- * @return {Promise}
- * @method
- * @private
- */
-const removeResources = () => {
-    return new Promise((resolve, reject) => {
-        const stream = cp.spawn("rm", [
-            "-rf",
-            `${process.cwd()}/electron/resources/`
-        ], { "stdio": "inherit" });
-        stream.on("close", (code) => {
-            if (code !== 0) {
-                reject("Failed to remove built resources.");
-            }
-            console.log(pc.green("Successfully remove built resources."));
-            resolve();
-        });
-    });
+import { getElectronVersion, withElectronHost, withElectronPackagerTemp } from "./electron-host.js";
+import { findSteamLaunch, recordSteamPackage, writeSharedSteamDepots } from "./steam.js";
+import { resolveToolPackages } from "./tool-packages.js";
+export const resolveElectronTarget = (platform, arch = "", preview = false) => {
+    const os = platform.replace(/^steam:/, "");
+    const target = { "windows": "win32", "macos": "darwin", "linux": "linux" }[os];
+    if (target !== "win32" && target !== "darwin" && target !== "linux") {
+        throw new Error(`Unsupported Electron platform: ${platform}`);
+    }
+    const cpu = arch || (preview ? process.arch : target === "darwin" ? "universal" : "x64");
+    if (cpu !== "x64" && cpu !== "arm64" && cpu !== "universal") {
+        throw new Error(`Unsupported Electron architecture: ${cpu}`);
+    }
+    if (cpu === "universal" && target !== "darwin") {
+        throw new Error("--arch universal is only supported for macOS.");
+    }
+    if (preview && (target !== process.platform || cpu !== process.arch)) {
+        throw new Error("Electron preview must use the host OS and architecture.");
+    }
+    return { "platform": target, "arch": cpu };
 };
-/**
- * @description ビルドしたリソースをコピー
- *              Copy built resources
- *
- * @return {Promise}
- * @method
- * @private
- */
-const copyResources = () => {
-    return new Promise((resolve, reject) => {
-        const stream = cp.spawn("cp", [
-            "-r",
-            `${ctx.buildDir}/`,
-            `${process.cwd()}/electron/resources`
-        ], { "stdio": "inherit" });
-        stream.on("close", (code) => {
-            if (code !== 0) {
-                reject("Failed to copy built resources.");
-            }
-            console.log(pc.green("Successfully copy built resources."));
-            resolve();
-        });
+const run = (command, args, cwd) => new Promise((resolve, reject) => {
+    const child = $spawn(command, args, { cwd, "stdio": "inherit" });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+        if (code !== 0) {
+            reject(new Error(`${command} failed (${signal || code}).`));
+            return;
+        }
+        resolve();
     });
-};
-/**
- * @description Electron ベースのデスクトップアプリ書き出し関数
- *              (Windows / macOS / Linux、Steam・Epic Games Store 等の配布に共通)。
- *              Export function for Electron-based desktop apps.
- *
- * @return {Promise}
- * @method
- * @public
- */
+});
 export const buildElectron = async () => {
-    // reset
-    await removeResources();
-    // copy HTML, JavaScript
-    await copyResources();
-    if (ctx.preview) {
-        $spawn("npx", [
-            "electron",
-            `${process.cwd()}/electron/index.js`
-        ], { "stdio": "inherit" });
+    const root = process.cwd();
+    const config = readElectronConfig(root);
+    const os = ctx.platform.replace(/^steam:/, "");
+    const target = resolveElectronTarget(ctx.platform, ctx.arch || (ctx.preview ? "" : config.architectures[os]), ctx.preview);
+    if (target.arch === "universal" && process.platform !== "darwin") {
+        throw new Error("Build universal macOS applications on macOS.");
+    }
+    const steam = ctx.platform.startsWith("steam:");
+    const version = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version;
+    const steamRoot = path.resolve(ctx.outDir, "steam");
+    const outDir = path.resolve(ctx.outDir, ctx.platformDir, "build", ctx.environment);
+    if (steam) {
+        // A failed rebuild must not leave a shared manifest pointing at partially replaced files.
+        fs.rmSync(path.join(outDir, "steam-package.json"), { "force": true });
+        writeSharedSteamDepots(steamRoot, ctx.environment, config, version);
     }
-    else {
-        await installElectron();
-        console.log(pc.green("Start the `Electron` build process."));
-        console.log();
-        const packageOptions = {
-            "dir": `${process.cwd()}/electron`,
-            "outDir": `${ctx.outDir}/${ctx.platformDir}/build`,
-            "platform": "",
-            "arch": "all"
-        };
-        switch (ctx.platform) {
-            case "windows":
-            case "steam:windows":
-                packageOptions.platform = "win32";
-                break;
-            case "macos":
-            case "steam:macos":
-                packageOptions.platform = "mas";
-                break;
-            case "linux":
-            case "steam:linux":
-                packageOptions.platform = "linux";
-                break;
-            default:
-                console.log(pc.red("There is an error in the export platform settings."));
-                console.log();
-                process.exit(1);
+    const outputPaths = await withElectronHost(root, ctx.buildDir, config, async (dir) => {
+        const options = createElectronPackagerOptions(root, config, os, path.join(dir, "resources"));
+        if (steam && os === "macos" && !options.osxNotarize) {
+            console.log(pc.yellow("Local macOS build: unsigned/unnotarized builds must not be submitted for Steam release. See docs/steam.md."));
         }
-        api
-            .package(packageOptions)
-            .then(() => {
-            console.log(pc.green(`Finished building \`Electron\` for ${ctx.platform}.`));
-            console.log();
-        })
-            .catch((error) => {
-            console.log(pc.red("Export of Electron failed."));
-            console.log(pc.red(error));
-        });
+        console.log(pc.green(`Packaging Electron (${target.platform}/${target.arch})`));
+        const packages = await resolveToolPackages("electron");
+        const require = createRequire(packages["@electron/packager"]);
+        const { packager } = await import(pathToFileURL(require.resolve("@electron/packager")).href);
+        // The generated host has no npm dependencies or native addons. Packager downloads
+        // the pinned Electron runtime directly and uses its normal download cache.
+        return await withElectronPackagerTemp(async (tmpdir) => await packager({
+            ...options, dir, ...target,
+            tmpdir,
+            "out": outDir,
+            "electronVersion": getElectronVersion(),
+            "overwrite": true,
+            "prune": false
+        }));
+    }, `${os}-${target.arch}`);
+    if (steam) {
+        for (const content of outputPaths) {
+            recordSteamPackage(content, ctx.platform, target.arch, config, version);
+        }
+        writeSharedSteamDepots(steamRoot, ctx.environment, config, version);
+    }
+    console.log(pc.green(`Finished Electron export: ${outDir}`));
+    if (ctx.preview) {
+        const content = outputPaths[0];
+        const launch = findSteamLaunch(content, `steam:${os}`, config.executableName);
+        const executable = target.platform === "darwin"
+            ? path.join(content, launch, "Contents/MacOS", config.executableName)
+            : path.join(content, launch);
+        await run(executable, [], root);
     }
 };

package/dist/index.js

@@ -8,6 +8,11 @@ import { loadConfig, buildWeb } from "./web.js";
 import { buildElectron } from "./electron.js";
 import { runNative, openNative, buildNative } from "./native.js";
 import { buildXbox } from "./xbox.js";
+import fs from "node:fs";
+import path from "node:path";
+import { readElectronConfig } from "./electron-config.js";
+import { writeSharedSteamDepots } from "./steam.js";
+import { uploadSteam } from "./steam-upload.js";
 // Node バージョン検証・引数解析・ctx 初期化 (不正時はここで終了)。
 initCli();
 /**
@@ -65,7 +70,23 @@ const multiBuild = async () => {
  */
 const execute = async () => {
     try {
+        if (ctx.steamUpload) {
+            await uploadSteam({
+                "root": process.cwd(), "steamRoot": ctx.steamRoot || "dist/steam", "environment": ctx.environment,
+                "branch": ctx.steamBranch || undefined, "comment": ctx.steamComment || undefined, "dryRun": ctx.dryRun
+            });
+            return;
+        }
         await loadConfig();
+        if (ctx.steamManifest) {
+            const config = readElectronConfig(process.cwd());
+            const version = JSON.parse(fs.readFileSync("package.json", "utf8")).version;
+            const pending = writeSharedSteamDepots(path.resolve(ctx.outDir, "steam"), ctx.environment, config, version);
+            if (pending.length) {
+                throw new Error(`Shared Steam depots are incomplete. Export or collect all required OS packages first.\n${pending.join("\n")}`);
+            }
+            return;
+        }
         await buildWeb();
         await multiBuild();
     }

package/dist/native.d.ts

@@ -1,27 +1,12 @@
-/**
- * @description iOS用アプリの書き出し関数
- *              Export function for iOS apps
- *
- * @return {Promise}
- * @method
- * @public
- */
+/** Resolve from npm's persistent tool cache without installing into the game. */
+export declare const getCapacitorCommand: () => Promise<{
+    cli: string;
+    env: NodeJS.ProcessEnv;
+}>;
+/** Await every CLI operation so failures propagate to the builder and CI. */
+export declare const runCapacitor: (args: string[], root?: string) => Promise<void>;
+/** Keep native customizations and update web assets/dependency paths in place. */
+export declare const syncNative: () => Promise<void>;
 export declare const runNative: () => Promise<void>;
-/**
- * @description iOS/Androidアプリのオープン関数
- *              Open function for iOS/Android apps
- *
- * @return {Promise}
- * @method
- * @public
- */
 export declare const openNative: () => Promise<void>;
-/**
- * @description iOS/Androidアプリのビルド関数
- *              Build function for iOS/Android apps
- *
- * @return {Promise}
- * @method
- * @public
- */
 export declare const buildNative: () => Promise<void>;

package/dist/native.js

@@ -1,123 +1,65 @@
-// iOS / Android (Capacitor) ビルド。
-import pc from "picocolors";
-import fs from "fs";
+// iOS / Android (Capacitor) ビルド。SDKとCLIはnpxで必要時に取得する。
+import fs from "node:fs";
+import path from "node:path";
 import { ctx } from "./context.js";
 import { $spawn } from "./utils.js";
 import { CAPACITOR_CONFIG_NAME } from "./constants.js";
-/**
- * @description iOS/Androidのプロジェクトを生成
- *              Generate iOS/Android project
- *
- * @return {Promise}
- * @method
- * @private
- */
-const generateNativeProject = () => {
+import { resolveToolPackages } from "./tool-packages.js";
+/** Resolve from npm's persistent tool cache without installing into the game. */
+export const getCapacitorCommand = async () => {
+    const resolved = await resolveToolPackages("capacitor");
+    const packages = ["cli", "core", "ios", "android"].map((name) => resolved[`@capacitor/${name}`]);
+    // Keep the game's cwd for plugin discovery/hooks; supply SDKs through NODE_PATH.
+    const roots = [...new Set(packages.map((file) => path.dirname(path.dirname(path.dirname(file)))))];
+    return {
+        "cli": path.join(path.dirname(packages[0]), "bin", "capacitor"),
+        "env": { ...process.env, "NODE_PATH": [...roots, process.env.NODE_PATH].filter(Boolean).join(path.delimiter) }
+    };
+};
+/** Await every CLI operation so failures propagate to the builder and CI. */
+export const runCapacitor = async (args, root = process.cwd()) => {
+    const { cli, env } = await getCapacitorCommand();
     return new Promise((resolve, reject) => {
-        if (fs.existsSync(`${process.cwd()}/${ctx.platform}`)) {
-            return resolve();
-        }
-        const stream = $spawn("npx", [
-            "cap",
-            "add",
-            ctx.platform
-        ], { "stdio": "inherit" });
-        stream.on("close", (code) => {
+        const child = $spawn(process.execPath, [cli, ...args], { "cwd": root, env, "stdio": "inherit" });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
             if (code !== 0) {
-                reject(`Failed generated ${ctx.platform} project.`);
+                reject(new Error(`Capacitor ${args.join(" ")} failed (${signal || code}).`));
+                return;
             }
-            console.log(pc.green(`Successfully generated ${ctx.platform} project.`));
-            console.log();
             resolve();
         });
     });
 };
-/**
- * @description Capacitor の webDir を現在のビルド出力へ書き換える
- *              Point the Capacitor webDir at the current build output
- *
- * @return {void}
- * @method
- * @private
- */
-const applyCapacitorWebDir = () => {
-    const config = JSON.parse(fs.readFileSync(`${process.cwd()}/${CAPACITOR_CONFIG_NAME}`, { "encoding": "utf8" }));
-    config.webDir = `${ctx.outDir}/${ctx.platformDir}/${ctx.environment}/`;
-    fs.writeFileSync(`${process.cwd()}/${CAPACITOR_CONFIG_NAME}`, JSON.stringify(config, null, 2));
+const prepareNativeProject = async () => {
+    if (ctx.platform !== "ios" && ctx.platform !== "android") {
+        throw new Error(`Unsupported Capacitor platform: ${ctx.platform}`);
+    }
+    const root = process.cwd();
+    const file = path.join(root, CAPACITOR_CONFIG_NAME);
+    const config = JSON.parse(fs.readFileSync(file, "utf8"));
+    // cap add performs an initial sync, so it must see the new webDir too.
+    config.webDir = path.relative(root, path.resolve(ctx.outDir, ctx.platformDir, ctx.environment)).replace(/\\/g, "/") + "/";
+    fs.writeFileSync(file, JSON.stringify(config, null, 2) + "\n");
+    const platformDir = path.resolve(root, config[ctx.platform]?.path ?? ctx.platform);
+    if (!fs.existsSync(platformDir)) {
+        await runCapacitor(["add", ctx.platform]);
+    }
+};
+/** Keep native customizations and update web assets/dependency paths in place. */
+export const syncNative = async () => {
+    await prepareNativeProject();
+    await runCapacitor(["sync", ctx.platform]);
 };
-/**
- * @description iOS用アプリの書き出し関数
- *              Export function for iOS apps
- *
- * @return {Promise}
- * @method
- * @public
- */
 export const runNative = async () => {
-    await generateNativeProject();
-    // Capacitorの書き出しに必要な設定を生成
-    applyCapacitorWebDir();
-    $spawn("npx", [
-        "cap",
-        "run",
-        ctx.platform
-    ], { "stdio": "inherit" });
+    await prepareNativeProject();
+    await runCapacitor(["run", ctx.platform]);
 };
-/**
- * @description iOS/Androidアプリのオープン関数
- *              Open function for iOS/Android apps
- *
- * @return {Promise}
- * @method
- * @public
- */
 export const openNative = async () => {
-    await generateNativeProject();
-    // Capacitorの書き出しに必要な設定を生成
-    applyCapacitorWebDir();
-    const stream = $spawn("npx", [
-        "cap",
-        "sync",
-        ctx.platform
-    ], { "stdio": "inherit" });
-    stream.on("close", (code) => {
-        if (code !== 0) {
-            console.log(pc.red(`Failed to sync ${ctx.platform} project.`));
-            return;
-        }
-        $spawn("npx", [
-            "cap",
-            "open",
-            ctx.platform
-        ], { "stdio": "inherit" });
-    });
+    await syncNative();
+    await runCapacitor(["open", ctx.platform]);
 };
-/**
- * @description iOS/Androidアプリのビルド関数
- *              Build function for iOS/Android apps
- *
- * @return {Promise}
- * @method
- * @public
- */
 export const buildNative = async () => {
-    await generateNativeProject();
-    // Capacitorの書き出しに必要な設定を生成
-    applyCapacitorWebDir();
-    const stream = $spawn("npx", [
-        "cap",
-        "sync",
-        ctx.platform
-    ], { "stdio": "inherit" });
-    stream.on("close", (code) => {
-        if (code !== 0) {
-            console.log(pc.red(`Failed to sync ${ctx.platform} project.`));
-            return;
-        }
-        $spawn("npx", [
-            "cap",
-            "build",
-            ctx.platform
-        ], { "stdio": "inherit" });
-    });
+    await syncNative();
+    await runCapacitor(["build", ctx.platform]);
 };

package/dist/project-vite.d.ts

@@ -0,0 +1,3 @@
+import type * as Vite from "vite";
+/** Resolve from the game, including when builder is launched through npx or a sibling checkout. */
+export declare const loadProjectVite: (root?: string) => Promise<typeof Vite>;

package/dist/project-vite.js

@@ -0,0 +1,21 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+/** Resolve from the game, including when builder is launched through npx or a sibling checkout. */
+export const loadProjectVite = async (root = process.cwd()) => {
+    const require = createRequire(path.join(root, "package.json"));
+    let entry;
+    try {
+        entry = require.resolve("vite");
+    }
+    catch {
+        throw new Error(`Vite is not installed in ${root}. Install the game's dependencies with npm install first.`);
+    }
+    const imported = await import(pathToFileURL(entry).href);
+    // Vite 7's require condition resolves to its CJS API wrapper; Vite 8 is ESM.
+    const vite = imported.default ?? imported;
+    if (typeof vite.loadConfigFromFile !== "function") {
+        throw new Error(`The Vite installation in ${root} does not expose loadConfigFromFile.`);
+    }
+    return vite;
+};

package/dist/resolve-tool-packages.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resolve-tool-packages.js

@@ -0,0 +1,29 @@
+// Runs inside npx, where the downloaded tools' node_modules/.bin is on PATH.
+import fs from "node:fs";
+import path from "node:path";
+const packages = JSON.parse(process.env.NEXT2D_TOOL_PACKAGES);
+let resolved;
+for (const bin of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (path.basename(bin) !== ".bin") {
+        continue;
+    }
+    const files = {};
+    for (const [name, version] of Object.entries(packages)) {
+        const file = path.join(path.dirname(bin), name, "package.json");
+        if (fs.existsSync(file)) {
+            const pkg = JSON.parse(fs.readFileSync(file, "utf8"));
+            if (pkg.name === name && pkg.version === version) {
+                files[name] = file;
+            }
+        }
+    }
+    // All SDKs must come from the same installation, with the requested exact versions.
+    if (Object.keys(files).length === Object.keys(packages).length) {
+        resolved = files;
+        break;
+    }
+}
+if (!resolved) {
+    throw new Error("Could not resolve the requested build tools from npx's PATH.");
+}
+fs.writeFileSync(process.env.NEXT2D_TOOL_RESULT, JSON.stringify(resolved));

package/dist/steam-upload.d.ts

@@ -0,0 +1,27 @@
+export interface ISteamUploadOptions {
+    root: string;
+    steamRoot: string;
+    environment: string;
+    branch?: string;
+    comment?: string;
+    dryRun?: boolean;
+}
+export declare const validateSteamBranch: (branch: unknown) => string;
+/** Recreate manifests from validated package records, never from stale or edited VDF files. */
+export declare const prepareSteamUpload: (options: ISteamUploadOptions) => {
+    appId: string;
+    branch: string;
+    version: string;
+    comment: string;
+    environment: string;
+    dryRun: boolean;
+    manifest: string;
+    launches: {
+        platform: string;
+        arch: string;
+        executable: string;
+        depotId: string;
+    }[];
+};
+/** Use SteamCMD's existing login session; passwords/Steam Guard codes never enter project config. */
+export declare const uploadSteam: (options: ISteamUploadOptions) => Promise<void>;