@chipmobilesdk/rn-notification 0.6.0 → 0.7.0

package/lib/commonjs/repeat/marker.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.REPEAT_STOP_PREFIX = void 0;
+exports.isRepeatStopId = isRepeatStopId;
+exports.markerIdFor = markerIdFor;
+exports.repeatStopFor = repeatStopFor;
+var _hash = require("../contract/hash.js");
+/**
+ * Stop-marker identity.
+ *
+ * A repeating alert has to end without the app being alive, and no platform
+ * offers "stop the sound at time T but keep the notification". So the package
+ * schedules its own notification at T and reacts to its delivery. That
+ * notification is a *marker*: it exists to be delivered and immediately
+ * removed, never to be read.
+ *
+ * The marker's identifier is derived from the target's by hashing rather than by
+ * concatenation. Concatenation would overflow the package's 128-character
+ * identifier limit for any target already near it, and would make the marker's
+ * identity a function of a value the consumer controls — which is how a
+ * consumer identifier ends up colliding with an internal one.
+ */
+
+/**
+ * Reserved identifier namespace.
+ *
+ * Rejected as a consumer identifier prefix. A consumer id colliding with a
+ * marker would not merely confuse a listing: the expiry handler cancels
+ * markers, so the collision would delete a real notification.
+ */
+const REPEAT_STOP_PREFIX = exports.REPEAT_STOP_PREFIX = 'cms.stop:';
+
+/**
+ * The marker identifier for a target notification.
+ *
+ * Two independent hashes rather than one: a single 32-bit hash collides often
+ * enough to matter once a device holds a handful of alarms, and a collision here
+ * means one alarm's marker silences the other alarm and never silences its own.
+ */
+function markerIdFor(targetId) {
+  return `${REPEAT_STOP_PREFIX}${(0, _hash.hex8)((0, _hash.fnv1a)(targetId, 0x811c9dc5))}${(0, _hash.hex8)((0, _hash.fnv1a)(targetId, 0x9e3779b9))}`;
+}
+function isRepeatStopId(id) {
+  return id.startsWith(REPEAT_STOP_PREFIX);
+}
+
+/** Describes the stop for a target whose alert must end at a known instant. */
+function repeatStopFor(targetId, deliveredAt, forMs) {
+  return {
+    markerId: markerIdFor(targetId),
+    targetId,
+    dueAt: deliveredAt + forMs
+  };
+}
+//# sourceMappingURL=marker.js.map

