@chipmobilesdk/rn-ads 0.7.0 → 0.8.0

package/lib/module/core/fullScreenLock.js

@@ -0,0 +1,44 @@
+"use strict";
+
+/**
+ * The single full-screen lock (FR-030).
+ *
+ * One token per instance, not per placement, because the constraint is about the
+ * screen rather than about any particular ad: two full-screen ads stacked on top
+ * of each other is a broken app regardless of which placements produced them.
+ *
+ * **There is no queue.** A refused show is refused, and the caller is told so
+ * immediately. Queueing would mean an ad opening at a moment the app never
+ * chose — seconds later, on a different screen, after the user moved on — which
+ * is exactly the behavior FR-045 forbids the package from deciding on its own.
+ */
+
+export function createFullScreenLock() {
+  let held = null;
+  return {
+    acquire(placementKey) {
+      if (held !== null) {
+        return false;
+      }
+      held = placementKey;
+      return true;
+    },
+    release(placementKey) {
+      // Guarded so a late dismissal from an earlier ad cannot release the
+      // lock out from under the ad currently on screen.
+      if (held === placementKey) {
+        held = null;
+      }
+    },
+    holder() {
+      return held;
+    },
+    isHeld() {
+      return held !== null;
+    },
+    reset() {
+      held = null;
+    }
+  };
+}
+//# sourceMappingURL=fullScreenLock.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFullScreenLock","held","acquire","placementKey","release","holder","isHeld","reset"],"sourceRoot":"../../../src","sources":["core/fullScreenLock.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAcA,OAAO,SAASA,oBAAoBA,CAAA,EAAmB;EACtD,IAAIC,IAAmB,GAAG,IAAI;EAE9B,OAAO;IACNC,OAAOA,CAACC,YAAY,EAAE;MACrB,IAAIF,IAAI,KAAK,IAAI,EAAE;QAClB,OAAO,KAAK;MACb;MACAA,IAAI,GAAGE,YAAY;MACnB,OAAO,IAAI;IACZ,CAAC;IACDC,OAAOA,CAACD,YAAY,EAAE;MACrB;MACA;MACA,IAAIF,IAAI,KAAKE,YAAY,EAAE;QAC1BF,IAAI,GAAG,IAAI;MACZ;IACD,CAAC;IACDI,MAAMA,CAAA,EAAG;MACR,OAAOJ,IAAI;IACZ,CAAC;IACDK,MAAMA,CAAA,EAAG;MACR,OAAOL,IAAI,KAAK,IAAI;IACrB,CAAC;IACDM,KAAKA,CAAA,EAAG;MACPN,IAAI,GAAG,IAAI;IACZ;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/core/gates.js

