@mpgd/cli 0.46.1 → 0.47.0

package/dist/native-build-target.js

@@ -1882,7 +1882,7 @@ async function verifyAssetPackDelivery(options) {
     positiveIntegerOption(failures, "maxEntryBytes", maxEntryBytes),
     positiveIntegerOption(failures, "maxExpandedBytes", maxExpandedBytes),
     ...Object.entries(hostLimits ?? {}).map(([name, value]) => positiveIntegerOption(failures, `--${name.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)}`, value))
-  ].every((valid) => valid);
+  ].every((valid2) => valid2);
   const startedAt = performance.now();
   const deadlineBreached = () => {
     if (performance.now() - startedAt <= verifyTimeoutMs) {
@@ -4959,9 +4959,230 @@ import { createHash as createHash7 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 
+// node_modules/.cache/mpgd-native-build/adapters/ait/src/iap-config.js
+var defaultAitCatalogTarget = "ait";
+function extractAitIapProductConfig(input, options = {}) {
+  const target2 = options.target ?? defaultAitCatalogTarget;
+  const sourceLabel = options.sourceLabel ?? "product catalog";
+  if (!isRecord2(input) || !Array.isArray(input.products)) {
+    throw new Error(`AIT product catalog is invalid: ${sourceLabel}`);
+  }
+  const products = input.products;
+  const productIds = /* @__PURE__ */ new Set();
+  const skus = /* @__PURE__ */ new Set();
+  const iapProducts = [];
+  for (const [index, product] of products.entries()) {
+    if (!isRecord2(product) || typeof product.id !== "string" || product.id.trim().length === 0) {
+      throw new Error(`AIT product catalog entry at index ${index} is invalid: ${sourceLabel}`);
+    }
+    if (productIds.has(product.id)) {
+      throw new Error(`Duplicate AIT product ID "${product.id}" at index ${index}: ${sourceLabel}`);
+    }
+    productIds.add(product.id);
+    if (product.type === "subscription") {
+      continue;
+    }
+    const identifiers = product.platformProductIds;
+    if (!isRecord2(identifiers) || !Object.prototype.hasOwnProperty.call(identifiers, target2)) {
+      continue;
+    }
+    const value = identifiers[target2];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const sku = value.trim();
+    if (sku.length === 0) {
+      continue;
+    }
+    if (skus.has(sku)) {
+      throw new Error(`Duplicate AIT SKU "${sku}" for ${target2}: ${sourceLabel}`);
+    }
+    skus.add(sku);
+    iapProducts.push({ productId: product.id, sku });
+  }
+  return iapProducts;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// node_modules/.cache/mpgd-native-build/packages/bridge/src/index.js
+import * as _isTypeUint32_12 from "typia/lib/internal/_isTypeUint32";
+import * as _isFormatDateTime_12 from "typia/lib/internal/_isFormatDateTime";
+import * as _assertGuard_14 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
+import typia4 from "typia";
+
+// node_modules/.cache/mpgd-native-build/packages/platform/src/commerce.js
+import * as _isTypeInt64_1 from "typia/lib/internal/_isTypeInt64";
+import * as _isTypeUint32_1 from "typia/lib/internal/_isTypeUint32";
+import * as _isFormatDateTime_1 from "typia/lib/internal/_isFormatDateTime";
+import * as _assertGuard_13 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_13 from "typia/lib/internal/_accessExpressionAsString";
+import typia3 from "typia";
+var commerceErrorCodes = Object.freeze([
+  "USER_CANCELLED",
+  "OUTCOME_UNKNOWN",
+  "ALREADY_OWNED",
+  "IN_PROGRESS",
+  "ITEM_UNAVAILABLE",
+  "NOT_PREPARED",
+  "NETWORK",
+  "STORE_UNAVAILABLE",
+  "CONFIGURATION_REQUIRED",
+  "ACTION_REQUIRED",
+  "ACCOUNT_BINDING_REQUIRED",
+  "INSUFFICIENT_BALANCE",
+  "INVALID_RESPONSE",
+  "UNKNOWN"
+]);
+var commerceBridgeMethods = Object.freeze([
+  "commerce.v2.getCapabilities",
+  "commerce.v2.fetchProducts",
+  "commerce.v2.requestPurchase",
+  "commerce.v2.getAvailablePurchases",
+  "commerce.v2.finishTransaction",
+  "commerce.v2.restorePurchases"
+]);
+var commercePurchaseStates = Object.freeze([
+  "requested",
+  "launched",
+  "pending",
+  "purchased",
+  "verifying",
+  "granted",
+  "finishing",
+  "finished",
+  "cancelled",
+  "failed",
+  "rejected",
+  "revoked"
+]);
+var commercePurchaseTransitions = Object.freeze({
+  requested: Object.freeze(["launched", "cancelled", "failed"]),
+  launched: Object.freeze(["pending", "purchased", "cancelled", "failed"]),
+  pending: Object.freeze(["purchased", "verifying", "cancelled", "failed"]),
+  purchased: Object.freeze(["verifying"]),
+  verifying: Object.freeze(["granted", "pending", "rejected"]),
+  granted: Object.freeze(["finishing", "finished", "revoked"]),
+  finishing: Object.freeze(["finished", "revoked"]),
+  finished: Object.freeze(["revoked"]),
+  cancelled: Object.freeze([]),
+  failed: Object.freeze([]),
+  rejected: Object.freeze([]),
+  revoked: Object.freeze([])
+});
+var terminalCommercePurchaseStates = Object.freeze([
+  "finished",
+  "cancelled",
+  "failed",
+  "rejected",
+  "revoked"
+]);
+var purchaseKindToProductType = Object.freeze({
+  consumable: "consumable",
+  durable: "non_consumable",
+  subscription: "subscription"
+});
+
+// node_modules/.cache/mpgd-native-build/packages/bridge/src/index.js
+var bridgeCommerceV2Methods = commerceBridgeMethods;
+var bridgeCommerceV2MethodSet = new Set(bridgeCommerceV2Methods);
+
+// node_modules/.cache/mpgd-native-build/adapters/devvit/src/catalog-products.js
+var defaultDevvitCatalogTarget = "reddit";
+function createDevvitCommerceBridgeProducts(catalog, target2 = defaultDevvitCatalogTarget) {
+  const skus = /* @__PURE__ */ new Set();
+  const productIds = /* @__PURE__ */ new Set();
+  const products = [];
+  for (const product of catalog.products) {
+    const sku = readSku(product, target2);
+    if (sku === void 0 || product.type === "subscription") {
+      continue;
+    }
+    if (productIds.has(product.id)) {
+      throw new TypeError(`Duplicate Devvit logical product ID: ${product.id}`);
+    }
+    if (skus.has(sku)) {
+      throw new TypeError(`Duplicate Devvit product SKU: ${sku}`);
+    }
+    productIds.add(product.id);
+    skus.add(sku);
+    products.push(Object.freeze({ productId: product.id, sku }));
+  }
+  return Object.freeze(products);
+}
+function readSku(product, target2) {
+  const identifiers = product.platformProductIds;
+  if (!Object.prototype.hasOwnProperty.call(identifiers, target2)) {
+    return void 0;
+  }
+  const value = identifiers[target2];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const sku = value.trim();
+  return sku.length === 0 ? void 0 : sku;
+}
+
+// node_modules/.cache/mpgd-native-build/packages/game-services/src/validation.js
+var gameServicesRequestLimits = {
+  /** Maximum length of any identifier or timestamp string in a client request. */
+  maxStringLength: 256,
+  /** Maximum number of entries accepted inside a platform evidence payload. */
+  maxEvidencePayloadEntries: 64,
+  /** Maximum request body size accepted by the HTTP and oRPC fetch handlers. */
+  maxBodyBytes: 64 * 1024
+};
+
+// node_modules/.cache/mpgd-native-build/packages/game-services/src/types.js
+var reservedDeploymentTargetNames = /* @__PURE__ */ new Set([
+  "aux",
+  "browser",
+  "con",
+  "devvit",
+  "index",
+  "msstore",
+  "nul",
+  "prn",
+  "constructor",
+  "prototype",
+  ...Array.from({ length: 9 }, (_, index) => `com${String(index + 1)}`),
+  ...Array.from({ length: 9 }, (_, index) => `lpt${String(index + 1)}`)
+]);
+
+// node_modules/.cache/mpgd-native-build/packages/game-services/src/commerce-evidence-registry.js
+var defaultPurchaseCapabilities = Object.freeze({
+  consumable: true,
+  durable: true,
+  subscription: false
+});
+var referenceCommerceLedgerTargets = Object.freeze({
+  "google-play": Object.freeze(["android"]),
+  "app-store": Object.freeze(["ios"]),
+  "microsoft-store": Object.freeze(["microsoft-store"]),
+  "apps-in-toss": Object.freeze(["ait"]),
+  devvit: Object.freeze(["reddit"]),
+  verse8: Object.freeze(["verse8"])
+});
+var referenceCommercePurchaseCapabilities = Object.freeze({
+  "google-play": Object.freeze({ consumable: true, durable: true, subscription: false }),
+  "app-store": Object.freeze({ consumable: true, durable: true, subscription: false }),
+  "microsoft-store": Object.freeze({ consumable: true, durable: false, subscription: false }),
+  "apps-in-toss": Object.freeze({ consumable: true, durable: true, subscription: false }),
+  devvit: Object.freeze({ consumable: true, durable: true, subscription: false }),
+  verse8: Object.freeze({ consumable: true, durable: true, subscription: false })
+});
+
+// node_modules/.cache/mpgd-native-build/adapters/devvit/src/server/post-operation.js
+var maximumLeaseTtlMs = 60 * 60 * 1e3;
+
+// node_modules/.cache/mpgd-native-build/packages/game-services/src/verified-leaderboard.js
+var timestampPattern = new RegExp("^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d{1,3}))?(Z|([+-])(\\d{2}):(\\d{2}))$");
+
 // node_modules/.cache/mpgd-native-build/packages/cli/src/target-name.js
 var deploymentTargetNamePattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-var reservedDeploymentTargetNames = /* @__PURE__ */ new Set([
+var reservedDeploymentTargetNames2 = /* @__PURE__ */ new Set([
   "aux",
   "browser",
   "con",
@@ -4977,7 +5198,7 @@ var reservedDeploymentTargetNames = /* @__PURE__ */ new Set([
 ]);
 var maximumDeploymentTargetNameLength = 64;
 function assertDeploymentTargetName(target2) {
-  if (!deploymentTargetNamePattern.test(target2) || target2.length > maximumDeploymentTargetNameLength || reservedDeploymentTargetNames.has(target2)) {
+  if (!deploymentTargetNamePattern.test(target2) || target2.length > maximumDeploymentTargetNameLength || reservedDeploymentTargetNames2.has(target2)) {
     throw new Error(`Invalid deployment target name: ${target2}. Use lowercase kebab-case and avoid reserved names.`);
   }
 }
@@ -5214,7 +5435,7 @@ function assertMiniGameArtifactPathsPortable(paths) {
   }
 }
 function readMiniGameSubpackages(gameConfig) {
-  if (!isRecord2(gameConfig)) {
+  if (!isRecord3(gameConfig)) {
     throw new Error("Mini-game game.json must contain a JSON object.");
   }
   if (gameConfig.subpackages === void 0) {
@@ -5224,7 +5445,7 @@ function readMiniGameSubpackages(gameConfig) {
     throw new Error("Mini-game game.json subpackages must be an array.");
   }
   return gameConfig.subpackages.map((input, index) => {
-    if (!isRecord2(input) || typeof input.root !== "string") {
+    if (!isRecord3(input) || typeof input.root !== "string") {
       throw new Error(`Mini-game subpackage ${String(index)} must define a string root.`);
     }
     if (input.independent !== void 0 && typeof input.independent !== "boolean") {
@@ -5306,7 +5527,7 @@ function assertMiniGameArtifactPathAllowed(path10) {
     throw new Error(`Mini-game Canvas MVP does not support audio assets yet: ${path10}`);
   }
 }
-function isRecord2(input) {
+function isRecord3(input) {
   return typeof input === "object" && input !== null && !Array.isArray(input);
 }
 function formatError4(error) {
@@ -5314,10 +5535,10 @@ function formatError4(error) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/schemas.js
-import * as _assertGuard_13 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_13 from "typia/lib/internal/_accessExpressionAsString";
-import typia3 from "typia";
-var __typia_transform__accessExpressionAsString = _accessExpressionAsString_13._accessExpressionAsString;
+import * as _assertGuard_15 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_15 from "typia/lib/internal/_accessExpressionAsString";
+import typia5 from "typia";
+var __typia_transform__accessExpressionAsString = _accessExpressionAsString_15._accessExpressionAsString;
 var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   const _ip0 = (input) => void 0 === input["assetPacks"] || "object" === typeof input["assetPacks"] && null !== input["assetPacks"] && _io3(input["assetPacks"]);
   const _ip1 = (input) => "string" === typeof input["gameApp"];
@@ -5329,75 +5550,75 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   const _ip7 = (input) => "string" === typeof input["wrapperApp"];
   const _ip8 = (input) => "string" === typeof input["webDir"];
   const _ip9 = (input) => "string" === typeof input["output"];
-  const _ap0 = (input, _path, _exceptionable = true) => void 0 === input["assetPacks"] || ("object" === typeof input["assetPacks"] && null !== input["assetPacks"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => void 0 === input["assetPacks"] || ("object" === typeof input["assetPacks"] && null !== input["assetPacks"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".assetPacks",
     expected: "(AssetPackTargetPolicy | undefined)",
     value: input["assetPacks"]
-  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".assetPacks",
     expected: "(AssetPackTargetPolicy | undefined)",
     value: input["assetPacks"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["gameApp"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["gameApp"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gameApp",
     expected: "string",
     value: input["gameApp"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["adapter"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["adapter"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".adapter",
     expected: "string",
     value: input["adapter"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => void 0 === input["metadata"] || ("object" === typeof input["metadata"] && null !== input["metadata"] && false === Array.isArray(input["metadata"]) || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => void 0 === input["metadata"] || ("object" === typeof input["metadata"] && null !== input["metadata"] && false === Array.isArray(input["metadata"]) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".metadata",
     expected: "(TargetReleaseMetadata | undefined)",
     value: input["metadata"]
-  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".metadata",
     expected: "(TargetReleaseMetadata | undefined)",
     value: input["metadata"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => void 0 === input["authoritativeGameServices"] || "boolean" === typeof input["authoritativeGameServices"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => void 0 === input["authoritativeGameServices"] || "boolean" === typeof input["authoritativeGameServices"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".authoritativeGameServices",
     expected: "(boolean | undefined)",
     value: input["authoritativeGameServices"]
   }, _errorFactory);
-  const _ap5 = (input, _path, _exceptionable = true) => void 0 === input["integrations"] || ("object" === typeof input["integrations"] && null !== input["integrations"] && false === Array.isArray(input["integrations"]) || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap5 = (input, _path, _exceptionable = true) => void 0 === input["integrations"] || ("object" === typeof input["integrations"] && null !== input["integrations"] && false === Array.isArray(input["integrations"]) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(Partial<TargetIntegrationConfig> | undefined)",
     value: input["integrations"]
-  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(Partial<TargetIntegrationConfig> | undefined)",
     value: input["integrations"]
   }, _errorFactory);
-  const _ap6 = (input, _path, _exceptionable = true) => void 0 === input["icon"] || ("object" === typeof input["icon"] && null !== input["icon"] && false === Array.isArray(input["icon"]) || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap6 = (input, _path, _exceptionable = true) => void 0 === input["icon"] || ("object" === typeof input["icon"] && null !== input["icon"] && false === Array.isArray(input["icon"]) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".icon",
     expected: "(TargetIconConfig | undefined)",
     value: input["icon"]
-  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".icon",
     expected: "(TargetIconConfig | undefined)",
     value: input["icon"]
   }, _errorFactory);
-  const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["wrapperApp"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["wrapperApp"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".wrapperApp",
     expected: "string",
     value: input["wrapperApp"]
   }, _errorFactory);
-  const _ap8 = (input, _path, _exceptionable = true) => "string" === typeof input["webDir"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap8 = (input, _path, _exceptionable = true) => "string" === typeof input["webDir"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".webDir",
     expected: "string",
@@ -5405,18 +5626,18 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   }, _errorFactory);
   const _ae0 = '("action-required" | "approval-required" | "available" | "configuration-required" | "disabled" | "temporarily-unavailable" | "unsupported" | undefined)';
   const _ae1 = "(undefined | { readonly maskable?: string; readonly androidForeground?: string; readonly monochrome?: string; readonly background?: string; })";
-  const _ap9 = (input, _path, _exceptionable = true) => "string" === typeof input["output"] || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ap9 = (input, _path, _exceptionable = true) => "string" === typeof input["output"] || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".output",
     expected: "string",
     value: input["output"]
   }, _errorFactory);
-  const _ao0 = (input, _path, _exceptionable = true) => ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, PlatformTargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, PlatformTargetConfig>",
@@ -5426,190 +5647,190 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_13._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_15._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString(key),
       expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
       value
-    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString(key), _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString(key), _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString(key),
       expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("capacitor-android" === input.kind || "capacitor-ios" === input.kind || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("capacitor-android" === input.kind || "capacitor-ios" === input.kind || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '("capacitor-android" | "capacitor-ios")',
     value: input.kind
-  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".shellApp",
     expected: "string",
     value: input.shellApp
-  }, _errorFactory)) && _ap8(input, _path, _exceptionable) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap8(input, _path, _exceptionable) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '("aab" | "apk" | "ipa")',
     value: input.artifact
   }, _errorFactory));
-  const _ao11 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("devvit-web" === input.kind || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao11 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("devvit-web" === input.kind || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"devvit-web"',
     value: input.kind
-  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && ("devvit" === input.artifact || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && ("devvit" === input.artifact || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '"devvit"',
     value: input.artifact
   }, _errorFactory));
-  const _ao12 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao12 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '("tiktok-minigame" | "wechat-minigame")',
     value: input.kind
-  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && ("canvas" === input.renderer || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && ("canvas" === input.renderer || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderer",
     expected: '"canvas"',
     value: input.renderer
-  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".orientation",
     expected: '("landscape" | "portrait")',
     value: input.orientation
-  }, _errorFactory)) && (true === input.experimental || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (true === input.experimental || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".experimental",
     expected: "true",
     value: input.experimental
-  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.remoteAssetOrigins
-  }, _errorFactory)) && input.remoteAssetOrigins.every((elem, _index4) => "string" === typeof elem || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.remoteAssetOrigins.every((elem, _index4) => "string" === typeof elem || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins[" + _index4 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.remoteAssetOrigins
-  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageBudget",
     expected: "MiniGamePackageBudget",
     value: input.packageBudget
-  }, _errorFactory)) && _ao13(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao13(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageBudget",
     expected: "MiniGamePackageBudget",
     value: input.packageBudget
   }, _errorFactory));
-  const _ao13 = (input, _path, _exceptionable = true) => ("number" === typeof input.mainBytes || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao13 = (input, _path, _exceptionable = true) => ("number" === typeof input.mainBytes || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".mainBytes",
     expected: "number",
     value: input.mainBytes
-  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".totalBytes",
     expected: "number",
     value: input.totalBytes
-  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".independentSubpackageBytes",
     expected: "(number | undefined)",
     value: input.independentSubpackageBytes
   }, _errorFactory));
-  const _ao14 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("web" === input.kind || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao14 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("web" === input.kind || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"web"',
     value: input.kind
-  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && (void 0 === input.installable || "boolean" === typeof input.installable || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && (void 0 === input.installable || "boolean" === typeof input.installable || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installable",
     expected: "(boolean | undefined)",
     value: input.installable
-  }, _errorFactory)) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".crazyGamesLaunch",
     expected: '("basic" | "full" | undefined)',
     value: input.crazyGamesLaunch
-  }, _errorFactory)) && (void 0 === input.staticDir || "string" === typeof input.staticDir || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.staticDir || "string" === typeof input.staticDir || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".staticDir",
     expected: "(string | undefined)",
     value: input.staticDir
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("apps-in-toss" === input.kind || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && _ap4(input, _path, _exceptionable) && _ap5(input, _path, _exceptionable) && _ap6(input, _path, _exceptionable) && ("apps-in-toss" === input.kind || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '"apps-in-toss"',
     value: input.kind
-  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && (".ait" === input.artifact || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && (".ait" === input.artifact || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '".ait"',
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.navigationBar || ("object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.navigationBar || ("object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".navigationBar",
     expected: "(AppsInTossNavigationBarConfig | undefined)",
     value: input.navigationBar
-  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".navigationBar",
     expected: "(AppsInTossNavigationBarConfig | undefined)",
     value: input.navigationBar
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".defaultLocation",
     expected: '("packaged" | "remote")',
     value: input.defaultLocation
-  }, _errorFactory)) && (void 0 === input.packs || ("object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packs || ("object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packs",
     expected: "(Readonly<Record<string, AssetPackLocation>> | undefined)",
     value: input.packs
-  }, _errorFactory)) && _ao4(input.packs, _path + ".packs", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.packs, _path + ".packs", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packs",
     expected: "(Readonly<Record<string, AssetPackLocation>> | undefined)",
     value: input.packs
-  }, _errorFactory)) && (void 0 === input.offlineRequired || (Array.isArray(input.offlineRequired) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.offlineRequired || (Array.isArray(input.offlineRequired) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.offlineRequired
-  }, _errorFactory)) && input.offlineRequired.every((elem, _index3) => "string" === typeof elem || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.offlineRequired.every((elem, _index3) => "string" === typeof elem || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired[" + _index3 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".offlineRequired",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.offlineRequired
-  }, _errorFactory)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteBaseUrl",
     expected: "(string | undefined)",
     value: input.remoteBaseUrl
-  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPackagedBytes",
     expected: "(number | undefined)",
     value: input.maxPackagedBytes
-  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildConfig",
     expected: "string",
@@ -5619,148 +5840,148 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return "packaged" === value || "remote" === value || _assertGuard_13._assertGuard(_exceptionable, {
+    return "packaged" === value || "remote" === value || _assertGuard_15._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString(key),
       expected: '("packaged" | "remote")',
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".displayName",
     expected: "(string | undefined)",
     value: input.displayName
-  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".primaryColor",
     expected: "(string | undefined)",
     value: input.primaryColor
-  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageId",
     expected: "(string | undefined)",
     value: input.packageId
-  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bundleId",
     expected: "(string | undefined)",
     value: input.bundleId
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sdkMajor",
     expected: "(number | undefined)",
     value: input.sdkMajor
   }, _errorFactory));
-  const _ao6 = (input, _path, _exceptionable = true) => (void 0 === input.identityUpgrade || "action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => (void 0 === input.identityUpgrade || "action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae0,
     value: input.identityUpgrade
-  }, _errorFactory)) && (void 0 === input.presentation || "action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.presentation || "action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae0,
     value: input.presentation
-  }, _errorFactory)) && (void 0 === input.sharing || "action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sharing || "action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae0,
     value: input.sharing
-  }, _errorFactory)) && (void 0 === input.inboundShare || "action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.inboundShare || "action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae0,
     value: input.inboundShare
-  }, _errorFactory)) && (void 0 === input.notifications || "action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.notifications || "action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae0,
     value: input.notifications
-  }, _errorFactory)) && (void 0 === input.presentationMode || "fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.presentationMode || "fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded" | undefined)',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao7 = (input, _path, _exceptionable = true) => (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".source",
     expected: "(string | undefined)",
     value: input.source
-  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".backgroundColor",
     expected: "(string | undefined)",
     value: input.backgroundColor
-  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalUrl",
     expected: "(string | undefined)",
     value: input.externalUrl
-  }, _errorFactory)) && (void 0 === input.variants || ("object" === typeof input.variants && null !== input.variants && false === Array.isArray(input.variants) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.variants || ("object" === typeof input.variants && null !== input.variants && false === Array.isArray(input.variants) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".variants",
     expected: _ae1,
     value: input.variants
-  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".variants",
     expected: _ae1,
     value: input.variants
   }, _errorFactory));
-  const _ao8 = (input, _path, _exceptionable = true) => (void 0 === input.maskable || "string" === typeof input.maskable || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (void 0 === input.maskable || "string" === typeof input.maskable || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maskable",
     expected: "(string | undefined)",
     value: input.maskable
-  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".androidForeground",
     expected: "(string | undefined)",
     value: input.androidForeground
-  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monochrome",
     expected: "(string | undefined)",
     value: input.monochrome
-  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".background",
     expected: "(string | undefined)",
     value: input.background
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => (void 0 === input.withBackButton || "boolean" === typeof input.withBackButton || _assertGuard_13._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => (void 0 === input.withBackButton || "boolean" === typeof input.withBackButton || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withBackButton",
     expected: "(boolean | undefined)",
     value: input.withBackButton
-  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withHomeButton",
     expected: "(boolean | undefined)",
     value: input.withHomeButton
-  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withTitle",
     expected: "(boolean | undefined)",
     value: input.withTitle
-  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".transparentBackground",
     expected: "(boolean | undefined)",
     value: input.transparentBackground
-  }, _errorFactory)) && (void 0 === input.theme || "dark" === input.theme || "light" === input.theme || _assertGuard_13._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.theme || "dark" === input.theme || "light" === input.theme || _assertGuard_15._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".theme",
     expected: '("dark" | "light" | undefined)',
@@ -5778,7 +5999,7 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     else if ("web" === input.kind)
       return _ao14(input, _path, _exceptionable);
     else
-      return _assertGuard_13._assertGuard(_exceptionable, {
+      return _assertGuard_15._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
@@ -5829,12 +6050,12 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_13._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_15._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_13._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_15._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
@@ -6133,12 +6354,12 @@ function assertTargetKind(input, target2) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/target-config-matrix.js
-import * as _assertGuard_14 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
 import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync11 } from "node:fs";
-import typia4 from "typia";
-var __typia_transform__accessExpressionAsString2 = _accessExpressionAsString_14._accessExpressionAsString;
+import typia6 from "typia";
+var __typia_transform__accessExpressionAsString2 = _accessExpressionAsString_16._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", "oneplay-web", "tiktok-minigame", "verse8-web", "web", "web-preview", "wechat-minigame"]);
@@ -6150,31 +6371,31 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   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, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
     expected: "boolean",
     value: input["iap"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bannerAds",
     expected: "(boolean | undefined)",
     value: input["bannerAds"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".rewardedAds",
     expected: "boolean",
     value: input["rewardedAds"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".interstitialAds",
     expected: "boolean",
     value: input["interstitialAds"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -6183,17 +6404,17 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   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, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, TargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, TargetConfig>",
@@ -6203,207 +6424,207 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_14._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString2(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString2(key),
       expected: "TargetConfig",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae2,
     value: input.identityUpgrade
-  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae2,
     value: input.presentation
-  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae2,
     value: input.sharing
-  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae2,
     value: input.inboundShare
-  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded")',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".subscriptions",
     expected: "(boolean | undefined)",
     value: input.subscriptions
-  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteLeaderboard",
     expected: "(boolean | undefined)",
     value: input.remoteLeaderboard
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".storage",
     expected: '("local" | "native" | "none")',
     value: input.storage
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".fallbackLocale",
     expected: '("en" | "ko")',
     value: input.fallbackLocale
   }, _errorFactory);
   const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable);
-  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".native",
     expected: "boolean",
     value: input.native
   }, _errorFactory);
-  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: _ae1,
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".billingAuthority",
     expected: '("host" | "store" | undefined)',
     value: input.billingAuthority
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -6430,12 +6651,12 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_14._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_14._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
@@ -6455,31 +6676,31 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   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, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iap",
     expected: "boolean",
     value: input["iap"]
   }, _errorFactory);
-  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bannerAds",
     expected: "(boolean | undefined)",
     value: input["bannerAds"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".rewardedAds",
     expected: "boolean",
     value: input["rewardedAds"]
   }, _errorFactory);
-  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".interstitialAds",
     expected: "boolean",
     value: input["interstitialAds"]
   }, _errorFactory);
-  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -6488,17 +6709,17 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   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, {
+  const _ao0 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".schemaVersion",
     expected: "1",
     value: input.schemaVersion
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Readonly<Record<string, TargetConfig>>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Readonly<Record<string, TargetConfig>>",
@@ -6508,207 +6729,207 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_14._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString2(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString2(key),
       expected: "TargetConfig",
       value
     }, _errorFactory);
   });
-  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao10 = (input, _path, _exceptionable = true) => ("action-required" === input.identityUpgrade || "approval-required" === input.identityUpgrade || "available" === input.identityUpgrade || "configuration-required" === input.identityUpgrade || "disabled" === input.identityUpgrade || "temporarily-unavailable" === input.identityUpgrade || "unsupported" === input.identityUpgrade || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".identityUpgrade",
     expected: _ae2,
     value: input.identityUpgrade
-  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.presentation || "approval-required" === input.presentation || "available" === input.presentation || "configuration-required" === input.presentation || "disabled" === input.presentation || "temporarily-unavailable" === input.presentation || "unsupported" === input.presentation || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentation",
     expected: _ae2,
     value: input.presentation
-  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.sharing || "approval-required" === input.sharing || "available" === input.sharing || "configuration-required" === input.sharing || "disabled" === input.sharing || "temporarily-unavailable" === input.sharing || "unsupported" === input.sharing || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharing",
     expected: _ae2,
     value: input.sharing
-  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.inboundShare || "approval-required" === input.inboundShare || "available" === input.inboundShare || "configuration-required" === input.inboundShare || "disabled" === input.inboundShare || "temporarily-unavailable" === input.inboundShare || "unsupported" === input.inboundShare || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".inboundShare",
     expected: _ae2,
     value: input.inboundShare
-  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("action-required" === input.notifications || "approval-required" === input.notifications || "available" === input.notifications || "configuration-required" === input.notifications || "disabled" === input.notifications || "temporarily-unavailable" === input.notifications || "unsupported" === input.notifications || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".presentationMode",
     expected: '("fullscreen" | "inline-expanded")',
     value: input.presentationMode
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".subscriptions",
     expected: "(boolean | undefined)",
     value: input.subscriptions
-  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteLeaderboard",
     expected: "(boolean | undefined)",
     value: input.remoteLeaderboard
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".storage",
     expected: '("local" | "native" | "none")',
     value: input.storage
   }, _errorFactory)) && _ap4(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".fallbackLocale",
     expected: '("en" | "ko")',
     value: input.fallbackLocale
   }, _errorFactory);
   const _ao6 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable);
