@chipmobilesdk/rn-ads 0.7.0 → 0.8.0

package/lib/module/core/retryPolicy.js

@@ -0,0 +1,113 @@
+"use strict";
+
+/**
+ * Bounded, opt-in retry for failed loads (FR-134 – FR-139).
+ *
+ * 0.1.0 shipped no retry on purpose, and the reason was sound: every retry is a
+ * billable request, and only the app knows what that costs. But the practical
+ * result was that every app rewrote the same backoff loop, and the cost of
+ * writing it wrong landed on a bill. This ships the loop once, keeps it **off by
+ * default**, and makes every attempt visible.
+ *
+ * Three properties do the work:
+ *
+ *   - Off unless configured, so upgrading from 0.1.0 issues not one extra
+ *     request (FR-134, and the compat test proves it rather than asserting it).
+ *   - Only `retryable` errors. Configuration and consent errors, an unsupported
+ *     platform, and a disabled or undecided instance are states another attempt
+ *     cannot change, so retrying them would spend money on a certainty (FR-135).
+ *   - Every attempt is an event carrying the load cycle's correlation id, so a
+ *     bill can be reconciled against the event stream alone (FR-138).
+ *
+ * Pure — the schedule is computed here, the waiting happens in the instance's
+ * TimerSet so `dispose()` can prove it released everything.
+ */
+
+import { computeBackoff } from '@chipmobilesdk/rn-core';
+import { AdsConfigError } from "../diagnostics/errors.js";
+import { checkBand, DEFAULT_RETRY_POLICY, RETRY_BOUNDS } from "./timers.js";
+/**
+ * Validates one policy against the bounds.
+ *
+ * Out-of-range values **throw** rather than being clamped, matching the rule
+ * `timers.ts` already follows: silently clamping a request for ten retries down
+ * to five tells the app it configured something it did not, and the discrepancy
+ * only surfaces later as a bill that does not match the code.
+ *
+ * `label` names the offending field precisely — an error that says only
+ * "invalid retry policy" makes an integrator hunt through a catalog by hand.
+ */
+export function resolveRetryPolicy(policy, label) {
+  const maxRetries = checkBand(`${label}.maxRetries`, policy.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries, RETRY_BOUNDS.maxRetries, 'retry_out_of_bounds', '');
+  const initialDelayMs = checkBand(`${label}.initialDelayMs`, policy.initialDelayMs ?? DEFAULT_RETRY_POLICY.initialDelayMs, RETRY_BOUNDS.initialDelayMs, 'retry_out_of_bounds');
+  const maxDelayMs = checkBand(`${label}.maxDelayMs`, policy.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs, RETRY_BOUNDS.maxDelayMs, 'retry_out_of_bounds');
+  if (!Number.isInteger(maxRetries)) {
+    throw new AdsConfigError('retry_out_of_bounds', {
+      message: `${label}.maxRetries must be a whole number; received ${maxRetries}`
+    });
+  }
+  if (initialDelayMs > maxDelayMs) {
+    throw new AdsConfigError('retry_out_of_bounds', {
+      message: `${label}.initialDelayMs (${initialDelayMs}ms) exceeds ${label}.maxDelayMs (${maxDelayMs}ms); the first retry would already be past the ceiling`
+    });
+  }
+  return {
+    maxRetries,
+    initialDelayMs,
+    maxDelayMs
+  };
+}
+
+/**
+ * Resolves the effective policy for one placement.
+ *
+ * An override **replaces** the instance-wide policy rather than merging into it.
+ * Merging would mean the effective policy for a placement could not be read off
+ * the configuration — you would have to simulate the merge to know what it was —
+ * and a per-field merge makes "this placement retries twice" quietly depend on a
+ * value written somewhere else.
+ *
+ * Both are validated against the same bounds, so an override narrows behavior
+ * but can never exceed a ceiling (FR-136a).
+ */
+export function resolveEffectiveRetry(instancePolicy, placementPolicy, placementKey) {
+  if (placementPolicy === false) {
+    // Explicit opt-out for this placement alone. A banner retry is cheap and
+    // invisible; a rewarded retry happens with a user waiting on the other
+    // side of it. An app may reasonably want one and not the other.
+    return null;
+  }
+  if (placementPolicy) {
+    return resolveRetryPolicy(placementPolicy, `placements.${placementKey}.retry`);
+  }
+  if (instancePolicy) {
+    return resolveRetryPolicy(instancePolicy, 'retry');
+  }
+  // Nothing configured anywhere: retry is entirely off, which is the default
+  // and the only behavior a 0.1.0 consumer can observe (FR-134).
+  return null;
+}
+
+/**
+ * Delay before the given attempt. `attempt` is 1-based — the first retry is 1.
+ *
+ * Exponential with a fixed x2 multiplier and **no jitter**. Jitter exists to
+ * desynchronize a fleet of clients hitting one server; a single device retrying
+ * its own load has no herd to avoid. Leaving it out keeps "two retries, 2s then
+ * 4s" an exact assertion instead of a statistical one, which matters more here
+ * than a property that does not apply.
+ */
+export function delayForAttempt(policy, attempt) {
+  return computeBackoff(attempt, {
+    initialDelayMs: policy.initialDelayMs,
+    maxDelayMs: policy.maxDelayMs,
+    factor: 2,
+    jitter: 'none'
+  });
+}
+
+/** Whether another attempt is permitted. `attemptsMade` counts retries only. */
+export function canRetry(policy, attemptsMade) {
+  return policy !== null && attemptsMade < policy.maxRetries;
+}
+//# sourceMappingURL=retryPolicy.js.map

