@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/commonjs/push/gate.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPushGate = createPushGate;
+var _errors = require("../contract/errors.js");
+var _envelope = require("./envelope.js");
+var _dedupLedger = require("../state/dedup-ledger.js");
+/**
+ * The push gate.
+ *
+ * Everything a consumer sees about push comes through here, in one normalized
+ * shape with zero provider types. Substituting a provider is therefore an
+ * adapter swap rather than a consumer rewrite.
+ *
+ * Two behaviours are deliberate and easy to get wrong. A push arriving in the
+ * **foreground is never auto-displayed** — presentation is the app's decision,
+ * and a library that decided for it would fight every consumer's design. And a
+ * malformed payload is **dropped safely**, because a broken message from a
+ * server must not be able to crash an installed app.
+ */
+
+function createPushGate(deps) {
+  const emit = deps.emit ?? (() => {});
+  let handlers = [];
+  let subscription;
+  /** Every token subscription, so a second one does not leak the first (NOT-24). */
+  const tokenSubscriptions = new Set();
+  let deliveryChain = Promise.resolve();
+  const dispatch = envelope => {
+    deliveryChain = deliveryChain.then(async () => {
+      for (const handler of handlers) {
+        try {
+          await handler(envelope);
+        } catch {
+          // A consumer's handler failing must not stop the next payload.
+        }
+      }
+    });
+  };
+  const receive = raw => {
+    let normalized;
+    try {
+      normalized = (0, _envelope.normalizeEnvelope)(raw, deps.now());
+    } catch (error) {
+      // Dropped safely and recorded. A broken message must never crash the app
+      // or corrupt the local schedule.
+      emit(_errors.DIAGNOSTIC_CODES.PAYLOAD_MALFORMED, (0, _errors.isNotificationError)(error) ? error.message : 'Push payload could not be interpreted and was discarded.', (0, _errors.isNotificationError)(error) ? error.context : undefined);
+      return undefined;
+    }
+    const {
+      envelope,
+      versionSkew
+    } = normalized;
+    if (versionSkew) {
+      emit(_errors.DIAGNOSTIC_CODES.PAYLOAD_VERSION_SKEW, `Push payload declares contract version ${envelope.version}; this build implements ${_envelope.IMPLEMENTED_PAYLOAD_VERSION}. Processed best-effort — known fields honoured, unknown fields ignored.`, {
+        received: envelope.version,
+        implemented: _envelope.IMPLEMENTED_PAYLOAD_VERSION
+      });
+    }
+
+    // Deduplication survives process death, which is the case that matters:
+    // a redelivery usually arrives in a fresh process.
+    if ((0, _dedupLedger.recordSeen)(deps.state, envelope.dedupId, deps.now(), envelope.ownerTag)) {
+      emit(_errors.DIAGNOSTIC_CODES.PAYLOAD_DUPLICATE, 'Push payload was already handled and was suppressed.', {
+        dedupId: envelope.dedupId
+      });
+      return undefined;
+    }
+    dispatch(envelope);
+    return envelope;
+  };
+  return {
+    /** Reports whether platform push services exist, so degradation is controlled. */
+    async getAvailability() {
+      const availability = await deps.provider.getAvailability();
+      if (availability === 'unavailable') {
+        emit(_errors.DIAGNOSTIC_CODES.PUSH_UNAVAILABLE, 'Platform push services are unavailable on this device. The push path is disabled; the entire local notification path is unaffected.');
+      }
+      return availability;
+    },
+    /** Waits for a genuine token. Never returns a placeholder presented as one. */
+    async getToken() {
+      const token = await deps.provider.getToken();
+      if (typeof token !== 'string' || token.length === 0) {
+        emit(_errors.DIAGNOSTIC_CODES.TOKEN_UNAVAILABLE, 'The provider has no registration token yet. An empty value is never returned as if it were one.');
+        throw new Error('Push token is not yet available.');
+      }
+      // The token value itself is never logged.
+      return token;
+    },
+    onTokenChange(handler) {
+      const unsubscribe = deps.provider.onTokenChange(handler);
+      tokenSubscriptions.add(unsubscribe);
+      return () => {
+        if (tokenSubscriptions.delete(unsubscribe)) {
+          unsubscribe();
+        }
+      };
+    },
+    async invalidateToken() {
+      const ok = await deps.provider.invalidateToken();
+      if (!ok) {
+        emit(_errors.DIAGNOSTIC_CODES.TOKEN_INVALIDATION_FAILED, 'Token invalidation did not succeed. The device may keep receiving messages for the previous account.');
+      }
+      return ok;
+    },
+    /**
+     * Subscribes to inbound payloads.
+     *
+     * Nothing is displayed automatically — the consumer decides whether and how
+     * to present a foreground push.
+     */
+    onPushReceived(handler) {
+      handlers.push(handler);
+      subscription ??= deps.provider.subscribeToMessages(receive);
+      return () => {
+        handlers = handlers.filter(h => h !== handler);
+      };
+    },
+    /**
+     * Processes a payload delivered while the app was in the background, from
+     * the module-scope handler `setBackgroundMessageHandler` requires (NOT-24).
+     *
+     * The same normalization and the same persisted deduplication as a
+     * foreground payload, so a redelivery after the process restarted is
+     * suppressed rather than handled twice. Resolves once every handler has run.
+     */
+    async handleBackground(raw) {
+      const envelope = receive(raw);
+      await deliveryChain;
+      return envelope;
+    },
+    /** Processes the payload that launched the app, if any. */
+    async collectInitial() {
+      const raw = await deps.provider.takeInitialMessage();
+      return raw === undefined ? undefined : receive(raw);
+    },
+    /** Reports a specific cause rather than leaving a non-delivery unexplained. */
+    reportUndeliverable(cause, context) {
+      emit(_errors.DIAGNOSTIC_CODES.PUSH_UNDELIVERABLE, `A push could not be delivered or displayed: ${cause}.`, {
+        cause,
+        ...context
+      });
+    },
+    /** Exposed for tests and orderly shutdown. */
+    async flush() {
+      await deliveryChain;
+    },
+    dispose() {
+      subscription?.();
+      subscription = undefined;
+      for (const unsubscribe of tokenSubscriptions) {
+        unsubscribe();
+      }
+      tokenSubscriptions.clear();
+      handlers = [];
+    }
+  };
+}
+//# sourceMappingURL=gate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_envelope","_dedupLedger","createPushGate","deps","emit","handlers","subscription","tokenSubscriptions","Set","deliveryChain","Promise","resolve","dispatch","envelope","then","handler","receive","raw","normalized","normalizeEnvelope","now","error","DIAGNOSTIC_CODES","PAYLOAD_MALFORMED","isNotificationError","message","context","undefined","versionSkew","PAYLOAD_VERSION_SKEW","version","IMPLEMENTED_PAYLOAD_VERSION","received","implemented","recordSeen","state","dedupId","ownerTag","PAYLOAD_DUPLICATE","getAvailability","availability","provider","PUSH_UNAVAILABLE","getToken","token","length","TOKEN_UNAVAILABLE","Error","onTokenChange","unsubscribe","add","delete","invalidateToken","ok","TOKEN_INVALIDATION_FAILED","onPushReceived","push","subscribeToMessages","filter","h","handleBackground","collectInitial","takeInitialMessage","reportUndeliverable","cause","PUSH_UNDELIVERABLE","flush","dispose","clear"],"sourceRoot":"../../../src","sources":["push/gate.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/push/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "IMPLEMENTED_PAYLOAD_VERSION", {
+  enumerable: true,
+  get: function () {
+    return _envelope.IMPLEMENTED_PAYLOAD_VERSION;
+  }
+});
+Object.defineProperty(exports, "createFcmProvider", {
+  enumerable: true,
+  get: function () {
+    return _fcmProvider.createFcmProvider;
+  }
+});
+Object.defineProperty(exports, "createInstructionHandler", {
+  enumerable: true,
+  get: function () {
+    return _instructions.createInstructionHandler;
+  }
+});
+Object.defineProperty(exports, "createPushGate", {
+  enumerable: true,
+  get: function () {
+    return _gate.createPushGate;
+  }
+});
+Object.defineProperty(exports, "createSignOut", {
+  enumerable: true,
+  get: function () {
+    return _signout.createSignOut;
+  }
+});
+Object.defineProperty(exports, "normalizeEnvelope", {
+  enumerable: true,
+  get: function () {
+    return _envelope.normalizeEnvelope;
+  }
+});
+var _gate = require("./gate.js");
+var _fcmProvider = require("./fcm-provider.js");
+var _signout = require("./signout.js");
+var _instructions = require("./instructions.js");
+var _envelope = require("./envelope.js");
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_gate","require","_fcmProvider","_signout","_instructions","_envelope"],"sourceRoot":"../../../src","sources":["push/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,IAAAA,KAAA,GAAAC,OAAA;AAGA,IAAAC,YAAA,GAAAD,OAAA;AAGA,IAAAE,QAAA,GAAAF,OAAA;AAGA,IAAAG,aAAA,GAAAH,OAAA;AAOA,IAAAI,SAAA,GAAAJ,OAAA","ignoreList":[]}

