@amplytools/react-native-amply-sdk 0.14.0 → 0.15.1

package/docs/ARCHITECTURE.md

@@ -150,6 +150,7 @@ export interface Spec extends TurboModule {
   isInitialized(): boolean;
   track(payload: TrackEventPayload): Promise<void>;
   getRecentEvents(limit: number): Promise<EventRecord[]>;
+  getLastCampaignTouch(withinMs: number): Promise<CampaignTouchPayload | null>;
   getDataSetSnapshot(type: DataSetType): Promise<DataSetSnapshot>;
   setUserId(userId: string | null): void;
   setAppLanguage(tag: string | null): void;
@@ -597,20 +598,29 @@ yarn codegen
 #### **2. JavaScript Bundling (TypeScript → JS)**
 
 ```bash
-yarn build
-# Internally runs: expo-module build (which uses tsup)
+yarn build:package
+# rm -rf dist plugin/build, then expo-module build (tsc), expo-module build plugin,
+# tsc -p tsconfig.cjs.json, then scripts/check-package.js
 ```
 
 **What it does:**
-- Compiles TypeScript to JavaScript using `tsup`
-- Generates ES Modules (`.mjs`) and CommonJS (`.js`)
-- Type checks via `tsc` → generates `.d.ts` files
-- Outputs to `dist/` directory
+- `expo-module build` runs `tsc` with `tsconfig.json`: ES modules plus `.d.ts` into `dist/src/` (and `dist/plugin/`)
+- `expo-module build plugin` compiles the Expo plugin into `plugin/build/` (what `app.plugin.js` requires)
+- `tsc -p tsconfig.cjs.json` writes a CommonJS copy of `src/` into `dist/cjs/`
+- `scripts/check-package.js` checks the tarball `npm pack` would produce (below)
 
 **Outputs:**
-- `dist/index.js` – CommonJS entry point (consumers importing from Node)
-- `dist/index.mjs` – ES Module entry point (bundlers like Metro)
-- `dist/src/**/*.d.ts` – TypeScript declarations
+- `dist/cjs/index.js` – `main`, CommonJS (Jest and anything else that `require`s the package)
+- `dist/src/index.js` – `module`, ES modules (bundlers)
+- `src/index.ts` – `react-native`; Metro compiles the source itself
+- `dist/src/**/*.d.ts` – TypeScript declarations (`types`)
+
+**The package check.** Until 0.15.0 `main` pointed at `dist/index.js`, a bundle from an early tsup build
+that no later build rewrote or removed, so every release shipped the API of late 2025. Metro never
+noticed (it reads `react-native`). `check-package.js` fails when an entry in package.json is not in the
+tarball, when `main` does not export exactly what `src/index.ts` exports, or when a compiled file in the
+tarball has no source file. `yarn test` runs it, and release.sh runs it before the release commit and
+again right before `npm publish`.
 
 **When to run:**
 - After changing any TypeScript/JavaScript code
@@ -703,25 +713,23 @@ When you link the SDK to example apps, these are called automatically:
 ### Script Dependency Chain
 
 ```
-developer runs yarn build
+developer runs yarn build:package
+        ↓
+rm -rf dist plugin/build (no leftovers from an older build can ship)
         ↓
-expo-module build (wrapper script)
+expo-module build → tsc → dist/src/** (ESM + .d.ts), dist/plugin/**
         ↓
-tsup (TypeScript bundler)
-  ├─→ tsc (compile TS)
-  ├─→ writes dist/index.js (CommonJS)
-  └─→ writes dist/index.mjs (ES Module)
+expo-module build plugin → plugin/build/**
         ↓
-tsc --project tsconfig.build.json
-  └─→ writes dist/src/**/*.d.ts (type declarations)
+tsc -p tsconfig.cjs.json → dist/cjs/** (CommonJS, main)
         ↓
-dist/ is ready for consumption
+scripts/check-package.js (entries ship, main == src/index.ts exports, no orphans)
 ```
 
 ### Why So Many Compile Steps?
 
 1. **Codegen** – Generates native stubs (Java, C++, ObjC++)
-2. **JS bundling** – Converts TS to JS for Node and Metro
+2. **JS compile** – Converts TS to JS for Node/Jest (CommonJS) and bundlers (ESM)
 3. **Type generation** – Creates `.d.ts` for consumers
 4. **Plugin build** – Separate build for Expo plugin code
 
@@ -961,6 +969,7 @@ src/
   ├─ index.ts                    # Public API (what users import)
   ├─ nativeModule.ts             # Module loader
   ├─ systemEvents.ts             # Event listener helper
+  ├─ campaignTouch.ts            # CampaignTouch type + getLastCampaignTouch payload narrowing
   ├─ hooks/
   │  └─ useAmplySystemEvents.ts # React hook
   └─ nativeSpecs/

package/docs/DEVELOPMENT.md

@@ -10,7 +10,8 @@ src/                               # TypeScript source (JS side)
   │   └── NativeAmplyModule.ts     # TurboModule spec (codegen source)
   ├── index.ts                      # Public API exports
   ├── nativeModule.ts               # Native module loader with fallbacks
-  └── systemEvents.ts               # Event emitter helpers
+  ├── systemEvents.ts               # Event emitter helpers
+  └── campaignTouch.ts              # CampaignTouch type + payload narrowing
 
 android/                           # Android native code
   ├── src/main/

package/ios/Sources/AmplyReactNative/AmplyModule.mm

@@ -659,6 +659,52 @@ static NSDictionary *AmplyGateDecisionToMap(ASDKGateDecision *decision) {
   }];
 }
 
