@chipmobilesdk/rn-notification 0.6.0 → 0.7.0

package/lib/commonjs/push/signout.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSignOut = createSignOut;
+var _reset = require("../state/reset.js");
+/**
+ * Sign-out cleanup.
+ *
+ * Three things must happen together, and the order matters: invalidate the
+ * token first so no further messages arrive for the account being left, then
+ * cancel its notifications, then clear its persisted state.
+ *
+ * Deliberately **scoped to one owner tag**. On a shared device, signing one
+ * account out must not clear another's deduplication history or cancel their
+ * reminders — and must not discard the channel migration ledger, which
+ * describes the device rather than any account.
+ */
+
+function createSignOut(deps) {
+  return {
+    async signOut(ownerTag) {
+      // Token first: stop the inbound flow before removing what would have
+      // handled it, so nothing arrives for an account that is already gone.
+      let tokenInvalidated = false;
+      if (deps.push !== undefined) {
+        try {
+          tokenInvalidated = await deps.push.invalidateToken();
+        } catch {
+          // A failed invalidation must not prevent local cleanup — leaving a
+          // signed-out account's notifications on the device is the worse of
+          // the two outcomes.
+          tokenInvalidated = false;
+        }
+      }
+      const cancelledIds = await deps.scheduler.cancelByOwner(ownerTag);
+      const {
+        clearedCollections
+      } = (0, _reset.clearOwner)(deps.state, ownerTag);
+      deps.emit?.('SIGN_OUT', `Signed out ${ownerTag}: token ${tokenInvalidated ? 'invalidated' : 'not invalidated'}, ${cancelledIds.length} notification(s) cancelled, per-owner state cleared.`, {
+        ownerTag,
+        tokenInvalidated,
+        cancelled: cancelledIds.length
+      });
+      return {
+        ownerTag,
+        tokenInvalidated,
+        cancelledIds,
+        clearedCollections
+      };
+    }
+  };
+}
+//# sourceMappingURL=signout.js.map

package/lib/commonjs/push/signout.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reset","require","createSignOut","deps","signOut","ownerTag","tokenInvalidated","push","undefined","invalidateToken","cancelledIds","scheduler","cancelByOwner","clearedCollections","clearOwner","state","emit","length","cancelled"],"sourceRoot":"../../../src","sources":["push/signout.ts"],"mappings":";;;;;;AAgBA,IAAAA,MAAA,GAAAC,OAAA;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAsBO,SAASC,aAAaA,CAACC,IAAyB,EAAE;EACxD,OAAO;IACN,MAAMC,OAAOA,CAACC,QAAgB,EAA0B;MACvD;MACA;MACA,IAAIC,gBAAgB,GAAG,KAAK;MAC5B,IAAIH,IAAI,CAACI,IAAI,KAAKC,SAAS,EAAE;QAC5B,IAAI;UACHF,gBAAgB,GAAG,MAAMH,IAAI,CAACI,IAAI,CAACE,eAAe,CAAC,CAAC;QACrD,CAAC,CAAC,MAAM;UACP;UACA;UACA;UACAH,gBAAgB,GAAG,KAAK;QACzB;MACD;MAEA,MAAMI,YAAY,GAAG,MAAMP,IAAI,CAACQ,SAAS,CAACC,aAAa,CAACP,QAAQ,CAAC;MACjE,MAAM;QAAEQ;MAAmB,CAAC,GAAG,IAAAC,iBAAU,EAACX,IAAI,CAACY,KAAK,EAAEV,QAAQ,CAAC;MAE/DF,IAAI,CAACa,IAAI,GACR,UAAU,EACV,cAAcX,QAAQ,WAAWC,gBAAgB,GAAG,aAAa,GAAG,iBAAiB,KAAKI,YAAY,CAACO,MAAM,sDAAsD,EACnK;QAAEZ,QAAQ;QAAEC,gBAAgB;QAAEY,SAAS,EAAER,YAAY,CAACO;MAAO,CAC9D,CAAC;MAED,OAAO;QAAEZ,QAAQ;QAAEC,gBAAgB;QAAEI,YAAY;QAAEG;MAAmB,CAAC;IACxE;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/reconcile/chunk.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_CHUNK_SIZE = void 0;
+exports.applyInChunks = applyInChunks;
+exports.yieldToEventLoop = yieldToEventLoop;
+/**
+ * Chunked application.
+ *
+ * A 500-entry reconciliation must not drop frames on a list screen, so work is
+ * applied in slices with a yield between them. No single slice may occupy the
+ * interface thread for more than 16 ms, which is what holds 60 fps while
+ * reconciliation is in flight.
+ */
+
+const DEFAULT_CHUNK_SIZE = exports.DEFAULT_CHUNK_SIZE = 25;
+
+/** Yields to the event loop so the interface thread can render between slices. */
+function yieldToEventLoop() {
+  return new Promise(resolve => setTimeout(resolve, 0));
+}
+/**
+ * Applies `work` to every item, yielding between chunks.
+ *
+ * Sequential within a chunk rather than parallel: these calls bridge to native,
+ * and a burst of concurrent scheduling is where duplicate-delivery races come
+ * from.
+ */
+async function applyInChunks(items, work, options = {}) {
+  const size = Math.max(1, options.size ?? DEFAULT_CHUNK_SIZE);
+  const yieldFn = options.onYield ?? yieldToEventLoop;
+  let applied = 0;
+  for (let start = 0; start < items.length; start += size) {
+    const chunk = items.slice(start, start + size);
+    for (const item of chunk) {
+      await work(item);
+      applied += 1;
+    }
+
+    // No yield after the final chunk — the caller is about to resume anyway.
+    if (start + size < items.length) {
+      await yieldFn();
+    }
+  }
+  return applied;
+}
+//# sourceMappingURL=chunk.js.map

