@chipmobilesdk/rn-notification 0.6.0 → 0.7.0

package/lib/commonjs/schedule/resolve-moment.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PAST_TOLERANCE_MS = void 0;
+exports.resolveMoment = resolveMoment;
+exports.validateMoment = validateMoment;
+var _errors = require("../contract/errors.js");
+/**
+ * Delivery moment resolution.
+ *
+ * Two rules, and they are two sides of one decision rather than a threshold:
+ * a moment more than the tolerance in the past is a caller error and is
+ * refused; a moment a few seconds in the past is a processing delay and is
+ * delivered promptly. Both outcomes are reported, so a caller never has to
+ * guess which happened.
+ *
+ * Sixty seconds is long enough to absorb reconciling a large desired set, cold
+ * start work, and clock skew, and short enough that a genuinely stale schedule
+ * is still caught rather than fired at the user minutes late with no
+ * explanation.
+ */
+
+const PAST_TOLERANCE_MS = exports.PAST_TOLERANCE_MS = 60_000;
+/**
+ * Classifies a resolved instant against now.
+ *
+ * Takes an already-anchored instant: anchoring decides *which* instant a moment
+ * means, and this decides whether that instant is usable. Keeping them separate
+ * is what lets each be tested without the other.
+ */
+function resolveMoment(resolvedAt, now) {
+  if (!Number.isFinite(resolvedAt)) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.MOMENT_IN_PAST, 'A delivery moment must be a finite epoch-millisecond timestamp.', {
+      received: String(resolvedAt)
+    });
+  }
+  if (resolvedAt >= now) {
+    return {
+      kind: 'future',
+      at: resolvedAt
+    };
+  }
+  const lateBy = now - resolvedAt;
+  if (lateBy <= PAST_TOLERANCE_MS) {
+    return {
+      kind: 'immediate',
+      at: now,
+      lateBy
+    };
+  }
+  throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.MOMENT_IN_PAST, `Delivery moment is ${Math.round(lateBy / 1000)}s in the past, beyond the ${PAST_TOLERANCE_MS / 1000}s tolerance. ` + 'It was not scheduled, because handing it to the platform would fire it immediately without explanation.', {
+    lateByMs: lateBy,
+    toleranceMs: PAST_TOLERANCE_MS
+  });
+}
+
+/** Validates the shape of a caller-supplied moment before anchoring resolves it. */
+function validateMoment(moment) {
+  if (typeof moment.at !== 'number' || !Number.isFinite(moment.at)) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.MOMENT_IN_PAST, 'A delivery moment must carry a finite epoch-millisecond `at` value.', {
+      received: typeof moment.at
+    });
+  }
+  if (moment.anchoring !== undefined && moment.anchoring !== 'wallClock' && moment.anchoring !== 'absolute') {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.MOMENT_IN_PAST, 'Anchoring must be either "wallClock" or "absolute".', {
+      received: String(moment.anchoring)
+    });
+  }
+}
+//# sourceMappingURL=resolve-moment.js.map

