@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/commonjs/schedule/validate-identifier.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_IDENTIFIER_LENGTH = void 0;
+exports.isValidIdentifier = isValidIdentifier;
+exports.validateIdentifier = validateIdentifier;
+exports.validateOptionalTag = validateOptionalTag;
+var _errors = require("../contract/errors.js");
+var _marker = require("../repeat/marker.js");
+/**
+ * Identifier validation.
+ *
+ * Identity is the caller's contract: only the caller can derive an identifier
+ * reproducibly from its own data, so the package never generates one.
+ *
+ * The charset is composite-friendly because real derived keys are hierarchical
+ * — `task:1234:reminder:2`. A charset that forced encoding of natural keys
+ * would work against caller-supplied identity being readable and reproducible,
+ * which is most of its value.
+ *
+ * Nothing is normalized, trimmed, case-folded, or hashed. Two identifiers
+ * differing in any character are different identifiers, and the value visible
+ * at the platform boundary is exactly what the caller supplied — which is what
+ * lets a notification be traced back to the data that produced it.
+ */
+
+const MAX_IDENTIFIER_LENGTH = exports.MAX_IDENTIFIER_LENGTH = 128;
+
+/** `A–Z a–z 0–9 . _ - : /` — printable, unambiguous, and safe at every boundary. */
+const IDENTIFIER_PATTERN = /^[A-Za-z0-9._:/-]+$/;
+
+/** Reports the first offending character so a failure is actionable without echoing the value. */
+function firstInvalidCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (!/[A-Za-z0-9._:/-]/.test(char)) {
+      return {
+        char,
+        index
+      };
+    }
+  }
+  return undefined;
+}
+const EMPTY_CODE = {
+  id: _errors.DIAGNOSTIC_CODES.INVALID_ID_EMPTY,
+  ownerTag: _errors.DIAGNOSTIC_CODES.INVALID_OWNER_TAG,
+  groupTag: _errors.DIAGNOSTIC_CODES.INVALID_GROUP_TAG,
+  seriesId: _errors.DIAGNOSTIC_CODES.INVALID_ID_EMPTY,
+  actionId: _errors.DIAGNOSTIC_CODES.INVALID_ID_EMPTY
+};
+const LENGTH_CODE = {
+  id: _errors.DIAGNOSTIC_CODES.INVALID_ID_LENGTH,
+  ownerTag: _errors.DIAGNOSTIC_CODES.INVALID_OWNER_TAG,
+  groupTag: _errors.DIAGNOSTIC_CODES.INVALID_GROUP_TAG,
+  seriesId: _errors.DIAGNOSTIC_CODES.INVALID_ID_LENGTH,
+  actionId: _errors.DIAGNOSTIC_CODES.INVALID_ID_LENGTH
+};
+const CHARSET_CODE = {
+  id: _errors.DIAGNOSTIC_CODES.INVALID_ID_CHARSET,
+  ownerTag: _errors.DIAGNOSTIC_CODES.INVALID_OWNER_TAG,
+  groupTag: _errors.DIAGNOSTIC_CODES.INVALID_GROUP_TAG,
+  seriesId: _errors.DIAGNOSTIC_CODES.INVALID_ID_CHARSET,
+  actionId: _errors.DIAGNOSTIC_CODES.INVALID_ID_CHARSET
+};
+
+/**
+ * Throws a typed error naming the violated rule.
+ *
+ * The offending character and its position are reported; the value itself never
+ * is, because an identifier can carry user data a caller derived it from.
+ */
+function validateIdentifier(value, kind = 'id') {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new _errors.NotificationError(EMPTY_CODE[kind], `A ${kind} must be a non-empty string supplied by the caller. The package never generates one.`, {
+      kind,
+      received: typeof value
+    });
+  }
+  if (value.length > MAX_IDENTIFIER_LENGTH) {
+    throw new _errors.NotificationError(LENGTH_CODE[kind], `A ${kind} must be at most ${MAX_IDENTIFIER_LENGTH} characters.`, {
+      kind,
+      length: value.length,
+      max: MAX_IDENTIFIER_LENGTH
+    });
+  }
+  if (value.startsWith(_marker.REPEAT_STOP_PREFIX)) {
+    // Not a style rule. Repeat expiry cancels markers by identifier, so a
+    // consumer identifier that looks like one would be deleted out from under
+    // a real notification.
+    throw new _errors.NotificationError(CHARSET_CODE[kind], `A ${kind} may not begin with "${_marker.REPEAT_STOP_PREFIX}" — that prefix is reserved for the package's own repeat-expiry markers, which are cancelled automatically.`, {
+      kind,
+      reservedPrefix: _marker.REPEAT_STOP_PREFIX
+    });
+  }
+  if (!IDENTIFIER_PATTERN.test(value)) {
+    const offender = firstInvalidCharacter(value);
+    throw new _errors.NotificationError(CHARSET_CODE[kind], `A ${kind} may contain only A-Z, a-z, 0-9, and the separators . _ - : / — whitespace and control characters are not permitted.`, {
+      kind,
+      index: offender?.index,
+      charCode: offender?.char.charCodeAt(0)
+    });
+  }
+  return value;
+}
+
+/** Non-throwing form, for validating a batch without unwinding on the first failure. */
+function isValidIdentifier(value) {
+  // The throwing form is the rule; this one only reports whether it holds, so
+  // the two cannot disagree (the reserved marker prefix was missing here).
+  try {
+    validateIdentifier(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Validates an optional tag, returning undefined when absent rather than failing. */
+function validateOptionalTag(value, kind) {
+  if (value === undefined) return undefined;
+  return validateIdentifier(value, kind);
+}
+//# sourceMappingURL=validate-identifier.js.map

package/lib/commonjs/schedule/validate-identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_marker","MAX_IDENTIFIER_LENGTH","exports","IDENTIFIER_PATTERN","firstInvalidCharacter","value","index","length","char","test","undefined","EMPTY_CODE","id","DIAGNOSTIC_CODES","INVALID_ID_EMPTY","ownerTag","INVALID_OWNER_TAG","groupTag","INVALID_GROUP_TAG","seriesId","actionId","LENGTH_CODE","INVALID_ID_LENGTH","CHARSET_CODE","INVALID_ID_CHARSET","validateIdentifier","kind","NotificationError","received","max","startsWith","REPEAT_STOP_PREFIX","reservedPrefix","offender","charCode","charCodeAt","isValidIdentifier","validateOptionalTag"],"sourceRoot":"../../../src","sources":["schedule/validate-identifier.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/schedule/writer.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScheduleWriter = createScheduleWriter;
+var _place = require("../repeat/place.js");
+/**
+ * The one door every consumer notification goes through to reach the engine.
+ *
+ * Scheduler, reconciler, recurrence, re-anchoring and channel re-homing all
+ * write notifications. Each used to call `engine.schedule` itself, and the
+ * guarantees attached to a write — a repeating alert gets its stop marker, and
+ * that marker moves when the notification moves — existed only on the paths
+ * that remembered them. A recurring alarm never stopped, and a re-anchored one
+ * stopped at the old instant.
+ *
+ * Validation stays with each caller, because each has its own failure policy:
+ * the scheduler throws, reconciliation rejects one entry and carries on, and
+ * recurrence validates its template once at registration.
+ */
+
+function createScheduleWriter(engine) {
+  return writerOver(engine, (0, _place.createStopPlacement)(engine));
+}
+function writerOver(engine, stops) {
+  return {
+    async write(input) {
+      await engine.schedule(input);
+      await stops.sync(input.request.id, input.tone, input.resolvedAt);
+    },
+    async cancel(id) {
+      await engine.cancel(id);
+      await stops.release(id);
+    },
+    releaseStop: targetId => stops.release(targetId),
+    async capacity() {
+      const capabilities = await engine.getCapabilities();
+      return Math.max(0, capabilities.pendingCeiling - (await stops.count()));
+    },
+    pass: () => writerOver(engine, stops.pass())
+  };
+}
+//# sourceMappingURL=writer.js.map

package/lib/commonjs/schedule/writer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_place","require","createScheduleWriter","engine","writerOver","createStopPlacement","stops","write","input","schedule","sync","request","id","tone","resolvedAt","cancel","release","releaseStop","targetId","capacity","capabilities","getCapabilities","Math","max","pendingCeiling","count","pass"],"sourceRoot":"../../../src","sources":["schedule/writer.ts"],"mappings":";;;;;;AAgBA,IAAAA,MAAA,GAAAC,OAAA;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAyBO,SAASC,oBAAoBA,CAACC,MAAiC,EAAkB;EACvF,OAAOC,UAAU,CAACD,MAAM,EAAE,IAAAE,0BAAmB,EAACF,MAAM,CAAC,CAAC;AACvD;AAEA,SAASC,UAAUA,CAACD,MAAiC,EAAEG,KAAoB,EAAkB;EAC5F,OAAO;IACN,MAAMC,KAAKA,CAACC,KAAK,EAAE;MAClB,MAAML,MAAM,CAACM,QAAQ,CAACD,KAAK,CAAC;MAC5B,MAAMF,KAAK,CAACI,IAAI,CAACF,KAAK,CAACG,OAAO,CAACC,EAAE,EAAEJ,KAAK,CAACK,IAAI,EAAEL,KAAK,CAACM,UAAU,CAAC;IACjE,CAAC;IAED,MAAMC,MAAMA,CAACH,EAAE,EAAE;MAChB,MAAMT,MAAM,CAACY,MAAM,CAACH,EAAE,CAAC;MACvB,MAAMN,KAAK,CAACU,OAAO,CAACJ,EAAE,CAAC;IACxB,CAAC;IAEDK,WAAW,EAAEC,QAAQ,IAAIZ,KAAK,CAACU,OAAO,CAACE,QAAQ,CAAC;IAEhD,MAAMC,QAAQA,CAAA,EAAG;MAChB,MAAMC,YAAY,GAAG,MAAMjB,MAAM,CAACkB,eAAe,CAAC,CAAC;MACnD,OAAOC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,YAAY,CAACI,cAAc,IAAI,MAAMlB,KAAK,CAACmB,KAAK,CAAC,CAAC,CAAC,CAAC;IACxE,CAAC;IAEDC,IAAI,EAAEA,CAAA,KAAMtB,UAAU,CAACD,MAAM,EAAEG,KAAK,CAACoB,IAAI,CAAC,CAAC;EAC5C,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/state/caps.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COLLECTION_CAPS = void 0;
+exports.evict = evict;
+/**
+ * Caps and eviction for the persisted collections.
+ *
+ * No collection may grow without bound. Eviction is oldest-first and always
+ * observable — a silent eviction would turn a bounded guarantee into an
+ * unexplained one.
+ */
+
+/** Every persisted collection with a size or age bound. */
+const COLLECTION_CAPS = exports.COLLECTION_CAPS = {
+  dedupLedger: {
+    maxEntries: 500,
+    retentionMs: 24 * 60 * 60 * 1000
+  },
+  interactionBuffer: {
+    maxEntries: 50,
+    retentionMs: 7 * 24 * 60 * 60 * 1000
+  },
+  migrationLedger: {
+    maxEntries: 20,
+    retentionMs: Number.POSITIVE_INFINITY
+  },
+  seriesLedger: {
+    maxEntries: 32,
+    retentionMs: Number.POSITIVE_INFINITY
+  },
+  permissionHistory: {
+    maxEntries: 64,
+    retentionMs: Number.POSITIVE_INFINITY
+  }
+};
+
+/** Anything stored with a timestamp, which is everything that can age out. */
+
+/**
+ * Which entries a cap may drop (NOT-16). The migration and series ledgers record
+ * live facts: an active channel's applied version, a series' count. Dropping one
+ * makes the package treat a migrated tone as new and restart a series from zero,
+ * so only retired and exhausted entries go; the rest are kept and reported.
+ */
+const EVICTABLE = {
+  migrationLedger: entry => entry.retired === true,
+  seriesLedger: entry => entry.exhausted === true
+};
+
+/**
+ * Applies retention first, then the size cap.
+ *
+ * Order matters: expiring stale entries before trimming means a burst of new
+ * entries does not evict fresh ones while stale ones sit protected by
+ * recency ordering.
+ */
+function evict(entries, collection, now) {
+  const {
+    maxEntries,
+    retentionMs
+  } = COLLECTION_CAPS[collection];
+  const expired = [];
+  const live = [];
+  for (const entry of entries) {
+    if (Number.isFinite(retentionMs) && now - entry.at > retentionMs) {
+      expired.push(entry);
+    } else {
+      live.push(entry);
+    }
+  }
+
+  // Oldest first, so the tail is what we keep when trimming.
+  live.sort((a, b) => a.at - b.at);
+  const evictable = EVICTABLE[collection] ?? (() => true);
+  const excess = Math.max(0, live.length - maxEntries);
+  const overflow = [];
+  for (const entry of live) {
+    if (overflow.length === excess) break;
+    if (evictable(entry)) overflow.push(entry);
+  }
+  const dropped = new Set(overflow);
+  const kept = overflow.length === 0 ? live : live.filter(entry => !dropped.has(entry));
+  let reason = 'none';
+  if (expired.length > 0 && overflow.length > 0) {
+    reason = 'cap+retention';
+  } else if (overflow.length > 0) {
+    reason = 'cap';
+  } else if (expired.length > 0) {
+    reason = 'retention';
+  }
+  return {
+    kept,
+    evicted: [...expired, ...overflow],
+    reason,
+    overCap: Math.max(0, kept.length - maxEntries)
+  };
+}
+//# sourceMappingURL=caps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["COLLECTION_CAPS","exports","dedupLedger","maxEntries","retentionMs","interactionBuffer","migrationLedger","Number","POSITIVE_INFINITY","seriesLedger","permissionHistory","EVICTABLE","entry","retired","exhausted","evict","entries","collection","now","expired","live","isFinite","at","push","sort","a","b","evictable","excess","Math","max","length","overflow","dropped","Set","kept","filter","has","reason","evicted","overCap"],"sourceRoot":"../../../src","sources":["state/caps.ts"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDuplicate = isDuplicate;
+exports.recordSeen = recordSeen;
+/**
+ * The push deduplication ledger.
+ *
+ * Providers redeliver. The redelivery typically arrives in a **fresh process**,
+ * which is precisely why this is persisted rather than held in memory — an
+ * in-memory set would forget exactly when it matters.
+ *
+ * Bounded by cap and retention. A payload redelivered after its entry has aged
+ * out is treated as new: that is the documented bound of the guarantee, not a
+ * defect.
+ */
+
+function isDuplicate(state, dedupId) {
+  return state.read().dedupLedger.some(entry => entry.dedupId === dedupId);
+}
+
+/**
+ * Records a payload as seen.
+ *
+ * Returns true when it was already known, so a caller can branch on the same
+ * read that records it rather than checking twice.
+ */
+function recordSeen(state, dedupId, now, ownerTag) {
+  if (isDuplicate(state, dedupId)) return true;
+  state.update('dedupLedger', current => [...current, {
+    at: now,
+    dedupId,
+    ownerTag
+  }]);
+  return false;
+}
+//# sourceMappingURL=dedup-ledger.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["isDuplicate","state","dedupId","read","dedupLedger","some","entry","recordSeen","now","ownerTag","update","current","at"],"sourceRoot":"../../../src","sources":["state/dedup-ledger.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIO,SAASA,WAAWA,CAACC,KAAmB,EAAEC,OAAe,EAAW;EAC1E,OAAOD,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,WAAW,CAACC,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACJ,OAAO,KAAKA,OAAO,CAAC;AACzE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACO,SAASK,UAAUA,CACzBN,KAAmB,EACnBC,OAAe,EACfM,GAAW,EACXC,QAAiB,EACP;EACV,IAAIT,WAAW,CAACC,KAAK,EAAEC,OAAO,CAAC,EAAE,OAAO,IAAI;EAE5CD,KAAK,CAACS,MAAM,CAAC,aAAa,EAAEC,OAAO,IAAI,CAAC,GAAGA,OAAO,EAAE;IAAEC,EAAE,EAAEJ,GAAG;IAAEN,OAAO;IAAEO;EAAS,CAAC,CAAC,CAAC;EACpF,OAAO,KAAK;AACb","ignoreList":[]}

package/lib/commonjs/state/interaction-buffer.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buffer = buffer;
+exports.bufferedCount = bufferedCount;
+exports.drain = drain;
+/**
+ * The durable interaction buffer.
+ *
+ * A cold-start tap arrives before any handler exists. Holding it in memory
+ * would be enough if the process always survived — but the process is exactly
+ * what does not survive a cold start, so the buffer is persisted.
+ *
+ * This is the one content-bearing thing the package stores: an interaction
+ * cannot be delivered without its routing payload. It is evicted the moment it
+ * is delivered, and time-limited regardless, so an event nobody ever collects
+ * cannot sit on disk forever.
+ *
+ * Text the user typed into a reply action is never written to disk (NOT-14): it
+ * is free text, and the store is not encrypted. It is held in memory beside the
+ * buffer, so a handler registered later in the same process still receives it;
+ * if the process dies first, the event is delivered without `inputText`.
+ */
+
+/** Typed replies, in memory only, per state manager and buffered event id. */
+const typedReplies = new WeakMap();
+function repliesOf(state) {
+  let replies = typedReplies.get(state);
+  if (!replies) {
+    replies = new Map();
+    typedReplies.set(state, replies);
+  }
+  return replies;
+}
+
+/** Identity for a buffered event, derived so re-buffering cannot duplicate. */
+function bufferedId(event) {
+  return `${event.kind}:${event.notificationId}:${event.actionId ?? ''}:${event.occurredAt}`;
+}
+function buffer(state, event) {
+  const id = bufferedId(event);
+  if (event.inputText !== undefined) {
+    repliesOf(state).set(id, event.inputText);
+  }
+  state.update('interactionBuffer', current => {
+    if (current.some(entry => entry.id === id)) return current;
+    const entry = {
+      at: event.occurredAt,
+      id,
+      kind: event.kind,
+      notificationId: event.notificationId,
+      actionId: event.actionId,
+      routing: event.routing,
+      ownerTag: event.ownerTag
+    };
+    return [...current, entry];
+  });
+}
+
+/**
+ * Takes every buffered event in occurrence order and clears them.
+ *
+ * Draining and clearing together is deliberate: delivering an event twice is
+ * worse than the alternative, because a consumer that acts on an interaction
+ * (marking a task done, sending a reply) would act twice.
+ */
+function drain(state) {
+  const buffered = [...state.read().interactionBuffer].sort((a, b) => a.at - b.at);
+  if (buffered.length === 0) return [];
+  state.update('interactionBuffer', () => []);
+  const replies = repliesOf(state);
+  return buffered.map(entry => ({
+    kind: entry.kind,
+    notificationId: entry.notificationId,
+    actionId: entry.actionId,
+    // A record written before 0.5 may still carry the text on disk; it is
+    // delivered once, and the buffer was just cleared.
+    inputText: takeReply(replies, entry.id) ?? entry.inputText,
+    routing: entry.routing,
+    ownerTag: entry.ownerTag,
+    occurredAt: entry.at,
+    // The state it arrived in is gone; what matters to a consumer is that it
+    // waited, which is what `wasBuffered` says.
+    appState: 'coldStart',
+    wasBuffered: true
+  }));
+}
+function bufferedCount(state) {
+  return state.read().interactionBuffer.length;
+}
+function takeReply(replies, id) {
+  const text = replies.get(id);
+  replies.delete(id);
+  return text;
+}
+//# sourceMappingURL=interaction-buffer.js.map

package/lib/commonjs/state/interaction-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["typedReplies","WeakMap","repliesOf","state","replies","get","Map","set","bufferedId","event","kind","notificationId","actionId","occurredAt","buffer","id","inputText","undefined","update","current","some","entry","at","routing","ownerTag","drain","buffered","read","interactionBuffer","sort","a","b","length","map","takeReply","appState","wasBuffered","bufferedCount","text","delete"],"sourceRoot":"../../../src","sources":["state/interaction-buffer.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA,MAAMA,YAAY,GAAG,IAAIC,OAAO,CAAoC,CAAC;AAErE,SAASC,SAASA,CAACC,KAAmB,EAAuB;EAC5D,IAAIC,OAAO,GAAGJ,YAAY,CAACK,GAAG,CAACF,KAAK,CAAC;EACrC,IAAI,CAACC,OAAO,EAAE;IACbA,OAAO,GAAG,IAAIE,GAAG,CAAC,CAAC;IACnBN,YAAY,CAACO,GAAG,CAACJ,KAAK,EAAEC,OAAO,CAAC;EACjC;EACA,OAAOA,OAAO;AACf;;AAEA;AACA,SAASI,UAAUA,CAACC,KAAuB,EAAU;EACpD,OAAO,GAAGA,KAAK,CAACC,IAAI,IAAID,KAAK,CAACE,cAAc,IAAIF,KAAK,CAACG,QAAQ,IAAI,EAAE,IAAIH,KAAK,CAACI,UAAU,EAAE;AAC3F;AAEO,SAASC,MAAMA,CAACX,KAAmB,EAAEM,KAAuB,EAAQ;EAC1E,MAAMM,EAAE,GAAGP,UAAU,CAACC,KAAK,CAAC;EAC5B,IAAIA,KAAK,CAACO,SAAS,KAAKC,SAAS,EAAE;IAClCf,SAAS,CAACC,KAAK,CAAC,CAACI,GAAG,CAACQ,EAAE,EAAEN,KAAK,CAACO,SAAS,CAAC;EAC1C;EAEAb,KAAK,CAACe,MAAM,CAAC,mBAAmB,EAAEC,OAAO,IAAI;IAC5C,IAAIA,OAAO,CAACC,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACN,EAAE,KAAKA,EAAE,CAAC,EAAE,OAAOI,OAAO;IAE1D,MAAME,KAA0B,GAAG;MAClCC,EAAE,EAAEb,KAAK,CAACI,UAAU;MACpBE,EAAE;MACFL,IAAI,EAAED,KAAK,CAACC,IAAI;MAChBC,cAAc,EAAEF,KAAK,CAACE,cAAc;MACpCC,QAAQ,EAAEH,KAAK,CAACG,QAAQ;MACxBW,OAAO,EAAEd,KAAK,CAACc,OAAO;MACtBC,QAAQ,EAAEf,KAAK,CAACe;IACjB,CAAC;IACD,OAAO,CAAC,GAAGL,OAAO,EAAEE,KAAK,CAAC;EAC3B,CAAC,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASI,KAAKA,CAACtB,KAAmB,EAA+B;EACvE,MAAMuB,QAAQ,GAAG,CAAC,GAAGvB,KAAK,CAACwB,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAACC,IAAI,CAAC,CAACC,CAAC,EAAEC,CAAC,KAAKD,CAAC,CAACR,EAAE,GAAGS,CAAC,CAACT,EAAE,CAAC;EAEhF,IAAII,QAAQ,CAACM,MAAM,KAAK,CAAC,EAAE,OAAO,EAAE;EAEpC7B,KAAK,CAACe,MAAM,CAAC,mBAAmB,EAAE,MAAM,EAAE,CAAC;EAC3C,MAAMd,OAAO,GAAGF,SAAS,CAACC,KAAK,CAAC;EAEhC,OAAOuB,QAAQ,CAACO,GAAG,CAACZ,KAAK,KAAK;IAC7BX,IAAI,EAAEW,KAAK,CAACX,IAAI;IAChBC,cAAc,EAAEU,KAAK,CAACV,cAAc;IACpCC,QAAQ,EAAES,KAAK,CAACT,QAAQ;IACxB;IACA;IACAI,SAAS,EAAEkB,SAAS,CAAC9B,OAAO,EAAEiB,KAAK,CAACN,EAAE,CAAC,IAAIM,KAAK,CAACL,SAAS;IAC1DO,OAAO,EAAEF,KAAK,CAACE,OAAO;IACtBC,QAAQ,EAAEH,KAAK,CAACG,QAAQ;IACxBX,UAAU,EAAEQ,KAAK,CAACC,EAAE;IACpB;IACA;IACAa,QAAQ,EAAE,WAAoB;IAC9BC,WAAW,EAAE;EACd,CAAC,CAAC,CAAC;AACJ;AAEO,SAASC,aAAaA,CAAClC,KAAmB,EAAU;EAC1D,OAAOA,KAAK,CAACwB,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAACI,MAAM;AAC7C;AAEA,SAASE,SAASA,CAAC9B,OAA4B,EAAEW,EAAU,EAAsB;EAChF,MAAMuB,IAAI,GAAGlC,OAAO,CAACC,GAAG,CAACU,EAAE,CAAC;EAC5BX,OAAO,CAACmC,MAAM,CAACxB,EAAE,CAAC;EAClB,OAAOuB,IAAI;AACZ","ignoreList":[]}

package/lib/commonjs/state/mmkv-store.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMmkvStore = createMmkvStore;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _errors = require("../contract/errors.js");
+/**
+ * MMKV-backed state store.
+ *
+ * Every MMKV import is confined to this file, so the rest of the package stays
+ * testable without a native module.
+ *
+ * Backup exclusion is achieved by *where* the data lives rather than by setting
+ * a file attribute: on iOS the instance is rooted under `Library/Caches`, which
+ * the platform excludes from iCloud and iTunes backup by design. The OS may
+ * purge that directory under storage pressure — acceptable here precisely
+ * because discarding and rebuilding this record is already a specified,
+ * non-blocking condition.
+ *
+ * On Android, backup exclusion is declared in the consuming app's
+ * `data_extraction_rules.xml` and `full_backup_content`, documented in the
+ * README. It is the app's manifest, so it is the app's declaration to make.
+ */
+
+const INSTANCE_ID = 'chipmobilesdk.notification';
+const mmkv = (0, _rnCore.lazyPeer)('react-native-mmkv', () => {
+  // Inside `try`, so Metro bundles an app that leaves this optional peer out.
+  try {
+    return require('react-native-mmkv');
+  } catch (cause) {
+    throw cause;
+  }
+});
+const channel = (0, _rnCore.createDiagnosticChannel)('rn-notification');
+/**
+ * Creates the persistent store, falling back to memory when MMKV is absent.
+ *
+ * The fallback is deliberate: a missing optional native module degrades
+ * deduplication and cold-start buffering to session scope, which is a
+ * documented degradation. It must never stop notifications being delivered, and
+ * it is never silent (NOT-15): it reports `STATE_STORE_DEGRADED` to the app's SDK
+ * sinks and to `onDegraded`, and the store reports `durable: false`.
+ */
+function createMmkvStore(options = {}) {
+  const port = (0, _rnCore.openDurable)(() =>
+  // v4's factory: up to 0.2.0 this called the v3 `new MMKV()`, which v4 no
+  // longer exports as a value, so every device silently got memory.
+  mmkv.require(peer => new Error(`${peer} is not installed`)).createMMKV({
+    id: INSTANCE_ID,
+    // Caches is backup-excluded by platform design; see the note above.
+    ...((0, _rnCore.currentPlatform)() === 'ios' ? {
+      path: 'Library/Caches/chipmobilesdk-notification'
+    } : {})
+  }), cause => {
+    channel.emit(_errors.DIAGNOSTIC_CODES.STATE_STORE_DEGRADED, 'warn');
+    options.onDegraded?.(cause);
+  });
+  return {
+    getString: key => port.getString(key),
+    setString: (key, value) => port.set(key, value),
+    delete: key => port.remove(key),
+    clearAll: () => port.clearAll(),
+    approximateBytes: () => {
+      let total = 0;
+      for (const key of port.keys()) {
+        total += key.length + (port.getString(key)?.length ?? 0);
+      }
+      return total;
+    },
+    durable: port.durable
+  };
+}
+//# sourceMappingURL=mmkv-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_errors","INSTANCE_ID","mmkv","lazyPeer","cause","channel","createDiagnosticChannel","createMmkvStore","options","port","openDurable","peer","Error","createMMKV","id","currentPlatform","path","emit","DIAGNOSTIC_CODES","STATE_STORE_DEGRADED","onDegraded","getString","key","setString","value","set","delete","remove","clearAll","approximateBytes","total","keys","length","durable"],"sourceRoot":"../../../src","sources":["state/mmkv-store.ts"],"mappings":";;;;;;AAkBA,IAAAA,OAAA,GAAAC,OAAA;AAQA,IAAAC,OAAA,GAAAD,OAAA;AA1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAaA,MAAME,WAAW,GAAG,4BAA4B;AAEhD,MAAMC,IAAI,GAAG,IAAAC,gBAAQ,EAAC,mBAAmB,EAAE,MAAM;EAChD;EACA,IAAI;IACH,OAAOJ,OAAO,CAAC,mBAAmB,CAAC;EAGpC,CAAC,CAAC,OAAOK,KAAK,EAAE;IACf,MAAMA,KAAK;EACZ;AACD,CAAC,CAAC;AAEF,MAAMC,OAAO,GAAG,IAAAC,+BAAuB,EAAC,iBAAiB,CAAC;AAO1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,eAAeA,CAACC,OAAyB,GAAG,CAAC,CAAC,EAAc;EAC3E,MAAMC,IAAI,GAAG,IAAAC,mBAAW,EACvB;EACC;EACA;EACAR,IAAI,CACFH,OAAO,CAACY,IAAI,IAAI,IAAIC,KAAK,CAAC,GAAGD,IAAI,mBAAmB,CAAC,CAAC,CACtDE,UAAU,CAAC;IACXC,EAAE,EAAEb,WAAW;IACf;IACA,IAAI,IAAAc,uBAAe,EAAC,CAAC,KAAK,KAAK,GAC5B;MAAEC,IAAI,EAAE;IAA4C,CAAC,GACrD,CAAC,CAAC;EACN,CAAC,CAAC,EACJZ,KAAK,IAAI;IACRC,OAAO,CAACY,IAAI,CAACC,wBAAgB,CAACC,oBAAoB,EAAE,MAAM,CAAC;IAC3DX,OAAO,CAACY,UAAU,GAAGhB,KAAK,CAAC;EAC5B,CACD,CAAC;EACD,OAAO;IACNiB,SAAS,EAAEC,GAAG,IAAIb,IAAI,CAACY,SAAS,CAACC,GAAG,CAAC;IACrCC,SAAS,EAAEA,CAACD,GAAG,EAAEE,KAAK,KAAKf,IAAI,CAACgB,GAAG,CAACH,GAAG,EAAEE,KAAK,CAAC;IAC/CE,MAAM,EAAEJ,GAAG,IAAIb,IAAI,CAACkB,MAAM,CAACL,GAAG,CAAC;IAC/BM,QAAQ,EAAEA,CAAA,KAAMnB,IAAI,CAACmB,QAAQ,CAAC,CAAC;IAC/BC,gBAAgB,EAAEA,CAAA,KAAM;MACvB,IAAIC,KAAK,GAAG,CAAC;MACb,KAAK,MAAMR,GAAG,IAAIb,IAAI,CAACsB,IAAI,CAAC,CAAC,EAAE;QAC9BD,KAAK,IAAIR,GAAG,CAACU,MAAM,IAAIvB,IAAI,CAACY,SAAS,CAACC,GAAG,CAAC,EAAEU,MAAM,IAAI,CAAC,CAAC;MACzD;MACA,OAAOF,KAAK;IACb,CAAC;IACDG,OAAO,EAAExB,IAAI,CAACwB;EACf,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/state/permission-history.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearDenials = clearDenials;
+exports.denialCount = denialCount;
+exports.hasRequested = hasRequested;
+exports.recordDenial = recordDenial;
+exports.recordRequested = recordRequested;
+/**
+ * Permission-request history.
+ *
+ * The platform cannot tell you whether you have already asked. On both
+ * platforms a second request after a denial is silently a no-op, so an app that
+ * does not remember will keep "asking" and keep appearing to be refused.
+ *
+ * Keyed by owner tag so a multi-account device can clear one account's history
+ * on sign-out without forgetting what it asked the others.
+ */
+
+function key(kind, ownerTag) {
+  return `${ownerTag ?? '*'}:${kind}`;
+}
+function hasRequested(state, kind, ownerTag) {
+  const target = key(kind, ownerTag);
+  return state.read().permissionHistory.some(entry => entry.key === target && entry.requested);
+}
+function recordRequested(state, kind, now, ownerTag) {
+  const target = key(kind, ownerTag);
+  if (hasRequested(state, kind, ownerTag)) return;
+  state.update('permissionHistory', current => [...current.filter(entry => entry.key !== target), {
+    at: now,
+    key: target,
+    requested: true
+  }]);
+}
+
+/** The device-wide key: a refusal is the user's answer to the app, not to one account. */
+const DEVICE = '#device';
+
+/** How many requests for `kind` the user has refused on this device. */
+function denialCount(state, kind) {
+  const target = key(kind, DEVICE);
+  return state.read().permissionHistory.find(entry => entry.key === target)?.denials ?? 0;
+}
+function recordDenial(state, kind, now) {
+  const target = key(kind, DEVICE);
+  const denials = denialCount(state, kind) + 1;
+  state.update('permissionHistory', current => [...current.filter(entry => entry.key !== target), {
+    at: now,
+    key: target,
+    requested: true,
+    denials
+  }]);
+}
+
+/** Forgets refusals once the permission is seen granted: the next refusal starts over. */
+function clearDenials(state, kind) {
+  if (denialCount(state, kind) === 0) return;
+  const target = key(kind, DEVICE);
+  state.update('permissionHistory', current => current.filter(entry => entry.key !== target));
+}
+//# sourceMappingURL=permission-history.js.map

package/lib/commonjs/state/permission-history.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["key","kind","ownerTag","hasRequested","state","target","read","permissionHistory","some","entry","requested","recordRequested","now","update","current","filter","at","DEVICE","denialCount","find","denials","recordDenial","clearDenials"],"sourceRoot":"../../../src","sources":["state/permission-history.ts"],"mappings":";;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA,SAASA,GAAGA,CAACC,IAAoB,EAAEC,QAAiB,EAAU;EAC7D,OAAO,GAAGA,QAAQ,IAAI,GAAG,IAAID,IAAI,EAAE;AACpC;AAEO,SAASE,YAAYA,CAC3BC,KAAmB,EACnBH,IAAoB,EACpBC,QAAiB,EACP;EACV,MAAMG,MAAM,GAAGL,GAAG,CAACC,IAAI,EAAEC,QAAQ,CAAC;EAClC,OAAOE,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAACC,IAAI,CAACC,KAAK,IAAIA,KAAK,CAACT,GAAG,KAAKK,MAAM,IAAII,KAAK,CAACC,SAAS,CAAC;AAC7F;AAEO,SAASC,eAAeA,CAC9BP,KAAmB,EACnBH,IAAoB,EACpBW,GAAW,EACXV,QAAiB,EACV;EACP,MAAMG,MAAM,GAAGL,GAAG,CAACC,IAAI,EAAEC,QAAQ,CAAC;EAClC,IAAIC,YAAY,CAACC,KAAK,EAAEH,IAAI,EAAEC,QAAQ,CAAC,EAAE;EAEzCE,KAAK,CAACS,MAAM,CAAC,mBAAmB,EAAEC,OAAO,IAAI,CAC5C,GAAGA,OAAO,CAACC,MAAM,CAACN,KAAK,IAAIA,KAAK,CAACT,GAAG,KAAKK,MAAM,CAAC,EAChD;IAAEW,EAAE,EAAEJ,GAAG;IAAEZ,GAAG,EAAEK,MAAM;IAAEK,SAAS,EAAE;EAAK,CAAC,CACzC,CAAC;AACH;;AAEA;AACA,MAAMO,MAAM,GAAG,SAAS;;AAExB;AACO,SAASC,WAAWA,CAACd,KAAmB,EAAEH,IAAoB,EAAU;EAC9E,MAAMI,MAAM,GAAGL,GAAG,CAACC,IAAI,EAAEgB,MAAM,CAAC;EAChC,OAAOb,KAAK,CAACE,IAAI,CAAC,CAAC,CAACC,iBAAiB,CAACY,IAAI,CAACV,KAAK,IAAIA,KAAK,CAACT,GAAG,KAAKK,MAAM,CAAC,EAAEe,OAAO,IAAI,CAAC;AACxF;AAEO,SAASC,YAAYA,CAACjB,KAAmB,EAAEH,IAAoB,EAAEW,GAAW,EAAQ;EAC1F,MAAMP,MAAM,GAAGL,GAAG,CAACC,IAAI,EAAEgB,MAAM,CAAC;EAChC,MAAMG,OAAO,GAAGF,WAAW,CAACd,KAAK,EAAEH,IAAI,CAAC,GAAG,CAAC;EAC5CG,KAAK,CAACS,MAAM,CAAC,mBAAmB,EAAEC,OAAO,IAAI,CAC5C,GAAGA,OAAO,CAACC,MAAM,CAACN,KAAK,IAAIA,KAAK,CAACT,GAAG,KAAKK,MAAM,CAAC,EAChD;IAAEW,EAAE,EAAEJ,GAAG;IAAEZ,GAAG,EAAEK,MAAM;IAAEK,SAAS,EAAE,IAAI;IAAEU;EAAQ,CAAC,CAClD,CAAC;AACH;;AAEA;AACO,SAASE,YAAYA,CAAClB,KAAmB,EAAEH,IAAoB,EAAQ;EAC7E,IAAIiB,WAAW,CAACd,KAAK,EAAEH,IAAI,CAAC,KAAK,CAAC,EAAE;EACpC,MAAMI,MAAM,GAAGL,GAAG,CAACC,IAAI,EAAEgB,MAAM,CAAC;EAChCb,KAAK,CAACS,MAAM,CAAC,mBAAmB,EAAEC,OAAO,IAAIA,OAAO,CAACC,MAAM,CAACN,KAAK,IAAIA,KAAK,CAACT,GAAG,KAAKK,MAAM,CAAC,CAAC;AAC5F","ignoreList":[]}