-  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".native",
     expected: "boolean",
     value: input.native
   }, _errorFactory);
-  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: _ae1,
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".billingAuthority",
     expected: '("host" | "store" | undefined)',
     value: input.billingAuthority
   }, _errorFactory));
-  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_14._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -6735,12 +6956,12 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_14._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_14._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
@@ -6876,8 +7097,43 @@ function validateEffectiveTargetConfigMatrix(matrix = loadEffectiveTargetConfigM
     }
     validateEffectiveTargetConfig(config2);
   }
+  const hostTargets = targets.filter((target2) => {
+    const adapter = matrix.targets[target2]?.sources.platformAdapter;
+    return adapter === "ait" || adapter === "devvit";
+  });
+  if (hostTargets.length > 0) {
+    const catalog = readJsonFile(productCatalogFilePath());
+    for (const target2 of hostTargets) {
+      const config2 = matrix.targets[target2];
+      if (config2 !== void 0) {
+        validateHostProductList(config2, catalog);
+      }
+    }
+  }
   return matrix;
 }
+function validateHostProductList(config2, catalog) {
+  if (!config2.features.iap) {
+    return;
+  }
+  const ait = config2.sources.platformAdapter === "ait";
+  const hostLabel = ait ? "the Apps in Toss wrapper (platformProductIds.ait)" : "the Devvit server (platformProductIds.reddit)";
+  const hostProducts = new Map(ait ? extractAitIapProductConfig(catalog).map((product) => [product.productId, product.sku]) : createDevvitCommerceBridgeProducts(catalog).map((product) => [
+    product.productId,
+    product.sku
+  ]));
+  const sold = new Map(config2.monetization.products.flatMap((product) => product.enabled && product.platformProductId !== void 0 ? [[product.id, product.platformProductId]] : []));
+  for (const [productId, sku] of sold) {
+    if (hostProducts.get(productId) !== sku) {
+      throw new Error(`Effective target ${config2.target} sells ${productId} as ${sku}, but ${hostLabel} ${hostProducts.has(productId) ? `lists it as ${String(hostProducts.get(productId))}` : "does not list it"}.`);
+    }
+  }
+  for (const productId of hostProducts.keys()) {
+    if (!sold.has(productId)) {
+      throw new Error(`Effective target ${config2.target} does not sell ${productId}, but ${hostLabel} lists it.`);
+    }
+  }
+}
 function writeEffectiveTargetConfigs(options = {}) {
   const matrix = loadEffectiveTargetConfigMatrix();
   const outputDir = options.outputDir ?? "artifacts/target-config";
@@ -6945,11 +7201,12 @@ function validateEffectiveTargetConfig(config2) {
   if (config2.sources.platformAdapter !== expectedPlatformAdapter) {
     throw new Error(`Effective target ${config2.target} runtime ${config2.runtime} does not match platform adapter ${config2.sources.platformAdapter ?? "undefined"}; expected ${expectedPlatformAdapter}.`);
   }
+  const catalogNamesTarget = config2.monetization.products.some((product) => product.platformProductId !== void 0);
   for (const product of config2.monetization.products) {
     if (!config2.features.iap && product.enabled) {
       throw new Error(`Effective target ${config2.target} enables product ${product.id} while IAP is disabled.`);
     }
-    if (config2.features.iap && product.reason === "missing-platform-id" && config2.target !== "reddit") {
+    if (config2.features.iap && product.reason === "missing-platform-id" && (config2.target !== "reddit" || catalogNamesTarget)) {
       throw new Error(`Effective target ${config2.target} is missing a platform product id for ${product.id}.`);
     }
   }
@@ -7061,104 +7318,104 @@ function sha2562(content) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_18 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_18 from "typia/lib/internal/_accessExpressionAsString";
 import { execFileSync } from "node:child_process";
 import { createHash as createHash8, randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync14, realpathSync as realpathSync6, renameSync as renameSync2, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "node:fs";
 import { isAbsolute as isAbsolute8, relative as relative9, resolve as resolve12 } from "node:path";
-import typia6 from "typia";
+import typia8 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/release-manifest/src/index.js
-import * as _assertGuard_15 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_15 from "typia/lib/internal/_accessExpressionAsString";
-import typia5 from "typia";
-var __typia_transform__accessExpressionAsString3 = _accessExpressionAsString_15._accessExpressionAsString;
+import * as _assertGuard_17 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_17 from "typia/lib/internal/_accessExpressionAsString";
+import typia7 from "typia";
+var __typia_transform__accessExpressionAsString3 = _accessExpressionAsString_17._accessExpressionAsString;
 var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
   const _ip0 = (input) => "string" === typeof input["gameVersion"];
   const _ip1 = (input) => "string" === typeof input["path"];
   const _ip2 = (input) => "string" === typeof input["digest"];
-  const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["gameVersion"] || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["gameVersion"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gameVersion",
     expected: "string",
     value: input["gameVersion"]
   }, _errorFactory);
   const _ae0 = "{ readonly path: string; readonly digest: string; readonly sourceSha256: string; readonly sharedConfigSha256: string; readonly renderConfigSha256: string; readonly generatorVersion: string; readonly targetProfile: string; readonly targetProfileVersion: string; }";
-  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".path",
     expected: "string",
     value: input["path"]
   }, _errorFactory);
-  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".digest",
     expected: "string",
     value: input["digest"]
   }, _errorFactory);
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.releaseId || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.releaseId || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseId",
     expected: "string",
     value: input.releaseId