+// The JS spelling of a touch kind. A kind this bridge does not know is passed through lowercased
+// rather than dropped here: the TS layer is the one place that decides what an unknown kind means.
+static NSString *AmplyCampaignTouchKindToString(ASDKCampaignTouchKind *kind) {
+  if ([kind isEqual:ASDKCampaignTouchKind.shown]) return @"shown";
+  if ([kind isEqual:ASDKCampaignTouchKind.engaged]) return @"engaged";
+  return kind.name.lowercaseString ?: @"";
+}
+
+- (void)getLastCampaignTouch:(double)withinMs
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  // Not a rejection, unlike getRecentEvents: the SDK answers "not initialised" with null for this
+  // query, and the bridge keeps that contract instead of inventing an error for it.
+  if (!self.amplyInstance) {
+    if (resolve) {
+      resolve([NSNull null]);
+    }
+    return;
+  }
+
+  [self.amplyInstance getLastCampaignTouchWithinMs:(int64_t)withinMs
+                                 completionHandler:^(ASDKCampaignTouch *touch, NSError *error) {
+    if (error) {
+      RCTLogError(@"[AmplyReactNative] Failed to get last campaign touch: %@", error.localizedDescription);
+      if (reject) {
+        reject(@"AMP_CAMPAIGN_TOUCH_FAILED", error.localizedDescription, error);
+      }
+      return;
+    }
+    if (!resolve) {
+      return;
+    }
+    if (!touch) {
+      resolve([NSNull null]);
+      return;
+    }
+    resolve(@{
+      @"campaignId": touch.campaignId ?: @"",
+      @"campaignName": touch.campaignName ?: @"",
+      @"kind": AmplyCampaignTouchKindToString(touch.kind),
+      @"atMs": @(touch.atMs),
+    });
+  }];
+}
+
 // Parses an array of `{name, value}` dicts into native EventParam objects.
 //
 // Bad-shape entries (non-dict, missing/non-string name) are silently dropped — this
@@ -1048,6 +1094,16 @@ static ASDKDataSetType *AmplyDataSetTypeFromDictionary(NSDictionary *type, NSStr
   [[ASDKLogger shared] setLevelLevel:level];
 }
 