package/lib/module/core/retryPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["computeBackoff","AdsConfigError","checkBand","DEFAULT_RETRY_POLICY","RETRY_BOUNDS","resolveRetryPolicy","policy","label","maxRetries","initialDelayMs","maxDelayMs","Number","isInteger","message","resolveEffectiveRetry","instancePolicy","placementPolicy","placementKey","delayForAttempt","attempt","factor","jitter","canRetry","attemptsMade"],"sourceRoot":"../../../src","sources":["core/retryPolicy.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,cAAc,QAAQ,wBAAwB;AAEvD,SAASC,cAAc,QAAQ,0BAAuB;AACtD,SAASC,SAAS,EAAEC,oBAAoB,EAAEC,YAAY,QAAQ,aAAU;AASxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAACC,MAAmB,EAAEC,KAAa,EAAuB;EAC3F,MAAMC,UAAU,GAAGN,SAAS,CAC3B,GAAGK,KAAK,aAAa,EACrBD,MAAM,CAACE,UAAU,IAAIL,oBAAoB,CAACK,UAAU,EACpDJ,YAAY,CAACI,UAAU,EACvB,qBAAqB,EACrB,EACD,CAAC;EACD,MAAMC,cAAc,GAAGP,SAAS,CAC/B,GAAGK,KAAK,iBAAiB,EACzBD,MAAM,CAACG,cAAc,IAAIN,oBAAoB,CAACM,cAAc,EAC5DL,YAAY,CAACK,cAAc,EAC3B,qBACD,CAAC;EACD,MAAMC,UAAU,GAAGR,SAAS,CAC3B,GAAGK,KAAK,aAAa,EACrBD,MAAM,CAACI,UAAU,IAAIP,oBAAoB,CAACO,UAAU,EACpDN,YAAY,CAACM,UAAU,EACvB,qBACD,CAAC;EAED,IAAI,CAACC,MAAM,CAACC,SAAS,CAACJ,UAAU,CAAC,EAAE;IAClC,MAAM,IAAIP,cAAc,CAAC,qBAAqB,EAAE;MAC/CY,OAAO,EAAE,GAAGN,KAAK,gDAAgDC,UAAU;IAC5E,CAAC,CAAC;EACH;EACA,IAAIC,cAAc,GAAGC,UAAU,EAAE;IAChC,MAAM,IAAIT,cAAc,CAAC,qBAAqB,EAAE;MAC/CY,OAAO,EAAE,GAAGN,KAAK,oBAAoBE,cAAc,eAAeF,KAAK,gBAAgBG,UAAU;IAClG,CAAC,CAAC;EACH;EAEA,OAAO;IAAEF,UAAU;IAAEC,cAAc;IAAEC;EAAW,CAAC;AAClD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,qBAAqBA,CACpCC,cAAuC,EACvCC,eAAgD,EAChDC,YAAoB,EACS;EAC7B,IAAID,eAAe,KAAK,KAAK,EAAE;IAC9B;IACA;IACA;IACA,OAAO,IAAI;EACZ;EACA,IAAIA,eAAe,EAAE;IACpB,OAAOX,kBAAkB,CAACW,eAAe,EAAE,cAAcC,YAAY,QAAQ,CAAC;EAC/E;EACA,IAAIF,cAAc,EAAE;IACnB,OAAOV,kBAAkB,CAACU,cAAc,EAAE,OAAO,CAAC;EACnD;EACA;EACA;EACA,OAAO,IAAI;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,eAAeA,CAACZ,MAA2B,EAAEa,OAAe,EAAU;EACrF,OAAOnB,cAAc,CAACmB,OAAO,EAAE;IAC9BV,cAAc,EAAEH,MAAM,CAACG,cAAc;IACrCC,UAAU,EAAEJ,MAAM,CAACI,UAAU;IAC7BU,MAAM,EAAE,CAAC;IACTC,MAAM,EAAE;EACT,CAAC,CAAC;AACH;;AAEA;AACA,OAAO,SAASC,QAAQA,CAAChB,MAAkC,EAAEiB,YAAoB,EAAW;EAC3F,OAAOjB,MAAM,KAAK,IAAI,IAAIiB,YAAY,GAAGjB,MAAM,CAACE,UAAU;AAC3D","ignoreList":[]}