package/lib/commonjs/reconcile/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_CHUNK_SIZE","exports","yieldToEventLoop","Promise","resolve","setTimeout","applyInChunks","items","work","options","size","Math","max","yieldFn","onYield","applied","start","length","chunk","slice","item"],"sourceRoot":"../../../src","sources":["reconcile/chunk.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEO,MAAMA,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,EAAE;;AAEpC;AACO,SAASE,gBAAgBA,CAAA,EAAkB;EACjD,OAAO,IAAIC,OAAO,CAACC,OAAO,IAAIC,UAAU,CAACD,OAAO,EAAE,CAAC,CAAC,CAAC;AACtD;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeE,aAAaA,CAClCC,KAAmB,EACnBC,IAAgC,EAChCC,OAAqB,GAAG,CAAC,CAAC,EACR;EAClB,MAAMC,IAAI,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,OAAO,CAACC,IAAI,IAAIV,kBAAkB,CAAC;EAC5D,MAAMa,OAAO,GAAGJ,OAAO,CAACK,OAAO,IAAIZ,gBAAgB;EACnD,IAAIa,OAAO,GAAG,CAAC;EAEf,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGT,KAAK,CAACU,MAAM,EAAED,KAAK,IAAIN,IAAI,EAAE;IACxD,MAAMQ,KAAK,GAAGX,KAAK,CAACY,KAAK,CAACH,KAAK,EAAEA,KAAK,GAAGN,IAAI,CAAC;IAE9C,KAAK,MAAMU,IAAI,IAAIF,KAAK,EAAE;MACzB,MAAMV,IAAI,CAACY,IAAI,CAAC;MAChBL,OAAO,IAAI,CAAC;IACb;;IAEA;IACA,IAAIC,KAAK,GAAGN,IAAI,GAAGH,KAAK,CAACU,MAAM,EAAE;MAChC,MAAMJ,OAAO,CAAC,CAAC;IAChB;EACD;EAEA,OAAOE,OAAO;AACf","ignoreList":[]}

