@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/commonjs/state/record.js

@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StateManager = exports.STATE_SCHEMA_VERSION = void 0;
+exports.emptyRecord = emptyRecord;
+var _caps = require("./caps.js");
+var _errors = require("../contract/errors.js");
+/**
+ * The persisted state record.
+ *
+ * Six collections, holding only what the platform will not tell us. No
+ * notification content, no push token, no desired set. The interaction buffer
+ * is the sole content-bearing exception, and it evicts on delivery.
+ *
+ * Corrupt or incompatible state is discarded and rebuilt rather than blocking:
+ * everything already scheduled lives in the OS and is unaffected, which is what
+ * makes discarding safe rather than destructive.
+ */
+
+/** The single record before 0.6.0; read once to migrate, then deleted. */
+const STATE_KEY = 'chipmobilesdk.notification.state';
+/**
+ * Since 0.6.0 each collection has its own key, plus one for the schema version and
+ * summaries, so recording one dedup entry writes the dedup ledger and nothing else
+ * (NOT-16). Before, every update serialized the whole record — the 500-entry dedup
+ * ledger included — synchronously on the JS thread.
+ */
+const META_KEY = `${STATE_KEY}:meta`;
+const COLLECTIONS = ['dedupLedger', 'interactionBuffer', 'migrationLedger', 'seriesLedger', 'permissionHistory'];
+const keyFor = collection => `${STATE_KEY}:${collection}`;
+
+/**
+ * Bumped whenever the shape below changes. A mismatch discards and rebuilds —
+ * never a migration, because none of this data is worth migrating and all of it
+ * is reconstructible.
+ */
+const STATE_SCHEMA_VERSION = exports.STATE_SCHEMA_VERSION = 1;
+function emptyRecord() {
+  return {
+    schemaVersion: STATE_SCHEMA_VERSION,
+    dedupLedger: [],
+    interactionBuffer: [],
+    migrationLedger: [],
+    seriesLedger: [],
+    permissionHistory: []
+  };
+}
+/**
+ * Owns the record's lifecycle. Reads are synchronous and cheap; writes are
+ * best-effort and never propagate a failure to the caller's operation.
+ */
+class StateManager {
+  rebuilt = false;
+  constructor(options) {
+    this.store = options.store;
+    this.now = options.now;
+    this.emit = options.emit ?? (() => {});
+    this.record = this.load();
+  }
+  load() {
+    try {
+      const meta = this.store.getString(META_KEY);
+      if (meta === undefined) {
+        return this.migrateLegacy();
+      }
+      const parsed = JSON.parse(meta);
+      if (parsed.schemaVersion !== STATE_SCHEMA_VERSION) {
+        return this.discardAndRebuild('schema-version-mismatch', {
+          found: parsed.schemaVersion,
+          expected: STATE_SCHEMA_VERSION
+        });
+      }
+      const record = {
+        schemaVersion: STATE_SCHEMA_VERSION,
+        lastReconcileSummary: parsed.lastReconcileSummary,
+        lastMaintenanceSummary: parsed.lastMaintenanceSummary
+      };
+      for (const collection of COLLECTIONS) {
+        const raw = this.store.getString(keyFor(collection));
+        const entries = raw === undefined ? [] : JSON.parse(raw);
+        if (!Array.isArray(entries)) {
+          return this.discardAndRebuild('unparseable', {
+            collection
+          });
+        }
+        record[collection] = entries;
+      }
+      return record;
+    } catch {
+      return this.discardAndRebuild('unparseable');
+    }
+  }
+
+  /** Reads the pre-0.6.0 single record, writes it out per collection, and drops it. */
+  migrateLegacy() {
+    const raw = this.store.getString(STATE_KEY);
+    if (raw === undefined) {
+      const fresh = emptyRecord();
+      this.persistMeta(fresh);
+      return fresh;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.schemaVersion !== STATE_SCHEMA_VERSION) {
+      return this.discardAndRebuild('schema-version-mismatch', {
+        found: parsed.schemaVersion,
+        expected: STATE_SCHEMA_VERSION
+      });
+    }
+    this.record = {
+      schemaVersion: STATE_SCHEMA_VERSION,
+      dedupLedger: parsed.dedupLedger ?? [],
+      interactionBuffer: parsed.interactionBuffer ?? [],
+      migrationLedger: parsed.migrationLedger ?? [],
+      seriesLedger: parsed.seriesLedger ?? [],
+      permissionHistory: parsed.permissionHistory ?? [],
+      lastReconcileSummary: parsed.lastReconcileSummary,
+      lastMaintenanceSummary: parsed.lastMaintenanceSummary
+    };
+    for (const collection of COLLECTIONS) {
+      this.persist(collection);
+    }
+    this.persistMeta(this.record);
+    this.store.delete(STATE_KEY);
+    return this.record;
+  }
+  discardAndRebuild(reason, extra) {
+    this.rebuilt = true;
+    this.deleteAll();
+    this.persistMeta(emptyRecord());
+    this.emit({
+      code: _errors.DIAGNOSTIC_CODES.STATE_CORRUPT_REBUILT,
+      // Note what is actually lost, so the consequence is stated rather than implied.
+      context: {
+        reason,
+        lost: ['dedupLedger', 'interactionBuffer'],
+        ...extra
+      }
+    });
+    return emptyRecord();
+  }
+  deleteAll() {
+    this.store.delete(STATE_KEY);
+    this.store.delete(META_KEY);
+    for (const collection of COLLECTIONS) {
+      this.store.delete(keyFor(collection));
+    }
+  }
+
+  /** Never throws. A storage failure degrades the affected guarantee, nothing more. */
+  write(key, value) {
+    try {
+      this.store.setString(key, JSON.stringify(value));
+    } catch (error) {
+      this.emit({
+        code: _errors.DIAGNOSTIC_CODES.STATE_WRITE_FAILED,
+        context: {
+          reason: error instanceof Error ? error.name : 'unknown'
+        }
+      });
+    }
+  }
+
+  /** Writes one collection, and only that one. */
+  persist(collection) {
+    this.write(keyFor(collection), this.record[collection]);
+  }
+
+  /** The schema version and summaries. Present whenever any collection is stored. */
+  persistMeta(record = this.record) {
+    this.write(META_KEY, {
+      schemaVersion: STATE_SCHEMA_VERSION,
+      lastReconcileSummary: record.lastReconcileSummary,
+      lastMaintenanceSummary: record.lastMaintenanceSummary
+    });
+  }
+  read() {
+    return this.record;
+  }
+
+  /** Applies a change, evicts the touched collection, and persists. */
+  update(collection, mutate) {
+    const next = mutate(this.record[collection]);
+    const {
+      kept,
+      evicted,
+      reason,
+      overCap
+    } = (0, _caps.evict)(next, collection, this.now());
+    if (overCap > 0) {
+      this.emit({
+        code: _errors.DIAGNOSTIC_CODES.STATE_CAP_EXCEEDED,
+        context: {
+          collection,
+          overCap,
+          cap: _caps.COLLECTION_CAPS[collection].maxEntries
+        }
+      });
+    }
+    if (evicted.length > 0) {
+      this.emit({
+        code: collection === 'interactionBuffer' ? _errors.DIAGNOSTIC_CODES.INTERACTION_BUFFER_EVICTED : _errors.DIAGNOSTIC_CODES.STATE_CAP_EVICTED,
+        context: {
+          collection,
+          evicted: evicted.length,
+          reason
+        }
+      });
+    }
+    this.record = {
+      ...this.record,
+      [collection]: kept
+    };
+    this.persist(collection);
+  }
+  setSummary(key, value) {
+    this.record = {
+      ...this.record,
+      [key]: value
+    };
+    this.persistMeta();
+  }
+
+  /** Clears everything. Public through `resetState()`. */
+  reset() {
+    this.record = emptyRecord();
+    this.rebuilt = false;
+    this.deleteAll();
+    this.persistMeta();
+  }
+
+  /**
+   * Clears one owner tag's entries, leaving every other tag untouched.
+   *
+   * Collections without an owner tag are left alone: a migration ledger and a
+   * series ledger describe the device, not an account.
+   */
+  clearOwner(ownerTag) {
+    this.record = {
+      ...this.record,
+      dedupLedger: this.record.dedupLedger.filter(e => e.ownerTag !== ownerTag),
+      interactionBuffer: this.record.interactionBuffer.filter(e => e.ownerTag !== ownerTag),
+      permissionHistory: this.record.permissionHistory.filter(e => !e.key.startsWith(`${ownerTag}:`))
+    };
+    this.persist('dedupLedger');
+    this.persist('interactionBuffer');
+    this.persist('permissionHistory');
+  }
+  health() {
+    const collections = Object.keys(_caps.COLLECTION_CAPS).map(name => {
+      const entries = this.record[name];
+      return {
+        name,
+        size: entries.length,
+        cap: _caps.COLLECTION_CAPS[name].maxEntries,
+        oldestEntryAt: entries.length > 0 ? Math.min(...entries.map(e => e.at)) : undefined
+      };
+    });
+    return {
+      readable: true,
+      rebuilt: this.rebuilt,
+      collections,
+      approximateBytes: this.store.approximateBytes()
+    };
+  }
+}
+exports.StateManager = StateManager;
+//# sourceMappingURL=record.js.map