package/lib/commonjs/push/instructions.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInstructionHandler = createInstructionHandler;
+var _errors = require("../contract/errors.js");
+/**
+ * Push-driven local scheduling.
+ *
+ * Where the two paths meet. A server can schedule or cancel a local
+ * notification, and it gets **no privileged path**: an instruction arriving by
+ * push passes exactly the same identifier validation, moment validation, tone
+ * resolution, and permission rules as a request from app code.
+ *
+ * That symmetry is the point. A server that could bypass validation would be
+ * able to put the device into a state the app itself could not produce, and no
+ * amount of local correctness would survive it.
+ */
+
+function createInstructionHandler(deps) {
+  const emit = deps.emit ?? (() => {});
+
+  /**
+   * Whether a local schedule already covers this event.
+   *
+   * Local wins: it is the entry the device can present at the right moment with
+   * no network. A server that genuinely wants to override sends an explicit
+   * cancel followed by a schedule, which is unambiguous in a way "last write
+   * wins" is not.
+   */
+  const localAlreadyCovers = async id => {
+    const pending = await deps.engine.getPending();
+    const existing = pending.find(entry => entry.id === id);
+    return existing !== undefined && !existing.pushCreated;
+  };
+  return {
+    async handle(envelope) {
+      if (envelope.kind !== 'schedule' && envelope.kind !== 'cancel') {
+        return {
+          kind: 'ignored',
+          id: envelope.id
+        };
+      }
+      try {
+        if (envelope.kind === 'cancel') {
+          await deps.scheduler.cancel(envelope.id);
+          return {
+            kind: 'cancelled',
+            id: envelope.id
+          };
+        }
+        if (envelope.moment === undefined || envelope.content === undefined) {
+          throw Object.assign(new Error('A schedule instruction must carry both a moment and content.'), {
+            code: _errors.DIAGNOSTIC_CODES.PAYLOAD_MALFORMED
+          });
+        }
+        if (await localAlreadyCovers(envelope.id)) {
+          emit(_errors.DIAGNOSTIC_CODES.PAYLOAD_DUPLICATE, 'A local schedule already covers this event; the push instruction was suppressed so the user sees exactly one notification.', {
+            id: envelope.id
+          });
+          return {
+            kind: 'suppressed',
+            id: envelope.id,
+            reason: 'A local schedule already covers this event.'
+          };
+        }
+        const result = await deps.scheduler.schedule({
+          id: envelope.id,
+          content: envelope.content,
+          tone: envelope.tone ?? '',
+          moment: envelope.moment,
+          routing: envelope.routing,
+          ownerTag: envelope.ownerTag
+        }, {
+          pushCreated: true
+        });
+        return {
+          kind: 'scheduled',
+          id: envelope.id,
+          replaced: result.replaced
+        };
+      } catch (error) {
+        // Rejected under exactly the rules an app-initiated request would face,
+        // and recorded rather than swallowed.
+        const code = (0, _errors.isNotificationError)(error) ? error.code : error.code ?? 'UNKNOWN';
+        const reason = error instanceof Error ? error.message : String(error);
+        emit(code, `Push instruction rejected: ${reason}`, {
+          id: envelope.id
+        });
+        return {
+          kind: 'rejected',
+          id: envelope.id,
+          code,
+          reason
+        };
+      }
+    }
+  };
+}
+//# sourceMappingURL=instructions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","createInstructionHandler","deps","emit","localAlreadyCovers","id","pending","engine","getPending","existing","find","entry","undefined","pushCreated","handle","envelope","kind","scheduler","cancel","moment","content","Object","assign","Error","code","DIAGNOSTIC_CODES","PAYLOAD_MALFORMED","PAYLOAD_DUPLICATE","reason","result","schedule","tone","routing","ownerTag","replaced","error","isNotificationError","message","String"],"sourceRoot":"../../../src","sources":["push/instructions.ts"],"mappings":";;;;;;AAgBA,IAAAA,OAAA,GAAAC,OAAA;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAyBO,SAASC,wBAAwBA,CAACC,IAA6B,EAAE;EACvE,MAAMC,IAAI,GAAGD,IAAI,CAACC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC;;EAEpC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;EACC,MAAMC,kBAAkB,GAAG,MAAOC,EAAU,IAAuB;IAClE,MAAMC,OAAO,GAAG,MAAMJ,IAAI,CAACK,MAAM,CAACC,UAAU,CAAC,CAAC;IAC9C,MAAMC,QAAQ,GAAGH,OAAO,CAACI,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACN,EAAE,KAAKA,EAAE,CAAC;IACvD,OAAOI,QAAQ,KAAKG,SAAS,IAAI,CAACH,QAAQ,CAACI,WAAW;EACvD,CAAC;EAED,OAAO;IACN,MAAMC,MAAMA,CAACC,QAAsB,EAA+B;MACjE,IAAIA,QAAQ,CAACC,IAAI,KAAK,UAAU,IAAID,QAAQ,CAACC,IAAI,KAAK,QAAQ,EAAE;QAC/D,OAAO;UAAEA,IAAI,EAAE,SAAS;UAAEX,EAAE,EAAEU,QAAQ,CAACV;QAAG,CAAC;MAC5C;MAEA,IAAI;QACH,IAAIU,QAAQ,CAACC,IAAI,KAAK,QAAQ,EAAE;UAC/B,MAAMd,IAAI,CAACe,SAAS,CAACC,MAAM,CAACH,QAAQ,CAACV,EAAE,CAAC;UACxC,OAAO;YAAEW,IAAI,EAAE,WAAW;YAAEX,EAAE,EAAEU,QAAQ,CAACV;UAAG,CAAC;QAC9C;QAEA,IAAIU,QAAQ,CAACI,MAAM,KAAKP,SAAS,IAAIG,QAAQ,CAACK,OAAO,KAAKR,SAAS,EAAE;UACpE,MAAMS,MAAM,CAACC,MAAM,CAClB,IAAIC,KAAK,CAAC,8DAA8D,CAAC,EACzE;YAAEC,IAAI,EAAEC,wBAAgB,CAACC;UAAkB,CAC5C,CAAC;QACF;QAEA,IAAI,MAAMtB,kBAAkB,CAACW,QAAQ,CAACV,EAAE,CAAC,EAAE;UAC1CF,IAAI,CACHsB,wBAAgB,CAACE,iBAAiB,EAClC,4HAA4H,EAC5H;YAAEtB,EAAE,EAAEU,QAAQ,CAACV;UAAG,CACnB,CAAC;UACD,OAAO;YACNW,IAAI,EAAE,YAAY;YAClBX,EAAE,EAAEU,QAAQ,CAACV,EAAE;YACfuB,MAAM,EAAE;UACT,CAAC;QACF;QAEA,MAAMC,MAAM,GAAG,MAAM3B,IAAI,CAACe,SAAS,CAACa,QAAQ,CAC3C;UACCzB,EAAE,EAAEU,QAAQ,CAACV,EAAE;UACfe,OAAO,EAAEL,QAAQ,CAACK,OAAO;UACzBW,IAAI,EAAEhB,QAAQ,CAACgB,IAAI,IAAI,EAAE;UACzBZ,MAAM,EAAEJ,QAAQ,CAACI,MAAM;UACvBa,OAAO,EAAEjB,QAAQ,CAACiB,OAAO;UACzBC,QAAQ,EAAElB,QAAQ,CAACkB;QACpB,CAAC,EACD;UAAEpB,WAAW,EAAE;QAAK,CACrB,CAAC;QAED,OAAO;UAAEG,IAAI,EAAE,WAAW;UAAEX,EAAE,EAAEU,QAAQ,CAACV,EAAE;UAAE6B,QAAQ,EAAEL,MAAM,CAACK;QAAS,CAAC;MACzE,CAAC,CAAC,OAAOC,KAAK,EAAE;QACf;QACA;QACA,MAAMX,IAAI,GAAG,IAAAY,2BAAmB,EAACD,KAAK,CAAC,GACpCA,KAAK,CAACX,IAAI,GACRW,KAAK,CAAuBX,IAAI,IAAI,SAAU;QACnD,MAAMI,MAAM,GAAGO,KAAK,YAAYZ,KAAK,GAAGY,KAAK,CAACE,OAAO,GAAGC,MAAM,CAACH,KAAK,CAAC;QAErEhC,IAAI,CAACqB,IAAI,EAAE,8BAA8BI,MAAM,EAAE,EAAE;UAAEvB,EAAE,EAAEU,QAAQ,CAACV;QAAG,CAAC,CAAC;QACvE,OAAO;UAAEW,IAAI,EAAE,UAAU;UAAEX,EAAE,EAAEU,QAAQ,CAACV,EAAE;UAAEmB,IAAI;UAAEI;QAAO,CAAC;MAC3D;IACD;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/push/provider-adapter.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=provider-adapter.js.map

package/lib/commonjs/push/provider-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["push/provider-adapter.ts"],"mappings":"","ignoreList":[]}

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":"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","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":[]}