@mpgd/cli 0.36.0 → 0.36.1

package/dist/native-build-target.js

@@ -1,6 +1,6 @@
 // node_modules/.cache/mpgd-native-build/tools/target/build-target.js
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { cpSync as cpSync4, existsSync as existsSync21, lstatSync as lstatSync10, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, readdirSync as readdirSync7, readFileSync as readFileSync19, realpathSync as realpathSync9, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync13 } from "node:fs";
+import { cpSync as cpSync4, existsSync as existsSync22, lstatSync as lstatSync11, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, readdirSync as readdirSync7, readFileSync as readFileSync20, realpathSync as realpathSync9, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync14 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { basename as basename4, dirname as dirname9, join as join9, relative as relative9, resolve as resolve14 } from "node:path";
 import { loadEnv } from "vite";
@@ -328,8 +328,8 @@ function resolveSecureGamePath(gameRoot, configuredPath) {
   }
   return real;
 }
-function toGameRelativePath(gameRoot, path9) {
-  return relative(realpathSync2(gameRoot), realpathSync2(path9)).split("\\").join("/");
+function toGameRelativePath(gameRoot, path10) {
+  return relative(realpathSync2(gameRoot), realpathSync2(path10)).split("\\").join("/");
 }
 function readAppIconConfig(input, label) {
   assertRecord(input, label);
@@ -350,9 +350,9 @@ function readVariants(input, label) {
   assertRecord(input, label);
   const variants = {};
   for (const name of variantNames) {
-    const path9 = readOptionalString(input[name], `${label}.${name}`);
-    if (path9 !== void 0) {
-      variants[name] = path9;
+    const path10 = readOptionalString(input[name], `${label}.${name}`);
+    if (path10 !== void 0) {
+      variants[name] = path10;
     }
   }
   for (const key of Object.keys(input)) {
@@ -394,38 +394,38 @@ import sharp from "sharp";
 var pngSignature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 var maximumDimension = 8192;
 var maximumPixels = maximumDimension * maximumDimension;
-async function validateBrandImage(path9, options) {
-  const bytes = readFileSync3(path9);
+async function validateBrandImage(path10, options) {
+  const bytes = readFileSync3(path10);
   const format = sniffFormat(bytes);
   if (format === "png" && hasPngChunk(bytes, "acTL")) {
-    throw new Error(`Animated or multi-page brand images are not supported: ${path9}`);
+    throw new Error(`Animated or multi-page brand images are not supported: ${path10}`);
   }
   const warnings = format === "svg" ? validateSvg(bytes, options.strict) : [];
   let metadata;
   try {
     metadata = await sharp(bytes, { animated: true, limitInputPixels: maximumPixels }).metadata();
   } catch (error) {
-    throw new Error(`Invalid brand image ${path9}: ${formatError2(error)}`);
+    throw new Error(`Invalid brand image ${path10}: ${formatError2(error)}`);
   }
   const width = metadata.width;
   const height = metadata.height;
   if (width === void 0 || height === void 0 || width < 1 || height < 1) {
-    throw new Error(`Brand image has no usable dimensions: ${path9}`);
+    throw new Error(`Brand image has no usable dimensions: ${path10}`);
   }
   if (width !== height) {
-    throw new Error(`Brand image must be square, got ${width}x${height}: ${path9}`);
+    throw new Error(`Brand image must be square, got ${width}x${height}: ${path10}`);
   }
   if (width > maximumDimension || height > maximumDimension) {
-    throw new Error(`Brand image exceeds ${maximumDimension}x${maximumDimension}: ${path9}`);
+    throw new Error(`Brand image exceeds ${maximumDimension}x${maximumDimension}: ${path10}`);
   }
   if ((metadata.pages ?? 1) > 1) {
-    throw new Error(`Animated or multi-page brand images are not supported: ${path9}`);
+    throw new Error(`Animated or multi-page brand images are not supported: ${path10}`);
   }
   if (format === "png" && options.minimumSize !== void 0 && width < options.minimumSize) {
-    throw new Error(`PNG brand image must be at least ${options.minimumSize}x${options.minimumSize}; got ${width}x${height}: ${path9}`);
+    throw new Error(`PNG brand image must be at least ${options.minimumSize}x${options.minimumSize}; got ${width}x${height}: ${path10}`);
   }
   return {
-    path: path9,
+    path: path10,
     bytes,
     format,
     width,
@@ -850,28 +850,28 @@ async function verifyGeneratedTargetIcons(result) {
   }
   assertManifestOutputsMatchProfile(result);
   for (const output of result.manifest.outputs) {
-    const path9 = resolve2(result.outputDir, output.path.slice("icons/".length));
-    const bytes = readFileSync4(path9);
+    const path10 = resolve2(result.outputDir, output.path.slice("icons/".length));
+    const bytes = readFileSync4(path10);
     if (sha256(bytes) !== output.sha256) {
-      throw new Error(`Stale generated icon output: ${path9}`);
+      throw new Error(`Stale generated icon output: ${path10}`);
     }
     let metadata;
     try {
       metadata = await sharp2(bytes).metadata();
     } catch {
-      throw new Error(`Generated icon is not a decodable PNG: ${path9}`);
+      throw new Error(`Generated icon is not a decodable PNG: ${path10}`);
     }
     if (metadata.format !== "png" || metadata.width !== output.width || metadata.height !== output.height || (metadata.pages ?? 1) !== 1) {
-      throw new Error(`Generated icon must be a ${output.width}x${output.height} single-page PNG: ${path9}`);
+      throw new Error(`Generated icon must be a ${output.width}x${output.height} single-page PNG: ${path10}`);
     }
     if (await pixelSha256(bytes) !== output.pixelSha256) {
-      throw new Error(`Generated icon pixel digest mismatch: ${path9}`);
+      throw new Error(`Generated icon pixel digest mismatch: ${path10}`);
     }
     if (output.opaque && !await isPngOpaque(bytes)) {
-      throw new Error(`Generated icon expected to be opaque: ${path9}`);
+      throw new Error(`Generated icon expected to be opaque: ${path10}`);
     }
     if (result.profile.id === "devvit" && bytes.byteLength > devvitIconMaximumBytes) {
-      throw new Error(`Devvit marketing icon must be at most ${devvitIconMaximumBytes} bytes: ${path9}`);
+      throw new Error(`Devvit marketing icon must be at most ${devvitIconMaximumBytes} bytes: ${path10}`);
     }
   }
 }
@@ -883,13 +883,13 @@ async function resolveOutputImage(input) {
 }
 async function loadVariantSources(gameRoot, appIcon, strict) {
   const entries = await Promise.all(brandImageVariants.map(async (variant) => {
-    const path9 = appIcon.variants?.[variant];
-    if (path9 === void 0) {
+    const path10 = appIcon.variants?.[variant];
+    if (path10 === void 0) {
       return void 0;
     }
     return [
       variant,
-      await validateBrandImage(resolveSecureGamePath(gameRoot, path9), { strict })
+      await validateBrandImage(resolveSecureGamePath(gameRoot, path10), { strict })
     ];
   }));
   return Object.fromEntries(entries.filter((entry) => entry !== void 0));
@@ -934,14 +934,14 @@ function assertManifestOutputsMatchProfile(result) {
     throw new Error(`Generated icon output count does not match ${result.profile.id} profile.`);
   }
   for (const expected of expectedOutputs) {
-    const path9 = `icons/${expected.file}`;
-    const matches = result.manifest.outputs.filter((output2) => output2.path === path9);
+    const path10 = `icons/${expected.file}`;
+    const matches = result.manifest.outputs.filter((output2) => output2.path === path10);
     if (matches.length !== 1) {
-      throw new Error(`Generated icon manifest must contain exactly one ${path9} output.`);
+      throw new Error(`Generated icon manifest must contain exactly one ${path10} output.`);
     }
     const output = matches[0];
     if (output === void 0 || output.target !== result.target || output.purpose !== expected.purpose || output.width !== expected.width || output.height !== expected.height || output.format !== "png" || output.opaque !== expected.opaque || !/^[0-9a-f]{64}$/u.test(output.sha256) || !/^[0-9a-f]{64}$/u.test(output.pixelSha256)) {
-      throw new Error(`Generated icon manifest output does not match profile: ${path9}`);
+      throw new Error(`Generated icon manifest output does not match profile: ${path10}`);
     }
   }
 }
@@ -1219,8 +1219,8 @@ function indexHtmlLinksExistingManifest(indexFile, manifests) {
 }
 function rootManifestNameFromHref(href) {
   const pathEnd = href.search(/[?#]/u);
-  const path9 = (pathEnd < 0 ? href : href.slice(0, pathEnd)).trim();
-  const rootRelativePath = path9.startsWith("./") ? path9.slice(2) : path9.startsWith("/") ? path9.slice(1) : path9;
+  const path10 = (pathEnd < 0 ? href : href.slice(0, pathEnd)).trim();
+  const rootRelativePath = path10.startsWith("./") ? path10.slice(2) : path10.startsWith("/") ? path10.slice(1) : path10;
   return rootRelativePath.length > 0 && !rootRelativePath.includes("/") && !rootRelativePath.includes("\\") && installableManifestNames.has(rootRelativePath.toLowerCase()) ? rootRelativePath : void 0;
 }
 function readHtmlAttribute(tag, expectedName) {
@@ -1582,25 +1582,25 @@ function assertExistingWebOutputsAreGeneratedArtifacts(outputs) {
   }
 }
 function isPathWithin(root, candidate) {
-  const path9 = relative3(root, candidate);
-  return path9 === "" || path9 !== ".." && !path9.startsWith(`..${sep}`) && !isAbsolute2(path9);
+  const path10 = relative3(root, candidate);
+  return path10 === "" || path10 !== ".." && !path10.startsWith(`..${sep}`) && !isAbsolute2(path10);
 }
 function pathsOverlap(first, second) {
   return isPathWithin(first, second) || isPathWithin(second, first);
 }
-function canonicalizeWebArtifactOutput(path9) {
-  const status = lstatIfPresent(path9);
+function canonicalizeWebArtifactOutput(path10) {
+  const status = lstatIfPresent(path10);
   if (status?.isSymbolicLink() === true) {
-    throw new Error(`Web artifact output must not be a symbolic link: ${path9}`);
+    throw new Error(`Web artifact output must not be a symbolic link: ${path10}`);
   }
   if (status !== void 0 && !status.isDirectory()) {
-    throw new Error(`Web artifact output must be a directory when it already exists: ${path9}`);
+    throw new Error(`Web artifact output must be a directory when it already exists: ${path10}`);
   }
-  return canonicalizeThroughExistingAncestor(path9);
+  return canonicalizeThroughExistingAncestor(path10);
 }
-function lstatIfPresent(path9) {
+function lstatIfPresent(path10) {
   try {
-    return lstatSync2(path9);
+    return lstatSync2(path10);
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -1608,14 +1608,14 @@ function lstatIfPresent(path9) {
     throw error;
   }
 }
-function canonicalizeThroughExistingAncestor(path9) {
-  const normalizedPath = resolve3(path9);
+function canonicalizeThroughExistingAncestor(path10) {
+  const normalizedPath = resolve3(path10);
   const suffix = [];
   let existingAncestor = normalizedPath;
   while (!existsSync4(existingAncestor)) {
     const parent = dirname2(existingAncestor);
     if (parent === existingAncestor) {
-      throw new Error(`Cannot resolve an existing ancestor for web output: ${path9}`);
+      throw new Error(`Cannot resolve an existing ancestor for web output: ${path10}`);
     }
     suffix.unshift(basename(existingAncestor));
     existingAncestor = parent;
@@ -1671,18 +1671,18 @@ function stageWrapperIcon(result, wrapperApp) {
 }
 async function stageNativeIconResources(result, shellApp) {
   const snapshots = /* @__PURE__ */ new Map();
-  const write = (path9, contents) => {
-    if (!snapshots.has(path9)) {
-      snapshots.set(path9, existsSync5(path9) ? readFileSync6(path9) : void 0);
+  const write = (path10, contents) => {
+    if (!snapshots.has(path10)) {
+      snapshots.set(path10, existsSync5(path10) ? readFileSync6(path10) : void 0);
     }
-    mkdirSync3(dirname3(path9), { recursive: true });
-    writeFileSync3(path9, contents);
+    mkdirSync3(dirname3(path10), { recursive: true });
+    writeFileSync3(path10, contents);
   };
-  const remove = (path9) => {
-    if (!snapshots.has(path9)) {
-      snapshots.set(path9, existsSync5(path9) ? readFileSync6(path9) : void 0);
+  const remove = (path10) => {
+    if (!snapshots.has(path10)) {
+      snapshots.set(path10, existsSync5(path10) ? readFileSync6(path10) : void 0);
     }
-    rmSync3(path9, { force: true });
+    rmSync3(path10, { force: true });
   };
   if (result.profile.id === "android-adaptive") {
     await stageAndroid(result, shellApp, write, remove);
@@ -1690,11 +1690,11 @@ async function stageNativeIconResources(result, shellApp) {
     stageIos(result, shellApp, write);
   }
   return () => {
-    for (const [path9, contents] of [...snapshots.entries()].reverse()) {
+    for (const [path10, contents] of [...snapshots.entries()].reverse()) {
       if (contents === void 0) {
-        rmSync3(path9, { force: true });
+        rmSync3(path10, { force: true });
       } else {
-        writeFileSync3(path9, contents);
+        writeFileSync3(path10, contents);
       }
     }
   };
@@ -1767,7 +1767,7 @@ function stageWebManifest(result, gameDist, manifestSourceDirectory) {
     stagedPath,
     publicWebManifestPath,
     publicJsonManifestPath
-  ].find((path9) => existsSync5(path9));
+  ].find((path10) => existsSync5(path10));
   const manifest = manifestPath !== void 0 ? readWebManifest(manifestPath) : {
     name: basename2(result.gameRoot),
     short_name: basename2(result.gameRoot),
@@ -1790,10 +1790,10 @@ function stageWebManifest(result, gameDist, manifestSourceDirectory) {
   }
   ensureInstallableWebManifestLink(gameDist);
 }
-function readWebManifest(path9) {
-  const parsed = JSON.parse(readFileSync6(path9, "utf8"));
+function readWebManifest(path10) {
+  const parsed = JSON.parse(readFileSync6(path10, "utf8"));
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Web app manifest must contain a JSON object: ${path9}`);
+    throw new Error(`Web app manifest must contain a JSON object: ${path10}`);
   }
   return parsed;
 }
@@ -1812,8 +1812,8 @@ function androidAdaptiveXml(hasMonochrome) {
 </adaptive-icon>
 `;
 }
-async function resizePng(path9, size) {
-  return sharp3(path9).resize(size, size, { kernel: sharp3.kernel.lanczos3 }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
+async function resizePng(path10, size) {
+  return sharp3(path10).resize(size, size, { kernel: sharp3.kernel.lanczos3 }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
 }
 function cacheOutputPath(result, output) {
   return resolve4(result.outputDir, basename2(output.path));
@@ -2287,8 +2287,8 @@ function readConfiguredPath(value) {
 import { readFileSync as readFileSync7 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
 import { pathToFileURL } from "node:url";
-function readJsonFile(path9) {
-  return JSON.parse(readFileSync7(resolve5(path9), "utf8"));
+function readJsonFile(path10) {
+  return JSON.parse(readFileSync7(resolve5(path10), "utf8"));
 }
 function isCliEntrypoint(metaUrl) {
   const scriptPath = process.argv[1];
@@ -2442,20 +2442,20 @@ function listMiniGameArtifactFiles(artifactRoot) {
       throw new Error("Mini-game artifact traversal lost its current directory.");
     }
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
-      const path9 = resolve6(directory, entry.name);
-      const stat = lstatSync4(path9);
+      const path10 = resolve6(directory, entry.name);
+      const stat = lstatSync4(path10);
       if (stat.isSymbolicLink()) {
-        throw new Error(`Mini-game artifacts must not contain symbolic links: ${path9}`);
+        throw new Error(`Mini-game artifacts must not contain symbolic links: ${path10}`);
       }
-      const artifactPath = toArtifactRelativePath(root, path9);
+      const artifactPath = toArtifactRelativePath(root, path10);
       assertMiniGameArtifactPathAllowed(artifactPath);
       artifactPaths.push(artifactPath);
       if (stat.isDirectory()) {
-        pending.push(path9);
+        pending.push(path10);
         continue;
       }
       if (!stat.isFile()) {
-        throw new Error(`Mini-game artifacts must contain regular files only: ${path9}`);
+        throw new Error(`Mini-game artifacts must contain regular files only: ${path10}`);
       }
       files.push({ path: artifactPath, bytes: stat.size });
     }
@@ -2465,22 +2465,22 @@ function listMiniGameArtifactFiles(artifactRoot) {
     return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
   });
 }
-function assertMiniGameArtifactRelativePath(path9, label) {
-  const segments = path9.split("/");
-  if (path9.length === 0 || path9.includes("\\") || path9.startsWith("/") || /^[A-Za-z]:/u.test(path9) || isAbsolute3(path9) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..") || segments.some((segment) => /[. ]$/u.test(segment) || /[<>:"|?*\u0000-\u001f]/u.test(segment) || /^(?:con|prn|aux|nul|clock\$|conin\$|conout\$|com[1-9\u00b9\u00b2\u00b3]|lpt[1-9\u00b9\u00b2\u00b3])(?:\..*)?$/iu.test(segment))) {
-    throw new Error(`${label} must be a safe artifact-relative path: ${path9}`);
+function assertMiniGameArtifactRelativePath(path10, label) {
+  const segments = path10.split("/");
+  if (path10.length === 0 || path10.includes("\\") || path10.startsWith("/") || /^[A-Za-z]:/u.test(path10) || isAbsolute3(path10) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..") || segments.some((segment) => /[. ]$/u.test(segment) || /[<>:"|?*\u0000-\u001f]/u.test(segment) || /^(?:con|prn|aux|nul|clock\$|conin\$|conout\$|com[1-9\u00b9\u00b2\u00b3]|lpt[1-9\u00b9\u00b2\u00b3])(?:\..*)?$/iu.test(segment))) {
+    throw new Error(`${label} must be a safe artifact-relative path: ${path10}`);
   }
 }
 function assertMiniGameArtifactPathsPortable(paths) {
   const seen = /* @__PURE__ */ new Map();
-  for (const path9 of paths) {
-    assertMiniGameArtifactRelativePath(path9, "Mini-game artifact path");
-    const portableKey = miniGamePortablePathKey(path9);
+  for (const path10 of paths) {
+    assertMiniGameArtifactRelativePath(path10, "Mini-game artifact path");
+    const portableKey = miniGamePortablePathKey(path10);
     const previous = seen.get(portableKey);
     if (previous !== void 0) {
-      throw new Error(`Mini-game artifact paths collide on portable filesystems: ${previous}, ${path9}.`);
+      throw new Error(`Mini-game artifact paths collide on portable filesystems: ${previous}, ${path10}.`);
     }
-    seen.set(portableKey, path9);
+    seen.set(portableKey, path10);
   }
 }
 function readMiniGameSubpackages(gameConfig) {
@@ -2517,40 +2517,40 @@ function assertSubpackageRoots(subpackages) {
     }
   }
 }
-function resolveArtifactPath(root, path9) {
-  const resolved = resolve6(root, path9);
+function resolveArtifactPath(root, path10) {
+  const resolved = resolve6(root, path10);
   const relativePath = relative4(root, resolved);
   if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith(`..${sep2}`) || isAbsolute3(relativePath)) {
-    throw new Error(`Mini-game path escapes its artifact root: ${path9}`);
+    throw new Error(`Mini-game path escapes its artifact root: ${path10}`);
   }
   try {
     const stat = lstatSync4(resolved);
     if (stat.isSymbolicLink()) {
-      throw new Error(`Mini-game path must not be a symbolic link: ${path9}`);
+      throw new Error(`Mini-game path must not be a symbolic link: ${path10}`);
     }
   } catch (error) {
-    throw new Error(`Mini-game subpackage root does not exist: ${path9} (${formatError4(error)})`);
+    throw new Error(`Mini-game subpackage root does not exist: ${path10} (${formatError4(error)})`);
   }
   return resolved;
 }
-function toArtifactRelativePath(root, path9) {
-  const artifactPath = relative4(root, path9).replaceAll("\\", "/");
+function toArtifactRelativePath(root, path10) {
+  const artifactPath = relative4(root, path10).replaceAll("\\", "/");
   assertMiniGameArtifactRelativePath(artifactPath, "Mini-game artifact file");
   return artifactPath;
 }
-function isInsideRoot(path9, root) {
-  return path9 === root || path9.startsWith(`${root}/`);
+function isInsideRoot(path10, root) {
+  return path10 === root || path10.startsWith(`${root}/`);
 }
-function miniGamePortablePathKey(path9) {
-  return path9.normalize("NFC").toLowerCase();
+function miniGamePortablePathKey(path10) {
+  return path10.normalize("NFC").toLowerCase();
 }
 function assertWithinBudget(actual, maximum, label) {
   if (actual > maximum) {
     throw new Error(`Mini-game ${label} exceeds its package budget: ${String(actual)} > ${String(maximum)} bytes.`);
   }
 }
-function assertMiniGameArtifactPathAllowed(path9) {
-  const segments = path9.split("/");
+function assertMiniGameArtifactPathAllowed(path10) {
+  const segments = path10.split("/");
   const fileName = segments.at(-1) ?? "";
   const normalizedFileName = fileName.toLowerCase();
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
@@ -2564,16 +2564,16 @@ function assertMiniGameArtifactPathAllowed(path9) {
     "tests"
   ]);
   if (normalizedSegments.some((segment) => forbiddenSegments.has(segment))) {
-    throw new Error(`Mini-game artifact contains a forbidden development path: ${path9}`);
+    throw new Error(`Mini-game artifact contains a forbidden development path: ${path10}`);
   }
   if (normalizedFileName === ".ds_store" || normalizedFileName === ".env" || normalizedFileName.startsWith(".env.") || normalizedFileName === ".npmrc" || normalizedFileName === "credentials.json" || normalizedFileName === "project.private.config.json" || /^service-account.*\.json$/iu.test(fileName) || /\.(?:map|jsx|ts|tsx|mts|cts|pem|key|p12|pfx)$/iu.test(fileName)) {
-    throw new Error(`Mini-game artifact contains a forbidden development or credential file: ${path9}`);
+    throw new Error(`Mini-game artifact contains a forbidden development or credential file: ${path10}`);
   }
   if (/\.(?:html?|css|svg)$/iu.test(fileName)) {
-    throw new Error(`Mini-game artifact contains a browser-only asset: ${path9}`);
+    throw new Error(`Mini-game artifact contains a browser-only asset: ${path10}`);
   }
   if (/\.(?:aac|m4a|mp3|ogg|opus|wav|webm)$/iu.test(fileName)) {
-    throw new Error(`Mini-game Canvas MVP does not support audio assets yet: ${path9}`);
+    throw new Error(`Mini-game Canvas MVP does not support audio assets yet: ${path10}`);
   }
 }
 function isRecord2(input) {
@@ -3041,19 +3041,19 @@ var effectiveTargetConfigOutputDirEnv = "MPGD_EFFECTIVE_TARGET_CONFIG_OUTPUT_DIR
 var targetIntegrationConfigKeys = /* @__PURE__ */ new Set([...targetIntegrations, "presentationMode"]);
 var integrationAvailabilityStateSet2 = new Set(integrationAvailabilityStates);
 var presentationModeSet2 = new Set(presentationModes);
-function platformTargetsFilePath(path9 = process.env[platformTargetsFileEnv] ?? "mpgd.targets.json") {
-  return resolve7(path9);
+function platformTargetsFilePath(path10 = process.env[platformTargetsFileEnv] ?? "mpgd.targets.json") {
+  return resolve7(path10);
 }
-function loadPlatformTargetsConfig(path9 = platformTargetsFilePath()) {
-  const resolvedPath = platformTargetsFilePath(path9);
+function loadPlatformTargetsConfig(path10 = platformTargetsFilePath()) {
+  const resolvedPath = platformTargetsFilePath(path10);
   return {
     path: resolvedPath,
     baseDir: dirname4(resolvedPath),
     config: assertPlatformTargetsConfigShape(readJsonFile(resolvedPath))
   };
 }
-function resolveFromPlatformTargetsBase(baseDir, path9) {
-  return isAbsolute4(path9) ? path9 : resolve7(baseDir, path9);
+function resolveFromPlatformTargetsBase(baseDir, path10) {
+  return isAbsolute4(path10) ? path10 : resolve7(baseDir, path10);
 }
 function releaseManifestPath(baseDir = dirname4(platformTargetsFilePath())) {
   return resolveFromPlatformTargetsBase(baseDir, process.env[releaseManifestFileEnv] ?? "artifacts/release-manifest.json");
@@ -4065,14 +4065,14 @@ function writeEffectiveTargetConfigs(options = {}) {
   writeFileSync4(indexPath, indexContent);
   return index;
 }
-function readExistingArtifactIndex(path9, version) {
-  if (!existsSync6(path9)) {
+function readExistingArtifactIndex(path10, version) {
+  if (!existsSync6(path10)) {
     return {
       version,
       artifacts: []
     };
   }
-  const parsed = JSON.parse(readFileSync9(path9, "utf8"));
+  const parsed = JSON.parse(readFileSync9(path10, "utf8"));
   if (parsed.version !== version) {
     return {
       version,
@@ -4083,14 +4083,14 @@ function readExistingArtifactIndex(path9, version) {
 }
 function writeEffectiveTargetConfig(target2, config2, outputDir) {
   assertDeploymentTargetName(target2);
-  const path9 = join4(outputDir, `${target2}.json`);
+  const path10 = join4(outputDir, `${target2}.json`);
   const content = `${JSON.stringify(config2, null, 2)}
 `;
-  mkdirSync4(dirname5(path9), { recursive: true });
-  writeFileSync4(path9, content);
+  mkdirSync4(dirname5(path10), { recursive: true });
+  writeFileSync4(path10, content);
   return {
     target: target2,
-    path: path9,
+    path: path10,
     digest: sha2562(content),
     version: config2.version
   };
@@ -5123,51 +5123,51 @@ function readNativeVersionEvidence(target2) {
   return {};
 }
 function readIconManifestEvidence(artifactPath) {
-  const path9 = readOptionalString2(process.env.MPGD_ICON_MANIFEST_PATH);
-  if (path9 === void 0) {
+  const path10 = readOptionalString2(process.env.MPGD_ICON_MANIFEST_PATH);
+  if (path10 === void 0) {
     throw new Error("MPGD_ICON_MANIFEST_PATH is required when generating a release manifest.");
   }
-  const bytes = readFileBytes(path9);
+  const bytes = readFileBytes(path10);
   const parsed = JSON.parse(bytes.toString("utf8"));
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Invalid icon manifest: ${path9}`);
+    throw new Error(`Invalid icon manifest: ${path10}`);
   }
   const manifest = parsed;
   const canonicalSource = manifest.canonicalSource;
   if (typeof canonicalSource !== "object" || canonicalSource === null || Array.isArray(canonicalSource)) {
-    throw new Error(`Invalid icon manifest canonicalSource: ${path9}`);
+    throw new Error(`Invalid icon manifest canonicalSource: ${path10}`);
   }
   const canonicalSourceRecord = canonicalSource;
   return {
     path: requirePortableArtifactPath(artifactPath),
     digest: createHash4("sha256").update(bytes).digest("hex"),
-    sourceSha256: requireManifestString(canonicalSourceRecord, "sha256", path9),
-    sharedConfigSha256: requireManifestString(manifest, "sharedConfigSha256", path9),
-    renderConfigSha256: requireManifestString(manifest, "renderConfigSha256", path9),
-    generatorVersion: requireManifestString(manifest, "generatorVersion", path9),
-    targetProfile: requireManifestString(manifest, "targetProfile", path9),
-    targetProfileVersion: requireManifestString(manifest, "targetProfileVersion", path9)
+    sourceSha256: requireManifestString(canonicalSourceRecord, "sha256", path10),
+    sharedConfigSha256: requireManifestString(manifest, "sharedConfigSha256", path10),
+    renderConfigSha256: requireManifestString(manifest, "renderConfigSha256", path10),
+    generatorVersion: requireManifestString(manifest, "generatorVersion", path10),
+    targetProfile: requireManifestString(manifest, "targetProfile", path10),
+    targetProfileVersion: requireManifestString(manifest, "targetProfileVersion", path10)
   };
 }
-function requirePortableArtifactPath(path9) {
-  const normalized = path9.replaceAll("\\", "/");
+function requirePortableArtifactPath(path10) {
+  const normalized = path10.replaceAll("\\", "/");
   const segments = normalized.split("/");
-  if (normalized.length === 0 || isAbsolute5(path9) || isAbsolute5(normalized) || /^[A-Za-z]:\//u.test(normalized) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-    throw new Error(`Invalid icon manifest artifact path: ${path9}`);
+  if (normalized.length === 0 || isAbsolute5(path10) || isAbsolute5(normalized) || /^[A-Za-z]:\//u.test(normalized) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    throw new Error(`Invalid icon manifest artifact path: ${path10}`);
   }
   return normalized;
 }
-function readFileBytes(path9) {
+function readFileBytes(path10) {
   try {
-    return readFileSync11(path9);
+    return readFileSync11(path10);
   } catch (error) {
-    throw new Error(`Failed to read icon manifest ${path9}: ${formatError5(error)}`);
+    throw new Error(`Failed to read icon manifest ${path10}: ${formatError5(error)}`);
   }
 }
-function requireManifestString(record, key, path9) {
+function requireManifestString(record, key, path10) {
   const value = record[key];
   if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Invalid icon manifest ${key}: ${path9}`);
+    throw new Error(`Invalid icon manifest ${key}: ${path10}`);
   }
   return value;
 }
@@ -5249,15 +5249,15 @@ function makeEffectiveConfigPathsPortable(manifest, baseDir) {
     ]))
   });
 }
-function toPortablePath(baseDir, path9) {
-  if (!isAbsolute5(path9)) {
-    return path9;
+function toPortablePath(baseDir, path10) {
+  if (!isAbsolute5(path10)) {
+    return path10;
   }
-  const relativePath = relative5(baseDir, path9);
+  const relativePath = relative5(baseDir, path10);
   if (relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute5(relativePath)) {
     return relativePath;
   }
-  return path9;
+  return path10;
 }
 function createBuildId() {
   const now = /* @__PURE__ */ new Date();
@@ -5619,20 +5619,20 @@ function listPrecacheEntries(artifactRoot) {
       throw new Error("PWA artifact traversal lost its directory.");
     }
     for (const entry of readdirSync3(directory, { withFileTypes: true })) {
-      const path9 = resolve9(directory, entry.name);
+      const path10 = resolve9(directory, entry.name);
       if (entry.isSymbolicLink()) {
-        throw new Error(`PWA artifact must not contain symbolic links: ${path9}`);
+        throw new Error(`PWA artifact must not contain symbolic links: ${path10}`);
       }
       if (entry.isDirectory()) {
-        pendingDirectories.push(path9);
+        pendingDirectories.push(path10);
       } else if (entry.isFile()) {
-        files.push(path9);
+        files.push(path10);
       }
     }
   }
-  return files.filter((path9) => !path9.endsWith(".map") && !path9.endsWith(`${sep3}pwa-release.json`) && !path9.endsWith(`${sep3}service-worker.js`)).map((path9) => ({
-    url: toPrecacheUrl(artifactRoot, path9),
-    source: readFileSync12(path9)
+  return files.filter((path10) => !path10.endsWith(".map") && !path10.endsWith(`${sep3}pwa-release.json`) && !path10.endsWith(`${sep3}service-worker.js`)).map((path10) => ({
+    url: toPrecacheUrl(artifactRoot, path10),
+    source: readFileSync12(path10)
   })).sort((left, right) => compareCodeUnits(left.url, right.url));
 }
 function normalizePrecacheEntries(entries) {
@@ -5656,8 +5656,8 @@ function normalizePrecacheUrls(urls) {
   }
   return normalized.sort(compareCodeUnits);
 }
-function toPrecacheUrl(root, path9) {
-  const portablePath = relative6(root, path9).split(sep3).join("/");
+function toPrecacheUrl(root, path10) {
+  const portablePath = relative6(root, path10).split(sep3).join("/");
   return assertMicrosoftStorePwaPrecacheUrl(`./${portablePath}`);
 }
 function requireGameSpecificPwaId(value) {
@@ -6058,23 +6058,23 @@ function pathsOverlap2(first, second) {
   return isPathWithin2(first, second) || isPathWithin2(second, first);
 }
 function isPathWithin2(root, candidate) {
-  const path9 = relative7(root, candidate);
-  return path9 === "" || path9 !== ".." && !path9.startsWith(`..${sep4}`) && !isAbsolute6(path9);
+  const path10 = relative7(root, candidate);
+  return path10 === "" || path10 !== ".." && !path10.startsWith(`..${sep4}`) && !isAbsolute6(path10);
 }
-function portablePathComparisonKey(path9) {
-  const portablePath = path9.replaceAll("\\", "/").split("/").map((segment) => {
+function portablePathComparisonKey(path10) {
+  const portablePath = path10.replaceAll("\\", "/").split("/").map((segment) => {
     return segment === "." || segment === ".." ? segment : segment.replace(/[. ]+$/u, "");
   }).join("/");
   return canonicalizeThroughExistingAncestor2(portablePath).normalize("NFC").toLowerCase();
 }
-function canonicalizeThroughExistingAncestor2(path9) {
-  const normalizedPath = resolve11(path9);
+function canonicalizeThroughExistingAncestor2(path10) {
+  const normalizedPath = resolve11(path10);
   const suffix = [];
   let existingAncestor = normalizedPath;
   while (!existsSync10(existingAncestor)) {
     const parent = dirname6(existingAncestor);
     if (parent === existingAncestor) {
-      throw new Error(`Cannot resolve an existing ancestor for mini-game output: ${path9}`);
+      throw new Error(`Cannot resolve an existing ancestor for mini-game output: ${path10}`);
     }
     suffix.unshift(basename3(existingAncestor));
     existingAncestor = parent;
@@ -6128,8 +6128,8 @@ function cleanupMiniGameArtifactBackup(backupRoot, removeDirectory = removeMiniG
     reportWarning(`The new mini-game artifact is active, but its prior backup could not be removed: ${backupRoot} (${formatError6(error)}). Remove this backup manually.`);
   }
 }
-function removeMiniGameArtifactBackupDirectory(path9) {
-  rmSync5(path9, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 });
+function removeMiniGameArtifactBackupDirectory(path10) {
+  rmSync5(path10, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 });
 }
 function assertMiniGameRequiredFiles(artifactRoot) {
   for (const file of [
@@ -6169,17 +6169,17 @@ function assertMiniGameJavaScriptSafety(artifactRoot, forbiddenMarkers, forbidde
     }
   }
 }
-function assertMiniGameJavaScriptAstSafety(source, path9, forbiddenGlobals) {
+function assertMiniGameJavaScriptAstSafety(source, path10, forbiddenGlobals) {
   let ast;
   try {
     ast = parse(source, {
       ecmaVersion: "latest",
-      sourceType: path9.toLowerCase().endsWith(".mjs") ? "module" : "script",
+      sourceType: path10.toLowerCase().endsWith(".mjs") ? "module" : "script",
       allowHashBang: true,
       allowReturnOutsideFunction: true
     });
   } catch (error) {
-    throw new Error(`Mini-game ${path9} is not valid JavaScript: ${formatError6(error)}`);
+    throw new Error(`Mini-game ${path10} is not valid JavaScript: ${formatError6(error)}`);
   }
   const scopeAnalysis = createMiniGameScopeAnalysis(ast);
   const ancestors = [];
@@ -6194,7 +6194,7 @@ function assertMiniGameJavaScriptAstSafety(source, path9, forbiddenGlobals) {
     if (!isAstRecord(input)) {
       return;
     }
-    assertSafeNode(input, ancestors, path9, scopeAnalysis, forbiddenGlobals);
+    assertSafeNode(input, ancestors, path10, scopeAnalysis, forbiddenGlobals);
     for (const [key, value] of Object.entries(input)) {
       if (key !== "start" && key !== "end" && key !== "loc" && key !== "range") {
         ancestors.push({ node: input, childKey: key });
@@ -6204,57 +6204,57 @@ function assertMiniGameJavaScriptAstSafety(source, path9, forbiddenGlobals) {
     }
   }
 }
-function assertSafeNode(node, ancestors, path9, scopeAnalysis, forbiddenGlobals) {
+function assertSafeNode(node, ancestors, path10, scopeAnalysis, forbiddenGlobals) {
   if (node.type === "ImportExpression") {
-    throw new Error(`Mini-game ${path9} contains forbidden dynamic import.`);
+    throw new Error(`Mini-game ${path10} contains forbidden dynamic import.`);
   }
   const parent = ancestors.at(-1)?.node;
   if (forbiddenGlobals.size > 0 && isMiniGameProtectedIntrinsicMutation(node, ancestors, scopeAnalysis)) {
-    throw new Error(`Mini-game ${path9} contains forbidden protected intrinsic mutation.`);
+    throw new Error(`Mini-game ${path10} contains forbidden protected intrinsic mutation.`);
   }
   if (isMiniGameFunctionNode(node) && (parent?.type === "MethodDefinition" && parent.value === node || parent?.type === "PropertyDefinition" && parent.value === node || parent?.type === "Property" && parent.value === node) && readMiniGameFunctionReturnValues(node).some((value) => {
     return isReturnedDynamicCodeConstructorSource(value, ancestors, scopeAnalysis);
   })) {
-    throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+    throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
   }
   if (node.type === "Identifier" && typeof node.name === "string" && isExecutableIdentifierReference(ancestors)) {
     const scope = scopeAnalysis.scopeByNode.get(node) ?? scopeAnalysis.programScope;
     const binding = resolveMiniGameBinding(node.name, scope);
     if (binding === void 0 && forbiddenGlobals.has(node.name)) {
-      throw new Error(`Mini-game ${path9} contains forbidden platform global ${node.name}.`);
+      throw new Error(`Mini-game ${path10} contains forbidden platform global ${node.name}.`);
     }
     if (binding !== void 0 && isInvocationArgument(node, ancestors) && (scopeAnalysis.dynamicCodeConstructorAliases.has(binding) || scopeAnalysis.dynamicCodeConstructorContainers.has(binding) || scopeAnalysis.dynamicCodeConstructorFactories.has(binding) || scopeAnalysis.dynamicCodeConstructorContainerFactories.has(binding))) {
-      throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
     }
     if (node.name === "eval") {
-      throw new Error(`Mini-game ${path9} contains forbidden eval.`);
+      throw new Error(`Mini-game ${path10} contains forbidden eval.`);
     }
     if (node.name === "Function") {
-      throw new Error(`Mini-game ${path9} contains forbidden Function constructor.`);
+      throw new Error(`Mini-game ${path10} contains forbidden Function constructor.`);
     }
     if (node.name === "importScripts" && !isTypeofReference(node, ancestors)) {
-      throw new Error(`Mini-game ${path9} contains forbidden importScripts.`);
+      throw new Error(`Mini-game ${path10} contains forbidden importScripts.`);
     }
   }
   if (node.type === "MemberExpression") {
     const propertyNames = readMiniGameMemberNames(node, ancestors, scopeAnalysis);
     if (node.computed === true && propertyNames.size === 0 && isGlobalObjectAliasSource(node.object, ancestors, scopeAnalysis) && !isMiniGameSymbolValue(node.property, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden computed global read.`);
+      throw new Error(`Mini-game ${path10} contains forbidden computed global read.`);
     }
     const forbiddenPlatformGlobal = [...propertyNames].find((propertyName) => {
       return forbiddenGlobals.has(propertyName);
     });
     if (forbiddenPlatformGlobal !== void 0) {
-      throw new Error(`Mini-game ${path9} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
+      throw new Error(`Mini-game ${path10} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
     }
     const forbiddenDynamicCodeProperty = [...propertyNames].find((propertyName) => {
       return ["eval", "Function", "importScripts"].includes(propertyName);
     });
     if (forbiddenDynamicCodeProperty !== void 0 && (node.computed === true || isGlobalObjectAliasSource(node.object, ancestors, scopeAnalysis)) && !isTypeofReference(node, ancestors)) {
-      throw new Error(`Mini-game ${path9} contains forbidden ${forbiddenDynamicCodeProperty}.`);
+      throw new Error(`Mini-game ${path10} contains forbidden ${forbiddenDynamicCodeProperty}.`);
     }
     if (isInvocationArgument(node, ancestors) && isDynamicCodeConstructorSource(node, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
     }
   }
   if (node.type === "Property") {
@@ -6264,17 +6264,17 @@ function assertSafeNode(node, ancestors, path9, scopeAnalysis, forbiddenGlobals)
       return forbiddenGlobals.has(propertyName);
     });
     if (isObjectPatternProperty && forbiddenPlatformGlobal !== void 0) {
-      throw new Error(`Mini-game ${path9} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
+      throw new Error(`Mini-game ${path10} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
     }
     if (isGlobalObjectDestructuring(ancestors, scopeAnalysis)) {
       if (node.computed === true) {
-        throw new Error(`Mini-game ${path9} contains forbidden computed destructuring.`);
+        throw new Error(`Mini-game ${path10} contains forbidden computed destructuring.`);
       }
       const forbiddenDynamicCodeProperty = [...propertyNames].find((propertyName) => {
         return ["eval", "Function", "importScripts"].includes(propertyName);
       });
       if (forbiddenDynamicCodeProperty !== void 0) {
-        throw new Error(`Mini-game ${path9} contains forbidden ${forbiddenDynamicCodeProperty} destructuring.`);
+        throw new Error(`Mini-game ${path10} contains forbidden ${forbiddenDynamicCodeProperty} destructuring.`);
       }
     }
   }
@@ -6283,35 +6283,35 @@ function assertSafeNode(node, ancestors, path9, scopeAnalysis, forbiddenGlobals)
     const arguments_ = Array.isArray(node.arguments) ? node.arguments : [];
     const firstArgument = arguments_[0];
     if (isDynamicCodeConstructorInvocation(node.callee, arguments_, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
     }
     if (isUnknownComputedGlobalMember(node.callee, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden computed global call.`);
+      throw new Error(`Mini-game ${path10} contains forbidden computed global call.`);
     }
     if (isReflectiveDynamicCodeGlobalRead(node, ancestors, scopeAnalysis, forbiddenGlobals)) {
-      throw new Error(`Mini-game ${path9} contains forbidden reflective global lookup.`);
+      throw new Error(`Mini-game ${path10} contains forbidden reflective global lookup.`);
     }
     if (calleeNames.has("createElement") && resolveMiniGameStaticStrings(firstArgument, ancestors, scopeAnalysis).has("script")) {
-      throw new Error(`Mini-game ${path9} contains forbidden script element creation.`);
+      throw new Error(`Mini-game ${path10} contains forbidden script element creation.`);
     }
   }
   if (node.type === "NewExpression" && isAstRecord(node.callee)) {
     const calleeNames = readMiniGameMemberNames(node.callee, ancestors, scopeAnalysis);
     if (isDynamicCodeConstructorSource(node.callee, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
     }
     if (isUnknownComputedGlobalMember(node.callee, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path9} contains forbidden computed global construction.`);
+      throw new Error(`Mini-game ${path10} contains forbidden computed global construction.`);
     }
     const forbiddenWorker = [...calleeNames].find((calleeName) => {
       return calleeName === "Worker" || calleeName === "SharedWorker";
     });
     if (forbiddenWorker !== void 0) {
-      throw new Error(`Mini-game ${path9} contains forbidden ${forbiddenWorker} construction.`);
+      throw new Error(`Mini-game ${path10} contains forbidden ${forbiddenWorker} construction.`);
     }
   }
   if (node.type === "TaggedTemplateExpression" && isDynamicCodeConstructorSource(node.tag, ancestors, scopeAnalysis)) {
-    throw new Error(`Mini-game ${path9} contains forbidden dynamic-code constructor.`);
+    throw new Error(`Mini-game ${path10} contains forbidden dynamic-code constructor.`);
   }
 }
 function isInvocationArgument(node, ancestors) {
@@ -8162,10 +8162,10 @@ function createEvidence(input, files, effectiveTargetConfig, iconManifest, packa
     files
   };
 }
-function requireEvidenceFile(artifactRoot, files, path9) {
-  const file = files.find((candidate) => candidate.path === path9);
-  if (file === void 0 || !existsSync10(join5(artifactRoot, path9))) {
-    throw new Error(`Mini-game artifact is missing required evidence file: ${path9}`);
+function requireEvidenceFile(artifactRoot, files, path10) {
+  const file = files.find((candidate) => candidate.path === path10);
+  if (file === void 0 || !existsSync10(join5(artifactRoot, path10))) {
+    throw new Error(`Mini-game artifact is missing required evidence file: ${path10}`);
   }
   return file;
 }
@@ -8239,9 +8239,9 @@ function verifyNamedDigest(artifactRoot, reference, expectedPath, label) {
     throw new Error(`Mini-game artifact ${label} digest mismatch.`);
   }
 }
-function readJson(path9, label) {
+function readJson(path10, label) {
   try {
-    return JSON.parse(readFileSync13(path9, "utf8"));
+    return JSON.parse(readFileSync13(path10, "utf8"));
   } catch (error) {
     throw new Error(`${label} is unreadable: ${formatError6(error)}`);
   }
@@ -8308,8 +8308,8 @@ function assertWechatAppId(appId, production) {
     throw new Error("WeChat Mini Game app id must be a valid AppID or the staging placeholder.");
   }
 }
-function writeJson(path9, input) {
-  writeFileSync9(path9, `${JSON.stringify(input, null, 2)}
+function writeJson(path10, input) {
+  writeFileSync9(path10, `${JSON.stringify(input, null, 2)}
 `);
 }
 
@@ -8425,7 +8425,7 @@ function isProcessAlive(pid) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-execution.js
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, readdirSync as readdirSync6, rmSync as rmSync10, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, readdirSync as readdirSync6, rmSync as rmSync10, statSync as statSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { dirname as dirname8, isAbsolute as isAbsolute9, join as join8 } from "node:path";
 
@@ -9171,16 +9171,73 @@ function createNativeShellStage(input) {
   }
 }
 
+// node_modules/.cache/mpgd-native-build/tools/target/native-shell-csp.js
+import { existsSync as existsSync16, lstatSync as lstatSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "node:fs";
+import path6 from "node:path";
+var capacitorShellContentSecurityPolicy = [
+  "default-src 'self'",
+  "script-src 'self' 'wasm-unsafe-eval'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "font-src 'self' data:",
+  "media-src 'self' data: blob:",
+  "connect-src 'self' https: wss:",
+  "worker-src 'self' blob:",
+  "object-src 'none'",
+  "base-uri 'self'",
+  "form-action 'none'"
+].join("; ");
+var metaTagPattern = /<meta\b[^>]*>/giu;
+var httpEquivPattern = /\bhttp-equiv\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/iu;
+var headOpenPattern = /<head\b[^>]*>/iu;
+function hasEnforcingCspMeta(html) {
+  for (const [tag] of html.matchAll(metaTagPattern)) {
+    const httpEquiv = httpEquivPattern.exec(tag);
+    if (httpEquiv === null) {
+      continue;
+    }
+    const value = httpEquiv[1] ?? httpEquiv[2] ?? httpEquiv[3] ?? "";
+    if (value.toLowerCase() === "content-security-policy") {
+      return true;
+    }
+  }
+  return false;
+}
+var capacitorShellCspMetaTag = `<meta http-equiv="Content-Security-Policy" content="${capacitorShellContentSecurityPolicy}">`;
+function injectCapacitorShellCsp(html) {
+  if (hasEnforcingCspMeta(html)) {
+    return html;
+  }
+  const head = headOpenPattern.exec(html);
+  if (head === null) {
+    throw new Error("Capacitor shell index.html must contain a <head> element for its CSP.");
+  }
+  const insertAt = head.index + head[0].length;
+  return `${html.slice(0, insertAt)}
+${capacitorShellCspMetaTag}${html.slice(insertAt)}`;
+}
+function applyCapacitorShellCsp(webDir) {
+  const indexFile = path6.join(webDir, "index.html");
+  if (!existsSync16(indexFile) || lstatSync9(indexFile).isSymbolicLink()) {
+    throw new Error("Capacitor shell web bundle must contain a regular index.html.");
+  }
+  const html = readFileSync16(indexFile, "utf8");
+  const hardened = injectCapacitorShellCsp(html);
+  if (hardened !== html) {
+    writeFileSync12(indexFile, hardened);
+  }
+}
+
 // node_modules/.cache/mpgd-native-build/tools/target/native-ios-inspection.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync16, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync17, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, rmSync as rmSync9, statSync as statSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 function inspectSignedIosArchive(archive, input) {
-  return inspectSignedIosApplication(path6.join(archive, "Products/Applications/App.app"), input);
+  return inspectSignedIosApplication(path7.join(archive, "Products/Applications/App.app"), input);
 }
 function inspectSignedIosIpa(ipa, input) {
-  if (!existsSync16(ipa) || !statSync4(ipa).isFile()) {
+  if (!existsSync17(ipa) || !statSync4(ipa).isFile()) {
     throw new Error("iOS store IPA is missing.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -9196,24 +9253,24 @@ function inspectSignedIosIpa(ipa, input) {
   if (appManifests.length !== 1) {
     throw new Error("iOS store IPA must contain exactly one app manifest.");
   }
-  const appRelative = path6.dirname(appManifests[0] ?? "");
-  const extracted = mkdtempSync3(path6.join(tmpdir2(), "mpgd-ios-inspection-"));
+  const appRelative = path7.dirname(appManifests[0] ?? "");
+  const extracted = mkdtempSync3(path7.join(tmpdir2(), "mpgd-ios-inspection-"));
   try {
     const result = runner.run("unzip", ["-q", ipa, "-d", extracted]);
     if (result.status !== 0) {
       throw new Error("iOS store IPA could not be extracted.");
     }
-    return inspectSignedIosApplication(path6.join(extracted, appRelative), input);
+    return inspectSignedIosApplication(path7.join(extracted, appRelative), input);
   } finally {
     rmSync9(extracted, { recursive: true, force: true });
   }
 }
 function inspectSignedIosApplication(appPath, input) {
-  const plist = path6.join(appPath, "Info.plist");
-  if (!existsSync16(plist) || !statSync4(plist).isFile()) {
+  const plist = path7.join(appPath, "Info.plist");
+  if (!existsSync17(plist) || !statSync4(plist).isFile()) {
     throw new Error("Signed iOS app manifest is missing.");
   }
-  if (!existsSync16(path6.join(appPath, "Assets.car")) || existsSync16(path6.join(appPath, "Info-Smoke.plist"))) {
+  if (!existsSync17(path7.join(appPath, "Assets.car")) || existsSync17(path7.join(appPath, "Info-Smoke.plist"))) {
     throw new Error("Signed iOS app contains smoke assets or omits release icons.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -9241,21 +9298,21 @@ ${signingInfo.stderr}`;
     return [name, expected];
   }));
   const configFiles = [
-    path6.join(appPath, "capacitor.config.json"),
-    path6.join(appPath, "public/capacitor.config.json")
+    path7.join(appPath, "capacitor.config.json"),
+    path7.join(appPath, "public/capacitor.config.json")
   ];
-  if (!configFiles.some((file) => existsSync16(file))) {
+  if (!configFiles.some((file) => existsSync17(file))) {
     throw new Error("Signed iOS app Capacitor configuration is missing.");
   }
   for (const configFile of configFiles) {
-    if (existsSync16(configFile)) {
+    if (existsSync17(configFile)) {
       assertNoDebugServer(configFile);
     }
   }
   return { ...observed, teamId: input.expectedTeamId, signed: true };
 }
 function assertNoDebugServer(file) {
-  const value = JSON.parse(readFileSync16(file, "utf8"));
+  const value = JSON.parse(readFileSync17(file, "utf8"));
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error("Signed iOS app has malformed Capacitor configuration.");
   }
@@ -9284,8 +9341,8 @@ function runCommand2(command, args) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-ios-signing.js
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync17, statSync as statSync5 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync18, statSync as statSync5 } from "node:fs";
+import path8 from "node:path";
 function resolveIosSigningPlan(environment, mode) {
   const teamId = environment.MPGD_IOS_TEAM_ID?.trim();
   if (teamId === void 0 || !/^[A-Z0-9]{10}$/u.test(teamId)) {
@@ -9318,8 +9375,8 @@ function resolveIosSigningPlan(environment, mode) {
   if (configuredExportFile === void 0 || configuredExportFile.trim() === "") {
     throw new Error("iOS store export requires MPGD_IOS_EXPORT_OPTIONS_PLIST.");
   }
-  const exportOptionsPlist = path7.resolve(configuredExportFile);
-  if (!existsSync17(exportOptionsPlist) || !statSync5(exportOptionsPlist).isFile()) {
+  const exportOptionsPlist = path8.resolve(configuredExportFile);
+  if (!existsSync18(exportOptionsPlist) || !statSync5(exportOptionsPlist).isFile()) {
     throw new Error("iOS export options plist must be an existing host file.");
   }
   const method = spawnSync4("/usr/libexec/PlistBuddy", ["-c", "Print :method", exportOptionsPlist], {
@@ -9333,12 +9390,12 @@ function resolveIosSigningPlan(environment, mode) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-release-identity.js
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
 import { dirname as dirname7, isAbsolute as isAbsolute8, join as join7, relative as relative8, resolve as resolve13 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/capacitor-shell-starter.js
-import { chmodSync as chmodSync2, existsSync as existsSync18, lstatSync as lstatSync9, mkdirSync as mkdirSync10, readdirSync as readdirSync5, readFileSync as readFileSync17, realpathSync as realpathSync8, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "node:fs";
-import path8 from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync19, lstatSync as lstatSync10, mkdirSync as mkdirSync10, readdirSync as readdirSync5, readFileSync as readFileSync18, realpathSync as realpathSync8, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
+import path9 from "node:path";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/native-shell-identity.js
@@ -9720,8 +9777,39 @@ var javaKeywords = new Set(`
   synchronized this throw throws transient try void volatile while true false null record sealed
   permits var yield
 `.trim().split(/\s+/u));
+var androidBackupDomains = ["root", "file", "database", "sharedpref", "external"];
+var androidBackupExcludes = androidBackupDomains.map((domain) => `<exclude domain="${domain}" path="." />`);
+var androidBackupRulesXml = [
+  '<?xml version="1.0" encoding="utf-8"?>',
+  "<!--",
+  "  Generated by mpgd target init capacitor. WebView storage and the",
+  "  game-services SharedPreferences save store hold player data, so the whole",
+  "  private data tree stays out of Android backups.",
+  "-->",
+  "<full-backup-content>",
+  ...androidBackupExcludes.map((line) => `    ${line}`),
+  "</full-backup-content>",
+  ""
+].join("\n");
+var androidDataExtractionRulesXml = [
+  '<?xml version="1.0" encoding="utf-8"?>',
+  "<!--",
+  "  Generated by mpgd target init capacitor. WebView storage and the",
+  "  game-services SharedPreferences save store hold player data, so neither",
+  "  cloud backup nor Android 12+ device-to-device transfer may copy them.",
+  "-->",
+  "<data-extraction-rules>",
+  "    <cloud-backup>",
+  ...androidBackupExcludes.map((line) => `        ${line}`),
+  "    </cloud-backup>",
+  "    <device-transfer>",
+  ...androidBackupExcludes.map((line) => `        ${line}`),
+  "    </device-transfer>",
+  "</data-extraction-rules>",
+  ""
+].join("\n");
 function assertAndroidLauncherClasses(nativeDirectory, gradle) {
-  const application = readAndroidApplication(path8.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
+  const application = readAndroidApplication(path9.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
   if (application === void 0) {
     throw new Error("Existing android project launcher activity is missing.");
   }
@@ -9729,8 +9817,8 @@ function assertAndroidLauncherClasses(nativeDirectory, gradle) {
   const manifestRoot = application.parentNode;
   const manifestPackage = manifestRoot?.getAttribute("package");
   const namespace = /\bnamespace\s*(?:=\s*)?["']([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)["']/u.exec(stripGradleComments(gradle))?.[1] ?? (manifestPackage === null || manifestPackage === "" ? void 0 : manifestPackage);
-  const releaseFile = path8.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-  const release = existsSync18(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
+  const releaseFile = path9.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
+  const release = existsSync19(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
   if (release !== void 0) {
     assertAndroidLauncherEnabled(release, "Release application");
   }
@@ -9840,7 +9928,7 @@ function resolvesAndroidClass(nativeDirectory, qualified, sourceFiles, visited,
     if (!isNativeFile(nativeDirectory, relative10)) {
       continue;
     }
-    const source = stripSourceCommentsAndStrings(readFileSync17(path8.join(nativeDirectory, relative10), "utf8"));
+    const source = stripSourceCommentsAndStrings(readFileSync18(path9.join(nativeDirectory, relative10), "utf8"));
     const declaredPackage = /\bpackage\s+([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)\s*;?/u.exec(source)?.[1];
     if (declaredPackage !== packageName) {
       continue;
@@ -9896,15 +9984,15 @@ function listNativeFiles(nativeDirectory, relativeRoot, extension) {
   const files = [];
   while (pending.length > 0) {
     const relative10 = pending.pop() ?? "";
-    const full = path8.join(nativeDirectory, relative10);
-    if (!existsSync18(full) || lstatSync9(full).isSymbolicLink()) {
+    const full = path9.join(nativeDirectory, relative10);
+    if (!existsSync19(full) || lstatSync10(full).isSymbolicLink()) {
       continue;
     }
     for (const entry of readdirSync5(full, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) {
         continue;
       }
-      const child = path8.join(relative10, entry.name);
+      const child = path9.join(relative10, entry.name);
       if (entry.isDirectory()) {
         pending.push(child);
       } else if (entry.isFile() && entry.name.endsWith(extension)) {
@@ -10110,7 +10198,7 @@ function assertReferencedIosFiles(nativeDirectory, project, infoRelative) {
       throw new Error(`Existing ios project is incomplete; referenced app file ${relative10} is missing.`);
     }
   }
-  const info = readFileSync17(path8.join(nativeDirectory, infoRelative), "utf8");
+  const info = readFileSync18(path9.join(nativeDirectory, infoRelative), "utf8");
   assertSceneDelegateFiles(nativeDirectory, info, "Release", compiledSources);
   return compiledSources;
 }
@@ -10241,7 +10329,7 @@ function readPbxGroupPath(project, parents, referenceId) {
     const groupPath = /\bpath\s*=\s*(?:"([^"]+)"|([^;]+))\s*;/u.exec(group);
     const value = (groupPath?.[1] ?? groupPath?.[2])?.trim();
     if (value !== void 0) {
-      if (value.includes("$") || path8.isAbsolute(value)) {
+      if (value.includes("$") || path9.isAbsolute(value)) {
         throw new Error("Existing ios project build input group path is unsupported.");
       }
       parts.push(value);
@@ -10263,7 +10351,7 @@ function assertPbxFileReference(nativeDirectory, project, referenceId, parentGro
   }
   const relative10 = /\bpath\s*=\s*(?:"([^"]+)"|([^;]+))\s*;/u.exec(reference);
   const filePath = (relative10?.[1] ?? relative10?.[2])?.trim();
-  if (filePath === void 0 || filePath.includes("$") || path8.isAbsolute(filePath)) {
+  if (filePath === void 0 || filePath.includes("$") || path9.isAbsolute(filePath)) {
     throw new Error("Existing ios project App build input path is unsupported.");
   }
   if (filePath === "public" || filePath === "capacitor.config.json") {
@@ -10290,19 +10378,19 @@ function assertPbxFileReference(nativeDirectory, project, referenceId, parentGro
   return [resolved];
 }
 function isNativeEntry(directory, relative10) {
-  const file = path8.resolve(directory, relative10);
-  const within = path8.relative(directory, file);
-  if (within === "" || within.startsWith("..") || path8.isAbsolute(within)) {
+  const file = path9.resolve(directory, relative10);
+  const within = path9.relative(directory, file);
+  if (within === "" || within.startsWith("..") || path9.isAbsolute(within)) {
     return false;
   }
   let current = directory;
-  for (const segment of within.split(path8.sep)) {
-    current = path8.join(current, segment);
-    if (!existsSync18(current) || lstatSync9(current).isSymbolicLink()) {
+  for (const segment of within.split(path9.sep)) {
+    current = path9.join(current, segment);
+    if (!existsSync19(current) || lstatSync10(current).isSymbolicLink()) {
       return false;
     }
   }
-  return lstatSync9(file).isFile() || lstatSync9(file).isDirectory();
+  return lstatSync10(file).isFile() || lstatSync10(file).isDirectory();
 }
 function assertSceneDelegateFiles(nativeDirectory, source, label, compiledSources) {
   const values = parsePlistDictionary(source, label);
@@ -10331,7 +10419,7 @@ function assertSceneDelegateFiles(nativeDirectory, source, label, compiledSource
       if (!compiledSources.has(relative10)) {
         return false;
       }
-      const text = stripSourceCommentsAndStrings(readFileSync17(path8.join(nativeDirectory, relative10), "utf8"));
+      const text = stripSourceCommentsAndStrings(readFileSync18(path9.join(nativeDirectory, relative10), "utf8"));
       return hasUsableTopLevelSwiftSceneDelegate(text, className);
     })) {
       throw new Error(`Existing ios project ${label} scene delegate ${delegate} is missing from App Sources.`);
@@ -10356,29 +10444,29 @@ function hasUsableTopLevelSwiftSceneDelegate(source, className) {
   return false;
 }
 function assertAndroidManifestResources(nativeDirectory) {
-  const manifestFiles = ["main", "release"].map((sourceSet) => path8.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync18(file));
-  const resourceRoots = ["main", "release"].map((sourceSet) => path8.join(nativeDirectory, `app/src/${sourceSet}/res`));
+  const manifestFiles = ["main", "release"].map((sourceSet) => path9.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync19(file));
+  const resourceRoots = ["main", "release"].map((sourceSet) => path9.join(nativeDirectory, `app/src/${sourceSet}/res`));
   const references = manifestFiles.flatMap((file) => {
-    const manifest = readFileSync17(file, "utf8").replace(/<!--[\s\S]*?-->/gu, "");
+    const manifest = readFileSync18(file, "utf8").replace(/<!--[\s\S]*?-->/gu, "");
     return [...manifest.matchAll(/(?<![\w+])@([a-z]+)\/([A-Za-z_][A-Za-z0-9_.]*)/gu)];
   });
   for (const reference of references) {
     const type = reference[1] ?? "";
     const name = reference[2] ?? "";
     const found = resourceRoots.some((resourceRoot) => {
-      if (!existsSync18(resourceRoot)) {
+      if (!existsSync19(resourceRoot)) {
         return false;
       }
       const folders = readdirSync5(resourceRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
       return folders.some((folder) => {
         const densityFallback = (type === "mipmap" || type === "drawable") && new RegExp(`^${type}-(?:ldpi|mdpi|hdpi|xhdpi|xxhdpi|xxxhdpi|nodpi|anydpi)$`, "u").test(folder);
         if (folder === type || densityFallback) {
-          return readdirSync5(path8.join(resourceRoot, folder)).some((file) => file === `${name}.xml` || file.startsWith(`${name}.`));
+          return readdirSync5(path9.join(resourceRoot, folder)).some((file) => file === `${name}.xml` || file.startsWith(`${name}.`));
         }
         if (folder !== "values") {
           return false;
         }
-        return readdirSync5(path8.join(resourceRoot, folder)).some((file) => file.endsWith(".xml") && readAndroidValueResource(path8.join(resourceRoot, folder, file), type, name).length > 0);
+        return readdirSync5(path9.join(resourceRoot, folder)).some((file) => file.endsWith(".xml") && readAndroidValueResource(path9.join(resourceRoot, folder, file), type, name).length > 0);
       });
     });
     if (!found) {
@@ -10391,13 +10479,13 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
   if (platform === "ios" && !isNativeFile(nativeDirectory, relative10)) {
     throw new Error(`Existing ${platform} project is incomplete; native display name resource is missing.`);
   }
-  const source = platform === "ios" ? readFileSync17(path8.join(nativeDirectory, relative10), "utf8") : "";
+  const source = platform === "ios" ? readFileSync18(path9.join(nativeDirectory, relative10), "utf8") : "";
   const labels = platform === "ios" ? [parsePlistDictionary(source, "Release").get("CFBundleDisplayName")].filter((value) => value?.tagName === "string").map((value) => value?.textContent ?? "") : [];
   if (platform === "ios" && (labels.length !== 1 || labels[0] !== expectedDisplayName)) {
     throw new Error(`Existing ${platform} project display name differs or cannot be read safely.`);
   }
   if (platform === "android") {
-    const main = readAndroidApplication(path8.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
+    const main = readAndroidApplication(path9.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
     if (main === void 0) {
       throw new Error("Existing android project application label is missing.");
     }
@@ -10416,8 +10504,8 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
         throw new Error("Existing android project launcher label differs from the requested name.");
       }
     }
-    const overlayFile = path8.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-    if (existsSync18(overlayFile)) {
+    const overlayFile = path9.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
+    if (existsSync19(overlayFile)) {
       const release = readAndroidApplication(overlayFile, false);
       if (release !== void 0) {
         if (hasAndroidMergerDirective(release)) {
@@ -10427,8 +10515,8 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
         if (releaseLabel !== null && resolveAndroidLabel(nativeDirectory, releaseLabel) !== expectedDisplayName) {
           throw new Error("Existing android Release application label differs from the requested name.");
         }
-        const appBuildFile = ["app/build.gradle", "app/build.gradle.kts"].map((relative11) => path8.join(nativeDirectory, relative11)).find((file) => existsSync18(file));
-        const appGradle = appBuildFile === void 0 ? "" : readFileSync17(appBuildFile, "utf8");
+        const appBuildFile = ["app/build.gradle", "app/build.gradle.kts"].map((relative11) => path9.join(nativeDirectory, relative11)).find((file) => existsSync19(file));
+        const appGradle = appBuildFile === void 0 ? "" : readFileSync18(appBuildFile, "utf8");
         const manifestPackage = main.parentNode?.getAttribute("package");
         const namespace = /\bnamespace\s*(?:=\s*)?["']([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)["']/u.exec(stripGradleComments(appGradle))?.[1] ?? (manifestPackage === null || manifestPackage === "" ? void 0 : manifestPackage);
         const launcherNames = /* @__PURE__ */ new Set();
@@ -10464,21 +10552,21 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
   }
 }
 function assertAndroidReleaseDisplayName(shellApp, expectedDisplayName) {
-  const nativeDirectory = path8.join(shellApp, "android");
+  const nativeDirectory = path9.join(shellApp, "android");
   assertAndroidManifestResources(nativeDirectory);
   assertNativeDisplayName(nativeDirectory, "android", expectedDisplayName);
 }
 function assertAndroidReleaseLauncherIntegrity(shellApp) {
-  const nativeDirectory = path8.join(shellApp, "android");
+  const nativeDirectory = path9.join(shellApp, "android");
   const gradleRelative = requireOneNativeFile(nativeDirectory, ["app/build.gradle", "app/build.gradle.kts"], "android");
-  const gradle = readFileSync17(path8.join(nativeDirectory, gradleRelative), "utf8");
+  const gradle = readFileSync18(path9.join(nativeDirectory, gradleRelative), "utf8");
   assertAndroidLauncherClasses(nativeDirectory, gradle);
 }
 function assertIosReleaseDisplayName(shellApp, expectedDisplayName) {
-  const nativeDirectory = path8.join(shellApp, "ios");
-  const projectFile = path8.join(nativeDirectory, "App/App.xcodeproj/project.pbxproj");
-  const project = readFileSync17(projectFile, "utf8");
-  const infoRelative = path8.join("App", readIosReleaseInfoPlist(project));
+  const nativeDirectory = path9.join(shellApp, "ios");
+  const projectFile = path9.join(nativeDirectory, "App/App.xcodeproj/project.pbxproj");
+  const project = readFileSync18(projectFile, "utf8");
+  const infoRelative = path9.join("App", readIosReleaseInfoPlist(project));
   if (!isNativeFile(nativeDirectory, infoRelative)) {
     throw new Error("Existing ios project Release Info.plist is missing or unsafe.");
   }
@@ -10488,20 +10576,20 @@ function assertIosReleaseDisplayName(shellApp, expectedDisplayName) {
 }
 function assertNoIosLocalizedDisplayNameOverride(nativeDirectory, project) {
   const files = listNativeFiles(nativeDirectory, "App/App", ".strings");
-  if (/\bInfoPlist\.strings\b/u.test(project) || isNativeFile(nativeDirectory, "App/InfoPlist.strings") || files.some((relative10) => path8.basename(relative10) === "InfoPlist.strings")) {
+  if (/\bInfoPlist\.strings\b/u.test(project) || isNativeFile(nativeDirectory, "App/InfoPlist.strings") || files.some((relative10) => path9.basename(relative10) === "InfoPlist.strings")) {
     throw new Error("Existing ios project localized InfoPlist.strings overrides are unsupported.");
   }
 }
 function assertIosArchiveScheme(shellApp) {
-  const nativeDirectory = path8.join(shellApp, "ios");
+  const nativeDirectory = path9.join(shellApp, "ios");
   const projectRelative = "App/App.xcodeproj/project.pbxproj";
   const schemeRelative = "App/App.xcodeproj/xcshareddata/xcschemes/App.xcscheme";
   if (!isNativeFile(nativeDirectory, projectRelative) || !isNativeFile(nativeDirectory, schemeRelative)) {
     throw new Error("Existing ios project shared App archive scheme is missing or unsafe.");
   }
-  const project = readFileSync17(path8.join(nativeDirectory, projectRelative), "utf8");
+  const project = readFileSync18(path9.join(nativeDirectory, projectRelative), "utf8");
   const appTargetId = readIosAppTargetId(project);
-  const schemeSource = readFileSync17(path8.join(nativeDirectory, schemeRelative), "utf8");
+  const schemeSource = readFileSync18(path9.join(nativeDirectory, schemeRelative), "utf8");
   const scheme = parseXml(schemeSource, "ios project App archive scheme").documentElement;
   if (scheme?.tagName !== "Scheme") {
     throw new Error("Existing ios project App archive scheme is malformed.");
@@ -10528,7 +10616,7 @@ function hasAndroidMergerDirectiveDeep(element) {
   return hasAndroidMergerDirective(element) || childElements(element).some(hasAndroidMergerDirectiveDeep);
 }
 function readAndroidApplication(file, required = true) {
-  const root = parseXml(readFileSync17(file, "utf8"), "android manifest").documentElement;
+  const root = parseXml(readFileSync18(file, "utf8"), "android manifest").documentElement;
   const application = root === null ? void 0 : childElements(root).find((element) => element.tagName === "application");
   if (root?.tagName !== "manifest" || required && application === void 0) {
     throw new Error("Existing android project manifest application is missing.");
@@ -10556,22 +10644,22 @@ function readAndroidString(nativeDirectory, key) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
     throw new Error("Existing android project application label is unsupported.");
   }
-  const overlay = path8.join(nativeDirectory, "app/src/release/res/values");
-  const overlayValues = existsSync18(overlay) && lstatSync9(overlay).isDirectory() ? readdirSync5(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path8.join(overlay, file), "string", key)) : [];
-  const main = path8.join(nativeDirectory, "app/src/main/res/values");
-  const mainValues = existsSync18(main) && lstatSync9(main).isDirectory() ? readdirSync5(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path8.join(main, file), "string", key)) : [];
+  const overlay = path9.join(nativeDirectory, "app/src/release/res/values");
+  const overlayValues = existsSync19(overlay) && lstatSync10(overlay).isDirectory() ? readdirSync5(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(overlay, file), "string", key)) : [];
+  const main = path9.join(nativeDirectory, "app/src/main/res/values");
+  const mainValues = existsSync19(main) && lstatSync10(main).isDirectory() ? readdirSync5(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(main, file), "string", key)) : [];
   const values = overlayValues.length > 0 ? overlayValues : mainValues;
   if (values.length !== 1) {
     throw new Error("Existing android project application label resource is missing or ambiguous.");
   }
-  const qualified = ["main", "release"].flatMap((sourceSet) => listNativeFiles(nativeDirectory, `app/src/${sourceSet}/res`, ".xml").filter((relative10) => /^values-[^/]+$/u.test(path8.basename(path8.dirname(relative10)))).flatMap((relative10) => readAndroidValueResource(path8.join(nativeDirectory, relative10), "string", key)));
+  const qualified = ["main", "release"].flatMap((sourceSet) => listNativeFiles(nativeDirectory, `app/src/${sourceSet}/res`, ".xml").filter((relative10) => /^values-[^/]+$/u.test(path9.basename(path9.dirname(relative10)))).flatMap((relative10) => readAndroidValueResource(path9.join(nativeDirectory, relative10), "string", key)));
   if (qualified.some((value) => value !== values[0])) {
     throw new Error("Existing android project configuration-qualified application label differs.");
   }
   return values[0] ?? "";
 }
 function readAndroidValueResource(file, type, name) {
-  const root = parseXml(readFileSync17(file, "utf8"), "android values resource").documentElement;
+  const root = parseXml(readFileSync18(file, "utf8"), "android values resource").documentElement;
   if (root?.tagName !== "resources") {
     throw new Error("Existing android values resource is malformed.");
   }
@@ -10631,19 +10719,19 @@ function requireOneNativeFile(directory, candidates, platform) {
   return present[0] ?? "";
 }
 function isNativeFile(directory, relative10) {
-  const file = path8.resolve(directory, relative10);
-  const within = path8.relative(directory, file);
-  if (within === "" || within.startsWith("..") || path8.isAbsolute(within)) {
+  const file = path9.resolve(directory, relative10);
+  const within = path9.relative(directory, file);
+  if (within === "" || within.startsWith("..") || path9.isAbsolute(within)) {
     return false;
   }
   let current = directory;
-  for (const segment of within.split(path8.sep)) {
-    current = path8.join(current, segment);
-    if (!existsSync18(current) || lstatSync9(current).isSymbolicLink()) {
+  for (const segment of within.split(path9.sep)) {
+    current = path9.join(current, segment);
+    if (!existsSync19(current) || lstatSync10(current).isSymbolicLink()) {
       return false;
     }
   }
-  return lstatSync9(file).isFile();
+  return lstatSync10(file).isFile();
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-release-identity.js
@@ -10657,7 +10745,7 @@ function assertNativeReleaseIdentity(input) {
     const candidates = [
       join7(input.shellApp, "android/app/build.gradle"),
       join7(input.shellApp, "android/app/build.gradle.kts")
-    ].filter((file) => existsSync19(file));
+    ].filter((file) => existsSync20(file));
     if (candidates.length !== 1) {
       throw new Error("Android native release requires exactly one Gradle app build file.");
     }
@@ -10809,7 +10897,7 @@ function assertAndroidAppliedScripts(appBuild, androidRoot) {
       throw new Error("Native release preflight cannot resolve an applied Gradle script.");
     }
   };
-  const rootFiles = ["build.gradle", "build.gradle.kts"].map((name) => join7(androidRoot, name)).filter((file) => existsSync19(file));
+  const rootFiles = ["build.gradle", "build.gradle.kts"].map((name) => join7(androidRoot, name)).filter((file) => existsSync20(file));
   if (rootFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android root Gradle build file.");
   }
@@ -10819,7 +10907,7 @@ function assertAndroidAppliedScripts(appBuild, androidRoot) {
   if (/\b(?:afterEvaluate|projectsEvaluated)\b/u.test(rootCode) && /\b(?:project|subprojects|allprojects|android)\b/u.test(rootCode)) {
     throw new Error("Native release preflight cannot resolve root Gradle app callbacks.");
   }
-  const settingsFiles = ["settings.gradle", "settings.gradle.kts"].map((name) => join7(androidRoot, name)).filter((file) => existsSync19(file));
+  const settingsFiles = ["settings.gradle", "settings.gradle.kts"].map((name) => join7(androidRoot, name)).filter((file) => existsSync20(file));
   if (settingsFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android settings Gradle file.");
   }
@@ -11143,10 +11231,10 @@ function stripOptionalQuotes(value) {
   return value;
 }
 function readRequiredFile(file, label) {
-  if (!existsSync19(file)) {
+  if (!existsSync20(file)) {
     throw new Error(`Missing ${label}: ${file}`);
   }
-  return readFileSync18(file, "utf8");
+  return readFileSync19(file, "utf8");
 }
 function requireFinalSemVer2(value, label) {
   const normalized = requireValue(value, label);
@@ -11198,6 +11286,7 @@ async function executeNativeTargetBuild(input) {
   const stage = createNativeShellStage({ shellApp, webDir });
   try {
     input.replaceDirectory(webBundle, stage.webDir);
+    applyCapacitorShellCsp(stage.webDir);
     input.ensureCapacitorPlatform(stage.shellApp, platform, environment);
     await stageNativeIconResources(input.generatedIcons, stage.shellApp);
     runNativeSyncWithIdentityCheck({ ...identityInput, shellApp: stage.shellApp }, () => {
@@ -11246,7 +11335,7 @@ function androidSignedReleaseGradleArgs(environment) {
   if (initScript === void 0 || initScript === "") {
     return ["bundleRelease", "--no-daemon"];
   }
-  if (!isAbsolute9(initScript) || !existsSync20(initScript) || !statSync6(initScript).isFile()) {
+  if (!isAbsolute9(initScript) || !existsSync21(initScript) || !statSync6(initScript).isFile()) {
     throw new Error("Android upload signing init script must be an existing absolute file.");
   }
   return ["bundleRelease", "--no-daemon", "--init-script", initScript];
@@ -11509,7 +11598,7 @@ if (process.env.MPGD_SKIP_BUILD_TARGET_PREFLIGHT !== "1") {
   run("pnpm", ["validate:target-config"], targetScopedEnv);
   run("pnpm", ["validate:effective-config"], targetScopedEnv);
   run("pnpm", ["validate:targets"], targetScopedEnv);
-  run("node", ["tools/run-ttsx.mjs", "tools/package/build-packages.ts"], process.env);
+  run("node", ["tools/run-ttsx.mjs", "tools/package/build-packages.ts", "--reuse-unchanged"], process.env);
 }
 var gameApp = targetPath(target.gameApp);
 var webTargetPaths = target.kind === "web" ? resolveWebTargetPaths(target, targetName) : void 0;
@@ -11737,7 +11826,7 @@ try {
 function createRuntimeTargetConfigMatrixFile(matrix) {
   const directory = mkdtempSync5(join9(tmpdir4(), "mpgd-target-config-matrix-"));
   const file = join9(directory, "matrix.json");
-  writeFileSync13(file, `${JSON.stringify(matrix)}
+  writeFileSync14(file, `${JSON.stringify(matrix)}
 `);
   return file;
 }
@@ -11757,7 +11846,7 @@ function replaceDirectory(source, destination) {
 function mirrorAitRuntimeAssets(gameApp2, wrapperApp) {
   const sourceAssets = `${gameApp2}/dist/assets`;
   const destinationAssets = `${wrapperApp}/public/assets`;
-  if (existsSync21(sourceAssets)) {
+  if (existsSync22(sourceAssets)) {
     replaceDirectory(sourceAssets, destinationAssets);
   } else {
     rmSync11(destinationAssets, { recursive: true, force: true });
@@ -11839,14 +11928,14 @@ function copyIosSyncSwiftPackage(shellApp, releaseArtifact, packageName, swiftPa
 }
 function rewriteIosSyncSwiftPackagePath(releaseArtifact, packageName, swiftPackageName) {
   const packageFile = targetPath(`${releaseArtifact}/App/CapApp-SPM/Package.swift`);
-  const contents = readFileSync19(packageFile, "utf8");
+  const contents = readFileSync20(packageFile, "utf8");
   const originalPath = readSwiftPackagePath(packageFile, swiftPackageName);
   const rewrittenPath = `../../node_modules/${packageName}`;
   const marker = `.package(name: "${swiftPackageName}", path: "`;
-  writeFileSync13(packageFile, contents.replace(`${marker}${originalPath}"`, `${marker}${rewrittenPath}"`));
+  writeFileSync14(packageFile, contents.replace(`${marker}${originalPath}"`, `${marker}${rewrittenPath}"`));
 }
 function readSwiftPackagePath(packageFile, swiftPackageName) {
-  const contents = readFileSync19(packageFile, "utf8");
+  const contents = readFileSync20(packageFile, "utf8");
   const marker = `.package(name: "${swiftPackageName}", path: "`;
   const index = contents.indexOf(marker);
   if (index < 0 || contents.indexOf(marker, index + marker.length) >= 0) {
@@ -11864,7 +11953,7 @@ function copyFile(source, destination) {
   cpSync4(source, destination);
 }
 function removeFilesByExtension(directory, extension) {
-  if (!existsSync21(directory)) {
+  if (!existsSync22(directory)) {
     return;
   }
   for (const file of readdirSync7(directory)) {
@@ -11879,7 +11968,7 @@ function safeArtifactFileStem(value) {
   return stem.length === 0 ? "mpgd-kit" : stem;
 }
 function ensureCapacitorPlatform(shellApp, platform, commandEnv) {
-  if (!existsSync21(`${shellApp}/${platform}`)) {
+  if (!existsSync22(`${shellApp}/${platform}`)) {
     run("pnpm", ["--dir", shellApp, "cap", "add", platform], commandEnv);
   }
 }
@@ -11903,7 +11992,7 @@ function writeManifest(target2, releaseProfile, artifact, commandEnv) {
 function findEmbeddedIconManifestArtifactPath(artifact) {
   const artifactPath = targetPath(artifact);
   const fileName = "mpgd-icon-manifest.json";
-  const matches = statSync7(artifactPath).isDirectory() ? findNamedArtifactFiles(artifactPath, fileName).map((path9) => relative9(artifactPath, path9).replaceAll("\\", "/")) : listZipEntries(artifactPath).filter((entry) => basename4(entry) === fileName);
+  const matches = statSync7(artifactPath).isDirectory() ? findNamedArtifactFiles(artifactPath, fileName).map((path10) => relative9(artifactPath, path10).replaceAll("\\", "/")) : listZipEntries(artifactPath).filter((entry) => basename4(entry) === fileName);
   if (matches.length !== 1) {
     throw new Error(`Expected exactly one ${fileName} in release artifact ${artifactPath}; found ${matches.length}.`);
   }
@@ -11916,21 +12005,21 @@ function findEmbeddedIconManifestArtifactPath(artifact) {
 function findNamedArtifactFiles(root, fileName) {
   const matches = [];
   for (const entry of readdirSync7(root)) {
-    const path9 = join9(root, entry);
-    const stat = lstatSync10(path9);
+    const path10 = join9(root, entry);
+    const stat = lstatSync11(path10);
     if (stat.isSymbolicLink()) {
       continue;
     }
     if (stat.isDirectory()) {
-      matches.push(...findNamedArtifactFiles(path9, fileName));
+      matches.push(...findNamedArtifactFiles(path10, fileName));
     } else if (stat.isFile() && entry === fileName) {
-      matches.push(path9);
+      matches.push(path10);
     }
   }
   return matches;
 }
-function listZipEntries(path9) {
-  const result = spawnSync5("unzip", ["-Z1", path9], {
+function listZipEntries(path10) {
+  const result = spawnSync5("unzip", ["-Z1", path10], {
     cwd: process.cwd(),
     env: nativeInspectionEnvironment(),
     encoding: "utf8"
@@ -11940,7 +12029,7 @@ function listZipEntries(path9) {
   }
   const toleratedPrefixWarning = result.status === 1 && result.stdout.trim().length > 0 && result.stderr.includes("extra bytes at beginning or within zipfile") && result.stderr.includes("(attempting to process anyway)");
   if (result.status !== 0 && !toleratedPrefixWarning) {
-    throw new Error(`Failed to list release artifact ${path9}: ${result.stderr.trim() || `exit ${String(result.status)}`}`);
+    throw new Error(`Failed to list release artifact ${path10}: ${result.stderr.trim() || `exit ${String(result.status)}`}`);
   }
   return result.stdout.split("\n").filter((entry) => entry.length > 0);
 }
@@ -11967,7 +12056,7 @@ function isMiniGameTarget(target2) {
 }
 function buildMiniGameBundle(bundleKind, outputDir, stagingRoot, gameApp2, profile2, commandEnv) {
   const viteConfig = join9(gameApp2, "vite.minigame.config.ts");
-  if (!existsSync21(viteConfig)) {
+  if (!existsSync22(viteConfig)) {
     throw new Error(`Mini-game target requires a game-owned vite.minigame.config.ts: ${viteConfig}`);
   }
   run("pnpm", ["exec", "vite", "build", "--config", "vite.minigame.config.ts", "--mode", profile2], {
@@ -11999,8 +12088,8 @@ function withProcessEnv(env2, keys, callback) {
     }
   }
 }
-function targetPath(path9) {
-  return resolveFromPlatformTargetsBase(configBaseDir, path9);
+function targetPath(path10) {
+  return resolveFromPlatformTargetsBase(configBaseDir, path10);
 }
 function findFileByExtension(directory, extension) {
   const files = readdirSync7(directory).filter((file) => file.endsWith(extension)).sort();