-  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gitSha",
     expected: "string",
     value: input.gitSha
-  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kitGitSha",
     expected: "string",
     value: input.kitGitSha
-  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && (void 0 === input.releaseIdentity || ("object" === typeof input.releaseIdentity && null !== input.releaseIdentity || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && (void 0 === input.releaseIdentity || ("object" === typeof input.releaseIdentity && null !== input.releaseIdentity || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildId",
     expected: "string",
     value: input.buildId
-  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetConfigVersion",
     expected: "string",
     value: input.targetConfigVersion
-  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".catalogVersion",
     expected: "string",
     value: input.catalogVersion
-  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".adPlacementVersion",
     expected: "string",
     value: input.adPlacementVersion
-  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, ReleaseTargetManifest>",
     value: input.targets
-  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, ReleaseTargetManifest>",
     value: input.targets
   }, _errorFactory));
-  const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.releaseRevision || "number" === typeof input.releaseRevision || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.releaseRevision || "number" === typeof input.releaseRevision || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseRevision",
     expected: "(number | undefined)",
     value: input.releaseRevision
-  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".label",
     expected: "string",
@@ -7168,142 +7425,142 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_15._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: "ReleaseTargetManifest",
       value
-    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: "ReleaseTargetManifest",
       value
     }, _errorFactory);
   });