package/lib/commonjs/repeat/marker.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hash","require","REPEAT_STOP_PREFIX","exports","markerIdFor","targetId","hex8","fnv1a","isRepeatStopId","id","startsWith","repeatStopFor","deliveredAt","forMs","markerId","dueAt"],"sourceRoot":"../../../src","sources":["repeat/marker.ts"],"mappings":";;;;;;;;;AAgBA,IAAAA,KAAA,GAAAC,OAAA;AAhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,WAAW;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,WAAWA,CAACC,QAAgB,EAAU;EACrD,OAAO,GAAGH,kBAAkB,GAAG,IAAAI,UAAI,EAAC,IAAAC,WAAK,EAACF,QAAQ,EAAE,UAAU,CAAC,CAAC,GAAG,IAAAC,UAAI,EAAC,IAAAC,WAAK,EAACF,QAAQ,EAAE,UAAU,CAAC,CAAC,EAAE;AACvG;AAEO,SAASG,cAAcA,CAACC,EAAU,EAAW;EACnD,OAAOA,EAAE,CAACC,UAAU,CAACR,kBAAkB,CAAC;AACzC;;AAEA;AACO,SAASS,aAAaA,CAACN,QAAgB,EAAEO,WAAmB,EAAEC,KAAa,EAAc;EAC/F,OAAO;IACNC,QAAQ,EAAEV,WAAW,CAACC,QAAQ,CAAC;IAC/BA,QAAQ;IACRU,KAAK,EAAEH,WAAW,GAAGC;EACtB,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/repeat/place.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStopPlacement = createStopPlacement;
+var _marker = require("./marker.js");
+/**
+ * Keeping a notification's stop marker in step with the notification.
+ *
+ * Shared by the scheduler and the reconciler rather than written twice. They are
+ * two doors into the same act — reconciliation is how most consumers schedule —
+ * and a bound that only existed on one path would be a bound that mostly did not
+ * exist.
+ */
+
+function createStopPlacement(engine) {
+  /** `snapshot`: read once and kept current, for a pass; otherwise read on every call. */
+  function placement(snapshot) {
+    let known;
+
+    /** targetId → markerId of every outstanding stop. */
+    const outstanding = async () => {
+      if (snapshot && known) {
+        return known;
+      }
+      const read = new Map((await engine.listRepeatStops()).map(stop => [stop.targetId, stop.markerId]));
+      if (snapshot) {
+        known = read;
+      }
+      return read;
+    };
+    const release = async targetId => {
+      const stops = await outstanding();
+      const markerId = stops.get(targetId);
+      if (markerId !== undefined) {
+        await engine.cancel(markerId);
+        stops.delete(targetId);
+      }
+    };
+    return {
+      release,
+      async count() {
+        return (await outstanding()).size;
+      },
+      async sync(targetId, tone, deliversAt) {
+        await release(targetId);
+        const forMs = tone.android.repeatForMs;
+        if (!tone.android.loopSound || forMs === undefined) return;
+        const capabilities = await engine.getCapabilities();
+        if (!capabilities.supportsRepeatingAlert) return;
+        const stop = (0, _marker.repeatStopFor)(targetId, deliversAt, forMs);
+        await engine.schedule({
+          request: {
+            id: stop.markerId,
+            // Deliberately empty. A marker is delivered and removed within the
+            // same handler invocation; anything readable here would be text a
+            // user might glimpse and be confused by.
+            content: {
+              title: '',
+              body: ''
+            },
+            tone: tone.toneId,
+            // Absolute: the bound is a duration from a known instant, not a
+            // wall-clock time that should follow the user across time zones.
+            moment: {
+              at: stop.dueAt,
+              anchoring: 'absolute'
+            }
+          },
+          resolvedAt: stop.dueAt,
+          tone,
+          approximate: false,
+          repeatStop: stop
+        });
+        known?.set(targetId, stop.markerId);
+      },
+      pass: () => placement(true)
+    };
+  }
+  return placement(false);
+}
+//# sourceMappingURL=place.js.map

