@mpgd/cli 0.61.1 → 0.62.0

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 existsSync27, lstatSync as lstatSync15, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync5, readdirSync as readdirSync9, readFileSync as readFileSync26, realpathSync as realpathSync10, rmSync as rmSync12, statSync as statSync7, writeFileSync as writeFileSync18 } from "node:fs";
+import { cpSync as cpSync4, existsSync as existsSync28, lstatSync as lstatSync16, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync5, readdirSync as readdirSync10, readFileSync as readFileSync26, realpathSync as realpathSync10, rmSync as rmSync12, statSync as statSync8, writeFileSync as writeFileSync18 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { basename as basename5, dirname as dirname12, join as join16, relative as relative13, resolve as resolve18 } from "node:path";
 import { loadEnv } from "vite";
@@ -43,8 +43,8 @@ var knownMediaTypes = /* @__PURE__ */ new Map([
   ["aac", { mediaType: "audio/aac", defaultMethod: "store" }],
   ["flac", { mediaType: "audio/flac", defaultMethod: "store" }]
 ]);
-function phaserPackMediaTypeForPath(path12) {
-  const extension = path12.slice(path12.lastIndexOf(".") + 1).toLowerCase();
+function phaserPackMediaTypeForPath(path13) {
+  const extension = path13.slice(path13.lastIndexOf(".") + 1).toLowerCase();
   return knownMediaTypes.get(extension) ?? null;
 }
 function parsePhaserPackEntryPath(input) {
@@ -677,9 +677,9 @@ var manifestFileName = "asset-pack-delivery.json";
 var stagingSequence = 0;
 var sha256Of = (data) => createHash("sha256").update(data).digest("hex");
 function realpathBestEffort(target2) {
-  const exists = (path12) => {
+  const exists = (path13) => {
     try {
-      lstatSync(path12);
+      lstatSync(path13);
       return true;
     } catch {
       return false;
@@ -915,11 +915,11 @@ function buildAssetPacks(options) {
 `, "utf8");
   validatePhaserPackDeliveryManifest(JSON.parse(manifestBytes.toString("utf8")));
   const outputRecords = [];
-  for (const [path12, data] of outputs) {
-    const target2 = join(outPath, path12);
+  for (const [path13, data] of outputs) {
+    const target2 = join(outPath, path13);
     if (!existsSync(target2)) {
       outputRecords.push({
-        path: path12,
+        path: path13,
         bytes: data.length,
         sha256: sha256Of(data),
         action: "written",
@@ -931,13 +931,13 @@ function buildAssetPacks(options) {
     try {
       existing = readFileSync(target2);
     } catch {
-      throw new Error(`Output path is not a readable file: ${path12}`);
+      throw new Error(`Output path is not a readable file: ${path13}`);
     }
     if (!existing.equals(data)) {
-      throw new Error(`Output path already holds different bytes (immutable conflict): ${path12}. Change the pack content or revision, or build into a new directory.`);
+      throw new Error(`Output path already holds different bytes (immutable conflict): ${path13}. Change the pack content or revision, or build into a new directory.`);
     }
     outputRecords.push({
-      path: path12,
+      path: path13,
       bytes: data.length,
       sha256: sha256Of(data),
       action: "unchanged",
@@ -1566,7 +1566,7 @@ var positiveIntegerOption = (failures, name, value) => {
 };
 var VerifyDeadlineError = class extends Error {
 };
-var streamSha256 = async (path12, handle, hasher, deadline) => {
+var streamSha256 = async (path13, handle, hasher, deadline) => {
   let bytes = 0;
   const stream = handle.createReadStream({
     highWaterMark: STREAM_CHUNK_BYTES,
@@ -1586,7 +1586,7 @@ var streamSha256 = async (path12, handle, hasher, deadline) => {
     if (error instanceof VerifyDeadlineError) {
       throw error;
     }
-    throw new Error(`Could not read ${path12}: ${errorText(error)}`);
+    throw new Error(`Could not read ${path13}: ${errorText(error)}`);
   } finally {
     clearTimeout(timer);
   }
@@ -1802,20 +1802,20 @@ var readManifestCapped = async (manifestPath, cap, deadline) => {
   }
   return Buffer.concat(chunks);
 };
-var readExact = async (path12, handle, bytes, deadline) => {
+var readExact = async (path13, handle, bytes, deadline) => {
   const buffer = Buffer.alloc(bytes);
   let received = 0;
   while (received < bytes) {
     const { bytesRead } = await deadline.race(handle.read(buffer, received, bytes - received, received));
     if (bytesRead === 0) {
-      throw new Error(`Archive shrank while being read: ${path12}`);
+      throw new Error(`Archive shrank while being read: ${path13}`);
     }
     received += bytesRead;
   }
   const tail = Buffer.alloc(1);
   const { bytesRead: tailBytes } = await deadline.race(handle.read(tail, 0, 1, bytes));
   if (tailBytes !== 0) {
-    throw new Error(`Archive grew while being read: ${path12}`);
+    throw new Error(`Archive grew while being read: ${path13}`);
   }
   return buffer;
 };
@@ -2269,9 +2269,9 @@ var assetPackTargetNamespace = "mpgd-asset-packs";
 var assetPackTargetManifestName = "asset-pack-delivery.json";
 var assetPackTargetPolicyName = "target-policy.json";
 var digest = (bytes) => createHash3("sha256").update(bytes).digest("hex");
-async function fileDigest(path12) {
+async function fileDigest(path13) {
   const hash = createHash3("sha256");
-  for await (const chunk of createReadStream(path12)) {
+  for await (const chunk of createReadStream(path13)) {
     hash.update(chunk);
   }
   return hash.digest("hex");
@@ -2280,8 +2280,8 @@ function inside(parent, child) {
   const step = relative3(parent, child);
   return step === "" || !isAbsolute3(step) && step !== ".." && !step.startsWith(`..${sep3}`);
 }
-async function noSymlink(path12) {
-  let current = resolve3(path12);
+async function noSymlink(path13) {
+  let current = resolve3(path13);
   while (true) {
     const stat2 = await lstat2(current).catch((error) => {
       if (error.code === "ENOENT") {
@@ -2292,7 +2292,7 @@ async function noSymlink(path12) {
     if (stat2?.isSymbolicLink()) {
       const systemAlias = process.platform === "darwin" && (current === "/var" && await realpath2(current) === "/private/var" || current === "/tmp" && await realpath2(current) === "/private/tmp");
       if (!systemAlias) {
-        throw new Error(`Asset target path must not traverse a symbolic link: ${path12}`);
+        throw new Error(`Asset target path must not traverse a symbolic link: ${path13}`);
       }
     }
     const parent = dirname2(current);
@@ -2302,12 +2302,12 @@ async function noSymlink(path12) {
     current = parent;
   }
 }
-async function canonicalOutput(path12) {
-  let ancestor = path12;
+async function canonicalOutput(path13) {
+  let ancestor = path13;
   while (true) {
     try {
       const canonical = await realpath2(ancestor);
-      return resolve3(canonical, relative3(ancestor, path12));
+      return resolve3(canonical, relative3(ancestor, path13));
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
@@ -2459,18 +2459,18 @@ async function assertAssetPackTargetArtifact(report, artifactRoot, namespacePath
   while (pending.length) {
     const directory = pending.pop();
     for (const entry of await readdir(directory, { withFileTypes: true })) {
-      const path12 = join3(directory, entry.name);
+      const path13 = join3(directory, entry.name);
       if (++count > 1e5 || entry.isSymbolicLink()) {
         throw new Error("Asset artifact inventory exceeds its limit or contains a symbolic link");
       }
       if (entry.isDirectory()) {
-        pending.push(path12);
+        pending.push(path13);
       } else if (entry.isFile()) {
-        if (inside(namespace, path12)) {
-          namespaceBytes += (await lstat2(path12)).size;
+        if (inside(namespace, path13)) {
+          namespaceBytes += (await lstat2(path13)).size;
         }
-        if (remoteHashes.has(await fileDigest(path12))) {
-          throw new Error(`Remote-only asset object is present in the packaged artifact: ${relative3(root, path12)}`);
+        if (remoteHashes.has(await fileDigest(path13))) {
+          throw new Error(`Remote-only asset object is present in the packaged artifact: ${relative3(root, path13)}`);
         }
       } else {
         throw new Error("Asset artifact contains a non-regular entry");
@@ -2512,14 +2512,14 @@ function expectedNamespace(artifact, namespace) {
   }
 }
 async function assertAssetPackNativeArtifact(report, artifact) {
-  const path12 = resolve4(artifact);
-  const stat2 = await lstat3(path12);
+  const path13 = resolve4(artifact);
+  const stat2 = await lstat3(path13);
   if (stat2.isSymbolicLink()) {
     throw new Error("Native asset artifact must not be a symbolic link");
   }
   if (stat2.isDirectory()) {
     const candidates = [];
-    const pending = [path12];
+    const pending = [path13];
     let entries = 0;
     while (pending.length) {
       const directory = pending.pop();
@@ -2531,17 +2531,17 @@ async function assertAssetPackNativeArtifact(report, artifact) {
         if (entry.isDirectory()) {
           pending.push(file);
         } else if (entry.name === assetPackTargetManifestName && basename(directory) === assetPackTargetNamespace) {
-          candidates.push(relative4(path12, directory));
+          candidates.push(relative4(path13, directory));
         }
       }
     }
     if (candidates.length !== 1) {
       throw new Error("Native asset artifact requires exactly one packaged pack namespace");
     }
-    if (!expectedNamespace(path12, candidates[0].replaceAll("\\", "/") + "/")) {
+    if (!expectedNamespace(path13, candidates[0].replaceAll("\\", "/") + "/")) {
       throw new Error("Native asset namespace is outside the platform web bundle");
     }
-    await assertAssetPackTargetArtifact(report, path12, candidates[0]);
+    await assertAssetPackTargetArtifact(report, path13, candidates[0]);
     return;
   }
   if (!stat2.isFile() || stat2.size > 2 * 1024 ** 3) {
@@ -2552,7 +2552,7 @@ async function assertAssetPackNativeArtifact(report, artifact) {
   const files = /* @__PURE__ */ new Map();
   let expanded = 0;
   let entryCount = 0;
-  const archive = await openPromise(path12, {
+  const archive = await openPromise(path13, {
     lazyEntries: true,
     strictFileNames: true,
     validateEntrySizes: true
@@ -2600,7 +2600,7 @@ async function assertAssetPackNativeArtifact(report, artifact) {
     throw new Error("Native asset package requires exactly one packaged pack namespace");
   }
   const namespace = namespaces[0];
-  if (!expectedNamespace(path12, namespace)) {
+  if (!expectedNamespace(path13, namespace)) {
     throw new Error("Native asset namespace is outside the platform web bundle");
   }
   const namespaceBytes = [...files].filter(([name]) => name.startsWith(namespace)).reduce((sum, [, file]) => sum + file.bytes, 0);
@@ -2942,8 +2942,8 @@ function resolveSecureGamePath(gameRoot, configuredPath) {
   }
   return real;
 }
-function toGameRelativePath(gameRoot, path12) {
-  return relative5(realpathSync3(gameRoot), realpathSync3(path12)).split("\\").join("/");
+function toGameRelativePath(gameRoot, path13) {
+  return relative5(realpathSync3(gameRoot), realpathSync3(path13)).split("\\").join("/");
 }
 function readAppIconConfig(input, label) {
   assertRecord(input, label);
@@ -2964,9 +2964,9 @@ function readVariants(input, label) {
   assertRecord(input, label);
   const variants = {};
   for (const name of variantNames) {
-    const path12 = readOptionalString(input[name], `${label}.${name}`);
-    if (path12 !== void 0) {
-      variants[name] = path12;
+    const path13 = readOptionalString(input[name], `${label}.${name}`);
+    if (path13 !== void 0) {
+      variants[name] = path13;
     }
   }
   for (const key of Object.keys(input)) {
@@ -3008,38 +3008,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(path12, options) {
-  const bytes = readFileSync4(path12);
+async function validateBrandImage(path13, options) {
+  const bytes = readFileSync4(path13);
   const format = sniffFormat(bytes);
   if (format === "png" && hasPngChunk(bytes, "acTL")) {
-    throw new Error(`Animated or multi-page brand images are not supported: ${path12}`);
+    throw new Error(`Animated or multi-page brand images are not supported: ${path13}`);
   }
   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 ${path12}: ${formatError2(error)}`);
+    throw new Error(`Invalid brand image ${path13}: ${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: ${path12}`);
+    throw new Error(`Brand image has no usable dimensions: ${path13}`);
   }
   if (width !== height) {
-    throw new Error(`Brand image must be square, got ${width}x${height}: ${path12}`);
+    throw new Error(`Brand image must be square, got ${width}x${height}: ${path13}`);
   }
   if (width > maximumDimension || height > maximumDimension) {
-    throw new Error(`Brand image exceeds ${maximumDimension}x${maximumDimension}: ${path12}`);
+    throw new Error(`Brand image exceeds ${maximumDimension}x${maximumDimension}: ${path13}`);
   }
   if ((metadata.pages ?? 1) > 1) {
-    throw new Error(`Animated or multi-page brand images are not supported: ${path12}`);
+    throw new Error(`Animated or multi-page brand images are not supported: ${path13}`);
   }
   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}: ${path12}`);
+    throw new Error(`PNG brand image must be at least ${options.minimumSize}x${options.minimumSize}; got ${width}x${height}: ${path13}`);
   }
   return {
-    path: path12,
+    path: path13,
     bytes,
     format,
     width,
@@ -3464,28 +3464,28 @@ async function verifyGeneratedTargetIcons(result) {
   }
   assertManifestOutputsMatchProfile(result);
   for (const output of result.manifest.outputs) {
-    const path12 = resolve6(result.outputDir, output.path.slice("icons/".length));
-    const bytes = readFileSync5(path12);
+    const path13 = resolve6(result.outputDir, output.path.slice("icons/".length));
+    const bytes = readFileSync5(path13);
     if (sha256(bytes) !== output.sha256) {
-      throw new Error(`Stale generated icon output: ${path12}`);
+      throw new Error(`Stale generated icon output: ${path13}`);
     }
     let metadata;
     try {
       metadata = await sharp2(bytes).metadata();
     } catch {
-      throw new Error(`Generated icon is not a decodable PNG: ${path12}`);
+      throw new Error(`Generated icon is not a decodable PNG: ${path13}`);
     }
     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: ${path12}`);
+      throw new Error(`Generated icon must be a ${output.width}x${output.height} single-page PNG: ${path13}`);
     }
     if (await pixelSha256(bytes) !== output.pixelSha256) {
-      throw new Error(`Generated icon pixel digest mismatch: ${path12}`);
+      throw new Error(`Generated icon pixel digest mismatch: ${path13}`);
     }
     if (output.opaque && !await isPngOpaque(bytes)) {
-      throw new Error(`Generated icon expected to be opaque: ${path12}`);
+      throw new Error(`Generated icon expected to be opaque: ${path13}`);
     }
     if (result.profile.id === "devvit" && bytes.byteLength > devvitIconMaximumBytes) {
-      throw new Error(`Devvit marketing icon must be at most ${devvitIconMaximumBytes} bytes: ${path12}`);
+      throw new Error(`Devvit marketing icon must be at most ${devvitIconMaximumBytes} bytes: ${path13}`);
     }
   }
 }
@@ -3497,13 +3497,13 @@ async function resolveOutputImage(input) {
 }
 async function loadVariantSources(gameRoot, appIcon, strict) {
   const entries = await Promise.all(brandImageVariants.map(async (variant) => {
-    const path12 = appIcon.variants?.[variant];
-    if (path12 === void 0) {
+    const path13 = appIcon.variants?.[variant];
+    if (path13 === void 0) {
       return void 0;
     }
     return [
       variant,
-      await validateBrandImage(resolveSecureGamePath(gameRoot, path12), { strict })
+      await validateBrandImage(resolveSecureGamePath(gameRoot, path13), { strict })
     ];
   }));
   return Object.fromEntries(entries.filter((entry) => entry !== void 0));
@@ -3548,14 +3548,14 @@ function assertManifestOutputsMatchProfile(result) {
     throw new Error(`Generated icon output count does not match ${result.profile.id} profile.`);
   }
   for (const expected of expectedOutputs) {
-    const path12 = `icons/${expected.file}`;
-    const matches = result.manifest.outputs.filter((output2) => output2.path === path12);
+    const path13 = `icons/${expected.file}`;
+    const matches = result.manifest.outputs.filter((output2) => output2.path === path13);
     if (matches.length !== 1) {
-      throw new Error(`Generated icon manifest must contain exactly one ${path12} output.`);
+      throw new Error(`Generated icon manifest must contain exactly one ${path13} 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: ${path12}`);
+      throw new Error(`Generated icon manifest output does not match profile: ${path13}`);
     }
   }
 }
@@ -3833,8 +3833,8 @@ function indexHtmlLinksExistingManifest(indexFile, manifests) {
 }
 function rootManifestNameFromHref(href) {
   const pathEnd = href.search(/[?#]/u);
-  const path12 = (pathEnd < 0 ? href : href.slice(0, pathEnd)).trim();
-  const rootRelativePath = path12.startsWith("./") ? path12.slice(2) : path12.startsWith("/") ? path12.slice(1) : path12;
+  const path13 = (pathEnd < 0 ? href : href.slice(0, pathEnd)).trim();
+  const rootRelativePath = path13.startsWith("./") ? path13.slice(2) : path13.startsWith("/") ? path13.slice(1) : path13;
   return rootRelativePath.length > 0 && !rootRelativePath.includes("/") && !rootRelativePath.includes("\\") && installableManifestNames.has(rootRelativePath.toLowerCase()) ? rootRelativePath : void 0;
 }
 function readHtmlAttribute(tag, expectedName) {
@@ -4196,25 +4196,25 @@ function assertExistingWebOutputsAreGeneratedArtifacts(outputs) {
   }
 }
 function isPathWithin(root, candidate) {
-  const path12 = relative7(root, candidate);
-  return path12 === "" || path12 !== ".." && !path12.startsWith(`..${sep4}`) && !isAbsolute5(path12);
+  const path13 = relative7(root, candidate);
+  return path13 === "" || path13 !== ".." && !path13.startsWith(`..${sep4}`) && !isAbsolute5(path13);
 }
 function pathsOverlap(first, second) {
   return isPathWithin(first, second) || isPathWithin(second, first);
 }
-function canonicalizeWebArtifactOutput(path12) {
-  const status = lstatIfPresent(path12);
+function canonicalizeWebArtifactOutput(path13) {
+  const status = lstatIfPresent(path13);
   if (status?.isSymbolicLink() === true) {
-    throw new Error(`Web artifact output must not be a symbolic link: ${path12}`);
+    throw new Error(`Web artifact output must not be a symbolic link: ${path13}`);
   }
   if (status !== void 0 && !status.isDirectory()) {
-    throw new Error(`Web artifact output must be a directory when it already exists: ${path12}`);
+    throw new Error(`Web artifact output must be a directory when it already exists: ${path13}`);
   }
-  return canonicalizeThroughExistingAncestor(path12);
+  return canonicalizeThroughExistingAncestor(path13);
 }
-function lstatIfPresent(path12) {
+function lstatIfPresent(path13) {
   try {
-    return lstatSync3(path12);
+    return lstatSync3(path13);
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -4222,14 +4222,14 @@ function lstatIfPresent(path12) {
     throw error;
   }
 }
-function canonicalizeThroughExistingAncestor(path12) {
-  const normalizedPath = resolve7(path12);
+function canonicalizeThroughExistingAncestor(path13) {
+  const normalizedPath = resolve7(path13);
   const suffix = [];
   let existingAncestor = normalizedPath;
   while (!existsSync5(existingAncestor)) {
     const parent = dirname4(existingAncestor);
     if (parent === existingAncestor) {
-      throw new Error(`Cannot resolve an existing ancestor for web output: ${path12}`);
+      throw new Error(`Cannot resolve an existing ancestor for web output: ${path13}`);
     }
     suffix.unshift(basename2(existingAncestor));
     existingAncestor = parent;
@@ -4285,18 +4285,18 @@ function stageWrapperIcon(result, wrapperApp) {
 }
 async function stageNativeIconResources(result, shellApp) {
   const snapshots = /* @__PURE__ */ new Map();
-  const write = (path12, contents) => {
-    if (!snapshots.has(path12)) {
-      snapshots.set(path12, existsSync6(path12) ? readFileSync7(path12) : void 0);
+  const write = (path13, contents) => {
+    if (!snapshots.has(path13)) {
+      snapshots.set(path13, existsSync6(path13) ? readFileSync7(path13) : void 0);
     }
-    mkdirSync4(dirname5(path12), { recursive: true });
-    writeFileSync4(path12, contents);
+    mkdirSync4(dirname5(path13), { recursive: true });
+    writeFileSync4(path13, contents);
   };
-  const remove = (path12) => {
-    if (!snapshots.has(path12)) {
-      snapshots.set(path12, existsSync6(path12) ? readFileSync7(path12) : void 0);
+  const remove = (path13) => {
+    if (!snapshots.has(path13)) {
+      snapshots.set(path13, existsSync6(path13) ? readFileSync7(path13) : void 0);
     }
-    rmSync4(path12, { force: true });
+    rmSync4(path13, { force: true });
   };
   if (result.profile.id === "android-adaptive") {
     await stageAndroid(result, shellApp, write, remove);
@@ -4304,11 +4304,11 @@ async function stageNativeIconResources(result, shellApp) {
     stageIos(result, shellApp, write);
   }
   return () => {
-    for (const [path12, contents] of [...snapshots.entries()].reverse()) {
+    for (const [path13, contents] of [...snapshots.entries()].reverse()) {
       if (contents === void 0) {
-        rmSync4(path12, { force: true });
+        rmSync4(path13, { force: true });
       } else {
-        writeFileSync4(path12, contents);
+        writeFileSync4(path13, contents);
       }
     }
   };
@@ -4381,7 +4381,7 @@ function stageWebManifest(result, gameDist, manifestSourceDirectory) {
     stagedPath,
     publicWebManifestPath,
     publicJsonManifestPath
-  ].find((path12) => existsSync6(path12));
+  ].find((path13) => existsSync6(path13));
   const manifest = manifestPath !== void 0 ? readWebManifest(manifestPath) : {
     name: basename3(result.gameRoot),
     short_name: basename3(result.gameRoot),
@@ -4404,10 +4404,10 @@ function stageWebManifest(result, gameDist, manifestSourceDirectory) {
   }
   ensureInstallableWebManifestLink(gameDist);
 }
-function readWebManifest(path12) {
-  const parsed = JSON.parse(readFileSync7(path12, "utf8"));
+function readWebManifest(path13) {
+  const parsed = JSON.parse(readFileSync7(path13, "utf8"));
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Web app manifest must contain a JSON object: ${path12}`);
+    throw new Error(`Web app manifest must contain a JSON object: ${path13}`);
   }
   return parsed;
 }
@@ -4426,8 +4426,8 @@ function androidAdaptiveXml(hasMonochrome) {
 </adaptive-icon>
 `;
 }
-async function resizePng(path12, size) {
-  return sharp3(path12).resize(size, size, { kernel: sharp3.kernel.lanczos3 }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
+async function resizePng(path13, size) {
+  return sharp3(path13).resize(size, size, { kernel: sharp3.kernel.lanczos3 }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
 }
 function cacheOutputPath(result, output) {
   return resolve8(result.outputDir, basename3(output.path));
@@ -4566,10 +4566,10 @@ function instantOrNaN(at) {
 function isNotificationTimestamp(at) {
   return !Number.isNaN(instantOrNaN(at));
 }
-function notificationTimeFieldIssue(value, fields, path12 = "") {
+function notificationTimeFieldIssue(value, fields, path13 = "") {
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      const issue = notificationTimeFieldIssue(item, fields, `${path12}[${index}]`);
+      const issue = notificationTimeFieldIssue(item, fields, `${path13}[${index}]`);
       if (issue !== void 0) {
         return issue;
       }
@@ -4584,7 +4584,7 @@ function notificationTimeFieldIssue(value, fields, path12 = "") {
       continue;
     }
     const field = value[key];
-    const at = path12 === "" ? key : `${path12}.${key}`;
+    const at = path13 === "" ? key : `${path13}.${key}`;
     if (typeof format !== "string") {
       const issue = notificationTimeFieldIssue(field, format, at);
       if (issue !== void 0) {
@@ -8427,10 +8427,10 @@ function assertCrazyGamesArtifact(root) {
   let bytes = 0;
   function visit(directory) {
     for (const name of readdirSync2(directory)) {
-      const path12 = join8(directory, name);
-      const stat2 = lstatSync5(path12);
+      const path13 = join8(directory, name);
+      const stat2 = lstatSync5(path13);
       if (stat2.isDirectory()) {
-        visit(path12);
+        visit(path13);
       } else if (stat2.isFile()) {
         files += 1;
         bytes += stat2.size;
@@ -8445,8 +8445,8 @@ function assertCrazyGamesArtifact(root) {
   }
   const index = readFileSync8(join8(root, "index.html"), "utf8");
   for (const match of index.matchAll(/\b(?:src|href)\s*=\s*(?:["']([^"']+)["']|([^\s"'`=<>]+))/giu)) {
-    const path12 = match[1] ?? match[2];
-    if (path12?.startsWith("/") || /^https?:/iu.test(path12 ?? "")) {
+    const path13 = match[1] ?? match[2];
+    if (path13?.startsWith("/") || /^https?:/iu.test(path13 ?? "")) {
       throw new Error("CrazyGames index assets must use relative paths.");
     }
   }
@@ -8458,9 +8458,9 @@ import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync
 import { join as join9 } from "node:path";
 var onePlayFrameAncestors = "https://*.onestore.co.kr https://*.onestore.net";
 function writeOnePlayHostingHeaders(root) {
-  const path12 = join9(root, "_headers");
-  if (!existsSync7(path12)) {
-    writeFileSync5(path12, `/*
+  const path13 = join9(root, "_headers");
+  if (!existsSync7(path13)) {
+    writeFileSync5(path13, `/*
   Content-Security-Policy: frame-ancestors ${onePlayFrameAncestors}
 `);
   }
@@ -8955,8 +8955,8 @@ function readConfiguredPath(value) {
 import { readFileSync as readFileSync10 } from "node:fs";
 import { resolve as resolve9 } from "node:path";
 import { pathToFileURL } from "node:url";
-function readJsonFile(path12) {
-  return JSON.parse(readFileSync10(resolve9(path12), "utf8"));
+function readJsonFile(path13) {
+  return JSON.parse(readFileSync10(resolve9(path13), "utf8"));
 }
 function isCliEntrypoint(metaUrl) {
   const scriptPath = process.argv[1];
@@ -9110,20 +9110,20 @@ function listMiniGameArtifactFiles(artifactRoot) {
       throw new Error("Mini-game artifact traversal lost its current directory.");
     }
     for (const entry of readdirSync3(directory, { withFileTypes: true })) {
-      const path12 = resolve10(directory, entry.name);
-      const stat2 = lstatSync6(path12);
+      const path13 = resolve10(directory, entry.name);
+      const stat2 = lstatSync6(path13);
       if (stat2.isSymbolicLink()) {
-        throw new Error(`Mini-game artifacts must not contain symbolic links: ${path12}`);
+        throw new Error(`Mini-game artifacts must not contain symbolic links: ${path13}`);
       }
-      const artifactPath = toArtifactRelativePath(root, path12);
+      const artifactPath = toArtifactRelativePath(root, path13);
       assertMiniGameArtifactPathAllowed(artifactPath);
       artifactPaths.push(artifactPath);
       if (stat2.isDirectory()) {
-        pending.push(path12);
+        pending.push(path13);
         continue;
       }
       if (!stat2.isFile()) {
-        throw new Error(`Mini-game artifacts must contain regular files only: ${path12}`);
+        throw new Error(`Mini-game artifacts must contain regular files only: ${path13}`);
       }
       files.push({ path: artifactPath, bytes: stat2.size });
     }
@@ -9133,22 +9133,22 @@ function listMiniGameArtifactFiles(artifactRoot) {
     return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
   });
 }
-function assertMiniGameArtifactRelativePath(path12, label) {
-  const segments = path12.split("/");
-  if (path12.length === 0 || path12.includes("\\") || path12.startsWith("/") || /^[A-Za-z]:/u.test(path12) || isAbsolute6(path12) || 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: ${path12}`);
+function assertMiniGameArtifactRelativePath(path13, label) {
+  const segments = path13.split("/");
+  if (path13.length === 0 || path13.includes("\\") || path13.startsWith("/") || /^[A-Za-z]:/u.test(path13) || isAbsolute6(path13) || 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: ${path13}`);
   }
 }
 function assertMiniGameArtifactPathsPortable(paths) {
   const seen = /* @__PURE__ */ new Map();
-  for (const path12 of paths) {
-    assertMiniGameArtifactRelativePath(path12, "Mini-game artifact path");
-    const portableKey = miniGamePortablePathKey(path12);
+  for (const path13 of paths) {
+    assertMiniGameArtifactRelativePath(path13, "Mini-game artifact path");
+    const portableKey = miniGamePortablePathKey(path13);
     const previous = seen.get(portableKey);
     if (previous !== void 0) {
-      throw new Error(`Mini-game artifact paths collide on portable filesystems: ${previous}, ${path12}.`);
+      throw new Error(`Mini-game artifact paths collide on portable filesystems: ${previous}, ${path13}.`);
     }
-    seen.set(portableKey, path12);
+    seen.set(portableKey, path13);
   }
 }
 function readMiniGameSubpackages(gameConfig) {
@@ -9185,40 +9185,40 @@ function assertSubpackageRoots(subpackages) {
     }
   }
 }
-function resolveArtifactPath2(root, path12) {
-  const resolved = resolve10(root, path12);
+function resolveArtifactPath2(root, path13) {
+  const resolved = resolve10(root, path13);
   const relativePath = relative8(root, resolved);
   if (relativePath.length === 0 || relativePath === ".." || relativePath.startsWith(`..${sep5}`) || isAbsolute6(relativePath)) {
-    throw new Error(`Mini-game path escapes its artifact root: ${path12}`);
+    throw new Error(`Mini-game path escapes its artifact root: ${path13}`);
   }
   try {
     const stat2 = lstatSync6(resolved);
     if (stat2.isSymbolicLink()) {
-      throw new Error(`Mini-game path must not be a symbolic link: ${path12}`);
+      throw new Error(`Mini-game path must not be a symbolic link: ${path13}`);
     }
   } catch (error) {
-    throw new Error(`Mini-game subpackage root does not exist: ${path12} (${formatError4(error)})`);
+    throw new Error(`Mini-game subpackage root does not exist: ${path13} (${formatError4(error)})`);
   }
   return resolved;
 }
-function toArtifactRelativePath(root, path12) {
-  const artifactPath = relative8(root, path12).replaceAll("\\", "/");
+function toArtifactRelativePath(root, path13) {
+  const artifactPath = relative8(root, path13).replaceAll("\\", "/");
   assertMiniGameArtifactRelativePath(artifactPath, "Mini-game artifact file");
   return artifactPath;
 }
-function isInsideRoot(path12, root) {
-  return path12 === root || path12.startsWith(`${root}/`);
+function isInsideRoot(path13, root) {
+  return path13 === root || path13.startsWith(`${root}/`);
 }
-function miniGamePortablePathKey(path12) {
-  return path12.normalize("NFC").toLowerCase();
+function miniGamePortablePathKey(path13) {
+  return path13.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(path12) {
-  const segments = path12.split("/");
+function assertMiniGameArtifactPathAllowed(path13) {
+  const segments = path13.split("/");
   const fileName = segments.at(-1) ?? "";
   const normalizedFileName = fileName.toLowerCase();
   const normalizedSegments = segments.map((segment) => segment.toLowerCase());
@@ -9232,16 +9232,16 @@ function assertMiniGameArtifactPathAllowed(path12) {
     "tests"
   ]);
   if (normalizedSegments.some((segment) => forbiddenSegments.has(segment))) {
-    throw new Error(`Mini-game artifact contains a forbidden development path: ${path12}`);
+    throw new Error(`Mini-game artifact contains a forbidden development path: ${path13}`);
   }
   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: ${path12}`);
+    throw new Error(`Mini-game artifact contains a forbidden development or credential file: ${path13}`);
   }
   if (/\.(?:html?|css|svg)$/iu.test(fileName)) {
-    throw new Error(`Mini-game artifact contains a browser-only asset: ${path12}`);
+    throw new Error(`Mini-game artifact contains a browser-only asset: ${path13}`);
   }
   if (/\.(?:aac|m4a|mp3|ogg|opus|wav|webm)$/iu.test(fileName)) {
-    throw new Error(`Mini-game Canvas MVP does not support audio assets yet: ${path12}`);
+    throw new Error(`Mini-game Canvas MVP does not support audio assets yet: ${path13}`);
   }
 }
 function isRecord3(input) {
@@ -9852,19 +9852,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(path12 = process.env[platformTargetsFileEnv] ?? "mpgd.targets.json") {
-  return resolve11(path12);
+function platformTargetsFilePath(path13 = process.env[platformTargetsFileEnv] ?? "mpgd.targets.json") {
+  return resolve11(path13);
 }
-function loadPlatformTargetsConfig(path12 = platformTargetsFilePath()) {
-  const resolvedPath = platformTargetsFilePath(path12);
+function loadPlatformTargetsConfig(path13 = platformTargetsFilePath()) {
+  const resolvedPath = platformTargetsFilePath(path13);
   return {
     path: resolvedPath,
     baseDir: dirname6(resolvedPath),
     config: assertPlatformTargetsConfigShape(readJsonFile(resolvedPath))
   };
 }
-function resolveFromPlatformTargetsBase(baseDir, path12) {
-  return isAbsolute7(path12) ? path12 : resolve11(baseDir, path12);
+function resolveFromPlatformTargetsBase(baseDir, path13) {
+  return isAbsolute7(path13) ? path13 : resolve11(baseDir, path13);
 }
 function releaseManifestPath(baseDir = dirname6(platformTargetsFilePath())) {
   return resolveFromPlatformTargetsBase(baseDir, process.env[releaseManifestFileEnv] ?? "artifacts/release-manifest.json");
@@ -10953,14 +10953,14 @@ function writeEffectiveTargetConfigs(options = {}) {
   writeFileSync6(indexPath, indexContent);
   return index;
 }
-function readExistingArtifactIndex(path12, version) {
-  if (!existsSync8(path12)) {
+function readExistingArtifactIndex(path13, version) {
+  if (!existsSync8(path13)) {
     return {
       version,
       artifacts: []
     };
   }
-  const parsed = JSON.parse(readFileSync12(path12, "utf8"));
+  const parsed = JSON.parse(readFileSync12(path13, "utf8"));
   if (parsed.version !== version) {
     return {
       version,
@@ -10971,14 +10971,14 @@ function readExistingArtifactIndex(path12, version) {
 }
 function writeEffectiveTargetConfig(target2, config2, outputDir) {
   assertDeploymentTargetName(target2);
-  const path12 = join10(outputDir, `${target2}.json`);
+  const path13 = join10(outputDir, `${target2}.json`);
   const content = `${JSON.stringify(config2, null, 2)}
 `;
-  mkdirSync5(dirname7(path12), { recursive: true });
-  writeFileSync6(path12, content);
+  mkdirSync5(dirname7(path13), { recursive: true });
+  writeFileSync6(path13, content);
   return {
     target: target2,
-    path: path12,
+    path: path13,
     digest: sha2562(content),
     version: config2.version
   };
@@ -12114,51 +12114,51 @@ function readNativeVersionEvidence(target2) {
   return {};
 }
 function readIconManifestEvidence(artifactPath) {
-  const path12 = readOptionalString2(process.env.MPGD_ICON_MANIFEST_PATH);
-  if (path12 === void 0) {
+  const path13 = readOptionalString2(process.env.MPGD_ICON_MANIFEST_PATH);
+  if (path13 === void 0) {
     throw new Error("MPGD_ICON_MANIFEST_PATH is required when generating a release manifest.");
   }
-  const bytes = readFileBytes(path12);
+  const bytes = readFileBytes(path13);
   const parsed = JSON.parse(bytes.toString("utf8"));
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`Invalid icon manifest: ${path12}`);
+    throw new Error(`Invalid icon manifest: ${path13}`);
   }
   const manifest = parsed;
   const canonicalSource = manifest.canonicalSource;
   if (typeof canonicalSource !== "object" || canonicalSource === null || Array.isArray(canonicalSource)) {
-    throw new Error(`Invalid icon manifest canonicalSource: ${path12}`);
+    throw new Error(`Invalid icon manifest canonicalSource: ${path13}`);
   }
   const canonicalSourceRecord = canonicalSource;
   return {
     path: requirePortableArtifactPath(artifactPath),
     digest: createHash8("sha256").update(bytes).digest("hex"),
-    sourceSha256: requireManifestString(canonicalSourceRecord, "sha256", path12),
-    sharedConfigSha256: requireManifestString(manifest, "sharedConfigSha256", path12),
-    renderConfigSha256: requireManifestString(manifest, "renderConfigSha256", path12),
-    generatorVersion: requireManifestString(manifest, "generatorVersion", path12),
-    targetProfile: requireManifestString(manifest, "targetProfile", path12),
-    targetProfileVersion: requireManifestString(manifest, "targetProfileVersion", path12)
+    sourceSha256: requireManifestString(canonicalSourceRecord, "sha256", path13),
+    sharedConfigSha256: requireManifestString(manifest, "sharedConfigSha256", path13),
+    renderConfigSha256: requireManifestString(manifest, "renderConfigSha256", path13),
+    generatorVersion: requireManifestString(manifest, "generatorVersion", path13),
+    targetProfile: requireManifestString(manifest, "targetProfile", path13),
+    targetProfileVersion: requireManifestString(manifest, "targetProfileVersion", path13)
   };
 }
-function requirePortableArtifactPath(path12) {
-  const normalized = path12.replaceAll("\\", "/");
+function requirePortableArtifactPath(path13) {
+  const normalized = path13.replaceAll("\\", "/");
   const segments = normalized.split("/");
-  if (normalized.length === 0 || isAbsolute8(path12) || isAbsolute8(normalized) || /^[A-Za-z]:\//u.test(normalized) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-    throw new Error(`Invalid icon manifest artifact path: ${path12}`);
+  if (normalized.length === 0 || isAbsolute8(path13) || isAbsolute8(normalized) || /^[A-Za-z]:\//u.test(normalized) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    throw new Error(`Invalid icon manifest artifact path: ${path13}`);
   }
   return normalized;
 }
-function readFileBytes(path12) {
+function readFileBytes(path13) {
   try {
-    return readFileSync14(path12);
+    return readFileSync14(path13);
   } catch (error) {
-    throw new Error(`Failed to read icon manifest ${path12}: ${formatError5(error)}`);
+    throw new Error(`Failed to read icon manifest ${path13}: ${formatError5(error)}`);
   }
 }
-function requireManifestString(record2, key, path12) {
+function requireManifestString(record2, key, path13) {
   const value = record2[key];
   if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`Invalid icon manifest ${key}: ${path12}`);
+    throw new Error(`Invalid icon manifest ${key}: ${path13}`);
   }
   return value;
 }
@@ -12240,15 +12240,15 @@ function makeEffectiveConfigPathsPortable(manifest, baseDir) {
     ]))
   });
 }
-function toPortablePath(baseDir, path12) {
-  if (!isAbsolute8(path12)) {
-    return path12;
+function toPortablePath(baseDir, path13) {
+  if (!isAbsolute8(path13)) {
+    return path13;
   }
-  const relativePath = relative9(baseDir, path12);
+  const relativePath = relative9(baseDir, path13);
   if (relativePath.length > 0 && !relativePath.startsWith("..") && !isAbsolute8(relativePath)) {
     return relativePath;
   }
-  return path12;
+  return path13;
 }
 function createBuildId() {
   const now = /* @__PURE__ */ new Date();
@@ -12648,20 +12648,20 @@ function listPrecacheEntries(artifactRoot) {
       throw new Error("PWA artifact traversal lost its directory.");
     }
     for (const entry of readdirSync4(directory, { withFileTypes: true })) {
-      const path12 = resolve13(directory, entry.name);
+      const path13 = resolve13(directory, entry.name);
       if (entry.isSymbolicLink()) {
-        throw new Error(`PWA artifact must not contain symbolic links: ${path12}`);
+        throw new Error(`PWA artifact must not contain symbolic links: ${path13}`);
       }
       if (entry.isDirectory()) {
-        pendingDirectories.push(path12);
+        pendingDirectories.push(path13);
       } else if (entry.isFile()) {
-        files.push(path12);
+        files.push(path13);
       }
     }
   }
-  return files.filter((path12) => !path12.endsWith(".map") && !path12.endsWith(`${sep6}pwa-release.json`) && !path12.endsWith(`${sep6}service-worker.js`)).map((path12) => ({
-    url: toPrecacheUrl(artifactRoot, path12),
-    source: readFileSync15(path12)
+  return files.filter((path13) => !path13.endsWith(".map") && !path13.endsWith(`${sep6}pwa-release.json`) && !path13.endsWith(`${sep6}service-worker.js`)).map((path13) => ({
+    url: toPrecacheUrl(artifactRoot, path13),
+    source: readFileSync15(path13)
   })).sort((left, right) => compareCodeUnits(left.url, right.url));
 }
 function normalizePrecacheEntries(entries) {
@@ -12685,8 +12685,8 @@ function normalizePrecacheUrls(urls) {
   }
   return normalized.sort(compareCodeUnits);
 }
-function toPrecacheUrl(root, path12) {
-  const portablePath = relative10(root, path12).split(sep6).join("/");
+function toPrecacheUrl(root, path13) {
+  const portablePath = relative10(root, path13).split(sep6).join("/");
   return assertMicrosoftStorePwaPrecacheUrl(`./${portablePath}`);
 }
 function requireGameSpecificPwaId(value) {
@@ -13087,23 +13087,23 @@ function pathsOverlap2(first, second) {
   return isPathWithin2(first, second) || isPathWithin2(second, first);
 }
 function isPathWithin2(root, candidate) {
-  const path12 = relative11(root, candidate);
-  return path12 === "" || path12 !== ".." && !path12.startsWith(`..${sep7}`) && !isAbsolute9(path12);
+  const path13 = relative11(root, candidate);
+  return path13 === "" || path13 !== ".." && !path13.startsWith(`..${sep7}`) && !isAbsolute9(path13);
 }
-function portablePathComparisonKey(path12) {
-  const portablePath = path12.replaceAll("\\", "/").split("/").map((segment) => {
+function portablePathComparisonKey(path13) {
+  const portablePath = path13.replaceAll("\\", "/").split("/").map((segment) => {
     return segment === "." || segment === ".." ? segment : segment.replace(/[. ]+$/u, "");
   }).join("/");
   return canonicalizeThroughExistingAncestor2(portablePath).normalize("NFC").toLowerCase();
 }
-function canonicalizeThroughExistingAncestor2(path12) {
-  const normalizedPath = resolve15(path12);
+function canonicalizeThroughExistingAncestor2(path13) {
+  const normalizedPath = resolve15(path13);
   const suffix = [];
   let existingAncestor = normalizedPath;
   while (!existsSync12(existingAncestor)) {
     const parent = dirname8(existingAncestor);
     if (parent === existingAncestor) {
-      throw new Error(`Cannot resolve an existing ancestor for mini-game output: ${path12}`);
+      throw new Error(`Cannot resolve an existing ancestor for mini-game output: ${path13}`);
     }
     suffix.unshift(basename4(existingAncestor));
     existingAncestor = parent;
@@ -13157,8 +13157,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(path12) {
-  rmSync6(path12, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 });
+function removeMiniGameArtifactBackupDirectory(path13) {
+  rmSync6(path13, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 });
 }
 function assertMiniGameRequiredFiles(artifactRoot) {
   for (const file of [
@@ -13198,17 +13198,17 @@ function assertMiniGameJavaScriptSafety(artifactRoot, forbiddenMarkers, forbidde
     }
   }
 }
-function assertMiniGameJavaScriptAstSafety(source, path12, forbiddenGlobals) {
+function assertMiniGameJavaScriptAstSafety(source, path13, forbiddenGlobals) {
   let ast;
   try {
     ast = parse(source, {
       ecmaVersion: "latest",
-      sourceType: path12.toLowerCase().endsWith(".mjs") ? "module" : "script",
+      sourceType: path13.toLowerCase().endsWith(".mjs") ? "module" : "script",
       allowHashBang: true,
       allowReturnOutsideFunction: true
     });
   } catch (error) {
-    throw new Error(`Mini-game ${path12} is not valid JavaScript: ${formatError6(error)}`);
+    throw new Error(`Mini-game ${path13} is not valid JavaScript: ${formatError6(error)}`);
   }
   const scopeAnalysis = createMiniGameScopeAnalysis(ast);
   const ancestors = [];
@@ -13223,7 +13223,7 @@ function assertMiniGameJavaScriptAstSafety(source, path12, forbiddenGlobals) {
     if (!isAstRecord(input)) {
       return;
     }
-    assertSafeNode(input, ancestors, path12, scopeAnalysis, forbiddenGlobals);
+    assertSafeNode(input, ancestors, path13, 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 });
@@ -13233,57 +13233,57 @@ function assertMiniGameJavaScriptAstSafety(source, path12, forbiddenGlobals) {
     }
   }
 }
-function assertSafeNode(node, ancestors, path12, scopeAnalysis, forbiddenGlobals) {
+function assertSafeNode(node, ancestors, path13, scopeAnalysis, forbiddenGlobals) {
   if (node.type === "ImportExpression") {
-    throw new Error(`Mini-game ${path12} contains forbidden dynamic import.`);
+    throw new Error(`Mini-game ${path13} contains forbidden dynamic import.`);
   }
   const parent = ancestors.at(-1)?.node;
   if (forbiddenGlobals.size > 0 && isMiniGameProtectedIntrinsicMutation(node, ancestors, scopeAnalysis)) {
-    throw new Error(`Mini-game ${path12} contains forbidden protected intrinsic mutation.`);
+    throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden dynamic-code constructor.`);
+    throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden platform global ${node.name}.`);
+      throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path13} contains forbidden dynamic-code constructor.`);
     }
     if (node.name === "eval") {
-      throw new Error(`Mini-game ${path12} contains forbidden eval.`);
+      throw new Error(`Mini-game ${path13} contains forbidden eval.`);
     }
     if (node.name === "Function") {
-      throw new Error(`Mini-game ${path12} contains forbidden Function constructor.`);
+      throw new Error(`Mini-game ${path13} contains forbidden Function constructor.`);
     }
     if (node.name === "importScripts" && !isTypeofReference(node, ancestors)) {
-      throw new Error(`Mini-game ${path12} contains forbidden importScripts.`);
+      throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden computed global read.`);
+      throw new Error(`Mini-game ${path13} contains forbidden computed global read.`);
     }
     const forbiddenPlatformGlobal = [...propertyNames].find((propertyName) => {
       return forbiddenGlobals.has(propertyName);
     });
     if (forbiddenPlatformGlobal !== void 0) {
-      throw new Error(`Mini-game ${path12} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
+      throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden ${forbiddenDynamicCodeProperty}.`);
+      throw new Error(`Mini-game ${path13} contains forbidden ${forbiddenDynamicCodeProperty}.`);
     }
     if (isInvocationArgument(node, ancestors) && isDynamicCodeConstructorSource(node, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path12} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path13} contains forbidden dynamic-code constructor.`);
     }
   }
   if (node.type === "Property") {
@@ -13293,17 +13293,17 @@ function assertSafeNode(node, ancestors, path12, scopeAnalysis, forbiddenGlobals
       return forbiddenGlobals.has(propertyName);
     });
     if (isObjectPatternProperty && forbiddenPlatformGlobal !== void 0) {
-      throw new Error(`Mini-game ${path12} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
+      throw new Error(`Mini-game ${path13} contains forbidden platform global ${forbiddenPlatformGlobal}.`);
     }
     if (isGlobalObjectDestructuring(ancestors, scopeAnalysis)) {
       if (node.computed === true) {
-        throw new Error(`Mini-game ${path12} contains forbidden computed destructuring.`);
+        throw new Error(`Mini-game ${path13} contains forbidden computed destructuring.`);
       }
       const forbiddenDynamicCodeProperty = [...propertyNames].find((propertyName) => {
         return ["eval", "Function", "importScripts"].includes(propertyName);
       });
       if (forbiddenDynamicCodeProperty !== void 0) {
-        throw new Error(`Mini-game ${path12} contains forbidden ${forbiddenDynamicCodeProperty} destructuring.`);
+        throw new Error(`Mini-game ${path13} contains forbidden ${forbiddenDynamicCodeProperty} destructuring.`);
       }
     }
   }
@@ -13312,35 +13312,35 @@ function assertSafeNode(node, ancestors, path12, 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 ${path12} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path13} contains forbidden dynamic-code constructor.`);
     }
     if (isUnknownComputedGlobalMember(node.callee, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path12} contains forbidden computed global call.`);
+      throw new Error(`Mini-game ${path13} contains forbidden computed global call.`);
     }
     if (isReflectiveDynamicCodeGlobalRead(node, ancestors, scopeAnalysis, forbiddenGlobals)) {
-      throw new Error(`Mini-game ${path12} contains forbidden reflective global lookup.`);
+      throw new Error(`Mini-game ${path13} contains forbidden reflective global lookup.`);
     }
     if (calleeNames.has("createElement") && resolveMiniGameStaticStrings(firstArgument, ancestors, scopeAnalysis).has("script")) {
-      throw new Error(`Mini-game ${path12} contains forbidden script element creation.`);
+      throw new Error(`Mini-game ${path13} 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 ${path12} contains forbidden dynamic-code constructor.`);
+      throw new Error(`Mini-game ${path13} contains forbidden dynamic-code constructor.`);
     }
     if (isUnknownComputedGlobalMember(node.callee, ancestors, scopeAnalysis)) {
-      throw new Error(`Mini-game ${path12} contains forbidden computed global construction.`);
+      throw new Error(`Mini-game ${path13} contains forbidden computed global construction.`);
     }
     const forbiddenWorker = [...calleeNames].find((calleeName) => {
       return calleeName === "Worker" || calleeName === "SharedWorker";
     });
     if (forbiddenWorker !== void 0) {
-      throw new Error(`Mini-game ${path12} contains forbidden ${forbiddenWorker} construction.`);
+      throw new Error(`Mini-game ${path13} contains forbidden ${forbiddenWorker} construction.`);
     }
   }
   if (node.type === "TaggedTemplateExpression" && isDynamicCodeConstructorSource(node.tag, ancestors, scopeAnalysis)) {
-    throw new Error(`Mini-game ${path12} contains forbidden dynamic-code constructor.`);
+    throw new Error(`Mini-game ${path13} contains forbidden dynamic-code constructor.`);
   }
 }
 function isInvocationArgument(node, ancestors) {
@@ -15191,10 +15191,10 @@ function createEvidence(input, files, effectiveTargetConfig, iconManifest, packa
     files
   };
 }
-function requireEvidenceFile(artifactRoot, files, path12) {
-  const file = files.find((candidate) => candidate.path === path12);
-  if (file === void 0 || !existsSync12(join11(artifactRoot, path12))) {
-    throw new Error(`Mini-game artifact is missing required evidence file: ${path12}`);
+function requireEvidenceFile(artifactRoot, files, path13) {
+  const file = files.find((candidate) => candidate.path === path13);
+  if (file === void 0 || !existsSync12(join11(artifactRoot, path13))) {
+    throw new Error(`Mini-game artifact is missing required evidence file: ${path13}`);
   }
   return file;
 }
@@ -15268,9 +15268,9 @@ function verifyNamedDigest(artifactRoot, reference, expectedPath, label) {
     throw new Error(`Mini-game artifact ${label} digest mismatch.`);
   }
 }
-function readJson(path12, label) {
+function readJson(path13, label) {
   try {
-    return JSON.parse(readFileSync16(path12, "utf8"));
+    return JSON.parse(readFileSync16(path13, "utf8"));
   } catch (error) {
     throw new Error(`${label} is unreadable: ${formatError6(error)}`);
   }
@@ -15337,8 +15337,8 @@ function assertWechatAppId(appId, production) {
     throw new Error("WeChat Mini Game app id must be a valid AppID or the staging placeholder.");
   }
 }
-function writeJson(path12, input) {
-  writeFileSync11(path12, `${JSON.stringify(input, null, 2)}
+function writeJson(path13, input) {
+  writeFileSync11(path13, `${JSON.stringify(input, null, 2)}
 `);
 }
 
@@ -15393,15 +15393,207 @@ function normalizeNotificationTopicsEnv(baseEnv, fallbackBaseDir = process.cwd()
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-attempt.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync17, renameSync as renameSync4, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import path4 from "node:path";
+
+// node_modules/.cache/mpgd-native-build/packages/cli/src/native-build-symbols.js
+import { closeSync as closeSync3, existsSync as existsSync14, lstatSync as lstatSync9, openSync as openSync3, readdirSync as readdirSync6, readSync as readSync2, statSync as statSync3 } from "node:fs";
 import path3 from "node:path";
+function assertNativeBuildSymbols(value, isPath) {
+  const isRecord6 = (entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry);
+  const pathField = (entry) => typeof entry === "string" && isPath(entry);
+  if (!isRecord6(value) || Object.keys(value).some((key) => key !== "r8Mapping" && key !== "crashlytics") || value.r8Mapping === void 0 === (value.crashlytics === void 0) || value.r8Mapping !== void 0 && !pathField(value.r8Mapping)) {
+    throw new Error("Native build symbols are malformed.");
+  }
+  const crashlytics = value.crashlytics;
+  if (crashlytics === void 0) {
+    return;
+  }
+  if (!isRecord6(crashlytics) || Object.keys(crashlytics).some((key) => !["dsymArchive", "dsyms", "uploadTool", "googleServiceInfo"].includes(key)) || !pathField(crashlytics.dsymArchive) || !pathField(crashlytics.uploadTool) || !pathField(crashlytics.googleServiceInfo) || !isDsymIdentityList(crashlytics.dsyms)) {
+    throw new Error("Native build symbols are malformed.");
+  }
+}
+function isDsymIdentityList(value) {
+  return Array.isArray(value) && value.length > 0 && value.length <= 256 && value.every((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && Object.keys(entry).every((key) => key === "bundle" || key === "uuids") && typeof entry.bundle === "string" && isDsymBundleName(entry.bundle) && Array.isArray(entry.uuids) && entry.uuids.length > 0 && entry.uuids.length <= 32 && entry.uuids.every(isDsymUuid));
+}
+function isDsymBundleName(name) {
+  return name.length <= 255 && /^[^./\\\u0000-\u001f\u007f][^/\\\u0000-\u001f\u007f]*\.dSYM$/u.test(name);
+}
+function isNativeOutputPath(file, target2) {
+  return file.startsWith(`release-output/native/${target2}/`) && !path3.isAbsolute(file) && !file.split(/[\\/]/u).some((segment) => segment === "" || segment === "..");
+}
+var androidReleaseMappingPath = "app/build/outputs/mapping/release/mapping.txt";
+var nativeSymbolFileNames = Object.freeze({
+  r8Mapping: "mapping.txt",
+  dsymArchive: "dSYMs.zip",
+  uploadTool: "upload-symbols",
+  googleServiceInfo: "GoogleService-Info.plist"
+});
+var iosCrashlyticsSourcePackagesDirectory = ".mpgd-source-packages";
+function crashlyticsUploadToolCandidates(input) {
+  return [
+    path3.join(input.sourcePackages, "checkouts/firebase-ios-sdk/Crashlytics/upload-symbols"),
+    path3.join(input.iosProject, "App/Pods/FirebaseCrashlytics/upload-symbols")
+  ];
+}
+function collectIosCrashlyticsSymbols(input) {
+  const dsymFolder = path3.join(input.archive, "dSYMs");
+  const dsyms = readArchiveDsyms(dsymFolder);
+  if (dsyms.length === 0) {
+    throw new Error('Crash reporting is on, but the iOS archive has no dSYM; set Debug Information Format to "DWARF with dSYM File" for the Release configuration.');
+  }
+  const tool = crashlyticsUploadToolCandidates(input).find((candidate) => existsSync14(candidate) && lstatSync9(candidate).isFile());
+  if (tool === void 0) {
+    throw new Error("Crash reporting is on, but the iOS build has no Firebase Crashlytics upload-symbols in its Swift Package (firebase-ios-sdk/Crashlytics) or CocoaPods (FirebaseCrashlytics) checkout.");
+  }
+  const plist = path3.join(archivedApp(input.archive), "GoogleService-Info.plist");
+  if (!existsSync14(plist) || !lstatSync9(plist).isFile()) {
+    throw new Error("Crash reporting is on, but the archived iOS app does not bundle GoogleService-Info.plist.");
+  }
+  const output = {
+    dsymArchive: path3.join(input.outputDirectory, nativeSymbolFileNames.dsymArchive),
+    uploadTool: path3.join(input.outputDirectory, nativeSymbolFileNames.uploadTool),
+    googleServiceInfo: path3.join(input.outputDirectory, nativeSymbolFileNames.googleServiceInfo)
+  };
+  input.zipDirectory(dsymFolder, output.dsymArchive);
+  if (!existsSync14(output.dsymArchive) || !statSync3(output.dsymArchive).isFile() || statSync3(output.dsymArchive).size === 0) {
+    throw new Error("The iOS dSYM archive was not written.");
+  }
+  input.copyFile(tool, output.uploadTool);
+  input.copyFile(plist, output.googleServiceInfo);
+  return { ...output, dsyms };
+}
+function archivedApp(archive) {
+  const applications = path3.join(archive, "Products/Applications");
+  const apps = existsSync14(applications) ? readdirSync6(applications).filter((name) => name.endsWith(".app")) : [];
+  if (apps.length !== 1) {
+    throw new Error("The iOS archive must contain exactly one application bundle.");
+  }
+  return path3.join(applications, apps[0] ?? "");
+}
+function readArchiveDsyms(dsymFolder) {
+  if (!existsSync14(dsymFolder)) {
+    return [];
+  }
+  const bundles = readdirSync6(dsymFolder).filter((name) => name.endsWith(".dSYM") && !name.startsWith(".")).sort();
+  return bundles.map((bundle) => {
+    if (!isDsymBundleName(bundle)) {
+      throw new Error(`dSYM bundle name is not supported: ${JSON.stringify(bundle)}.`);
+    }
+    const dwarf = path3.join(dsymFolder, bundle, "Contents/Resources/DWARF");
+    const files = existsSync14(dwarf) ? readdirSync6(dwarf).filter((name) => lstatSync9(path3.join(dwarf, name)).isFile()).sort() : [];
+    const uuids = [...new Set(files.flatMap((file) => {
+      const candidate = path3.join(dwarf, file);
+      return isMachOFile(candidate) ? readMachOUuids(candidate) : [];
+    }))].sort();
+    if (uuids.length === 0) {
+      throw new Error(`dSYM ${bundle} has no Mach-O UUID.`);
+    }
+    return { bundle, uuids };
+  });
+}
+function isMachOFile(file) {
+  const descriptor = openSync3(file, "r");
+  try {
+    const magic = Buffer.alloc(4);
+    if (readSync2(descriptor, magic, 0, 4, 0) !== 4) {
+      return false;
+    }
+    return [4277009103, 4277009102, 3489328638, 3472551422, 3405691582, 3405691583].includes(magic.readUInt32BE(0));
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+var lcUuid = 27;
+var uuidPattern = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/u;
+function isDsymUuid(value) {
+  return typeof value === "string" && uuidPattern.test(value);
+}
+function readMachOUuids(file) {
+  const descriptor = openSync3(file, "r");
+  try {
+    const read = (offset, length) => {
+      const buffer = Buffer.alloc(length);
+      const bytes = readSync2(descriptor, buffer, 0, length, offset);
+      if (bytes !== length) {
+        throw new Error(`${path3.basename(file)} is not a complete Mach-O file.`);
+      }
+      return buffer;
+    };
+    const magic = read(0, 4).readUInt32BE(0);
+    if (magic === 3405691582 || magic === 3405691583) {
+      const wide = magic === 3405691583;
+      const count = read(4, 4).readUInt32BE(0);
+      if (count === 0 || count > 32) {
+        throw new Error(`${path3.basename(file)} has an invalid universal header.`);
+      }
+      const entrySize = wide ? 32 : 20;
+      const uuids = [];
+      for (let index = 0; index < count; index += 1) {
+        const entry = read(8 + index * entrySize, entrySize);
+        const offset = wide ? Number(entry.readBigUInt64BE(8)) : entry.readUInt32BE(8);
+        uuids.push(...readThinMachOUuid(read, offset, file));
+      }
+      return uuids;
+    }
+    return readThinMachOUuid(read, 0, file);
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+function readThinMachOUuid(read, base, file) {
+  const magicBytes = read(base, 4);
+  const magic = magicBytes.readUInt32LE(0);
+  let headerSize;
+  let littleEndian = true;
+  if (magic === 4277009103) {
+    headerSize = 32;
+  } else if (magic === 4277009102) {
+    headerSize = 28;
+  } else if (magicBytes.readUInt32BE(0) === 4277009103) {
+    headerSize = 32;
+    littleEndian = false;
+  } else if (magicBytes.readUInt32BE(0) === 4277009102) {
+    headerSize = 28;
+    littleEndian = false;
+  } else {
+    throw new Error(`${path3.basename(file)} is not a Mach-O file.`);
+  }
+  const u32 = (buffer, offset2) => littleEndian ? buffer.readUInt32LE(offset2) : buffer.readUInt32BE(offset2);
+  const header = read(base, headerSize);
+  const commandCount = u32(header, 16);
+  const commandBytes = u32(header, 20);
+  if (commandCount > 4096 || commandBytes > 16 * 1024 * 1024) {
+    throw new Error(`${path3.basename(file)} has an invalid Mach-O header.`);
+  }
+  const commands = read(base + headerSize, commandBytes);
+  let offset = 0;
+  for (let index = 0; index < commandCount; index += 1) {
+    if (offset + 8 > commands.length) {
+      break;
+    }
+    const command = u32(commands, offset);
+    const size = u32(commands, offset + 4);
+    if (size < 8 || offset + size > commands.length) {
+      break;
+    }
+    if (command === lcUuid && size >= 24) {
+      const hex = commands.subarray(offset + 8, offset + 24).toString("hex").toUpperCase();
+      return [`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`];
+    }
+    offset += size;
+  }
+  return [];
+}
+
+// node_modules/.cache/mpgd-native-build/tools/target/native-build-attempt.js
 function nativeBuildAttemptPath(gameRoot, target2) {
   assertDeploymentTargetName(target2);
-  return path3.join(gameRoot, "artifacts/native-build-status", `${target2}.json`);
+  return path4.join(gameRoot, "artifacts/native-build-status", `${target2}.json`);
 }
 function readNativeBuildAttempt(gameRoot, target2) {
   const file = nativeBuildAttemptPath(gameRoot, target2);
-  if (!existsSync14(file)) {
+  if (!existsSync15(file)) {
     return void 0;
   }
   const parsed = JSON.parse(readFileSync17(file, "utf8"));
@@ -15409,7 +15601,7 @@ function readNativeBuildAttempt(gameRoot, target2) {
     throw new Error("Native build status must be an object.");
   }
   const record2 = parsed;
-  if (record2.target !== target2 || typeof record2.runId !== "string" || typeof record2.pid !== "number" || !Number.isSafeInteger(record2.pid) || record2.pid < 1 || record2.status !== "building" && record2.status !== "failed" && record2.status !== "success" || record2.artifact !== void 0 && typeof record2.artifact !== "string") {
+  if (record2.target !== target2 || typeof record2.runId !== "string" || typeof record2.pid !== "number" || !Number.isSafeInteger(record2.pid) || record2.pid < 1 || record2.status !== "building" && record2.status !== "failed" && record2.status !== "success" || record2.artifact !== void 0 && typeof record2.artifact !== "string" || record2.symbols !== void 0 && (record2.status !== "success" || !isNativeBuildSymbols(record2.symbols, target2))) {
     throw new Error("Native build status is malformed.");
   }
   return record2;
@@ -15429,28 +15621,44 @@ function beginNativeBuildAttempt(gameRoot, target2) {
     }
     writeRecord(file, record2);
   });
-  function settle(status, artifact) {
+  function settle(status, artifact, symbols) {
     const current = readNativeBuildAttempt(gameRoot, target2);
     if (current?.runId !== record2.runId || current.status !== "building") {
       throw new Error("Native build status was replaced by another attempt.");
     }
-    writeRecord(file, { ...record2, status, ...artifact === void 0 ? {} : { artifact } });
+    writeRecord(file, {
+      ...record2,
+      status,
+      ...artifact === void 0 ? {} : { artifact },
+      ...symbols === void 0 ? {} : { symbols }
+    });
   }
   return {
     runId: record2.runId,
-    complete(artifact) {
-      if (!artifact.startsWith(`release-output/native/${target2}/`) || path3.isAbsolute(artifact) || artifact.split(/[\\/]/u).some((segment) => segment === "" || segment === "..")) {
+    complete(artifact, symbols) {
+      if (!isNativeOutputPath(artifact, target2)) {
         throw new Error("Native build artifact path is invalid.");
       }
-      settle("success", artifact);
+      if (symbols !== void 0) {
+        assertNativeBuildSymbols(symbols, (file2) => isNativeOutputPath(file2, target2));
+      }
+      settle("success", artifact, symbols);
     },
     fail() {
       settle("failed");
     }
   };
 }
+function isNativeBuildSymbols(value, target2) {
+  try {
+    assertNativeBuildSymbols(value, (file) => isNativeOutputPath(file, target2));
+    return true;
+  } catch {
+    return false;
+  }
+}
 function writeRecord(file, record2) {
-  mkdirSync9(path3.dirname(file), { recursive: true });
+  mkdirSync9(path4.dirname(file), { recursive: true });
   const temporary = `${file}.${randomUUID3()}.tmp`;
   try {
     writeFileSync12(temporary, `${JSON.stringify(record2, null, 2)}
@@ -15470,15 +15678,15 @@ function isProcessAlive(pid) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-execution.js
-import { existsSync as existsSync26, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync4, readdirSync as readdirSync8, rmSync as rmSync11, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync4, readdirSync as readdirSync9, rmSync as rmSync11, statSync as statSync7 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname11, isAbsolute as isAbsolute12, join as join15 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/ios-signing-session.js
 import { createHash as createHash12, randomBytes } from "node:crypto";
-import { chmodSync, constants as constants2, copyFileSync as copyFileSync3, existsSync as existsSync15, lstatSync as lstatSync9, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, rmSync as rmSync8, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync, constants as constants2, copyFileSync as copyFileSync3, existsSync as existsSync16, lstatSync as lstatSync10, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, rmSync as rmSync8, writeFileSync as writeFileSync13 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/deploy-process.js
@@ -15798,11 +16006,11 @@ async function prepareIosSigningSession(input) {
   }
   const p12File = requiredCredentialFile(input.p12File, "iOS P12");
   const profileFile = requiredCredentialFile(input.provisioningProfileFile, "iOS profile");
-  const ownedRoot = mkdtempSync2(path4.join(input.temporaryParent ?? tmpdir2(), "mpgd-ios-signing-"));
-  const keychainFile = path4.join(ownedRoot, "signing.keychain-db");
-  const decodedProfile = path4.join(ownedRoot, "profile.plist");
-  const decodedXml = path4.join(ownedRoot, "profile.xml");
-  const exportOptionsPlist = path4.join(ownedRoot, "ExportOptions.plist");
+  const ownedRoot = mkdtempSync2(path5.join(input.temporaryParent ?? tmpdir2(), "mpgd-ios-signing-"));
+  const keychainFile = path5.join(ownedRoot, "signing.keychain-db");
+  const decodedProfile = path5.join(ownedRoot, "profile.plist");
+  const decodedXml = path5.join(ownedRoot, "profile.xml");
+  const exportOptionsPlist = path5.join(ownedRoot, "ExportOptions.plist");
   const keychainPassword = randomBytes(32).toString("hex");
   const environment = {
     ...input.environment ?? process.env,
@@ -15819,12 +16027,12 @@ async function prepareIosSigningSession(input) {
   let installedProfile;
   try {
     chmodSync(ownedRoot, 448);
-    mkdirSync10(path4.join(ownedRoot, "Library", "Preferences"), {
+    mkdirSync10(path5.join(ownedRoot, "Library", "Preferences"), {
       recursive: true,
       mode: 448
     });
-    const helper = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "ios-keychain-import.swift");
-    if (!existsSync15(helper)) {
+    const helper = path5.join(path5.dirname(fileURLToPath(import.meta.url)), "ios-keychain-import.swift");
+    if (!existsSync16(helper)) {
       throw new Error("The installed CLI is missing its iOS signing helper.");
     }
     const imported = await runReleaseProcess({
@@ -15897,13 +16105,13 @@ async function prepareIosSigningSession(input) {
       signal: input.signal
     });
     const profile2 = inspectIosDistributionProfile(parseIosProfilePlist(readFileSync18(decodedXml, "utf8")), { bundleId: input.bundleId, teamId: input.teamId, certificateSha256 });
-    const profileDirectory = path4.join(ownedRoot, "Library", "Developer", "Xcode", "UserData", "Provisioning Profiles");
+    const profileDirectory = path5.join(ownedRoot, "Library", "Developer", "Xcode", "UserData", "Provisioning Profiles");
     mkdirSync10(profileDirectory, { recursive: true, mode: 448 });
-    const destination = path4.join(profileDirectory, `${profile2.uuid}.mobileprovision`);
+    const destination = path5.join(profileDirectory, `${profile2.uuid}.mobileprovision`);
     if (isSymlink(destination)) {
       throw new Error("The iOS provisioning profile destination must not be a symlink.");
     }
-    if (existsSync15(destination)) {
+    if (existsSync16(destination)) {
       if (!readFileSync18(destination).equals(readFileSync18(profileFile))) {
         throw new Error("An existing iOS provisioning profile has the same UUID but different bytes.");
       }
@@ -15966,7 +16174,7 @@ function removeOwnedSigningMaterial(root, profile2) {
   const errors = [];
   if (profile2 !== void 0) {
     try {
-      if (existsSync15(profile2.path) || isSymlink(profile2.path)) {
+      if (existsSync16(profile2.path) || isSymlink(profile2.path)) {
         if (isSymlink(profile2.path) || fileDigest2(profile2.path) !== profile2.sha256) {
           throw new Error("Owned iOS provisioning profile changed before cleanup.");
         }
@@ -15992,10 +16200,10 @@ function fileDigest2(file) {
   return createHash12("sha256").update(readFileSync18(file)).digest("hex");
 }
 function requiredCredentialFile(file, label) {
-  const absolute = path4.resolve(file);
+  const absolute = path5.resolve(file);
   let stat2;
   try {
-    stat2 = lstatSync9(absolute);
+    stat2 = lstatSync10(absolute);
   } catch {
     throw new Error(`${label} is missing or unreadable.`);
   }
@@ -16006,7 +16214,7 @@ function requiredCredentialFile(file, label) {
 }
 function isSymlink(file) {
   try {
-    return lstatSync9(file).isSymbolicLink();
+    return lstatSync10(file).isSymbolicLink();
   } catch {
     return false;
   }
@@ -16025,7 +16233,7 @@ function exportPlist(teamId, bundleId, profileUuid, certificateSha1) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-android-inspection.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync16, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync17, statSync as statSync4 } from "node:fs";
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-inspection-environment.js
 var allowedInspectionEnvironmentNames = [
@@ -16061,10 +16269,10 @@ function nativeInspectionEnvironment(source = process.env) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-android-inspection.js
 function inspectSignedAndroidBundle(input) {
-  if (!existsSync16(input.bundle) || !statSync3(input.bundle).isFile()) {
+  if (!existsSync17(input.bundle) || !statSync4(input.bundle).isFile()) {
     throw new Error("Signed Android app bundle is missing.");
   }
-  if (input.bundletoolJar !== void 0 && !existsSync16(input.bundletoolJar)) {
+  if (input.bundletoolJar !== void 0 && !existsSync17(input.bundletoolJar)) {
     throw new Error("Configured bundletool JAR is missing.");
   }
   const runner = input.runner ?? { run: runCommand };
@@ -16153,25 +16361,25 @@ function runCommand(command, args) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-stage.js
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { cpSync as cpSync3, existsSync as existsSync17, lstatSync as lstatSync10, realpathSync as realpathSync8, rmSync as rmSync9 } from "node:fs";
-import path5 from "node:path";
+import { cpSync as cpSync3, existsSync as existsSync18, lstatSync as lstatSync11, realpathSync as realpathSync8, rmSync as rmSync9 } from "node:fs";
+import path6 from "node:path";
 function createNativeShellStage(input) {
   const sourceShell = realpathSync8(input.shellApp);
-  const declaredShell = path5.resolve(input.shellApp);
-  const declaredWeb = path5.resolve(input.webDir);
-  if (!lstatSync10(sourceShell).isDirectory()) {
+  const declaredShell = path6.resolve(input.shellApp);
+  const declaredWeb = path6.resolve(input.webDir);
+  if (!lstatSync11(sourceShell).isDirectory()) {
     throw new Error("Native shell must be a directory.");
   }
-  const webRelative = path5.relative(declaredShell, declaredWeb);
-  if (webRelative === "" || webRelative.startsWith("..") || path5.isAbsolute(webRelative)) {
+  const webRelative = path6.relative(declaredShell, declaredWeb);
+  if (webRelative === "" || webRelative.startsWith("..") || path6.isAbsolute(webRelative)) {
     throw new Error("Native web directory must be inside its game-owned shell.");
   }
-  const sourceWeb = path5.join(sourceShell, webRelative);
+  const sourceWeb = path6.join(sourceShell, webRelative);
   let checkedPath = sourceShell;
-  for (const segment of webRelative.split(path5.sep)) {
-    checkedPath = path5.join(checkedPath, segment);
+  for (const segment of webRelative.split(path6.sep)) {
+    checkedPath = path6.join(checkedPath, segment);
     try {
-      if (lstatSync10(checkedPath).isSymbolicLink()) {
+      if (lstatSync11(checkedPath).isSymbolicLink()) {
         throw new Error("Native web directory must not traverse a symbolic link.");
       }
     } catch (error) {
@@ -16180,11 +16388,11 @@ function createNativeShellStage(input) {
       }
     }
   }
-  if (existsSync17(sourceWeb) && !lstatSync10(sourceWeb).isDirectory()) {
+  if (existsSync18(sourceWeb) && !lstatSync11(sourceWeb).isDirectory()) {
     throw new Error("Native web directory must be a directory when it exists.");
   }
-  const stage = path5.join(path5.dirname(sourceShell), `.mpgd-native-stage-${randomUUID4()}`);
-  if (existsSync17(stage)) {
+  const stage = path6.join(path6.dirname(sourceShell), `.mpgd-native-stage-${randomUUID4()}`);
+  if (existsSync18(stage)) {
     throw new Error("Native staging path already exists.");
   }
   try {
@@ -16192,12 +16400,12 @@ function createNativeShellStage(input) {
       recursive: true,
       dereference: false,
       filter(source) {
-        const relative14 = path5.relative(sourceShell, source);
-        const segments = relative14.split(path5.sep);
+        const relative14 = path6.relative(sourceShell, source);
+        const segments = relative14.split(path6.sep);
         if (segments.some((segment) => [".gradle", "DerivedData", "Pods", "build"].includes(segment))) {
           return false;
         }
-        if (relative14 !== "" && lstatSync10(source).isSymbolicLink() && segments[0] !== "node_modules") {
+        if (relative14 !== "" && lstatSync11(source).isSymbolicLink() && segments[0] !== "node_modules") {
           throw new Error(`Native shell symlink is unsupported in mutable project inputs: ${relative14}.`);
         }
         return true;
@@ -16205,7 +16413,7 @@ function createNativeShellStage(input) {
     });
     return {
       shellApp: stage,
-      webDir: path5.join(stage, webRelative),
+      webDir: path6.join(stage, webRelative),
       dispose() {
         rmSync9(stage, { recursive: true, force: true });
       }
@@ -16217,8 +16425,8 @@ function createNativeShellStage(input) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-shell-csp.js
-import { existsSync as existsSync18, lstatSync as lstatSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync19, lstatSync as lstatSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
+import path7 from "node:path";
 var capacitorShellContentSecurityPolicy = [
   "default-src 'self'",
   "script-src 'self' 'wasm-unsafe-eval'",
@@ -16262,8 +16470,8 @@ function injectCapacitorShellCsp(html) {
 ${capacitorShellCspMetaTag}${html.slice(insertAt)}`;
 }
 function applyCapacitorShellCsp(webDir) {
-  const indexFile = path6.join(webDir, "index.html");
-  if (!existsSync18(indexFile) || lstatSync11(indexFile).isSymbolicLink()) {
+  const indexFile = path7.join(webDir, "index.html");
+  if (!existsSync19(indexFile) || lstatSync12(indexFile).isSymbolicLink()) {
     throw new Error("Capacitor shell web bundle must contain a regular index.html.");
   }
   const html = readFileSync19(indexFile, "utf8");
@@ -16274,12 +16482,12 @@ function applyCapacitorShellCsp(webDir) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-store-policy.js
-import { existsSync as existsSync21, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "node:fs";
 import { dirname as dirname9, join as join13 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/crash-reporting-starter.js
-import { existsSync as existsSync19, lstatSync as lstatSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync20, lstatSync as lstatSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import path8 from "node:path";
 import { satisfies, valid, validRange } from "semver";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/native-shell-identity.js
@@ -17729,12 +17937,12 @@ var crashReportingAndroidSteps = Object.freeze([
   `In android/app/build.gradle, add apply plugin: '${crashlyticsGradlePluginId}' right after apply plugin: 'com.google.gms.google-services', inside the same google-services.json check.`
 ]);
 var crashReportingIosSteps = Object.freeze([
-  'Upload dSYMs for every App Store build: add the Crashlytics run script build phase ("${BUILD_DIR%/Build/*}/SourcePackages/checkouts/firebase-ios-sdk/Crashlytics/run") as the last phase of the App target, or run upload-symbols after each archive; see docs/CRASH_REPORTING.md in mpgd-kit.'
+  'dSYMs: mpgd deploy run uploads them for every App Store build it makes (retry with mpgd deploy symbols). For an archive made in Xcode or another pipeline, add the Crashlytics run script build phase ("${BUILD_DIR%/Build/*}/SourcePackages/checkouts/firebase-ios-sdk/Crashlytics/run") as the last phase of the App target, or run upload-symbols after the archive; see docs/CRASH_REPORTING.md in mpgd-kit.'
 ]);
 function androidShellHasCrashlytics(shellRoot) {
   const read = (relative14) => {
-    const file = path7.join(shellRoot, relative14);
-    return existsSync19(file) && lstatSync12(file).isFile() ? readFileSync20(file, "utf8") : void 0;
+    const file = path8.join(shellRoot, relative14);
+    return existsSync20(file) && lstatSync13(file).isFile() ? readFileSync20(file, "utf8") : void 0;
   };
   const root = read(androidRootGradle);
   const app = read(androidAppGradle);
@@ -17763,8 +17971,8 @@ function inspectCrashReportingShell(input) {
   }
   const issues = [];
   if (input.platform === "android") {
-    const config2 = path7.join(input.shellApp, "android/app/google-services.json");
-    if (!existsSync19(config2) || !lstatSync12(config2).isFile() || readFileSync20(config2, "utf8").trim() === "") {
+    const config2 = path8.join(input.shellApp, "android/app/google-services.json");
+    if (!existsSync20(config2) || !lstatSync13(config2).isFile() || readFileSync20(config2, "utf8").trim() === "") {
       issues.push({
         level: "error",
         message: `The shell installs ${crashReportingPlugin}, but android/app/google-services.json is missing; Firebase does not start and the release reports no crashes. Download it from the Firebase console (the same file notifications use).`
@@ -17788,8 +17996,8 @@ function inspectCrashReportingShell(input) {
 }
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/native-shell-ios-push-files.js
-import { existsSync as existsSync20, lstatSync as lstatSync13, readdirSync as readdirSync6, readFileSync as readFileSync21 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync21, lstatSync as lstatSync14, readdirSync as readdirSync7, readFileSync as readFileSync21 } from "node:fs";
+import path9 from "node:path";
 var maxSwiftSources = 2e3;
 function readIosPushWiringInput(iosProjectDirectory) {
   const project = readContainedFile(iosProjectDirectory, "App.xcodeproj/project.pbxproj");
@@ -17803,32 +18011,32 @@ function readIosPushWiringInput(iosProjectDirectory) {
   };
 }
 function readContainedFile(root, relative14) {
-  const file = path8.resolve(root, relative14);
-  const within = path8.relative(root, file);
-  if (within === "" || within.startsWith("..") || path8.isAbsolute(within)) {
+  const file = path9.resolve(root, relative14);
+  const within = path9.relative(root, file);
+  if (within === "" || within.startsWith("..") || path9.isAbsolute(within)) {
     return void 0;
   }
   let current = root;
-  for (const segment of within.split(path8.sep)) {
-    current = path8.join(current, segment);
-    if (!existsSync20(current) || lstatSync13(current).isSymbolicLink()) {
+  for (const segment of within.split(path9.sep)) {
+    current = path9.join(current, segment);
+    if (!existsSync21(current) || lstatSync14(current).isSymbolicLink()) {
       return void 0;
     }
   }
-  return lstatSync13(file).isFile() ? readFileSync21(file, "utf8") : void 0;
+  return lstatSync14(file).isFile() ? readFileSync21(file, "utf8") : void 0;
 }
 function listContainedSwiftFiles(root, relativeRoot) {
   const pending = [relativeRoot];
   const files = [];
   while (pending.length > 0) {
     const relative14 = pending.pop() ?? "";
-    const full = path8.join(root, relative14);
-    if (!existsSync20(full) || lstatSync13(full).isSymbolicLink() || !lstatSync13(full).isDirectory()) {
+    const full = path9.join(root, relative14);
+    if (!existsSync21(full) || lstatSync14(full).isSymbolicLink() || !lstatSync14(full).isDirectory()) {
       continue;
     }
-    for (const entry of readdirSync6(full, { withFileTypes: true })) {
-      const child = path8.join(relative14, entry.name);
-      if (entry.isDirectory() && child !== path8.join(relativeRoot, "public")) {
+    for (const entry of readdirSync7(full, { withFileTypes: true })) {
+      const child = path9.join(relative14, entry.name);
+      if (entry.isDirectory() && child !== path9.join(relativeRoot, "public")) {
         pending.push(child);
       } else if (entry.isFile() && entry.name.endsWith(".swift")) {
         files.push(child);
@@ -17844,15 +18052,15 @@ function listContainedSwiftFiles(root, relativeRoot) {
 // node_modules/.cache/mpgd-native-build/tools/target/native-store-policy.js
 function inspectNativeStorePolicy(input) {
   const gameConfig = input.gameRoot === void 0 ? void 0 : join13(input.gameRoot, "mpgd.game.json");
-  const gameConfigJson = gameConfig !== void 0 && existsSync21(gameConfig) ? readJson2(gameConfig) : void 0;
+  const gameConfigJson = gameConfig !== void 0 && existsSync22(gameConfig) ? readJson2(gameConfig) : void 0;
   const orientation = readGameNativeOrientation(gameConfigJson);
   const shellPackage = join13(input.shellApp, "package.json");
-  const shellPackageJson = existsSync21(shellPackage) ? readJson2(shellPackage) : void 0;
+  const shellPackageJson = existsSync22(shellPackage) ? readJson2(shellPackage) : void 0;
   const usesAds = shellUsesAdMob(shellPackageJson);
   const usesPush = shellUsesFirebaseMessaging(shellPackageJson);
   if (input.platform === "ios") {
     const project = join13(input.shellApp, "ios/App/App.xcodeproj/project.pbxproj");
-    if (!existsSync21(project)) {
+    if (!existsSync22(project)) {
       return [];
     }
     const projectSource = readFileSync22(project, "utf8");
@@ -17872,19 +18080,19 @@ function inspectNativeStorePolicy(input) {
       iosProject: projectSource
     }));
     const plist = join13(dirname9(dirname9(project)), readIosReleaseInfoPlist(projectSource));
-    if (existsSync21(plist)) {
+    if (existsSync22(plist)) {
       const plistSource = readFileSync22(plist, "utf8");
       issues.push(...inspectIosInfoPlistStorePolicy(plistSource), ...inspectIosInfoPlistOrientation(plistSource, orientation, deviceFamily ?? "universal"), ...inspectIosInfoPlistAds(plistSource, usesAds));
     }
     return issues;
   }
   const manifest = join13(input.shellApp, "android/app/src/main/AndroidManifest.xml");
-  if (!existsSync21(manifest)) {
+  if (!existsSync22(manifest)) {
     return [];
   }
   const manifestSource = readFileSync22(manifest, "utf8");
   const releaseManifest = join13(input.shellApp, "android/app/src/release/AndroidManifest.xml");
-  const releaseSource = existsSync21(releaseManifest) ? readFileSync22(releaseManifest, "utf8") : "";
+  const releaseSource = existsSync22(releaseManifest) ? readFileSync22(releaseManifest, "utf8") : "";
   return [
     ...inspectAndroidManifestOrientation(manifestSource, orientation),
     ...inspectAndroidManifestAds(`${manifestSource}
@@ -17899,7 +18107,11 @@ ${releaseSource}`, usesAds, usesAds ? readGameAdvertisingIdPolicy(gameConfigJson
 }
 function shellInstallsFirebaseMessaging(shellApp) {
   const shellPackage = join13(shellApp, "package.json");
-  return existsSync21(shellPackage) && shellUsesFirebaseMessaging(readJson2(shellPackage));
+  return existsSync22(shellPackage) && shellUsesFirebaseMessaging(readJson2(shellPackage));
+}
+function shellInstallsCrashlytics(shellApp) {
+  const shellPackage = join13(shellApp, "package.json");
+  return existsSync22(shellPackage) && shellUsesCrashlytics(readJson2(shellPackage));
 }
 function readJson2(file) {
   const source = readFileSync22(file, "utf8");
@@ -17920,16 +18132,36 @@ ${errors.map((issue) => `- ${issue.message}`).join("\n")}`);
   }
 }
 
+// node_modules/.cache/mpgd-native-build/tools/target/ios-simulator-build-settings.js
+var iosSimulatorAppTarget = "App";
+function perTarget(setting) {
+  return `MPGD_SMOKE_${setting}_$(TARGET_NAME)`;
+}
+function iosSimulatorSmokeBuildSettings(swiftConditions = []) {
+  const app = iosSimulatorAppTarget;
+  return [
+    `INFOPLIST_FILE=$(${perTarget("INFOPLIST_FILE")}:default=$(inherited))`,
+    `MPGD_SMOKE_INFOPLIST_FILE_${app}=App/Info-Smoke.plist`,
+    `EXCLUDED_SOURCE_FILE_NAMES=$(inherited) $(${perTarget("EXCLUDED_SOURCE_FILE_NAMES")})`,
+    `MPGD_SMOKE_EXCLUDED_SOURCE_FILE_NAMES_${app}=Main.storyboard LaunchScreen.storyboard Assets.xcassets`,
+    "ASSETCATALOG_COMPILER_APPICON_NAME=",
+    ...swiftConditions.length === 0 ? [] : [
+      `SWIFT_ACTIVE_COMPILATION_CONDITIONS=$(inherited) $(${perTarget("SWIFT_ACTIVE_COMPILATION_CONDITIONS")})`,
+      `MPGD_SMOKE_SWIFT_ACTIVE_COMPILATION_CONDITIONS_${app}=${swiftConditions.join(" ")}`
+    ]
+  ];
+}
+
 // node_modules/.cache/mpgd-native-build/tools/target/native-ios-inspection.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync22, mkdtempSync as mkdtempSync3, readFileSync as readFileSync23, rmSync as rmSync10, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync23, mkdtempSync as mkdtempSync3, readFileSync as readFileSync23, rmSync as rmSync10, statSync as statSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 function inspectSignedIosArchive(archive, input) {
-  return inspectSignedIosApplication(path9.join(archive, "Products/Applications/App.app"), input);
+  return inspectSignedIosApplication(path10.join(archive, "Products/Applications/App.app"), input);
 }
 function inspectSignedIosIpa(ipa, input) {
-  if (!existsSync22(ipa) || !statSync4(ipa).isFile()) {
+  if (!existsSync23(ipa) || !statSync5(ipa).isFile()) {
     throw new Error("iOS store IPA is missing.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -17945,24 +18177,24 @@ function inspectSignedIosIpa(ipa, input) {
   if (appManifests.length !== 1) {
     throw new Error("iOS store IPA must contain exactly one app manifest.");
   }
-  const appRelative = path9.dirname(appManifests[0] ?? "");
-  const extracted = mkdtempSync3(path9.join(tmpdir3(), "mpgd-ios-inspection-"));
+  const appRelative = path10.dirname(appManifests[0] ?? "");
+  const extracted = mkdtempSync3(path10.join(tmpdir3(), "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(path9.join(extracted, appRelative), input);
+    return inspectSignedIosApplication(path10.join(extracted, appRelative), input);
   } finally {
     rmSync10(extracted, { recursive: true, force: true });
   }
 }
 function inspectSignedIosApplication(appPath, input) {
-  const plist = path9.join(appPath, "Info.plist");
-  if (!existsSync22(plist) || !statSync4(plist).isFile()) {
+  const plist = path10.join(appPath, "Info.plist");
+  if (!existsSync23(plist) || !statSync5(plist).isFile()) {
     throw new Error("Signed iOS app manifest is missing.");
   }
-  if (!existsSync22(path9.join(appPath, "Assets.car")) || existsSync22(path9.join(appPath, "Info-Smoke.plist"))) {
+  if (!existsSync23(path10.join(appPath, "Assets.car")) || existsSync23(path10.join(appPath, "Info-Smoke.plist"))) {
     throw new Error("Signed iOS app contains smoke assets or omits release icons.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -18000,14 +18232,14 @@ ${signingInfo.stderr}`;
     return [name, expected];
   }));
   const configFiles = [
-    path9.join(appPath, "capacitor.config.json"),
-    path9.join(appPath, "public/capacitor.config.json")
+    path10.join(appPath, "capacitor.config.json"),
+    path10.join(appPath, "public/capacitor.config.json")
   ];
-  if (!configFiles.some((file) => existsSync22(file))) {
+  if (!configFiles.some((file) => existsSync23(file))) {
     throw new Error("Signed iOS app Capacitor configuration is missing.");
   }
   for (const configFile of configFiles) {
-    if (existsSync22(configFile)) {
+    if (existsSync23(configFile)) {
       assertNoDebugServer(configFile);
     }
   }
@@ -18072,8 +18304,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 existsSync23, statSync as statSync5 } from "node:fs";
-import path10 from "node:path";
+import { existsSync as existsSync24, statSync as statSync6 } from "node:fs";
+import path11 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)) {
@@ -18106,8 +18338,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 = path10.resolve(configuredExportFile);
-  if (!existsSync23(exportOptionsPlist) || !statSync5(exportOptionsPlist).isFile()) {
+  const exportOptionsPlist = path11.resolve(configuredExportFile);
+  if (!existsSync24(exportOptionsPlist) || !statSync6(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], {
@@ -18121,14 +18353,22 @@ function resolveIosSigningPlan(environment, mode) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-release-identity.js
-import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync25, writeFileSync as writeFileSync17 } from "node:fs";
 import { dirname as dirname10, isAbsolute as isAbsolute11, join as join14, relative as relative12, resolve as resolve17 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/capacitor-shell-starter.js
-import { chmodSync as chmodSync2, existsSync as existsSync24, lstatSync as lstatSync14, mkdirSync as mkdirSync11, readdirSync as readdirSync7, readFileSync as readFileSync24, realpathSync as realpathSync9, renameSync as renameSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync16 } from "node:fs";
-import path11 from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync25, lstatSync as lstatSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync8, readFileSync as readFileSync24, realpathSync as realpathSync9, renameSync as renameSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync16 } from "node:fs";
+import path12 from "node:path";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
 import { satisfies as satisfies2, valid as valid2, validRange as validRange2 } from "semver";
+
+// node_modules/.cache/mpgd-native-build/packages/cli/src/pnpm-build-approvals.js
+var notificationsBuildApprovals = Object.freeze({
+  "@firebase/util": false,
+  protobufjs: true
+});
+
+// node_modules/.cache/mpgd-native-build/packages/cli/src/capacitor-shell-starter.js
 var shellPath = "apps/mobile-capacitor";
 var webPath = `${shellPath}/www`;
 var javaKeywords = new Set(`
@@ -18209,7 +18449,7 @@ var androidDataExtractionRulesXml = [
   ""
 ].join("\n");
 function assertAndroidLauncherClasses(nativeDirectory, gradle) {
-  const application = readAndroidApplication(path11.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
+  const application = readAndroidApplication(path12.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
   if (application === void 0) {
     throw new Error("Existing android project launcher activity is missing.");
   }
@@ -18217,8 +18457,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 = path11.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-  const release = existsSync24(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
+  const releaseFile = path12.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
+  const release = existsSync25(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
   if (release !== void 0) {
     assertAndroidLauncherEnabled(release, "Release application");
   }
@@ -18328,7 +18568,7 @@ function resolvesAndroidClass(nativeDirectory, qualified, sourceFiles, visited,
     if (!isNativeFile(nativeDirectory, relative14)) {
       continue;
     }
-    const source = stripSourceCommentsAndStrings(readFileSync24(path11.join(nativeDirectory, relative14), "utf8"));
+    const source = stripSourceCommentsAndStrings(readFileSync24(path12.join(nativeDirectory, relative14), "utf8"));
     const declaredPackage = /\bpackage\s+([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)\s*;?/u.exec(source)?.[1];
     if (declaredPackage !== packageName) {
       continue;
@@ -18384,15 +18624,15 @@ function listNativeFiles(nativeDirectory, relativeRoot, extension) {
   const files = [];
   while (pending.length > 0) {
     const relative14 = pending.pop() ?? "";
-    const full = path11.join(nativeDirectory, relative14);
-    if (!existsSync24(full) || lstatSync14(full).isSymbolicLink()) {
+    const full = path12.join(nativeDirectory, relative14);
+    if (!existsSync25(full) || lstatSync15(full).isSymbolicLink()) {
       continue;
     }
-    for (const entry of readdirSync7(full, { withFileTypes: true })) {
+    for (const entry of readdirSync8(full, { withFileTypes: true })) {
       if (entry.isSymbolicLink()) {
         continue;
       }
-      const child = path11.join(relative14, entry.name);
+      const child = path12.join(relative14, entry.name);
       if (entry.isDirectory()) {
         pending.push(child);
       } else if (entry.isFile() && entry.name.endsWith(extension)) {
@@ -18598,7 +18838,7 @@ function assertReferencedIosFiles(nativeDirectory, project, infoRelative) {
       throw new Error(`Existing ios project is incomplete; referenced app file ${relative14} is missing.`);
     }
   }
-  const info = readFileSync24(path11.join(nativeDirectory, infoRelative), "utf8");
+  const info = readFileSync24(path12.join(nativeDirectory, infoRelative), "utf8");
   assertSceneDelegateFiles(nativeDirectory, info, "Release", compiledSources);
   return compiledSources;
 }
@@ -18729,7 +18969,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("$") || path11.isAbsolute(value)) {
+      if (value.includes("$") || path12.isAbsolute(value)) {
         throw new Error("Existing ios project build input group path is unsupported.");
       }
       parts.push(value);
@@ -18751,7 +18991,7 @@ function assertPbxFileReference(nativeDirectory, project, referenceId, parentGro
   }
   const relative14 = /\bpath\s*=\s*(?:"([^"]+)"|([^;]+))\s*;/u.exec(reference);
   const filePath = (relative14?.[1] ?? relative14?.[2])?.trim();
-  if (filePath === void 0 || filePath.includes("$") || path11.isAbsolute(filePath)) {
+  if (filePath === void 0 || filePath.includes("$") || path12.isAbsolute(filePath)) {
     throw new Error("Existing ios project App build input path is unsupported.");
   }
   if (filePath === "public" || filePath === "capacitor.config.json") {
@@ -18778,19 +19018,19 @@ function assertPbxFileReference(nativeDirectory, project, referenceId, parentGro
   return [resolved];
 }
 function isNativeEntry(directory, relative14) {
-  const file = path11.resolve(directory, relative14);
-  const within = path11.relative(directory, file);
-  if (within === "" || within.startsWith("..") || path11.isAbsolute(within)) {
+  const file = path12.resolve(directory, relative14);
+  const within = path12.relative(directory, file);
+  if (within === "" || within.startsWith("..") || path12.isAbsolute(within)) {
     return false;
   }
   let current = directory;
-  for (const segment of within.split(path11.sep)) {
-    current = path11.join(current, segment);
-    if (!existsSync24(current) || lstatSync14(current).isSymbolicLink()) {
+  for (const segment of within.split(path12.sep)) {
+    current = path12.join(current, segment);
+    if (!existsSync25(current) || lstatSync15(current).isSymbolicLink()) {
       return false;
     }
   }
-  return lstatSync14(file).isFile() || lstatSync14(file).isDirectory();
+  return lstatSync15(file).isFile() || lstatSync15(file).isDirectory();
 }
 function assertSceneDelegateFiles(nativeDirectory, source, label, compiledSources) {
   const values = parsePlistDictionary(source, label);
@@ -18819,7 +19059,7 @@ function assertSceneDelegateFiles(nativeDirectory, source, label, compiledSource
       if (!compiledSources.has(relative14)) {
         return false;
       }
-      const text = stripSourceCommentsAndStrings(readFileSync24(path11.join(nativeDirectory, relative14), "utf8"));
+      const text = stripSourceCommentsAndStrings(readFileSync24(path12.join(nativeDirectory, relative14), "utf8"));
       return hasUsableTopLevelSwiftSceneDelegate(text, className);
     })) {
       throw new Error(`Existing ios project ${label} scene delegate ${delegate} is missing from App Sources.`);
@@ -18844,8 +19084,8 @@ function hasUsableTopLevelSwiftSceneDelegate(source, className) {
   return false;
 }
 function assertAndroidManifestResources(nativeDirectory) {
-  const manifestFiles = ["main", "release"].map((sourceSet) => path11.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync24(file));
-  const resourceRoots = ["main", "release"].map((sourceSet) => path11.join(nativeDirectory, `app/src/${sourceSet}/res`));
+  const manifestFiles = ["main", "release"].map((sourceSet) => path12.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync25(file));
+  const resourceRoots = ["main", "release"].map((sourceSet) => path12.join(nativeDirectory, `app/src/${sourceSet}/res`));
   const references = manifestFiles.flatMap((file) => {
     const manifest = readFileSync24(file, "utf8").replace(/<!--[\s\S]*?-->/gu, "");
     return [...manifest.matchAll(/(?<![\w+])@([a-z]+)\/([A-Za-z_][A-Za-z0-9_.]*)/gu)];
@@ -18854,19 +19094,19 @@ function assertAndroidManifestResources(nativeDirectory) {
     const type = reference[1] ?? "";
     const name = reference[2] ?? "";
     const found = resourceRoots.some((resourceRoot) => {
-      if (!existsSync24(resourceRoot)) {
+      if (!existsSync25(resourceRoot)) {
         return false;
       }
-      const folders = readdirSync7(resourceRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      const folders = readdirSync8(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 readdirSync7(path11.join(resourceRoot, folder)).some((file) => file === `${name}.xml` || file.startsWith(`${name}.`));
+          return readdirSync8(path12.join(resourceRoot, folder)).some((file) => file === `${name}.xml` || file.startsWith(`${name}.`));
         }
         if (folder !== "values") {
           return false;
         }
-        return readdirSync7(path11.join(resourceRoot, folder)).some((file) => file.endsWith(".xml") && readAndroidValueResource(path11.join(resourceRoot, folder, file), type, name).length > 0);
+        return readdirSync8(path12.join(resourceRoot, folder)).some((file) => file.endsWith(".xml") && readAndroidValueResource(path12.join(resourceRoot, folder, file), type, name).length > 0);
       });
     });
     if (!found) {
@@ -18879,13 +19119,13 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
   if (platform === "ios" && !isNativeFile(nativeDirectory, relative14)) {
     throw new Error(`Existing ${platform} project is incomplete; native display name resource is missing.`);
   }
-  const source = platform === "ios" ? readFileSync24(path11.join(nativeDirectory, relative14), "utf8") : "";
+  const source = platform === "ios" ? readFileSync24(path12.join(nativeDirectory, relative14), "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(path11.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
+    const main = readAndroidApplication(path12.join(nativeDirectory, "app/src/main/AndroidManifest.xml"));
     if (main === void 0) {
       throw new Error("Existing android project application label is missing.");
     }
@@ -18904,8 +19144,8 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
         throw new Error("Existing android project launcher label differs from the requested name.");
       }
     }
-    const overlayFile = path11.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-    if (existsSync24(overlayFile)) {
+    const overlayFile = path12.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
+    if (existsSync25(overlayFile)) {
       const release = readAndroidApplication(overlayFile, false);
       if (release !== void 0) {
         if (hasAndroidMergerDirective(release)) {
@@ -18915,7 +19155,7 @@ 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((relative15) => path11.join(nativeDirectory, relative15)).find((file) => existsSync24(file));
+        const appBuildFile = ["app/build.gradle", "app/build.gradle.kts"].map((relative15) => path12.join(nativeDirectory, relative15)).find((file) => existsSync25(file));
         const appGradle = appBuildFile === void 0 ? "" : readFileSync24(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);
@@ -18952,21 +19192,21 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
   }
 }
 function assertAndroidReleaseDisplayName(shellApp, expectedDisplayName) {
-  const nativeDirectory = path11.join(shellApp, "android");
+  const nativeDirectory = path12.join(shellApp, "android");
   assertAndroidManifestResources(nativeDirectory);
   assertNativeDisplayName(nativeDirectory, "android", expectedDisplayName);
 }
 function assertAndroidReleaseLauncherIntegrity(shellApp) {
-  const nativeDirectory = path11.join(shellApp, "android");
+  const nativeDirectory = path12.join(shellApp, "android");
   const gradleRelative = requireOneNativeFile(nativeDirectory, ["app/build.gradle", "app/build.gradle.kts"], "android");
-  const gradle = readFileSync24(path11.join(nativeDirectory, gradleRelative), "utf8");
+  const gradle = readFileSync24(path12.join(nativeDirectory, gradleRelative), "utf8");
   assertAndroidLauncherClasses(nativeDirectory, gradle);
 }
 function assertIosReleaseDisplayName(shellApp, expectedDisplayName) {
-  const nativeDirectory = path11.join(shellApp, "ios");
-  const projectFile = path11.join(nativeDirectory, "App/App.xcodeproj/project.pbxproj");
+  const nativeDirectory = path12.join(shellApp, "ios");
+  const projectFile = path12.join(nativeDirectory, "App/App.xcodeproj/project.pbxproj");
   const project = readFileSync24(projectFile, "utf8");
-  const infoRelative = path11.join("App", readIosReleaseInfoPlist(project));
+  const infoRelative = path12.join("App", readIosReleaseInfoPlist(project));
   if (!isNativeFile(nativeDirectory, infoRelative)) {
     throw new Error("Existing ios project Release Info.plist is missing or unsafe.");
   }
@@ -18976,20 +19216,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((relative14) => path11.basename(relative14) === "InfoPlist.strings")) {
+  if (/\bInfoPlist\.strings\b/u.test(project) || isNativeFile(nativeDirectory, "App/InfoPlist.strings") || files.some((relative14) => path12.basename(relative14) === "InfoPlist.strings")) {
     throw new Error("Existing ios project localized InfoPlist.strings overrides are unsupported.");
   }
 }
 function assertIosArchiveScheme(shellApp) {
-  const nativeDirectory = path11.join(shellApp, "ios");
+  const nativeDirectory = path12.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 = readFileSync24(path11.join(nativeDirectory, projectRelative), "utf8");
+  const project = readFileSync24(path12.join(nativeDirectory, projectRelative), "utf8");
   const appTargetId = readIosAppTargetId(project);
-  const schemeSource = readFileSync24(path11.join(nativeDirectory, schemeRelative), "utf8");
+  const schemeSource = readFileSync24(path12.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.");
@@ -19044,15 +19284,15 @@ 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 = path11.join(nativeDirectory, "app/src/release/res/values");
-  const overlayValues = existsSync24(overlay) && lstatSync14(overlay).isDirectory() ? readdirSync7(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path11.join(overlay, file), "string", key)) : [];
-  const main = path11.join(nativeDirectory, "app/src/main/res/values");
-  const mainValues = existsSync24(main) && lstatSync14(main).isDirectory() ? readdirSync7(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path11.join(main, file), "string", key)) : [];
+  const overlay = path12.join(nativeDirectory, "app/src/release/res/values");
+  const overlayValues = existsSync25(overlay) && lstatSync15(overlay).isDirectory() ? readdirSync8(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path12.join(overlay, file), "string", key)) : [];
+  const main = path12.join(nativeDirectory, "app/src/main/res/values");
+  const mainValues = existsSync25(main) && lstatSync15(main).isDirectory() ? readdirSync8(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path12.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((relative14) => /^values-[^/]+$/u.test(path11.basename(path11.dirname(relative14)))).flatMap((relative14) => readAndroidValueResource(path11.join(nativeDirectory, relative14), "string", key)));
+  const qualified = ["main", "release"].flatMap((sourceSet) => listNativeFiles(nativeDirectory, `app/src/${sourceSet}/res`, ".xml").filter((relative14) => /^values-[^/]+$/u.test(path12.basename(path12.dirname(relative14)))).flatMap((relative14) => readAndroidValueResource(path12.join(nativeDirectory, relative14), "string", key)));
   if (qualified.some((value) => value !== values[0])) {
     throw new Error("Existing android project configuration-qualified application label differs.");
   }
@@ -19119,19 +19359,19 @@ function requireOneNativeFile(directory, candidates, platform) {
   return present[0] ?? "";
 }
 function isNativeFile(directory, relative14) {
-  const file = path11.resolve(directory, relative14);
-  const within = path11.relative(directory, file);
-  if (within === "" || within.startsWith("..") || path11.isAbsolute(within)) {
+  const file = path12.resolve(directory, relative14);
+  const within = path12.relative(directory, file);
+  if (within === "" || within.startsWith("..") || path12.isAbsolute(within)) {
     return false;
   }
   let current = directory;
-  for (const segment of within.split(path11.sep)) {
-    current = path11.join(current, segment);
-    if (!existsSync24(current) || lstatSync14(current).isSymbolicLink()) {
+  for (const segment of within.split(path12.sep)) {
+    current = path12.join(current, segment);
+    if (!existsSync25(current) || lstatSync15(current).isSymbolicLink()) {
       return false;
     }
   }
-  return lstatSync14(file).isFile();
+  return lstatSync15(file).isFile();
 }
 var androidAdvertisingRendererService = "dev.mpgd.capacitor.AdvertisingMessagingService";
 var androidMessagingPluginService = "io.capawesome.capacitorjs.plugins.firebase.messaging.MessagingService";
@@ -19176,7 +19416,7 @@ function assertNativeReleaseIdentity(input) {
     const candidates = [
       join14(input.shellApp, "android/app/build.gradle"),
       join14(input.shellApp, "android/app/build.gradle.kts")
-    ].filter((file) => existsSync25(file));
+    ].filter((file) => existsSync26(file));
     if (candidates.length !== 1) {
       throw new Error("Android native release requires exactly one Gradle app build file.");
     }
@@ -19207,7 +19447,7 @@ function stampNativeReleaseVersions(input) {
     const candidates = [
       join14(input.stagedShellApp, "android/app/build.gradle"),
       join14(input.stagedShellApp, "android/app/build.gradle.kts")
-    ].filter((file3) => existsSync25(file3));
+    ].filter((file3) => existsSync26(file3));
     if (candidates.length !== 1) {
       throw new Error("Android native release requires exactly one Gradle app build file.");
     }
@@ -19483,7 +19723,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) => join14(androidRoot, name)).filter((file) => existsSync25(file));
+  const rootFiles = ["build.gradle", "build.gradle.kts"].map((name) => join14(androidRoot, name)).filter((file) => existsSync26(file));
   if (rootFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android root Gradle build file.");
   }
@@ -19493,7 +19733,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) => join14(androidRoot, name)).filter((file) => existsSync25(file));
+  const settingsFiles = ["settings.gradle", "settings.gradle.kts"].map((name) => join14(androidRoot, name)).filter((file) => existsSync26(file));
   if (settingsFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android settings Gradle file.");
   }
@@ -19829,7 +20069,7 @@ function stripOptionalQuotes(value) {
   return value;
 }
 function readRequiredFile(file, label) {
-  if (!existsSync25(file)) {
+  if (!existsSync26(file)) {
     throw new Error(`Missing ${label}: ${file}`);
   }
   return readFileSync25(file, "utf8");
@@ -19912,6 +20152,7 @@ function executeAndroidBuild(input, stagedShell) {
   const { plan, artifactRoot, environment, target: target2 } = input;
   const androidProject = `${stagedShell}/android`;
   let releaseArtifact;
+  let symbols;
   if (plan.mode === "sync") {
     releaseArtifact = `${artifactRoot}/capacitor-sync`;
     input.replaceDirectory(androidProject, input.targetPath(releaseArtifact));
@@ -19923,6 +20164,12 @@ function executeAndroidBuild(input, stagedShell) {
     input.run("./gradlew", plan.mode === "signed-archive" ? androidSignedReleaseGradleArgs(environment) : ["bundleRelease", "--no-daemon"], environment, androidProject);
     releaseArtifact = `${artifactRoot}/app-release.aab`;
     input.copyFile(`${androidProject}/app/build/outputs/bundle/release/app-release.aab`, input.targetPath(releaseArtifact));
+    const mapping = `${androidProject}/${androidReleaseMappingPath}`;
+    if (existsSync27(mapping) && statSync7(mapping).isFile() && statSync7(mapping).size > 0) {
+      const r8Mapping = `${artifactRoot}/symbols/${nativeSymbolFileNames.r8Mapping}`;
+      input.copyFile(mapping, input.targetPath(r8Mapping));
+      symbols = { r8Mapping };
+    }
     if (plan.mode === "signed-archive") {
       inspectSignedAndroidBundle({
         bundle: input.targetPath(releaseArtifact),
@@ -19936,14 +20183,14 @@ function executeAndroidBuild(input, stagedShell) {
   } else {
     throw new Error(`Unsupported Android build mode: ${plan.mode}.`);
   }
-  return releaseArtifact;
+  return { artifact: releaseArtifact, ...symbols === void 0 ? {} : { symbols } };
 }
 function androidSignedReleaseGradleArgs(environment) {
   const initScript = environment.MPGD_ANDROID_SIGNING_INIT_SCRIPT;
   if (initScript === void 0 || initScript === "") {
     return ["bundleRelease", "--no-daemon"];
   }
-  if (!isAbsolute12(initScript) || !existsSync26(initScript) || !statSync6(initScript).isFile()) {
+  if (!isAbsolute12(initScript) || !existsSync27(initScript) || !statSync7(initScript).isFile()) {
     throw new Error("Android upload signing init script must be an existing absolute file.");
   }
   return ["bundleRelease", "--no-daemon", "--init-script", initScript];
@@ -19966,6 +20213,7 @@ async function executeIosBuild(input, stagedShell) {
 function executeIosBuildWithEnvironment(input, stagedShell, environment) {
   const { plan, artifactRoot, target: target2 } = input;
   let releaseArtifact;
+  let symbols;
   if (plan.mode === "unsigned-archive") {
     releaseArtifact = `${artifactRoot}/App.xcarchive`;
     mkdirSync12(dirname11(input.targetPath(releaseArtifact)), { recursive: true });
@@ -19992,17 +20240,14 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
         "-project",
         "App/App.xcodeproj",
         "-target",
-        "App",
+        iosSimulatorAppTarget,
         "-configuration",
         "Release",
         "-sdk",
         "iphonesimulator",
         `SYMROOT=${buildRoot}`,
         `OBJROOT=${join15(buildRoot, "Intermediates.noindex")}`,
-        "INFOPLIST_FILE=App/Info-Smoke.plist",
-        "EXCLUDED_SOURCE_FILE_NAMES=Main.storyboard LaunchScreen.storyboard Assets.xcassets",
-        "ASSETCATALOG_COMPILER_APPICON_NAME=",
-        "SWIFT_ACTIVE_COMPILATION_CONDITIONS=MPGD_SMOKE_NO_STORYBOARD",
+        ...iosSimulatorSmokeBuildSettings(["MPGD_SMOKE_NO_STORYBOARD"]),
         "CODE_SIGNING_ALLOWED=NO"
       ], environment, `${stagedShell}/ios`);
       input.replaceDirectory(`${buildRoot}/Release-iphonesimulator/App.app`, input.targetPath(releaseArtifact));
@@ -20019,6 +20264,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
     const signing = resolveIosSigningPlan(environment, plan.mode);
     const archiveArtifact = `${artifactRoot}/App.xcarchive`;
     mkdirSync12(dirname11(input.targetPath(archiveArtifact)), { recursive: true });
+    const sourcePackages = shellInstallsCrashlytics(stagedShell) ? join15(stagedShell, "ios", iosCrashlyticsSourcePackagesDirectory) : void 0;
     input.run("xcodebuild", [
       "archive",
       "-project",
@@ -20031,6 +20277,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
       "generic/platform=iOS",
       "-archivePath",
       input.targetPath(archiveArtifact),
+      ...sourcePackages === void 0 ? [] : ["-clonedSourcePackagesDirPath", sourcePackages],
       ...signing.archiveBuildSettings
     ], environment, `${stagedShell}/ios`);
     const expectedIosIdentity = {
@@ -20040,6 +20287,30 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
       expectedTeamId: signing.teamId
     };
     inspectSignedIosArchive(input.targetPath(archiveArtifact), expectedIosIdentity);
+    if (sourcePackages !== void 0) {
+      const symbolRoot = `${artifactRoot}/symbols`;
+      const collected = collectIosCrashlyticsSymbols({
+        archive: input.targetPath(archiveArtifact),
+        iosProject: `${stagedShell}/ios`,
+        sourcePackages,
+        outputDirectory: input.targetPath(symbolRoot),
+        copyFile: input.copyFile,
+        // Without --sequesterRsrc, ditto writes no __MACOSX AppleDouble
+        // entries that upload-symbols could take for `._*.dSYM` bundles.
+        zipDirectory: (source, destination) => {
+          mkdirSync12(dirname11(destination), { recursive: true });
+          input.run("ditto", ["-c", "-k", "--keepParent", source, destination], environment);
+        }
+      });
+      symbols = {
+        crashlytics: {
+          dsymArchive: `${symbolRoot}/${nativeSymbolFileNames.dsymArchive}`,
+          dsyms: collected.dsyms,
+          uploadTool: `${symbolRoot}/${nativeSymbolFileNames.uploadTool}`,
+          googleServiceInfo: `${symbolRoot}/${nativeSymbolFileNames.googleServiceInfo}`
+        }
+      };
+    }
     releaseArtifact = archiveArtifact;
     if (plan.mode === "store-export") {
       const exportRoot = mkdtempSync4(join15(tmpdir4(), "mpgd-ios-export-"));
@@ -20053,7 +20324,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
           "-exportOptionsPlist",
           requireString(signing.exportOptionsPlist, "iOS export options plist")
         ], environment, `${stagedShell}/ios`);
-        const exportedIpas = readdirSync8(exportRoot).filter((name) => name.endsWith(".ipa"));
+        const exportedIpas = readdirSync9(exportRoot).filter((name) => name.endsWith(".ipa"));
         if (exportedIpas.length !== 1) {
           throw new Error("iOS store export must produce exactly one IPA.");
         }
@@ -20070,7 +20341,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
   } else {
     throw new Error(`Unsupported iOS build mode: ${plan.mode}.`);
   }
-  return releaseArtifact;
+  return { artifact: releaseArtifact, ...symbols === void 0 ? {} : { symbols } };
 }
 function requireString(value, label) {
   if (value === void 0 || value.length === 0) {
@@ -20174,7 +20445,7 @@ var releaseManifestEnvKeys = [
 var platformTargets = loadPlatformTargetsConfig();
 var configBaseDir = platformTargets.baseDir;
 var kitLinkCheck = resolve18("tools/workspace/relink-kit-workspace.mjs");
-if (existsSync27(kitLinkCheck)) {
+if (existsSync28(kitLinkCheck)) {
   spawnSync5(process.execPath, [kitLinkCheck, "--warn-unless-owner", configBaseDir], {
     stdio: "inherit"
   });
@@ -20463,7 +20734,7 @@ try {
       if (nativePlan === void 0 || nativeArtifactRoot === void 0 || nativeAttempt === void 0 || nativeWebBundle === void 0) {
         throw new Error("Native build plan is missing.");
       }
-      const releaseArtifact = await executeNativeTargetBuild({
+      const nativeOutput = await executeNativeTargetBuild({
         targetName,
         target,
         profile,
@@ -20479,12 +20750,13 @@ try {
         copyIosSyncSwiftPackage,
         run
       });
+      const releaseArtifact = nativeOutput.artifact;
       if (assetTargetReport !== void 0) {
         await assertAssetPackNativeArtifact(assetTargetReport, targetPath(releaseArtifact));
       }
       await writeRemoteAssetPacks();
       writeManifest(targetName, profile, releaseArtifact, env);
-      nativeAttempt.complete(releaseArtifact);
+      nativeAttempt.complete(releaseArtifact, nativeOutput.symbols);
       nativeCompleted = true;
       break;
     }
@@ -20524,7 +20796,7 @@ function replaceDirectory(source, destination) {
 function mirrorAitRuntimeAssets(gameApp2, wrapperApp) {
   const sourceAssets = `${gameApp2}/dist/assets`;
   const destinationAssets = `${wrapperApp}/public/assets`;
-  if (existsSync27(sourceAssets)) {
+  if (existsSync28(sourceAssets)) {
     replaceDirectory(sourceAssets, destinationAssets);
   } else {
     rmSync12(destinationAssets, { recursive: true, force: true });
@@ -20535,7 +20807,7 @@ async function stageTargetAssetPacks(webOutput) {
     return;
   }
   const destination = join16(webOutput, assetPackTargetNamespace);
-  if (existsSync27(destination)) {
+  if (existsSync28(destination)) {
     throw new Error("mpgd-asset-packs is owned by the target policy; remove source/public copies from the game");
   }
   cpSync4(assetTargetReport.packagedDir, destination, {
@@ -20666,12 +20938,12 @@ function copyFile2(source, destination) {
   cpSync4(source, destination);
 }
 function removeFilesByExtension(directory, extension) {
-  if (!existsSync27(directory)) {
+  if (!existsSync28(directory)) {
     return;
   }
-  for (const file of readdirSync9(directory)) {
+  for (const file of readdirSync10(directory)) {
     const target2 = `${directory}/${file}`;
-    if (file.endsWith(extension) && statSync7(target2).isFile()) {
+    if (file.endsWith(extension) && statSync8(target2).isFile()) {
       rmSync12(target2, { force: true });
     }
   }
@@ -20681,7 +20953,7 @@ function safeArtifactFileStem(value) {
   return stem.length === 0 ? "mpgd-kit" : stem;
 }
 function ensureCapacitorPlatform(shellApp, platform, commandEnv) {
-  if (!existsSync27(`${shellApp}/${platform}`)) {
+  if (!existsSync28(`${shellApp}/${platform}`)) {
     run("pnpm", ["--dir", shellApp, "cap", "add", platform], commandEnv);
   }
 }
@@ -20705,7 +20977,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((path12) => relative13(artifactPath, path12).replaceAll("\\", "/")) : listZipEntries(artifactPath).filter((entry) => basename5(entry) === fileName);
+  const matches = statSync8(artifactPath).isDirectory() ? findNamedArtifactFiles(artifactPath, fileName).map((path13) => relative13(artifactPath, path13).replaceAll("\\", "/")) : listZipEntries(artifactPath).filter((entry) => basename5(entry) === fileName);
   if (matches.length !== 1) {
     throw new Error(`Expected exactly one ${fileName} in release artifact ${artifactPath}; found ${matches.length}.`);
   }
@@ -20717,22 +20989,22 @@ function findEmbeddedIconManifestArtifactPath(artifact) {
 }
 function findNamedArtifactFiles(root, fileName) {
   const matches = [];
-  for (const entry of readdirSync9(root)) {
-    const path12 = join16(root, entry);
-    const stat2 = lstatSync15(path12);
+  for (const entry of readdirSync10(root)) {
+    const path13 = join16(root, entry);
+    const stat2 = lstatSync16(path13);
     if (stat2.isSymbolicLink()) {
       continue;
     }
     if (stat2.isDirectory()) {
-      matches.push(...findNamedArtifactFiles(path12, fileName));
+      matches.push(...findNamedArtifactFiles(path13, fileName));
     } else if (stat2.isFile() && entry === fileName) {
-      matches.push(path12);
+      matches.push(path13);
     }
   }
   return matches;
 }
-function listZipEntries(path12) {
-  const result = spawnSync5("unzip", ["-Z1", path12], {
+function listZipEntries(path13) {
+  const result = spawnSync5("unzip", ["-Z1", path13], {
     cwd: process.cwd(),
     env: nativeInspectionEnvironment(),
     encoding: "utf8"
@@ -20742,7 +21014,7 @@ function listZipEntries(path12) {
   }
   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 ${path12}: ${result.stderr.trim() || `exit ${String(result.status)}`}`);
+    throw new Error(`Failed to list release artifact ${path13}: ${result.stderr.trim() || `exit ${String(result.status)}`}`);
   }
   return result.stdout.split("\n").filter((entry) => entry.length > 0);
 }
@@ -20769,7 +21041,7 @@ function isMiniGameTarget(target2) {
 }
 function buildMiniGameBundle(bundleKind, outputDir, stagingRoot, gameApp2, profile2, commandEnv) {
   const viteConfig = join16(gameApp2, "vite.minigame.config.ts");
-  if (!existsSync27(viteConfig)) {
+  if (!existsSync28(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], {
@@ -20801,11 +21073,11 @@ function withProcessEnv(env2, keys, callback) {
     }
   }
 }
-function targetPath(path12) {
-  return resolveFromPlatformTargetsBase(configBaseDir, path12);
+function targetPath(path13) {
+  return resolveFromPlatformTargetsBase(configBaseDir, path13);
 }
 function findFileByExtension(directory, extension) {
-  const files = readdirSync9(directory).filter((file) => file.endsWith(extension)).sort();
+  const files = readdirSync10(directory).filter((file) => file.endsWith(extension)).sort();
   if (files.length === 0) {
     throw new Error(`Missing ${extension} artifact in ${directory}.`);
   }