@chipmobilesdk/rn-notification 0.1.2 → 0.2.0

package/src/reconcile/duplicates.ts

@@ -1,73 +1,73 @@
-/**
- * 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.
- */
-
-import type { NotificationRequest } from '../contract/notification';
-import type { RejectedEntry } from '../contract/reconcile';
-import { DIAGNOSTIC_CODES } from '../contract/errors';
-
-export interface DuplicateSplit {
-	/** Entries whose identifier appeared exactly once. */
-	readonly unique: readonly NotificationRequest[];
-	/** One rejection record per repeated identifier, not per copy. */
-	readonly rejected: readonly RejectedEntry[];
-}
-
-/**
- * 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".
- */
-export function splitDuplicates(
-	desired: readonly NotificationRequest[],
-	existingIds: ReadonlySet<string> = new Set(),
-): DuplicateSplit {
-	const counts = new Map<string, number>();
-	for (const request of desired) {
-		counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
-	}
-
-	const unique: NotificationRequest[] = [];
-	const rejected: RejectedEntry[] = [];
-
-	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: 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 };
-}
+/**
+ * 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.
+ */
+
+import type { NotificationRequest } from '../contract/notification';
+import type { RejectedEntry } from '../contract/reconcile';
+import { DIAGNOSTIC_CODES } from '../contract/errors';
+
+export interface DuplicateSplit {
+	/** Entries whose identifier appeared exactly once. */
+	readonly unique: readonly NotificationRequest[];
+	/** One rejection record per repeated identifier, not per copy. */
+	readonly rejected: readonly RejectedEntry[];
+}
+
+/**
+ * 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".
+ */
+export function splitDuplicates(
+	desired: readonly NotificationRequest[],
+	existingIds: ReadonlySet<string> = new Set(),
+): DuplicateSplit {
+	const counts = new Map<string, number>();
+	for (const request of desired) {
+		counts.set(request.id, (counts.get(request.id) ?? 0) + 1);
+	}
+
+	const unique: NotificationRequest[] = [];
+	const rejected: RejectedEntry[] = [];
+
+	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: 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 };
+}

package/src/reconcile/index.ts

@@ -23,6 +23,7 @@ import { isNotificationError } from '../contract/errors';
 import type { RejectedEntry } from '../contract/reconcile';
 import { splitDuplicates } from './duplicates';
 import { truncateToCeiling } from './truncate';
+import { createStopPlacement } from '../repeat/place';
 import { diff } from './diff';
 import { applyInChunks } from './chunk';
 
@@ -51,6 +52,7 @@ function inDomain(entry: PendingEntry, input: ReconcileInput): boolean {
 
 export function createReconciler(deps: ReconcileDependencies) {
 	const emit = deps.emit ?? (() => {});
+	const stops = createStopPlacement(deps.engine);
 	let inFlight: Promise<ReconcileResult> = Promise.resolve() as unknown as Promise<ReconcileResult>;
 
 	const run = async (input: ReconcileInput): Promise<ReconcileResult> => {
@@ -89,10 +91,16 @@ export function createReconciler(deps: ReconcileDependencies) {
 		}
 
 		const capabilities = await deps.engine.getCapabilities();
+
+		// Stop markers occupy real platform capacity, so the ceiling a consumer's
+		// notifications can actually use is smaller than the platform's own.
+		// Hiding that would let the package quietly reduce how many notifications
+		// fit and report a full set as registered when it was not.
+		const markerCost = (await deps.engine.listRepeatStops()).length;
 		const { kept, report: truncation } = truncateToCeiling(
 			valid,
 			resolvedAt,
-			capabilities.pendingCeiling,
+			Math.max(0, capabilities.pendingCeiling - markerCost),
 		);
 
 		if (truncation !== undefined) {
@@ -124,6 +132,7 @@ export function createReconciler(deps: ReconcileDependencies) {
 			async operation => {
 				if (operation.kind === 'cancel') {
 					await deps.engine.cancel(operation.id);
+					await stops.release(operation.id);
 					cancelled.push(operation.id);
 					return;
 				}
@@ -138,6 +147,10 @@ export function createReconciler(deps: ReconcileDependencies) {
 						(request.moment.anchoring ?? 'wallClock') === 'absolute' ? undefined : zone,
 					approximate,
 				});
+				// Reconciliation is how most consumers schedule, so a bound placed
+				// only by the direct scheduler would be a bound that mostly did not
+				// exist.
+				await stops.sync(request.id, tone, operation.resolvedAt!);
 				(operation.kind === 'create' ? created : replaced).push(operation.id);
 			},
 			{ size: deps.chunkSize },

package/src/reconcile/truncate.ts

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

package/src/recurrence/clock-guard.ts

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