@mpgd/cli 0.38.0 → 0.39.0

package/dist/native-build-target.js

@@ -1,8 +1,8 @@
 // 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 existsSync22, lstatSync as lstatSync12, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, readdirSync as readdirSync8, readFileSync as readFileSync21, realpathSync as realpathSync9, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { cpSync as cpSync4, existsSync as existsSync23, lstatSync as lstatSync12, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync5, readdirSync as readdirSync8, readFileSync as readFileSync22, realpathSync as realpathSync9, rmSync as rmSync11, statSync as statSync7, writeFileSync as writeFileSync15 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename4, dirname as dirname9, join as join10, relative as relative9, resolve as resolve14 } from "node:path";
+import { basename as basename4, dirname as dirname9, join as join11, relative as relative9, resolve as resolve14 } from "node:path";
 import { loadEnv } from "vite";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/production-target-readiness.js
@@ -1878,6 +1878,13 @@ var integrationUpperBoundsByRuntime = {
     inboundShare: "unsupported",
     notifications: "unsupported"
   },
+  "oneplay-web": {
+    identityUpgrade: "unsupported",
+    presentation: "available",
+    sharing: "unsupported",
+    inboundShare: "unsupported",
+    notifications: "unsupported"
+  },
   "tiktok-minigame": {
     identityUpgrade: "unsupported",
     presentation: "available",
@@ -1947,7 +1954,7 @@ function normalizeTargetIntegrationConfig(config2) {
 }
 function assertTargetIntegrationRuntimeBounds(runtime, config2, label) {
   const integrations = normalizeTargetIntegrationConfig(config2);
-  if (runtime !== "tiktok-minigame" && runtime !== "verse8-web" && runtime !== "crazygames-web" && runtime !== "web-preview" && runtime !== "wechat-minigame") {
+  if (runtime !== "tiktok-minigame" && runtime !== "verse8-web" && runtime !== "crazygames-web" && runtime !== "oneplay-web" && runtime !== "web-preview" && runtime !== "wechat-minigame") {
     return integrations;
   }
   const upperBounds = integrationUpperBoundsByRuntime[runtime];
@@ -2051,6 +2058,19 @@ function createEffectiveTargetConfig(input) {
   };
 }
 function resolveAuthoritativeGameServicesConfig(config2, platformTarget) {
+  if (config2.runtime === "oneplay-web") {
+    const authority = platformTarget?.authoritativeGameServices === true;
+    const iap = authority && config2.features.iap && config2.monetization.iap;
+    const rewardedAds = authority && config2.features.rewardedAds && config2.monetization.rewardedAds;
+    const interstitialAds = config2.features.interstitialAds && config2.monetization.interstitialAds;
+    const monetization = {
+      ...disabledAuthoritativeMonetization,
+      iap,
+      rewardedAds,
+      interstitialAds
+    };
+    return { ...config2, features: { ...config2.features, ...monetization }, monetization };
+  }
   if (config2.runtime === "crazygames-web") {
     const interstitialAds = platformTarget?.crazyGamesLaunch === "full" && config2.features.interstitialAds && config2.monetization.interstitialAds;
     const monetization = { ...disabledAuthoritativeMonetization, interstitialAds };
@@ -2270,10 +2290,47 @@ function assertCrazyGamesArtifact(root) {
   return { files, bytes };
 }
 
+// node_modules/.cache/mpgd-native-build/tools/target/oneplay-artifact.js
+import { existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+var onePlayFrameAncestors = "https://*.onestore.co.kr https://*.onestore.net";
+function writeOnePlayHostingHeaders(root) {
+  const path10 = join5(root, "_headers");
+  if (!existsSync6(path10)) {
+    writeFileSync4(path10, `/*
+  Content-Security-Policy: frame-ancestors ${onePlayFrameAncestors}
+`);
+  }
+  assertOnePlayArtifact(root);
+}
+function assertOnePlayArtifact(root) {
+  assertNonInstallableWebArtifact(root);
+  const headers = readFileSync8(join5(root, "_headers"), "utf8");
+  let rule = "";
+  let allowed = false;
+  for (const line of headers.split(/\r?\n/u)) {
+    if (/^\S/u.test(line) && !line.startsWith("#")) {
+      rule = line.trim();
+    }
+    const policy = /^\s+Content-Security-Policy:\s*(.+)$/iu.exec(line)?.[1];
+    const directive = policy === void 0 ? void 0 : /(?:^|;)\s*frame-ancestors\s+([^;]+)/iu.exec(policy)?.[1];
+    const origins = directive?.trim().split(/\s+/u);
+    if (rule === "/*" && origins?.includes("https://*.onestore.co.kr") && origins.includes("https://*.onestore.net") && !origins.includes("'none'")) {
+      allowed = true;
+    }
+  }
+  if (!allowed) {
+    throw new Error("ONE play hosting headers must allow both ONE store domain families.");
+  }
+  if (/x-frame-options\s*:\s*(?:deny|sameorigin)/iu.test(headers)) {
+    throw new Error("ONE play hosting headers contain a conflicting X-Frame-Options rule.");
+  }
+}
+
 // node_modules/.cache/mpgd-native-build/tools/target/effective-config.js
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join5 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join6 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/target-name.js
 var deploymentTargetNamePattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
@@ -2330,11 +2387,11 @@ function readConfiguredPath(value) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/io.js
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
 import { pathToFileURL } from "node:url";
 function readJsonFile(path10) {
-  return JSON.parse(readFileSync8(resolve5(path10), "utf8"));
+  return JSON.parse(readFileSync9(resolve5(path10), "utf8"));
 }
 function isCliEntrypoint(metaUrl) {
   const scriptPath = process.argv[1];
@@ -3147,6 +3204,12 @@ function assertPlatformTargetConfigShape(input, target2) {
   if (target2 === "crazygames" && (input.kind !== "web" || input.adapter !== "crazygames")) {
     throw new Error("crazygames target must use the web kind and crazygames adapter.");
   }
+  if (target2 === "oneplay" && (input.kind !== "web" || input.adapter !== "oneplay")) {
+    throw new Error("oneplay target must use the web kind and oneplay adapter.");
+  }
+  if (input.adapter === "oneplay" && (input.kind !== "web" || input.installable !== false)) {
+    throw new Error("ONE play requires a web target with installable: false.");
+  }
   if (input.adapter === "crazygames" && (input.kind !== "web" || input.installable !== false)) {
     throw new Error("CrazyGames requires a web target with installable: false.");
   }
@@ -3367,20 +3430,20 @@ function assertTargetKind(input, target2) {
 import * as _assertGuard_14 from "typia/lib/internal/_assertGuard";
 import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
 import { createHash as createHash2 } from "node:crypto";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import typia4 from "typia";
 var __typia_transform__accessExpressionAsString2 = _accessExpressionAsString_14._accessExpressionAsString;
 var defaultTargetConfigMatrixFile = "packages/target-config/targets.json";
 var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
-  const _iv0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
+  const _iv0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
   const _ip0 = (input) => "boolean" === typeof input["iap"];
   const _ip1 = (input) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"];
   const _ip2 = (input) => "boolean" === typeof input["rewardedAds"];
   const _ip3 = (input) => "boolean" === typeof input["interstitialAds"];
   const _ip4 = (input) => "boolean" === typeof input["localization"];
-  const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
-  const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
-  const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
+  const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
+  const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
+  const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "oneplay-web" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
   const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_14._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
@@ -3411,8 +3474,8 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
     expected: "boolean",
     value: input["localization"]
   }, _errorFactory);
-  const _av1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
-  const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
+  const _av1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
+  const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "oneplay" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
   const _ae2 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported")';
   const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_14._assertGuard(_exceptionable, {
     method: "typia.createAssert",
@@ -3672,15 +3735,15 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   };
 })();
 var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
-  const _iv0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
+  const _iv0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
   const _ip0 = (input) => "boolean" === typeof input["iap"];
   const _ip1 = (input) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"];
   const _ip2 = (input) => "boolean" === typeof input["rewardedAds"];
   const _ip3 = (input) => "boolean" === typeof input["interstitialAds"];
   const _ip4 = (input) => "boolean" === typeof input["localization"];
-  const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
-  const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
-  const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
+  const _iv1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
+  const _av0 = /* @__PURE__ */ new Set(["apps-in-toss", "capacitor-android", "capacitor-ios", "crazygames-web", "devvit-web", "microsoft-store-pwa", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
+  const _ae0 = '("apps-in-toss" | "capacitor-android" | "capacitor-ios" | "crazygames-web" | "devvit-web" | "microsoft-store-pwa" | "oneplay-web" | "tiktok-minigame" | "verse8-web" | "web" | "web-preview" | "wechat-minigame")';
   const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_14._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
@@ -3711,8 +3774,8 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
     expected: "boolean",
     value: input["localization"]
   }, _errorFactory);
-  const _av1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
-  const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
+  const _av1 = /* @__PURE__ */ new Set(["app-store", "apps-in-toss", "crazygames", "devvit", "google-play", "microsoft-store", "oneplay", "tiktok-minigame", "verse8", "web", "web-preview", "wechat-minigame"]);
+  const _ae1 = '("app-store" | "apps-in-toss" | "crazygames" | "devvit" | "google-play" | "microsoft-store" | "oneplay" | "tiktok-minigame" | "verse8" | "web" | "web-preview" | "wechat-minigame")';
   const _ae2 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported")';
   const _ao0 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_14._assertGuard(_exceptionable, {
     method: "typia.createAssert",
@@ -3987,6 +4050,7 @@ var releaseProfileByRuntime = {
   "devvit-web": "devvit",
   "verse8-web": "verse8",
   "crazygames-web": "crazygames",
+  "oneplay-web": "oneplay",
   "wechat-minigame": "wechat-minigame",
   "tiktok-minigame": "tiktok-minigame"
 };
@@ -3996,7 +4060,7 @@ function loadTargetConfigMatrix(baseFile = process.env[targetConfigMatrixFileEnv
     return base;
   }
   const normalizedExtensionsFile = extensionsFile.trim();
-  const fileContent = readFileSync9(normalizedExtensionsFile);
+  const fileContent = readFileSync10(normalizedExtensionsFile);
   const extensions = assertTargetConfigExtensions(JSON.parse(fileContent.toString("utf8")));
   const collisions = Object.keys(extensions.targets).filter((target2) => base.targets[target2] !== void 0);
   if (collisions.length > 0) {
@@ -4110,7 +4174,7 @@ function writeEffectiveTargetConfigs(options = {}) {
     }
     return writeEffectiveTargetConfig(target2, config2, outputDir);
   });
-  const indexPath = join5(outputDir, "index.json");
+  const indexPath = join6(outputDir, "index.json");
   const previousArtifacts = readExistingArtifactIndex(indexPath, matrix.version).artifacts;
   const artifactsByTarget = new Map(previousArtifacts.filter((artifact) => matrix.targets[artifact.target] !== void 0).map((artifact) => [artifact.target, artifact]));
   for (const artifact of artifacts) {
@@ -4123,17 +4187,17 @@ function writeEffectiveTargetConfigs(options = {}) {
   const indexContent = `${JSON.stringify(index, null, 2)}
 `;
   mkdirSync4(dirname5(indexPath), { recursive: true });
-  writeFileSync4(indexPath, indexContent);
+  writeFileSync5(indexPath, indexContent);
   return index;
 }
 function readExistingArtifactIndex(path10, version) {
-  if (!existsSync6(path10)) {
+  if (!existsSync7(path10)) {
     return {
       version,
       artifacts: []
     };
   }
-  const parsed = JSON.parse(readFileSync10(path10, "utf8"));
+  const parsed = JSON.parse(readFileSync11(path10, "utf8"));
   if (parsed.version !== version) {
     return {
       version,
@@ -4144,11 +4208,11 @@ function readExistingArtifactIndex(path10, version) {
 }
 function writeEffectiveTargetConfig(target2, config2, outputDir) {
   assertDeploymentTargetName(target2);
-  const path10 = join5(outputDir, `${target2}.json`);
+  const path10 = join6(outputDir, `${target2}.json`);
   const content = `${JSON.stringify(config2, null, 2)}
 `;
   mkdirSync4(dirname5(path10), { recursive: true });
-  writeFileSync4(path10, content);
+  writeFileSync5(path10, content);
   return {
     target: target2,
     path: path10,
@@ -4241,6 +4305,7 @@ function platformKindForRuntime(runtime) {
       return "devvit-web";
     case "verse8-web":
     case "crazygames-web":
+    case "oneplay-web":
       return "web";
     case "wechat-minigame":
       return "wechat-minigame";
@@ -4266,6 +4331,8 @@ function platformAdapterForRuntime(runtime) {
       return "verse8";
     case "crazygames-web":
       return "crazygames";
+    case "oneplay-web":
+      return "oneplay";
     case "wechat-minigame":
       return "wechat";
     case "tiktok-minigame":
@@ -4281,7 +4348,7 @@ import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
 import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
 import { execFileSync } from "node:child_process";
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync12, realpathSync as realpathSync5, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync13, realpathSync as realpathSync5, renameSync, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "node:fs";
 import { isAbsolute as isAbsolute5, relative as relative5, resolve as resolve8 } from "node:path";
 import typia6 from "typia";
 
@@ -4602,7 +4669,7 @@ function assertReleaseManifest(input) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/release-manifest-lock.js
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync as existsSync7, lstatSync as lstatSync6, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync11, statSync, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { closeSync, existsSync as existsSync8, lstatSync as lstatSync6, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync12, statSync, unlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
 import path2 from "node:path";
 var maximumWaitMs = 3e4;
 var pollingIntervalMs = 50;
@@ -4617,7 +4684,7 @@ function withReleaseManifestLock(file, action) {
     try {
       const descriptor = openSync(lockFile, "wx", 384);
       try {
-        writeFileSync5(descriptor, `${JSON.stringify({ pid: process.pid, token })}
+        writeFileSync6(descriptor, `${JSON.stringify({ pid: process.pid, token })}
 `);
       } catch (error) {
         unlinkSync(lockFile);
@@ -4664,8 +4731,8 @@ function withReleaseManifestLock(file, action) {
   try {
     return action();
   } finally {
-    if (existsSync7(lockFile)) {
-      const contents = readFileSync11(lockFile, "utf8");
+    if (existsSync8(lockFile)) {
+      const contents = readFileSync12(lockFile, "utf8");
       if (contents.includes(token)) {
         unlinkSync(lockFile);
       }
@@ -4675,7 +4742,7 @@ function withReleaseManifestLock(file, action) {
 function canRecoverLock(lockFile) {
   let record;
   try {
-    record = JSON.parse(readFileSync11(lockFile, "utf8"));
+    record = JSON.parse(readFileSync12(lockFile, "utf8"));
   } catch {
     return Date.now() - statSync(lockFile).mtimeMs > incompleteLockGraceMs;
   }
@@ -4901,14 +4968,14 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && input.placements.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
-    path: _path + ".placements[" + _index2 + "]",
+    path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index2 + "]", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
-    path: _path + ".placements[" + _index2 + "]",
+    path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
   }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
@@ -4916,6 +4983,21 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
+  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".sharedPlatformPlacementTargets",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.sharedPlatformPlacementTargets
+  }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".sharedPlatformPlacementTargets[" + _index4 + "]",
+    expected: "string",
+    value: elem
+  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".sharedPlatformPlacementTargets",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.sharedPlatformPlacementTargets
   }, _errorFactory));
   const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("rewarded" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
@@ -5045,7 +5127,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
         value: input
       }, _errorFactory);
   })();
-  const _io0 = (input) => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every((elem) => "object" === typeof elem && null !== elem && _iu0(elem)));
+  const _io0 = (input) => "string" === typeof input.version && (Array.isArray(input.placements) && input.placements.every((elem) => "object" === typeof elem && null !== elem && _iu0(elem))) && (void 0 === input.sharedPlatformPlacementTargets || Array.isArray(input.sharedPlatformPlacementTargets) && input.sharedPlatformPlacementTargets.every((elem) => "string" === typeof elem));
   const _io1 = (input) => _io2(input) && ("rewarded" === input.type && (void 0 === input.reward || "object" === typeof input.reward && null !== input.reward && _iu1(input.reward)));
   const _io2 = (input) => "string" === typeof input.id && ("object" === typeof input.frequencyCap && null !== input.frequencyCap && _io3(input.frequencyCap)) && ("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) && _io4(input.platformPlacementIds));
   const _io3 = (input) => "number" === typeof input.cooldownSeconds && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval);
@@ -5224,7 +5306,7 @@ function requirePortableArtifactPath(path10) {
 }
 function readFileBytes(path10) {
   try {
-    return readFileSync12(path10);
+    return readFileSync13(path10);
   } catch (error) {
     throw new Error(`Failed to read icon manifest ${path10}: ${formatError5(error)}`);
   }
@@ -5250,7 +5332,7 @@ function writeReleaseManifestWithProvenance(input, provenance) {
     const manifest = makeEffectiveConfigPathsPortable(mergeManifest(outputPath, nextManifest), platformTargets2.baseDir);
     const temporary = `${outputPath}.${randomUUID2()}.tmp`;
     try {
-      writeFileSync6(temporary, `${JSON.stringify(manifest, null, 2)}
+      writeFileSync7(temporary, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
       renameSync(temporary, outputPath);
     } finally {
@@ -5260,7 +5342,7 @@ function writeReleaseManifestWithProvenance(input, provenance) {
   });
 }
 function mergeManifest(outputPath, nextManifest) {
-  if (!existsSync8(outputPath)) {
+  if (!existsSync9(outputPath)) {
     return nextManifest;
   }
   let previous;
@@ -5477,7 +5559,7 @@ if (process.env.MPGD_NATIVE_PACKAGED_BUILD !== "1" && isCliEntrypoint(import.met
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/microsoft-store-pwa.js
-import { writeFileSync as writeFileSync7 } from "node:fs";
+import { writeFileSync as writeFileSync8 } from "node:fs";
 import { resolve as resolve10 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/microsoft-store-pwa-e2e.js
@@ -5512,7 +5594,7 @@ function requireNonEmptyString(input, label) {
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/microsoft-store-pwa-release.js
 import { createHash as createHash5 } from "node:crypto";
-import { closeSync as closeSync2, existsSync as existsSync9, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync13, readSync, statSync as statSync2 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync10, openSync as openSync2, readdirSync as readdirSync4, readFileSync as readFileSync14, readSync, statSync as statSync2 } from "node:fs";
 import { relative as relative6, resolve as resolve9, sep as sep3 } from "node:path";
 function assertMicrosoftStorePwaProvenance(input) {
   return {
@@ -5697,7 +5779,7 @@ function listPrecacheEntries(artifactRoot) {
   }
   return files.filter((path10) => !path10.endsWith(".map") && !path10.endsWith(`${sep3}pwa-release.json`) && !path10.endsWith(`${sep3}service-worker.js`)).map((path10) => ({
     url: toPrecacheUrl(artifactRoot, path10),
-    source: readFileSync13(path10)
+    source: readFileSync14(path10)
   })).sort((left, right) => compareCodeUnits(left.url, right.url));
 }
 function normalizePrecacheEntries(entries) {
@@ -5781,9 +5863,9 @@ function writeMicrosoftStorePwaArtifacts(input) {
     revision,
     precacheUrls
   });
-  writeFileSync7(`${artifactRoot}/pwa-release.json`, `${JSON.stringify(evidence, null, 2)}
+  writeFileSync8(`${artifactRoot}/pwa-release.json`, `${JSON.stringify(evidence, null, 2)}
 `);
-  writeFileSync7(`${artifactRoot}/service-worker.js`, createMicrosoftStorePwaServiceWorker(evidence));
+  writeFileSync8(`${artifactRoot}/service-worker.js`, createMicrosoftStorePwaServiceWorker(evidence));
   return evidence;
 }
 function compareCodeUnits2(left, right) {
@@ -5798,8 +5880,8 @@ function readPwaId(input) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/minigame-artifact.js
 import { createHash as createHash6 } from "node:crypto";
-import { copyFileSync as copyFileSync2, cpSync as cpSync2, existsSync as existsSync10, constants as fsConstants, lstatSync as lstatSync7, mkdirSync as mkdirSync6, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync14, realpathSync as realpathSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { basename as basename3, dirname as dirname6, extname, isAbsolute as isAbsolute6, join as join6, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
+import { copyFileSync as copyFileSync2, cpSync as cpSync2, existsSync as existsSync11, constants as fsConstants, lstatSync as lstatSync7, mkdirSync as mkdirSync6, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync15, realpathSync as realpathSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { basename as basename3, dirname as dirname6, extname, isAbsolute as isAbsolute6, join as join7, relative as relative7, resolve as resolve11, sep as sep4 } from "node:path";
 import { parse } from "acorn";
 var miniGameArtifactEvidenceFileName = "mpgd-minigame-artifact.json";
 var miniGameEffectiveTargetConfigFileName = "mpgd-effective-target-config.json";
@@ -5863,14 +5945,14 @@ function assembleMiniGameArtifact(input) {
   assertMiniGameArtifactOutputDirectory(artifactRoot, input.projectRoot);
   const artifactParent = dirname6(artifactRoot);
   mkdirSync6(artifactParent, { recursive: true });
-  const stagingRoot = mkdtempSync(join6(artifactParent, `.${basename3(artifactRoot)}-staging-`));
+  const stagingRoot = mkdtempSync(join7(artifactParent, `.${basename3(artifactRoot)}-staging-`));
   let projectFilesRoot;
   const stagingInput = { ...input, artifactRoot: stagingRoot };
   try {
-    projectFilesRoot = mkdtempSync(join6(artifactParent, `.${basename3(artifactRoot)}-project-files-`));
+    projectFilesRoot = mkdtempSync(join7(artifactParent, `.${basename3(artifactRoot)}-project-files-`));
     copyMiniGameBundleOutput(input.runtimeBundleRoot, stagingRoot);
     copyMiniGameBundleOutput(input.gameBundleRoot, stagingRoot);
-    copyMiniGameArtifactFile(input.effectiveTargetConfigSource, join6(stagingRoot, miniGameEffectiveTargetConfigFileName), miniGameEffectiveTargetConfigFileName);
+    copyMiniGameArtifactFile(input.effectiveTargetConfigSource, join7(stagingRoot, miniGameEffectiveTargetConfigFileName), miniGameEffectiveTargetConfigFileName);
     stageMiniGameIconEvidence(input.generatedIcons, stagingRoot);
     input.writeProjectFiles(projectFilesRoot);
     copyMiniGameBundleOutput(projectFilesRoot, stagingRoot);
@@ -5903,7 +5985,7 @@ function assertMiniGameArtifactOutputDirectory(artifactRoot, projectRoot) {
   assertMiniGameArtifactRelativePath(portableProjectRelativePath, "Mini-game artifact output");
   let candidate = artifact;
   while (candidate !== project) {
-    if (existsSync10(candidate)) {
+    if (existsSync11(candidate)) {
       const status = lstatSync7(candidate);
       if (status.isSymbolicLink()) {
         throw new Error("Mini-game artifact output must not traverse a symbolic link: " + candidate);
@@ -5961,16 +6043,16 @@ function assertDisjointMiniGameTargetOutputs(targets, resolvePath, protectedOutp
 }
 function writeMiniGameArtifactEvidence(input) {
   const artifactRoot = resolve11(input.artifactRoot);
-  const evidencePath = join6(artifactRoot, miniGameArtifactEvidenceFileName);
+  const evidencePath = join7(artifactRoot, miniGameArtifactEvidenceFileName);
   rmSync5(evidencePath, { force: true });
   const files = listMiniGameArtifactFiles(artifactRoot).map((file) => ({
     path: file.path,
     size: file.bytes,
-    sha256: sha2563(readFileSync14(join6(artifactRoot, file.path)))
+    sha256: sha2563(readFileSync15(join7(artifactRoot, file.path)))
   }));
   const effectiveTargetConfig = requireEvidenceFile(artifactRoot, files, miniGameEffectiveTargetConfigFileName);
   const iconManifest = requireEvidenceFile(artifactRoot, files, miniGameIconManifestFileName);
-  const gameConfig = readJson(join6(artifactRoot, "game.json"), "Mini-game game.json");
+  const gameConfig = readJson(join7(artifactRoot, "game.json"), "Mini-game game.json");
   let packageSize = assertMiniGamePackageBudget({
     artifactRoot,
     gameConfig,
@@ -5980,7 +6062,7 @@ function writeMiniGameArtifactEvidence(input) {
   for (let attempt = 0; attempt < 10; attempt += 1) {
     const serialized = `${JSON.stringify(evidence, null, 2)}
 `;
-    writeFileSync8(evidencePath, serialized);
+    writeFileSync9(evidencePath, serialized);
     packageSize = assertMiniGamePackageBudget({
       artifactRoot,
       gameConfig,
@@ -5998,7 +6080,7 @@ function writeMiniGameArtifactEvidence(input) {
 }
 function verifyMiniGameArtifactEvidence(input) {
   const artifactRoot = resolve11(input.artifactRoot);
-  const evidencePath = join6(artifactRoot, miniGameArtifactEvidenceFileName);
+  const evidencePath = join7(artifactRoot, miniGameArtifactEvidenceFileName);
   const parsed = readJson(evidencePath, "Mini-game artifact evidence");
   const evidence = assertMiniGameArtifactEvidenceShape(parsed);
   for (const [field, expected] of [
@@ -6029,7 +6111,7 @@ function verifyMiniGameArtifactEvidence(input) {
     if (actual === void 0 || actual.bytes !== file.size) {
       throw new Error(`Mini-game artifact evidence size mismatch: ${file.path}`);
     }
-    if (sha2563(readFileSync14(join6(artifactRoot, file.path))) !== file.sha256) {
+    if (sha2563(readFileSync15(join7(artifactRoot, file.path))) !== file.sha256) {
       throw new Error(`Mini-game artifact evidence digest mismatch: ${file.path}`);
     }
   }
@@ -6037,7 +6119,7 @@ function verifyMiniGameArtifactEvidence(input) {
   verifyNamedDigest(artifactRoot, evidence.iconManifest, miniGameIconManifestFileName, "icon manifest");
   const packageSize = assertMiniGamePackageBudget({
     artifactRoot,
-    gameConfig: readJson(join6(artifactRoot, "game.json"), "Mini-game game.json"),
+    gameConfig: readJson(join7(artifactRoot, "game.json"), "Mini-game game.json"),
     budget: input.budget
   });
   if (JSON.stringify(packageSize) !== JSON.stringify(evidence.packageSize)) {
@@ -6050,14 +6132,14 @@ function stageMiniGameIconEvidence(generated, artifactRoot) {
   const files = [
     {
       source: generated.manifestPath,
-      destination: join6(artifactRoot, miniGameIconManifestFileName),
+      destination: join7(artifactRoot, miniGameIconManifestFileName),
       relativePath: miniGameIconManifestFileName
     },
     ...generated.manifest.outputs.map((output) => {
       assertMiniGameArtifactRelativePath(output.path, "Mini-game icon output");
       return {
-        source: join6(generated.outputDir, basename3(output.path)),
-        destination: join6(artifactRoot, output.path),
+        source: join7(generated.outputDir, basename3(output.path)),
+        destination: join7(artifactRoot, output.path),
         relativePath: output.path
       };
     })
@@ -6069,7 +6151,7 @@ function stageMiniGameIconEvidence(generated, artifactRoot) {
       throw new Error(`Mini-game icon outputs collide at ${file.relativePath}.`);
     }
     plannedPaths.add(comparisonKey);
-    if (existsSync10(file.destination)) {
+    if (existsSync11(file.destination)) {
       throw new Error(`Mini-game artifact files collide at ${file.relativePath}.`);
     }
   }
@@ -6078,7 +6160,7 @@ function stageMiniGameIconEvidence(generated, artifactRoot) {
   }
 }
 function copyMiniGameArtifactFile(source, destination, relativePath) {
-  if (existsSync10(destination)) {
+  if (existsSync11(destination)) {
     throw new Error(`Mini-game artifact files collide at ${relativePath}.`);
   }
   mkdirSync6(dirname6(destination), { recursive: true });
@@ -6088,7 +6170,7 @@ function configuredNonMiniGameOutputs(targets, resolvePath) {
   return Object.entries(targets).flatMap(([name, target2]) => {
     const viteOutput = {
       name: `${name} Vite output`,
-      path: resolvePath(join6(target2.gameApp, "dist"))
+      path: resolvePath(join7(target2.gameApp, "dist"))
     };
     switch (target2.kind) {
       case "web":
@@ -6110,7 +6192,7 @@ function configuredNonMiniGameOutputs(targets, resolvePath) {
           { name: `${name} web staging output`, path: resolvePath(target2.webDir) },
           {
             name: `${name} wrapper build output`,
-            path: resolvePath(join6(target2.wrapperApp, "dist"))
+            path: resolvePath(join7(target2.wrapperApp, "dist"))
           }
         ];
       case "wechat-minigame":
@@ -6136,7 +6218,7 @@ function canonicalizeThroughExistingAncestor2(path10) {
   const normalizedPath = resolve11(path10);
   const suffix = [];
   let existingAncestor = normalizedPath;
-  while (!existsSync10(existingAncestor)) {
+  while (!existsSync11(existingAncestor)) {
     const parent = dirname6(existingAncestor);
     if (parent === existingAncestor) {
       throw new Error(`Cannot resolve an existing ancestor for mini-game output: ${path10}`);
@@ -6148,15 +6230,15 @@ function canonicalizeThroughExistingAncestor2(path10) {
 }
 function copyMiniGameBundleOutput(sourceRoot, artifactRoot) {
   const source = resolve11(sourceRoot);
-  if (!existsSync10(source)) {
+  if (!existsSync11(source)) {
     throw new Error(`Mini-game bundle output does not exist: ${source}`);
   }
   for (const entry of readdirSync5(source)) {
-    const destination = join6(artifactRoot, entry);
-    if (existsSync10(destination)) {
+    const destination = join7(artifactRoot, entry);
+    if (existsSync11(destination)) {
       throw new Error(`Mini-game bundle outputs collide at ${entry}.`);
     }
-    cpSync2(join6(source, entry), destination, {
+    cpSync2(join7(source, entry), destination, {
       recursive: true,
       errorOnExist: true,
       force: false
@@ -6165,8 +6247,8 @@ function copyMiniGameBundleOutput(sourceRoot, artifactRoot) {
 }
 function replaceMiniGameArtifact(stagingRoot, artifactRoot) {
   let backupRoot;
-  if (existsSync10(artifactRoot)) {
-    backupRoot = mkdtempSync(join6(dirname6(artifactRoot), `.${basename3(artifactRoot)}-backup-`));
+  if (existsSync11(artifactRoot)) {
+    backupRoot = mkdtempSync(join7(dirname6(artifactRoot), `.${basename3(artifactRoot)}-backup-`));
     rmSync5(backupRoot, { force: true, recursive: true });
     renameSync2(artifactRoot, backupRoot);
   }
@@ -6206,11 +6288,11 @@ function assertMiniGameRequiredFiles(artifactRoot) {
     miniGameEffectiveTargetConfigFileName,
     miniGameIconManifestFileName
   ]) {
-    if (!existsSync10(join6(artifactRoot, file))) {
+    if (!existsSync11(join7(artifactRoot, file))) {
       throw new Error(`Mini-game artifact is missing required file: ${file}`);
     }
   }
-  const entry = readFileSync14(join6(artifactRoot, "game.js"), "utf8");
+  const entry = readFileSync15(join7(artifactRoot, "game.js"), "utf8");
   if (entry !== "require('./runtime.js');\nrequire('./game.bundle.js');\n") {
     throw new Error("Mini-game game.js must load runtime.js before game.bundle.js.");
   }
@@ -6220,7 +6302,7 @@ function assertMiniGameJavaScriptSafety(artifactRoot, forbiddenMarkers, forbidde
   const gameOwnedGlobals = new Set(forbiddenGameBundleGlobals);
   const noForbiddenGlobals = /* @__PURE__ */ new Set();
   for (const file of javascript) {
-    const source = readFileSync14(join6(artifactRoot, file.path), "utf8");
+    const source = readFileSync15(join7(artifactRoot, file.path), "utf8");
     assertMiniGameJavaScriptAstSafety(source, file.path, file.path === "runtime.js" ? noForbiddenGlobals : gameOwnedGlobals);
     for (const { pattern, label } of forbiddenJavaScriptPatterns) {
       if (pattern.test(source)) {
@@ -8229,7 +8311,7 @@ function createEvidence(input, files, effectiveTargetConfig, iconManifest, packa
 }
 function requireEvidenceFile(artifactRoot, files, path10) {
   const file = files.find((candidate) => candidate.path === path10);
-  if (file === void 0 || !existsSync10(join6(artifactRoot, path10))) {
+  if (file === void 0 || !existsSync11(join7(artifactRoot, path10))) {
     throw new Error(`Mini-game artifact is missing required evidence file: ${path10}`);
   }
   return file;
@@ -8299,14 +8381,14 @@ function verifyNamedDigest(artifactRoot, reference, expectedPath, label) {
   if (reference.path !== expectedPath) {
     throw new Error(`Mini-game artifact ${label} path mismatch.`);
   }
-  const digest = sha2563(readFileSync14(join6(artifactRoot, reference.path)));
+  const digest = sha2563(readFileSync15(join7(artifactRoot, reference.path)));
   if (digest !== reference.sha256) {
     throw new Error(`Mini-game artifact ${label} digest mismatch.`);
   }
 }
 function readJson(path10, label) {
   try {
-    return JSON.parse(readFileSync14(path10, "utf8"));
+    return JSON.parse(readFileSync15(path10, "utf8"));
   } catch (error) {
     throw new Error(`${label} is unreadable: ${formatError6(error)}`);
   }
@@ -8339,17 +8421,17 @@ function formatError6(error) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/minigame-project-files.js
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join8 } from "node:path";
 var wechatStagingAppId2 = "wx0000000000000000";
 function writeWechatMiniGameProjectFiles(input) {
   assertWechatAppId(input.appId, input.production);
   mkdirSync7(input.artifactRoot, { recursive: true });
-  writeFileSync9(join7(input.artifactRoot, "game.js"), "require('./runtime.js');\nrequire('./game.bundle.js');\n");
-  writeJson(join7(input.artifactRoot, "game.json"), {
+  writeFileSync10(join8(input.artifactRoot, "game.js"), "require('./runtime.js');\nrequire('./game.bundle.js');\n");
+  writeJson(join8(input.artifactRoot, "game.json"), {
     deviceOrientation: input.orientation
   });
-  writeJson(join7(input.artifactRoot, "project.config.json"), {
+  writeJson(join8(input.artifactRoot, "project.config.json"), {
     description: "Experimental mpgd Phaser Canvas Mini Game validation build.",
     setting: {
       urlCheck: input.production,
@@ -8374,12 +8456,12 @@ function assertWechatAppId(appId, production) {
   }
 }
 function writeJson(path10, input) {
-  writeFileSync9(path10, `${JSON.stringify(input, null, 2)}
+  writeFileSync10(path10, `${JSON.stringify(input, null, 2)}
 `);
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/monetization-catalog-env.js
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import { isAbsolute as isAbsolute7, resolve as resolve12 } from "node:path";
 function normalizeMonetizationCatalogEnv(baseEnv, fallbackBaseDir = process.cwd()) {
   const configuredFiles = configuredMonetizationCatalogFilePaths(baseEnv);
@@ -8408,12 +8490,12 @@ function resolveConfiguredBaseDir(baseEnv, fallbackBaseDir, productCatalogFile,
   return fallbackBaseDir;
 }
 function configuredFileExists(baseDir, file) {
-  return existsSync11(isAbsolute7(file) ? file : resolve12(baseDir, file));
+  return existsSync12(isAbsolute7(file) ? file : resolve12(baseDir, file));
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-attempt.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync15, renameSync as renameSync3, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync3, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "node:fs";
 import path3 from "node:path";
 function nativeBuildAttemptPath(gameRoot, target2) {
   assertDeploymentTargetName(target2);
@@ -8421,10 +8503,10 @@ function nativeBuildAttemptPath(gameRoot, target2) {
 }
 function readNativeBuildAttempt(gameRoot, target2) {
   const file = nativeBuildAttemptPath(gameRoot, target2);
-  if (!existsSync12(file)) {
+  if (!existsSync13(file)) {
     return void 0;
   }
-  const parsed = JSON.parse(readFileSync15(file, "utf8"));
+  const parsed = JSON.parse(readFileSync16(file, "utf8"));
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
     throw new Error("Native build status must be an object.");
   }
@@ -8473,7 +8555,7 @@ function writeRecord(file, record) {
   mkdirSync8(path3.dirname(file), { recursive: true });
   const temporary = `${file}.${randomUUID3()}.tmp`;
   try {
-    writeFileSync10(temporary, `${JSON.stringify(record, null, 2)}
+    writeFileSync11(temporary, `${JSON.stringify(record, null, 2)}
 `, { flag: "wx" });
     renameSync3(temporary, file);
   } finally {
@@ -8490,13 +8572,13 @@ function isProcessAlive(pid) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-build-execution.js
-import { existsSync as existsSync21, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, readdirSync as readdirSync7, rmSync as rmSync10, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, mkdtempSync as mkdtempSync4, readdirSync as readdirSync7, rmSync as rmSync10, statSync as statSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute9, join as join9 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute9, join as join10 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/ios-signing-session.js
 import { createHash as createHash8, randomBytes } from "node:crypto";
-import { chmodSync, constants, copyFileSync as copyFileSync3, existsSync as existsSync13, lstatSync as lstatSync8, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { chmodSync, constants, copyFileSync as copyFileSync3, existsSync as existsSync14, lstatSync as lstatSync8, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync17, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
 import { tmpdir } from "node:os";
 import path4 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -8844,7 +8926,7 @@ async function prepareIosSigningSession(input) {
       mode: 448
     });
     const helper = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "ios-keychain-import.swift");
-    if (!existsSync13(helper)) {
+    if (!existsSync14(helper)) {
       throw new Error("The installed CLI is missing its iOS signing helper.");
     }
     const imported = await runReleaseProcess({
@@ -8916,15 +8998,15 @@ async function prepareIosSigningSession(input) {
       timeoutMs: 3e4,
       signal: input.signal
     });
-    const profile2 = inspectIosDistributionProfile(parseIosProfilePlist(readFileSync16(decodedXml, "utf8")), { bundleId: input.bundleId, teamId: input.teamId, certificateSha256 });
+    const profile2 = inspectIosDistributionProfile(parseIosProfilePlist(readFileSync17(decodedXml, "utf8")), { bundleId: input.bundleId, teamId: input.teamId, certificateSha256 });
     const profileDirectory = path4.join(ownedRoot, "Library", "Developer", "Xcode", "UserData", "Provisioning Profiles");
     mkdirSync9(profileDirectory, { recursive: true, mode: 448 });
     const destination = path4.join(profileDirectory, `${profile2.uuid}.mobileprovision`);
     if (isSymlink(destination)) {
       throw new Error("The iOS provisioning profile destination must not be a symlink.");
     }
-    if (existsSync13(destination)) {
-      if (!readFileSync16(destination).equals(readFileSync16(profileFile))) {
+    if (existsSync14(destination)) {
+      if (!readFileSync17(destination).equals(readFileSync17(profileFile))) {
         throw new Error("An existing iOS provisioning profile has the same UUID but different bytes.");
       }
     } else {
@@ -8933,7 +9015,7 @@ async function prepareIosSigningSession(input) {
       installedProfile = { path: destination, sha256: profileSha256 };
       chmodSync(destination, 384);
     }
-    writeFileSync11(exportOptionsPlist, exportPlist(input.teamId, input.bundleId, profile2.uuid, certificateSha1), { mode: 384, flag: "wx" });
+    writeFileSync12(exportOptionsPlist, exportPlist(input.teamId, input.bundleId, profile2.uuid, certificateSha1), { mode: 384, flag: "wx" });
     environment.MPGD_IOS_PROVISIONING_PROFILE_SPECIFIER = profile2.uuid;
     environment.MPGD_IOS_SIGNING_IDENTITY = certificateSha1;
     environment.MPGD_IOS_SIGNING_KEYCHAIN = keychainFile;
@@ -8986,7 +9068,7 @@ function removeOwnedSigningMaterial(root, profile2) {
   const errors = [];
   if (profile2 !== void 0) {
     try {
-      if (existsSync13(profile2.path) || isSymlink(profile2.path)) {
+      if (existsSync14(profile2.path) || isSymlink(profile2.path)) {
         if (isSymlink(profile2.path) || fileDigest(profile2.path) !== profile2.sha256) {
           throw new Error("Owned iOS provisioning profile changed before cleanup.");
         }
@@ -9009,7 +9091,7 @@ function removeOwnedSigningMaterial(root, profile2) {
   }
 }
 function fileDigest(file) {
-  return createHash8("sha256").update(readFileSync16(file)).digest("hex");
+  return createHash8("sha256").update(readFileSync17(file)).digest("hex");
 }
 function requiredCredentialFile(file, label) {
   const absolute = path4.resolve(file);
@@ -9045,7 +9127,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 existsSync14, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync15, statSync as statSync3 } from "node:fs";
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-inspection-environment.js
 var allowedInspectionEnvironmentNames = [
@@ -9081,10 +9163,10 @@ function nativeInspectionEnvironment(source = process.env) {
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-android-inspection.js
 function inspectSignedAndroidBundle(input) {
-  if (!existsSync14(input.bundle) || !statSync3(input.bundle).isFile()) {
+  if (!existsSync15(input.bundle) || !statSync3(input.bundle).isFile()) {
     throw new Error("Signed Android app bundle is missing.");
   }
-  if (input.bundletoolJar !== void 0 && !existsSync14(input.bundletoolJar)) {
+  if (input.bundletoolJar !== void 0 && !existsSync15(input.bundletoolJar)) {
     throw new Error("Configured bundletool JAR is missing.");
   }
   const runner = input.runner ?? { run: runCommand };
@@ -9173,7 +9255,7 @@ 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 existsSync15, lstatSync as lstatSync9, realpathSync as realpathSync7, rmSync as rmSync8 } from "node:fs";
+import { cpSync as cpSync3, existsSync as existsSync16, lstatSync as lstatSync9, realpathSync as realpathSync7, rmSync as rmSync8 } from "node:fs";
 import path5 from "node:path";
 function createNativeShellStage(input) {
   const sourceShell = realpathSync7(input.shellApp);
@@ -9200,11 +9282,11 @@ function createNativeShellStage(input) {
       }
     }
   }
-  if (existsSync15(sourceWeb) && !lstatSync9(sourceWeb).isDirectory()) {
+  if (existsSync16(sourceWeb) && !lstatSync9(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 (existsSync15(stage)) {
+  if (existsSync16(stage)) {
     throw new Error("Native staging path already exists.");
   }
   try {
@@ -9237,7 +9319,7 @@ function createNativeShellStage(input) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-shell-csp.js
-import { existsSync as existsSync16, lstatSync as lstatSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync17, lstatSync as lstatSync10, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
 import path6 from "node:path";
 var capacitorShellContentSecurityPolicy = [
   "default-src 'self'",
@@ -9283,26 +9365,26 @@ ${capacitorShellCspMetaTag}${html.slice(insertAt)}`;
 }
 function applyCapacitorShellCsp(webDir) {
   const indexFile = path6.join(webDir, "index.html");
-  if (!existsSync16(indexFile) || lstatSync10(indexFile).isSymbolicLink()) {
+  if (!existsSync17(indexFile) || lstatSync10(indexFile).isSymbolicLink()) {
     throw new Error("Capacitor shell web bundle must contain a regular index.html.");
   }
-  const html = readFileSync17(indexFile, "utf8");
+  const html = readFileSync18(indexFile, "utf8");
   const hardened = injectCapacitorShellCsp(html);
   if (hardened !== html) {
-    writeFileSync12(indexFile, hardened);
+    writeFileSync13(indexFile, hardened);
   }
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-ios-inspection.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync17, mkdtempSync as mkdtempSync3, readFileSync as readFileSync18, rmSync as rmSync9, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync18, mkdtempSync as mkdtempSync3, readFileSync as readFileSync19, rmSync as rmSync9, statSync as statSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path7 from "node:path";
 function inspectSignedIosArchive(archive, input) {
   return inspectSignedIosApplication(path7.join(archive, "Products/Applications/App.app"), input);
 }
 function inspectSignedIosIpa(ipa, input) {
-  if (!existsSync17(ipa) || !statSync4(ipa).isFile()) {
+  if (!existsSync18(ipa) || !statSync4(ipa).isFile()) {
     throw new Error("iOS store IPA is missing.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -9332,10 +9414,10 @@ function inspectSignedIosIpa(ipa, input) {
 }
 function inspectSignedIosApplication(appPath, input) {
   const plist = path7.join(appPath, "Info.plist");
-  if (!existsSync17(plist) || !statSync4(plist).isFile()) {
+  if (!existsSync18(plist) || !statSync4(plist).isFile()) {
     throw new Error("Signed iOS app manifest is missing.");
   }
-  if (!existsSync17(path7.join(appPath, "Assets.car")) || existsSync17(path7.join(appPath, "Info-Smoke.plist"))) {
+  if (!existsSync18(path7.join(appPath, "Assets.car")) || existsSync18(path7.join(appPath, "Info-Smoke.plist"))) {
     throw new Error("Signed iOS app contains smoke assets or omits release icons.");
   }
   const runner = input.runner ?? { run: runCommand2 };
@@ -9366,18 +9448,18 @@ ${signingInfo.stderr}`;
     path7.join(appPath, "capacitor.config.json"),
     path7.join(appPath, "public/capacitor.config.json")
   ];
-  if (!configFiles.some((file) => existsSync17(file))) {
+  if (!configFiles.some((file) => existsSync18(file))) {
     throw new Error("Signed iOS app Capacitor configuration is missing.");
   }
   for (const configFile of configFiles) {
-    if (existsSync17(configFile)) {
+    if (existsSync18(configFile)) {
       assertNoDebugServer(configFile);
     }
   }
   return { ...observed, teamId: input.expectedTeamId, signed: true };
 }
 function assertNoDebugServer(file) {
-  const value = JSON.parse(readFileSync18(file, "utf8"));
+  const value = JSON.parse(readFileSync19(file, "utf8"));
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error("Signed iOS app has malformed Capacitor configuration.");
   }
@@ -9406,7 +9488,7 @@ 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 existsSync18, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync19, statSync as statSync5 } from "node:fs";
 import path8 from "node:path";
 function resolveIosSigningPlan(environment, mode) {
   const teamId = environment.MPGD_IOS_TEAM_ID?.trim();
@@ -9441,7 +9523,7 @@ function resolveIosSigningPlan(environment, mode) {
     throw new Error("iOS store export requires MPGD_IOS_EXPORT_OPTIONS_PLIST.");
   }
   const exportOptionsPlist = path8.resolve(configuredExportFile);
-  if (!existsSync18(exportOptionsPlist) || !statSync5(exportOptionsPlist).isFile()) {
+  if (!existsSync19(exportOptionsPlist) || !statSync5(exportOptionsPlist).isFile()) {
     throw new Error("iOS export options plist must be an existing host file.");
   }
   const method = spawnSync4("/usr/libexec/PlistBuddy", ["-c", "Print :method", exportOptionsPlist], {
@@ -9455,11 +9537,11 @@ function resolveIosSigningPlan(environment, mode) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/native-release-identity.js
-import { existsSync as existsSync20, readFileSync as readFileSync20 } from "node:fs";
-import { dirname as dirname7, isAbsolute as isAbsolute8, join as join8, relative as relative8, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync21 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute8, join as join9, relative as relative8, resolve as resolve13 } from "node:path";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/capacitor-shell-starter.js
-import { chmodSync as chmodSync2, existsSync as existsSync19, lstatSync as lstatSync11, mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync19, realpathSync as realpathSync8, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync20, lstatSync as lstatSync11, mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync20, realpathSync as realpathSync8, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync14 } from "node:fs";
 import path9 from "node:path";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
 
@@ -9883,7 +9965,7 @@ function assertAndroidLauncherClasses(nativeDirectory, gradle) {
   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 = path9.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-  const release = existsSync19(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
+  const release = existsSync20(releaseFile) ? readAndroidApplication(releaseFile, false) : void 0;
   if (release !== void 0) {
     assertAndroidLauncherEnabled(release, "Release application");
   }
@@ -9993,7 +10075,7 @@ function resolvesAndroidClass(nativeDirectory, qualified, sourceFiles, visited,
     if (!isNativeFile(nativeDirectory, relative10)) {
       continue;
     }
-    const source = stripSourceCommentsAndStrings(readFileSync19(path9.join(nativeDirectory, relative10), "utf8"));
+    const source = stripSourceCommentsAndStrings(readFileSync20(path9.join(nativeDirectory, relative10), "utf8"));
     const declaredPackage = /\bpackage\s+([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)\s*;?/u.exec(source)?.[1];
     if (declaredPackage !== packageName) {
       continue;
@@ -10050,7 +10132,7 @@ function listNativeFiles(nativeDirectory, relativeRoot, extension) {
   while (pending.length > 0) {
     const relative10 = pending.pop() ?? "";
     const full = path9.join(nativeDirectory, relative10);
-    if (!existsSync19(full) || lstatSync11(full).isSymbolicLink()) {
+    if (!existsSync20(full) || lstatSync11(full).isSymbolicLink()) {
       continue;
     }
     for (const entry of readdirSync6(full, { withFileTypes: true })) {
@@ -10263,7 +10345,7 @@ function assertReferencedIosFiles(nativeDirectory, project, infoRelative) {
       throw new Error(`Existing ios project is incomplete; referenced app file ${relative10} is missing.`);
     }
   }
-  const info = readFileSync19(path9.join(nativeDirectory, infoRelative), "utf8");
+  const info = readFileSync20(path9.join(nativeDirectory, infoRelative), "utf8");
   assertSceneDelegateFiles(nativeDirectory, info, "Release", compiledSources);
   return compiledSources;
 }
@@ -10451,7 +10533,7 @@ function isNativeEntry(directory, relative10) {
   let current = directory;
   for (const segment of within.split(path9.sep)) {
     current = path9.join(current, segment);
-    if (!existsSync19(current) || lstatSync11(current).isSymbolicLink()) {
+    if (!existsSync20(current) || lstatSync11(current).isSymbolicLink()) {
       return false;
     }
   }
@@ -10484,7 +10566,7 @@ function assertSceneDelegateFiles(nativeDirectory, source, label, compiledSource
       if (!compiledSources.has(relative10)) {
         return false;
       }
-      const text = stripSourceCommentsAndStrings(readFileSync19(path9.join(nativeDirectory, relative10), "utf8"));
+      const text = stripSourceCommentsAndStrings(readFileSync20(path9.join(nativeDirectory, relative10), "utf8"));
       return hasUsableTopLevelSwiftSceneDelegate(text, className);
     })) {
       throw new Error(`Existing ios project ${label} scene delegate ${delegate} is missing from App Sources.`);
@@ -10509,17 +10591,17 @@ function hasUsableTopLevelSwiftSceneDelegate(source, className) {
   return false;
 }
 function assertAndroidManifestResources(nativeDirectory) {
-  const manifestFiles = ["main", "release"].map((sourceSet) => path9.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync19(file));
+  const manifestFiles = ["main", "release"].map((sourceSet) => path9.join(nativeDirectory, `app/src/${sourceSet}/AndroidManifest.xml`)).filter((file) => existsSync20(file));
   const resourceRoots = ["main", "release"].map((sourceSet) => path9.join(nativeDirectory, `app/src/${sourceSet}/res`));
   const references = manifestFiles.flatMap((file) => {
-    const manifest = readFileSync19(file, "utf8").replace(/<!--[\s\S]*?-->/gu, "");
+    const manifest = readFileSync20(file, "utf8").replace(/<!--[\s\S]*?-->/gu, "");
     return [...manifest.matchAll(/(?<![\w+])@([a-z]+)\/([A-Za-z_][A-Za-z0-9_.]*)/gu)];
   });
   for (const reference of references) {
     const type = reference[1] ?? "";
     const name = reference[2] ?? "";
     const found = resourceRoots.some((resourceRoot) => {
-      if (!existsSync19(resourceRoot)) {
+      if (!existsSync20(resourceRoot)) {
         return false;
       }
       const folders = readdirSync6(resourceRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -10544,7 +10626,7 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
   if (platform === "ios" && !isNativeFile(nativeDirectory, relative10)) {
     throw new Error(`Existing ${platform} project is incomplete; native display name resource is missing.`);
   }
-  const source = platform === "ios" ? readFileSync19(path9.join(nativeDirectory, relative10), "utf8") : "";
+  const source = platform === "ios" ? readFileSync20(path9.join(nativeDirectory, relative10), "utf8") : "";
   const labels = platform === "ios" ? [parsePlistDictionary(source, "Release").get("CFBundleDisplayName")].filter((value) => value?.tagName === "string").map((value) => value?.textContent ?? "") : [];
   if (platform === "ios" && (labels.length !== 1 || labels[0] !== expectedDisplayName)) {
     throw new Error(`Existing ${platform} project display name differs or cannot be read safely.`);
@@ -10570,7 +10652,7 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
       }
     }
     const overlayFile = path9.join(nativeDirectory, "app/src/release/AndroidManifest.xml");
-    if (existsSync19(overlayFile)) {
+    if (existsSync20(overlayFile)) {
       const release = readAndroidApplication(overlayFile, false);
       if (release !== void 0) {
         if (hasAndroidMergerDirective(release)) {
@@ -10580,8 +10662,8 @@ function assertNativeDisplayName(nativeDirectory, platform, expectedDisplayName,
         if (releaseLabel !== null && resolveAndroidLabel(nativeDirectory, releaseLabel) !== expectedDisplayName) {
           throw new Error("Existing android Release application label differs from the requested name.");
         }
-        const appBuildFile = ["app/build.gradle", "app/build.gradle.kts"].map((relative11) => path9.join(nativeDirectory, relative11)).find((file) => existsSync19(file));
-        const appGradle = appBuildFile === void 0 ? "" : readFileSync19(appBuildFile, "utf8");
+        const appBuildFile = ["app/build.gradle", "app/build.gradle.kts"].map((relative11) => path9.join(nativeDirectory, relative11)).find((file) => existsSync20(file));
+        const appGradle = appBuildFile === void 0 ? "" : readFileSync20(appBuildFile, "utf8");
         const manifestPackage = main.parentNode?.getAttribute("package");
         const namespace = /\bnamespace\s*(?:=\s*)?["']([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+)["']/u.exec(stripGradleComments(appGradle))?.[1] ?? (manifestPackage === null || manifestPackage === "" ? void 0 : manifestPackage);
         const launcherNames = /* @__PURE__ */ new Set();
@@ -10624,13 +10706,13 @@ function assertAndroidReleaseDisplayName(shellApp, expectedDisplayName) {
 function assertAndroidReleaseLauncherIntegrity(shellApp) {
   const nativeDirectory = path9.join(shellApp, "android");
   const gradleRelative = requireOneNativeFile(nativeDirectory, ["app/build.gradle", "app/build.gradle.kts"], "android");
-  const gradle = readFileSync19(path9.join(nativeDirectory, gradleRelative), "utf8");
+  const gradle = readFileSync20(path9.join(nativeDirectory, gradleRelative), "utf8");
   assertAndroidLauncherClasses(nativeDirectory, gradle);
 }
 function assertIosReleaseDisplayName(shellApp, expectedDisplayName) {
   const nativeDirectory = path9.join(shellApp, "ios");
   const projectFile = path9.join(nativeDirectory, "App/App.xcodeproj/project.pbxproj");
-  const project = readFileSync19(projectFile, "utf8");
+  const project = readFileSync20(projectFile, "utf8");
   const infoRelative = path9.join("App", readIosReleaseInfoPlist(project));
   if (!isNativeFile(nativeDirectory, infoRelative)) {
     throw new Error("Existing ios project Release Info.plist is missing or unsafe.");
@@ -10652,9 +10734,9 @@ function assertIosArchiveScheme(shellApp) {
   if (!isNativeFile(nativeDirectory, projectRelative) || !isNativeFile(nativeDirectory, schemeRelative)) {
     throw new Error("Existing ios project shared App archive scheme is missing or unsafe.");
   }
-  const project = readFileSync19(path9.join(nativeDirectory, projectRelative), "utf8");
+  const project = readFileSync20(path9.join(nativeDirectory, projectRelative), "utf8");
   const appTargetId = readIosAppTargetId(project);
-  const schemeSource = readFileSync19(path9.join(nativeDirectory, schemeRelative), "utf8");
+  const schemeSource = readFileSync20(path9.join(nativeDirectory, schemeRelative), "utf8");
   const scheme = parseXml(schemeSource, "ios project App archive scheme").documentElement;
   if (scheme?.tagName !== "Scheme") {
     throw new Error("Existing ios project App archive scheme is malformed.");
@@ -10681,7 +10763,7 @@ function hasAndroidMergerDirectiveDeep(element) {
   return hasAndroidMergerDirective(element) || childElements(element).some(hasAndroidMergerDirectiveDeep);
 }
 function readAndroidApplication(file, required = true) {
-  const root = parseXml(readFileSync19(file, "utf8"), "android manifest").documentElement;
+  const root = parseXml(readFileSync20(file, "utf8"), "android manifest").documentElement;
   const application = root === null ? void 0 : childElements(root).find((element) => element.tagName === "application");
   if (root?.tagName !== "manifest" || required && application === void 0) {
     throw new Error("Existing android project manifest application is missing.");
@@ -10710,9 +10792,9 @@ function readAndroidString(nativeDirectory, key) {
     throw new Error("Existing android project application label is unsupported.");
   }
   const overlay = path9.join(nativeDirectory, "app/src/release/res/values");
-  const overlayValues = existsSync19(overlay) && lstatSync11(overlay).isDirectory() ? readdirSync6(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(overlay, file), "string", key)) : [];
+  const overlayValues = existsSync20(overlay) && lstatSync11(overlay).isDirectory() ? readdirSync6(overlay).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(overlay, file), "string", key)) : [];
   const main = path9.join(nativeDirectory, "app/src/main/res/values");
-  const mainValues = existsSync19(main) && lstatSync11(main).isDirectory() ? readdirSync6(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(main, file), "string", key)) : [];
+  const mainValues = existsSync20(main) && lstatSync11(main).isDirectory() ? readdirSync6(main).filter((file) => file.endsWith(".xml")).flatMap((file) => readAndroidValueResource(path9.join(main, file), "string", key)) : [];
   const values = overlayValues.length > 0 ? overlayValues : mainValues;
   if (values.length !== 1) {
     throw new Error("Existing android project application label resource is missing or ambiguous.");
@@ -10724,7 +10806,7 @@ function readAndroidString(nativeDirectory, key) {
   return values[0] ?? "";
 }
 function readAndroidValueResource(file, type, name) {
-  const root = parseXml(readFileSync19(file, "utf8"), "android values resource").documentElement;
+  const root = parseXml(readFileSync20(file, "utf8"), "android values resource").documentElement;
   if (root?.tagName !== "resources") {
     throw new Error("Existing android values resource is malformed.");
   }
@@ -10792,7 +10874,7 @@ function isNativeFile(directory, relative10) {
   let current = directory;
   for (const segment of within.split(path9.sep)) {
     current = path9.join(current, segment);
-    if (!existsSync19(current) || lstatSync11(current).isSymbolicLink()) {
+    if (!existsSync20(current) || lstatSync11(current).isSymbolicLink()) {
       return false;
     }
   }
@@ -10808,14 +10890,14 @@ function assertNativeReleaseIdentity(input) {
   assertNativeVersionMatchesGameVersion(expected, input.environment, input.required);
   if (expected.kind === "android") {
     const candidates = [
-      join8(input.shellApp, "android/app/build.gradle"),
-      join8(input.shellApp, "android/app/build.gradle.kts")
-    ].filter((file) => existsSync20(file));
+      join9(input.shellApp, "android/app/build.gradle"),
+      join9(input.shellApp, "android/app/build.gradle.kts")
+    ].filter((file) => existsSync21(file));
     if (candidates.length !== 1) {
       throw new Error("Android native release requires exactly one Gradle app build file.");
     }
     assertAndroidIdentity(candidates[0] ?? "", expected);
-    assertAndroidAppliedScripts(candidates[0] ?? "", join8(input.shellApp, "android"));
+    assertAndroidAppliedScripts(candidates[0] ?? "", join9(input.shellApp, "android"));
     if (input.required) {
       const name = requireValue(input.metadata?.displayName, "Android target metadata displayName");
       assertAndroidReleaseDisplayName(input.shellApp, name);
@@ -10823,7 +10905,7 @@ function assertNativeReleaseIdentity(input) {
     }
     return;
   }
-  assertIosIdentity(join8(input.shellApp, "ios/App/App.xcodeproj/project.pbxproj"), expected);
+  assertIosIdentity(join9(input.shellApp, "ios/App/App.xcodeproj/project.pbxproj"), expected);
   if (input.required) {
     const name = requireValue(input.metadata?.displayName, "iOS target metadata displayName");
     assertIosReleaseDisplayName(input.shellApp, name);
@@ -10962,7 +11044,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) => join8(androidRoot, name)).filter((file) => existsSync20(file));
+  const rootFiles = ["build.gradle", "build.gradle.kts"].map((name) => join9(androidRoot, name)).filter((file) => existsSync21(file));
   if (rootFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android root Gradle build file.");
   }
@@ -10972,7 +11054,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) => join8(androidRoot, name)).filter((file) => existsSync20(file));
+  const settingsFiles = ["settings.gradle", "settings.gradle.kts"].map((name) => join9(androidRoot, name)).filter((file) => existsSync21(file));
   if (settingsFiles.length !== 1) {
     throw new Error("Native release preflight requires one Android settings Gradle file.");
   }
@@ -10996,7 +11078,7 @@ function assertIosIdentity(file, expected) {
   assertIosSetting(releaseSettings, "MARKETING_VERSION", expected.marketingVersion, file);
   assertIosSetting(releaseSettings, "CURRENT_PROJECT_VERSION", expected.buildNumber, file);
   const plistRelative = readIosReleaseInfoPlist(source);
-  const plist = join8(dirname7(dirname7(file)), plistRelative);
+  const plist = join9(dirname7(dirname7(file)), plistRelative);
   assertIosReleasePlistIdentity(readRequiredFile(plist, "iOS Release Info.plist"));
 }
 function assertIosSetting(settings, key, expected, file) {
@@ -11296,10 +11378,10 @@ function stripOptionalQuotes(value) {
   return value;
 }
 function readRequiredFile(file, label) {
-  if (!existsSync20(file)) {
+  if (!existsSync21(file)) {
     throw new Error(`Missing ${label}: ${file}`);
   }
-  return readFileSync20(file, "utf8");
+  return readFileSync21(file, "utf8");
 }
 function requireFinalSemVer2(value, label) {
   const normalized = requireValue(value, label);
@@ -11400,7 +11482,7 @@ function androidSignedReleaseGradleArgs(environment) {
   if (initScript === void 0 || initScript === "") {
     return ["bundleRelease", "--no-daemon"];
   }
-  if (!isAbsolute9(initScript) || !existsSync21(initScript) || !statSync6(initScript).isFile()) {
+  if (!isAbsolute9(initScript) || !existsSync22(initScript) || !statSync6(initScript).isFile()) {
     throw new Error("Android upload signing init script must be an existing absolute file.");
   }
   return ["bundleRelease", "--no-daemon", "--init-script", initScript];
@@ -11441,7 +11523,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
       "CODE_SIGNING_ALLOWED=NO"
     ], environment, `${stagedShell}/ios`);
   } else if (plan.mode === "simulator") {
-    const buildRoot = mkdtempSync4(join9(tmpdir3(), "mpgd-ios-simulator-"));
+    const buildRoot = mkdtempSync4(join10(tmpdir3(), "mpgd-ios-simulator-"));
     releaseArtifact = `${artifactRoot}/App.app`;
     try {
       input.run("xcodebuild", [
@@ -11455,7 +11537,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
         "-sdk",
         "iphonesimulator",
         `SYMROOT=${buildRoot}`,
-        `OBJROOT=${join9(buildRoot, "Intermediates.noindex")}`,
+        `OBJROOT=${join10(buildRoot, "Intermediates.noindex")}`,
         "INFOPLIST_FILE=App/Info-Smoke.plist",
         "EXCLUDED_SOURCE_FILE_NAMES=Main.storyboard LaunchScreen.storyboard Assets.xcassets",
         "ASSETCATALOG_COMPILER_APPICON_NAME=",
@@ -11499,7 +11581,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
     inspectSignedIosArchive(input.targetPath(archiveArtifact), expectedIosIdentity);
     releaseArtifact = archiveArtifact;
     if (plan.mode === "store-export") {
-      const exportRoot = mkdtempSync4(join9(tmpdir3(), "mpgd-ios-export-"));
+      const exportRoot = mkdtempSync4(join10(tmpdir3(), "mpgd-ios-export-"));
       try {
         input.run("xcodebuild", [
           "-exportArchive",
@@ -11515,7 +11597,7 @@ function executeIosBuildWithEnvironment(input, stagedShell, environment) {
           throw new Error("iOS store export must produce exactly one IPA.");
         }
         releaseArtifact = `${artifactRoot}/App.ipa`;
-        input.copyFile(join9(exportRoot, exportedIpas[0] ?? ""), input.targetPath(releaseArtifact));
+        input.copyFile(join10(exportRoot, exportedIpas[0] ?? ""), input.targetPath(releaseArtifact));
         inspectSignedIosIpa(input.targetPath(releaseArtifact), expectedIosIdentity);
       } finally {
         rmSync10(exportRoot, { recursive: true, force: true });
@@ -11693,7 +11775,7 @@ assertProductionTargetReadiness({
   ...runtimeTargetConfigMatrix.targets[targetName] === void 0 ? {} : { targetPolicy: runtimeTargetConfigMatrix.targets[targetName] },
   ...gameServicesUrl === void 0 ? {} : { gameServicesUrl }
 });
-var nativeWebBundle = nativePlan === void 0 ? void 0 : mkdtempSync5(join10(tmpdir4(), "mpgd-native-web-"));
+var nativeWebBundle = nativePlan === void 0 ? void 0 : mkdtempSync5(join11(tmpdir4(), "mpgd-native-web-"));
 var nativeArtifactRoot = nativeAttempt === void 0 ? void 0 : `release-output/native/${targetName}/${safeArtifactFileStem(profile)}/${nativeAttempt.runId}`;
 var nativeCompleted = false;
 var runtimeTargetConfigMatrixFile = createRuntimeTargetConfigMatrixFile(runtimeTargetConfigMatrix);
@@ -11741,10 +11823,10 @@ try {
     case "wechat-minigame": {
       const outputConfigPath = requireString2(target.output, `${targetName}.output`);
       const output = targetPath(outputConfigPath);
-      const bundleRoot = mkdtempSync5(join10(tmpdir4(), "mpgd-wechat-bundles-"));
+      const bundleRoot = mkdtempSync5(join11(tmpdir4(), "mpgd-wechat-bundles-"));
       try {
-        const runtimeBundleRoot = join10(bundleRoot, "runtime");
-        const gameBundleRoot = join10(bundleRoot, "game");
+        const runtimeBundleRoot = join11(bundleRoot, "runtime");
+        const gameBundleRoot = join11(bundleRoot, "game");
         buildMiniGameBundle("runtime", runtimeBundleRoot, bundleRoot, gameApp, profile, env);
         buildMiniGameBundle("game", gameBundleRoot, bundleRoot, gameApp, profile, env);
         const effectiveTargetConfig = generateEffectiveTargetConfigArtifact(targetName, env);
@@ -11816,6 +11898,9 @@ try {
       } else {
         assertInstallableWebArtifact(output);
       }
+      if (target.adapter === "oneplay") {
+        writeOnePlayHostingHeaders(output);
+      }
       if (target.adapter === "crazygames") {
         assertCrazyGamesArtifact(output);
       }
@@ -11892,9 +11977,9 @@ try {
   rmSync11(dirname9(runtimeTargetConfigMatrixFile), { force: true, recursive: true });
 }
 function createRuntimeTargetConfigMatrixFile(matrix) {
-  const directory = mkdtempSync5(join10(tmpdir4(), "mpgd-target-config-matrix-"));
-  const file = join10(directory, "matrix.json");
-  writeFileSync14(file, `${JSON.stringify(matrix)}
+  const directory = mkdtempSync5(join11(tmpdir4(), "mpgd-target-config-matrix-"));
+  const file = join11(directory, "matrix.json");
+  writeFileSync15(file, `${JSON.stringify(matrix)}
 `);
   return file;
 }
@@ -11914,7 +11999,7 @@ function replaceDirectory(source, destination) {
 function mirrorAitRuntimeAssets(gameApp2, wrapperApp) {
   const sourceAssets = `${gameApp2}/dist/assets`;
   const destinationAssets = `${wrapperApp}/public/assets`;
-  if (existsSync22(sourceAssets)) {
+  if (existsSync23(sourceAssets)) {
     replaceDirectory(sourceAssets, destinationAssets);
   } else {
     rmSync11(destinationAssets, { recursive: true, force: true });
@@ -11996,14 +12081,14 @@ function copyIosSyncSwiftPackage(shellApp, releaseArtifact, packageName, swiftPa
 }
 function rewriteIosSyncSwiftPackagePath(releaseArtifact, packageName, swiftPackageName) {
   const packageFile = targetPath(`${releaseArtifact}/App/CapApp-SPM/Package.swift`);
-  const contents = readFileSync21(packageFile, "utf8");
+  const contents = readFileSync22(packageFile, "utf8");
   const originalPath = readSwiftPackagePath(packageFile, swiftPackageName);
   const rewrittenPath = `../../node_modules/${packageName}`;
   const marker = `.package(name: "${swiftPackageName}", path: "`;
-  writeFileSync14(packageFile, contents.replace(`${marker}${originalPath}"`, `${marker}${rewrittenPath}"`));
+  writeFileSync15(packageFile, contents.replace(`${marker}${originalPath}"`, `${marker}${rewrittenPath}"`));
 }
 function readSwiftPackagePath(packageFile, swiftPackageName) {
-  const contents = readFileSync21(packageFile, "utf8");
+  const contents = readFileSync22(packageFile, "utf8");
   const marker = `.package(name: "${swiftPackageName}", path: "`;
   const index = contents.indexOf(marker);
   if (index < 0 || contents.indexOf(marker, index + marker.length) >= 0) {
@@ -12021,7 +12106,7 @@ function copyFile(source, destination) {
   cpSync4(source, destination);
 }
 function removeFilesByExtension(directory, extension) {
-  if (!existsSync22(directory)) {
+  if (!existsSync23(directory)) {
     return;
   }
   for (const file of readdirSync8(directory)) {
@@ -12036,7 +12121,7 @@ function safeArtifactFileStem(value) {
   return stem.length === 0 ? "mpgd-kit" : stem;
 }
 function ensureCapacitorPlatform(shellApp, platform, commandEnv) {
-  if (!existsSync22(`${shellApp}/${platform}`)) {
+  if (!existsSync23(`${shellApp}/${platform}`)) {
     run("pnpm", ["--dir", shellApp, "cap", "add", platform], commandEnv);
   }
 }
@@ -12073,7 +12158,7 @@ function findEmbeddedIconManifestArtifactPath(artifact) {
 function findNamedArtifactFiles(root, fileName) {
   const matches = [];
   for (const entry of readdirSync8(root)) {
-    const path10 = join10(root, entry);
+    const path10 = join11(root, entry);
     const stat = lstatSync12(path10);
     if (stat.isSymbolicLink()) {
       continue;
@@ -12123,8 +12208,8 @@ function isMiniGameTarget(target2) {
   return target2.kind === "wechat-minigame" || target2.kind === "tiktok-minigame";
 }
 function buildMiniGameBundle(bundleKind, outputDir, stagingRoot, gameApp2, profile2, commandEnv) {
-  const viteConfig = join10(gameApp2, "vite.minigame.config.ts");
-  if (!existsSync22(viteConfig)) {
+  const viteConfig = join11(gameApp2, "vite.minigame.config.ts");
+  if (!existsSync23(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], {