@maccesar/titools 5.2.0 → 5.2.2

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

@@ -1,4 +1,4 @@
-> Source snapshot: official ti.admob.unified 1.0.0 documentation at commit `5b4cbf9` (copied 2026-10-11). Relative links rebased for this skill.
+> 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.
 
 # Copy-ready JavaScript library
 
@@ -7,13 +7,15 @@ The integration library is [`example/lib/ads.js`](../assets/example/lib/ads.js).
 - Alloy: `app/lib/ads.js`
 - Classic Titanium: `Resources/lib/ads.js`
 
-Then import it with:
+Import it from an Alloy controller with `require('ads')`, or from Classic Titanium with `require('lib/ads')`:
 
 ```js
 const Admob = require('ti.admob.unified')
-const ads = require('lib/ads')
+const ads = require('lib/ads') // Classic; Alloy: require('ads')
 ```
 
+Alloy copies `app/lib/ads.js` to the generated Resources root. Keep that import distinction when adapting the Classic examples.
+
 The library handles UMP sequencing, the `canRequestAds()` check, initialization, named-listener cleanup, banner slots, deferred loads, privacy-option reauthorization and terminal cleanup. You can also use the native module directly, as [`example/app.js`](../assets/example/app.js) does while sharing the library’s fullscreen size guard.
 
 ## What it covers
@@ -24,9 +26,10 @@ The library handles UMP sequencing, the `canRequestAds()` check, initialization,
 | Adaptive banner | `createAdaptiveBanner()` | `pause()`, `resume()`, `retry()`, `rebuild()`, `isLoaded()`, `destroy()` |
 | Interstitial    | `createInterstitial()`   | `load()`, `show()`, `retry()`, `isLoaded()`, `destroy()`                 |
 | Rewarded        | `createRewarded()`       | `load()`, `show()`, `retry()`, `isLoaded()`, `destroy()`                 |
+| Rewarded interstitial | `createRewardedInterstitial()` | `load()`, `show()`, `retry()`, `isLoaded()`, `destroy()` |
 | App open        | `createAppOpen()`        | `load()`, `show()`, `retry()`, `isLoaded()`, `destroy()`                 |
 
-Rewarded interstitial and native ads are not included because version `1.0.0` does not implement those factories.
+Native ads have no factory in version `1.0.0`. For rewarded interstitials, show an introduction with a skip option before calling the manager's `show()`; see [Rewarded interstitial ads](rewarded-interstitial.md).
 
 ## Start once
 
