@maccesar/titools 5.2.0 → 5.2.1

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

@@ -1,14 +1,14 @@
-> 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.
 
 # Fullscreen ads
 
-Interstitial, rewarded and app open proxies share one public lifecycle and event contract on iOS and Android.
+Interstitial, rewarded, rewarded interstitial and app open proxies share one public lifecycle and event contract on iOS and Android.
 
 ## When to show a fullscreen ad
 
 A fullscreen ad interrupts the current screen, so choose its presentation point before requesting it.
 
-Load early, show later: `load()` is a network request and can take seconds. Start it before the intended break, for example when a level opens, an article starts or a form appears. Call `show()` when the application reaches that break. Presenting inside the `loaded` listener lets network timing determine when the user is interrupted.
+Load early, show later: `load()` is a network request and can take seconds. Start it before the intended break, for example when a level opens, an article starts or a form appears. Call `show()` when the application reaches that break. Do not present unconditionally from the `loaded` listener: that lets network timing determine when the user is interrupted. A screen may instead keep an explicit Show request pending during loading, provided it cancels that request when the user leaves or the app loses the foreground.
 
 Show fullscreen ads at a natural break, such as between levels or after a task or flow ends. Avoid interrupting work in progress.
 
@@ -17,10 +17,10 @@ Google's guidance includes these restrictions:
 - Do not show an interstitial as the app opens. That moment belongs to the App Open format, documented below.
 - Do not show one on the way out, when the user is already leaving.
 - Do not interrupt an action in progress, or place the ad where a button or a control the user was about to touch used to be.
-- Use `createRewarded()` to reward users for watching ads. Interstitials must not offer rewards.
-- Avoid consecutive interstitials and excessive frequency. Configure frequency capping on the ad unit in the AdMob console; JavaScript does not control it.
+- Use `createRewarded()` or the dedicated `createRewardedInterstitial()` format for rewards. Ordinary interstitials must not offer rewards.
+- Avoid consecutive interstitials and excessive frequency. Configure the ad unit's frequency cap in the AdMob console; it is not a JavaScript setting.
 
-The full lists are in Google's [Android interstitial guide](https://developers.google.com/admob/android/interstitial) and [iOS interstitial guide](https://developers.google.com/admob/ios/interstitial).
+See the full restrictions in Google's [Android interstitial guide](https://developers.google.com/admob/android/interstitial) and [iOS interstitial guide](https://developers.google.com/admob/ios/interstitial).
 
 ## Privacy gate
 