package/lib/commonjs/state/record.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_caps","require","_errors","STATE_KEY","META_KEY","COLLECTIONS","keyFor","collection","STATE_SCHEMA_VERSION","exports","emptyRecord","schemaVersion","dedupLedger","interactionBuffer","migrationLedger","seriesLedger","permissionHistory","StateManager","rebuilt","constructor","options","store","now","emit","record","load","meta","getString","undefined","migrateLegacy","parsed","JSON","parse","discardAndRebuild","found","expected","lastReconcileSummary","lastMaintenanceSummary","raw","entries","Array","isArray","fresh","persistMeta","persist","delete","reason","extra","deleteAll","code","DIAGNOSTIC_CODES","STATE_CORRUPT_REBUILT","context","lost","write","key","value","setString","stringify","error","STATE_WRITE_FAILED","Error","name","read","update","mutate","next","kept","evicted","overCap","evict","STATE_CAP_EXCEEDED","cap","COLLECTION_CAPS","maxEntries","length","INTERACTION_BUFFER_EVICTED","STATE_CAP_EVICTED","setSummary","reset","clearOwner","ownerTag","filter","e","startsWith","health","collections","Object","keys","map","size","oldestEntryAt","Math","min","at","readable","approximateBytes"],"sourceRoot":"../../../src","sources":["state/record.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/state/reset.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearOwner = clearOwner;
+exports.resetState = resetState;
+/**
+ * Public state reset and per-owner clearing.
+ *
+ * These are the only two ways a consumer may touch the persisted record. The
+ * record itself is unreachable — a consumer can discard state, but can never
+ * read or write it.
+ */
+
+/** Discards the entire record. Nothing already scheduled with the OS is affected. */
+function resetState(state) {
+  state.reset();
+  return {
+    clearedCollections: ['dedupLedger', 'interactionBuffer', 'migrationLedger', 'seriesLedger', 'permissionHistory']
+  };
+}
+
+/**
+ * Clears one owner tag's entries on sign-out.
+ *
+ * Deliberately narrower than a full reset: the migration and series ledgers
+ * describe the device rather than an account, so signing one account out must
+ * not discard channel migration history that every account depends on.
+ */
+function clearOwner(state, ownerTag) {
+  state.clearOwner(ownerTag);
+  return {
+    clearedCollections: ['dedupLedger', 'interactionBuffer', 'permissionHistory']
+  };
+}
+//# sourceMappingURL=reset.js.map