package/lib/module/core/rewardedSession.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * Rewarded session bookkeeping (FR-046 – FR-049).
+ *
+ * Two independent booleans, never derived from one another:
+ *
+ *              rewardConfirmed=false        rewardConfirmed=true
+ *   dismissed=false   in progress           reward emitted, awaiting dismissal
+ *   dismissed=true    dismissed_no_reward   earned
+ *
+ * The defect this exists to prevent is inferring "earned" from dismissal. It is
+ * the most common way rewarded integrations go wrong, and it is a direct revenue
+ * and fairness fault: a user who closed the ad after two seconds gets the prize,
+ * and the publisher is billed for nothing.
+ *
+ * Tracking two flags and deriving the outcome makes both callback orderings
+ * produce the same result *by construction* rather than by the provider
+ * happening to fire in a convenient order (SC-007).
+ */
+
+export function createRewardedSession() {
+  let confirmed = false;
+  let dismissed = false;
+  let earnedReward = null;
+  return {
+    confirmReward(reward) {
+      if (confirmed) {
+        return null;
+      }
+      confirmed = true;
+      earnedReward = reward;
+      return reward;
+    },
+    dismiss() {
+      if (dismissed) {
+        return false;
+      }
+      dismissed = true;
+      return true;
+    },
+    outcome() {
+      if (!dismissed) {
+        return 'in_progress';
+      }
+      // Read at dismissal time, so a reward that arrived first is honored and
+      // one that never arrives is not invented.
+      return confirmed ? 'earned' : 'dismissed_without_reward';
+    },
+    get rewardEarned() {
+      return confirmed;
+    },
+    get dismissed() {
+      return dismissed;
+    },
+    reward() {
+      return earnedReward;
+    }
+  };
+}
+//# sourceMappingURL=rewardedSession.js.map

package/lib/module/core/rewardedSession.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createRewardedSession","confirmed","dismissed","earnedReward","confirmReward","reward","dismiss","outcome","rewardEarned"],"sourceRoot":"../../../src","sources":["core/rewardedSession.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAsBA,OAAO,SAASA,qBAAqBA,CAAA,EAAoB;EACxD,IAAIC,SAAS,GAAG,KAAK;EACrB,IAAIC,SAAS,GAAG,KAAK;EACrB,IAAIC,YAA2B,GAAG,IAAI;EAEtC,OAAO;IACNC,aAAaA,CAACC,MAAM,EAAE;MACrB,IAAIJ,SAAS,EAAE;QACd,OAAO,IAAI;MACZ;MACAA,SAAS,GAAG,IAAI;MAChBE,YAAY,GAAGE,MAAM;MACrB,OAAOA,MAAM;IACd,CAAC;IAEDC,OAAOA,CAAA,EAAG;MACT,IAAIJ,SAAS,EAAE;QACd,OAAO,KAAK;MACb;MACAA,SAAS,GAAG,IAAI;MAChB,OAAO,IAAI;IACZ,CAAC;IAEDK,OAAOA,CAAA,EAAG;MACT,IAAI,CAACL,SAAS,EAAE;QACf,OAAO,aAAa;MACrB;MACA;MACA;MACA,OAAOD,SAAS,GAAG,QAAQ,GAAG,0BAA0B;IACzD,CAAC;IAED,IAAIO,YAAYA,CAAA,EAAG;MAClB,OAAOP,SAAS;IACjB,CAAC;IAED,IAAIC,SAASA,CAAA,EAAG;MACf,OAAOA,SAAS;IACjB,CAAC;IAEDG,MAAMA,CAAA,EAAG;MACR,OAAOF,YAAY;IACpB;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/core/timers.js