-  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: "string",
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".effectiveConfig",
     expected: "{ readonly path: string; readonly version: string; readonly digest: string; }",
     value: input.effectiveConfig
-  }, _errorFactory)) && _ao4(input.effectiveConfig, _path + ".effectiveConfig", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.effectiveConfig, _path + ".effectiveConfig", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".effectiveConfig",
     expected: "{ readonly path: string; readonly version: string; readonly digest: string; }",
     value: input.effectiveConfig
-  }, _errorFactory)) && (("object" === typeof input.iconManifest && null !== input.iconManifest || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.iconManifest && null !== input.iconManifest || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionName",
     expected: "(string | undefined)",
     value: input.versionName
-  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionCode",
     expected: "(number | undefined)",
     value: input.versionCode
-  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".marketingVersion",
     expected: "(string | undefined)",
     value: input.marketingVersion
-  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildNumber",
     expected: "(string | undefined)",
     value: input.buildNumber
-  }, _errorFactory)) && (void 0 === input.nativeDelivery || ("object" === typeof input.nativeDelivery && null !== input.nativeDelivery || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeDelivery || ("object" === typeof input.nativeDelivery && null !== input.nativeDelivery || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sdkMajor",
     expected: "(number | undefined)",
     value: input.sdkMajor
   }, _errorFactory));