@@ -44,10 +47,16 @@ ads.start({
   if (!result.initialized) {
     Ti.API.warn('Ads are unavailable for this session')
   }
+}).catch(error => {
+  Ti.API.warn(`Ads startup failed: ${error.message || error}`)
 })
 ```
 
-Set `requestTrackingAuthorization: true` only when the application has a real ATT use case and a valid `NSUserTrackingUsageDescription`. ATT is not another ad-request gate.
+Set `requestTrackingAuthorization: true` only when the application has a real ATT use case and a valid `NSUserTrackingUsageDescription`. This option controls only the library's explicit ATT request. An IDFA message configured in AdMob may let UMP present ATT during the consent step even when this option is false. When UMP handles ATT, leave the option false and retain the required description/translations. The startup result's `tracking` value describes the explicit request only; query `Admob.getTrackingAuthorizationStatus()` for current system state. ATT is not another ad-request gate. Call `start()` from the active foreground after other prompts have closed. If an iOS interruption occurs during UMP, the library waits for `Ti.App.resumed` before requesting ATT, then removes its temporary lifecycle listeners. It does not coordinate unrelated prompts opened by application code.
+
+Use `Admob.getTrackingAuthorizationStatus()` to inspect ATT without prompting, including after a return from Settings. The same method works in Classic and Alloy. Android reports `applicable: false`; its `authorized: true` convention does not grant general tracking permission.
+
+`start()` caches its promise for the JavaScript session, including an unavailable result. Repeating it does not retry a failed consent update or initialization. If the app needs a recoverable startup retry UI, use the [raw event-based flow](privacy.md#requestconsentconfig), which supports consent retries; do not call `resetConsent()` in production. Native invocation exceptions are converted into failure results by the library; inspect `result.initialized` and the result events. Catch errors in application promise callbacks as well.
 
 ## Banners
 
@@ -80,13 +89,29 @@ child.addEventListener('close', () => {
 
 Do not mirror `Ti.App` background and foreground events. The native module already owns activity/application lifecycle as an independent pause cause.
 
-The library creates no refresh timer. The first request comes from `load()`; later banner refreshes belong to Google Mobile Ads and the refresh policy configured for that ad unit in AdMob. A banner that is not actually on screen is ineligible for Android auto-refresh. On iOS the module disables and restores native autoload while paused.
+The library creates no refresh timer. Banner managers start their first request automatically when the gate and layout are ready; there is no public banner-manager `load()` method. Later banner refreshes belong to Google Mobile Ads and the refresh policy configured for that ad unit in AdMob. A banner that is not actually on screen is ineligible for Android auto-refresh. On iOS the module disables and restores native autoload while paused.
 
 Use `retry()` after a recoverable failure. Use `rebuild()` when the placement configuration changes, such as its width or orientation. Tab focus, window focus, appearance changes and ordinary background/foreground transitions do not require a rebuild.
 
+### Banner manager options
+
+Alongside the native banner properties, the library accepts:
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `host` | Required | Permanent Titanium container for the banner. |
+| `content` | Omitted | Adjacent composite-layout view whose bottom inset follows the slot. |
+| `reservedHeight` | Required | Positive initial reservation in dp. |
+| `paused` | `false` | Defer the first request until `resume()`. |
+| `collapseOnFailure` | `true` | Set to `false` to preserve the slot on a load failure. |
+| `onLoaded`, `onFailedToLoad`, `onDestroyed` | Omitted | Placement lifecycle callbacks receiving the event. |
+| `onClicked`, `onImpression`, `onOpened`, `onClosed` | Omitted | Forwarded native event callbacks. |
+
+Keep the options object stable. Managers do not expose the raw proxy's mutable properties; use a new manager when changing configuration. `rebuild()` recreates the proxy from the manager's existing options, and `retry()` does the same for a failed placement. `destroy()` removes the placement and collapses its slot.
+
 ## Fullscreen ads
 
-Create once, load early, and show only at a moment chosen by the application:
+Create the placement once. Load before the intended break and show it when the application reaches that break:
 
 ```js
 const interstitial = ads.createInterstitial({
@@ -128,12 +153,18 @@ function onApplicationResumed() {
 }
 ```
 
-Pass the owning `window` to each fullscreen factory (otherwise the library reads `Ti.UI.currentWindow`). The library remembers its dimensions when requesting the ad. Rotation alone makes no requests. At `show()`, a changed size discards and reloads only that ad and returns `false`; wait for `onLoaded` and a later user action to show it. Banners are not rebuilt by this check.
+Pass the owning `window` to each fullscreen factory (otherwise the library reads `Ti.UI.currentWindow`). The library records that window's dimensions when requesting the ad. Rotation alone makes no requests. At `show()`, a changed size discards and reloads only that ad and returns `false`; wait for `onLoaded` and a later user action to show it. Banners are not rebuilt by this check.
 
-The raw-API playground shares this logic through `createFullscreenSizeGuard(getSize)`: call `recordLoad()` before requesting, then `show(present, reload)` when the user requests presentation. This helper does not initialize the SDK or run consent.
+The raw-API playground shares this logic through `createFullscreenSizeGuard(getSize)`: call `recordLoad()` before requesting, then `show(present, reload)` when the user requests presentation. The callback can return the window itself (preferred) or a measured `{ width, height }` size. For a window, the guard compares valid outer `rect` bounds and falls back to `size` before layout. Transient Android client-area changes after dismissing an ad therefore keep a ready preload, while rotation and window resizing still invalidate it. This helper does not initialize the SDK or run consent. The playground adds a pending user request around this check so its Show button can wait for a replacement and present it without another tap. The manager API itself keeps the immediate Boolean return contract above; it does not queue a later presentation after returning `false`.
 
 `show()` returns `false` when no valid ad is ready. Do not delay navigation or user work waiting for a fullscreen request.
 
+### Fullscreen manager options and return values
+
+Pass the native creation properties plus `window` and optionally `autoLoad: true` to request the first ad automatically after startup. Otherwise call `load()`. `autoReload: true` requests another ad after close only. Managers forward `onLoaded`, `onFailedToLoad`, `onOpened`, `onShowed`, `onClosed`, `onClicked`, `onImpression`, `onFailedToShow`, `onDestroyed` and, for rewarded, `onRewarded`.
+
+`load()` and `retry()` report whether the manager accepted the call, not whether an ad arrived. `show()` reports whether presentation was attempted; native presentation may still fail and emit `onFailedToShow`. `isLoaded()` checks native readiness. These Boolean manager results differ from the raw proxy's `void` `load()` / `show()` methods.
+
 ## Privacy and diagnostics
 
 Expose the privacy entry point only when required:
@@ -184,6 +215,6 @@ See [`example/library-usage.js`](../assets/example/library-usage.js) for a compl
 
 ## Concurrent operations and cleanup
 
-Concurrent calls to `showPrivacyOptions()` share one native presentation and one promise. `openAdInspector()` does the same for Inspector. Terminal events and synchronous native exceptions remove their listeners; a later call starts a new operation. `destroyAll()` releases placements only. It does not cancel an SDK form or its pending promise.
+Concurrent calls to `showPrivacyOptions()` share one native presentation and one promise. `openAdInspector()` does the same for Inspector. Terminal events and synchronous native exceptions clear the operation's listeners. A later call starts a new operation. `destroyAll()` releases placements only. It does not cancel an SDK form or its pending promise.
 
 A banner failure or destruction cleans up the old proxy before invoking application callbacks, so calling `retry()` from those callbacks preserves the replacement. On iOS, adaptive placements reserve the native anchored height when width is known and wait for positive layout before loading. Destroying a placement removes any pending layout listener.

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

@@ -1,4 +1,4 @@
-> Source snapshot: official ti.admob.unified 1.0.0 documentation at commit `5b4cbf9` (copied 2026-10-11). Relative links rebased for this skill.
+> 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
 
@@ -8,11 +8,11 @@ The first release, `1.0.0`, provides five optional dependency modules with ident
 | ------------------------- | ------------------------------------- | ----------- | --------------- |
 | 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.4.1.0`  | `11.4.1.2`      |
-| Unity Ads                 | `ti.admob.unified.mediation.unity`    | `4.20.1.0`  | `4.20.1.0`      |
-| Liftoff Monetize (Vungle) | `ti.admob.unified.mediation.liftoff`  | `7.7.7.0`   | `7.7.8.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.20.1 no longer depends on IronSourceAdQualitySDK, so it is not distributed.
+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
 
@@ -57,6 +57,17 @@ Do not silence these messages with placeholder credentials. Complete the provide
 
 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.
@@ -71,9 +82,11 @@ An internal Android demo build with several adapters produced these messages. Ea
 
 ### Why there is no automatic “missing local key → skip this network” filter
 
-Each optional module only packages dependencies; it does not call each provider's initializer. 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.
+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. The module leaves readiness checks and provider initialization to Google, without using private SDK internals.
+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:
 
@@ -112,7 +125,7 @@ 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 each selected adapter's SDK transitively through its POM.
+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.
 
@@ -129,4 +142,4 @@ Google test ads do not prove provider delivery. iOS simulator results do not sub
 
 ## Unity consent with the pinned adapter
 
-The distribution uses Unity adapter `4.20.1.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.
+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

@@ -1,4 +1,4 @@
-> Source snapshot: official ti.admob.unified 1.0.0 documentation at commit `5b4cbf9` (copied 2026-10-11). Relative links rebased for this skill.
+> 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
 
@@ -207,7 +207,7 @@ The application issues the initial `load()`. Google Mobile Ads manages later ref
 
 ## Adopt the fullscreen lifecycle
 
-Interstitial, rewarded, and app open proxies share the same methods and event payloads on iOS and Android:
+Interstitial, rewarded, rewarded interstitial, and app open proxies share the same methods and event payloads on iOS and Android:
 
 ```js
 fullscreen.load()
@@ -222,15 +222,15 @@ Common events include `adUnitId` and `adType`; failures add `error`, `message`,
 
 ### App open
 
-`createAppOpen()` returns a proxy on both platforms. Of the modules it replaces, `ti.admob` documents the iOS type without a factory, and `ti.android.admob` supplies an Android-only proxy. Applications previously had to implement the missing iOS support themselves.
+`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 the request. 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).
+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.
 
-Availability probes remain in `ti.admob.unified` for portable diagnostics, and report `false` for every network when no complements are installed. Legacy provider consent setters are deprecated no-ops because UMP and each provider's current requirements must drive privacy configuration. Installing an adapter does not create an account or enable a mediation source: configure mappings and credentials in AdMob, then validate with Ad Inspector.
+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).
 