@@ -69,7 +69,7 @@ function onLevelCompleted() {
 
 If the ad is not ready, let the application continue and try at the next break.
 
-The executable [example app](../assets/example/app.js) loads automatically after initialization. Each format has one button that reports its state and enables Show when ready.
+The executable [example app](../assets/example/app.js) loads automatically after initialization. Each format has one button that reports its state and enables Show when ready. One Show or Retry tap is enough: if an ad needs loading or replacement after a size change, the example waits and presents when it arrives. The rewarded interstitial card explains the reward and AdMob’s introduction requirements, links to the official policy and opens a Watch test ad/Skip introduction after Show. Watch permits presentation; Skip cancels it. Watch also remains valid through a required size replacement, so loading does not require another Show tap. Closing an ad preloads another without presenting it. Leaving the foreground, closing the window, changing privacy eligibility or requesting a different fullscreen cancels the pending presentation.
 
 ## Rewarded
 
@@ -92,7 +92,13 @@ rewarded.addEventListener(Admob.AD_FAILED_TO_SHOW, event => {
 rewarded.load()
 ```
 
-Closing a rewarded ad is not proof that the reward was earned.
+Present it only after the user accepts a clear reward offer, using `isLoaded()` before `show()`. Closing a rewarded ad is not proof that the reward was earned. Keep the reward handler alive until the SDK delivers the result; mediated callback ordering may differ. Version `1.0.0` exposes client-side rewards only; it has no server-side verification configuration.
+
+The application must coordinate fullscreen proxies so only one presentation is active at a time. Keep it separate from UMP, ATT and Ad Inspector.
+
+## Rewarded interstitial
+
+`createRewardedInterstitial()` shares Rewarded's configuration, methods and reward event. Before presentation, explain the reward and offer a way to skip. The proxy does not show that introduction itself. See [Rewarded interstitial ads](rewarded-interstitial.md) for the complete flow.
 
 ## App open
 
@@ -112,16 +118,20 @@ appOpen.load()
 ```
 
 ```js
-function onApplicationResumed() {
-  if (appOpen && appOpen.isLoaded()) {
+function onForegroundLoadingScreen() {
+  if (appOpen.isLoaded()) {
     appOpen.show()
+  } else {
+    appOpen.load()
   }
 }
 ```
 
+Call this only while your loading screen is visible and no consent form, other fullscreen ad or external flow is active. Do not wire an unconditional show to every activity resume: closing an ad or returning from its click can also resume the host. If loading finishes before the ad is ready, continue into the app and save the ad for a later opportunity. Remove any application lifecycle listener when its owner is disposed.
+
 ### The four hour window
 
-Google documents that an app open ad expires four hours after it was requested. An ad rendered later is no longer valid and may not earn revenue, so the proxy enforces the window itself, with no timer and no extra event:
+Google documents a four-hour validity window and its sample checks the time since the ad loaded. Both module proxies record successful load completion and check that age, with no timer and no extra event. See Google's [Android](https://developers.google.com/admob/android/app-open#consider_ad_expiration) and [iOS](https://developers.google.com/admob/ios/app-open) guides:
 
 - The load time is recorded when the ad arrives.
 - `isLoaded()` returns `false` once four hours have passed.
@@ -132,7 +142,7 @@ Google documents that an app open ad expires four hours after it was requested.
 
 ## Creation properties
 
-All three factories accept:
+All four factories accept:
 
 | Property       | Type     | Default | Notes                                                              |
 | -------------- | -------- | ------- | ------------------------------------------------------------------ |
@@ -146,7 +156,7 @@ Do not use `extras` to bypass UMP or synthesize personalization state.
 
 Both platforms preserve primitive values in `extras`. Use the types required by the receiving adapter; for example, pass `{ npa: '1' }` when it expects a string.
 
-Pass initial configuration to the factory. Later assignments to the five configuration properties affect the next request on both platforms. An already loaded ad keeps the configuration of its original request.
+Pass initial configuration to the factory. Later assignments to `adUnitId`, `keywords`, `requestAgent` and `extras` affect the next request on both platforms; an already loaded ad keeps its original request configuration. `autoReload` is a live close policy: both native ports read its current value when the shown ad closes, so changing it while an ad is loaded or presented changes whether that close starts another load. It does not present another ad or retry a load/show failure.
 
 ## Shared methods
 
@@ -157,7 +167,7 @@ Pass initial configuration to the factory. Later assignments to the five configu
 | `isLoaded()` | Returns `true` only while an unused ad is ready. For app open, an ad older than four hours is not ready.        |
 | `destroy()`  | Terminal, idempotent cleanup; emits `destroyed` once.                                                           |
 
-Google fullscreen ads are single-use. After a presentation or a show failure the proxy holds no ad: its native reference is cleared and `isLoaded()` turns `false`. Call `load()` again before the next `show()`.
+Google fullscreen ads are single-use. Once presentation starts, `isLoaded()` is `false`. Native dismissal or presentation-failure callbacks discard the consumed reference. A local precondition failure, such as a missing host before presentation, can retain the unused ad; recheck readiness after correcting the condition. Call `load()` again before the next `show()`.
 
 Late native callbacks are ignored after `destroy()`. A dismissed or failed-to-show ad reference is cleared before the terminal event is emitted.
 
@@ -183,21 +193,27 @@ Reuse the proxy across loads. Create a new one only after `destroy()`.
 
 ### Common events
 
-| Event                       | Interstitial | Rewarded | App open | Common payload                                     |
-| --------------------------- | -----------: | -------: | -------: | -------------------------------------------------- |
-| `loaded`                    |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `failed_to_load`            |          Yes |      Yes |      Yes | `adUnitId`, `adType`, `error`, `message`, `code`   |
-| `opened`                    |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `showed_fullscreen_content` |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `closed`                    |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `clicked`                   |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `impression`                |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `failed_to_show`            |          Yes |      Yes |      Yes | `adUnitId`, `adType`, `error`, `message`, `code`   |
-| `destroyed`                 |          Yes |      Yes |      Yes | `adUnitId`, `adType`                               |
-| `rewarded`                  |           No |      Yes |       No | `adUnitId`, `adType`, `rewardType`, `rewardAmount` |
+| Event                       | Interstitial | Rewarded | App open | Rewarded interstitial | Common payload                                     |
+| --------------------------- | -----------: | -------: | -------: | -------: | -------------------------------------------------- |
+| `loaded`                    |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `failed_to_load`            |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`, `error`, `message`, `code`   |
+| `opened`                    |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `showed_fullscreen_content` |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `closed`                    |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `clicked`                   |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `impression`                |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `failed_to_show`            |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`, `error`, `message`, `code`   |
+| `destroyed`                 |          Yes |      Yes |      Yes | Yes | `adUnitId`, `adType`                               |
+| `rewarded`                  |           No |      Yes |       No | Yes | `adUnitId`, `adType`, `rewardType`, `rewardAmount` |
 
 `message` duplicates `error` for compatibility. New code may use `error`; both keys are portable.
 
+## iPad collapsed-SVG workaround
+
+With the pinned GMA iOS 13.11.0 SDK, an Interstitial image creative can contain an SVG whose automatic width collapses in WebKit on iPad. The wrapper checks the presented Google WebView during a bounded first-second window. It repairs only `svg.advertiser-provided-image` with zero width, positive height, a valid SVG viewBox, a Google `simgad` background image and a column-flex parent. The parent receives the viewBox aspect ratio; visible images, intentionally hidden content and other layouts remain unchanged. Pending attempts stop on dismissal, presentation failure or destruction.
+
+The check applies to Interstitials on iPad with both demo and publisher-owned unit IDs. It uses internal creative markup and is not an official Google SDK setting. Other templates, nested content or later layout failures may remain outside its scope. Rewarded and Rewarded Interstitial are not modified. Device tests established the original repair with Google's demo creative; extending eligibility to publisher IDs does not certify every production creative. Validate your units with [test devices enabled](https://developers.google.com/admob/ios/test-ads).
+
 ## Cleanup
 
 Use named callbacks and remove them before disposing the proxy:
@@ -217,7 +233,6 @@ Create a new proxy after disposal; a destroyed proxy cannot load again.
 
 The module exports format-name and test-ID constants for future compatibility, but it does not expose working factories for:
 
-- Rewarded interstitial
 - Native
 
-`TEST_REWARDED_INTERSTITIAL` and `TEST_NATIVE` name units no factory accepts.
+`TEST_NATIVE` names a unit no factory accepts.

package/skills/ti-admob-unified/references/game-monetization.md

@@ -1,17 +1,148 @@
 # Game monetization and module integration
 
-Use the official `fullscreen.md`, `privacy.md` and `library.md` contract for calls. This reference adds product/lifecycle criteria, not a second module API. The detailed asset-to-game coordination guide is `ti-game-assets/references/responsible-ads.md` when that skill is available; this skill works independently of it.
+Use [fullscreen.md](fullscreen.md), [privacy.md](privacy.md) and
+[library.md](library.md) for calls. This reference adds game-specific product
+and lifecycle criteria, not a second module API. Reviewed against
+`ti.admob.unified@034843299b2984253988e0ffccb9f6a1c91682c9` (1.0.0).
+Read [production.md](production.md) before shipping an application. When
+available, `ti-game-assets/references/responsible-ads.md` adds asset/game
+coordination; this skill remains usable independently of it.
+
+## Current formats and their boundaries
+
+| Placement | Integration boundary |
+| --- | --- |
+| Interstitial | Preload; show at a natural break without offering a reward. Avoid app entry, exit, active gameplay and repeated/consecutive interruptions. |
+| Rewarded | Offer a clear voluntary exchange; present after acceptance; grant only from `rewarded` / `onRewarded`. |
+| Rewarded interstitial | Implemented by `createRewardedInterstitial()` and its library manager. At a natural transition, explain the configured reward and show a clear, unobstructed Skip option before presentation, with enough time to understand and decline. The proxy/manager does not build this introduction. See [rewarded-interstitial.md](rewarded-interstitial.md). |
+| App open | Implemented, but belongs only to an application's own foreground loading experience. Skip when content is already usable; do not show unconditionally from every resume. An expired ad needs a new load. |
+| Banner/adaptive banner | Reserve a safe, measured slot away from controls; preserve that slot across ordinary screen pauses. See [banners.md](banners.md). |
+| Native | No factory in 1.0.0. Format/test-ID constants alone do not implement it. |
+
+Adding another implemented format still requires an intentional product decision.
+Do not add forced rewarded continues or replace every retry with an ad. For a
+rewarded-interstitial introduction, use the reward configured for that unit;
+there is no pre-presentation reward getter. A visible Watch/Skip AlertDialog
+works on both platforms; an iPad OptionDialog's hidden cancel item is not an
+equivalent visible Skip action. Cancel a pending introduction when its screen
+closes, the foreground or eligibility is lost, or another fullscreen is chosen.
+
+Only the SDK's `rewarded` event grants value; `closed`, `impression`, clicks
+and a successful Show attempt do not. The rewarded-interstitial native proxies
+deduplicate reward callbacks per presentation and preserve the presented unit's
+SDK reward while another request may load. Keep reward handling alive for the
+SDK result: mediated reward and dismissal callback ordering can differ.
+`destroy()` is terminal and suppresses late callbacks; it is not a dismissal API.
+Client-side rewards do not provide server-side verification in this release.
+
+## Privacy and integration ownership
+
+Run the consent-first flow on every app launch: register listeners, request
+UMP, wait for `consent_complete`, evaluate `canRequestAds()`, initialize, then
+load. A failed UMP update may retain permission from a previous choice; an
+error alone is neither approval nor denial. Continue the game without ads
+when unavailable. Raw fullscreen proxies do not enforce this gate.
+
+ATT is separate. If the app uses it, resolve the foreground prompt after UMP
+and before initialization; keep the required description/translations even if
+an AdMob UMP IDFA message presents ATT. Query
+`getTrackingAuthorizationStatus()` to inspect state without prompting, including
+after Settings. Android's `applicable: false` / `authorized: true` convention
+is not general tracking permission. ATT denial does not override UMP's request
+gate. If explicitly requesting ATT, wait for `tracking_authorization_completed`
+even when permission was resolved in an earlier session. See [privacy.md](privacy.md).
+
+The copy-ready library owns sequencing, deferred loads, dimensions and placement
+cleanup. It does **not** choose game breaks, impose frequency limits, pause
+native gameplay/audio/input, or serialize unrelated application modal flows.
+Its `start()` promise is cached even after an unavailable result; repeating it
+is not a startup retry. Use the documented raw consent/init recovery flow if
+recoverable startup is part of the application. Never reset production consent
+to force another attempt.
+
+Provide an interactive privacy action when required. Serialize it with ads,
+ATT and Inspector; suspend new ad opportunities until its result is evaluated.
+The library reauthorizes/replaces requests after dismissal. Raw consumers must
+replace requests affected by changed choices themselves. Do not destroy an
+onscreen fullscreen ad to dismiss it or treat `destroyAll()` as cancelling
+UMP/Inspector: it releases placements only. See [library.md](library.md).
 
 ## Community-Discovered Patterns
 
-These are author guidance and integration lessons from Lander/Guardian, not additional module API or a verified optimal monetization policy. Preserve this section during official-doc refreshes and re-evaluate its lifecycle claims against current builds.
+These are preserved author guidance and integration lessons from Lander/Guardian,
+not additional module API or a verified optimal monetization policy. Their
+frequency/director separation remains useful alongside the official library;
+their application configuration and numeric thresholds are not defaults for
+other games.
+
+Choose deliberate natural breaks, such as settled end-of-run results, rather
+than interrupting flight/combat or attaching an ad to every retry. Preserve
+pause/tutorial/practice and voluntary-exit choices. Load early, but let the
+application choose Show. A time threshold makes a later break eligible; it
+never authorizes a timer-driven interruption. Google's
+[interstitial placement guidance](https://support.google.com/admob/answer/6201362?hl=en)
+disallows unexpected and excessive placements; re-check it before a live change.
+
+Before presentation, capture the intended scene state, suspend native motion
+and relevant timers, silence app-owned audio as appropriate, and release held
+input. A stopped JS tick does not stop native gravity. Restore only the scene,
+clock scale and audio that should still be active after dismissal or confirmed
+failure, provided the owner is alive and the app is foregrounded. Do not blindly
+resume a previously paused game, undo a newer navigation choice, or restore held
+throttle/fire inputs. Returning from an ad is a lifecycle event, not a new ad
+opportunity.
+
+One application director owns presentation and rejects simultaneous attempts,
+including UMP, ATT, Inspector and other fullscreen formats. Keep a once-only
+continuation and an ownership/generation token so callbacks from an abandoned
+screen cannot advance its successor. A missing-opening watchdog may recover an
+attempt that never opens; after a confirmed `opened`, clear that watchdog and
+wait for actual dismissal or presentation failure. An opening/impression does
+not prove the creative was visibly rendered. Associate completion with the
+active attempt: a rejected duplicate Show is not proof that an already open
+ad has ended.
+
+Distinguish the APIs at the boundary: raw `load()` / `show()` return no success
+value. Library-manager `show()` returns `false` when not ready or when the
+size guard requests a replacement; continue without blocking. A `true` result
+means presentation was attempted and may still fail through `onFailedToShow`.
+Supply the owning window. The manager does not queue a future Show after
+returning `false`; a late load or background/resume must not launch a missed
+interstitial. An explicit user-requested pending flow, such as the published
+rewarded-interstitial demo, needs its own cancellation and introduction state.
 
-Choose deliberate natural breaks, such as settled end-of-run results, rather than interrupting flight/combat or attaching an ad to every retry. Preserve pause/tutorial/practice and voluntary-exit choices. Load early, but only the application decides to show; reaching a time threshold makes a later boundary eligible, never a timer-based interruption. Current [Google guidance](https://support.google.com/admob/answer/6201362?hl=en) disallows unexpected and excessive interstitial placements; re-check it before a live change.
+Keep grace period, active-play accumulation, cooldown after dismissal,
+hourly/daily caps and permitted boundaries distinct. Count actual openings
+once and close separately; do not count both `opened` and
+`showed_fullscreen_content` as two exposures. Preserve persistence and
+conservative handling of clock rollback. Caps are ceilings, not exposure
+targets, and application eligibility is separate from AdMob's ad-unit cap.
+Use backoff after load/show failures; `autoReload` requests a replacement after
+`closed` only and never presents it automatically.
 
-The ad boundary must suspend/release native motion and sound as appropriate. A stopped JS tick does not stop native gravity. Resume only the intended scene after an actual dismissal or confirmed show failure. One director owns presentation, protects against simultaneous attempts, and discards continuations after the screen/session closes. Timeouts may handle missing opening; they must not resume gameplay behind a confirmed open ad. A background/resume or late load callback does not start a missed ad.
+A banner host must stay away from touch controls and reserve the native loaded
+height inside safe areas. Choose `collapseOnFailure: false` on a library banner
+when retrying should preserve its slot. Use screen-level `pause()` / `resume()`
+only when navigation hides it while the same host lifecycle remains active;
+background/activity lifecycle is already native. Pausing preserves the creative,
+visibility and geometry; no JS refresh timer or destroy/recreate loop is needed.
+On Android, ignore `_closeFromActivityForcedToDestroy` for placement teardown:
+that close can be activity recreation rather than a destroyed screen. Remove
+named listeners and destroy placements on actual owner disposal. Preserve reward
+listeners until their result; destruction must not resume an abandoned game.
 
-Keep grace period, active-play accumulation, cooldown after dismissal, hourly/daily caps and permitted boundaries distinct. Count actual openings once and track close separately. Preserve persistence and conservative handling of clock rollback. Lander and Guardian implement this separation, but their numeric thresholds are initial settings without evidence of an optimum; do not transplant them into every game. Caps are ceilings, not exposure targets. Application eligibility is separate from the network's AdMob frequency cap.
+## Acceptance in the consuming game
 
-Use test IDs and the official consent-first flow. Banners need layout away from controls; rewarded ads need an explicit voluntary offer, a real reward and one grant from the documented rewarded event. Interstitials are not rewarded ads. Do not add forced rewarded continues, App Open or a new format without product scope. The module's implemented formats and roadmap determine what is possible.
+Use test units and test devices. Exercise unavailable module, no fill,
+load/show failures, repeated taps, late/duplicate callbacks, reward once,
+Skip, real dismissal, background/resume, privacy changes, rotation between
+load/introduction/Show, owner destruction and phone/tablet layouts on both
+platforms. Check native clock, input and audio restoration on each path.
 
-Test unavailable module, no fill, load/show failures, repeated taps, late/duplicate callbacks, real close, background/resume, destruction and phone/tablet layout on both platforms. An SDK opening/impression does not prove the creative was visible: physical visual acceptance is separate. Measure confirmed exposure per active-play minute, abandonment at ad boundaries and retention/retries where telemetry is authorized; unit tests do not prove players enjoy the frequency.
+A source check, wrapper test, SDK opening or impression does not prove visible
+creative rendering, provider delivery or acceptable game frequency. Record
+physical visual acceptance separately. Where telemetry is authorized, measure
+confirmed exposure per active-play minute, abandonment at boundaries and
+retention/retries. Unit tests do not prove players enjoy the frequency.
+Production units, app verification, app-ads.txt, provider setup and store/privacy
+disclosures belong to [production.md](production.md), not game frequency logic.

package/skills/ti-admob-unified/references/getting-started.md

@@ -1,9 +1,27 @@
-> 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.
 
 # Getting started
 
+<!-- TOC-START -->
+## Contents
+
+- [1. Install the modules](#1-install-the-modules)
+- [2. Configure the AdMob application IDs](#2-configure-the-admob-application-ids)
+- [3. Configure mediation if needed](#3-configure-mediation-if-needed)
+- [4. Configure Privacy & messaging](#4-configure-privacy--messaging)
+- [5. Use official test units](#5-use-official-test-units)
+- [6. Request consent, then initialize](#6-request-consent-then-initialize)
+- [7. Create an ad only after the gate opens](#7-create-an-ad-only-after-the-gate-opens)
+- [Common setup mistakes](#common-setup-mistakes)
+- [Before shipping](#before-shipping)
+- [Example appearance](#example-appearance)
+
+<!-- TOC-END -->
+
 ## 1. Install the modules
 
+Download the core archives from [GitHub Releases](https://github.com/macCesar/ti.admob.unified/releases). Use `ti.admob.unified-iphone-1.0.0.zip` for iOS and `ti.admob.unified-android-1.0.0.zip` for Android. Extract each ZIP at your Titanium application's root, keeping the archive's `modules/` directory. The resulting manifests must be at `modules/iphone/ti.admob.unified/1.0.0/manifest` and `modules/android/ti.admob.unified/1.0.0/manifest`. Do not add another nested `modules/` directory.
+
 Install the `1.0.0` ZIP of `ti.admob.unified` for every platform you build. All artifacts of a given module must have the same module ID and version:
 
 ```xml
@@ -12,7 +30,7 @@ Install the `1.0.0` ZIP of `ti.admob.unified` for every platform you build. All
 </modules>
 ```
 
-An application that serves AdMob demand needs only the core: about 14 MB on iOS and 325 KB on Android, with no third-party network SDKs in the build.
+An application that serves AdMob demand needs only the core. Android resolves its Maven dependencies during the consumer build, so the module ZIP size is not the installed app-size cost. CocoaPods and the framework installer scripts are for building this repository, not for applications installing its release ZIPs.
 
 If the application mediates, install the selected per-network complements at the same version. For AppLovin:
 
@@ -25,7 +43,7 @@ If the application mediates, install the selected per-network complements at the
 
 Each complement carries one adapter and its dependencies, with no JavaScript API. Add a module line for each intended network; leave unneeded networks out. See [AdMob mediation](mediation.md).
 
-The current baselines are Titanium `13.2.0.GA`, iOS `15.0+`, and Android API `24+`.
+The minimum versions are Titanium `13.4.1.GA`, iOS `15.0+`, and Android API `24+`.
 
 For an existing AdMob integration, see [Migrating to ti.admob.unified](migration.md).
 
@@ -43,7 +61,7 @@ An **ad unit ID** contains a slash:
 ca-app-pub-0000000000000000/0000000000
 ```
 
-They are not interchangeable. The application ID belongs in `tiapp.xml`; ad unit IDs are supplied to ad factories such as `createAdaptiveBanner()`.
+Put the application ID in `tiapp.xml` and pass ad unit IDs to factories such as `createAdaptiveBanner()`. Each field requires its own ID type.
 
 ### iOS
 
@@ -60,7 +78,7 @@ Add the iOS application ID to the app plist section:
 </ios>
 ```
 
-App Tracking Transparency is optional and separate from UMP. Most banner applications do not need it: serving ads does not require tracking users across other companies' apps and websites. Add the usage description only when the application uses tracking, and describe that use accurately. Apple reviews the prompt against the app's behavior.
+App Tracking Transparency is optional and separate from UMP. Serving ads does not require tracking users across other companies' apps and websites. Add the usage description only when the application uses tracking, and describe that use accurately. Apple reviews the prompt against the app's behavior.
 
 ```xml
 <ios>
@@ -73,7 +91,24 @@ App Tracking Transparency is optional and separate from UMP. Most banner applica
 </ios>
 ```
 
-Omit that key entirely if the application never calls `requestTrackingAuthorization()`. UMP still runs and still shows the consent form where the region requires one; the two mechanisms are unrelated.
+Include this key whenever the app or an included SDK requests ATT, including an IDFA message configured in AdMob UMP. Omit it only when the app and its SDK configuration never request ATT and do not perform tracking. UMP regional consent can run without ATT.
+
+The usage description is the explanation shown in Apple's ATT prompt. Localize it with `i18n/<language>/app.xml` in the consumer app, using the `NSUserTrackingUsageDescription` string name. Provide an English value and a translation for each supported language, including Spanish when the app supports it. This applies to Classic and Alloy projects; verify that the built app contains `<language>.lproj/InfoPlist.strings` with those values.
+
+```xml
+<resources>
+  <string name="NSUserTrackingUsageDescription">This identifier helps us measure advertising performance.</string>
+</resources>
+```
+
+These settings serve separate purposes:
+
+- `NSUserTrackingUsageDescription` and its translations explain the ATT request. They do not request permission by themselves.
+- `GADApplicationIdentifier` identifies the iOS app to AdMob. It is required even when ATT is disabled.
+- `SKAdNetworkItems` configures attribution identifiers. It does not grant ATT permission.
+- App Store Connect privacy disclosures describe the app's actual collection and tracking, including its SDKs. They must match the integration; a plist entry does not complete those disclosures. See Apple's [privacy and data use guidance](https://developer.apple.com/app-store/user-privacy-and-data-use/).
+
+A successful App Store review of another integration is a reference, not a promise that Apple will approve this app. Review depends on its behavior, configuration and disclosures.
 
 Keep any required `SKAdNetworkItems` in the consuming app. Follow Google's [iOS setup guide](https://developers.google.com/admob/ios/quick-start) for the current list and App Store requirements.
 
@@ -129,7 +164,7 @@ const interstitialId = Admob.TEST_INTERSTITIAL
 const rewardedId = Admob.TEST_REWARDED
 ```
 
-The module exports the full set of test constants for compatibility. Two formats have no implemented factory:
+The module exports the full set of test constants for compatibility. Native remains reserved without a factory:
 
 | Constant                     | Factory that accepts it                           |
 | ---------------------------- | ------------------------------------------------- |
@@ -138,7 +173,7 @@ The module exports the full set of test constants for compatibility. Two formats
 | `TEST_INTERSTITIAL`          | `createInterstitial()`                            |
 | `TEST_INTERSTITIAL_VIDEO`    | `createInterstitial()` (same API, video creative) |
 | `TEST_REWARDED`              | `createRewarded()`                                |
-| `TEST_REWARDED_INTERSTITIAL` | None. Reserved; the format is not implemented     |
+| `TEST_REWARDED_INTERSTITIAL` | `createRewardedInterstitial()`                    |
 | `TEST_NATIVE`                | None. Reserved; the format is not implemented     |
 | `TEST_APP_OPEN`              | `createAppOpen()`                                 |
 
@@ -172,7 +207,9 @@ function initializeOnce() {
 Admob.addEventListener('module_initialized', event => {
   if (event.success) {
     Ti.API.info('Google Mobile Ads initialized')
+    // Create/load placements here, after initialization succeeds.
   } else {
+    initialized = false // allow a later app-controlled retry
     Ti.API.warn(`Google Mobile Ads initialization failed: ${event.error}`)
   }
 })
@@ -192,7 +229,7 @@ Admob.requestConsent({
 
 Skip this section unless step 2 added `NSUserTrackingUsageDescription`. ATT is not a prerequisite for serving ads, and requesting it without a real tracking case invites an App Store rejection.
 
-An application that does request it waits for the Apple prompt to settle before initializing, so that the SDK reads a final tracking status:
+Replace the `consent_complete` listener from step 6 with the listener below; do not register both. An application that requests ATT waits for the Apple prompt to settle before initializing, so that the SDK reads a final tracking status. Present it while the app is active and no other system prompt or consent form is onscreen:
 
 ```js
 Admob.addEventListener('consent_complete', event => {
@@ -217,38 +254,41 @@ Admob.addEventListener('consent_complete', event => {
 })
 ```
 
-Google Mobile Ads reads `trackingAuthorizationStatus` on its own on iOS. That read is not a permission request and does not open Apple's prompt: only `requestTrackingAuthorization()` does.
+Google Mobile Ads reads `trackingAuthorizationStatus` on its own on iOS; that read does not open Apple's prompt. An IDFA message configured in AdMob can let UMP present ATT during `requestConsent()`. In that integration, keep the usage description and translations, let UMP finish, and use `getTrackingAuthorizationStatus()` to inspect the result. A separate explicit ATT request is unnecessary when UMP already handles it. See Google's [UMP IDFA message guide](https://developers.google.com/admob/ios/privacy/idfa).
 
 `initialize()` and `requestConsent()` are idempotent native operations. Application-level guards are still useful because cached terminal events may be emitted again when a caller invokes an already-completed operation.
 
 ## 7. Create an ad only after the gate opens
 
-A banner needs a host view that is already in the hierarchy, so the native view can measure its real width.
+For a complete first banner, use the integration library below **instead of the raw startup listeners in step 6**. It runs the same consent/initialization sequence and waits for a real layout. Keep `const Admob = require('ti.admob.unified')` from step 5. Choose one startup owner for the app.
 
-Reserve the host height before the ad arrives. Growing it from zero when `loaded` fires moves surrounding content after the screen appears. Give the host its expected height and a background colour that matches the screen, so the empty slot looks like a bottom margin:
+Reserve the host height before the ad arrives. Growing it from zero when `loaded` fires moves surrounding content after the screen appears. Give the host its expected height and a background color that matches the screen. The empty slot then looks like a bottom margin:
 
 ```js
-const bannerHost = Ti.UI.createView({
-  left: 0,
-  right: 0,
-  bottom: 0,
-  height: '50dp'
+// Classic Titanium; copy example/lib/ads.js into Resources/lib/ first.
+// Alloy: copy to app/lib/ads.js and use require('ads').
+const ads = require('lib/ads')
+const win = Ti.UI.createWindow({ backgroundColor: '#ffffff' })
+const content = Ti.UI.createView({ top: 0, left: 0, right: 0, bottom: 0 })
+const bannerHost = Ti.UI.createView({ left: 0, right: 0, bottom: 0, height: '50dp' })
+win.add(content)
+win.add(bannerHost)
+
+const banner = ads.createAdaptiveBanner({
+  host: bannerHost,
+  content,
+  reservedHeight: 50,
+  adUnitId: Admob.TEST_ADAPTIVE_BANNER,
+  adaptiveType: Admob.ADAPTIVE_ANCHORED
 })
 
-if (Admob.canRequestAds()) {
-  const banner = Admob.createAdaptiveBanner({
-    adUnitId: Admob.TEST_ADAPTIVE_BANNER,
-    adaptiveType: Admob.ADAPTIVE_ANCHORED,
-    width: Ti.UI.FILL
-  })
-
-  banner.addEventListener(Admob.AD_LOADED, event => {
-    bannerHost.height = `${event.height}dp`
-  })
-
-  bannerHost.add(banner)
-  banner.load()
-}
+win.addEventListener('close', event => {
+  if (!event._closeFromActivityForcedToDestroy) banner.destroy()
+})
+win.open()
+ads.start({ consent: { tagForUnderAgeOfConsent: false } }).catch(error => {
+  Ti.API.warn(`Ads startup failed: ${error.message || error}`)
+})
 ```
 
 A fixed `BANNER` is `50dp` and `FULLBANNER` is `60dp`, so a fixed-size placement can reserve its exact height. An adaptive banner reports its final height after loading. Reserve a suitable minimum, then adjust it in the loaded event to avoid growing the host from zero.
@@ -270,6 +310,10 @@ The module does not enforce the privacy gate inside ad proxies. The consuming ap
 - Installing mediation complements without configured ad sources adds SDK size and may delay startup while unused networks time out.
 - Publishing an app that is supposed to mediate without the selected complements installed, which must be checked through package inventories and Ad Inspector; an empty diagnostic map alone is not an installation check.
 
+## Before shipping
+
+Follow [Shipping an application](production.md) for production configuration, app-ads.txt, store disclosures, validation and troubleshooting.
+
 ## Example appearance
 
 For the classic playground, copy `example/app.js` and `example/semantic.colors.json` into `Resources/`, and `example/lib/ads.js` into `Resources/lib/`. The named colors provide light and dark variants for the content and window title. Keep the default DayNight Android theme so system icons follow the selected appearance. The sample keeps the title and status bars visible. Changing appearance does not require rebuilding the ad proxies or resetting the scroll position.

package/skills/ti-admob-unified/references/index.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.
 
 # ti.admob.unified documentation
 
@@ -12,7 +12,10 @@ This documentation describes the public JavaScript contract implemented by `ti.a
 4. [Privacy and initialization](privacy.md): implement UMP, ATT, the `canRequestAds()` gate, and privacy options correctly.
 5. [AdMob mediation](mediation.md): install selected complements, and configure and validate the five networks without platform-specific JavaScript.
 6. [Banner ads](banners.md): integrate standard or adaptive banners with real layout space and deterministic cleanup.
-7. [Fullscreen ads](fullscreen.md): interstitial, rewarded, and app open ads on one lifecycle, and when it is acceptable to interrupt the user.
+7. [Fullscreen ads](fullscreen.md): interstitial, rewarded, rewarded interstitial, and app open ads on one lifecycle, and when it is acceptable to interrupt the user.
+
+8. [Rewarded interstitial ads](rewarded-interstitial.md): introduce the reward, allow skipping, and handle actual earned rewards.
+9. [Shipping an application](production.md): production configuration, app verification, store disclosures, troubleshooting and validation.
 
 ## Reference
 

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

@@ -1,12 +1,12 @@
-> 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.
 
 # Integrating the module
 
-The native module manages Google Mobile Ads, UMP, portable proxy behavior and host lifecycle. The consuming application controls navigation and layout, including which screen is visible.
+The native module manages Google Mobile Ads, UMP, proxy behavior and host lifecycle on both platforms. Your application controls navigation, layout and which screen is visible.
 
 ## Recommended path
 
-Copy [`example/lib/ads.js`](../assets/example/lib/ads.js) into the consuming application's `lib/` directory. It covers every format implemented by version `1.0.0` and supplies the startup, cleanup and placement code shared by applications.
+Copy [`example/lib/ads.js`](../assets/example/lib/ads.js) to `app/lib/ads.js` in Alloy or `Resources/lib/ads.js` in Classic Titanium. It supports every format in version `1.0.0` and handles startup, placement lifecycle and cleanup.
 
 See [Copy-ready JavaScript library](library.md) for the API and examples, and [`example/library-usage.js`](../assets/example/library-usage.js) for a compact runnable integration.
 
@@ -33,10 +33,11 @@ An Android secondary window backed by another activity is already covered by the
 
 ```js
 banner.pause()
+showSameActivityOverlay()
 
-const child = Alloy.createController('child').getView()
-child.addEventListener('close', () => banner.resume())
-child.open()
+function onOverlayDismissed() {
+  banner.resume()
+}
 ```
 
 Pausing does not change `visible`, opacity, height, the host, or the loaded creative. Do not destroy/recreate on tab changes, focus/blur, or light/dark appearance changes. Rebuild only for a real configuration or authorization boundary, or after a recoverable failure.
@@ -83,3 +84,4 @@ When using the raw API, keep named event callbacks so every listener can be remo
 - [Banner ads](banners.md)
 - [Fullscreen ads](fullscreen.md)
 - [Privacy and initialization](privacy.md)
+- [Shipping an application](production.md)