package/lib/commonjs/schedule/resolve-moment.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","PAST_TOLERANCE_MS","exports","resolveMoment","resolvedAt","now","Number","isFinite","NotificationError","DIAGNOSTIC_CODES","MOMENT_IN_PAST","received","String","kind","at","lateBy","Math","round","lateByMs","toleranceMs","validateMoment","moment","anchoring","undefined"],"sourceRoot":"../../../src","sources":["schedule/resolve-moment.ts"],"mappings":";;;;;;;;AAeA,IAAAA,OAAA,GAAAC,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKO,MAAMC,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,MAAM;AAMvC;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,aAAaA,CAACC,UAAkB,EAAEC,GAAW,EAAoB;EAChF,IAAI,CAACC,MAAM,CAACC,QAAQ,CAACH,UAAU,CAAC,EAAE;IACjC,MAAM,IAAII,yBAAiB,CAC1BC,wBAAgB,CAACC,cAAc,EAC/B,iEAAiE,EACjE;MAAEC,QAAQ,EAAEC,MAAM,CAACR,UAAU;IAAE,CAChC,CAAC;EACF;EAEA,IAAIA,UAAU,IAAIC,GAAG,EAAE;IACtB,OAAO;MAAEQ,IAAI,EAAE,QAAQ;MAAEC,EAAE,EAAEV;IAAW,CAAC;EAC1C;EAEA,MAAMW,MAAM,GAAGV,GAAG,GAAGD,UAAU;EAE/B,IAAIW,MAAM,IAAId,iBAAiB,EAAE;IAChC,OAAO;MAAEY,IAAI,EAAE,WAAW;MAAEC,EAAE,EAAET,GAAG;MAAEU;IAAO,CAAC;EAC9C;EAEA,MAAM,IAAIP,yBAAiB,CAC1BC,wBAAgB,CAACC,cAAc,EAC/B,sBAAsBM,IAAI,CAACC,KAAK,CAACF,MAAM,GAAG,IAAI,CAAC,6BAA6Bd,iBAAiB,GAAG,IAAI,eAAe,GAClH,yGAAyG,EAC1G;IAAEiB,QAAQ,EAAEH,MAAM;IAAEI,WAAW,EAAElB;EAAkB,CACpD,CAAC;AACF;;AAEA;AACO,SAASmB,cAAcA,CAACC,MAAsB,EAAQ;EAC5D,IAAI,OAAOA,MAAM,CAACP,EAAE,KAAK,QAAQ,IAAI,CAACR,MAAM,CAACC,QAAQ,CAACc,MAAM,CAACP,EAAE,CAAC,EAAE;IACjE,MAAM,IAAIN,yBAAiB,CAC1BC,wBAAgB,CAACC,cAAc,EAC/B,qEAAqE,EACrE;MAAEC,QAAQ,EAAE,OAAOU,MAAM,CAACP;IAAG,CAC9B,CAAC;EACF;EAEA,IACCO,MAAM,CAACC,SAAS,KAAKC,SAAS,IAC9BF,MAAM,CAACC,SAAS,KAAK,WAAW,IAChCD,MAAM,CAACC,SAAS,KAAK,UAAU,EAC9B;IACD,MAAM,IAAId,yBAAiB,CAC1BC,wBAAgB,CAACC,cAAc,EAC/B,qDAAqD,EACrD;MAAEC,QAAQ,EAAEC,MAAM,CAACS,MAAM,CAACC,SAAS;IAAE,CACtC,CAAC;EACF;AACD","ignoreList":[]}

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

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CONTENT_LIMITS = void 0;
+exports.byteLength = byteLength;
+exports.validateContent = validateContent;
+var _errors = require("../contract/errors.js");
+/**
+ * Content validation.
+ *
+ * The package passes content through **unchanged** and never truncates it.
+ * Display truncation is the platform's decision and differs between them; a
+ * library that pre-truncated would be guessing at a rule it does not own, and
+ * would corrupt content that would have displayed fine.
+ *
+ * What it does refuse is content over the platform's hard payload limit, where
+ * the alternative is not a shortened notification but a failed or undefined
+ * delivery. That is a real error and is reported as one, before any platform
+ * call.
+ */
+
+/**
+ * Hard payload ceilings.
+ *
+ * These are *not* display limits. A title longer than a phone shows is fine and
+ * is passed through; the README documents where each platform visually
+ * truncates so a caller can decide for itself.
+ *
+ * The total is deliberately lower than the sum of the parts, so it actually
+ * binds — a per-field check that can never be exceeded in aggregate would be
+ * dead code. It sits under the 4 KB payload budget both platforms enforce,
+ * leaving headroom for the routing payload that shares it.
+ */
+const CONTENT_LIMITS = exports.CONTENT_LIMITS = {
+  maxTitleBytes: 512,
+  maxBodyBytes: 3072,
+  maxSubtitleBytes: 512,
+  maxTotalBytes: 3584
+};
+
+/** UTF-8 byte length — the unit the platforms actually bound. */
+function byteLength(value) {
+  let bytes = 0;
+  for (const char of value) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code <= 0x7f) bytes += 1;else if (code <= 0x7ff) bytes += 2;else if (code <= 0xffff) bytes += 3;else bytes += 4;
+  }
+  return bytes;
+}
+function requireString(value, field) {
+  if (typeof value !== 'string') {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.CONTENT_TOO_LARGE, `Notification content field "${field}" must be a string of resolved display text. The package performs no locale resolution.`, {
+      field,
+      received: typeof value
+    });
+  }
+  return value;
+}
+
+/**
+ * Validates content and returns it **byte-identical**.
+ *
+ * The return value is the same object reference where possible, so nothing
+ * downstream can mistake this for a transformation step.
+ */
+function validateContent(content) {
+  const title = requireString(content.title, 'title');
+  const body = requireString(content.body, 'body');
+  const subtitle = content.subtitle === undefined ? undefined : requireString(content.subtitle, 'subtitle');
+  if (title.length === 0 && body.length === 0) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.CONTENT_TOO_LARGE, 'A notification must carry a title or a body; both were empty.', {
+      field: 'title+body'
+    });
+  }
+  const checks = [['title', title, CONTENT_LIMITS.maxTitleBytes], ['body', body, CONTENT_LIMITS.maxBodyBytes]];
+  if (subtitle !== undefined) {
+    checks.push(['subtitle', subtitle, CONTENT_LIMITS.maxSubtitleBytes]);
+  }
+  for (const [field, value, limit] of checks) {
+    const size = byteLength(value);
+    if (size > limit) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.CONTENT_TOO_LARGE, `Notification "${field}" is ${size} bytes, over the ${limit}-byte platform limit. ` + "It was refused rather than truncated, because the package does not decide where a caller's content should be cut.", {
+        field,
+        bytes: size,
+        limit
+      });
+    }
+  }
+  const total = byteLength(title) + byteLength(body) + (subtitle ? byteLength(subtitle) : 0);
+  if (total > CONTENT_LIMITS.maxTotalBytes) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.CONTENT_TOO_LARGE, `Notification content totals ${total} bytes, over the ${CONTENT_LIMITS.maxTotalBytes}-byte payload limit.`, {
+      field: 'total',
+      bytes: total,
+      limit: CONTENT_LIMITS.maxTotalBytes
+    });
+  }
+  return content;
+}
+//# sourceMappingURL=validate-content.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","CONTENT_LIMITS","exports","maxTitleBytes","maxBodyBytes","maxSubtitleBytes","maxTotalBytes","byteLength","value","bytes","char","code","codePointAt","requireString","field","NotificationError","DIAGNOSTIC_CODES","CONTENT_TOO_LARGE","received","validateContent","content","title","body","subtitle","undefined","length","checks","push","limit","size","total"],"sourceRoot":"../../../src","sources":["schedule/validate-content.ts"],"mappings":"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","ignoreList":[]}

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