@@ -241,7 +241,7 @@ An application that serves AdMob demand only leaves the complements out and uses
 - 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, and app open duplicate loads, show failures, close, reward delivery, and repeated destruction.
+- 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.
@@ -252,4 +252,8 @@ An application that serves AdMob demand only leaves the complements out and uses
 
 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. Availability diagnostics require the adapter class, so a network SDK installed without its adapter reports `false`.
+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

@@ -1,10 +1,28 @@
-> Source snapshot: official ti.admob.unified 1.0.0 documentation at commit `5b4cbf9` (copied 2026-10-11). Relative links rebased for this skill.
+> 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] — Unreleased
+## [1.0.0] - 2026-10-24
 
-### Audit corrections
+- 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.
@@ -21,19 +39,31 @@
 - Accept iOS UMP UUID test identifiers and support per-platform consent test defaults in the example application's properties.
 
 
-First public release. Earlier development snapshots were not published releases.
+### 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
 
-- Update Google Mobile Ads to iOS 13.10.0 and Android 25.5.0; UMP remains at iOS 3.1.0 and Android 4.0.0.
-- Update all five adapters to the September 23, 2026 published versions listed in [Dependencies](dependencies.md).
-- Remove IronSourceAdQualitySDK from Unity: Unity Ads 4.20.1 no longer depends on it.
-- Pin Guava 33.7.1-android in the core and OkHttp 4.12.0 in InMobi/Liftoff to replace the Guava, OkHttp and Okio versions flagged in the security review.
+- 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
 