@@ -0,0 +1,91 @@
+"use strict";
+
+/**
+ * The one place that decides why a request was refused (FR-140, FR-141).
+ *
+ * After 0.2.0 there are three independent ways to be blocked — platform
+ * availability, the app's three-state enable flag, and consent — and they can be
+ * closed in any combination. A precedence spread across four call sites is not a
+ * precedence; it is four coincidences that currently agree. So every refusal
+ * path in the package routes through `evaluateGates` and nothing else compares
+ * gate state.
+ *
+ * **The order is availability, then enablement, then consent — most immovable
+ * first.** Two reasons, and they agree:
+ *
+ * 1. It is what 0.1.0 already did. `initMachine`'s BLOCK transition is refused
+ *    outright when the status is `disabled` or `unavailable`, so consent was
+ *    already the weakest of the three. Any other order would change observable
+ *    behavior for a consumer who configured nothing new.
+ * 2. It is the most useful order for whoever is debugging. An unsupported
+ *    platform makes the other two unfixable, so reporting "consent required" on
+ *    a platform that can never serve an ad sends a developer off to build a flow
+ *    that will never help. Reporting `unavailable` to an app that has also
+ *    disabled ads costs nothing — that app was not going to show an ad either
+ *    way.
+ *
+ * The accepted cost is that an app which *deliberately* disabled ads on an
+ * unsupported platform is told about the platform rather than about its own
+ * switch. That is fine: neither answer changes what the app does next.
+ *
+ * Pure. No provider, no React, no I/O — which is what lets the full combination
+ * table be a unit test rather than an integration one.
+ */
+
+/** What the consent flow contributes, or `null` when the app never opted in. */
+
+export function evaluateGates(input) {
+  // 1. Availability. Nothing downstream can be fixed while this is closed.
+  if (!input.available.ok) {
+    return {
+      allowed: false,
+      kind: 'unavailable',
+      reason: input.available.reason
+    };
+  }
+
+  // 2. Enablement. `undecided` is reported separately from `disabled` because
+  // that distinction is the entire reason the third state exists (FR-116).
+  if (input.enablement === 'disabled') {
+    return {
+      allowed: false,
+      kind: 'disabled'
+    };
+  }
+  if (input.enablement === 'undecided') {
+    return {
+      allowed: false,
+      kind: 'undecided'
+    };
+  }
+
+  // 3. Consent, whose two inputs combine as most-restrictive-wins (FR-105a).
+  //
+  // Requesting is permitted only when both permit it, and neither can widen
+  // what the other allows. The case this protects is an app that obtained
+  // consent successfully but independently blocked ads for a reason of its own
+  // — a reason FR-120 forbids the package from knowing, and therefore one it
+  // must never overrule.
+  //
+  // When both are closed the app's own gate is reported: it is the input the
+  // app controls directly, and the flow's state is separately readable through
+  // `consent.getState()` at any time.
+  if (!input.appGate.permitted) {
+    return {
+      allowed: false,
+      kind: 'blocked',
+      reason: input.appGate.reason
+    };
+  }
+  if (input.consentGate && !input.consentGate.permitted) {
+    return {
+      allowed: false,
+      kind: 'blocked',
+      reason: input.consentGate.reason
+    };
+  }
+  return {
+    allowed: true
+  };
+}
+//# sourceMappingURL=gates.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["evaluateGates","input","available","ok","allowed","kind","reason","enablement","appGate","permitted","consentGate"],"sourceRoot":"../../../src","sources":["core/gates.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;;AAyBA,OAAO,SAASA,aAAaA,CAACC,KAAgB,EAAgB;EAC7D;EACA,IAAI,CAACA,KAAK,CAACC,SAAS,CAACC,EAAE,EAAE;IACxB,OAAO;MAAEC,OAAO,EAAE,KAAK;MAAEC,IAAI,EAAE,aAAa;MAAEC,MAAM,EAAEL,KAAK,CAACC,SAAS,CAACI;IAAO,CAAC;EAC/E;;EAEA;EACA;EACA,IAAIL,KAAK,CAACM,UAAU,KAAK,UAAU,EAAE;IACpC,OAAO;MAAEH,OAAO,EAAE,KAAK;MAAEC,IAAI,EAAE;IAAW,CAAC;EAC5C;EACA,IAAIJ,KAAK,CAACM,UAAU,KAAK,WAAW,EAAE;IACrC,OAAO;MAAEH,OAAO,EAAE,KAAK;MAAEC,IAAI,EAAE;IAAY,CAAC;EAC7C;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,IAAI,CAACJ,KAAK,CAACO,OAAO,CAACC,SAAS,EAAE;IAC7B,OAAO;MAAEL,OAAO,EAAE,KAAK;MAAEC,IAAI,EAAE,SAAS;MAAEC,MAAM,EAAEL,KAAK,CAACO,OAAO,CAACF;IAAO,CAAC;EACzE;EACA,IAAIL,KAAK,CAACS,WAAW,IAAI,CAACT,KAAK,CAACS,WAAW,CAACD,SAAS,EAAE;IACtD,OAAO;MAAEL,OAAO,EAAE,KAAK;MAAEC,IAAI,EAAE,SAAS;MAAEC,MAAM,EAAEL,KAAK,CAACS,WAAW,CAACJ;IAAO,CAAC;EAC7E;EAEA,OAAO;IAAEF,OAAO,EAAE;EAAK,CAAC;AACzB","ignoreList":[]}

package/lib/module/core/initMachine.js

