@mpgd/cli 0.47.0 → 0.48.0

package/dist/native-build-target.js

@@ -4445,14 +4445,1719 @@ function requireOutput2(result, purpose, width) {
 }
 
 // node_modules/.cache/mpgd-native-build/packages/target-config/src/index.js
+import * as _assertGuard_13 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_14 from "typia/lib/internal/_accessExpressionAsString";
+import typia5 from "typia";
+
+// node_modules/.cache/mpgd-native-build/packages/catalog/src/index.js
 import * as _assertGuard_12 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_13 from "typia/lib/internal/_accessExpressionAsString";
+import typia3 from "typia";
+
+// node_modules/.cache/mpgd-native-build/packages/platform/src/notifications.js
+import * as _isTypeUint32_1 from "typia/lib/internal/_isTypeUint32";
+import * as _isFormatDateTime_1 from "typia/lib/internal/_isFormatDateTime";
+import * as _isFormatDate_1 from "typia/lib/internal/_isFormatDate";
+import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_1 from "typia/lib/internal/_accessExpressionAsString";
+import typia from "typia";
+
+// node_modules/.cache/mpgd-native-build/packages/platform/src/notifications-policy.js
+var recordableNotificationPermissionStates = Object.freeze([
+  "granted",
+  "prompt-with-rationale",
+  "denied",
+  "blocked"
+]);
+var referenceNotificationProviders = deepFreeze({
+  fcm: {
+    provider: "fcm",
+    purposes: ["service", "requested", "advertising"],
+    addressing: "device",
+    content: "free-form",
+    permission: { scope: "app", serverReadable: false, allowance: "persistent" },
+    expiry: true,
+    actions: true,
+    link: false,
+    mappingFields: [],
+    mapping: { channelId: { required: false } }
+  },
+  "apps-in-toss": {
+    provider: "apps-in-toss",
+    purposes: ["service", "requested"],
+    addressing: "platform-user",
+    content: "host-template",
+    permission: { scope: "topic", serverReadable: false, allowance: "persistent" },
+    limits: [{ count: 10, windowSeconds: 60 }],
+    rate: { count: 15e3, windowSeconds: 60 },
+    expiry: false,
+    actions: false,
+    link: false,
+    mappingFields: ["templateSetCode", "agreement"],
+    mapping: {
+      templateSetCode: { required: true },
+      agreement: { required: true, values: ["required", "none"] }
+    }
+  },
+  devvit: {
+    provider: "devvit",
+    purposes: ["service", "requested"],
+    addressing: "platform-user",
+    content: "free-form",
+    permission: { scope: "app", serverReadable: true, allowance: "persistent" },
+    limits: [{ count: 2, windowSeconds: 86400 }],
+    rate: { count: 25e3, windowSeconds: 86400 },
+    expiry: false,
+    actions: false,
+    link: true,
+    mappingFields: ["title", "body"],
+    mapping: {
+      title: { required: true, maxLength: 60 },
+      body: { required: true, maxLength: 100 },
+      link: { required: false, pattern: "^t[13]_[A-Za-z0-9]+$" }
+    }
+  }
+});
+var referenceNotificationTargetProviders = Object.freeze({
+  android: "fcm",
+  ios: "fcm",
+  ait: "apps-in-toss",
+  reddit: "devvit"
+});
+var notificationSuppressionReasons = Object.freeze([
+  "topic-unknown",
+  "channel-unsupported",
+  "purpose-unsupported",
+  "permission-denied",
+  "agreement-missing",
+  "allowance-exhausted",
+  "request-missing",
+  "preference-off",
+  "advertising-consent-missing",
+  "night-consent-missing",
+  "quiet-hours",
+  "frequency-capped",
+  "provider-limit",
+  "advertising-sender-missing"
+]);
+var notificationInputBounds = Object.freeze({
+  keyLength: 2048,
+  entries: 128,
+  stringLength: 16384
+});
+var notificationReservedKeyPrefixes = Object.freeze(["reminder:", "notice:"]);
+var minuteMs = 6e4;
+var hourMs = 60 * minuteMs;
+var dayMs = 24 * hourMs;
+var seoulOffsetMs = 9 * hourMs;
+var notificationNightWindow = Object.freeze({
+  timeZone: "Asia/Seoul",
+  start: "21:00",
+  end: "08:00"
+});
+var isoInstantPattern = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(?:[Zz]|([+-])(\d{2}):(\d{2}))$/u;
+function instantOrNaN(at) {
+  const match = isoInstantPattern.exec(at);
+  return match === null ? Number.NaN : instantOf(match);
+}
+function isNotificationTimestamp(at) {
+  return !Number.isNaN(instantOrNaN(at));
+}
+function notificationTimeFieldIssue(value, fields, path10 = "") {
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      const issue = notificationTimeFieldIssue(item, fields, `${path10}[${index}]`);
+      if (issue !== void 0) {
+        return issue;
+      }
+    }
+    return void 0;
+  }
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  for (const [key, format] of Object.entries(fields)) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) {
+      continue;
+    }
+    const field = value[key];
+    const at = path10 === "" ? key : `${path10}.${key}`;
+    if (typeof format !== "string") {
+      const issue = notificationTimeFieldIssue(field, format, at);
+      if (issue !== void 0) {
+        return issue;
+      }
+    } else if (typeof field === "string" && !(format === "date" ? isNotificationCalendarDate(field) : isNotificationTimestamp(field))) {
+      return format === "date" ? `${at} must be a date that exists, YYYY-MM-DD; got ${JSON.stringify(field)}` : `${at} must be RFC 3339 with a date that exists, T, and an offset; got ${JSON.stringify(field)}`;
+    }
+  }
+  return void 0;
+}
+var noticeTimeFields = { record: { at: "date-time" }, dueBy: "date" };
+var notificationTimeFields = {
+  LocalNotificationRequest: { fireAt: "date-time" },
+  LocalNotificationEntry: { fireAt: "date-time" },
+  NotificationBridgeListLocalResult: { pending: { fireAt: "date-time" } },
+  NotificationConsentRecord: { at: "date-time" },
+  NotificationNotice: noticeTimeFields,
+  RecordNotificationNoticeInput: noticeTimeFields,
+  NotificationConformanceVector: {
+    context: { now: "date-time" },
+    steps: {
+      at: "date-time",
+      input: { fireAt: "date-time", ...noticeTimeFields },
+      returns: { until: "date-time", ...noticeTimeFields }
+    },
+    expect: {
+      deliveries: { until: "date-time" },
+      providerCalls: { expiresAt: "date-time" },
+      local: { operations: { fireAt: "date-time" }, pending: { fireAt: "date-time" } },
+      reminders: { fireAt: "date-time" },
+      notices: noticeTimeFields
+    }
+  }
+};
+function instantOf(match) {
+  const [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number);
+  const offsetHours = Number(match[9] ?? 0);
+  const offsetMinutes = Number(match[10] ?? 0);
+  if (year === void 0 || month === void 0 || day === void 0 || hour === void 0 || minute === void 0 || second === void 0 || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month) || hour > 23 || minute > 59 || second > 59 || offsetHours > 23 || offsetMinutes > 59) {
+    return Number.NaN;
+  }
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(hour, minute, second, Number((match[7] ?? "0").slice(0, 3).padEnd(3, "0")));
+  const offsetMs = (offsetHours * 60 + offsetMinutes) * minuteMs;
+  return date.getTime() - (match[8] === "-" ? -offsetMs : offsetMs);
+}
+function daysInMonth(year, month) {
+  const leap = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+  return [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] ?? 0;
+}
+function fixedOffsetZone(offsetMs) {
+  return {
+    wall(millis) {
+      const local = new Date(millis + offsetMs);
+      return {
+        year: local.getUTCFullYear(),
+        month: local.getUTCMonth() + 1,
+        day: local.getUTCDate(),
+        minute: local.getUTCHours() * 60 + local.getUTCMinutes()
+      };
+    },
+    instants(year, month, day, minute) {
+      return [Date.UTC(year, month - 1, day, 0, minute) - offsetMs];
+    },
+    shiftedInstant(year, month, day, minute) {
+      return Date.UTC(year, month - 1, day, 0, minute) - offsetMs;
+    }
+  };
+}
+var seoulZone = fixedOffsetZone(seoulOffsetMs);
+var notificationNoticeVariants = Object.freeze([
+  "consent-result.advertising.granted",
+  "consent-result.advertising.refused",
+  "consent-result.advertising.withdrawn",
+  "consent-result.night.granted",
+  "consent-result.night.refused",
+  "consent-result.night.withdrawn",
+  "reconfirmation.advertising",
+  "reconfirmation.night"
+]);
+var notificationNoticeVariantFallbacks = Object.freeze({
+  "consent-result.advertising.refused": "consent-result.advertising.withdrawn",
+  "consent-result.night.refused": "consent-result.night.withdrawn"
+});
+function isNotificationCalendarDate(date) {
+  return !Number.isNaN(calendarDateMillis(date));
+}
+function calendarDateMillis(date) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(date);
+  if (match === null) {
+    return Number.NaN;
+  }
+  const [year, month, day] = match.slice(1, 4).map(Number);
+  if (year === void 0 || month === void 0 || day === void 0 || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
+    return Number.NaN;
+  }
+  const midnight = /* @__PURE__ */ new Date(0);
+  midnight.setUTCFullYear(year, month - 1, day);
+  return midnight.getTime();
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null) {
+    for (const nested of Object.values(value)) {
+      deepFreeze(nested);
+    }
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// node_modules/.cache/mpgd-native-build/packages/platform/src/notifications.js
+var __typia_transform__accessExpressionAsString = _accessExpressionAsString_1._accessExpressionAsString;
+var notificationErrorCodes = Object.freeze([
+  "NOTIFICATIONS_UNSUPPORTED",
+  "NOTIFICATIONS_CONFIGURATION_REQUIRED",
+  "NOTIFICATIONS_USER_GESTURE_REQUIRED",
+  "NOTIFICATIONS_HOST_VERSION_UNSUPPORTED",
+  "NOTIFICATIONS_INVALID_INPUT",
+  "NOTIFICATIONS_IDEMPOTENCY_CONFLICT",
+  "NOTIFICATIONS_TEMPORARILY_UNAVAILABLE",
+  "NOTIFICATIONS_V2_UNAVAILABLE"
+]);
+var notificationBridgeMethods = Object.freeze([
+  "notifications.v2.getCapabilities",
+  "notifications.v2.getPermission",
+  "notifications.v2.requestPermission",
+  "notifications.v2.revokePermission",
+  "notifications.v2.register",
+  "notifications.v2.scheduleLocal",
+  "notifications.v2.cancelLocal",
+  "notifications.v2.listLocal",
+  "notifications.v2.openSettings"
+]);
+function withStrictTimes(what, assert, fields) {
+  return (input) => {
+    const value = assert(input);
+    const issue = notificationTimeFieldIssue(value, fields);
+    if (issue !== void 0) {
+      throw new TypeError(`Invalid ${what}: ${issue}.`);
+    }
+    return value;
+  };
+}
+var assertLocalNotificationRequestShape = withStrictTimes("local reminder request", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "string & CommerceMinLength<1>",
+    value: input.key
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "(string & CommerceMinLength<1>)",
+    value: input.key
+  }, _errorFactory)) && ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string",
+    value: input.topic
+  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "string & CommerceDateTimeFormat",
+    value: input.fireAt
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "(string & CommerceDateTimeFormat)",
+    value: input.fireAt
+  }, _errorFactory)) && ("string" === typeof input.title || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".title",
+    expected: "string",
+    value: input.title
+  }, _errorFactory)) && ("string" === typeof input.body || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".body",
+    expected: "string",
+    value: input.body
+  }, _errorFactory)) && (void 0 === input.route || "string" === typeof input.route || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".route",
+    expected: "(string | undefined)",
+    value: input.route
+  }, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt", "title", "body", "route"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.key && 1 <= input.key.length && "string" === typeof input.topic && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && "string" === typeof input.title && "string" === typeof input.body && (void 0 === input.route || "string" === typeof input.route) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt", "title", "body", "route"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "LocalNotificationRequest",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "LocalNotificationRequest",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.LocalNotificationRequest);
+var assertLocalNotificationEntry = withStrictTimes("local reminder entry", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "string & CommerceMinLength<1>",
+    value: input.key
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "(string & CommerceMinLength<1>)",
+    value: input.key
+  }, _errorFactory)) && ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string",
+    value: input.topic
+  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "string & CommerceDateTimeFormat",
+    value: input.fireAt
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "(string & CommerceDateTimeFormat)",
+    value: input.fireAt
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => "string" === typeof input.key && 1 <= input.key.length && "string" === typeof input.topic && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "LocalNotificationEntry",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "LocalNotificationEntry",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.LocalNotificationEntry);
+var assertNotificationConsentRecord = withStrictTimes("consent record", /* @__PURE__ */ (() => {
+  const _ae0 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; })';
+  const _ae1 = '({ readonly kind: "advertising" | "night"; readonly topic?: never; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion: NonEmptyString; } | { readonly kind: "topic-preference"; readonly topic: NonEmptyString; readonly state: "granted" | "withdrawn"; readonly source: "player"; readonly at: IsoDateTime; readonly evidence?: never; readonly textVersion?: never; } | { readonly kind: "host-agreement"; readonly topic: NonEmptyString; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "provider"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; } | { readonly kind: "delivery-permission"; readonly topic?: never; readonly state: NotificationRecordablePermissionState; readonly source: "client-report" | "player"; readonly at: IsoDateTime; readonly evidence?: PlatformEvidenceEnvelope; readonly textVersion?: never; })';
+  const _ao0 = (input, _path, _exceptionable = true) => ("delivery-permission" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"delivery-permission"',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "player")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao1(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.schema || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".schema",
+    expected: "string",
+    value: input.schema
+  }, _errorFactory)) && (("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && _ao2(input.payload, _path + ".payload", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".payload",
+    expected: "Readonly<Record<string, string | number | boolean>>",
+    value: input.payload
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + __typia_transform__accessExpressionAsString(key),
+      expected: "(boolean | number | string)",
+      value
+    }, _errorFactory);
+  });
+  const _ao3 = (input, _path, _exceptionable = true) => ("host-agreement" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"host-agreement"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("blocked" | "denied" | "granted" | "prompt-with-rationale")',
+    value: input.state
+  }, _errorFactory)) && ("client-report" === input.source || "provider" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '("client-report" | "provider")',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.evidence || ("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && _ao1(input.evidence, _path + ".evidence", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "(PlatformEvidenceEnvelope | undefined)",
+    value: input.evidence
+  }, _errorFactory)) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao4 = (input, _path, _exceptionable = true) => ("topic-preference" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '"topic-preference"',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.topic && (1 <= input.topic.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ((null !== input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory)) && (void 0 === input.textVersion || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "undefined",
+    value: input.textVersion
+  }, _errorFactory))) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao5 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ((null !== input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory)) && (void 0 === input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "undefined",
+    value: input.topic
+  }, _errorFactory))) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("player" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".source",
+    expected: '"player"',
+    value: input.source
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && ((null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory)) && (void 0 === input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".evidence",
+    expected: "undefined",
+    value: input.evidence
+  }, _errorFactory))) && ("string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "(string & MinLength<1>)",
+    value: input.textVersion
+  }, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _ao5(input, _path, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _ao4(input, _path, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _ao3(input, _path, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _ao0(input, _path, _exceptionable);
+    else
+      return _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path,
+        expected: _ae1,
+        value: input
+      }, _errorFactory);
+  })();
+  const _io0 = (input, _exceptionable = true) => "delivery-permission" === input.kind && (null !== input.topic && void 0 === input.topic) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "player" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io1(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.schema && ("object" === typeof input.payload && null !== input.payload && false === Array.isArray(input.payload) && _io2(input.payload, _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["schema", "payload"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const _io3 = (input, _exceptionable = true) => "host-agreement" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("blocked" === input.state || "denied" === input.state || "granted" === input.state || "prompt-with-rationale" === input.state) && ("client-report" === input.source || "provider" === input.source) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.evidence || "object" === typeof input.evidence && null !== input.evidence && _io1(input.evidence, _exceptionable)) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io4 = (input, _exceptionable = true) => "topic-preference" === input.kind && ("string" === typeof input.topic && 1 <= input.topic.length) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && (null !== input.textVersion && void 0 === input.textVersion) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io5 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && (null !== input.topic && void 0 === input.topic) && ("granted" === input.state || "withdrawn" === input.state) && "player" === input.source && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (null !== input.evidence && void 0 === input.evidence) && ("string" === typeof input.textVersion && 1 <= input.textVersion.length) && (5 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "topic", "state", "source", "at", "evidence", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("advertising" === input.kind || "night" === input.kind)
+      return _io5(input, _exceptionable);
+    else if ("topic-preference" === input.kind)
+      return _io4(input, _exceptionable);
+    else if ("host-agreement" === input.kind)
+      return _io3(input, _exceptionable);
+    else if ("delivery-permission" === input.kind)
+      return _io0(input, _exceptionable);
+    else
+      return false;
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: _ae0,
+        value: input2
+      }, _errorFactory)) && _au0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: _ae0,
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationConsentRecord);
+var assertNotificationNotice = withStrictTimes("notice", /* @__PURE__ */ (() => {
+  const _ae0 = '{ readonly kind: "advertising" | "night"; readonly state: "granted" | "withdrawn"; readonly at: IsoDateTime; readonly textVersion?: NonEmptyString; }';
+  const _ae1 = '("consent-result.advertising.granted" | "consent-result.advertising.refused" | "consent-result.advertising.withdrawn" | "consent-result.night.granted" | "consent-result.night.refused" | "consent-result.night.withdrawn" | "reconfirmation.advertising" | "reconfirmation.night")';
+  const _ao0 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".variant",
+    expected: _ae1,
+    value: input.variant
+  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.textVersion
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationNotice",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationNotice",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationNotice);
+var assertRecordNotificationNoticeInput = withStrictTimes("notice to record", /* @__PURE__ */ (() => {
+  const _ae0 = '{ readonly kind: "advertising" | "night"; readonly state: "granted" | "withdrawn"; readonly at: IsoDateTime; readonly textVersion?: NonEmptyString; }';
+  const _ae1 = '("consent-result.advertising.granted" | "consent-result.advertising.refused" | "consent-result.advertising.withdrawn" | "consent-result.night.granted" | "consent-result.night.refused" | "consent-result.night.withdrawn" | "reconfirmation.advertising" | "reconfirmation.night")';
+  const _ao0 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && _ao1(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: _ae0,
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".variant",
+    expected: _ae1,
+    value: input.variant
+  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("granted" === input.state || "withdrawn" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".state",
+    expected: '("granted" | "withdrawn")',
+    value: input.state
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && (1 <= input.textVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "string & MinLength<1>",
+    value: input.textVersion
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".textVersion",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.textVersion
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao2 = (input, _path, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("consent-result" | "reconfirmation")',
+    value: input.kind
+  }, _errorFactory)) && (("object" === typeof input.record && null !== input.record || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
+    value: input.record
+  }, _errorFactory)) && _ao3(input.record, _path + ".record", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".record",
+    expected: '{ readonly kind: "advertising" | "night"; readonly at: IsoDateTime; }',
+    value: input.record
+  }, _errorFactory)) && ("string" === typeof input.dueBy && (_isFormatDate_1._isFormatDate(input.dueBy) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: 'string & Format<"date">',
+    value: input.dueBy
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".dueBy",
+    expected: '(string & Format<"date">)',
+    value: input.dueBy
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao3 = (input, _path, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".kind",
+    expected: '("advertising" | "night")',
+    value: input.kind
+  }, _errorFactory)) && ("string" === typeof input.at && (_isFormatDateTime_1._isFormatDateTime(input.at) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: 'string & Format<"date-time">',
+    value: input.at
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".at",
+    expected: '(string & Format<"date-time">)',
+    value: input.at
+  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["kind", "at"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (void 0 !== input.variant)
+      return _ao0(input, _path, _exceptionable);
+    else
+      return _ao2(input, _path, _exceptionable);
+  })();
+  const _io0 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io1(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && ("consent-result.advertising.granted" === input.variant || "consent-result.advertising.refused" === input.variant || "consent-result.advertising.withdrawn" === input.variant || "consent-result.night.granted" === input.variant || "consent-result.night.refused" === input.variant || "consent-result.night.withdrawn" === input.variant || "reconfirmation.advertising" === input.variant || "reconfirmation.night" === input.variant) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy", "variant"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("granted" === input.state || "withdrawn" === input.state) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (void 0 === input.textVersion || "string" === typeof input.textVersion && 1 <= input.textVersion.length) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "state", "at", "textVersion"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => ("consent-result" === input.kind || "reconfirmation" === input.kind) && ("object" === typeof input.record && null !== input.record && _io3(input.record, _exceptionable)) && ("string" === typeof input.dueBy && _isFormatDate_1._isFormatDate(input.dueBy)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "record", "dueBy"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => ("advertising" === input.kind || "night" === input.kind) && ("string" === typeof input.at && _isFormatDateTime_1._isFormatDateTime(input.at)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["kind", "at"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _iu0 = (input, _exceptionable = true) => (() => {
+    if (void 0 !== input.variant)
+      return _io0(input, _exceptionable);
+    else
+      return _io2(input, _exceptionable);
+  })();
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "(NotificationNotice | NotificationNoticeIdentity)",
+        value: input2
+      }, _errorFactory)) && _au0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "(NotificationNotice | NotificationNoticeIdentity)",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.RecordNotificationNoticeInput);
+var assertNotificationBridgeListLocalResult = withStrictTimes("listLocal result", /* @__PURE__ */ (() => {
+  const _ao0 = (input, _path, _exceptionable = true) => ((Array.isArray(input.pending) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending",
+    expected: "ReadonlyArray<LocalNotificationEntry>",
+    value: input.pending
+  }, _errorFactory)) && input.pending.every((elem, _index2) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending[" + _index2 + "]",
+    expected: "LocalNotificationEntry",
+    value: elem
+  }, _errorFactory)) && _ao1(elem, _path + ".pending[" + _index2 + "]", _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending[" + _index2 + "]",
+    expected: "LocalNotificationEntry",
+    value: elem
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".pending",
+    expected: "ReadonlyArray<LocalNotificationEntry>",
+    value: input.pending
+  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["pending"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.key && (1 <= input.key.length || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "string & CommerceMinLength<1>",
+    value: input.key
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".key",
+    expected: "(string & CommerceMinLength<1>)",
+    value: input.key
+  }, _errorFactory)) && ("string" === typeof input.topic || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".topic",
+    expected: "string",
+    value: input.topic
+  }, _errorFactory)) && ("string" === typeof input.fireAt && (_isFormatDateTime_1._isFormatDateTime(input.fireAt) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "string & CommerceDateTimeFormat",
+    value: input.fireAt
+  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+    method: "typia.createAssertEquals",
+    path: _path + ".fireAt",
+    expected: "(string & CommerceDateTimeFormat)",
+    value: input.fireAt
+  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _assertGuard_1._assertGuard(_exceptionable, {
+      method: "typia.createAssertEquals",
+      path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+      expected: "undefined",
+      value
+    }, _errorFactory);
+  })));
+  const _io0 = (input, _exceptionable = true) => Array.isArray(input.pending) && input.pending.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["pending"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.key && 1 <= input.key.length && "string" === typeof input.topic && ("string" === typeof input.fireAt && _isFormatDateTime_1._isFormatDateTime(input.fireAt)) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["key", "topic", "fireAt"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let _errorFactory;
+  return (input, errorFactory) => {
+    if (false === __is(input)) {
+      _errorFactory = errorFactory;
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBridgeListLocalResult",
+        value: input2
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_1._assertGuard(true, {
+        method: "typia.createAssertEquals",
+        path: _path + "",
+        expected: "NotificationBridgeListLocalResult",
+        value: input2
+      }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+  };
+})(), notificationTimeFields.NotificationBridgeListLocalResult);
+
+// node_modules/.cache/mpgd-native-build/packages/catalog/src/notification-topics-shape.js
+import * as _isTypeUint32_12 from "typia/lib/internal/_isTypeUint32";
 import * as _accessExpressionAsString_12 from "typia/lib/internal/_accessExpressionAsString";
+import * as _validateReport_1 from "typia/lib/internal/_validateReport";
+import * as _createStandardSchema_1 from "typia/lib/internal/_createStandardSchema";
 import typia2 from "typia";
+var __typia_transform__accessExpressionAsString2 = _accessExpressionAsString_12._accessExpressionAsString;
+var validateShape = (() => {
+  const _io0 = (input, _exceptionable = true) => (void 0 === input.notices || "object" === typeof input.notices && null !== input.notices && _io1(input.notices, _exceptionable)) && ("string" === typeof input.version && 1 <= input.version.length) && ("string" === typeof input.defaultLocale && 1 <= input.defaultLocale.length) && (Array.isArray(input.topics) && input.topics.every((elem, _index1) => "object" === typeof elem && null !== elem && _io2(elem, _exceptionable))) && (3 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["notices", "version", "defaultLocale", "topics"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io1 = (input, _exceptionable = true) => "string" === typeof input.topic && 1 <= input.topic.length && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["copy", "topic"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io2 = (input, _exceptionable = true) => "string" === typeof input.id && 1 <= input.id.length && ("advertising" === input.purpose || "requested" === input.purpose || "service" === input.purpose) && (Array.isArray(input.channels) && (1 <= input.channels.length && input.channels.every((elem, _index2) => "local" === elem || "remote" === elem))) && ("string" === typeof input.route && 1 <= input.route.length) && (void 0 === input.optOutRoute || "string" === typeof input.optOutRoute && 1 <= input.optOutRoute.length) && (void 0 === input.copy || "object" === typeof input.copy && null !== input.copy && false === Array.isArray(input.copy) && _io3(input.copy, _exceptionable)) && (void 0 === input.frequency || "object" === typeof input.frequency && null !== input.frequency && _io5(input.frequency, _exceptionable)) && (void 0 === input.quietHours || "object" === typeof input.quietHours && null !== input.quietHours && _io6(input.quietHours, _exceptionable)) && (void 0 === input.deferrable || "boolean" === typeof input.deferrable) && (void 0 === input.targets || "object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) && _io7(input.targets, _exceptionable)) && (4 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["id", "purpose", "channels", "route", "optOutRoute", "copy", "frequency", "quietHours", "deferrable", "targets"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io3 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "object" === typeof value && null !== value && _io4(value, _exceptionable);
+  });
+  const _io4 = (input, _exceptionable = true) => "string" === typeof input.title && 1 <= input.title.length && ("string" === typeof input.body && 1 <= input.body.length) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["title", "body"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io5 = (input, _exceptionable = true) => "number" === typeof input.maxPerDay && (_isTypeUint32_12._isTypeUint32(input.maxPerDay) && 1 <= input.maxPerDay) && (1 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["maxPerDay"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io6 = (input, _exceptionable = true) => "string" === typeof input.start && RegExp("^(?:[01][0-9]|2[0-3]):[0-5][0-9]$").test(input.start) && ("string" === typeof input.end && RegExp("^(?:[01][0-9]|2[0-3]):[0-5][0-9]$").test(input.end)) && (2 === Object.keys(input).length || Object.keys(input).every((key) => {
+    if (["start", "end"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return false;
+  }));
+  const _io7 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "object" === typeof value && null !== value && false === Array.isArray(value) && _io8(value, _exceptionable);
+  });
+  const _io8 = (input, _exceptionable = true) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value;
+  });
+  const _vo0 = (input, _path, _exceptionable = true) => [void 0 === input.notices || ("object" === typeof input.notices && null !== input.notices || _report(_exceptionable, {
+    path: _path + ".notices",
+    expected: "(NotificationTopicCatalogNotices | undefined)",
+    value: input.notices
+  })) && _vo1(input.notices, _path + ".notices", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".notices",
+    expected: "(NotificationTopicCatalogNotices | undefined)",
+    value: input.notices
+  }), "string" === typeof input.version && (1 <= input.version.length || _report(_exceptionable, {
+    path: _path + ".version",
+    expected: "string & MinLength<1>",
+    value: input.version
+  })) || _report(_exceptionable, {
+    path: _path + ".version",
+    expected: "(string & MinLength<1>)",
+    value: input.version
+  }), "string" === typeof input.defaultLocale && (1 <= input.defaultLocale.length || _report(_exceptionable, {
+    path: _path + ".defaultLocale",
+    expected: "string & MinLength<1>",
+    value: input.defaultLocale
+  })) || _report(_exceptionable, {
+    path: _path + ".defaultLocale",
+    expected: "(string & MinLength<1>)",
+    value: input.defaultLocale
+  }), (Array.isArray(input.topics) || _report(_exceptionable, {
+    path: _path + ".topics",
+    expected: "ReadonlyArray<NotificationTopicCatalogEntry>",
+    value: input.topics
+  })) && input.topics.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".topics[" + _index3 + "]",
+    expected: "NotificationTopicCatalogEntry",
+    value: elem
+  })) && _vo2(elem, _path + ".topics[" + _index3 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".topics[" + _index3 + "]",
+    expected: "NotificationTopicCatalogEntry",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".topics",
+    expected: "ReadonlyArray<NotificationTopicCatalogEntry>",
+    value: input.topics
+  }), 3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["notices", "version", "defaultLocale", "topics"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => [true, "string" === typeof input.topic && (1 <= input.topic.length || _report(_exceptionable, {
+    path: _path + ".topic",
+    expected: "string & MinLength<1>",
+    value: input.topic
+  })) || _report(_exceptionable, {
+    path: _path + ".topic",
+    expected: "(string & MinLength<1>)",
+    value: input.topic
+  }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["copy", "topic"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.id && (1 <= input.id.length || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "string & MinLength<1>",
+    value: input.id
+  })) || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "(string & MinLength<1>)",
+    value: input.id
+  }), "advertising" === input.purpose || "requested" === input.purpose || "service" === input.purpose || _report(_exceptionable, {
+    path: _path + ".purpose",
+    expected: '("advertising" | "requested" | "service")',
+    value: input.purpose
+  }), (Array.isArray(input.channels) || _report(_exceptionable, {
+    path: _path + ".channels",
+    expected: "(ReadonlyArray<NotificationChannel> & MinItems<1>)",
+    value: input.channels
+  })) && ((1 <= input.channels.length || _report(_exceptionable, {
+    path: _path + ".channels",
+    expected: "Array<> & MinItems<1>",
+    value: input.channels
+  })) && input.channels.map((elem, _index4) => "local" === elem || "remote" === elem || _report(_exceptionable, {
+    path: _path + ".channels[" + _index4 + "]",
+    expected: '("local" | "remote")',
+    value: elem
+  })).every((flag) => flag)) || _report(_exceptionable, {
+    path: _path + ".channels",
+    expected: "(ReadonlyArray<NotificationChannel> & MinItems<1>)",
+    value: input.channels
+  }), "string" === typeof input.route && (1 <= input.route.length || _report(_exceptionable, {
+    path: _path + ".route",
+    expected: "string & MinLength<1>",
+    value: input.route
+  })) || _report(_exceptionable, {
+    path: _path + ".route",
+    expected: "(string & MinLength<1>)",
+    value: input.route
+  }), void 0 === input.optOutRoute || "string" === typeof input.optOutRoute && (1 <= input.optOutRoute.length || _report(_exceptionable, {
+    path: _path + ".optOutRoute",
+    expected: "string & MinLength<1>",
+    value: input.optOutRoute
+  })) || _report(_exceptionable, {
+    path: _path + ".optOutRoute",
+    expected: "((string & MinLength<1>) | undefined)",
+    value: input.optOutRoute
+  }), void 0 === input.copy || ("object" === typeof input.copy && null !== input.copy && false === Array.isArray(input.copy) || _report(_exceptionable, {
+    path: _path + ".copy",
+    expected: "(Readonly<Record<string, NotificationTopicCopy>> | undefined)",
+    value: input.copy
+  })) && _vo3(input.copy, _path + ".copy", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".copy",
+    expected: "(Readonly<Record<string, NotificationTopicCopy>> | undefined)",
+    value: input.copy
+  }), void 0 === input.frequency || ("object" === typeof input.frequency && null !== input.frequency || _report(_exceptionable, {
+    path: _path + ".frequency",
+    expected: "(NotificationTopicFrequency | undefined)",
+    value: input.frequency
+  })) && _vo5(input.frequency, _path + ".frequency", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".frequency",
+    expected: "(NotificationTopicFrequency | undefined)",
+    value: input.frequency
+  }), void 0 === input.quietHours || ("object" === typeof input.quietHours && null !== input.quietHours || _report(_exceptionable, {
+    path: _path + ".quietHours",
+    expected: "(NotificationQuietHours | undefined)",
+    value: input.quietHours
+  })) && _vo6(input.quietHours, _path + ".quietHours", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".quietHours",
+    expected: "(NotificationQuietHours | undefined)",
+    value: input.quietHours
+  }), void 0 === input.deferrable || "boolean" === typeof input.deferrable || _report(_exceptionable, {
+    path: _path + ".deferrable",
+    expected: "(boolean | undefined)",
+    value: input.deferrable
+  }), void 0 === input.targets || ("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _report(_exceptionable, {
+    path: _path + ".targets",
+    expected: "(Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined)",
+    value: input.targets
+  })) && _vo7(input.targets, _path + ".targets", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".targets",
+    expected: "(Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined)",
+    value: input.targets
+  }), 4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["id", "purpose", "channels", "route", "optOutRoute", "copy", "frequency", "quietHours", "deferrable", "targets"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return ("object" === typeof value && null !== value || _report(_exceptionable, {
+      path: _path + __typia_transform__accessExpressionAsString2(key),
+      expected: "NotificationTopicCopy",
+      value
+    })) && _vo4(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _report(_exceptionable, {
+      path: _path + __typia_transform__accessExpressionAsString2(key),
+      expected: "NotificationTopicCopy",
+      value
+    });
+  }).every((flag) => flag)].every((flag) => flag);
+  const _vo4 = (input, _path, _exceptionable = true) => ["string" === typeof input.title && (1 <= input.title.length || _report(_exceptionable, {
+    path: _path + ".title",
+    expected: "string & MinLength<1>",
+    value: input.title
+  })) || _report(_exceptionable, {
+    path: _path + ".title",
+    expected: "(string & MinLength<1>)",
+    value: input.title
+  }), "string" === typeof input.body && (1 <= input.body.length || _report(_exceptionable, {
+    path: _path + ".body",
+    expected: "string & MinLength<1>",
+    value: input.body
+  })) || _report(_exceptionable, {
+    path: _path + ".body",
+    expected: "(string & MinLength<1>)",
+    value: input.body
+  }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["title", "body"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo5 = (input, _path, _exceptionable = true) => ["number" === typeof input.maxPerDay && (_isTypeUint32_12._isTypeUint32(input.maxPerDay) || _report(_exceptionable, {
+    path: _path + ".maxPerDay",
+    expected: 'number & Type<"uint32">',
+    value: input.maxPerDay
+  })) && (1 <= input.maxPerDay || _report(_exceptionable, {
+    path: _path + ".maxPerDay",
+    expected: "number & Minimum<1>",
+    value: input.maxPerDay
+  })) || _report(_exceptionable, {
+    path: _path + ".maxPerDay",
+    expected: '(number & Type<"uint32"> & Minimum<1>)',
+    value: input.maxPerDay
+  }), 1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["maxPerDay"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo6 = (input, _path, _exceptionable = true) => ["string" === typeof input.start && (RegExp("^(?:[01][0-9]|2[0-3]):[0-5][0-9]$").test(input.start) || _report(_exceptionable, {
+    path: _path + ".start",
+    expected: 'string & Pattern<"^(?:[01][0-9]|2[0-3]):[0-5][0-9]$">',
+    value: input.start
+  })) || _report(_exceptionable, {
+    path: _path + ".start",
+    expected: '(string & Pattern<"^(?:[01][0-9]|2[0-3]):[0-5][0-9]$">)',
+    value: input.start
+  }), "string" === typeof input.end && (RegExp("^(?:[01][0-9]|2[0-3]):[0-5][0-9]$").test(input.end) || _report(_exceptionable, {
+    path: _path + ".end",
+    expected: 'string & Pattern<"^(?:[01][0-9]|2[0-3]):[0-5][0-9]$">',
+    value: input.end
+  })) || _report(_exceptionable, {
+    path: _path + ".end",
+    expected: '(string & Pattern<"^(?:[01][0-9]|2[0-3]):[0-5][0-9]$">)',
+    value: input.end
+  }), 2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).map((key) => {
+    if (["start", "end"].some((prop) => key === prop))
+      return true;
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return _report(_exceptionable, {
+      path: _path + _accessExpressionAsString_12._accessExpressionAsString(key),
+      expected: "undefined",
+      value,
+      description: [
+        `The property \`${key}\` is not defined in the object type.`,
+        "",
+        "Please remove the property next time."
+      ].join("\n")
+    });
+  }).every((flag) => flag))].every((flag) => flag);
+  const _vo7 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return ("object" === typeof value && null !== value && false === Array.isArray(value) || _report(_exceptionable, {
+      path: _path + __typia_transform__accessExpressionAsString2(key),
+      expected: "Readonly<Record<string, string | number | boolean>>",
+      value
+    })) && _vo8(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _report(_exceptionable, {
+      path: _path + __typia_transform__accessExpressionAsString2(key),
+      expected: "Readonly<Record<string, string | number | boolean>>",
+      value
+    });
+  }).every((flag) => flag)].every((flag) => flag);
+  const _vo8 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return "string" === typeof value || "number" === typeof value || "boolean" === typeof value || _report(_exceptionable, {
+      path: _path + __typia_transform__accessExpressionAsString2(key),
+      expected: "(boolean | number | string)",
+      value
+    });
+  }).every((flag) => flag)].every((flag) => flag);
+  const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+  let errors;
+  let _report;
+  return _createStandardSchema_1._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = _validateReport_1._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "NotificationTopicCatalog",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "NotificationTopicCatalog",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
 
 // node_modules/.cache/mpgd-native-build/packages/catalog/src/index.js
