@maccesar/titools 5.1.1 → 5.2.1

package/skills/ti-admob-unified/references/mediation-parity.md

@@ -0,0 +1,17 @@
+> Source snapshot: official ti.admob.unified 1.0.0 documentation at release source commit `034843299b2984253988e0ffccb9f6a1c91682c9` (copied 2026-10-24). Relative links rebased for this skill.
+
+# Mediation parity
+
+The first release, `1.0.0`, provides five optional dependency modules with identical identifiers on iOS and Android. Install only the networks the application intends to use. The core `ti.admob.unified` contains Google Mobile Ads and UMP only. The complements provide dependencies without a JavaScript API or manual provider initialization.
+
+| Network                   | Module ID                             | iOS adapter  | Android adapter |
+| ------------------------- | ------------------------------------- | ------------ | --------------- |
+| AppLovin                  | `ti.admob.unified.mediation.applovin` | `13.6.4.0` | `13.6.4.2` |
+| Meta Audience Network     | `ti.admob.unified.mediation.meta`     | `6.22.0.0` | `6.22.0.1` |
+| InMobi                    | `ti.admob.unified.mediation.inmobi`   | `11.5.0.0` | `11.5.0.1` |
+| Unity Ads                 | `ti.admob.unified.mediation.unity`    | `4.21.0.0` | `4.21.0.0` |
+| Liftoff Monetize (Vungle) | `ti.admob.unified.mediation.liftoff`  | `7.7.8.0` | `7.7.9.0` |
+
+ironSource mediation is deferred: neither its adapter nor its advertising SDK is distributed. Unity includes UnityCoherenceLib; Unity Ads 4.21.0 no longer requires IronSourceAdQualitySDK.
+
+All requests use the core factories and event contracts. Network selection requires installing the corresponding complement and configuring the source in AdMob. `getMediationStatus()` reports `{ initializationState, adapters }` with all statuses known to Google on both platforms. Entries include native class name, state, description and latency in milliseconds. Initialization and ad delivery require separate verification. See [AdMob mediation](mediation.md).

package/skills/ti-admob-unified/references/mediation.md