@@ -0,0 +1,152 @@
+"use strict";
+
+/**
+ * Initialization state machine (FR-022 – FR-025).
+ *
+ * Pure and synchronous: it decides what a transition means; the instance
+ * performs the I/O. That split is what makes every rule in data-model.md §3.1
+ * testable without a provider.
+ *
+ * The load-bearing invariant is idempotence. Three consumers calling
+ * `initialize()` at once must produce exactly one native initialization and
+ * three identical results (SC-005) — the instance holds one in-flight promise,
+ * and this machine refuses to leave `initializing` for anything but a terminal
+ * outcome.
+ */
+
+export const initialInit = {
+  status: 'not_started',
+  blockReason: null,
+  unavailableReason: null,
+  error: null,
+  resumeTo: null
+};
+function at(status, patch = {}) {
+  return {
+    ...initialInit,
+    status,
+    ...patch
+  };
+}
+
+/**
+ * States that behave as "switched off" for everything downstream.
+ *
+ * `undecided` is grouped with `disabled` for request handling — neither may
+ * reach the provider — while staying a distinct reported status, which is the
+ * only reason the third state is worth having (FR-115, FR-116).
+ */
+function isSwitchedOff(status) {
+  return status === 'disabled' || status === 'undecided';
+}
+
+/**
+ * States a fresh start may leave from.
+ *
+ * `blocked` is included because resolving consent and trying again is the
+ * documented, expected flow (FR-019). `initializing` is excluded because that is
+ * exactly the race idempotence exists to prevent. `ready` is excluded because
+ * re-initializing an initialized provider is what FR-022 forbids.
+ */
+const STARTABLE = new Set(['not_started', 'blocked', 'failed']);
+export function canStart(status) {
+  return STARTABLE.has(status);
+}
+
+/** Only `ready` may issue requests. Everything else is a refusal with a reason. */
+export function canRequest(status) {
+  return status === 'ready';
+}
+
+/**
+ * What to remember when switching off.
+ *
+ * Only a completed initialization is worth keeping. A `blocked` or `failed`
+ * instance has nothing to resume to, and remembering `initializing` would mean
+ * resuming into a state whose in-flight operation was already abandoned.
+ */
+function rememberFor(state) {
+  if (state.status === 'ready') {
+    return 'ready';
+  }
+  // Preserve an earlier memory across an off -> off transition, so
+  // disable -> undecided -> enable still resumes.
+  return isSwitchedOff(state.status) ? state.resumeTo : null;
+}
+export function initReducer(state, event) {
+  switch (event.type) {
+    case 'START':
+      // `disabled`, `undecided`, and `unavailable` all refuse a start:
+      // nothing may reach the provider while any of them holds.
+      if (isSwitchedOff(state.status) || state.status === 'unavailable') {
+        return state;
+      }
+      return canStart(state.status) ? at('initializing') : state;
+    case 'BLOCK':
+      // Consent is the weakest of the three gates, so it never overwrites a
+      // stronger one. This guard is the 0.1.0 behavior that settled the
+      // precedence question: availability and enablement already outranked
+      // consent, and FR-140 makes that explicit rather than inventing it.
+      if (isSwitchedOff(state.status) || state.status === 'unavailable') {
+        return state;
+      }
+      // A gate withdrawn after initialization does not un-initialize the
+      // provider — it stops requests. Reporting `blocked` is what the app
+      // acts on; the native SDK stays as it is.
+      return at('blocked', {
+        blockReason: event.reason
+      });
+    case 'UNAVAILABLE':
+      return at('unavailable', {
+        unavailableReason: event.reason
+      });
+    case 'DISABLE':
+      // Availability outranks enablement (FR-140a). 0.1.0 left these two
+      // unguarded against each other, so whichever arrived last won and the
+      // reported reason depended on timing — exactly the incidental ordering
+      // FR-140 forbids. Availability winning is deterministic and is the
+      // more useful answer: an unsupported platform cannot be fixed by
+      // turning ads back on.
+      if (state.status === 'unavailable') {
+        return state;
+      }
+      return at('disabled', {
+        resumeTo: rememberFor(state)
+      });
+    case 'UNDECIDE':
+      if (state.status === 'unavailable') {
+        return state;
+      }
+      return at('undecided', {
+        resumeTo: rememberFor(state)
+      });
+    case 'ENABLE':
+      {
+        if (!isSwitchedOff(state.status)) {
+          return state;
+        }
+        // Resume only from a completed initialization. Anything else has no
+        // ready state to return to, and claiming one would put the instance in
+        // a state it never actually reached — so the caller is told to
+        // initialize instead, explicitly (FR-121).
+        return state.resumeTo === 'ready' ? at('ready') : at('not_started');
+      }
+    case 'SUCCEED':
+      // Only a transition out of `initializing` counts. A `SUCCEED` arriving
+      // after a disable or a block is a late callback, and honoring it would
+      // resurrect a state the app deliberately left.
+      return state.status === 'initializing' ? at('ready') : state;
+    case 'RESUME':
+      // Same guard as START, for the same reason: `disabled`, `undecided` and
+      // `unavailable` are not left by a gate reopening. `canStart` excludes
+      // them, and `initializing`, whose own outcome is still on its way.
+      return canStart(state.status) ? at('ready') : state;
+    case 'FAIL':
+      return state.status === 'initializing' ? at('failed', {
+        error: event.error
+      }) : state;
+    default:
+      return state;
+  }
+}
+//# sourceMappingURL=initMachine.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["initialInit","status","blockReason","unavailableReason","error","resumeTo","at","patch","isSwitchedOff","STARTABLE","Set","canStart","has","canRequest","rememberFor","state","initReducer","event","type","reason"],"sourceRoot":"../../../src","sources":["core/initMachine.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/instance/consent.js