+- (NSNumber *)handleUrl:(NSString *)url
+{
+  // Not buffered: a link is only meaningful to a live SDK, and the answer is needed right now.
+  ASDKAmply *instance = self.amplyInstance;
+  if (instance == nil || url == nil) {
+    return @NO;
+  }
+  return @([instance handleUrlUrl:url]);
+}
+
 - (NSString *)getLogLevel
 {
   return AmplyLogLevelToString(self.currentLogLevel);

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative-generated.mm

@@ -80,6 +80,10 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getRecentEvents", @selector(getRecentEvents:resolve:reject:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getLastCampaignTouch(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getLastCampaignTouch", @selector(getLastCampaignTouch:resolve:reject:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getDataSetSnapshot", @selector(getDataSetSnapshot:resolve:reject:), args, count);
     }
@@ -96,6 +100,10 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "setAppLanguage", @selector(setAppLanguage:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_handleUrl(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, BooleanKind, "handleUrl", @selector(handleUrl:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_setLogLevel(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "setLogLevel", @selector(setLogLevel:), args, count);
     }
@@ -155,6 +163,9 @@ namespace facebook::react {
         methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
         
         
+        methodMap_["getLastCampaignTouch"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getLastCampaignTouch};
+        
+        
         methodMap_["getDataSetSnapshot"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getDataSetSnapshot};
         
         
@@ -167,6 +178,9 @@ namespace facebook::react {
         methodMap_["setAppLanguage"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_setAppLanguage};
         
         
+        methodMap_["handleUrl"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_handleUrl};
+        
+        
         methodMap_["setLogLevel"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_setLogLevel};
         
         

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative.h

@@ -94,12 +94,16 @@ namespace JS {
 - (void)getRecentEvents:(double)limit
                 resolve:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject;
+- (void)getLastCampaignTouch:(double)withinMs
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject;
 - (void)getDataSetSnapshot:(NSDictionary *)type
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject;
 - (void)registerDeepLinkListener;
 - (void)setUserId:(NSString * _Nullable)userId;
 - (void)setAppLanguage:(NSString * _Nullable)tag;
+- (NSNumber *)handleUrl:(NSString *)url;
 - (void)setLogLevel:(NSString *)level;
 - (NSString *)getLogLevel;
 - (void)setCustomProperties:(NSDictionary *)properties;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplytools/react-native-amply-sdk",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "description": "React Native SDK for Amply: Mobile SDK to orchestrate in-app experiences and campaigns remotely, without app releases",
   "license": "MIT",
   "repository": {
@@ -11,8 +11,8 @@
   "bugs": {
     "url": "https://github.com/amply-tools/amply-react-native/issues"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
+  "main": "dist/cjs/index.js",
+  "module": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "react-native": "src/index.ts",
   "source": "src/index.ts",
@@ -27,19 +27,25 @@
     "react-native.config.js",
     "app.plugin.js",
     "README.md",
-    "docs/"
+    "docs/",
+    "!dist/**/__tests__",
+    "!src/**/__tests__",
+    "!**/*.tsbuildinfo"
   ],
   "scripts": {
     "build": "expo-module build",
     "build:plugin": "expo-module build plugin",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:package": "rm -rf dist plugin/build && EXPO_NONINTERACTIVE=1 expo-module build && EXPO_NONINTERACTIVE=1 expo-module build plugin && tsc -p tsconfig.cjs.json && node scripts/check-package.js",
     "clean": "expo-module clean",
-    "test": "node scripts/codegen.js --check && expo-module test && yarn check:seam-tokens && yarn check:sample-parity",
+    "test": "node scripts/codegen.js --check && expo-module test && yarn check:seam-tokens && yarn check:sample-parity && yarn build:package",
     "prepare": "expo-module prepare",
     "prepublishOnly": "expo-module prepublishOnly",
     "codegen": "node scripts/codegen.js",
     "codegen:check": "node scripts/codegen.js --check",
     "check:seam-tokens": "bash scripts/check-seam-tokens.sh",
-    "check:sample-parity": "bash scripts/check-sample-parity.sh"
+    "check:sample-parity": "bash scripts/check-sample-parity.sh",
+    "check:package": "node scripts/check-package.js"
   },
   "peerDependencies": {
     "expo": ">=54.0.0",

package/scripts/check-package.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Checks the tarball `npm publish` would ship, after a build: every entry point in package.json is
+ * in it, and every compiled file in it comes from a source file in this repo.
+ *
+ * Why: until 0.15.0 `main` pointed at `dist/index.js`, a bundle an early tsup build had
+ * left in the working tree. `expo-module build` writes to `dist/src/`, so nothing ever rebuilt or
+ * removed that file, and every release shipped it — `main` served the API of late 2025 (no
+ * `handleUrl`, no `getLastCampaignTouch`). Metro reads `react-native` and never noticed; Jest and
+ * anything else that resolves `main` did. A leftover like that has no source file behind it, which
+ * is what the second check looks for.
+ *
+ * `yarn build:package` runs it after a clean build; `yarn test` and release.sh (before anything is
+ * pushed, and again right before `npm publish`) run that.
+ * Exits non-zero and names each problem.
+ */
+const {execFileSync} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+process.chdir(root);
+
+const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+
+// The tsc builds and where their sources live: `dist/cjs/` mirrors `src/` (tsconfig.cjs.json),
+// the rest of `dist/` mirrors the repo root (rootDir "."), `plugin/build/` mirrors `plugin/src/`.
+// First match wins, so the narrower `dist/cjs/` comes before `dist/`.
+const OUTPUTS = [
+  {outDir: 'dist/cjs/', sourceDir: 'src/'},
+  {outDir: 'dist/', sourceDir: ''},
+  {outDir: 'plugin/build/', sourceDir: 'plugin/src/'},
+];
+const COMPILED = /(\.d\.ts\.map|\.d\.ts|\.js\.map|\.mjs\.map|\.js|\.mjs)$/;
+const SOURCE_EXTENSIONS = ['.ts', '.tsx'];
+
+const packed = JSON.parse(packList())[0].files.map((file) => file.path);
+const shipped = new Set(packed);
+
+const problems = [];
+
+const entries = {
+  main: pkg.main,
+  types: pkg.types,
+  'react-native': pkg['react-native'],
+  source: pkg.source,
+  module: pkg.module,
+  'expo.plugin': pkg.expo?.plugin?.replace(/^\.\//, ''),
+};
+for (const [field, entry] of Object.entries(entries)) {
+  if (entry !== undefined && !shipped.has(entry)) {
+    problems.push(`package.json "${field}" points at ${entry}, which is not in the tarball`);
+  }
+}
+
+// app.plugin.js is a one-line require of the compiled plugin; that target has to ship too.
+const pluginTarget = /require\('\.\/([^']+)'\)/.exec(fs.readFileSync('app.plugin.js', 'utf8'))?.[1];
+if (pluginTarget && !shipped.has(`${pluginTarget}/index.js`) && !shipped.has(`${pluginTarget}.js`)) {
+  problems.push(`app.plugin.js requires ./${pluginTarget}, which is not in the tarball`);
+}
+
+// `main` must serve the API of this tree's src/index.ts, name for name. It is loaded the way Jest
+// loads it (plain require), with the peers stubbed: nothing in the SDK touches native at import.
+const sourceExports = exportedNames('src/index.ts');
+const mainExports = requiredNames(pkg.main);
+const missing = sourceExports.filter((name) => !mainExports.includes(name));
+const extra = mainExports.filter((name) => !sourceExports.includes(name));
+if (missing.length > 0 || extra.length > 0) {
+  problems.push(
+    `"main" (${pkg.main}) does not serve src/index.ts — missing: [${missing.join(', ')}], extra: [${extra.join(', ')}]`,
+  );
+}
+
+for (const file of packed) {
+  const output = OUTPUTS.find(({outDir}) => file.startsWith(outDir));
+  if (!output || !COMPILED.test(file)) {
+    continue;
+  }
+  const stem = output.sourceDir + file.slice(output.outDir.length).replace(COMPILED, '');
+  if (!SOURCE_EXTENSIONS.some((extension) => fs.existsSync(stem + extension))) {
+    problems.push(`${file} has no source (${stem}.ts) — a leftover from an older build`);
+  }
+}
+
+/**
+ * `npm pack --dry-run --json`. The bare example's assembleDebug writes android/.cxx into the
+ * package root, and with it present npm 11 dies with "Exit handler never called!" (measured
+ * 2026-10-17: rc 1 with android/.cxx, rc 0 without it). That failure is npm's, not the package's —
+ * say so and name the way out instead of dying on a stack trace.
+ */
+function packList() {
+  try {
+    return execFileSync('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (error) {
+    const npmErrors = String(error.stderr ?? '')
+      .split('\n')
+      .filter((line) => line.startsWith('npm error'))
+      .slice(0, 3);
+    console.error(`FAIL: npm pack --dry-run failed:\n  ${npmErrors.join('\n  ')}`);
+    console.error('check-package: a native build in the package root is the usual cause — rm -rf android/build android/.cxx ios/build');
+    process.exit(1);
+  }
+}
+
+/** The value exports of a TypeScript module, as the compiler sees them (types are not runtime). */
+function exportedNames(file) {
+  const ts = require('typescript');
+  const program = ts.createProgram([file], {allowJs: false, jsx: ts.JsxEmit.ReactNative, skipLibCheck: true});
+  const checker = program.getTypeChecker();
+  const moduleSymbol = checker.getSymbolAtLocation(program.getSourceFile(file));
+  return checker
+    .getExportsOfModule(moduleSymbol)
+    .filter((symbol) => {
+      const target = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      return (target.flags & ts.SymbolFlags.Value) !== 0;
+    })
+    .map((symbol) => symbol.getName())
+    .sort();
+}
+
+/** The export names of a CommonJS file when required with react / react-native stubbed out. */
+function requiredNames(file) {
+  const Module = require('module');
+  const load = Module._load;
+  const stubs = {
+    react: {useEffect() {}, useRef: () => ({}), useState: () => [], useCallback: (callback) => callback},
+    'react-native': {
+      NativeModules: {},
+      TurboModuleRegistry: {},
+      Platform: {OS: 'ios'},
+      NativeEventEmitter: class {},
+      Linking: {},
+    },
+  };
+  Module._load = function loadWithStubs(request, ...rest) {
+    return request in stubs ? stubs[request] : load.call(this, request, ...rest);
+  };
+  globalThis.__DEV__ = false;
+  try {
+    return Object.keys(require(path.resolve(file))).sort();
+  } catch (error) {
+    problems.push(`"main" (${file}) cannot be required: ${error.message.split('\n')[0]}`);
+    return [];
+  } finally {
+    Module._load = load;
+  }
+}
+
+if (problems.length > 0) {
+  for (const problem of problems) {
+    console.error(`FAIL: ${problem}`);
+  }
+  console.error('check-package: rebuild from a clean tree (rm -rf dist plugin/build) or fix the entry.');
+  process.exit(1);
+}
+console.log(`check-package: OK — ${packed.length} files, every entry ships, every compiled file has a source.`);

package/src/campaignTouch.ts

@@ -0,0 +1,74 @@
+import type {CampaignTouchPayload} from './nativeSpecs/NativeAmplyModule';
+
+/**
+ * - `'shown'`: the campaign was shown (`CampaignShown`).
+ * - `'engaged'`: the campaign resolved `Completed` (`CampaignResolved` with `result: 'Completed'`).
+ */
+export type CampaignTouchKind = 'shown' | 'engaged';
+
+/**
+ * The most recent moment a campaign reached the user, as answered by `getLastCampaignTouch`.
+ *
+ * Meant for your own analytics: attach `campaignId` / `campaignName` to a purchase (or any
+ * conversion) that happens shortly after a campaign, even when it did not start from the
+ * campaign's own link.
+ */
+export type CampaignTouch = {
+  /**
+   * The id the SDK reports in `CampaignShown`. Inside an experiment that is the arm's own id —
+   * the same value `{@campaign.id}` resolves to, so it is also the right value for an explicit
+   * `amply_campaign_id` mark.
+   */
+  campaignId: string;
+  /** The campaign's name when the touch was recorded. Empty if the event carried no name. */
+  campaignName: string;
+  /** One touch per campaign: the newer of a show and a completion wins. */
+  kind: CampaignTouchKind;
+  /** When it happened, epoch milliseconds in the SDK's server-corrected clock. */
+  atMs: number;
+};
+
+/** Thrown (as a rejection) by `getLastCampaignTouch` for a window that is not a usable number. */
+export function assertValidWithinMs(withinMs: unknown): asserts withinMs is number {
+  if (typeof withinMs !== 'number' || !Number.isFinite(withinMs) || withinMs < 0) {
+    throw new RangeError(
+      `[Amply] getLastCampaignTouch: withinMs must be a finite number >= 0, got ${String(withinMs)}`,
+    );
+  }
+}
+
+function toKind(raw: unknown): CampaignTouchKind | null {
+  if (typeof raw !== 'string') {
+    return null;
+  }
+  const lowered = raw.toLowerCase();
+  return lowered === 'shown' || lowered === 'engaged' ? lowered : null;
+}
+
+/**
+ * Narrows what the native bridge resolved to the public type. Anything it cannot read as a
+ * touch becomes null with a warning: the caller asked "was there a campaign", and a payload this
+ * bridge does not understand is not one it can vouch for.
+ */
+export function toCampaignTouch(payload: CampaignTouchPayload | null | undefined): CampaignTouch | null {
+  if (payload == null) {
+    return null;
+  }
+  const kind = toKind(payload.kind);
+  const isReadable =
+    kind !== null &&
+    typeof payload.campaignId === 'string' &&
+    payload.campaignId.length > 0 &&
+    typeof payload.atMs === 'number' &&
+    Number.isFinite(payload.atMs);
+  if (!isReadable) {
+    console.warn('[Amply] getLastCampaignTouch: ignoring an unreadable native payload', payload);
+    return null;
+  }
+  return {
+    campaignId: payload.campaignId,
+    campaignName: typeof payload.campaignName === 'string' ? payload.campaignName : '',
+    kind,
+    atMs: payload.atMs,
+  };
+}