package/lib/commonjs/reconcile/diff.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.diff = diff;
+/**
+ * Desired-versus-device diffing.
+ *
+ * The package's central promise lives here: reconciling twice with unchanged
+ * input must produce **zero** platform operations on the second run. That is
+ * only true if "unchanged" is decided by comparing everything that would make
+ * the delivered notification different — miss a field and the second run
+ * rewrites entries needlessly; include a volatile one and it never settles.
+ *
+ * Anchoring mode is part of the comparison key deliberately. A mode change on
+ * the same identifier must force a replacement rather than read as unchanged,
+ * because the two modes resolve to different instants the moment a zone
+ * changes.
+ */
+
+/** The fields that make one delivered notification different from another. */
+
+/**
+ * Stable serialization of those fields. One function for what the app wants and
+ * what the device holds, so the two cannot drift into comparing different
+ * things (NOT-19).
+ */
+function fingerprintFields(fields) {
+  return JSON.stringify([fields.resolvedAt, fields.anchoring, fields.content.title, fields.content.body, fields.content.subtitle ?? null, fields.tone, fields.ownerTag ?? null, fields.groupTag ?? null,
+  // Key order is not stable across constructions, so sort before comparing —
+  // otherwise two structurally identical payloads could compare unequal and
+  // the second pass would rewrite every entry carrying routing data.
+  fields.routing === undefined ? null : stableStringify(fields.routing), fields.actions === undefined ? null : fields.actions.map(a => [a.id, a.title, a.mode, a.input?.placeholder ?? null])]);
+}
+function fingerprint(request, resolvedAt) {
+  return fingerprintFields({
+    ...request,
+    resolvedAt,
+    anchoring: request.moment.anchoring ?? 'wallClock'
+  });
+}
+function entryFingerprint(entry) {
+  return fingerprintFields(entry);
+}
+
+/** Key-order-independent JSON, so structurally equal payloads compare equal. */
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null';
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(',')}}`;
+}
+/**
+ * Computes the minimal operation set.
+ *
+ * Cancels are emitted before creates so an interrupted pass leaves a
+ * recoverable gap rather than a duplicate: a missing notification is fixed by
+ * the next reconcile, whereas two notifications for one subject is a defect the
+ * user sees.
+ */
+function diff(input) {
+  const deviceById = new Map(input.device.map(entry => [entry.id, entry]));
+  const desiredIds = new Set(input.desired.map(request => request.id));
+  const cancels = [];
+  const writes = [];
+  const unchanged = [];
+  const protectedIds = input.protectedIds ?? new Set();
+  for (const entry of input.device) {
+    if (!desiredIds.has(entry.id) && !protectedIds.has(entry.id)) {
+      cancels.push({
+        kind: 'cancel',
+        id: entry.id
+      });
+    }
+  }
+  for (const request of input.desired) {
+    const resolvedAt = input.resolvedAt.get(request.id) ?? request.moment.at;
+    const existing = deviceById.get(request.id);
+    if (existing === undefined) {
+      writes.push({
+        kind: 'create',
+        id: request.id,
+        request,
+        resolvedAt
+      });
+      continue;
+    }
+    if (fingerprint(request, resolvedAt) === entryFingerprint(existing)) {
+      unchanged.push(request.id);
+      continue;
+    }
+    writes.push({
+      kind: 'replace',
+      id: request.id,
+      request,
+      resolvedAt
+    });
+  }
+  return {
+    operations: [...cancels, ...writes],
+    unchanged
+  };
+}
+//# sourceMappingURL=diff.js.map

package/lib/commonjs/reconcile/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fingerprintFields","fields","JSON","stringify","resolvedAt","anchoring","content","title","body","subtitle","tone","ownerTag","groupTag","routing","undefined","stableStringify","actions","map","a","id","mode","input","placeholder","fingerprint","request","moment","entryFingerprint","entry","value","Array","isArray","join","entries","Object","sort","b","k","v","diff","deviceById","Map","device","desiredIds","Set","desired","cancels","writes","unchanged","protectedIds","has","push","kind","get","at","existing","operations"],"sourceRoot":"../../../src","sources":["reconcile/diff.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAoBA;;AAYA;AACA;AACA;AACA;AACA;AACA,SAASA,iBAAiBA,CAACC,MAAyB,EAAU;EAC7D,OAAOC,IAAI,CAACC,SAAS,CAAC,CACrBF,MAAM,CAACG,UAAU,EACjBH,MAAM,CAACI,SAAS,EAChBJ,MAAM,CAACK,OAAO,CAACC,KAAK,EACpBN,MAAM,CAACK,OAAO,CAACE,IAAI,EACnBP,MAAM,CAACK,OAAO,CAACG,QAAQ,IAAI,IAAI,EAC/BR,MAAM,CAACS,IAAI,EACXT,MAAM,CAACU,QAAQ,IAAI,IAAI,EACvBV,MAAM,CAACW,QAAQ,IAAI,IAAI;EACvB;EACA;EACA;EACAX,MAAM,CAACY,OAAO,KAAKC,SAAS,GAAG,IAAI,GAAGC,eAAe,CAACd,MAAM,CAACY,OAAO,CAAC,EACrEZ,MAAM,CAACe,OAAO,KAAKF,SAAS,GACzB,IAAI,GACJb,MAAM,CAACe,OAAO,CAACC,GAAG,CAACC,CAAC,IAAI,CAACA,CAAC,CAACC,EAAE,EAAED,CAAC,CAACX,KAAK,EAAEW,CAAC,CAACE,IAAI,EAAEF,CAAC,CAACG,KAAK,EAAEC,WAAW,IAAI,IAAI,CAAC,CAAC,CACjF,CAAC;AACH;AAEA,SAASC,WAAWA,CAACC,OAA4B,EAAEpB,UAAkB,EAAU;EAC9E,OAAOJ,iBAAiB,CAAC;IACxB,GAAGwB,OAAO;IACVpB,UAAU;IACVC,SAAS,EAAEmB,OAAO,CAACC,MAAM,CAACpB,SAAS,IAAI;EACxC,CAAC,CAAC;AACH;AAEA,SAASqB,gBAAgBA,CAACC,KAAmB,EAAU;EACtD,OAAO3B,iBAAiB,CAAC2B,KAAK,CAAC;AAChC;;AAEA;AACA,SAASZ,eAAeA,CAACa,KAAc,EAAU;EAChD,IAAIA,KAAK,KAAK,IAAI,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE,OAAO1B,IAAI,CAACC,SAAS,CAACyB,KAAK,CAAC,IAAI,MAAM;EACvF,IAAIC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,EAAE,OAAO,IAAIA,KAAK,CAACX,GAAG,CAACF,eAAe,CAAC,CAACgB,IAAI,CAAC,GAAG,CAAC,GAAG;EAE5E,MAAMC,OAAO,GAAGC,MAAM,CAACD,OAAO,CAACJ,KAAgC,CAAC,CAACM,IAAI,CAAC,CAAC,CAAChB,CAAC,CAAC,EAAE,CAACiB,CAAC,CAAC,KAC9EjB,CAAC,GAAGiB,CAAC,GAAG,CAAC,CAAC,GAAGjB,CAAC,GAAGiB,CAAC,GAAG,CAAC,GAAG,CAC1B,CAAC;EACD,OAAO,IAAIH,OAAO,CAACf,GAAG,CAAC,CAAC,CAACmB,CAAC,EAAEC,CAAC,CAAC,KAAK,GAAGnC,IAAI,CAACC,SAAS,CAACiC,CAAC,CAAC,IAAIrB,eAAe,CAACsB,CAAC,CAAC,EAAE,CAAC,CAACN,IAAI,CAAC,GAAG,CAAC,GAAG;AAC9F;AAmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASO,IAAIA,CAACjB,KAAgB,EAAc;EAClD,MAAMkB,UAAU,GAAG,IAAIC,GAAG,CAACnB,KAAK,CAACoB,MAAM,CAACxB,GAAG,CAACU,KAAK,IAAI,CAACA,KAAK,CAACR,EAAE,EAAEQ,KAAK,CAAC,CAAC,CAAC;EACxE,MAAMe,UAAU,GAAG,IAAIC,GAAG,CAACtB,KAAK,CAACuB,OAAO,CAAC3B,GAAG,CAACO,OAAO,IAAIA,OAAO,CAACL,EAAE,CAAC,CAAC;EAEpE,MAAM0B,OAAwB,GAAG,EAAE;EACnC,MAAMC,MAAuB,GAAG,EAAE;EAClC,MAAMC,SAAmB,GAAG,EAAE;EAE9B,MAAMC,YAAY,GAAG3B,KAAK,CAAC2B,YAAY,IAAI,IAAIL,GAAG,CAAS,CAAC;EAE5D,KAAK,MAAMhB,KAAK,IAAIN,KAAK,CAACoB,MAAM,EAAE;IACjC,IAAI,CAACC,UAAU,CAACO,GAAG,CAACtB,KAAK,CAACR,EAAE,CAAC,IAAI,CAAC6B,YAAY,CAACC,GAAG,CAACtB,KAAK,CAACR,EAAE,CAAC,EAAE;MAC7D0B,OAAO,CAACK,IAAI,CAAC;QAAEC,IAAI,EAAE,QAAQ;QAAEhC,EAAE,EAAEQ,KAAK,CAACR;MAAG,CAAC,CAAC;IAC/C;EACD;EAEA,KAAK,MAAMK,OAAO,IAAIH,KAAK,CAACuB,OAAO,EAAE;IACpC,MAAMxC,UAAU,GAAGiB,KAAK,CAACjB,UAAU,CAACgD,GAAG,CAAC5B,OAAO,CAACL,EAAE,CAAC,IAAIK,OAAO,CAACC,MAAM,CAAC4B,EAAE;IACxE,MAAMC,QAAQ,GAAGf,UAAU,CAACa,GAAG,CAAC5B,OAAO,CAACL,EAAE,CAAC;IAE3C,IAAImC,QAAQ,KAAKxC,SAAS,EAAE;MAC3BgC,MAAM,CAACI,IAAI,CAAC;QAAEC,IAAI,EAAE,QAAQ;QAAEhC,EAAE,EAAEK,OAAO,CAACL,EAAE;QAAEK,OAAO;QAAEpB;MAAW,CAAC,CAAC;MACpE;IACD;IAEA,IAAImB,WAAW,CAACC,OAAO,EAAEpB,UAAU,CAAC,KAAKsB,gBAAgB,CAAC4B,QAAQ,CAAC,EAAE;MACpEP,SAAS,CAACG,IAAI,CAAC1B,OAAO,CAACL,EAAE,CAAC;MAC1B;IACD;IAEA2B,MAAM,CAACI,IAAI,CAAC;MAAEC,IAAI,EAAE,SAAS;MAAEhC,EAAE,EAAEK,OAAO,CAACL,EAAE;MAAEK,OAAO;MAAEpB;IAAW,CAAC,CAAC;EACtE;EAEA,OAAO;IAAEmD,UAAU,EAAE,CAAC,GAAGV,OAAO,EAAE,GAAGC,MAAM,CAAC;IAAEC;EAAU,CAAC;AAC1D","ignoreList":[]}

package/lib/commonjs/reconcile/duplicates.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitDuplicates = splitDuplicates;
+var _errors = require("../contract/errors.js");
+/**
+ * Duplicate identifier resolution.
+ *
+ * An identifier appearing twice in one desired set means the caller's key
+ * derivation produced two notifications for one identity. That is a bug, not a
+ * preference, so the package refuses rather than silently picking a winner.
+ *
+ * **Every** copy is rejected — no entry wins. Order-independence then follows
+ * for free rather than having to be engineered: there is no "first" or "last"
+ * to depend on.
+ *
+ * The rule applies even to byte-identical duplicates. Treating those as
+ * mergeable would require a deep-equality definition that becomes a contract of
+ * its own, and a repeated identifier is a key-derivation bug either way.
+ */
+
+/**
+ * Splits a desired set into applicable entries and rejections.
+ *
+ * `existingIds` lets the rejection state whether a notification already
+ * scheduled under that identifier was left in place — without it a caller could
+ * reasonably read "rejected" as "cancelled".
+ */
+function splitDuplicates(desired, existingIds = new Set()) {
+  const counts = new Map();
+  for (const request of desired) {
+    counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
+  }
+  const unique = [];
+  const rejected = [];
+  for (const request of desired) {
+    if ((counts.get(request.id) ?? 0) === 1) {
+      unique.push(request);
+    }
+  }
+
+  // Sorted so the report itself is order-independent, not merely its effect.
+  const repeated = [...counts.entries()].filter(([, count]) => count > 1).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  for (const [id, occurrences] of repeated) {
+    rejected.push({
+      id,
+      code: _errors.DIAGNOSTIC_CODES.DUPLICATE_IDENTIFIER,
+      reason: `Identifier appeared ${occurrences} times in one desired set. Every copy was rejected, because the package cannot know which was intended.` + (existingIds.has(id) ? ' Any notification already scheduled under it was left in place — this is a rejection, not a cancellation.' : ''),
+      occurrences,
+      existingLeftInPlace: existingIds.has(id)
+    });
+  }
+  return {
+    unique,
+    rejected
+  };
+}
+//# sourceMappingURL=duplicates.js.map

package/lib/commonjs/reconcile/duplicates.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","splitDuplicates","desired","existingIds","Set","counts","Map","request","set","id","get","unique","rejected","push","repeated","entries","filter","count","sort","a","b","occurrences","code","DIAGNOSTIC_CODES","DUPLICATE_IDENTIFIER","reason","has","existingLeftInPlace"],"sourceRoot":"../../../src","sources":["reconcile/duplicates.ts"],"mappings":";;;;;;AAkBA,IAAAA,OAAA,GAAAC,OAAA;AAlBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAaA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,eAAeA,CAC9BC,OAAuC,EACvCC,WAAgC,GAAG,IAAIC,GAAG,CAAC,CAAC,EAC3B;EACjB,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAAiB,CAAC;EACxC,KAAK,MAAMC,OAAO,IAAIL,OAAO,EAAE;IAC9BG,MAAM,CAACG,GAAG,CAACD,OAAO,CAACE,EAAE,EAAE,CAACJ,MAAM,CAACK,GAAG,CAACH,OAAO,CAACE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;EAC1D;EAEA,MAAME,MAA6B,GAAG,EAAE;EACxC,MAAMC,QAAyB,GAAG,EAAE;EAEpC,KAAK,MAAML,OAAO,IAAIL,OAAO,EAAE;IAC9B,IAAI,CAACG,MAAM,CAACK,GAAG,CAACH,OAAO,CAACE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;MACxCE,MAAM,CAACE,IAAI,CAACN,OAAO,CAAC;IACrB;EACD;;EAEA;EACA,MAAMO,QAAQ,GAAG,CAAC,GAAGT,MAAM,CAACU,OAAO,CAAC,CAAC,CAAC,CACpCC,MAAM,CAAC,CAAC,GAAGC,KAAK,CAAC,KAAKA,KAAK,GAAG,CAAC,CAAC,CAChCC,IAAI,CAAC,CAAC,CAACC,CAAC,CAAC,EAAE,CAACC,CAAC,CAAC,KAAMD,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;EAElD,KAAK,MAAM,CAACX,EAAE,EAAEY,WAAW,CAAC,IAAIP,QAAQ,EAAE;IACzCF,QAAQ,CAACC,IAAI,CAAC;MACbJ,EAAE;MACFa,IAAI,EAAEC,wBAAgB,CAACC,oBAAoB;MAC3CC,MAAM,EACL,uBAAuBJ,WAAW,yGAAyG,IAC1IlB,WAAW,CAACuB,GAAG,CAACjB,EAAE,CAAC,GACjB,2GAA2G,GAC3G,EAAE,CAAC;MACPY,WAAW;MACXM,mBAAmB,EAAExB,WAAW,CAACuB,GAAG,CAACjB,EAAE;IACxC,CAAC,CAAC;EACH;EAEA,OAAO;IAAEE,MAAM;IAAEC;EAAS,CAAC;AAC5B","ignoreList":[]}

package/lib/commonjs/reconcile/index.js

@@ -0,0 +1,164 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReconciler = createReconciler;
+var _errors = require("../contract/errors.js");
+var _anchor = require("../schedule/anchor.js");
+var _resolveMoment = require("../schedule/resolve-moment.js");
+var _index = require("../schedule/index.js");
+var _duplicates = require("./duplicates.js");
+var _truncate = require("./truncate.js");
+var _writer = require("../schedule/writer.js");
+var _diff = require("./diff.js");
+var _chunk = require("./chunk.js");
+/**
+ * The reconciliation operation.
+ *
+ * A caller hands over the complete set its data implies; the package works out
+ * what to add, replace, and remove. This is **never** run automatically — only
+ * the caller knows what its data implies, and a package that guessed a desired
+ * set would cancel notifications it does not understand.
+ *
+ * Overlapping calls are serialized rather than run concurrently, because two
+ * passes interleaving their cancels and creates is exactly how duplicates
+ * appear.
+ */
+
+/**
+ * Narrows the device set to the caller's declared domain.
+ *
+ * Everything outside it is invisible to this pass, which is what makes it safe
+ * to cancel strays: a notification from another domain or another library is
+ * never a stray, it simply is not ours.
+ */
+function inDomain(entry, input) {
+  if (entry.pushCreated && input.includePushCreated !== true) return false;
+  return entry.groupTag === input.domain;
+}
+function createReconciler(deps) {
+  const emit = deps.emit ?? (() => {});
+  const writer = (0, _writer.createScheduleWriter)(deps.engine);
+  let inFlight = Promise.resolve();
+  const run = async input => {
+    const startedAt = deps.now();
+    const zone = deps.timeZone();
+    const everything = await deps.engine.getPending();
+    const device = everything.filter(entry => inDomain(entry, input));
+    // The ceiling is the platform's, shared with every other domain, every
+    // recurring series and every directly scheduled notification. Budgeting a
+    // domain against the whole of it let two domains and a series overflow iOS's
+    // 64 together while each reported "nothing truncated" (NOT-11).
+    const heldElsewhere = everything.length - device.length;
+    const existingIds = new Set(device.map(entry => entry.id));
+
+    // Duplicates first: a repeated identifier is refused before anything else
+    // looks at it, so no later stage has to decide which copy it meant.
+    const {
+      unique,
+      rejected: duplicateRejections
+    } = (0, _duplicates.splitDuplicates)(input.desired, existingIds);
+    const rejected = [...duplicateRejections];
+
+    // Validate and anchor. A rejection here removes one entry; it never fails
+    // the pass, because 499 valid entries should not be lost to one bad one.
+    const valid = [];
+    const resolvedAt = new Map();
+    for (const request of unique) {
+      try {
+        (0, _index.validateRequest)(request, deps.resolveTone);
+        const anchored = (0, _anchor.anchorMoment)(request.moment, zone);
+        const resolution = (0, _resolveMoment.resolveMoment)(anchored.resolvedAt, deps.now());
+        resolvedAt.set(request.id, resolution.at);
+        valid.push(request);
+      } catch (error) {
+        rejected.push({
+          id: request.id,
+          code: (0, _errors.isNotificationError)(error) ? error.code : 'UNKNOWN',
+          reason: error instanceof Error ? error.message : String(error),
+          occurrences: 1,
+          existingLeftInPlace: existingIds.has(request.id)
+        });
+      }
+    }
+
+    // Stop markers occupy real platform capacity, so the ceiling a consumer's
+    // notifications can actually use is smaller than the platform's own.
+    // Hiding that would let the package quietly reduce how many notifications
+    // fit and report a full set as registered when it was not.
+    // One pass: the outstanding stop markers are read once for the capacity and
+    // every operation below, not once per operation (NOT-08).
+    const pass = writer.pass();
+    const {
+      kept,
+      report: truncation
+    } = (0, _truncate.truncateToCeiling)(valid, resolvedAt, Math.max(0, (await pass.capacity()) - heldElsewhere));
+    if (truncation !== undefined) {
+      emit(_errors.DIAGNOSTIC_CODES.TRUNCATED_OVER_CEILING, `Desired set exceeded the platform ceiling of ${truncation.ceiling}; ${truncation.droppedCount} furthest-out entries were not registered. They are re-evaluated at the next window refresh.`, {
+        ceiling: truncation.ceiling,
+        dropped: truncation.droppedCount
+      });
+    }
+
+    // Every rejected identifier is protected from cancellation. A rejection
+    // means the package could not tell what the caller intended, and
+    // destroying the existing notification on that basis would be the worst
+    // available answer (FR-028c).
+    const {
+      operations,
+      unchanged
+    } = (0, _diff.diff)({
+      desired: kept,
+      resolvedAt,
+      device,
+      protectedIds: new Set(rejected.map(entry => entry.id))
+    });
+    const created = [];
+    const replaced = [];
+    const cancelled = [];
+    const approximate = !deps.canScheduleExactly();
+    await (0, _chunk.applyInChunks)(operations, async operation => {
+      if (operation.kind === 'cancel') {
+        await pass.cancel(operation.id);
+        cancelled.push(operation.id);
+        return;
+      }
+      const request = operation.request;
+      const tone = deps.resolveTone(request.tone);
+      await pass.write({
+        request,
+        resolvedAt: operation.resolvedAt,
+        tone,
+        anchoringGeneration: (request.moment.anchoring ?? 'wallClock') === 'absolute' ? undefined : zone,
+        approximate
+      });
+      (operation.kind === 'create' ? created : replaced).push(operation.id);
+    }, {
+      size: deps.chunkSize
+    });
+    return {
+      domain: input.domain,
+      created,
+      replaced,
+      cancelled,
+      unchanged,
+      rejected,
+      truncated: truncation,
+      operationCount: operations.length,
+      durationMs: deps.now() - startedAt
+    };
+  };
+  return {
+    /**
+     * Serialized against itself: a second call waits for the first rather than
+     * interleaving with it.
+     */
+    async reconcile(input) {
+      const next = inFlight.then(() => run(input), () => run(input));
+      inFlight = next.catch(() => undefined);
+      return next;
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/reconcile/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_anchor","_resolveMoment","_index","_duplicates","_truncate","_writer","_diff","_chunk","inDomain","entry","input","pushCreated","includePushCreated","groupTag","domain","createReconciler","deps","emit","writer","createScheduleWriter","engine","inFlight","Promise","resolve","run","startedAt","now","zone","timeZone","everything","getPending","device","filter","heldElsewhere","length","existingIds","Set","map","id","unique","rejected","duplicateRejections","splitDuplicates","desired","valid","resolvedAt","Map","request","validateRequest","resolveTone","anchored","anchorMoment","moment","resolution","resolveMoment","set","at","push","error","code","isNotificationError","reason","Error","message","String","occurrences","existingLeftInPlace","has","pass","kept","report","truncation","truncateToCeiling","Math","max","capacity","undefined","DIAGNOSTIC_CODES","TRUNCATED_OVER_CEILING","ceiling","droppedCount","dropped","operations","unchanged","diff","protectedIds","created","replaced","cancelled","approximate","canScheduleExactly","applyInChunks","operation","kind","cancel","tone","write","anchoringGeneration","anchoring","size","chunkSize","truncated","operationCount","durationMs","reconcile","next","then","catch"],"sourceRoot":"../../../src","sources":["reconcile/index.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/reconcile/truncate.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.truncateToCeiling = truncateToCeiling;
+/**
+ * Platform-ceiling truncation.
+ *
+ * iOS keeps only the 64 soonest pending notifications and silently discards the
+ * rest. The package computes the same cut deliberately, so the outcome is
+ * reported rather than discovered as missing notifications.
+ *
+ * Soonest-first is the only rule that degrades gracefully: dropped entries are
+ * not lost, they are simply not yet registered, and each window refresh
+ * registers those that have moved into range.
+ */
+
+/**
+ * Keeps the `ceiling` soonest entries.
+ *
+ * Ties on the delivery instant are broken by identifier so the cut is
+ * deterministic — otherwise two runs over the same data could drop different
+ * entries and the idempotence guarantee would not hold.
+ */
+function truncateToCeiling(desired, resolvedAt, ceiling) {
+  if (desired.length <= ceiling) {
+    return {
+      kept: desired
+    };
+  }
+  const ordered = [...desired].sort((a, b) => {
+    const aAt = resolvedAt.get(a.id) ?? a.moment.at;
+    const bAt = resolvedAt.get(b.id) ?? b.moment.at;
+    if (aAt !== bAt) return aAt - bAt;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  const kept = ordered.slice(0, ceiling);
+  const dropped = ordered.slice(ceiling);
+  return {
+    kept,
+    report: {
+      ceiling,
+      droppedCount: dropped.length,
+      droppedIds: dropped.map(entry => entry.id),
+      reEvaluatedOnNextRefresh: true
+    }
+  };
+}
+//# sourceMappingURL=truncate.js.map

package/lib/commonjs/reconcile/truncate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["truncateToCeiling","desired","resolvedAt","ceiling","length","kept","ordered","sort","a","b","aAt","get","id","moment","at","bAt","slice","dropped","report","droppedCount","droppedIds","map","entry","reEvaluatedOnNextRefresh"],"sourceRoot":"../../../src","sources":["reconcile/truncate.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,iBAAiBA,CAChCC,OAAuC,EACvCC,UAAuC,EACvCC,OAAe,EACK;EACpB,IAAIF,OAAO,CAACG,MAAM,IAAID,OAAO,EAAE;IAC9B,OAAO;MAAEE,IAAI,EAAEJ;IAAQ,CAAC;EACzB;EAEA,MAAMK,OAAO,GAAG,CAAC,GAAGL,OAAO,CAAC,CAACM,IAAI,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAK;IAC3C,MAAMC,GAAG,GAAGR,UAAU,CAACS,GAAG,CAACH,CAAC,CAACI,EAAE,CAAC,IAAIJ,CAAC,CAACK,MAAM,CAACC,EAAE;IAC/C,MAAMC,GAAG,GAAGb,UAAU,CAACS,GAAG,CAACF,CAAC,CAACG,EAAE,CAAC,IAAIH,CAAC,CAACI,MAAM,CAACC,EAAE;IAC/C,IAAIJ,GAAG,KAAKK,GAAG,EAAE,OAAOL,GAAG,GAAGK,GAAG;IACjC,OAAOP,CAAC,CAACI,EAAE,GAAGH,CAAC,CAACG,EAAE,GAAG,CAAC,CAAC,GAAGJ,CAAC,CAACI,EAAE,GAAGH,CAAC,CAACG,EAAE,GAAG,CAAC,GAAG,CAAC;EAC9C,CAAC,CAAC;EAEF,MAAMP,IAAI,GAAGC,OAAO,CAACU,KAAK,CAAC,CAAC,EAAEb,OAAO,CAAC;EACtC,MAAMc,OAAO,GAAGX,OAAO,CAACU,KAAK,CAACb,OAAO,CAAC;EAEtC,OAAO;IACNE,IAAI;IACJa,MAAM,EAAE;MACPf,OAAO;MACPgB,YAAY,EAAEF,OAAO,CAACb,MAAM;MAC5BgB,UAAU,EAAEH,OAAO,CAACI,GAAG,CAACC,KAAK,IAAIA,KAAK,CAACV,EAAE,CAAC;MAC1CW,wBAAwB,EAAE;IAC3B;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/recurrence/clock-guard.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLOCK_DISCONTINUITY_THRESHOLD_MS = void 0;
+exports.guardAgainstClockChange = guardAgainstClockChange;
+/**
+ * Clock-discontinuity bounding.
+ *
+ * A device clock moved backwards makes past occurrences look future again. Left
+ * alone, the next expansion would re-register every occurrence the user already
+ * received, and moving the clock forward again would fire them all at once.
+ *
+ * The guard is deliberately blunt: occurrences at or before the last horizon the
+ * series already expanded through are never re-emitted. The package would
+ * rather lose an occurrence after a manual clock change than deliver a burst of
+ * notifications for events that already happened.
+ */
+
+/** A jump larger than this is treated as a clock change rather than ordinary drift. */
+const CLOCK_DISCONTINUITY_THRESHOLD_MS = exports.CLOCK_DISCONTINUITY_THRESHOLD_MS = 60 * 60 * 1000;
+/**
+ * Drops occurrences that a clock discontinuity would otherwise resurrect.
+ *
+ * Forward jumps are detected and reported but not filtered: an occurrence that
+ * became due because time genuinely passed is legitimate, and the platform's
+ * own delivery is the right place for it to be resolved.
+ */
+function guardAgainstClockChange(input) {
+  const {
+    occurrences,
+    previousHorizon,
+    now,
+    previousNow
+  } = input;
+  let discontinuity = 'none';
+  if (previousNow !== undefined) {
+    const delta = now - previousNow;
+    if (delta < -CLOCK_DISCONTINUITY_THRESHOLD_MS) {
+      discontinuity = 'backwards';
+    } else if (delta > CLOCK_DISCONTINUITY_THRESHOLD_MS * 24) {
+      discontinuity = 'forwards';
+    }
+  }
+  if (previousHorizon === undefined) {
+    return {
+      occurrences,
+      suppressed: 0,
+      discontinuity
+    };
+  }
+
+  // Anything at or before the previously-expanded horizon was already handled
+  // once. Re-emitting it would mean delivering a notification for an event the
+  // user has already seen.
+  const kept = occurrences.filter(occurrence => occurrence.at > previousHorizon || occurrence.at > now);
+  const alreadyHandled = occurrences.filter(occurrence => occurrence.at <= previousHorizon && occurrence.at <= now);
+  return {
+    occurrences: kept,
+    suppressed: alreadyHandled.length,
+    discontinuity
+  };
+}
+//# sourceMappingURL=clock-guard.js.map

package/lib/commonjs/recurrence/clock-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CLOCK_DISCONTINUITY_THRESHOLD_MS","exports","guardAgainstClockChange","input","occurrences","previousHorizon","now","previousNow","discontinuity","undefined","delta","suppressed","kept","filter","occurrence","at","alreadyHandled","length"],"sourceRoot":"../../../src","sources":["recurrence/clock-guard.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACO,MAAMA,gCAAgC,GAAAC,OAAA,CAAAD,gCAAA,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI;AAiB9D;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,uBAAuBA,CAACC,KAAsB,EAAoB;EACjF,MAAM;IAAEC,WAAW;IAAEC,eAAe;IAAEC,GAAG;IAAEC;EAAY,CAAC,GAAGJ,KAAK;EAEhE,IAAIK,aAAgD,GAAG,MAAM;EAC7D,IAAID,WAAW,KAAKE,SAAS,EAAE;IAC9B,MAAMC,KAAK,GAAGJ,GAAG,GAAGC,WAAW;IAC/B,IAAIG,KAAK,GAAG,CAACV,gCAAgC,EAAE;MAC9CQ,aAAa,GAAG,WAAW;IAC5B,CAAC,MAAM,IAAIE,KAAK,GAAGV,gCAAgC,GAAG,EAAE,EAAE;MACzDQ,aAAa,GAAG,UAAU;IAC3B;EACD;EAEA,IAAIH,eAAe,KAAKI,SAAS,EAAE;IAClC,OAAO;MAAEL,WAAW;MAAEO,UAAU,EAAE,CAAC;MAAEH;IAAc,CAAC;EACrD;;EAEA;EACA;EACA;EACA,MAAMI,IAAI,GAAGR,WAAW,CAACS,MAAM,CAC9BC,UAAU,IAAIA,UAAU,CAACC,EAAE,GAAGV,eAAe,IAAIS,UAAU,CAACC,EAAE,GAAGT,GAClE,CAAC;EACD,MAAMU,cAAc,GAAGZ,WAAW,CAACS,MAAM,CACxCC,UAAU,IAAIA,UAAU,CAACC,EAAE,IAAIV,eAAe,IAAIS,UAAU,CAACC,EAAE,IAAIT,GACpE,CAAC;EAED,OAAO;IACNF,WAAW,EAAEQ,IAAI;IACjBD,UAAU,EAAEK,cAAc,CAACC,MAAM;IACjCT;EACD,CAAC;AACF","ignoreList":[]}