@@ -0,0 +1,151 @@
+"use strict";
+
+/**
+ * The optional consent capability (FR-101 – FR-113, FR-150 – FR-157).
+ *
+ * Every outcome feeds the gate through `reevaluate`, so the app never wires
+ * consent to requests by hand (FR-105), and a failure is never a grant
+ * (FR-106).
+ */
+
+import { buildConsentOptions, INITIAL_CONSENT, needsForm, normalizeConsent, runConsentStep, toConsentError } from "../consentFlow.js";
+export function createConsentApi(context, reevaluate) {
+  const {
+    state,
+    engine,
+    resolved
+  } = context;
+
+  /** Applies an outcome unless the instance went away while it was pending. */
+  async function settle(next) {
+    if (state.disposed) {
+      return state.consent;
+    }
+    context.setConsent(next);
+    await reevaluate();
+    return next;
+  }
+  return {
+    async requestInfoUpdate() {
+      if (state.disposed) {
+        return state.consent;
+      }
+      // Marks the flow as in use. Until this is called the gate sees no consent
+      // input at all, which is how an app that supplies its own gate keeps
+      // 0.1.0 behavior without opting out of anything (FR-102).
+      state.consentStarted = true;
+      if (resolved.consentTesting?.resetOnStart) {
+        try {
+          engine.consent.reset();
+        } catch {
+          // A failed reset must not abort the update; the flow continues
+          // against whatever state is stored.
+        }
+      }
+      const next = await runConsentStep(() => engine.consent.requestInfoUpdate(buildConsentOptions(resolved.consentTesting, state.currentPrivacy?.underAgeOfConsent, resolved.testDeviceIds)), 'consent information update failed');
+      return settle(next);
+    },
+    async showFormIfRequired() {
+      if (state.disposed) {
+        return state.consent;
+      }
+      state.consentStarted = true;
+      // Nothing to present is not an error: a region that does not require
+      // consent is the normal case (FR-107). Nor is a privacy options form
+      // already on screen — one provider form at a time.
+      if (!needsForm(state.consent) || state.privacyOptionsFormOpen) {
+        return state.consent;
+      }
+      state.consentFormsOpen += 1;
+      let next;
+      try {
+        next = await runConsentStep(() => engine.consent.showFormIfRequired(), 'consent form failed');
+      } finally {
+        state.consentFormsOpen -= 1;
+      }
+      return settle(next);
+    },
+    async showPrivacyOptionsForm() {
+      // The refusals, most immovable first — the same reading order as the
+      // request gates, so the answer is the most useful one.
+      if (state.disposed) {
+        return {
+          status: 'unavailable',
+          reason: 'provider_missing'
+        };
+      }
+      if (!engine.isAvailable()) {
+        return {
+          status: 'unavailable',
+          reason: 'unsupported_platform'
+        };
+      }
+      if (state.privacyOptionsFormOpen || state.consentFormsOpen > 0) {
+        return {
+          status: 'busy'
+        };
+      }
+      if (state.consent.privacyOptionsRequirement === 'unknown') {
+        return {
+          status: 'info_update_required'
+        };
+      }
+      if (state.consent.privacyOptionsRequirement !== 'required') {
+        // The provider's verdict, not a region guess of ours (FR-150).
+        return {
+          status: 'not_required'
+        };
+      }
+      state.privacyOptionsFormOpen = true;
+      let next;
+      let failure = null;
+      try {
+        next = normalizeConsent(await engine.consent.showPrivacyOptionsForm());
+      } catch (cause) {
+        failure = toConsentError(cause, 'privacy options form failed');
+        // The form did not complete, so the stored decision is the provider's
+        // to report — ask rather than assume. Collapsing to `error` the way a
+        // failed first-time form does would revoke a consent the user never
+        // changed. If the provider cannot answer either, the gate closes: a
+        // failure is never consent (FR-106).
+        next = state.disposed ? state.consent : await runConsentStep(() => engine.consent.getInfo(), 'consent information could not be read after the privacy options form failed');
+      } finally {
+        state.privacyOptionsFormOpen = false;
+      }
+      // dispose() during the form: the form stays until the user closes it, but
+      // its outcome reaches nobody (FR-157).
+      if (state.disposed) {
+        return {
+          status: 'unavailable',
+          reason: 'provider_missing'
+        };
+      }
+      await settle(next);
+      return failure ? {
+        status: 'failed',
+        error: failure
+      } : {
+        status: 'shown',
+        consent: next
+      };
+    },
+    getState() {
+      return state.consent;
+    },
+    subscribe: listener => context.consentListeners.add(listener),
+    async reset() {
+      // Config validation strips the testing tools in production, so this is
+      // inert there without a check here (FR-113).
+      if (state.disposed || !resolved.consentTesting) {
+        return;
+      }
+      try {
+        engine.consent.reset();
+      } catch {
+        // The stored state is the provider's; a failed reset leaves it as it was.
+      }
+      context.setConsent(INITIAL_CONSENT);
+    }
+  };
+}
+//# sourceMappingURL=consent.js.map