-  const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && ("string" === typeof input.version || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && ("string" === typeof input.version || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
   }, _errorFactory)) && _ap2(input, _path, _exceptionable);
-  const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && ("string" === typeof input.sourceSha256 || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && ("string" === typeof input.sourceSha256 || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sourceSha256",
     expected: "string",
     value: input.sourceSha256
-  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedConfigSha256",
     expected: "string",
     value: input.sharedConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderConfigSha256",
     expected: "string",
     value: input.renderConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".generatorVersion",
     expected: "string",
     value: input.generatorVersion
-  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetProfile",
     expected: "string",
     value: input.targetProfile
-  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetProfileVersion",
     expected: "string",
     value: input.targetProfileVersion
   }, _errorFactory));
-  const _ao6 = (input, _path, _exceptionable = true) => ("android" === input.platform || "ios" === input.platform || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("android" === input.platform || "ios" === input.platform || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platform",
     expected: '("android" | "ios")',
     value: input.platform
-  }, _errorFactory)) && ("debug" === input.mode || "signed-archive" === input.mode || "simulator" === input.mode || "store-export" === input.mode || "sync" === input.mode || "unsigned-archive" === input.mode || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("debug" === input.mode || "signed-archive" === input.mode || "simulator" === input.mode || "store-export" === input.mode || "sync" === input.mode || "unsigned-archive" === input.mode || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".mode",
     expected: '("debug" | "signed-archive" | "simulator" | "store-export" | "sync" | "unsigned-archive")',
     value: input.mode
-  }, _errorFactory)) && ("boolean" === typeof input.signed || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.signed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".signed",
     expected: "boolean",
     value: input.signed
-  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".submissionCandidate",
     expected: "boolean",
@@ -7326,12 +7583,12 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_15._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_15._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
@@ -7479,149 +7736,149 @@ function canRecoverLock(lockFile) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_16._accessExpressionAsString;
+var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_18._accessExpressionAsString;
 var assertProductCatalog = /* @__PURE__ */ (() => {
   const _ae0 = '({ readonly type: "currency"; readonly currency: string & MinLength<1>; readonly amount: number; } | { readonly type: "entitlement"; readonly entitlement: string; } | { readonly type: "resource"; readonly resource: string & MinLength<1>; readonly amount: number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>; })';
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "((ReadonlyArray<string & MinLength<1>> & MinItems<1>) | undefined)",
     value: input.currencies
-  }, _errorFactory)) && ((1 <= input.currencies.length || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((1 <= input.currencies.length || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "Array<> & MinItems<1>",
     value: input.currencies
-  }, _errorFactory)) && input.currencies.every((elem, _index3) => "string" === typeof elem && (1 <= elem.length || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.currencies.every((elem, _index3) => "string" === typeof elem && (1 <= elem.length || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "string & MinLength<1>",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "(string & MinLength<1>)",
     value: elem
-  }, _errorFactory))) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory))) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies",
     expected: "((ReadonlyArray<string & MinLength<1>> & MinItems<1>) | undefined)",
     value: input.currencies