package/lib/commonjs/state/reset.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resetState","state","reset","clearedCollections","clearOwner","ownerTag"],"sourceRoot":"../../../src","sources":["state/reset.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAQA;AACO,SAASA,UAAUA,CAACC,KAAmB,EAAgB;EAC7DA,KAAK,CAACC,KAAK,CAAC,CAAC;EACb,OAAO;IACNC,kBAAkB,EAAE,CACnB,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,mBAAmB;EAErB,CAAC;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,UAAUA,CAACH,KAAmB,EAAEI,QAAgB,EAAgB;EAC/EJ,KAAK,CAACG,UAAU,CAACC,QAAQ,CAAC;EAC1B,OAAO;IACNF,kBAAkB,EAAE,CAAC,aAAa,EAAE,mBAAmB,EAAE,mBAAmB;EAC7E,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/state/series-ledger.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listSeries = listSeries;
+exports.ownedIdentifiers = ownedIdentifiers;
+exports.ownsIdentifier = ownsIdentifier;
+exports.readSeries = readSeries;
+exports.removeSeries = removeSeries;
+exports.upsertSeries = upsertSeries;
+/**
+ * The recurrence series ledger.
+ *
+ * What makes automatic maintenance possible without a desired set from the
+ * consumer: the package remembers which series it owns, how far each has been
+ * expanded, and how many occurrences a count-limited series has already
+ * emitted. None of that is derivable from the platform's pending set, which
+ * knows only about individual notifications.
+ *
+ * It also defines what maintenance is allowed to touch. An occurrence belongs
+ * to a series in this ledger, so cancelling it is within scope; anything else
+ * is a directly-scheduled notification the package does not own.
+ */
+
+function readSeries(state, seriesId) {
+  return state.read().seriesLedger.find(entry => entry.seriesId === seriesId);
+}
+function listSeries(state) {
+  return state.read().seriesLedger;
+}
+
+/** Records or updates a series. Replaces in place so a re-registration cannot duplicate. */
+function upsertSeries(state, rule, update, now) {
+  const entry = {
+    at: now,
+    seriesId: rule.id,
+    anchoring: rule.anchoring ?? 'wallClock',
+    expandedThrough: update.expandedThrough,
+    emittedCount: update.emittedCount,
+    exhausted: update.exhausted,
+    ...(update.lastEmittedKey !== undefined ? {
+      lastEmittedKey: update.lastEmittedKey
+    } : {})
+  };
+  state.update('seriesLedger', current => [...current.filter(existing => existing.seriesId !== rule.id), entry]);
+}
+function removeSeries(state, seriesId) {
+  state.update('seriesLedger', current => current.filter(entry => entry.seriesId !== seriesId));
+}
+
+/**
+ * Identifiers the package owns.
+ *
+ * An occurrence identifier is `<seriesId>#<instant>`, so ownership is decided
+ * by prefix rather than by an enumeration the ledger would have to keep in sync
+ * with the device. That keeps the check correct even for occurrences scheduled
+ * before the app last restarted.
+ */
+function ownsIdentifier(state, id) {
+  const separator = id.lastIndexOf('#');
+  if (separator === -1) return false;
+  const seriesId = id.slice(0, separator);
+  return state.read().seriesLedger.some(entry => entry.seriesId === seriesId);
+}
+
+/** Every occurrence identifier currently attributable to a tracked series. */
+function ownedIdentifiers(state, pendingIds) {
+  return new Set(pendingIds.filter(id => ownsIdentifier(state, id)));
+}
+//# sourceMappingURL=series-ledger.js.map