-- One iOS/Android JavaScript API for standard/adaptive banners, interstitials, rewarded ads and app open ads.
+- 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.
@@ -42,10 +72,10 @@ First public release. Earlier development snapshots were not published releases.
 ### 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 only its adapter Maven coordinate. Each iOS complement vendors only its own adapter, SDK and required resources/dependencies.
+- 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 published September 23, 2026 versions; framework checksums were regenerated. See [Dependencies](dependencies.md).
+- 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.
 

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

@@ -1,4 +1,4 @@
-> Source snapshot: official ti.admob.unified 1.0.0 documentation at commit `5b4cbf9` (copied 2026-10-11). Relative links rebased for this skill.
+> 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.
 
 # Privacy and initialization
 
@@ -41,7 +41,8 @@ The operation is idempotent:
 
 - Concurrent calls share the active native operation.
 - The first accepted call supplies the configuration.
-- A later call after completion re-emits the cached `consent_complete` result.
+- A later call after success re-emits the cached `consent_complete` result.
+- After an update or form failure, another `requestConsent({})` can retry without clearing persisted consent.
 - `resetConsent()` clears UMP test state and the module's cached consent operation so a new request can run.
 
 Do not put `resetConsent()` in a production launch path.
@@ -70,7 +71,9 @@ On failure:
 }
 ```
 
-The exact native `code` is platform and SDK dependent. Do not make business logic depend on a particular code.
+A failed update can still report `canRequestAds: true` from previously stored consent. Check that field even when `success` is false; do not assume an error requires blocking all requests. If it is false, continue the app without ads and offer a later retry.
+
+The native `code` depends on the platform and SDK. Avoid tying business logic to a particular value.
 
 The payload temporarily retains these deprecated keys:
 
@@ -110,6 +113,7 @@ Configures the global Google Mobile Ads request settings and initializes the SDK
 | Property                       | Type     | Description                                                                                                          |
 | ------------------------------ | -------- | -------------------------------------------------------------------------------------------------------------------- |
 | `testDeviceIds`                | String[] | Google Mobile Ads test-device identifiers.                                                                           |
+| `disableMediation`             | Boolean  | Optional global session exception before SDK startup; defaults to `false`. See [automatic adapter discovery](api-reference.md#automatic-adapter-discovery). |
 | `ageRestrictedTreatment`       | String   | One `AGE_RESTRICTED_TREATMENT_*` constant.                                                                           |
 | `maxAdContentRating`           | String   | One `MAX_AD_CONTENT_RATING_*` constant.                                                                              |
 | `tagForChildDirectedTreatment` | Boolean  | Deprecated compatibility input; maps to child/unspecified.                                                           |
@@ -145,11 +149,15 @@ Android can report a missing-activity failure:
 }
 ```
 