-  }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products",
     expected: "ReadonlyArray<ProductCatalogEntry>",
     value: input.products
-  }, _errorFactory)) && input.products.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.products.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products",
     expected: "ReadonlyArray<ProductCatalogEntry>",
     value: input.products
   }, _errorFactory));
-  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".id",
     expected: "string",
     value: input.id
-  }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '("consumable" | "non_consumable" | "subscription")',
     value: input.type
-  }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".grant",
     expected: _ae0,
     value: input.grant
-  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".grant",
     expected: _ae0,
     value: input.grant
-  }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformProductIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformProductIds
-  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformProductIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformProductIds
   }, _errorFactory));
-  const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"currency"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "(string & MinLength<1>)",
     value: input.currency
-  }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number",
     value: input.amount
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"entitlement"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".entitlement",
     expected: "string",
     value: input.entitlement
   }, _errorFactory));
-  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"resource"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "string & MinLength<1>",
     value: input.resource
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "(string & MinLength<1>)",
     value: input.resource
-  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & ExclusiveMinimum<0>",
     value: input.amount
-  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Maximum<1.7976931348623157e+308>",
     value: input.amount
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "(number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>)",
@@ -7631,7 +7888,7 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_16._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "(string | undefined)",
@@ -7646,7 +7903,7 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     else if ("resource" === input.type)
       return _ao4(input, _path, _exceptionable);
     else