package/lib/commonjs/state/series-ledger.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["readSeries","state","seriesId","read","seriesLedger","find","entry","listSeries","upsertSeries","rule","update","now","at","id","anchoring","expandedThrough","emittedCount","exhausted","lastEmittedKey","undefined","current","filter","existing","removeSeries","ownsIdentifier","separator","lastIndexOf","slice","some","ownedIdentifiers","pendingIds","Set"],"sourceRoot":"../../../src","sources":["state/series-ledger.ts"],"mappings":";;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAgBO,SAASA,UAAUA,CAACC,KAAmB,EAAEC,QAAgB,EAA4B;EAC3F,OAAOD,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,YAAY,CAACC,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACJ,QAAQ,KAAKA,QAAQ,CAAC;AAC5E;AAEO,SAASK,UAAUA,CAACN,KAAmB,EAA2B;EACxE,OAAOA,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,YAAY;AACjC;;AAEA;AACO,SAASI,YAAYA,CAC3BP,KAAmB,EACnBQ,IAAoB,EACpBC,MAKC,EACDC,GAAW,EACJ;EACP,MAAML,KAAkB,GAAG;IAC1BM,EAAE,EAAED,GAAG;IACPT,QAAQ,EAAEO,IAAI,CAACI,EAAE;IACjBC,SAAS,EAAEL,IAAI,CAACK,SAAS,IAAI,WAAW;IACxCC,eAAe,EAAEL,MAAM,CAACK,eAAe;IACvCC,YAAY,EAAEN,MAAM,CAACM,YAAY;IACjCC,SAAS,EAAEP,MAAM,CAACO,SAAS;IAC3B,IAAIP,MAAM,CAACQ,cAAc,KAAKC,SAAS,GAAG;MAAED,cAAc,EAAER,MAAM,CAACQ;IAAe,CAAC,GAAG,CAAC,CAAC;EACzF,CAAC;EAEDjB,KAAK,CAACS,MAAM,CAAC,cAAc,EAAEU,OAAO,IAAI,CACvC,GAAGA,OAAO,CAACC,MAAM,CAACC,QAAQ,IAAIA,QAAQ,CAACpB,QAAQ,KAAKO,IAAI,CAACI,EAAE,CAAC,EAC5DP,KAAK,CACL,CAAC;AACH;AAEO,SAASiB,YAAYA,CAACtB,KAAmB,EAAEC,QAAgB,EAAQ;EACzED,KAAK,CAACS,MAAM,CAAC,cAAc,EAAEU,OAAO,IAAIA,OAAO,CAACC,MAAM,CAACf,KAAK,IAAIA,KAAK,CAACJ,QAAQ,KAAKA,QAAQ,CAAC,CAAC;AAC9F;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASsB,cAAcA,CAACvB,KAAmB,EAAEY,EAAU,EAAW;EACxE,MAAMY,SAAS,GAAGZ,EAAE,CAACa,WAAW,CAAC,GAAG,CAAC;EACrC,IAAID,SAAS,KAAK,CAAC,CAAC,EAAE,OAAO,KAAK;EAElC,MAAMvB,QAAQ,GAAGW,EAAE,CAACc,KAAK,CAAC,CAAC,EAAEF,SAAS,CAAC;EACvC,OAAOxB,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,YAAY,CAACwB,IAAI,CAACtB,KAAK,IAAIA,KAAK,CAACJ,QAAQ,KAAKA,QAAQ,CAAC;AAC5E;;AAEA;AACO,SAAS2B,gBAAgBA,CAC/B5B,KAAmB,EACnB6B,UAA6B,EACP;EACtB,OAAO,IAAIC,GAAG,CAACD,UAAU,CAACT,MAAM,CAACR,EAAE,IAAIW,cAAc,CAACvB,KAAK,EAAEY,EAAE,CAAC,CAAC,CAAC;AACnE","ignoreList":[]}