package/lib/commonjs/repeat/place.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_marker","require","createStopPlacement","engine","placement","snapshot","known","outstanding","read","Map","listRepeatStops","map","stop","targetId","markerId","release","stops","get","undefined","cancel","delete","count","size","sync","tone","deliversAt","forMs","android","repeatForMs","loopSound","capabilities","getCapabilities","supportsRepeatingAlert","repeatStopFor","schedule","request","id","content","title","body","toneId","moment","at","dueAt","anchoring","resolvedAt","approximate","repeatStop","set","pass"],"sourceRoot":"../../../src","sources":["repeat/place.ts"],"mappings":";;;;;;AAWA,IAAAA,OAAA,GAAAC,OAAA;AAXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkCO,SAASC,mBAAmBA,CAACC,MAAiC,EAAiB;EACrF;EACA,SAASC,SAASA,CAACC,QAAiB,EAAiB;IACpD,IAAIC,KAAsC;;IAE1C;IACA,MAAMC,WAAW,GAAG,MAAAA,CAAA,KAA0C;MAC7D,IAAIF,QAAQ,IAAIC,KAAK,EAAE;QACtB,OAAOA,KAAK;MACb;MACA,MAAME,IAAI,GAAG,IAAIC,GAAG,CACnB,CAAC,MAAMN,MAAM,CAACO,eAAe,CAAC,CAAC,EAAEC,GAAG,CAACC,IAAI,IAAI,CAACA,IAAI,CAACC,QAAQ,EAAED,IAAI,CAACE,QAAQ,CAAU,CACrF,CAAC;MACD,IAAIT,QAAQ,EAAE;QACbC,KAAK,GAAGE,IAAI;MACb;MACA,OAAOA,IAAI;IACZ,CAAC;IAED,MAAMO,OAAO,GAAG,MAAOF,QAAgB,IAAoB;MAC1D,MAAMG,KAAK,GAAG,MAAMT,WAAW,CAAC,CAAC;MACjC,MAAMO,QAAQ,GAAGE,KAAK,CAACC,GAAG,CAACJ,QAAQ,CAAC;MACpC,IAAIC,QAAQ,KAAKI,SAAS,EAAE;QAC3B,MAAMf,MAAM,CAACgB,MAAM,CAACL,QAAQ,CAAC;QAC7BE,KAAK,CAACI,MAAM,CAACP,QAAQ,CAAC;MACvB;IACD,CAAC;IAED,OAAO;MACNE,OAAO;MAEP,MAAMM,KAAKA,CAAA,EAAG;QACb,OAAO,CAAC,MAAMd,WAAW,CAAC,CAAC,EAAEe,IAAI;MAClC,CAAC;MAED,MAAMC,IAAIA,CAACV,QAAQ,EAAEW,IAAI,EAAEC,UAAU,EAAE;QACtC,MAAMV,OAAO,CAACF,QAAQ,CAAC;QAEvB,MAAMa,KAAK,GAAGF,IAAI,CAACG,OAAO,CAACC,WAAW;QACtC,IAAI,CAACJ,IAAI,CAACG,OAAO,CAACE,SAAS,IAAIH,KAAK,KAAKR,SAAS,EAAE;QAEpD,MAAMY,YAAY,GAAG,MAAM3B,MAAM,CAAC4B,eAAe,CAAC,CAAC;QACnD,IAAI,CAACD,YAAY,CAACE,sBAAsB,EAAE;QAE1C,MAAMpB,IAAI,GAAG,IAAAqB,qBAAa,EAACpB,QAAQ,EAAEY,UAAU,EAAEC,KAAK,CAAC;QACvD,MAAMvB,MAAM,CAAC+B,QAAQ,CAAC;UACrBC,OAAO,EAAE;YACRC,EAAE,EAAExB,IAAI,CAACE,QAAQ;YACjB;YACA;YACA;YACAuB,OAAO,EAAE;cAAEC,KAAK,EAAE,EAAE;cAAEC,IAAI,EAAE;YAAG,CAAC;YAChCf,IAAI,EAAEA,IAAI,CAACgB,MAAM;YACjB;YACA;YACAC,MAAM,EAAE;cAAEC,EAAE,EAAE9B,IAAI,CAAC+B,KAAK;cAAEC,SAAS,EAAE;YAAW;UACjD,CAAC;UACDC,UAAU,EAAEjC,IAAI,CAAC+B,KAAK;UACtBnB,IAAI;UACJsB,WAAW,EAAE,KAAK;UAClBC,UAAU,EAAEnC;QACb,CAAC,CAAC;QACFN,KAAK,EAAE0C,GAAG,CAACnC,QAAQ,EAAED,IAAI,CAACE,QAAQ,CAAC;MACpC,CAAC;MAEDmC,IAAI,EAAEA,CAAA,KAAM7C,SAAS,CAAC,IAAI;IAC3B,CAAC;EACF;EAEA,OAAOA,SAAS,CAAC,KAAK,CAAC;AACxB","ignoreList":[]}

package/lib/commonjs/schedule/anchor.js