-Use `status` for diagnostics. Its text is not a stable machine-readable value.
+Android SDK initialization failures also emit `success: false`, `code: -1` and the failure text; a later call can retry. Request configuration and SDK startup run in the background, while completion events return to the UI thread. The app can continue while SDK work runs; a provider timeout still delays completion.
+
+Use `status` for diagnostics. Its text can change and should not drive application logic.
 
 ## App Tracking Transparency
 
-`requestTrackingAuthorization()` is available on both platforms and emits:
+`getTrackingAuthorizationStatus()` reads the current ATT state synchronously, without a prompt, event, or SDK initialization. Call it again after returning from Settings; the result is not cached.
+
+`requestTrackingAuthorization()` remains the explicit permission request and emits:
 
 ```js
 {
@@ -168,11 +176,13 @@ On iOS, the numeric status follows Apple's `ATTrackingManagerAuthorizationStatus
 |   `2` | Denied         |
 |   `3` | Authorized     |
 
-On Android, ATT does not apply. The method completes synchronously with `status: 3`, `authorized: true`, and `applicable: false`, allowing the same listener and call site on both platforms.
+On Android, ATT does not apply. The method completes synchronously with `status: 3`, `authorized: true`, and `applicable: false`, allowing the same listener and call site on both platforms. The query returns the same convention. `authorized: true` here is not general permission to track an Android user.
 
-Always wait for `tracking_authorization_completed`, even if the user resolved ATT in an earlier session. Denial changes tracking availability and does not imply `canRequestAds() === false`; UMP still determines permission to request ads.
+For apps that use tracking, run UMP → optional ATT → `canRequestAds()` → `initialize()` → ad loading. Request ATT while the application is active in the foreground, after UMP has dismissed its form and other system prompts have finished. If the app becomes inactive, defer the request until it is active again.
 