@@ -0,0 +1,150 @@
+"use strict";
+
+/**
+ * Timeout and staleness policy (FR-032, FR-034).
+ *
+ * Defaults and bounds live here rather than at each call site so there is one
+ * place to read what the package will wait for. Values outside a band are a
+ * configuration error rather than being silently clamped: silently clamping a
+ * one-second load timeout to five would mean the app is told it configured
+ * something it did not (FR-008).
+ */
+
+import { checkRange } from '@chipmobilesdk/rn-core';
+import { AdsConfigError } from "../diagnostics/errors.js";
+/** Comfortably longer than a normal fill on a slow mobile network, still bounded. */
+export const DEFAULT_LOAD_TIMEOUT_MS = 30_000;
+/** Generous for what is essentially a local presentation. */
+export const DEFAULT_SHOW_TIMEOUT_MS = 10_000;
+/**
+ * Google documents that a loaded ad object expires about an hour after load.
+ * Sixty minutes is the provider's own number; choosing anything else would be
+ * inventing a constraint (R7).
+ */
+export const DEFAULT_AD_VALIDITY_MS = 3_600_000;
+
+/**
+ * App-open's own window, deliberately shorter than the hour the other
+ * full-screen formats get (FR-130).
+ *
+ * Worth being explicit about why: Google expires app-open ads after **four
+ * hours**, which is *longer* than DEFAULT_AD_VALIDITY_MS, so the provider does
+ * not constrain this at all. The shorter window is a product decision. An
+ * app-open ad shows at the most prominent moment the app has, and a creative
+ * cached for an hour is stale by then; thirty minutes still spares a returning
+ * user the spinner of a cold load, which is both the worst app-open experience
+ * and the specific behavior store policy penalizes.
+ */
+export const DEFAULT_APP_OPEN_VALIDITY_MS = 1_800_000;
+
+/**
+ * How long `enabled: 'undecided'` may go unresolved before one warning fires.
+ *
+ * Ten seconds is several times a realistic worst case for the round trip this
+ * state exists to cover — asking a store whether the user owns an ad-removal
+ * entitlement — so an app doing the right thing essentially never trips it,
+ * while an app that forgot to resolve trips it inside a single QA session,
+ * which is where it needs to be caught (FR-119).
+ */
+export const DEFAULT_UNDECIDED_WARNING_MS = 10_000;
+export const LOAD_TIMEOUT_BOUNDS = {
+  min: 5_000,
+  max: 120_000
+};
+export const SHOW_TIMEOUT_BOUNDS = {
+  min: 5_000,
+  max: 30_000
+};
+export const AD_VALIDITY_BOUNDS = {
+  min: 60_000,
+  max: 3_600_000
+};
+/** Ceiling is one hour so app-open can never outlive the general window. */
+export const APP_OPEN_VALIDITY_BOUNDS = {
+  min: 60_000,
+  max: 3_600_000
+};
+export const UNDECIDED_WARNING_BOUNDS = {
+  min: 1_000,
+  max: 120_000
+};
+
+/**
+ * Retry defaults (FR-136).
+ *
+ * Two retries rather than more: each one is a billable request, and two covers
+ * the transient network failure and the momentary no-fill — the cases where
+ * trying again plausibly helps. A third mostly pays for a failure that was not
+ * transient. 2s then 4s keeps both inside a window the user still associates
+ * with the action that triggered the load.
+ */
+export const DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  initialDelayMs: 2_000,
+  maxDelayMs: 30_000
+};
+export const RETRY_BOUNDS = {
+  maxRetries: {
+    min: 1,
+    max: 5
+  },
+  initialDelayMs: {
+    min: 500,
+    max: 30_000
+  },
+  maxDelayMs: {
+    min: 1_000,
+    max: 60_000
+  }
+};
+
+/**
+ * Ad-originated return detection (FR-128).
+ *
+ * A background transition within CLICK_WINDOW of a click is attributed to a
+ * browser the ad opened. An absence longer than MAX_AWAY is no longer
+ * attributable to the ad — the user did something else in between. GRACE covers
+ * the moment right after the return, where an app-open show would otherwise
+ * fire, without outliving it and refusing a genuinely later show.
+ */
+export const AD_CLICK_WINDOW_MS = 2_000;
+export const AD_RETURN_MAX_AWAY_MS = 300_000;
+export const AD_RETURN_GRACE_MS = 10_000;
+/**
+ * `value` when it is inside `bounds`, else an `AdsConfigError` with `code`: each
+ * field reports the code its documentation names, so a retry policy out of bounds
+ * is `retry_out_of_bounds`, not a timeout's code (CORE-04, ADS-16).
+ */
+export function checkBand(label, value, bounds, code = 'timeout_out_of_bounds', unit = 'ms') {
+  return checkRange(label, value, bounds, message => new AdsConfigError(code, {
+    message
+  }), unit);
+}
+export function resolveTimeouts(input) {
+  const {
+    timeouts,
+    adValidityMs,
+    appOpenValidityMs,
+    undecidedWarningMs
+  } = input;
+  return {
+    load: checkBand('timeouts.load', timeouts?.load ?? DEFAULT_LOAD_TIMEOUT_MS, LOAD_TIMEOUT_BOUNDS),
+    show: checkBand('timeouts.show', timeouts?.show ?? DEFAULT_SHOW_TIMEOUT_MS, SHOW_TIMEOUT_BOUNDS),
+    adValidity: checkBand('adValidityMs', adValidityMs ?? DEFAULT_AD_VALIDITY_MS, AD_VALIDITY_BOUNDS),
+    appOpenValidity: checkBand('appOpenValidityMs', appOpenValidityMs ?? DEFAULT_APP_OPEN_VALIDITY_MS, APP_OPEN_VALIDITY_BOUNDS),
+    undecidedWarning: checkBand('undecidedWarningMs', undecidedWarningMs ?? DEFAULT_UNDECIDED_WARNING_MS, UNDECIDED_WARNING_BOUNDS)
+  };
+}
+
+/**
+ * How timers are scheduled, and the set that tracks them so `dispose()` can prove
+ * it released every one (SC-008): rn-core's, injectable so a test drives retry
+ * backoff, app-open expiry and the undecided warning by moving a clock.
+ */
+export { createTimerSet } from '@chipmobilesdk/rn-core';
+
+/** A loaded ad past its validity window must never be reported ready (FR-034). */
+export function isStale(loadedAtMs, nowMs, adValidityMs) {
+  return nowMs - loadedAtMs >= adValidityMs;
+}
+//# sourceMappingURL=timers.js.map