-      return _assertGuard_16._assertGuard(_exceptionable, {
+      return _assertGuard_18._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -7679,12 +7936,12 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_16._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
@@ -7698,107 +7955,107 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
   const _ip0 = (input) => "number" === typeof input["amount"];
   const _ae0 = '(AdPlacementEntryBase & { readonly type: "banner" | "interstitial"; readonly reward?: never; } | AdPlacementEntryBase & { readonly type: "rewarded"; readonly reward?: AdReward; })';
   const _ae1 = '(undefined | { readonly type: "continue"; readonly amount: number; } | { readonly type: "currency"; readonly amount: number; readonly currency: string & MinLength<1>; })';
-  const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number",
     value: input["amount"]
   }, _errorFactory);
   const _ae2 = '({ readonly type: "continue"; readonly amount: number; } | { readonly type: "currency"; readonly amount: number; readonly currency: string & MinLength<1>; })';
-  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_18._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, {
+  }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedPlatformPlacementTargets[" + _index4 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._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, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("rewarded" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"rewarded"',
     value: input.type
-  }, _errorFactory)) && (void 0 === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: _ae1,
     value: input.reward
-  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: _ae1,
     value: input.reward
   }, _errorFactory)));
-  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".id",
     expected: "string",
     value: input.id
-  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".frequencyCap",
     expected: "FrequencyCap",
     value: input.frequencyCap