@@ -0,0 +1,145 @@
+> Source snapshot: official ti.admob.unified 1.0.0 documentation at release source commit `034843299b2984253988e0ffccb9f6a1c91682c9` (copied 2026-10-24). Relative links rebased for this skill.
+
+# AdMob mediation
+
+The first release, `1.0.0`, provides five optional dependency modules with identical identifiers on iOS and Android. Install only the networks the application intends to use. The core `ti.admob.unified` contains Google Mobile Ads and UMP only. Each complement has no JavaScript API and performs no manual provider initialization.
+
+| Network                   | Module ID                             | iOS adapter | Android adapter |
+| ------------------------- | ------------------------------------- | ----------- | --------------- |
+| AppLovin                  | `ti.admob.unified.mediation.applovin` | `13.6.4.0`  | `13.6.4.2`      |
+| Meta Audience Network     | `ti.admob.unified.mediation.meta`     | `6.22.0.0`  | `6.22.0.1`      |
+| InMobi                    | `ti.admob.unified.mediation.inmobi`   | `11.5.0.0`  | `11.5.0.1`      |
+| Unity Ads                 | `ti.admob.unified.mediation.unity`    | `4.21.0.0`  | `4.21.0.0`      |
+| Liftoff Monetize (Vungle) | `ti.admob.unified.mediation.liftoff`  | `7.7.8.0`   | `7.7.9.0`       |
+
+ironSource mediation is deferred: neither its adapter nor its advertising SDK is distributed. Unity includes UnityCoherenceLib. Unity Ads 4.21.0 no longer depends on IronSourceAdQualitySDK, so it is not distributed.
+
+## Installing one or several networks
+
+Install the core ZIP and each selected complement ZIP for every target platform. One declaration covers both platforms:
+
+```xml
+<modules>
+  <module version="1.0.0">ti.admob.unified</module>
+  <module version="1.0.0">ti.admob.unified.mediation.applovin</module>
+</modules>
+```
+
+For AppLovin and Unity together:
+
+```xml
+<modules>
+  <module version="1.0.0">ti.admob.unified</module>
+  <module version="1.0.0">ti.admob.unified.mediation.applovin</module>
+  <module version="1.0.0">ti.admob.unified.mediation.unity</module>
+</modules>
+```
+
+Use `1.0.0` for the core and complements. Call only `require('ti.admob.unified')` and its factories. To remove a network, remove its declaration and rebuild.
+
+## Installing an adapter is not the same as enabling a network
+
+Installing an adapter adds its SDK to the application and makes it discoverable by Google Mobile Ads. It does not approve a publisher account, configure a mediation group or validate credentials. Leave unneeded complements out of the build. Their exact frameworks, dependencies and versions are recorded in [Dependencies](dependencies.md).
+
+## Publisher setup
+
+For each network that an application will use:
+
+1. Create or connect the publisher account for that network.
+2. Add the network as an ad source in the AdMob mediation group.
+3. Enter the provider credentials and map the provider placement to the AdMob ad unit.
+4. Complete the provider's privacy and store-disclosure requirements.
+5. Validate the integration with test ads and Ad Inspector before enabling production traffic.
+
+Google Mobile Ads can still inspect or initialize every installed adapter during SDK startup. In development, incomplete or conflicting server mappings can produce provider warnings even when Google serves the requested test banner. Examples include a missing AppLovin SDK key and multiple Liftoff Monetize app IDs. The module does not add provider credentials to either native manifest; AdMob supplies those server parameters from the mediation mapping.
+
+Do not silence these messages with placeholder credentials. Complete the provider mapping, use that provider's test mode, and verify it through single-source testing in Ad Inspector. If the application does not intend to use a network, leave it out of the AdMob mediation group.
+
+Google maintains the current setup instructions and format caveats in its [Android mediation network guide](https://developers.google.com/admob/android/choose-networks) and [iOS mediation network guide](https://developers.google.com/admob/ios/choose-networks). Use formats supported by the selected network and adapter version.
+
+Use the provider-specific instructions for account mapping, privacy, SKAdNetwork IDs and test mode. Their current sample dependency versions may be newer than the versions packaged here; use [Dependencies](dependencies.md) for this release's inventory.
+
+| Provider | Android setup | iOS setup |
+| --- | --- | --- |
+| AppLovin | [Guide](https://developers.google.com/admob/android/mediation/applovin) | [Guide](https://developers.google.com/admob/ios/mediation/applovin) |
+| Meta | [Guide](https://developers.google.com/admob/android/mediation/meta) | [Guide](https://developers.google.com/admob/ios/mediation/meta) |
+| InMobi | [Guide](https://developers.google.com/admob/android/mediation/inmobi) | [Guide](https://developers.google.com/admob/ios/mediation/inmobi) |
+| Unity | [Guide](https://developers.google.com/admob/android/mediation/unity) | [Guide](https://developers.google.com/admob/ios/mediation/unity) |
+| Liftoff | [Guide](https://developers.google.com/admob/android/mediation/liftoff-monetize) | [Guide](https://developers.google.com/admob/ios/mediation/liftoff-monetize) |
+
+
+## Missing configuration and startup errors
+
+Only install selected complements when the app will use mediation and its publisher accounts, source mappings and credentials are configured. The examples and the core-only test app do not require these accounts. Do not install the complements merely to run Google demo ads.
+
+An internal Android demo build with several adapters produced these messages. Each points to a different failure; only some identify missing credentials:
+
+| Message                                 | What it establishes                                                                                                                                                | Action                                                                                                                                                   |
+| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AppLovin: `Missing or invalid SDK Key.` | The adapter did not receive a usable SDK key.                                                                                                                      | Verify the publisher SDK key and the AppLovin mapping in AdMob.                                                                                          |
+| AdColony: `Failed to create Adapter.`   | Google could not construct the requested adapter. This does not establish a missing key. AdColony is not one of the five distributed adapters.                     | Inspect the requested ad source/mapping and adapter availability in Ad Inspector. Do not add a legacy SDK or placeholder credentials just to silence it. |
+| Liftoff/Vungle: `Timeout.`              | Initialization did not finish before the SDK timeout. In the observed run, a preceding warning reported conflicting app IDs and selection of `fake-vungle-app-id`. | Check the provider app ID and AdMob mapping; the timeout alone does not prove which configuration value is wrong.                                        |
+
+### Why there is no automatic “missing local key → skip this network” filter
+
+Android runs Google request configuration and startup on a worker thread. Waiting for the completion event can still take up to the SDK timeout when a selected provider does not finish. Keep application navigation usable during this wait.
+
+Each optional module packages dependencies. Google calls the provider initializers. Google Mobile Ads controls adapter initialization and supplies mediation parameters from AdMob. There is no supported pre-initialization API in the Google Mobile Ads APIs used here that lets this module read all publisher mappings and selectively suppress adapters with missing credentials.
+
+A key may be absent from JavaScript or the native manifest and still be configured in AdMob. The [AppLovin adapter guide](https://developers.google.com/admob/android/mediation/applovin) instructs publishers to enter the SDK key in AdMob; its changelog says adapter 12.1.0.0 stopped checking the Android manifest. Google handles readiness checks and provider initialization through its public SDK APIs.
+
+Choose the setup that matches the application:
+
+- For Google ads alone, omit complements and call `Admob.initialize({})`. There are no third-party adapters to initialize.
+- For mediation, include one `tiapp.xml` entry per selected network, configure its account and AdMob mappings, and call `Admob.initialize({})`. Google discovers the installed adapters without an `enableMediation` flag or manual provider initializer. Check native initialization results and Ad Inspector; `getMediationStatus()` reports the adapter initialization states known to Google.
+
+For a session that deliberately skips initialization of installed adapters, see the [initialization reference](api-reference.md#automatic-adapter-discovery). That exception is global and does not validate credentials or filter individual networks.
+
+## Portable diagnostics
+
+`getMediationStatus()` belongs to the core and returns `{ initializationState, adapters }`. It includes every adapter Google reports, including Google, sorted by native class name. Entries contain `adapterClass`, `state`, `description` and numeric `latencyMs`; native class names may differ across platforms.
+
+```js
+const Admob = require('ti.admob.unified')
+Admob.addEventListener('module_initialized', event => {
+  const diagnostic = Admob.getMediationStatus()
+  Ti.API.info(diagnostic.initializationState)
+  diagnostic.adapters.forEach(adapter => {
+    Ti.API.info(`${adapter.adapterClass}: ${adapter.state} (${adapter.latencyMs} ms) ${adapter.description}`)
+  })
+})
+```
+
+Before `initialize()`, the result is `not_started` with no adapters. During startup it is `initializing` and Google's map may be partial or empty. `completed` means the core callback finished, even when an adapter is `not_ready`; an initialization exception reports `failed`. The query does not initialize SDKs or request ads. Neither absence from this map nor `ready` establishes installed-module inventory, valid accounts, credentials or ad delivery. See the [complete contract](api-reference.md#mediation-diagnostics).
+
+New providers need no core registration. Follow [Adding a network](contributing.md#adding-a-network) to package an existing official adapter.
+
+After initialization on a registered test device, inspect actual requests:
+
+```js
+Admob.addEventListener('ad_inspector_closed', event => {
+  Ti.API.info(JSON.stringify(event))
+})
+Admob.openAdInspector()
+```
+
+## Privacy and bundled resources
+
+Continue using UMP and `canRequestAds()` before requests. Each selected iOS complement includes its vendor resources and privacy manifests. Review the current Google/provider guidance for SKAdNetwork entries, privacy disclosures and consent propagation for the networks the application distributes. Android resolves the Maven dependencies declared by each selected complement, including the explicitly declared Unity SDK.
+
+The public example and the test demo use only the core, with no mediation flag. No provider credentials are required to run Google demo ads. Adding a selected complement to `tiapp.xml` makes its adapter discoverable at SDK startup; configure the provider account and AdMob mapping before using that network. Automatic discovery does not validate credentials or eliminate initialization timeouts.
+
+## Release validation
+
+Build all discovered modules (two ZIPs per module) and inspect their framework inventories and generated POMs. Compile isolated consumer applications on both platforms with core only, each of the five complements individually, AppLovin + Unity, and all five together. Check that no framework is duplicated and that resolved dependency versions remain pinned.
+
+Record separately:
+
+- Integration and linking: the build succeeds, expected adapter classes are visible, and official Google test ads load.
+- Provider ad delivery: the provider returns its own test ad with valid publisher accounts and AdMob mappings, confirmed by single-source testing in Ad Inspector.
+
+Google test ads do not prove provider delivery. iOS simulator results do not substitute for device results. Re-run device validation when hardware is available. Do not use or click production ads during development.
+
+## Unity consent with the pinned adapter
+
+The distribution uses Unity adapter `4.21.0.0` on both platforms. It includes the automatic forwarding of `IABTCF_AddtlConsent` introduced in `4.19.0.1` on [Android](https://developers.google.com/admob/android/mediation/unity) and [iOS](https://developers.google.com/admob/ios/mediation/unity). Configure Unity as a consent partner and verify signal propagation with the provider before enabling demand. Adapter presence and a Google test ad do not establish provider consent or delivery.

package/skills/ti-admob-unified/references/migration.md

@@ -0,0 +1,259 @@
+> Source snapshot: official ti.admob.unified 1.0.0 documentation at release source commit `034843299b2984253988e0ffccb9f6a1c91682c9` (copied 2026-10-24). Relative links rebased for this skill.
+
+# Migrating to ti.admob.unified
+
+This guide covers adopting the first release, `1.0.0`, from a platform-specific AdMob module or an internal development build. There are no previously published versions of this module.
+
+## Selecting mediation dependencies
+
+Install only the core for Google ads. If the application mediates, install a complement for each selected network. For example:
+
+```xml
+<modules>
+  <module version="1.0.0">ti.admob.unified</module>
+  <module version="1.0.0">ti.admob.unified.mediation.applovin</module>
+</modules>
+```
+
+The aggregate development package is not part of this release. Replace its declaration with the desired per-network modules. `getMediationStatus()` now reports Google initialization states through `{ initializationState, adapters }`; it does not validate mappings or delivery. ironSource mediation is deferred. See [AdMob mediation](mediation.md).
+
+## If you used an internal pre-release build
+
+Internal ZIPs exposed API differences that never reached a published release. Update code that depends on them as follows.
+
+### Generic mediation diagnostics
+
+Replace reads of the old six-Boolean map (for example `status.appLovin`) with iteration over `Admob.getMediationStatus().adapters` after `module_initialized`. Use `initializationState` for the core process and each entry's `state` for Google's adapter report. There is no portable provider-key mapping: native class names differ between iOS and Android. Before startup the array is empty; during startup it may be partial. A `ready` entry does not prove account configuration or ad delivery.
+
+Remove calls to `isAppLovinAvailable`, `isMetaAvailable`, `isInMobiAvailable`, `isVungleAvailable`, `isUnityAvailable`, `isIronSourceAvailable` and `enableOptionalMediationNetworks`. Also remove `setAppLovinGDPRConsent`, `setInMobiGDPRConsent` and `setVungleGDPRConsent`; those pre-release setters only logged warnings. Continue using UMP and each provider's documented consent requirements. `disableMediation` and the `module_initialized` payload are unchanged.
+
+### There is no `COLLAPSIBLE_TOP` or `COLLAPSIBLE_BOTTOM`
+
+Neither constant is exported. Reading it returns `undefined`; passing `Admob.COLLAPSIBLE_TOP` therefore sends `undefined` to the native layer.
+
+They used to hold `"collapsible_top"` and `"collapsible_bottom"`. Google's SDK accepts only `"top"` and `"bottom"`, and the module forwarded the value unchanged, so every request built from those constants was invalid.
+
+The `collapsible` property itself is unchanged and now works on both platforms. It takes Google's native string:
+
+```js
+const banner = Admob.createAdaptiveBanner({
+  adUnitId: Admob.TEST_ADAPTIVE_BANNER,
+  collapsible: 'bottom'
+})
+```
+
+### `smart_banner` no longer produces a full-width banner on iOS
+
+Google removed the size on Android and deprecated it on iOS. Internal builds selected a fixed 320×50 banner on Android and a full-width strip on iOS. The value now falls back to `BANNER` on both platforms, like any other unrecognised size.
+
+Android behaviour is unaffected. On iOS, a placement that relied on `adSize: 'smart_banner'` for a full-width strip now renders a 320×50 banner.
+
+The replacement is `customAdSize`, which both platforms accept:
+
+```js
+function screenWidthInDp() {
+  const caps = Ti.Platform.displayCaps
+
+  if (Ti.Platform.osname === 'android') {
+    return Math.round(caps.platformWidth / caps.logicalDensityFactor)
+  }
+
+  return Math.round(caps.platformWidth)
+}
+
+const banner = Admob.createBanner({
+  adUnitId: Admob.TEST_BANNER,
+  customAdSize: { width: screenWidthInDp(), height: 50 },
+  width: Ti.UI.FILL
+})
+```
+
+`createAdaptiveBanner()` is the other option when Google should choose the height. See [Standard banner properties](banners.md#creation-properties-1).
+
+### Legacy privacy methods no longer gate ads
+
+`canShowPersonalizedAds()` always returns `false` and `canShowAds()` is an alias of `canRequestAds()`. Code that branched on either one has to move to the single gate described below.
+
+## Module declaration
+
+Replace platform-specific or older AdMob modules with one declaration:
+
+```xml
+<modules>
+  <module version="1.0.0">ti.admob.unified</module>
+</modules>
+```
+
+Add the selected network complements only if the application mediates; for example, `<module version="1.0.0">ti.admob.unified.mediation.applovin</module>` for AppLovin.
+
+Update JavaScript imports:
+
+```js
+const Admob = require('ti.admob.unified')
+```
+
+Install both local artifacts when the app targets iOS and Android.
+
+## Move the application ID to `tiapp.xml`
+
+Remove `applicationId` from JavaScript initialization. Configure `GADApplicationIdentifier` on iOS and `com.google.android.gms.ads.APPLICATION_ID` on Android as described in [Getting started](getting-started.md).
+
+## Replace privacy gates
+
+Before:
+
+```js
+if (Admob.canShowPersonalizedAds() || !Admob.isGDPR()) {
+  loadAds()
+}
+```
+
+After:
+
+```js
+if (Admob.canRequestAds()) {
+  loadAds()
+}
+```
+
+Do not consume:
+
+- `canShowPersonalizedAds()`
+- `isGDPR()`
+- `canShowAds()`
+- `consent_ready`
+- `consent_error`
+- legacy payload aliases such as `isPrivacyOptionsRequired`
+
+Use `consent_complete`, `canRequestAds`, and `privacyOptionsRequired`.
+
+## Replace callback-style consent code
+
+The supported contract is event-based:
+
+```js
+Admob.addEventListener('consent_complete', onConsentComplete)
+Admob.requestConsent({})
+```
+
+Callback properties passed inside the config object are not invoked.
+
+## Request UMP before initialization
+
+The recommended order is:
+
+```text
+UMP -> canRequestAds -> initialize -> load ads
+```
+
+Use that same sequence on both platforms. Do not initialize before UMP has updated the current session.
+
+App Tracking Transparency is optional and sits outside this sequence. If your application has its own tracking case, resolve it before `initialize()`; it is not an ad-request gate, and `canRequestAds()` remains the only one. The call is portable: iOS resolves ATT, and Android emits `tracking_authorization_completed` immediately with `applicable: false`.
+
+## Adopt adaptive banner sizing
+
+Replace fixed full-width or smart-banner assumptions:
+
+```js
+const banner = Admob.createAdaptiveBanner({
+  adUnitId: Admob.TEST_ADAPTIVE_BANNER,
+  adaptiveType: Admob.ADAPTIVE_ANCHORED,
+  width: Ti.UI.FILL
+})
+```
+
+On `loaded`, use `event.height` with `event.heightUnit`. Update both the banner host and the adjacent content inset. Collapse both on error and destruction.
+
+Do not keep a fixed `50`, `90`, or device-specific height.
+
+`ADAPTIVE_INLINE` and `maxHeight` work on iOS too. An application that branched on `Ti.Platform.osname` to keep inline banners off iOS can drop the branch.
+
+## Adopt the banner lifecycle
+
+Both standard and adaptive banners support:
+
+```js
+banner.load()
+banner.pause()
+banner.resume()
+banner.isLoaded()
+banner.destroy()
+```
+
+`destroy()` is terminal and idempotent. Remove JavaScript event listeners and the proxy from its parent when the owning placement closes.
+
+The module pauses banners when the Android activity pauses or the iOS application enters the background. Remove any application code that duplicates those handlers. Keep calls for navigation changes the module cannot observe, such as hiding a tab or covering a window. See [Who pauses a banner](banners.md#who-pauses-a-banner).
+
+Do not carry forward code that changes `visible`, opacity, height, or the banner host during pause/resume. TiAdMobUnified preserves the same visual slot and creative; navigation owns only the application pause cause.
+
+Replace both historical aliases when practical:
+
+```js
+banner.destroyAdViewAndCancelRequest()
+banner.destoyAdViewAndCancelRequest()
+```
+
+with:
+
+```js
+banner.destroy()
+```
+
+## Remove manual refresh timers
+
+Delete `setTimeout`/`setInterval` banner renewal loops. Configure refresh in AdMob and let the native SDK own it.
+
+The application issues the initial `load()`. Google Mobile Ads manages later refresh requests; TiAdMobUnified manages lifecycle.
+
+## Adopt the fullscreen lifecycle
+
+Interstitial, rewarded, rewarded interstitial, and app open proxies share the same methods and event payloads on iOS and Android:
+
+```js
+fullscreen.load()
+fullscreen.show()
+fullscreen.isLoaded()
+fullscreen.destroy()
+```
+
+Calls to `load()` while a request, loaded ad, or presentation is active are ignored. Each native fullscreen ad is single-use. `destroy()` is terminal and idempotent, and emits `destroyed` once.
+
+Common events include `adUnitId` and `adType`; failures add `error`, `message`, and `code`. Both platforms emit `opened` and `showed_fullscreen_content`. Rewarded value must be granted only from the `rewarded` event.
+
+### App open
+
+`createAppOpen()` returns a dedicated proxy on both platforms. Use this shared factory and the fullscreen lifecycle for app open placements.
+
+It follows the fullscreen contract above, with one addition: an app open ad expires four hours after loading completes. Past that point `isLoaded()` reports `false` and `show()` emits `failed_to_show` with code `1`. See [The four hour window](fullscreen.md#the-four-hour-window).
+
+## Mediation
+
+Five optional complements carry AppLovin, Meta, InMobi, Unity and Liftoff dependencies on both platforms. Google Mobile Ads discovers their adapters; applications keep calling the core factories. ironSource mediation is deferred.
+
+The provider availability probes and legacy consent setters from internal builds have been removed from `ti.admob.unified`. Use `getMediationStatus()` for Google-reported initialization diagnostics, then verify the packaged dependencies separately. Follow UMP and each provider's current consent requirements. Configure accounts, mappings and credentials in AdMob, then validate delivery with Ad Inspector.
+
+An application that serves AdMob demand only leaves the complements out and uses `Admob.initialize({})`, with no disabling flag. Including selected complements opts into automatic adapter discovery; no `enableMediation` flag is needed. An exceptional session that skips installed adapters is covered in the [initialization reference](api-reference.md#automatic-adapter-discovery).
+
+## Development checklist
+
+- Use the module's `TEST_*` constants.
+- Keep production IDs disabled until physical validation is complete.
+- Test consent accepted, rejected, not required, and previous-session states.
+- Test ATT authorized, denied, and previously resolved on iOS.
+- Test banner load, error collapse, rotation, background/resume, and repeated window close.
+- Test interstitial, rewarded, rewarded interstitial, and app open duplicate loads, show failures, close, reward delivery, and repeated destruction.
+- Confirm no duplicate banners or retained listeners.
+- Inspect requests with Ad Inspector.
+- Inspect `getMediationStatus()` after `module_initialized`, and verify installed complements separately through package inventories and Ad Inspector.
+- Run `npm test` and `./scripts/verify-artifacts.sh`.
+
+
+## Corrections from internal audit builds
+
+Boolean results and payload fields use JavaScript Booleans on both platforms; replace comparisons to numeric `0` or `1`. iOS load errors now use the shared error constants; presentation, UMP and Inspector codes remain domain-specific. Use the event name and the reference's error table when migrating code that compared raw NSError values.
+
+Application volume now works on iOS using the same percentage string accepted on Android. Fullscreen configuration properties are mutable for subsequent loads on both platforms. Native helper/delegate methods and internal state from earlier iOS builds are no longer exposed as application APIs. The current generic diagnostic reports only the adapters known to Google; it does not return the old per-provider Boolean availability map.
+
+## Earlier core-only startup settings
+
+If an existing startup block passes `disableMediation: true`, remove that exception before using optional mediation complements. Google then initializes the adapters selected in tiapp.xml. Core-only apps need no mediation switch. Changing this option requires a new app session because the first initialization configuration wins.

package/skills/ti-admob-unified/references/module-changelog.md

@@ -0,0 +1,84 @@
+> Source snapshot: official ti.admob.unified 1.0.0 documentation at release source commit `034843299b2984253988e0ffccb9f6a1c91682c9` (copied 2026-10-24). Relative links rebased for this skill.
+
+# Changelog
+
+## [1.0.0] - 2026-10-24
+
+- Add a bounded iPad layout workaround for a collapsed Google Interstitial SVG. Eligibility follows the zero-width column-flex markup for both demo and publisher-owned units. It preserves proportions and stops with the presentation lifecycle. Production creative coverage remains unverified; see the fullscreen guide for its limits.
+
+- Preserve ready fullscreen preloads across Android client-area changes after dismissal by comparing stable outer window bounds; retain invalidation for rotation and window resizing.
+
+- Keep the example's session status panel fixed above the scrolling content, reserving its measured height and preserving the banner's separate space.
+
+- Keep an explicit fullscreen Show/Retry request pending through loading or size replacement in the example, then present without a second tap. Cancel pending presentation when its foreground, privacy or window context ends.
+
+- Add visible ATT status/query/request controls to the example, with current-state refresh after returning from Settings, visible feedback for repeated checks, an explanation for resolved permissions and explicit Android applicability.
+
+- Explain AdMob’s rewarded interstitial introduction requirements in the demo card, with an official policy link. Show opens a reward introduction with Watch test ad and Skip; Skip cancels that presentation. After Watch, a needed reload completes and presents without another Show tap. Clarify ATT configuration when AdMob UMP presents the IDFA message.
+
+- Add `getTrackingAuthorizationStatus()` on iOS and Android for a current ATT snapshot without prompting or starting ads. Clarify ATT startup order, localization and store disclosures.
+
+- Added `createRewardedInterstitial()` on iOS and Android, with shared fullscreen events, SDK-earned rewards, terminal cleanup and a matching integration-library manager. The demo introduces the reward and allows skipping before presentation.
+
+First public release. Earlier development snapshots were not published releases.
+
+### Integration and reliability
+
+- Normalize iOS load errors to the shared constants and return actual Booleans through the bridge.
+- Implement percentage-based application volume on iOS and validate the same range on Android.
+- Hide accidental iOS state/helper exports while preserving native delegates and lifecycle callbacks.
+- Expose fullscreen configuration properties on Android and retain primitive extras; defer banner reconfiguration to its next load.
+- Allow consent retries after failures, refresh cached results after privacy options, and serialize reset with outstanding UMP work.
+- Read Android's standard IAB preferences and restrict mediation availability to installed adapters.
+- Capture the presented rewarded ad's reward independently of dismissal/reload; serialize fullscreen SDK operations on the UI thread.
+- Remove targeting values and test-device IDs from module-owned debug messages.
+- Fix library callback reentrancy, share concurrent privacy/Inspector operations, and wait for iOS adaptive layout.
+- Keep banner-button feedback in the button with light-green styling; reuse the current banner on reload without collapsing its slot.
+- Keep ads and listeners through an Android light/dark switch: the example and the cleanup guide ignore the `close` event Titanium fires while it recreates the activity.
+- Check fullscreen request dimensions at Show in the library and playground; reload only the selected stale ad, without rotation listeners or timers.
+- Accept iOS UMP UUID test identifiers and support per-platform consent test defaults in the example application's properties.
+
+
+### Documentation
+
+- Add production integration guidance for archive installation, Alloy/Classic imports, privacy, store disclosures, app verification and troubleshooting.
+- Separate fullscreen load and show examples, make the optional ATT startup path explicit, and reconcile consent retries, banner reconfiguration and app-open expiry documentation with both native implementations.
+- Document API limits and preserve known iOS runtime issues in release readiness.
+- Include README screenshots in offline release archives and verify their packaged contents.
+
+### Dependency refresh
+
+- Include Unity Ads SDK 4.21.0 explicitly on Android; the adapter POM does not supply it.
+- Update UnityCoherenceLib to 0.2.0 with Unity Ads 4.21.0.
+- Retain Meta SDK 6.22.0 and InMobi Android SDK 11.5.0 as required by their latest published adapters, despite newer standalone SDKs.
+
+- Update Google Mobile Ads to iOS 13.11.0 and Android 25.5.0; UMP remains at iOS 3.1.0 and Android 4.0.0.
+- Refresh InMobi, Unity and Liftoff to the compatible published versions checked October 23, 2026; AppLovin and Meta adapters remain current. See [Dependencies](dependencies.md).
+- Remove IronSourceAdQualitySDK from Unity: Unity Ads 4.21.0 no longer depends on it.
+- Require Titanium SDK 13.4.1.GA for the core and every optional complement, matching the build toolchain and Android compile SDK 36.
+- Pin Guava 33.7.2-android in the core plus OkHttp 5.4.0 and Okio 3.18.2 in InMobi/Liftoff/Unity to replace the Guava, OkHttp and Okio versions flagged in the security review.
+- Retain the version contract test: Meta now matches across platforms; Liftoff retains the documented SDK difference.
+
+### Unified core
+
+- Run Android SDK configuration and initialization off the UI thread; preserve idempotency and deliver success/failure on the UI thread.
+
+- One iOS/Android JavaScript API for standard/adaptive banners, interstitials, rewarded ads, rewarded interstitials and app open ads.
+- Consent-first UMP flow, portable ATT completion and Ad Inspector support.
+- Idempotent initialization, serialized loads and deterministic cleanup.
+- Google Mobile Ads and UMP only; no third-party network adapters in the core.
+- The examples use only the core without a mediation flag. Google Mobile Ads automatically discovers adapters supplied by selected complements; `disableMediation: true` remains an explicit session exception.
+
+### Optional mediation
+
+- Five independent dependency modules: `ti.admob.unified.mediation.applovin`, `.meta`, `.inmobi`, `.unity` and `.liftoff`, each on Android and iOS at `1.0.0`.
+- Each Android complement declares its adapter Maven coordinate, any required explicit SDK dependency, and documented utility overrides. Each iOS complement vendors only its own adapter, SDK and required resources/dependencies.
+- Unity includes UnityAdapter, UnityAds and UnityCoherenceLib. Its updated SDK no longer requires IronSourceAdQualitySDK.
+- ironSource mediation is deferred; IronSourceAdapter and IronSource are not distributed.
+- SDKs and adapters were updated to the compatible October 23, 2026 versions; framework checksums were regenerated. See [Dependencies](dependencies.md).
+- `getMediationStatus()` returns generic Google initialization diagnostics; pre-release provider probes and no-op consent setters were removed. `disableMediation` remains a global startup control.
+- Release artifacts are discovered from complement folders and manifests; packaged dependencies are checked against literal Gradle declarations without a provider list. Nothing is published or tagged by the build scripts.
+
+### Validation
+
+Packaging/linking and Google test-ad loading are separate from third-party ad delivery. Provider delivery requires configured accounts, mappings and Ad Inspector evidence; it is not established by a successful build or a Google test ad. See [release validation](mediation.md#release-validation).

package/skills/ti-admob-unified/references/module-license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 César Estrada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.