-import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_1 from "typia/lib/internal/_accessExpressionAsString";
-import typia from "typia";
 var defaultCatalogCurrencies = Object.freeze(["coin", "gem"]);
 function resolveProductPlatformId(product, target2) {
   const identifier = readOwnPlatformIdentifier(product.platformProductIds, target2);
@@ -4470,6 +6175,8 @@ function normalizePlatformIdentifier(identifier) {
 }
 
 // node_modules/.cache/mpgd-native-build/packages/target-config/src/runtime.js
+import * as _isTypeUint32_13 from "typia/lib/internal/_isTypeUint32";
+import typia4 from "typia";
 var adPlacementFeatureByType = {
   rewarded: "rewardedAds",
   interstitial: "interstitialAds",
@@ -5007,19 +6714,19 @@ function isRecord2(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";
+import * as _isTypeUint32_15 from "typia/lib/internal/_isTypeUint32";
+import * as _isFormatDateTime_13 from "typia/lib/internal/_isFormatDateTime";
+import * as _assertGuard_15 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
+import typia7 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";
+import * as _isTypeUint32_14 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_15 from "typia/lib/internal/_accessExpressionAsString";
+import typia6 from "typia";
 var commerceErrorCodes = Object.freeze([
   "USER_CANCELLED",
   "OUTCOME_UNKNOWN",
@@ -5079,15 +6786,23 @@ var terminalCommercePurchaseStates = Object.freeze([
   "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);
+var notificationsV2MethodList = [
+  "notifications.v2.getCapabilities",
+  "notifications.v2.getPermission",
+  "notifications.v2.requestPermission",
+  "notifications.v2.revokePermission",
+  "notifications.v2.register",
+  "notifications.v2.scheduleLocal",
+  "notifications.v2.cancelLocal",
+  "notifications.v2.listLocal",
+  "notifications.v2.openSettings"
+];
+var bridgeNotificationsV2Methods = Object.freeze(notificationsV2MethodList);
+var bridgeNotificationsV2MethodSet = new Set(bridgeNotificationsV2Methods);
 
 // node_modules/.cache/mpgd-native-build/adapters/devvit/src/catalog-products.js
 var defaultDevvitCatalogTarget = "reddit";
@@ -5535,10 +7250,10 @@ function formatError4(error) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/schemas.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__accessExpressionAsString = _accessExpressionAsString_15._accessExpressionAsString;
+import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_17 from "typia/lib/internal/_accessExpressionAsString";
+import typia8 from "typia";
+var __typia_transform__accessExpressionAsString3 = _accessExpressionAsString_17._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"];
@@ -5550,75 +7265,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_15._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => void 0 === input["assetPacks"] || ("object" === typeof input["assetPacks"] && null !== input["assetPacks"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".assetPacks",
     expected: "(AssetPackTargetPolicy | undefined)",
     value: input["assetPacks"]
-  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input["assetPacks"], _path + ".assetPacks", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["gameApp"] || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["adapter"] || _assertGuard_16._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_15._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_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".metadata",
     expected: "(TargetReleaseMetadata | undefined)",
     value: input["metadata"]
-  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input["metadata"], _path + ".metadata", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => void 0 === input["authoritativeGameServices"] || "boolean" === typeof input["authoritativeGameServices"] || _assertGuard_16._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_15._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_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(Partial<TargetIntegrationConfig> | undefined)",
     value: input["integrations"]
-  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input["integrations"], _path + ".integrations", _exceptionable) || _assertGuard_16._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_15._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_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".icon",
     expected: "(TargetIconConfig | undefined)",
     value: input["icon"]
-  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input["icon"], _path + ".icon", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["wrapperApp"] || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ap8 = (input, _path, _exceptionable = true) => "string" === typeof input["webDir"] || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".webDir",
     expected: "string",
@@ -5626,18 +7341,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_15._assertGuard(_exceptionable, {
+  const _ap9 = (input, _path, _exceptionable = true) => "string" === typeof input["output"] || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("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, PlatformTargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, PlatformTargetConfig>",
@@ -5647,190 +7362,241 @@ var assertPlatformTargetsConfig = /* @__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_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString(key),
+      path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
       value
-    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString(key), _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _au0(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString(key),
+      path: _path + __typia_transform__accessExpressionAsString3(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_15._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_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".kind",
     expected: '("capacitor-android" | "capacitor-ios")',
     value: input.kind
-  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.shellApp || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap8(input, _path, _exceptionable) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact || _assertGuard_16._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_15._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_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && ("devvit" === input.artifact || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: '"devvit"',
     value: input.artifact
+  }, _errorFactory)) && (void 0 === input.inlineEntry || "string" === typeof input.inlineEntry || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".inlineEntry",
+    expected: "(string | undefined)",
+    value: input.inlineEntry
+  }, _errorFactory)) && (void 0 === input.inlineBudget || ("object" === typeof input.inlineBudget && null !== input.inlineBudget && false === Array.isArray(input.inlineBudget) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".inlineBudget",
+    expected: "(DevvitInlineBudget | undefined)",
+    value: input.inlineBudget
+  }, _errorFactory)) && _ao12(input.inlineBudget, _path + ".inlineBudget", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".inlineBudget",
+    expected: "(DevvitInlineBudget | undefined)",
+    value: input.inlineBudget
+  }, _errorFactory));
+  const _ao12 = (input, _path, _exceptionable = true) => (void 0 === input.maxGzipKb || "number" === typeof input.maxGzipKb || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".maxGzipKb",
+    expected: "(number | undefined)",
+    value: input.maxGzipKb
+  }, _errorFactory)) && (void 0 === input.forbidModules || (Array.isArray(input.forbidModules) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".forbidModules",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.forbidModules
+  }, _errorFactory)) && input.forbidModules.every((elem, _index6) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".forbidModules[" + _index6 + "]",
+    expected: "string",
+    value: elem
+  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".forbidModules",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.forbidModules
+  }, _errorFactory)) && (void 0 === input.deferredChunks || (Array.isArray(input.deferredChunks) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".deferredChunks",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.deferredChunks
+  }, _errorFactory)) && input.deferredChunks.every((elem, _index7) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".deferredChunks[" + _index7 + "]",
+    expected: "string",
+    value: elem
+  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
+    method: "typia.createAssert",
+    path: _path + ".deferredChunks",
+    expected: "(ReadonlyArray<string> | undefined)",
+    value: input.deferredChunks
   }, _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_15._assertGuard(_exceptionable, {
+  const _ao13 = (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_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && ("canvas" === input.renderer || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderer",
     expected: '"canvas"',
     value: input.renderer
-  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("landscape" === input.orientation || "portrait" === input.orientation || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".orientation",
     expected: '("landscape" | "portrait")',
     value: input.orientation
-  }, _errorFactory)) && (true === input.experimental || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (true === input.experimental || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".experimental",
     expected: "true",
     value: input.experimental
-  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteAssetOrigins || (Array.isArray(input.remoteAssetOrigins) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.remoteAssetOrigins.every((elem, _index8) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
-    path: _path + ".remoteAssetOrigins[" + _index4 + "]",
+    path: _path + ".remoteAssetOrigins[" + _index8 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteAssetOrigins",
     expected: "(ReadonlyArray<string> | undefined)",
     value: input.remoteAssetOrigins
-  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.packageBudget && null !== input.packageBudget || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageBudget",
     expected: "MiniGamePackageBudget",
     value: input.packageBudget
-  }, _errorFactory)) && _ao13(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao14(input.packageBudget, _path + ".packageBudget", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao14 = (input, _path, _exceptionable = true) => ("number" === typeof input.mainBytes || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".mainBytes",
     expected: "number",
     value: input.mainBytes
-  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.totalBytes || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".totalBytes",
     expected: "number",
     value: input.totalBytes
-  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao15 = (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_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap9(input, _path, _exceptionable) && (void 0 === input.installable || "boolean" === typeof input.installable || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.staticDir || "string" === typeof input.staticDir || _assertGuard_16._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_15._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_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap7(input, _path, _exceptionable) && _ap8(input, _path, _exceptionable) && (".ait" === input.artifact || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.navigationBar || ("object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".navigationBar",
     expected: "(AppsInTossNavigationBarConfig | undefined)",
     value: input.navigationBar
-  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.navigationBar, _path + ".navigationBar", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packs || ("object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.packs, _path + ".packs", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.offlineRequired || (Array.isArray(input.offlineRequired) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.offlineRequired.every((elem, _index5) => "string" === typeof elem || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
-    path: _path + ".offlineRequired[" + _index3 + "]",
+    path: _path + ".offlineRequired[" + _index5 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteBaseUrl",
     expected: "(string | undefined)",
     value: input.remoteBaseUrl
-  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPackagedBytes",
     expected: "(number | undefined)",
     value: input.maxPackagedBytes
-  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildConfig || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildConfig",
     expected: "string",
@@ -5840,148 +7606,148 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return "packaged" === value || "remote" === value || _assertGuard_15._assertGuard(_exceptionable, {
+    return "packaged" === value || "remote" === value || _assertGuard_16._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString(key),
+      path: _path + __typia_transform__accessExpressionAsString3(key),
       expected: '("packaged" | "remote")',
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_15._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.displayName || "string" === typeof input.displayName || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".displayName",
     expected: "(string | undefined)",
     value: input.displayName
-  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.primaryColor || "string" === typeof input.primaryColor || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".primaryColor",
     expected: "(string | undefined)",
     value: input.primaryColor
-  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.packageId || "string" === typeof input.packageId || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".packageId",
     expected: "(string | undefined)",
     value: input.packageId
-  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.bundleId || "string" === typeof input.bundleId || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".bundleId",
     expected: "(string | undefined)",
     value: input.bundleId
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_16._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_15._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_16._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_15._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_16._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_15._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_16._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_15._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_16._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_15._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_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.presentationMode || "fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.source || "string" === typeof input.source || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".source",
     expected: "(string | undefined)",
     value: input.source
-  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.backgroundColor || "string" === typeof input.backgroundColor || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".backgroundColor",
     expected: "(string | undefined)",
     value: input.backgroundColor
-  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.externalUrl || "string" === typeof input.externalUrl || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.variants || ("object" === typeof input.variants && null !== input.variants && false === Array.isArray(input.variants) || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".variants",
     expected: _ae1,
     value: input.variants
-  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.variants, _path + ".variants", _exceptionable) || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (void 0 === input.maskable || "string" === typeof input.maskable || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maskable",
     expected: "(string | undefined)",
     value: input.maskable
-  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.androidForeground || "string" === typeof input.androidForeground || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".androidForeground",
     expected: "(string | undefined)",
     value: input.androidForeground
-  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.monochrome || "string" === typeof input.monochrome || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monochrome",
     expected: "(string | undefined)",
     value: input.monochrome
-  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.background || "string" === typeof input.background || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => (void 0 === input.withBackButton || "boolean" === typeof input.withBackButton || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withBackButton",
     expected: "(boolean | undefined)",
     value: input.withBackButton
-  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withHomeButton || "boolean" === typeof input.withHomeButton || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withHomeButton",
     expected: "(boolean | undefined)",
     value: input.withHomeButton
-  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.withTitle || "boolean" === typeof input.withTitle || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".withTitle",
     expected: "(boolean | undefined)",
     value: input.withTitle
-  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.transparentBackground || "boolean" === typeof input.transparentBackground || _assertGuard_16._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_15._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.theme || "dark" === input.theme || "light" === input.theme || _assertGuard_16._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".theme",
     expected: '("dark" | "light" | undefined)',
@@ -5995,11 +7761,11 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     else if ("devvit-web" === input.kind)
       return _ao11(input, _path, _exceptionable);
     else if ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind)
-      return _ao12(input, _path, _exceptionable);
+      return _ao13(input, _path, _exceptionable);
     else if ("web" === input.kind)
-      return _ao14(input, _path, _exceptionable);
+      return _ao15(input, _path, _exceptionable);
     else
-      return _assertGuard_15._assertGuard(_exceptionable, {
+      return _assertGuard_16._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: "(AppsInTossTargetConfig | CapacitorTargetConfig | DevvitTargetConfig | MiniGameTargetConfig | WebTargetConfig)",
@@ -6014,10 +7780,11 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     return "object" === typeof value && null !== value && _iu0(value);
   });
   const _io10 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && ("capacitor-android" === input.kind || "capacitor-ios" === input.kind) && "string" === typeof input.shellApp && _ip8(input) && ("aab" === input.artifact || "apk" === input.artifact || "ipa" === input.artifact);
-  const _io11 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && "devvit-web" === input.kind && _ip7(input) && _ip8(input) && "devvit" === input.artifact;
-  const _io12 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind) && _ip9(input) && "canvas" === input.renderer && ("landscape" === input.orientation || "portrait" === input.orientation) && true === input.experimental && (void 0 === input.remoteAssetOrigins || Array.isArray(input.remoteAssetOrigins) && input.remoteAssetOrigins.every((elem) => "string" === typeof elem)) && ("object" === typeof input.packageBudget && null !== input.packageBudget && _io13(input.packageBudget));
-  const _io13 = (input) => "number" === typeof input.mainBytes && "number" === typeof input.totalBytes && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes);
-  const _io14 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && "web" === input.kind && _ip9(input) && (void 0 === input.installable || "boolean" === typeof input.installable) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch) && (void 0 === input.staticDir || "string" === typeof input.staticDir);
+  const _io11 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && "devvit-web" === input.kind && _ip7(input) && _ip8(input) && "devvit" === input.artifact && (void 0 === input.inlineEntry || "string" === typeof input.inlineEntry) && (void 0 === input.inlineBudget || "object" === typeof input.inlineBudget && null !== input.inlineBudget && false === Array.isArray(input.inlineBudget) && _io12(input.inlineBudget));
+  const _io12 = (input) => (void 0 === input.maxGzipKb || "number" === typeof input.maxGzipKb) && (void 0 === input.forbidModules || Array.isArray(input.forbidModules) && input.forbidModules.every((elem) => "string" === typeof elem)) && (void 0 === input.deferredChunks || Array.isArray(input.deferredChunks) && input.deferredChunks.every((elem) => "string" === typeof elem));
+  const _io13 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind) && _ip9(input) && "canvas" === input.renderer && ("landscape" === input.orientation || "portrait" === input.orientation) && true === input.experimental && (void 0 === input.remoteAssetOrigins || Array.isArray(input.remoteAssetOrigins) && input.remoteAssetOrigins.every((elem) => "string" === typeof elem)) && ("object" === typeof input.packageBudget && null !== input.packageBudget && _io14(input.packageBudget));
+  const _io14 = (input) => "number" === typeof input.mainBytes && "number" === typeof input.totalBytes && (void 0 === input.independentSubpackageBytes || "number" === typeof input.independentSubpackageBytes);
+  const _io15 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && "web" === input.kind && _ip9(input) && (void 0 === input.installable || "boolean" === typeof input.installable) && (void 0 === input.crazyGamesLaunch || "basic" === input.crazyGamesLaunch || "full" === input.crazyGamesLaunch) && (void 0 === input.staticDir || "string" === typeof input.staticDir);
   const _io2 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && "apps-in-toss" === input.kind && _ip7(input) && _ip8(input) && ".ait" === input.artifact && (void 0 === input.navigationBar || "object" === typeof input.navigationBar && null !== input.navigationBar && false === Array.isArray(input.navigationBar) && _io9(input.navigationBar));
   const _io3 = (input) => ("packaged" === input.defaultLocation || "remote" === input.defaultLocation) && (void 0 === input.packs || "object" === typeof input.packs && null !== input.packs && false === Array.isArray(input.packs) && _io4(input.packs)) && (void 0 === input.offlineRequired || Array.isArray(input.offlineRequired) && input.offlineRequired.every((elem) => "string" === typeof elem)) && (void 0 === input.remoteBaseUrl || "string" === typeof input.remoteBaseUrl) && (void 0 === input.maxPackagedBytes || "number" === typeof input.maxPackagedBytes) && "string" === typeof input.buildConfig;
   const _io4 = (input) => Object.keys(input).every((key) => {
@@ -6039,9 +7806,9 @@ var assertPlatformTargetsConfig = /* @__PURE__ */ (() => {
     else if ("devvit-web" === input.kind)
       return _io11(input);
     else if ("tiktok-minigame" === input.kind || "wechat-minigame" === input.kind)
-      return _io12(input);
+      return _io13(input);
     else if ("web" === input.kind)
-      return _io14(input);
+      return _io15(input);
     else
       return false;
   })();
@@ -6050,12 +7817,12 @@ var assertPlatformTargetsConfig = /* @__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_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_15._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "PlatformTargetsConfig",
@@ -6354,12 +8121,12 @@ function assertTargetKind(input, target2) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/target-config-matrix.js
-import * as _assertGuard_16 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_16 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_17 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_18 from "typia/lib/internal/_accessExpressionAsString";
 import { createHash as createHash6 } from "node:crypto";
 import { readFileSync as readFileSync11 } from "node:fs";
-import typia6 from "typia";
-var __typia_transform__accessExpressionAsString2 = _accessExpressionAsString_16._accessExpressionAsString;
+import typia9 from "typia";
+var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_18._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"]);
@@ -6371,31 +8138,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_16._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -6404,17 +8171,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_16._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_17._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_16._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, TargetConfig>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, TargetConfig>",
@@ -6424,207 +8191,207 @@ var assertTargetConfigMatrix = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_16._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString2(key),
+      path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString2(key),
+      path: _path + __typia_transform__accessExpressionAsString4(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_16._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_17._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_16._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_17._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_16._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_17._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_16._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_17._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_16._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_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -6651,12 +8418,12 @@ var assertTargetConfigMatrix = /* @__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_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigMatrix",
@@ -6676,31 +8443,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_16._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "boolean" === typeof input["iap"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => void 0 === input["bannerAds"] || "boolean" === typeof input["bannerAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "boolean" === typeof input["rewardedAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap3 = (input, _path, _exceptionable = true) => "boolean" === typeof input["interstitialAds"] || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ap4 = (input, _path, _exceptionable = true) => "boolean" === typeof input["localization"] || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "boolean",
@@ -6709,17 +8476,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_16._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_17._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_16._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: "Readonly<Record<string, TargetConfig>>",
     value: input.targets
-  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Readonly<Record<string, TargetConfig>>",
@@ -6729,207 +8496,207 @@ var assertTargetConfigExtensions = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_16._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString2(key),
+      path: _path + __typia_transform__accessExpressionAsString4(key),
       expected: "TargetConfig",
       value
-    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString2(key), _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao2(value, _path + __typia_transform__accessExpressionAsString4(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString2(key),
+      path: _path + __typia_transform__accessExpressionAsString4(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_16._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_17._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_16._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_17._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_16._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_17._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_16._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_17._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_16._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_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".notifications",
     expected: _ae2,
     value: input.notifications
-  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("fullscreen" === input.presentationMode || "inline-expanded" === input.presentationMode || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => (true === _av0.has(input.runtime) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".runtime",
     expected: _ae0,
     value: input.runtime
-  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.features && null !== input.features || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.features, _path + ".features", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".features",
     expected: "TargetFeatureConfig",
     value: input.features
-  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.capabilities, _path + ".capabilities", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".capabilities",
     expected: "TargetCapabilityConfig",
     value: input.capabilities
-  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.localization && null !== input.localization || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.localization, _path + ".localization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".localization",
     expected: "TargetLocalizationConfig",
     value: input.localization
-  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.monetization && null !== input.monetization || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.monetization, _path + ".monetization", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".monetization",
     expected: "TargetMonetizationConfig",
     value: input.monetization
-  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.leaderboard && null !== input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao7(input.leaderboard, _path + ".leaderboard", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "TargetLeaderboardConfig",
     value: input.leaderboard
-  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.release && null !== input.release || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao8(input.release, _path + ".release", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".release",
     expected: "TargetReleaseConfig",
     value: input.release
-  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.policy && null !== input.policy || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".policy",
     expected: "TargetPolicyRestrictions",
     value: input.policy
-  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao9(input.policy, _path + ".policy", _exceptionable) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.integrations || ("object" === typeof input.integrations && null !== input.integrations || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".integrations",
     expected: "(TargetIntegrationConfig | undefined)",
     value: input.integrations
-  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao10(input.integrations, _path + ".integrations", _exceptionable) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.subscriptions || "boolean" === typeof input.subscriptions || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && _ap3(input, _path, _exceptionable) && ("boolean" === typeof input.leaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".leaderboard",
     expected: "boolean",
     value: input.leaderboard
-  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeLeaderboard || "boolean" === typeof input.nativeLeaderboard || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeLeaderboard",
     expected: "(boolean | undefined)",
     value: input.nativeLeaderboard
-  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.remoteLeaderboard || "boolean" === typeof input.remoteLeaderboard || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("local" === input.storage || "native" === input.storage || "none" === input.storage || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => "en" === input.fallbackLocale || "ko" === input.fallbackLocale || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => "boolean" === typeof input.native || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao8 = (input, _path, _exceptionable = true) => (true === _av1.has(input.profile) || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.billingAuthority || "host" === input.billingAuthority || "store" === input.billingAuthority || _assertGuard_17._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_16._assertGuard(_exceptionable, {
+  const _ao9 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.externalPaymentAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".externalPaymentAllowed",
     expected: "boolean",
     value: input.externalPaymentAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.remoteExecutableCodeAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".remoteExecutableCodeAllowed",
     expected: "boolean",
     value: input.remoteExecutableCodeAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.installOtherAppCTAAllowed || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".installOtherAppCTAAllowed",
     expected: "boolean",
     value: input.installOtherAppCTAAllowed
-  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresStoreReview || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresStoreReview",
     expected: "boolean",
     value: input.requiresStoreReview
-  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_16._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.requiresAitReview || _assertGuard_17._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".requiresAitReview",
     expected: "boolean",
@@ -6956,12 +8723,12 @@ var assertTargetConfigExtensions = /* @__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_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_16._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "TargetConfigExtensions",
@@ -7318,104 +9085,104 @@ function sha2562(content) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-import * as _assertGuard_18 from "typia/lib/internal/_assertGuard";
-import * as _accessExpressionAsString_18 from "typia/lib/internal/_accessExpressionAsString";
+import * as _assertGuard_19 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_110 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 typia8 from "typia";
+import typia11 from "typia";
 
 // node_modules/.cache/mpgd-native-build/packages/release-manifest/src/index.js
-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;
+import * as _assertGuard_18 from "typia/lib/internal/_assertGuard";
+import * as _accessExpressionAsString_19 from "typia/lib/internal/_accessExpressionAsString";
+import typia10 from "typia";
+var __typia_transform__accessExpressionAsString5 = _accessExpressionAsString_19._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_17._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["gameVersion"] || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["digest"] || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.releaseId || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseId",
     expected: "string",
     value: input.releaseId
-  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.gitSha || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".gitSha",
     expected: "string",
     value: input.gitSha
-  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.kitGitSha || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && (void 0 === input.releaseIdentity || ("object" === typeof input.releaseIdentity && null !== input.releaseIdentity || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(input.releaseIdentity, _path + ".releaseIdentity", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseIdentity",
     expected: "(MpgdReleaseIdentity | undefined)",
     value: input.releaseIdentity
-  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".buildId",
     expected: "string",
     value: input.buildId
-  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetConfigVersion || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetConfigVersion",
     expected: "string",
     value: input.targetConfigVersion
-  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.catalogVersion || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".catalogVersion",
     expected: "string",
     value: input.catalogVersion
-  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.adPlacementVersion || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.targets && null !== input.targets && false === Array.isArray(input.targets) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targets",
     expected: "Record<string, ReleaseTargetManifest>",
     value: input.targets
-  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao2(input.targets, _path + ".targets", _exceptionable) || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, _exceptionable) && (void 0 === input.releaseRevision || "number" === typeof input.releaseRevision || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".releaseRevision",
     expected: "(number | undefined)",
     value: input.releaseRevision
-  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.label || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".label",
     expected: "string",
@@ -7425,142 +9192,142 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return ("object" === typeof value && null !== value || _assertGuard_17._assertGuard(_exceptionable, {
+    return ("object" === typeof value && null !== value || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString3(key),
+      path: _path + __typia_transform__accessExpressionAsString5(key),
       expected: "ReleaseTargetManifest",
       value
-    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString3(key), _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+    }, _errorFactory)) && _ao3(value, _path + __typia_transform__accessExpressionAsString5(key), _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString3(key),
+      path: _path + __typia_transform__accessExpressionAsString5(key),
       expected: "ReleaseTargetManifest",
       value
     }, _errorFactory);
   });
-  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_17._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.artifact || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".artifact",
     expected: "string",
     value: input.artifact
-  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.profile || "string" === typeof input.profile || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".profile",
     expected: "(string | undefined)",
     value: input.profile
-  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.effectiveConfig && null !== input.effectiveConfig || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.effectiveConfig, _path + ".effectiveConfig", _exceptionable) || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.iconManifest && null !== input.iconManifest || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.iconManifest, _path + ".iconManifest", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".iconManifest",
     expected: _ae0,
     value: input.iconManifest
-  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionName || "string" === typeof input.versionName || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionName",
     expected: "(string | undefined)",
     value: input.versionName
-  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.versionCode || "number" === typeof input.versionCode || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".versionCode",
     expected: "(number | undefined)",
     value: input.versionCode
-  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.marketingVersion || "string" === typeof input.marketingVersion || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".marketingVersion",
     expected: "(string | undefined)",
     value: input.marketingVersion
-  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.buildNumber || "string" === typeof input.buildNumber || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.nativeDelivery || ("object" === typeof input.nativeDelivery && null !== input.nativeDelivery || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao6(input.nativeDelivery, _path + ".nativeDelivery", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".nativeDelivery",
     expected: "(ReleaseNativeDelivery | undefined)",
     value: input.nativeDelivery
-  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.appName || "string" === typeof input.appName || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".appName",
     expected: "(string | undefined)",
     value: input.appName
-  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sdkMajor || "number" === typeof input.sdkMajor || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && ("string" === typeof input.version || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => _ap1(input, _path, _exceptionable) && _ap2(input, _path, _exceptionable) && ("string" === typeof input.sourceSha256 || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sourceSha256",
     expected: "string",
     value: input.sourceSha256
-  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.sharedConfigSha256 || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedConfigSha256",
     expected: "string",
     value: input.sharedConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.renderConfigSha256 || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".renderConfigSha256",
     expected: "string",
     value: input.renderConfigSha256
-  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.generatorVersion || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".generatorVersion",
     expected: "string",
     value: input.generatorVersion
-  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfile || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".targetProfile",
     expected: "string",
     value: input.targetProfile
-  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.targetProfileVersion || _assertGuard_18._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_17._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("android" === input.platform || "ios" === input.platform || _assertGuard_18._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_17._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_18._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_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.signed || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".signed",
     expected: "boolean",
     value: input.signed
-  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_17._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("boolean" === typeof input.submissionCandidate || _assertGuard_18._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".submissionCandidate",
     expected: "boolean",
@@ -7583,12 +9350,12 @@ var assertReleaseManifestStructure = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_17._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_17._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ReleaseManifest",
@@ -7736,149 +9503,149 @@ function canRecoverLock(lockFile) {
 }
 
 // node_modules/.cache/mpgd-native-build/tools/target/generate-release-manifest.js
-var __typia_transform__accessExpressionAsString4 = _accessExpressionAsString_18._accessExpressionAsString;
+var __typia_transform__accessExpressionAsString6 = _accessExpressionAsString_110._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_18._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.currencies || (Array.isArray(input.currencies) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((1 <= input.currencies.length || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.currencies.every((elem, _index3) => "string" === typeof elem && (1 <= elem.length || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "string & MinLength<1>",
     value: elem
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currencies[" + _index3 + "]",
     expected: "(string & MinLength<1>)",
     value: elem
-  }, _errorFactory))) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory))) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.products) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.products.every((elem, _index4) => ("object" === typeof elem && null !== elem || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao1(elem, _path + ".products[" + _index4 + "]", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".products[" + _index4 + "]",
     expected: "ProductCatalogEntry",
     value: elem
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("consumable" === input.type || "non_consumable" === input.type || "subscription" === input.type || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.grant && null !== input.grant || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".grant",
     expected: _ae0,
     value: input.grant
-  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(input.grant, _path + ".grant", _exceptionable) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformProductIds && null !== input.platformProductIds && false === Array.isArray(input.platformProductIds) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformProductIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformProductIds
-  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao5(input.platformProductIds, _path + ".platformProductIds", _exceptionable) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"currency"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "(string & MinLength<1>)",
     value: input.currency
-  }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number",
     value: input.amount
   }, _errorFactory));
-  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("entitlement" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"entitlement"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.entitlement || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".entitlement",
     expected: "string",
     value: input.entitlement
   }, _errorFactory));
-  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao4 = (input, _path, _exceptionable = true) => ("resource" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '"resource"',
     value: input.type
-  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("string" === typeof input.resource && (1 <= input.resource.length || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "string & MinLength<1>",
     value: input.resource
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".resource",
     expected: "(string & MinLength<1>)",
     value: input.resource
-  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & ExclusiveMinimum<0>",
     value: input.amount
-  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (input.amount <= 17976931348623157e292 || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "number & Maximum<1.7976931348623157e+308>",
     value: input.amount
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".amount",
     expected: "(number & ExclusiveMinimum<0> & Maximum<1.7976931348623157e+308>)",
@@ -7888,9 +9655,9 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_18._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_19._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString4(key),
+      path: _path + __typia_transform__accessExpressionAsString6(key),
       expected: "(string | undefined)",
       value
     }, _errorFactory);
@@ -7903,7 +9670,7 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
     else if ("resource" === input.type)
       return _ao4(input, _path, _exceptionable);
     else
-      return _assertGuard_18._assertGuard(_exceptionable, {
+      return _assertGuard_19._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -7936,12 +9703,12 @@ var assertProductCatalog = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "ProductCatalog",
@@ -7955,107 +9722,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_18._assertGuard(_exceptionable, {
+  const _ap0 = (input, _path, _exceptionable = true) => "number" === typeof input["amount"] || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.version || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".version",
     expected: "string",
     value: input.version
-  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((Array.isArray(input.placements) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.placements.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au0(elem, _path + ".placements[" + _index3 + "]", _exceptionable) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements[" + _index3 + "]",
     expected: _ae0,
     value: elem
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".placements",
     expected: "ReadonlyArray<AdPlacementEntry>",
     value: input.placements
-  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.sharedPlatformPlacementTargets || (Array.isArray(input.sharedPlatformPlacementTargets) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && input.sharedPlatformPlacementTargets.every((elem, _index4) => "string" === typeof elem || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".sharedPlatformPlacementTargets[" + _index4 + "]",
     expected: "string",
     value: elem
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao1 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("rewarded" === input.type || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || ("object" === typeof input.reward && null !== input.reward || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: _ae1,
     value: input.reward
-  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _au1(input.reward, _path + ".reward", _exceptionable) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".id",
     expected: "string",
     value: input.id
-  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.frequencyCap && null !== input.frequencyCap || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".frequencyCap",
     expected: "FrequencyCap",
     value: input.frequencyCap
-  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao3(input.frequencyCap, _path + ".frequencyCap", _exceptionable) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (("object" === typeof input.platformPlacementIds && null !== input.platformPlacementIds && false === Array.isArray(input.platformPlacementIds) || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".platformPlacementIds",
     expected: "Partial<Record<string, string>>",
     value: input.platformPlacementIds
-  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ao4(input.platformPlacementIds, _path + ".platformPlacementIds", _exceptionable) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao3 = (input, _path, _exceptionable = true) => ("number" === typeof input.cooldownSeconds || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".cooldownSeconds",
     expected: "number",
     value: input.cooldownSeconds
-  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.maxPerSession || "number" === typeof input.maxPerSession || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".maxPerSession",
     expected: "(number | undefined)",
     value: input.maxPerSession
-  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.minStageInterval || "number" === typeof input.minStageInterval || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".minStageInterval",
     expected: "(number | undefined)",
@@ -8065,46 +9832,46 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     const value = input[key];
     if (void 0 === value)
       return true;
-    return void 0 === value || "string" === typeof value || _assertGuard_18._assertGuard(_exceptionable, {
+    return void 0 === value || "string" === typeof value || _assertGuard_19._assertGuard(_exceptionable, {
       method: "typia.createAssert",
-      path: _path + __typia_transform__accessExpressionAsString4(key),
+      path: _path + __typia_transform__accessExpressionAsString6(key),
       expected: "(string | undefined)",
       value
     }, _errorFactory);
   });
-  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_18._assertGuard(_exceptionable, {
+  const _ao5 = (input, _path, _exceptionable = true) => ("continue" === input.type || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao6 = (input, _path, _exceptionable = true) => ("currency" === input.type || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && _ap0(input, _path, _exceptionable) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".currency",
     expected: "string & MinLength<1>",
     value: input.currency
-  }, _errorFactory)) || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) || _assertGuard_19._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_18._assertGuard(_exceptionable, {
+  const _ao7 = (input, _path, _exceptionable = true) => _ao2(input, _path, _exceptionable) && (("banner" === input.type || "interstitial" === input.type || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".type",
     expected: '("banner" | "interstitial")',
     value: input.type
-  }, _errorFactory)) && ((null !== input.reward || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && ((null !== input.reward || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
     value: input.reward
-  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_18._assertGuard(_exceptionable, {
+  }, _errorFactory)) && (void 0 === input.reward || _assertGuard_19._assertGuard(_exceptionable, {
     method: "typia.createAssert",
     path: _path + ".reward",
     expected: "undefined",
@@ -8116,7 +9883,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("rewarded" === input.type)
       return _ao1(input, _path, _exceptionable);
     else
-      return _assertGuard_18._assertGuard(_exceptionable, {
+      return _assertGuard_19._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae0,
@@ -8129,7 +9896,7 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
     else if ("currency" === input.type)
       return _ao6(input, _path, _exceptionable);
     else
-      return _assertGuard_18._assertGuard(_exceptionable, {
+      return _assertGuard_19._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path,
         expected: _ae2,
@@ -8170,12 +9937,12 @@ var assertAdPlacements = /* @__PURE__ */ (() => {
   return (input, errorFactory) => {
     if (false === __is(input)) {
       _errorFactory = errorFactory;
-      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_18._assertGuard(true, {
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",
         value: input2
-      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_18._assertGuard(true, {
+      }, _errorFactory)) && _ao0(input2, _path + "", true) || _assertGuard_19._assertGuard(true, {
         method: "typia.createAssert",
         path: _path + "",
         expected: "AdPlacements",
@@ -14664,7 +16431,7 @@ function requireString(value, label) {
   return value;
 }
 
-// node_modules/.cache/mpgd-native-build/tools/target/native-command-launcher.js
+// node_modules/.cache/mpgd-native-build/packages/cli/src/command-launcher.js
 function resolveNativeCommandLaunch(input) {
   if ((input.platform ?? process.platform) !== "win32") {
     return { command: input.command, args: input.args };
@@ -14675,13 +16442,17 @@ function resolveNativeCommandLaunch(input) {
   if (input.command !== "pnpm") {
     return { command: input.command, args: input.args };
   }
-  const pnpmScript = input.environment.npm_execpath;
-  if (pnpmScript === void 0 || !/\.[cm]?js$/iu.test(pnpmScript)) {
-    throw new Error("Windows native builds require pnpm exec mpgd so npm_execpath resolves the pnpm JavaScript entrypoint.");
+  const pnpmEntry = input.environment.npm_execpath;
+  const pnpmBase = pnpmEntry?.split(/[\\/]/u).at(-1) ?? "";
+  if (pnpmEntry === void 0 || !/^pnpm(?:\.exe|\.[cm]?js)$/iu.test(pnpmBase)) {
+    throw new Error("Windows builds require pnpm exec mpgd so npm_execpath resolves the pnpm executable or JavaScript entrypoint.");
+  }
+  if (/\.exe$/iu.test(pnpmEntry)) {
+    return { command: pnpmEntry, args: input.args };
   }
   return {
     command: input.nodeExecutable ?? process.execPath,
-    args: [pnpmScript, ...input.args]
+    args: [pnpmEntry, ...input.args]
   };
 }