-ATT is optional. An application that calls `requestTrackingAuthorization()` must ship `NSUserTrackingUsageDescription` in its plist, because Apple's prompt cannot be presented without one. An application that never calls it should omit the key: Apple reviews the prompt against actual behavior, and UMP works without it. See [Getting started](getting-started.md#ios).
+When requesting ATT, always wait for `tracking_authorization_completed`, even if the user resolved ATT in an earlier session. Denial changes tracking availability and does not imply `canRequestAds() === false`; UMP still determines permission to request ads.
+
+ATT is optional. An application that calls `requestTrackingAuthorization()` must ship `NSUserTrackingUsageDescription` in its plist, because Apple's prompt cannot be presented without one. An IDFA message configured in AdMob can also make UMP request ATT during `requestConsent()`, which requires the same key and translations even if the app never calls the module's explicit request method. Omit the key only when neither the app nor its SDK configuration requests ATT and the app does not track. See Google's [UMP IDFA message guide](https://developers.google.com/admob/ios/privacy/idfa). See [Getting started](getting-started.md#ios).
 
 ## Privacy options
 
@@ -193,6 +203,8 @@ const onPrivacyDismissed = event => {
 
   privacyButton.visible = event.privacyOptionsRequired
   privacyButton.touchEnabled = privacyButton.visible
+  // Recheck event.canRequestAds and replace affected placements before
+  // requesting more ads. The integration library handles this boundary.
 }
 
 Admob.addEventListener('privacy_options_dismissed', onPrivacyDismissed)
@@ -214,8 +226,12 @@ The event payload is:
 
 Failures add `error` and `code`. Remove the module listener when its owning service is disposed.
 