-  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".frequencyCap",
     expected: "FrequencyCap",
     value: input.frequencyCap
-  }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformPlacementIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformPlacementIds
-  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformPlacementIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformPlacementIds
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".cooldownSeconds",
     expected: "number",
     value: input.cooldownSeconds
-  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPerSession",
     expected: "(number | undefined)",
     value: input.maxPerSession
-  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".minStageInterval",
     expected: "(number | undefined)",
@@ -7808,46 +8065,46 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_16._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
       path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "(string | undefined)",
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"continue"',
     value: input.type
   }, _errorFactory)) && _ap0(input, _path, _exceptionable);
-  const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"currency"',
     value: input.type
-  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "(string & MinLength<1>)",
     value: input.currency
   }, _errorFactory));
-  const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_16._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '("banner" | "interstitial")',
     value: input.type
-  }, _errorFactory)) && ((null !== input.reward || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((null !== input.reward || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
     value: input.reward
-  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
@@ -7859,7 +8116,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("rewarded" === input.type)
       return _ao1(input, _path, _exceptionable);
     else
-      return _assertGuard_16._assertGuard(_exceptionable, {
+      return _assertGuard_18._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -7872,7 +8129,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("currency" === input.type)
       return _ao6(input, _path, _exceptionable);
     else
-      return _assertGuard_16._assertGuard(_exceptionable, {
+      return _assertGuard_18._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae2,
@@ -7913,12 +8170,12 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_16._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",
@@ -11601,7 +11858,7 @@ import { createHash as createHash11 } from "node:crypto";
 var profileUuidPattern = /^[0-9A-F]{8}-(?:[0-9A-F]{4}-){3}[0-9A-F]{12}$/iu;
 var certFingerprintPattern = /^[0-9A-F]{64}$/u;
 function inspectIosDistributionProfile(value, input) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     throw new Error("iOS provisioning profile is malformed.");
   }
   const uuid = value.UUID;
@@ -11618,7 +11875,7 @@ function inspectIosDistributionProfile(value, input) {
   if (!Array.isArray(appIdPrefixes) || appIdPrefixes.length !== 1 || typeof appIdPrefixes[0] !== "string" || !/^[A-Z0-9]{10}$/u.test(appIdPrefixes[0])) {
     throw new Error("iOS provisioning profile has an invalid App ID prefix.");
   }
-  if (!isRecord3(value.Entitlements) || value.Entitlements["application-identifier"] !== `${appIdPrefixes[0]}.${input.bundleId}` || value.Entitlements["get-task-allow"] === true || value.Entitlements["com.apple.developer.team-identifier"] !== void 0 && value.Entitlements["com.apple.developer.team-identifier"] !== input.teamId) {
+  if (!isRecord4(value.Entitlements) || value.Entitlements["application-identifier"] !== `${appIdPrefixes[0]}.${input.bundleId}` || value.Entitlements["get-task-allow"] === true || value.Entitlements["com.apple.developer.team-identifier"] !== void 0 && value.Entitlements["com.apple.developer.team-identifier"] !== input.teamId) {
     throw new Error("iOS provisioning profile does not match the app ID or distribution rights.");
   }
   if (!Array.isArray(value.DeveloperCertificates) || !value.DeveloperCertificates.some((certificate) => {
@@ -11635,7 +11892,7 @@ function inspectIosDistributionProfile(value, input) {
   }
   return { uuid, name, expiresAt };
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -12296,6 +12553,7 @@ import { dirname as dirname9, isAbsolute as isAbsolute11, join as join13, relati
 import { chmodSync as chmodSync2, existsSync as existsSync21, lstatSync as lstatSync12, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync21, realpathSync as realpathSync9, renameSync as renameSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync15 } from "node:fs";
 import path9 from "node:path";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
+import { satisfies, valid } from "semver";
 
 // node_modules/.cache/mpgd-native-build/packages/cli/src/native-shell-identity.js
 function assertAndroidSettingsAppProject(source) {
@@ -12676,6 +12934,45 @@ var javaKeywords = new Set(`
   synchronized this throw throws transient try void volatile while true false null record sealed
   permits var yield
 `.trim().split(/\s+/u));
+var unwiredCapacitorGateway = (target2) => [
+  "import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';",
+  "import type { PlatformGateway } from '@mpgd/platform';",
+  "",
+  "import type { RuntimeConfig } from '../runtimeDetector';",
+  "",
+  "export async function createBuildGateway(runtime: RuntimeConfig): Promise<PlatformGateway> {",
+  "  return createCapacitorPlatformGateway({",
+  `    target: '${target2}',`,
+  "    appVersion: runtime.appVersion,",
+  "    buildId: runtime.buildId,",
+  "  });",
+  "}",
+  ""
+].join("\n");
+var capacitorShellProviderPlugins = Object.freeze([
+  {
+    id: "play-billing",
+    packageName: "@mpgd/capacitor-play-billing",
+    packageDir: "native-plugins/capacitor-play-billing",
+    platform: "android",
+    gatewayFile: "src/platform/buildGateways/capacitorAndroid.ts",
+    gatewayFactory: "createCapacitorPlayBillingServiceProvider",
+    legacyGatewaySources: [unwiredCapacitorGateway("android")]
+  },
+  {
+    id: "storekit",
+    packageName: "@mpgd/capacitor-storekit",
+    packageDir: "native-plugins/capacitor-storekit",
+    platform: "ios",
+    gatewayFile: "src/platform/buildGateways/capacitorIos.ts",
+    gatewayFactory: "createCapacitorStoreKitServiceProvider",
+    legacyGatewaySources: [unwiredCapacitorGateway("ios")]
+  }
+]);
+var capacitorShellProviderSupportFiles = Object.freeze([
+  "src/platform/commerceProducts.ts",
+  "src/platform/commerceAccountBinding.ts"
+]);
 var androidBackupDomains = ["root", "file", "database", "sharedpref", "external"];
 var androidBackupExcludes = androidBackupDomains.map((domain) => `<exclude domain="${domain}" path="." />`);
 var androidBackupRulesXml = [