package/lib/module/core/timers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["checkRange","AdsConfigError","DEFAULT_LOAD_TIMEOUT_MS","DEFAULT_SHOW_TIMEOUT_MS","DEFAULT_AD_VALIDITY_MS","DEFAULT_APP_OPEN_VALIDITY_MS","DEFAULT_UNDECIDED_WARNING_MS","LOAD_TIMEOUT_BOUNDS","min","max","SHOW_TIMEOUT_BOUNDS","AD_VALIDITY_BOUNDS","APP_OPEN_VALIDITY_BOUNDS","UNDECIDED_WARNING_BOUNDS","DEFAULT_RETRY_POLICY","maxRetries","initialDelayMs","maxDelayMs","RETRY_BOUNDS","AD_CLICK_WINDOW_MS","AD_RETURN_MAX_AWAY_MS","AD_RETURN_GRACE_MS","checkBand","label","value","bounds","code","unit","message","resolveTimeouts","input","timeouts","adValidityMs","appOpenValidityMs","undecidedWarningMs","load","show","adValidity","appOpenValidity","undecidedWarning","createTimerSet","isStale","loadedAtMs","nowMs"],"sourceRoot":"../../../src","sources":["core/timers.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/diagnostics/correlation.js

@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * Correlation identifiers (FR-052).
+ *
+ * One value is minted when a load begins and carried by every event of that
+ * load/show cycle through its terminal event. It is what lets a consumer
+ * reconstruct a single ad's life from an event stream alone (SC-009) without the
+ * package having to store any history of its own.
+ *
+ * Opaque and monotonic per instance. Not a UUID, and deliberately not derived
+ * from anything about the device or the user — it exists to group events, and
+ * anything with more meaning than that would be a payload the package has
+ * promised not to carry (FR-021).
+ */
+
+export function createCorrelationIssuer(prefix = 'ad') {
+  let counter = 0;
+  // Distinguishes cycles from two instances in one process, which otherwise
+  // both start at 1 and would collide in a merged log.
+  const instance = Math.random().toString(36).slice(2, 8);
+  return {
+    next() {
+      counter += 1;
+      return `${prefix}-${instance}-${counter}`;
+    }
+  };
+}
+//# sourceMappingURL=correlation.js.map

package/lib/module/diagnostics/correlation.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createCorrelationIssuer","prefix","counter","instance","Math","random","toString","slice","next"],"sourceRoot":"../../../src","sources":["diagnostics/correlation.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA,OAAO,SAASA,uBAAuBA,CAACC,MAAM,GAAG,IAAI,EAAqB;EACzE,IAAIC,OAAO,GAAG,CAAC;EACf;EACA;EACA,MAAMC,QAAQ,GAAGC,IAAI,CAACC,MAAM,CAAC,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC,CAACC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;EAEvD,OAAO;IACNC,IAAIA,CAAA,EAAG;MACNN,OAAO,IAAI,CAAC;MACZ,OAAO,GAAGD,MAAM,IAAIE,QAAQ,IAAID,OAAO,EAAE;IAC1C;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/diagnostics/errors.js

@@ -0,0 +1,143 @@
+"use strict";
+
+/**
+ * Normalized error model (FR-053) and redaction (NFR-006).
+ *
+ * Codes are stable public API: renaming one is a breaking change under LIB-008.
+ * They exist so a consuming app branches on `code` and `retryable` rather than
+ * string-matching a provider message that may change under it.
+ *
+ * `cause` is a redacted string, never the provider's error object. A provider
+ * object reaching a consumer would be a contract leak (FR-002) and a potential
+ * carrier for identifiers the package promises never to emit (FR-021).
+ */
+
+import { SdkError, createRedactor } from '@chipmobilesdk/rn-core';
+/**
+ * "Retrying this operation could plausibly succeed" — not "retry immediately".
+ *
+ * 0.2.0 added an opt-in retry policy, and this set is what it is allowed to act
+ * on. Everything outside it is excluded deliberately: configuration and consent
+ * errors, an unsupported platform, and a disabled or undecided instance are all
+ * states another attempt cannot change, so retrying them would spend a billable
+ * request on a certainty (FR-135).
+ */
+const RETRYABLE = new Set(['no_fill', 'network_error', 'load_timeout', 'show_timeout', 'ad_expired', 'not_ready', 'busy', 'consumed', 'app_inactive', 'provider_error']);
+/** The package's error; an `SdkError` (`@chipmobilesdk/rn-core`) with `pkg: 'rn-ads'`. */
+export class AdsError extends SdkError {
+  /** Redacted provider detail. Never a provider object. */
+
+  constructor(code, options = {}) {
+    const cause = options.cause === undefined ? undefined : redact(options.cause);
+    super('rn-ads', code, {
+      message: options.message,
+      retryable: RETRYABLE.has(code),
+      redactedCause: cause
+    });
+    this.name = 'AdsError';
+    this.operation = options.operation;
+    this.placementKey = options.placementKey;
+    this.format = options.format;
+    this.cause = cause;
+  }
+}
+
+/**
+ * Configuration faults are thrown rather than returned, because they mean the
+ * app is wired wrong and no runtime result could describe a usable outcome.
+ * Every other failure in the package is a typed result (FR-004).
+ */
+export class AdsConfigError extends AdsError {
+  constructor(code, options = {}) {
+    super(code, {
+      ...options,
+      operation: options.operation ?? 'configure'
+    });
+    this.name = 'AdsConfigError';
+  }
+}
+export function isAdsError(value) {
+  return value instanceof AdsError;
+}
+
+/** An AdMob unit or app id. Redacted so a log never carries a live identifier. */
+const AD_UNIT_PATTERN = /ca-app-pub-\d+[~/]\d+/g;
+
+/**
+ * Keys dropped wholesale rather than pattern-matched, because their values are
+ * sensitive regardless of shape — a bare advertising id has no separator for a
+ * pattern to catch.
+ */
+const SENSITIVE_KEYS = ['adid', 'adUnitId', 'advertisingId', 'consent', 'consentString', 'gaid', 'idfa', 'tcString', 'token', 'userId'];
+
+/**
+ * rn-core's pattern redaction (URLs, JWTs, e-mail addresses, UUIDs, payload-sized
+ * runs) plus ad unit ids, with the keys above dropped. Provider messages are kept
+ * readable: they describe the failure, and every identifier in them is shaped.
+ */
+const redactor = createRedactor({
+  text: 'patterns',
+  patterns: [AD_UNIT_PATTERN],
+  dropKeys: SENSITIVE_KEYS,
+  maxDepth: 2
+});
+
+/**
+ * Reduces an arbitrary provider value to a safe string (FR-053, NFR-006).
+ *
+ * Returns a string rather than a structure on purpose: a redacted object still
+ * hands the consumer a reference into provider-owned memory, and the contract
+ * promises no provider object crosses the boundary. An `AdsError` reduces to its
+ * code.
+ */
+export function redact(value) {
+  return redactor.text(value);
+}
+
+/**
+ * Maps a provider failure onto the normalized taxonomy.
+ *
+ * The adapter's classification wins when it gave one (ADS-08). Otherwise the
+ * match is on substrings that have been stable across provider releases, and
+ * anything unrecognized becomes a retryable `provider_error` rather than being
+ * reshaped into a code that means something specific.
+ */
+export function normalizeProviderError(value, options = {}, kind) {
+  switch (kind) {
+    case 'no_fill':
+      return new AdsError('no_fill', {
+        ...options,
+        cause: value
+      });
+    case 'network':
+      return new AdsError('network_error', {
+        ...options,
+        cause: value
+      });
+    case 'rejected':
+      return new AdsError('provider_rejected', {
+        ...options,
+        cause: value
+      });
+    default:
+  }
+  const text = value instanceof Error ? value.message : String(value ?? '');
+  const lowered = text.toLowerCase();
+  if (lowered.includes('no-fill') || lowered.includes('no fill')) {
+    return new AdsError('no_fill', {
+      ...options,
+      cause: value
+    });
+  }
+  if (lowered.includes('network')) {
+    return new AdsError('network_error', {
+      ...options,
+      cause: value
+    });
+  }
+  return new AdsError('provider_error', {
+    ...options,
+    cause: value
+  });
+}
+//# sourceMappingURL=errors.js.map

package/lib/module/diagnostics/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SdkError","createRedactor","RETRYABLE","Set","AdsError","constructor","code","options","cause","undefined","redact","message","retryable","has","redactedCause","name","operation","placementKey","format","AdsConfigError","isAdsError","value","AD_UNIT_PATTERN","SENSITIVE_KEYS","redactor","text","patterns","dropKeys","maxDepth","normalizeProviderError","kind","Error","String","lowered","toLowerCase","includes"],"sourceRoot":"../../../src","sources":["diagnostics/errors.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/diagnostics/events.js

@@ -0,0 +1,128 @@
+"use strict";
+
+/**
+ * Normalized event model and emitter (FR-051, FR-052, FR-054, FR-056).
+ *
+ * Events are the package's only observability surface. They carry no provider
+ * object, no advertising identifier, no consent payload, and nothing that
+ * identifies a user — a consuming app forwards them to whatever logging or
+ * analytics it already has, and the package depends on none (FR-055).
+ *
+ * Dispatch iterates a snapshot of the listener set so subscribing or
+ * unsubscribing during a dispatch neither skips a listener nor double-invokes
+ * one. A listener that throws is caught and reported once; it cannot corrupt a
+ * state machine or starve another listener (FR-056).
+ */
+
+import { createDiagnosticChannel, createEmitter } from '@chipmobilesdk/rn-core';
+import { AdsError } from "./errors.js";
+
+/**
+ * `source` records whether the provider reported a true impression or the
+ * package derived one. Banners get a real impression callback; full-screen
+ * formats have none in the provider's event enum, so theirs is derived from the
+ * ad opening. Flattening that away would make the model quietly wrong for anyone
+ * reconciling these events against revenue reporting.
+ */
+
+/**
+ * Configuration problems worth telling the app about, all under one event type.
+ *
+ * One type rather than three because FR-132 forbids a parallel vocabulary, and
+ * because a consumer already routing `config_warning` into its logging should
+ * not have to subscribe again to keep seeing everything.
+ */
+
+/** Events that may occur at most once within one correlated cycle (FR-054). */
+const ONCE_PER_CYCLE = new Set(['loaded', 'display_started', 'impression', 'dismissed', 'reward_earned']);
+/**
+ * How many once-per-cycle keys the emitter remembers. A cycle's duplicates arrive
+ * within that cycle, so forgetting the oldest keys past this bound loses nothing,
+ * and memory stays flat however long the instance lives (CORE-12, ADS-05).
+ */
+const DEDUPE_CAPACITY = 256;
+
+/** Every delivered event also goes to the app's SDK sinks (`installSdkSink`, CORE-08). */
+const channel = createDiagnosticChannel('rn-ads');
+function severityOf(event) {
+  switch (event.type) {
+    case 'internal_error':
+      return 'error';
+    case 'load_failed':
+    case 'display_failed':
+    case 'config_warning':
+      return 'warn';
+    default:
+      return 'info';
+  }
+}
+
+/** What a sink may see: where and which cycle, and an error's code. Never a payload. */
+function contextOf(event) {
+  return {
+    ...(event.placementKey === undefined ? {} : {
+      placementKey: event.placementKey
+    }),
+    ...(event.format === undefined ? {} : {
+      format: event.format
+    }),
+    ...('error' in event ? {
+      code: event.error.code,
+      retryable: event.error.retryable
+    } : {})
+  };
+}
+export function createEventEmitter() {
+  // The event whose listeners are running, so a listener's failure is reported
+  // against the placement and cycle it broke (FR-056).
+  let dispatching = null;
+  const emitter = createEmitter({
+    onListenerError(error) {
+      emitter.emit({
+        type: 'internal_error',
+        timestamp: Date.now(),
+        placementKey: dispatching?.placementKey,
+        format: dispatching?.format,
+        correlationId: dispatching?.correlationId,
+        error: new AdsError('internal_error', {
+          message: 'consumer event listener threw',
+          cause: error
+        })
+      });
+    },
+    dedupe: {
+      key: event => event.correlationId && ONCE_PER_CYCLE.has(event.type) ? `${event.correlationId}:${event.type}` : undefined,
+      capacity: DEDUPE_CAPACITY
+    }
+  });
+  return {
+    emit(event) {
+      // After dispose, a late provider callback updates nothing and emits
+      // nothing (FR-035, SC-008); the rn-core emitter enforces both.
+      const previous = dispatching;
+      dispatching = event;
+      try {
+        if (emitter.emit(event)) {
+          channel.emit(event.type, severityOf(event), contextOf(event), event.correlationId);
+        }
+      } finally {
+        dispatching = previous;
+      }
+    },
+    // Idempotent unsubscribe (FR-005).
+    subscribe: listener => emitter.subscribe(listener),
+    dispose: () => emitter.dispose(),
+    listenerCount: () => emitter.listenerCount()
+  };
+}
+
+/** Normalizes a provider reward descriptor. No provider object crosses this (FR-047). */
+export function normalizeReward(value) {
+  const source = value ?? {};
+  const amount = Number(source.amount);
+  return {
+    type: typeof source.type === 'string' ? source.type : 'reward',
+    amount: Number.isFinite(amount) ? amount : 0
+  };
+}
+//# sourceMappingURL=events.js.map

package/lib/module/diagnostics/events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDiagnosticChannel","createEmitter","AdsError","ONCE_PER_CYCLE","Set","DEDUPE_CAPACITY","channel","severityOf","event","type","contextOf","placementKey","undefined","format","code","error","retryable","createEventEmitter","dispatching","emitter","onListenerError","emit","timestamp","Date","now","correlationId","message","cause","dedupe","key","has","capacity","previous","subscribe","listener","dispose","listenerCount","normalizeReward","value","source","amount","Number","isFinite"],"sourceRoot":"../../../src","sources":["diagnostics/events.ts"],"mappings":"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","ignoreList":[]}