@@ -0,0 +1,243 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anchorMoment = anchorMoment;
+exports.createPlatformTimeZoneReader = createPlatformTimeZoneReader;
+exports.instantForParts = instantForParts;
+exports.isStaleAnchor = isStaleAnchor;
+exports.isValidTimeZone = isValidTimeZone;
+exports.partsInZone = partsInZone;
+exports.planReAnchor = planReAnchor;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _notification = require("../contract/notification.js");
+/**
+ * Time-zone anchoring and re-anchoring.
+ *
+ * Wall-clock is the default because reminders are wall-clock things: an 08:00
+ * reminder should stay 08:00 after the user crosses a time zone, and a caller
+ * who does not choose should get what their users expect rather than a silent
+ * shift.
+ *
+ * The cost is re-anchoring. When the device zone changes, every scheduled
+ * wall-clock entry must be rewritten to preserve the clock time it named, and
+ * every absolute entry must be left completely alone.
+ *
+ * The limit this cannot fix is stated rather than hidden: a wall-clock
+ * notification whose moment arrives while the app has not run since the zone
+ * changed fires at the previously anchored instant. The anchoring generation on
+ * each entry is what makes that detectable instead of invisible.
+ */
+
+/** Reads the platform time zone. Injected so the pure logic needs no native module. */
+
+const localizePeer = (0, _rnCore.lazyPeer)('react-native-localize', () => {
+  // Inside `try`, so Metro bundles an app that leaves this optional peer out.
+  try {
+    return require('react-native-localize');
+  } catch (cause) {
+    throw cause;
+  }
+});
+
+/**
+ * Resolves the platform zone via `react-native-localize`.
+ *
+ * Pure JavaScript is not sufficient here: `Intl.DateTimeFormat().resolvedOptions().timeZone`
+ * is documented in React Native as not reliably updating when the device zone
+ * changes, so it cannot back re-anchoring. Falls back to `Intl` only when the
+ * module is absent, which is better than failing outright.
+ */
+function createPlatformTimeZoneReader() {
+  return () => {
+    const localize = localizePeer.get();
+    try {
+      if (localize.ok) return localize.module.getTimeZone();
+      return Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'UTC';
+    } catch {
+      try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'UTC';
+      } catch {
+        return 'UTC';
+      }
+    }
+  };
+}
+
+/** The calendar fields a wall-clock moment actually names. */
+
+/**
+ * Whether a zone name is one the runtime can actually format against.
+ *
+ * Hermes throws a hard `JSRangeErrorException: Invalid timezone name!` for a
+ * bad zone, which kills the JavaScript thread rather than returning an error.
+ * A stored anchoring generation is data that can be wrong — a corrupted record,
+ * an entry written by an older build, or a defect like the one that stored a
+ * tone id here — so it must be checked before it reaches `Intl`.
+ */
+function isValidTimeZone(timeZone) {
+  // rn-core memoizes the answer per zone: a recurrence expansion asks thousands
+  // of times about the same few zones (PERF-01).
+  return (0, _rnCore.isValidTimeZone)(timeZone);
+}
+
+/** The options `partsInZone` formats with; one shared formatter per zone. */
+const PARTS_OPTIONS = {
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+  hour: '2-digit',
+  minute: '2-digit',
+  second: '2-digit',
+  hour12: false
+};
+
+/**
+ * Decomposes an instant into the clock reading it produces in a given zone.
+ *
+ * Falls back to UTC for an unusable zone rather than throwing: a bad stored
+ * value should degrade one entry's anchoring, not crash the app.
+ */
+function partsInZone(instant, timeZone) {
+  const zone = isValidTimeZone(timeZone) ? timeZone : 'UTC';
+  // Built once per zone and reused (PERF-01): constructing one per call was
+  // most of the cost of expanding a recurrence.
+  const formatter = (0, _rnCore.getDateTimeFormat)('en-US', {
+    ...PARTS_OPTIONS,
+    timeZone: zone
+  });
+  const fields = {};
+  for (const part of formatter.formatToParts(new Date(instant))) {
+    if (part.type !== 'literal') {
+      fields[part.type] = Number.parseInt(part.value, 10);
+    }
+  }
+  return {
+    year: fields.year,
+    month: fields.month,
+    day: fields.day,
+    // Intl renders midnight as hour 24 in some environments; normalize it.
+    hour: fields.hour === 24 ? 0 : fields.hour,
+    minute: fields.minute,
+    second: fields.second
+  };
+}
+
+/** The zone's offset from UTC, in milliseconds, at a given instant. */
+function offsetAt(instant, timeZone) {
+  const parts = partsInZone(instant, timeZone);
+  const asUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  return asUtc - Math.floor(instant / 1000) * 1000;
+}
+
+/**
+ * Finds the instant at which a zone shows the given clock reading.
+ *
+ * Two passes, because the offset itself depends on the instant: the first guess
+ * uses the offset at the naive UTC interpretation, the second corrects for a
+ * daylight-saving boundary crossed by that guess.
+ *
+ * Daylight-saving resolution, per the documented rule:
+ * - a clock time that does not exist resolves **forward** to the next valid instant;
+ * - a clock time that occurs twice resolves to its **first** occurrence, so
+ *   exactly one notification results rather than two.
+ */
+function instantForParts(parts, timeZone) {
+  const naive = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+  let candidate = naive - offsetAt(naive, timeZone);
+  candidate = naive - offsetAt(candidate, timeZone);
+  const rendered = partsInZone(candidate, timeZone);
+  if (rendered.hour === parts.hour && rendered.minute === parts.minute) {
+    // Ambiguous readings (the repeated hour) land here on the first, earlier
+    // offset, which is the documented choice.
+    return candidate;
+  }
+
+  // The reading does not exist in this zone — a spring-forward gap. Step
+  // forward to the next instant that does exist rather than skipping the
+  // occurrence or failing.
+  const gapStep = 60 * 60 * 1000;
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    const shifted = candidate + gapStep * attempt;
+    const shiftedParts = partsInZone(shifted, timeZone);
+    if (shiftedParts.day === parts.day || shiftedParts.hour > parts.hour) {
+      return shifted;
+    }
+  }
+  return candidate;
+}
+/**
+ * Resolves a caller-supplied moment into a firing instant.
+ *
+ * An absolute moment passes through untouched — that is the entire distinction.
+ */
+function anchorMoment(input, timeZone) {
+  const anchoring = input.anchoring ?? _notification.DEFAULT_ANCHORING_MODE;
+  if (anchoring === 'absolute') {
+    return {
+      resolvedAt: input.at,
+      anchoring
+    };
+  }
+  return {
+    resolvedAt: input.at,
+    anchoring,
+    generation: timeZone
+  };
+}
+/**
+ * Computes what a zone change requires.
+ *
+ * Returns an empty plan when the zone has not moved, which is what makes
+ * re-anchoring idempotent: the no-change check costs one comparison per entry
+ * and issues zero platform operations.
+ */
+function planReAnchor(pending, currentZone) {
+  const rewrites = [];
+  const unreadableGeneration = [];
+  let fromZone;
+  for (const entry of pending) {
+    // Absolute-instant entries are never re-anchored, re-scheduled, or touched.
+    if (entry.anchoring === 'absolute') continue;
+    const generation = entry.anchoringGeneration;
+    if (generation === undefined || generation === currentZone) continue;
+
+    // A stored generation is data, and data can be wrong. Re-anchoring against
+    // a zone the runtime cannot read would move the entry to an arbitrary
+    // instant, which is worse than leaving it where it is and saying so.
+    if (!isValidTimeZone(generation)) {
+      unreadableGeneration.push(entry.id);
+      continue;
+    }
+    fromZone ??= generation;
+
+    // Preserve the clock reading the entry originally named, not the instant.
+    const originalParts = partsInZone(entry.resolvedAt, generation);
+    const resolvedAt = instantForParts(originalParts, currentZone);
+    if (resolvedAt !== entry.resolvedAt) {
+      rewrites.push({
+        entry,
+        resolvedAt
+      });
+    }
+  }
+  return {
+    rewrites,
+    fromZone,
+    toZone: currentZone,
+    zoneChanged: rewrites.length > 0 || fromZone !== undefined,
+    unreadableGeneration
+  };
+}
+
+/**
+ * True when an entry was anchored against a zone the device has since left.
+ *
+ * This is the FR-007c condition: the entry will fire at its old instant, and a
+ * consumer can detect and explain that rather than being told nothing happened.
+ */
+function isStaleAnchor(entry, currentZone) {
+  return entry.anchoring === 'wallClock' && entry.anchoringGeneration !== undefined && entry.anchoringGeneration !== currentZone;
+}
+//# sourceMappingURL=anchor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_notification","localizePeer","lazyPeer","cause","createPlatformTimeZoneReader","localize","get","ok","module","getTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","isValidTimeZone","isZoneValid","PARTS_OPTIONS","year","month","day","hour","minute","second","hour12","partsInZone","instant","zone","formatter","getDateTimeFormat","fields","part","formatToParts","Date","type","Number","parseInt","value","offsetAt","parts","asUtc","UTC","Math","floor","instantForParts","naive","candidate","rendered","gapStep","attempt","shifted","shiftedParts","anchorMoment","input","anchoring","DEFAULT_ANCHORING_MODE","resolvedAt","at","generation","planReAnchor","pending","currentZone","rewrites","unreadableGeneration","fromZone","entry","anchoringGeneration","undefined","push","id","originalParts","toZone","zoneChanged","length","isStaleAnchor"],"sourceRoot":"../../../src","sources":["schedule/anchor.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/schedule/index.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScheduler = createScheduler;
+exports.validateRequest = validateRequest;
+var _errors = require("../contract/errors.js");
+var _interaction = require("../contract/interaction.js");
+var _validateIdentifier = require("./validate-identifier.js");
+var _validateContent = require("./validate-content.js");
+var _resolveMoment = require("./resolve-moment.js");
+var _anchor = require("./anchor.js");
+var _partition = require("./partition.js");
+var _writer = require("./writer.js");
+/**
+ * The scheduling operations.
+ *
+ * Validation runs in a fixed order and completes entirely before any platform
+ * call: identifier, tags, content, moment shape, tone, actions, routing size.
+ * A caller therefore never sees a native-level error surface through the
+ * package, and a rejected request leaves the device untouched.
+ *
+ * Scheduling an identifier that already has a notification **replaces** it.
+ * That is the defined semantic rather than a side effect, which is what lets a
+ * caller stop tracking whether it has already scheduled something.
+ */
+
+/** Validates a request completely, before the engine is touched at all. */
+function validateRequest(request, resolveTone) {
+  (0, _validateIdentifier.validateIdentifier)(request.id, 'id');
+  (0, _validateIdentifier.validateOptionalTag)(request.ownerTag, 'ownerTag');
+  (0, _validateIdentifier.validateOptionalTag)(request.groupTag, 'groupTag');
+  (0, _validateContent.validateContent)(request.content);
+  (0, _resolveMoment.validateMoment)(request.moment);
+  const tone = resolveTone(request.tone);
+  if (tone === undefined) {
+    throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.UNDECLARED_TONE, `Tone "${request.tone}" was never declared in the package configuration. Declare it before scheduling against it.`, {
+      toneId: request.tone
+    });
+  }
+  if (request.actions !== undefined) {
+    if (request.actions.length > _interaction.MAX_ACTIONS_PER_NOTIFICATION) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.TOO_MANY_ACTIONS, `A notification may carry at most ${_interaction.MAX_ACTIONS_PER_NOTIFICATION} actions; ${request.actions.length} were supplied.`, {
+        count: request.actions.length,
+        limit: _interaction.MAX_ACTIONS_PER_NOTIFICATION
+      });
+    }
+    for (const action of request.actions) {
+      (0, _validateIdentifier.validateIdentifier)(action.id, 'actionId');
+    }
+  }
+  if (request.routing !== undefined) {
+    // Sized at schedule time rather than discovered as truncated at tap time,
+    // which is where an over-large payload would otherwise surface.
+    const size = (0, _validateContent.byteLength)(JSON.stringify(request.routing));
+    if (size > _interaction.MAX_ROUTING_PAYLOAD_BYTES) {
+      throw new _errors.NotificationError(_errors.DIAGNOSTIC_CODES.ROUTING_PAYLOAD_TOO_LARGE, `Routing payload is ${size} bytes, over the ${_interaction.MAX_ROUTING_PAYLOAD_BYTES}-byte limit.`, {
+        bytes: size,
+        limit: _interaction.MAX_ROUTING_PAYLOAD_BYTES
+      });
+    }
+  }
+  return tone;
+}
+function createScheduler(deps) {
+  const emit = deps.emit ?? (() => {});
+  const writer = (0, _writer.createScheduleWriter)(deps.engine);
+  const scheduleOne = async (request, options = {}) => {
+    const tone = validateRequest(request, deps.resolveTone);
+    const zone = deps.timeZone();
+    const anchored = (0, _anchor.anchorMoment)(request.moment, zone);
+    const resolution = (0, _resolveMoment.resolveMoment)(anchored.resolvedAt, deps.now());
+
+    // Identifiers only where the engine can list them cheaply: reading every
+    // pending payload across the bridge just to answer "was this one already
+    // there" cost a full read per schedule (NOT-08).
+    const replaced = deps.engine.pendingIds ? (await deps.engine.pendingIds()).includes(request.id) : (await deps.engine.getPending()).some(entry => entry.id === request.id);
+
+    // Approximate mode is a degradation, not a refusal: the notification is
+    // still scheduled and the caller is told it may arrive late.
+    const approximate = !deps.canScheduleExactly();
+    if (approximate) {
+      emit(_errors.DIAGNOSTIC_CODES.EXACT_ALARM_UNAVAILABLE, 'Scheduled in approximate mode; delivery may be late.', {
+        id: request.id
+      });
+    }
+    await writer.write({
+      request,
+      resolvedAt: resolution.at,
+      tone,
+      // The zone this was anchored against, so `getPending` can report it and a
+      // consumer can detect a stale anchor (FR-007c). Absent for absolute
+      // moments, which are never anchored to a zone.
+      anchoringGeneration: anchored.generation,
+      approximate,
+      seriesId: options.seriesId,
+      pushCreated: options.pushCreated
+    });
+    return {
+      id: request.id,
+      resolvedAt: resolution.at,
+      anchoring: anchored.anchoring,
+      replaced,
+      deliveredImmediately: resolution.kind === 'immediate',
+      mayBeDelayed: approximate
+    };
+  };
+  return {
+    schedule: scheduleOne,
+    async cancel(id) {
+      (0, _validateIdentifier.validateIdentifier)(id, 'id');
+      // A marker guarding a notification that no longer exists would fire
+      // against nothing. Harmless, but it holds platform capacity a real
+      // notification could use.
+      await writer.cancel(id);
+    },
+    async cancelByGroup(groupTag) {
+      (0, _validateIdentifier.validateIdentifier)(groupTag, 'groupTag');
+      const ids = (0, _partition.idsForTag)(await deps.engine.getPending(), 'group', groupTag);
+      await deps.engine.cancelMany(ids);
+      const pass = writer.pass();
+      for (const id of ids) await pass.releaseStop(id);
+      return ids;
+    },
+    async cancelByOwner(ownerTag) {
+      (0, _validateIdentifier.validateIdentifier)(ownerTag, 'ownerTag');
+      const ids = (0, _partition.idsForTag)(await deps.engine.getPending(), 'owner', ownerTag);
+      await deps.engine.cancelMany(ids);
+      const pass = writer.pass();
+      for (const id of ids) await pass.releaseStop(id);
+      return ids;
+    },
+    async cancelAll() {
+      await deps.engine.cancelAll();
+    },
+    async getPending() {
+      return deps.engine.getPending();
+    }
+  };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_interaction","_validateIdentifier","_validateContent","_resolveMoment","_anchor","_partition","_writer","validateRequest","request","resolveTone","validateIdentifier","id","validateOptionalTag","ownerTag","groupTag","validateContent","content","validateMoment","moment","tone","undefined","NotificationError","DIAGNOSTIC_CODES","UNDECLARED_TONE","toneId","actions","length","MAX_ACTIONS_PER_NOTIFICATION","TOO_MANY_ACTIONS","count","limit","action","routing","size","byteLength","JSON","stringify","MAX_ROUTING_PAYLOAD_BYTES","ROUTING_PAYLOAD_TOO_LARGE","bytes","createScheduler","deps","emit","writer","createScheduleWriter","engine","scheduleOne","options","zone","timeZone","anchored","anchorMoment","resolution","resolveMoment","resolvedAt","now","replaced","pendingIds","includes","getPending","some","entry","approximate","canScheduleExactly","EXACT_ALARM_UNAVAILABLE","write","at","anchoringGeneration","generation","seriesId","pushCreated","anchoring","deliveredImmediately","kind","mayBeDelayed","schedule","cancel","cancelByGroup","ids","idsForTag","cancelMany","pass","releaseStop","cancelByOwner","cancelAll"],"sourceRoot":"../../../src","sources":["schedule/index.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/schedule/partition.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.idsForTag = idsForTag;
+exports.partition = partition;
+exports.selectByTag = selectByTag;
+/**
+ * Owner-tag and group-tag partitioning.
+ *
+ * A tag is an opaque label the caller supplies and the package never
+ * interprets. That is deliberate: modelling identity would mean acquiring an
+ * opinion about it, and this package is forbidden from knowing anything about
+ * accounts, tenants, or users.
+ *
+ * What the tag buys is one call — "clear this account's notifications" — on a
+ * shared device, without the package ever learning what an account is.
+ */
+
+/** Selects entries carrying a tag. Comparison is exact; nothing is normalized. */
+function selectByTag(entries, kind, tag) {
+  return entries.filter(entry => kind === 'owner' ? entry.ownerTag === tag : entry.groupTag === tag);
+}
+
+/** Identifiers to cancel for a tag. */
+function idsForTag(entries, kind, tag) {
+  return selectByTag(entries, kind, tag).map(entry => entry.id);
+}
+
+/**
+ * Groups entries by a tag, keeping untagged entries under a distinct bucket.
+ *
+ * Untagged is not the same as any tag: an entry with no owner belongs to no
+ * account, and folding it into one would make a sign-out delete notifications
+ * that were never that account's.
+ */
+function partition(entries, kind) {
+  const tagged = new Map();
+  const untagged = [];
+  for (const entry of entries) {
+    const tag = kind === 'owner' ? entry.ownerTag : entry.groupTag;
+    if (tag === undefined) {
+      untagged.push(entry);
+      continue;
+    }
+    const bucket = tagged.get(tag);
+    if (bucket === undefined) {
+      tagged.set(tag, [entry]);
+    } else {
+      bucket.push(entry);
+    }
+  }
+  return {
+    tagged,
+    untagged
+  };
+}
+//# sourceMappingURL=partition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["selectByTag","entries","kind","tag","filter","entry","ownerTag","groupTag","idsForTag","map","id","partition","tagged","Map","untagged","undefined","push","bucket","get","set"],"sourceRoot":"../../../src","sources":["schedule/partition.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA;AACO,SAASA,WAAWA,CAC1BC,OAAgC,EAChCC,IAAmB,EACnBC,GAAW,EACe;EAC1B,OAAOF,OAAO,CAACG,MAAM,CAACC,KAAK,IAC1BH,IAAI,KAAK,OAAO,GAAGG,KAAK,CAACC,QAAQ,KAAKH,GAAG,GAAGE,KAAK,CAACE,QAAQ,KAAKJ,GAChE,CAAC;AACF;;AAEA;AACO,SAASK,SAASA,CACxBP,OAAgC,EAChCC,IAAmB,EACnBC,GAAW,EACS;EACpB,OAAOH,WAAW,CAACC,OAAO,EAAEC,IAAI,EAAEC,GAAG,CAAC,CAACM,GAAG,CAACJ,KAAK,IAAIA,KAAK,CAACK,EAAE,CAAC;AAC9D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,SAASA,CACxBV,OAAgC,EAChCC,IAAmB,EAIlB;EACD,MAAMU,MAAM,GAAG,IAAIC,GAAG,CAAyB,CAAC;EAChD,MAAMC,QAAwB,GAAG,EAAE;EAEnC,KAAK,MAAMT,KAAK,IAAIJ,OAAO,EAAE;IAC5B,MAAME,GAAG,GAAGD,IAAI,KAAK,OAAO,GAAGG,KAAK,CAACC,QAAQ,GAAGD,KAAK,CAACE,QAAQ;IAC9D,IAAIJ,GAAG,KAAKY,SAAS,EAAE;MACtBD,QAAQ,CAACE,IAAI,CAACX,KAAK,CAAC;MACpB;IACD;IACA,MAAMY,MAAM,GAAGL,MAAM,CAACM,GAAG,CAACf,GAAG,CAAC;IAC9B,IAAIc,MAAM,KAAKF,SAAS,EAAE;MACzBH,MAAM,CAACO,GAAG,CAAChB,GAAG,EAAE,CAACE,KAAK,CAAC,CAAC;IACzB,CAAC,MAAM;MACNY,MAAM,CAACD,IAAI,CAACX,KAAK,CAAC;IACnB;EACD;EAEA,OAAO;IAAEO,MAAM;IAAEE;EAAS,CAAC;AAC5B","ignoreList":[]}