package/lib/module/core/instance/consent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["buildConsentOptions","INITIAL_CONSENT","needsForm","normalizeConsent","runConsentStep","toConsentError","createConsentApi","context","reevaluate","state","engine","resolved","settle","next","disposed","consent","setConsent","requestInfoUpdate","consentStarted","consentTesting","resetOnStart","reset","currentPrivacy","underAgeOfConsent","testDeviceIds","showFormIfRequired","privacyOptionsFormOpen","consentFormsOpen","showPrivacyOptionsForm","status","reason","isAvailable","privacyOptionsRequirement","failure","cause","getInfo","error","getState","subscribe","listener","consentListeners","add"],"sourceRoot":"../../../../src","sources":["core/instance/consent.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/instance/context.js

@@ -0,0 +1,212 @@
+"use strict";
+
+/**
+ * What every part of an ads instance shares (ADS-10).
+ *
+ * 0.5.0 kept all of this as `let` bindings inside one 1,500-line closure, and
+ * each path that closed a gate re-implemented its own teardown — which is how
+ * ADS-01, ADS-02 and ADS-04 happened. Here the state is one object, the
+ * placement runtimes are one map, and the helpers that change them are defined
+ * once. The controllers (gate, init, load, show, consent, banner) each take this
+ * context and nothing else.
+ */
+import { createListenerSet, isDevBuild as detectDevBuild } from '@chipmobilesdk/rn-core';
+import { validateConfig } from "../../config/validate.js";
+import { createCorrelationIssuer } from "../../diagnostics/correlation.js";
+import { AdsError } from "../../diagnostics/errors.js";
+import { createEventEmitter } from "../../diagnostics/events.js";
+import { createAdOriginatedTracker } from "../adOriginatedReturn.js";
+import { INITIAL_CONSENT } from "../consentFlow.js";
+import { createFullScreenLock } from "../fullScreenLock.js";
+import { initialInit, initReducer } from "../initMachine.js";
+import { initialPlacement, placementReducer } from "../placementMachine.js";
+import { createRequestThrottle } from "../requestThrottle.js";
+import { createTimerSet } from "../timers.js";
+
+/** Everything about the instance that changes after creation. */
+
+export function createInstanceContext(config, options, defaultEngine) {
+  const isDevBuild = options.isDevBuild ?? detectDevBuild();
+  const now = options.now ?? (() => Date.now());
+
+  // Throws on a structural fault or the FR-012 fail-closed case. Deliberately
+  // before anything else: a misconfigured instance should not exist at all.
+  const resolved = validateConfig(config, {
+    isDevBuild
+  });
+  const engine = options.engine ?? defaultEngine();
+  const events = createEventEmitter();
+
+  /**
+   * Status, consent and placement listeners are consumer code. A failure is
+   * isolated from the rest and reported the way an event listener's is: as an
+   * `internal_error` event (FR-056).
+   */
+  const listenerOptions = {
+    onListenerError(error) {
+      events.emit({
+        type: 'internal_error',
+        timestamp: now(),
+        error: new AdsError('internal_error', {
+          message: 'consumer listener threw',
+          cause: error
+        })
+      });
+    }
+  };
+  const placements = new Map();
+  for (const key of resolved.placements.keys()) {
+    placements.set(key, {
+      snapshot: initialPlacement,
+      correlationId: null,
+      dismissed: false,
+      handle: null,
+      unsubscribeEngine: null,
+      inFlightLoad: null,
+      abortLoad: null,
+      cancelLoadTimer: null,
+      cancelShowTimer: null,
+      rewarded: null,
+      listeners: createListenerSet(listenerOptions),
+      retryAttempts: 0,
+      cancelRetry: null
+    });
+  }
+  const state = {
+    /**
+     * An instance told it is `undecided` says so from the moment it exists, or
+     * it would report `not_started` until `initialize()` runs — which looks like
+     * a disabled instance at exactly the point an app decides whether to reserve
+     * the banner's space (FR-116). `disabled` keeps 0.1.0's `not_started`
+     * (BC-004).
+     */
+    init: resolved.enablement === 'undecided' ? initReducer(initialInit, {
+      type: 'UNDECIDE'
+    }) : initialInit,
+    enablement: resolved.enablement,
+    appActive: true,
+    consent: INITIAL_CONSENT,
+    consentStarted: false,
+    consentFormsOpen: 0,
+    privacyOptionsFormOpen: false,
+    providerInitialized: false,
+    undecidedWarned: false,
+    cancelUndecidedTimer: null,
+    appliedPrivacy: null,
+    currentPrivacy: null,
+    inFlightInit: null,
+    disposed: false,
+    warnedSubstitution: false
+  };
+  const statusListeners = createListenerSet(listenerOptions);
+  const consentListeners = createListenerSet(listenerOptions);
+  const context = {
+    resolved,
+    engine,
+    now,
+    events,
+    correlation: createCorrelationIssuer(),
+    requestThrottle: createRequestThrottle(now),
+    timers: createTimerSet(options.scheduler),
+    lock: createFullScreenLock(),
+    adReturn: createAdOriginatedTracker(),
+    state,
+    placements,
+    statusListeners,
+    consentListeners,
+    placement(key) {
+      const runtime = placements.get(key);
+      const definition = resolved.placements.get(key);
+      return runtime && definition ? {
+        runtime,
+        definition
+      } : null;
+    },
+    setInit(next) {
+      const previous = state.init;
+      state.init = next;
+      if (next === previous || next.status === previous.status) {
+        return;
+      }
+      events.emit({
+        type: 'initialization',
+        timestamp: now(),
+        status: next.status,
+        retryable: next.error?.retryable
+      });
+      statusListeners.notify(next.status);
+    },
+    setPlacement(key, next) {
+      const runtime = placements.get(key);
+      if (!runtime) {
+        return;
+      }
+      const changed = runtime.snapshot.state !== next.state;
+      runtime.snapshot = next;
+      if (changed) {
+        runtime.listeners.notify(next.state);
+      }
+    },
+    dispatchPlacement(key, event) {
+      const found = context.placement(key);
+      if (found) {
+        context.setPlacement(key, placementReducer(found.runtime.snapshot, event, found.definition.format));
+      }
+    },
+    setConsent(next) {
+      state.consent = next;
+      consentListeners.notify(next);
+    },
+    releasePlacementResources(key) {
+      const runtime = placements.get(key);
+      if (!runtime) {
+        return;
+      }
+      runtime.cancelLoadTimer?.();
+      runtime.cancelLoadTimer = null;
+      runtime.cancelShowTimer?.();
+      runtime.cancelShowTimer = null;
+      runtime.unsubscribeEngine?.();
+      runtime.unsubscribeEngine = null;
+      if (runtime.handle) {
+        engine.dispose(runtime.handle);
+        runtime.handle = null;
+      }
+      runtime.inFlightLoad = null;
+      runtime.abortLoad = null;
+      runtime.rewarded = null;
+      runtime.cancelRetry?.();
+      runtime.cancelRetry = null;
+    },
+    emitRefusal(operation, result, placementKey, format) {
+      if (result.status === 'disabled' || result.status === 'undecided') {
+        // `undecided` reuses the `disabled` event: for an observer of the
+        // stream the fact is the same — no request was made — and the
+        // distinction is carried by the typed result and the init status.
+        events.emit({
+          type: 'disabled',
+          timestamp: now(),
+          operation,
+          placementKey,
+          format
+        });
+        return;
+      }
+      events.emit({
+        type: 'unavailable',
+        timestamp: now(),
+        operation,
+        placementKey,
+        format,
+        reason: result.reason
+      });
+    }
+  };
+  return context;
+}
+
+/** App-open expires on its own, shorter window (FR-130). */
+export function validityFor(context, format) {
+  return format === 'app_open' ? context.resolved.timeouts.appOpenValidity : context.resolved.timeouts.adValidity;
+}
+//# sourceMappingURL=context.js.map