+After a privacy change, stop new loads and presentations until the dismissal result has been evaluated. Discard ads requested under the previous choice and create fresh requests only if `canRequestAds()` allows them. Do not destroy an onscreen fullscreen ad as a way to dismiss it. The [integration library](library.md#privacy-and-diagnostics) manages placement reauthorization.
+
 ## Testing UMP
 
+GMA test-device IDs and UMP test-device IDs belong to separate SDK configurations; registering one does not register the other. Copy each identifier from that SDK's log. `TEST_*` ad units select Google test creatives; they do not force a UMP region.
+
 Use debug geography only with registered UMP test devices:
 
 ```js
@@ -252,3 +268,14 @@ Demo ad unit IDs do not register physical devices for UMP debugging. If the SDK
 These test buttons reset UMP consent only. They cannot reset Apple's ATT permission. Do not copy these testing controls or debug geography into a production consent flow. Unknown/error states are displayed separately from a successful result that does not require privacy options.
 
 Google reference: [Testing UMP on iOS](https://developers.google.com/admob/ios/privacy#testing) and [Testing UMP on Android](https://developers.google.com/admob/android/privacy#testing).
+
+
+## ATT demo controls
+
+The published example includes a Tracking transparency section on both platforms:
+
+- Check ATT status calls `getTrackingAuthorizationStatus()` and displays the current status, authorization and applicability without requesting permission or initializing ads. The result also shows when it was checked and a manual check count, so repeated taps have visible feedback.
+- Request ATT permission is enabled only for an undetermined iOS permission while the app is active and no consent/initialization operation is busy. It uses the same request event as startup. Resolved, restricted and Android states keep the button disabled. A resolved iOS permission has a nearby explanation directing changes to Settings.
+- Returning from Settings refreshes the displayed system state. The app cannot reset ATT through UMP or show Apple's prompt again after a resolved choice.
+
+An AdMob UMP IDFA message may already resolve ATT during startup. In that case the request button is disabled and the current result remains visible. On Android, the section explains that the portable `authorized: true` value is not general tracking permission. See [ATT configuration](getting-started.md#ios) for the usage description and translations.

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

@@ -0,0 +1,67 @@
+> 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.
+
+# Shipping an application
+
+Use this guide after the [first test integration](getting-started.md) works. Version `1.0.0` supplies the native bridge and an optional JavaScript integration library. Your application controls ad placement, production configuration, consent entry points and store disclosures.
+
+## Install and configure the release
+
+Install the core ZIP for every target platform and only the mediation complements you use. Extract archives at the application root so the manifests sit under `modules/<platform>/<module-id>/1.0.0/`. Declare matching versions in `tiapp.xml` and rebuild the app after changing modules. Do not add another AdMob module, a second copy of Google Mobile Ads, or duplicate provider frameworks alongside this distribution.
+
+Use a maintained Titanium SDK at or above `13.4.1.GA`, iOS `15.0+` and Android API `24+`. The minimums describe the declared support floor; consult [release readiness](roadmap.md#release-readiness) for the device coverage. On Android, Maven dependencies resolve during the app build. On iOS, the ZIP already includes the native frameworks; consumers do not run this repository's CocoaPods installers.
+
+Set each platform's own AdMob application ID in `tiapp.xml`, then select an ad-unit ID for that platform **and format**. App IDs contain `~`; unit IDs contain `/`. Keep Google's `TEST_*` constants in development builds and supply your own units through the app's build configuration for distribution. GMA test-device registration and UMP debug-device registration are separate. Remove forced UMP geography, consent-reset controls and demo property overrides from production flows. See [testing guidance for Android](https://developers.google.com/admob/android/test-ads) and [iOS](https://developers.google.com/admob/ios/test-ads).
+
+A release ZIP's size is not the installed application size: Android dependencies resolve separately and iOS frameworks contain device/simulator slices. Measure the final store archive for the chosen networks.
+
+## Verify the application in AdMob
+
+Link the correct store listing to each platform's AdMob app. Follow the verification and app-readiness status shown in the AdMob console; a working Google demo ad does not prove that a production app is approved to serve ads.
+
+Publish the account's own `app-ads.txt` entries on the developer website associated with the store listing. This file belongs on that website, not in Titanium's `Resources/`. Follow Google's [app verification instructions](https://support.google.com/admob/answer/14538460?hl=en-GB) and use the console's verification check. Review the selected providers' seller entries when configuring mediation.
+
+## Finish privacy and store settings
+
+Request a fresh UMP update on every launch, wait for `consent_complete`, check `canRequestAds()`, then initialize and load. A UMP error can still leave requests allowed by prior consent; use the returned gate rather than inferring consent from the error. Keep the application usable when ads are unavailable.
+
+Expose an accessible privacy-options action when `isPrivacyOptionsRequired()` is true. After dismissal, reevaluate the gate and replace requests affected by changed choices. The [integration library](library.md) manages that boundary. Do not use `resetConsent()` as a production revocation action. Google's [UMP guide](https://developers.google.com/admob/ios/privacy) describes the update, request gate and privacy entry point.
+
+ATT applies to the app's actual tracking use on iOS. If you request it, provide an accurate `NSUserTrackingUsageDescription`, resolve the prompt before SDK initialization, and handle denial without treating it as a UMP denial. Review [Apple's tracking requirements](https://developer.apple.com/app-store/user-privacy-and-data-use/). Configure the UMP under-age input and GMA age treatment for the app's audience; they are separate settings. A maximum content rating alone does not establish an age policy.
+
+Review Google's [App Store data disclosure guide](https://developers.google.com/admob/ios/privacy/data-disclosure) and [Google Play data disclosure guide](https://developers.google.com/admob/android/privacy/play-data-disclosure), plus the guidance for each included provider. Complete the app's privacy policy, store privacy answers and advertising declarations based on the SDKs and features it actually uses. Bundled privacy manifests do not fill in those answers for you. Maintain the `SKAdNetworkItems` required by Google and the installed networks, using their current setup guides.
+
+## Choose presentation points
+
+Reserve real banner space within safe areas and away from navigation controls. For anchored adaptive banners, measure the laid-out host width, reserve the native size and apply the loaded height. The [banner guide](banners.md) covers pause/resume, orientation and cleanup. Let Google's ad-unit policy own automatic refresh.
+
+Preload fullscreen ads and show at a deliberate opportunity. Offer rewarded ads explicitly. For [rewarded interstitials](rewarded-interstitial.md), explain the configured reward and provide a skip option before presentation. Grant rewards only from `rewarded`; `closed` and `impression` do not prove a reward. Allow one fullscreen presentation at a time, including UMP, ATT and Inspector. Keep app-open ads within a foreground loading experience; skip the opportunity when the user has reached content. An expired app-open ad needs another `load()` even with `autoReload: true`.
+
+The library checks fullscreen dimensions at `show()` and reloads an incompatible ad without presenting it automatically. Raw API consumers must manage that boundary themselves. See [fullscreen guidance](fullscreen.md) and the [library contract](library.md#fullscreen-ads).
+
+## Validate selected mediation sources
+
+Configure each provider account, credentials, format and AdMob source mapping. Install the corresponding complement and initialize the core normally. `getMediationStatus()` reports Google's initialization diagnostics, not successful delivery or a complete package inventory.
+
+Use provider test mode and Ad Inspector single-source testing on a registered test device. Check each platform separately: a Google demo ad or an adapter marked `ready` does not prove that the provider served an ad. Follow the [mediation guide](mediation.md) and the exact versions in [Dependencies](dependencies.md).
+
+## Troubleshoot integration failures
+
+| Symptom | Check and next action |
+| --- | --- |
+| App terminates before JavaScript startup | Verify `GADApplicationIdentifier` / Android `APPLICATION_ID` in the consumer configuration and inspect native logs. |
+| `canRequestAds()` is false | Inspect `consent_complete`, the app ID and AdMob message setup. Continue without ads; retry a failed consent update later without resetting production consent. |
+| Banner is empty, clipped or offscreen | Inspect host/proxy dimensions, safe areas, available width and the final `postlayout`. On iOS reserve anchored height before loading. |
+| `failed_to_load` | Record event name, format, code and message. Use test units, check connectivity/configuration, then retry at a later opportunity with backoff. Avoid immediate retry loops. |
+| `failed_to_show` | Check readiness, foreground host, expiry, dimensions and another active presentation. Raw `show()` returns no success value; listen for events. |
+| Rewarded/interstitial has controls but no visible creative | Capture the visible failure and SDK logs. An impression does not prove visible rendering. See the known iOS issues in [release readiness](roadmap.md#release-readiness). |
+| Google ads work but a provider does not | Check provider mappings, test mode and Ad Inspector single-source results; core test units do not validate mediation. |
+| iOS extraction reports `EACCES` or a reinstall uses stale files | Replace the affected module extraction with a freshly unpacked release ZIP, then clean/rebuild. Check installed manifest/files; maintainers must package writable frameworks. |
+| Ads disappear after an Android theme change | Preserve placements on Titanium's `_closeFromActivityForcedToDestroy` close event; see [cleanup](library.md#cleanup). |
+
+When reporting a problem, include module/Titanium versions, OS/device, format, test versus production unit, complete error payload and a minimal reproduction. Remove credentials, personal test-device identifiers and user data from shared logs. Native load errors, show errors and UMP errors use different code domains; consult the [API reference](api-reference.md#common-google-mobile-ads-error-codes).
+
+## Test the final app build
+
+Exercise the app on physical iOS and Android devices with test traffic: first launch and saved consent, privacy reopening, applicable ATT outcomes, banner layout/rotation/backgrounding, fullscreen show/close/failure and actual reward delivery. Verify repeated navigation releases listeners and preserves the banner slot. Test an unavailable-ad path so navigation never depends on receiving an ad.
+
+Version `1.0.0` implements standard, anchored/inline adaptive and collapsible banners, interstitial, rewarded, rewarded interstitial and app open. The Native factory is unavailable. Server-side reward verification configuration, paid-event callbacks and public response-info access are also outside this release's API. Review [the API reference](api-reference.md) before depending on additional SDK features.