package/lib/commonjs/state/store.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMemoryStore = createMemoryStore;
+/**
+ * The storage port behind the persisted state record.
+ *
+ * Kept as a port so the pure state logic is testable with no native module,
+ * and so MMKV stays confined to one file. This is internal — a consumer can
+ * reset or clear state, but can never read or write the record directly.
+ */
+
+/** In-memory store, used by tests and as the fallback when MMKV is unavailable. */
+function createMemoryStore() {
+  const map = new Map();
+  return {
+    getString: key => map.get(key),
+    setString: (key, value) => {
+      map.set(key, value);
+    },
+    delete: key => {
+      map.delete(key);
+    },
+    clearAll: () => {
+      map.clear();
+    },
+    approximateBytes: () => {
+      let total = 0;
+      for (const [key, value] of map) {
+        total += key.length + value.length;
+      }
+      return total;
+    },
+    durable: false
+  };
+}
+//# sourceMappingURL=store.js.map

package/lib/commonjs/state/store.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createMemoryStore","map","Map","getString","key","get","setString","value","set","delete","clearAll","clear","approximateBytes","total","length","durable"],"sourceRoot":"../../../src","sources":["state/store.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAaA;AACO,SAASA,iBAAiBA,CAAA,EAAe;EAC/C,MAAMC,GAAG,GAAG,IAAIC,GAAG,CAAiB,CAAC;EACrC,OAAO;IACNC,SAAS,EAAEC,GAAG,IAAIH,GAAG,CAACI,GAAG,CAACD,GAAG,CAAC;IAC9BE,SAAS,EAAEA,CAACF,GAAG,EAAEG,KAAK,KAAK;MAC1BN,GAAG,CAACO,GAAG,CAACJ,GAAG,EAAEG,KAAK,CAAC;IACpB,CAAC;IACDE,MAAM,EAAEL,GAAG,IAAI;MACdH,GAAG,CAACQ,MAAM,CAACL,GAAG,CAAC;IAChB,CAAC;IACDM,QAAQ,EAAEA,CAAA,KAAM;MACfT,GAAG,CAACU,KAAK,CAAC,CAAC;IACZ,CAAC;IACDC,gBAAgB,EAAEA,CAAA,KAAM;MACvB,IAAIC,KAAK,GAAG,CAAC;MACb,KAAK,MAAM,CAACT,GAAG,EAAEG,KAAK,CAAC,IAAIN,GAAG,EAAE;QAC/BY,KAAK,IAAIT,GAAG,CAACU,MAAM,GAAGP,KAAK,CAACO,MAAM;MACnC;MACA,OAAOD,KAAK;IACb,CAAC;IACDE,OAAO,EAAE;EACV,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/testing/conformance/index.js

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runConformanceSuite = runConformanceSuite;
+/**
+ * The shared conformance suite.
+ *
+ * The executable definition of what an engine adapter must do. Run against the
+ * real engine and against the fake, it is what backs the claim that testing
+ * with fakes proves something about production — if the two ever diverge, this
+ * is where it shows up rather than on a user's device.
+ *
+ * Written as a plain async function rather than a Jest suite so it can be
+ * driven from the demo app on a real device as well as from continuous
+ * integration.
+ */
+
+const TONE = {
+  toneId: 'conformance',
+  version: 1,
+  android: {
+    channelId: 'conformance.v1',
+    importance: 'default',
+    vibration: false,
+    badge: false,
+    bypassDnd: false,
+    name: 'Fixture tone',
+    loopSound: false,
+    alarmCategory: false
+  },
+  ios: {
+    categoryId: 'conformance',
+    interruptionLevel: 'active',
+    badge: false,
+    repeatRefused: false
+  }
+};
+async function runConformanceSuite(adapter, options = {}) {
+  const now = options.now ?? (() => Date.now());
+  const prefix = options.prefix ?? 'conformance';
+  const checks = [];
+  const check = async (name, run) => {
+    try {
+      const outcome = await run();
+      checks.push(outcome === true ? {
+        name,
+        passed: true
+      } : {
+        name,
+        passed: false,
+        detail: typeof outcome === 'string' ? outcome : 'returned false'
+      });
+    } catch (error) {
+      checks.push({
+        name,
+        passed: false,
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const id = suffix => `${prefix}:${suffix}`;
+  const at = now() + 3_600_000;
+  const schedule = (suffix, overrides = {}) => adapter.schedule({
+    request: {
+      id: id(suffix),
+      content: {
+        title: `Conformance ${suffix}`,
+        body: 'Suite entry'
+      },
+      tone: 'conformance',
+      moment: {
+        at
+      },
+      ...overrides
+    },
+    resolvedAt: at,
+    tone: TONE,
+    approximate: false
+  });
+
+  // Start clean so a previous run cannot mask a failure.
+  await adapter.cancelAll();
+  await check('reports its capabilities', async () => {
+    const capabilities = await adapter.getCapabilities();
+    return capabilities.pendingCeiling > 0 || `pendingCeiling must be positive, got ${capabilities.pendingCeiling}`;
+  });
+  await check('schedules and reads back an entry', async () => {
+    await schedule('a');
+    const pending = await adapter.getPending();
+    return pending.some(entry => entry.id === id('a')) || 'scheduled entry was not returned';
+  });
+  await check('returns enough detail to diff, not merely to count', async () => {
+    const [entry] = (await adapter.getPending()).filter(e => e.id === id('a'));
+    if (entry === undefined) return 'entry missing';
+    return entry.content.title.length > 0 && entry.resolvedAt > 0 && entry.anchoring !== undefined || 'entry lacked content, instant, or anchoring mode';
+  });
+  await check('replaces rather than duplicates on the same identifier', async () => {
+    await schedule('a', {
+      content: {
+        title: 'Replaced',
+        body: 'Newer'
+      }
+    });
+    const matching = (await adapter.getPending()).filter(entry => entry.id === id('a'));
+    return matching.length === 1 || `expected exactly 1 entry, found ${matching.length}`;
+  });
+  await check('round-trips a routing payload unchanged', async () => {
+    await schedule('routing', {
+      routing: {
+        screen: 'task',
+        nested: {
+          deep: true
+        }
+      }
+    });
+    const entry = (await adapter.getPending()).find(e => e.id === id('routing'));
+    return JSON.stringify(entry?.routing) === JSON.stringify({
+      screen: 'task',
+      nested: {
+        deep: true
+      }
+    }) || `routing payload changed: ${JSON.stringify(entry?.routing)}`;
+  });
+  await check('preserves the anchoring mode it was given', async () => {
+    await schedule('absolute', {
+      moment: {
+        at,
+        anchoring: 'absolute'
+      }
+    });
+    const entry = (await adapter.getPending()).find(e => e.id === id('absolute'));
+    return entry?.anchoring === 'absolute' || `expected absolute, got ${entry?.anchoring}`;
+  });
+  await check('cancels one entry without touching the others', async () => {
+    const before = (await adapter.getPending()).length;
+    await adapter.cancel(id('a'));
+    const after = await adapter.getPending();
+    return after.length === before - 1 && !after.some(entry => entry.id === id('a')) || 'cancel removed the wrong number of entries';
+  });
+  await check('cancelling something absent is harmless', async () => {
+    await adapter.cancel(id('never-existed'));
+    return true;
+  });
+  await check('reports permission state without throwing', async () => {
+    const state = await adapter.getPermission('display');
+    return ['notAsked', 'granted', 'denied', 'permanentlyDenied', 'provisional', 'notRequired'].includes(state) || `unexpected permission state: ${state}`;
+  });
+  await check('reports background restrictions, admitting unknown', async () => {
+    const report = await adapter.getRestrictions();
+    return ['unrestricted', 'restricted', 'unknown'].includes(report.batteryOptimization) || `unexpected restriction status: ${report.batteryOptimization}`;
+  });
+  await check('returns pending entries in ascending delivery order', async () => {
+    const pending = await adapter.getPending();
+    const instants = pending.map(entry => entry.resolvedAt);
+    const sorted = [...instants].sort((x, y) => x - y);
+    return JSON.stringify(instants) === JSON.stringify(sorted) || 'entries were not time-ordered';
+  });
+  await check('cancelAll leaves nothing behind', async () => {
+    await adapter.cancelAll();
+    const pending = await adapter.getPending();
+    return pending.length === 0 || `${pending.length} entries survived cancelAll`;
+  });
+
+  // --- Repeat expiry -------------------------------------------------------
+  // A substituted engine must be checked on these, not trusted: every one of
+  // them is a way to end up with a device that will not stop ringing, or with
+  // a consumer cancelling an artifact it was never meant to see.
+
+  await check('answers whether it can repeat an alert, rather than guessing', async () => {
+    const capabilities = await adapter.getCapabilities();
+    return typeof capabilities.supportsRepeatingAlert === 'boolean' || 'supportsRepeatingAlert was not a boolean';
+  });
+  await check('reports a repeating alert it cannot honour', async () => {
+    const capabilities = await adapter.getCapabilities();
+    if (capabilities.supportsRepeatingAlert) return true;
+
+    // A partially emulated repeat is worse than an honest refusal: the
+    // consumer believes the alarm is bounded when nothing bounds it.
+    const repeating = {
+      ...TONE,
+      android: {
+        ...TONE.android,
+        loopSound: true,
+        repeatForMs: 900_000
+      },
+      ios: {
+        ...TONE.ios,
+        repeatRefused: true
+      }
+    };
+    return repeating.ios.repeatRefused || 'refusal was not recorded on the resolved tone';
+  });
+  await check('keeps stop markers out of the consumer-visible pending set', async () => {
+    const stops = await adapter.listRepeatStops();
+    const pending = await adapter.getPending();
+    const leaked = pending.filter(entry => stops.some(stop => stop.markerId === entry.id));
+    return leaked.length === 0 || `${leaked.length} package-owned marker(s) were reported as consumer notifications`;
+  });
+  await check('silencing a notification that is gone is an answer, not a failure', async () => {
+    // The ordinary case after the user has handled it. An engine that throws
+    // here turns the commonest path into an error.
+    const silenced = await adapter.silenceDelivered(id('never-displayed'));
+    return silenced === false || 'reported silencing a notification it was not displaying';
+  });
+  await check('says whether a background delivery handler is registered', async () => {
+    return typeof adapter.hasBackgroundDeliveryHandler() === 'boolean' || 'hasBackgroundDeliveryHandler was not a boolean';
+  });
+  const passed = checks.filter(entry => entry.passed).length;
+  return {
+    adapter: adapter.name,
+    checks,
+    passed,
+    failed: checks.length - passed
+  };
+}
+//# sourceMappingURL=index.js.map