@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/typescript/module/reconcile/chunk.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Chunked application.
+ *
+ * A 500-entry reconciliation must not drop frames on a list screen, so work is
+ * applied in slices with a yield between them. No single slice may occupy the
+ * interface thread for more than 16 ms, which is what holds 60 fps while
+ * reconciliation is in flight.
+ */
+export declare const DEFAULT_CHUNK_SIZE = 25;
+/** Yields to the event loop so the interface thread can render between slices. */
+export declare function yieldToEventLoop(): Promise<void>;
+export interface ChunkOptions {
+    readonly size?: number;
+    readonly onYield?: () => Promise<void>;
+}
+/**
+ * Applies `work` to every item, yielding between chunks.
+ *
+ * Sequential within a chunk rather than parallel: these calls bridge to native,
+ * and a burst of concurrent scheduling is where duplicate-delivery races come
+ * from.
+ */
+export declare function applyInChunks<T>(items: readonly T[], work: (item: T) => Promise<void>, options?: ChunkOptions): Promise<number>;
+//# sourceMappingURL=chunk.d.ts.map

package/lib/typescript/module/reconcile/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../../src/reconcile/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,kFAAkF;AAClF,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACpC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAChC,OAAO,GAAE,YAAiB,GACxB,OAAO,CAAC,MAAM,CAAC,CAoBjB"}

package/lib/typescript/module/reconcile/diff.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Desired-versus-device diffing.
+ *
+ * The package's central promise lives here: reconciling twice with unchanged
+ * input must produce **zero** platform operations on the second run. That is
+ * only true if "unchanged" is decided by comparing everything that would make
+ * the delivered notification different — miss a field and the second run
+ * rewrites entries needlessly; include a volatile one and it never settles.
+ *
+ * Anchoring mode is part of the comparison key deliberately. A mode change on
+ * the same identifier must force a replacement rather than read as unchanged,
+ * because the two modes resolve to different instants the moment a zone
+ * changes.
+ */
+import type { NotificationRequest, PendingEntry } from '../contract/notification.js';
+export type OperationKind = 'create' | 'replace' | 'cancel';
+export interface DiffOperation {
+    readonly kind: OperationKind;
+    readonly id: string;
+    /** Present for create and replace. */
+    readonly request?: NotificationRequest;
+    /** The instant the entry should fire, after anchoring resolution. */
+    readonly resolvedAt?: number;
+}
+export interface DiffResult {
+    readonly operations: readonly DiffOperation[];
+    readonly unchanged: readonly string[];
+}
+export interface DiffInput {
+    readonly desired: readonly NotificationRequest[];
+    /** Resolved firing instant per desired identifier, after anchoring. */
+    readonly resolvedAt: ReadonlyMap<string, number>;
+    /** What the device currently holds, already narrowed to the caller's domain. */
+    readonly device: readonly PendingEntry[];
+    /**
+     * Identifiers that were rejected before diffing and must be left alone.
+     *
+     * Without this they would look like strays — present on the device, absent
+     * from the desired set — and be cancelled. But a rejection is not a
+     * cancellation: the package could not decide what the caller meant, so
+     * destroying the existing notification would be the worst available answer.
+     */
+    readonly protectedIds?: ReadonlySet<string>;
+}
+/**
+ * Computes the minimal operation set.
+ *
+ * Cancels are emitted before creates so an interrupted pass leaves a
+ * recoverable gap rather than a duplicate: a missing notification is fixed by
+ * the next reconcile, whereas two notifications for one subject is a defect the
+ * user sees.
+ */
+export declare function diff(input: DiffInput): DiffResult;
+//# sourceMappingURL=diff.d.ts.map

package/lib/typescript/module/reconcile/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../src/reconcile/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,6BAA0B,CAAC;AAElF,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE5D,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC;IACvC,qEAAqE;IACrE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AA8DD,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC5C;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAkCjD"}

package/lib/typescript/module/reconcile/duplicates.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.js';
+import type { RejectedEntry } from '../contract/reconcile.js';
+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 declare function splitDuplicates(desired: readonly NotificationRequest[], existingIds?: ReadonlySet<string>): DuplicateSplit;
+//# sourceMappingURL=duplicates.d.ts.map

package/lib/typescript/module/reconcile/duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicates.d.ts","sourceRoot":"","sources":["../../../../src/reconcile/duplicates.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAAuB,CAAC;AAG3D,MAAM,WAAW,cAAc;IAC9B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAChD,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,WAAW,GAAE,WAAW,CAAC,MAAM,CAAa,GAC1C,cAAc,CAmChB"}

package/lib/typescript/module/reconcile/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The reconciliation operation.
+ *
+ * A caller hands over the complete set its data implies; the package works out
+ * what to add, replace, and remove. This is **never** run automatically — only
+ * the caller knows what its data implies, and a package that guessed a desired
+ * set would cancel notifications it does not understand.
+ *
+ * Overlapping calls are serialized rather than run concurrently, because two
+ * passes interleaving their cancels and creates is exactly how duplicates
+ * appear.
+ */
+import type { ReconcileInput, ReconcileResult } from '../contract/reconcile.js';
+import type { ResolvedTone } from '../contract/channel.js';
+import type { NotificationEngineAdapter } from '../engine/adapter.js';
+import { type TimeZoneReader } from '../schedule/anchor.js';
+export interface ReconcileDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly resolveTone: (toneId: string) => ResolvedTone | undefined;
+    readonly timeZone: TimeZoneReader;
+    readonly now: () => number;
+    readonly canScheduleExactly: () => boolean;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+    /** Overridable for tests that need to observe chunk boundaries. */
+    readonly chunkSize?: number;
+}
+export declare function createReconciler(deps: ReconcileDependencies): {
+    /**
+     * Serialized against itself: a second call waits for the first rather than
+     * interleaving with it.
+     */
+    reconcile(input: ReconcileInput): Promise<ReconcileResult>;
+};
+export type Reconciler = ReturnType<typeof createReconciler>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/reconcile/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/reconcile/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,0BAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAmB,CAAC;AAEnE,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,uBAAoB,CAAC;AAWvE,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,CAAC;IACnE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3F,mEAAmE;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC5B;AAcD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,qBAAqB;IAyH1D;;;OAGG;qBACoB,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;EASjE;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/lib/typescript/module/reconcile/truncate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.js';
+import type { TruncationReport } from '../contract/reconcile.js';
+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 declare function truncateToCeiling(desired: readonly NotificationRequest[], resolvedAt: ReadonlyMap<string, number>, ceiling: number): TruncationOutcome;
+//# sourceMappingURL=truncate.d.ts.map

package/lib/typescript/module/reconcile/truncate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate.d.ts","sourceRoot":"","sources":["../../../../src/reconcile/truncate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAAuB,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACvC,OAAO,EAAE,MAAM,GACb,iBAAiB,CAwBnB"}

package/lib/typescript/module/recurrence/clock-guard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.js';
+/** A jump larger than this is treated as a clock change rather than ordinary drift. */
+export declare const CLOCK_DISCONTINUITY_THRESHOLD_MS: number;
+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 declare function guardAgainstClockChange(input: ClockGuardInput): ClockGuardResult;
+//# sourceMappingURL=clock-guard.d.ts.map

package/lib/typescript/module/recurrence/clock-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock-guard.d.ts","sourceRoot":"","sources":["../../../../src/recurrence/clock-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAU,CAAC;AAE3C,uFAAuF;AACvF,eAAO,MAAM,gCAAgC,QAAiB,CAAC;AAE/D,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,mEAAmE;IACnE,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,GAAG,UAAU,CAAC;CAC1D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAgChF"}

package/lib/typescript/module/recurrence/expand.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Recurrence expansion.
+ *
+ * Written first-party rather than delegated to an RFC 5545 library, because the
+ * daylight-saving rules here are specified behaviour (FR-008) rather than a
+ * dependency's opinion, and because expansion must be provable with no device.
+ *
+ * Determinism is the hard requirement: the same rule, anchoring mode, zone, and
+ * evaluation moment must produce exactly the same occurrences in the same order
+ * on every run and on both platforms. Without that, reconciliation could not be
+ * idempotent over a recurring series.
+ */
+import type { RecurrenceRule, LookaheadConfig } from '../contract/recurrence.js';
+import type { AnchoringMode } from '../contract/notification.js';
+import { type WallClockParts } from '../schedule/anchor.js';
+export interface Occurrence {
+    /** Derived from the series id and the occurrence's calendar slot — never random. */
+    readonly id: string;
+    /** The calendar slot, `YYYYMMDDTHHmm`. Orders occurrences and survives a zone change. */
+    readonly key: string;
+    readonly seriesId: string;
+    readonly at: number;
+    readonly anchoring: AnchoringMode;
+    /** True when an earlier expansion already counted this occurrence. */
+    readonly previouslyEmitted: boolean;
+}
+/**
+ * The calendar slot of an occurrence: the date and clock time the rule asked
+ * for, in the frame the series is anchored in. Fixed-width, so comparing two
+ * keys as strings compares them in time.
+ */
+export declare function occurrenceKey(parts: WallClockParts): string;
+/**
+ * Occurrence identity.
+ *
+ * Derived from the series and the calendar slot, not the instant. Re-expanding
+ * the same series produces the same identifiers, which is what lets a refresh
+ * recognize an occurrence it already scheduled. Until 0.4.0 the instant was
+ * used, so after a time-zone change re-anchoring kept the old identifier while
+ * the window refresh derived a new one, and the occurrence was scheduled twice.
+ */
+export declare function occurrenceId(seriesId: string, slot: WallClockParts | string): string;
+export interface ExpandInput {
+    readonly rule: RecurrenceRule;
+    /** Occurrences strictly after this instant are produced. */
+    readonly from: number;
+    readonly lookahead: LookaheadConfig;
+    /** Zone the series is anchored against. Ignored for absolute anchoring. */
+    readonly timeZone: string;
+    /** How many occurrences the series has already emitted, for count-limited rules. */
+    readonly alreadyEmitted?: number;
+    /**
+     * Key of the latest occurrence an earlier expansion emitted. Occurrences at or
+     * before it are produced again — they are still in the window — but are not
+     * counted again. Counting them on every refresh is what ended count-limited
+     * series early.
+     */
+    readonly lastEmittedKey?: string;
+}
+export interface ExpandResult {
+    readonly occurrences: readonly Occurrence[];
+    /** The horizon expansion reached. */
+    readonly expandedThrough: number;
+    /** True when the series produced its final occurrence. */
+    readonly exhausted: boolean;
+}
+/**
+ * Expands a rule inside the lookahead window.
+ *
+ * Bounded by both a duration and a count, because either alone fails: a
+ * duration alone lets a frequent series exhaust the platform ceiling, and a
+ * count alone leaves an annual series scheduled a decade out.
+ */
+export declare function expand(input: ExpandInput): ExpandResult;
+//# sourceMappingURL=expand.d.ts.map

package/lib/typescript/module/recurrence/expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expand.d.ts","sourceRoot":"","sources":["../../../../src/recurrence/expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACX,cAAc,EAKd,eAAe,EAEf,MAAM,2BAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA0B,CAAC;AAE9D,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,uBAAoB,CAAC;AAEvF,MAAM,WAAW,UAAU;IAC1B,oFAAoF;IACpF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yFAAyF;IACzF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,sEAAsE;IACtE,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;CACpC;AAID;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,MAAM,CAEpF;AAmGD,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,qCAAqC;IACrC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAgEvD"}

package/lib/typescript/module/recurrence/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Series registration and the lookahead window.
+ *
+ * A caller declares a rule once. The package expands it inside a finite window
+ * and refreshes that window on its own, because only it knows when the horizon
+ * has moved — that is the one piece of recurrence knowledge the consumer does
+ * not have.
+ *
+ * Occurrences carry derived identifiers, so re-expanding a series recognises
+ * what it already scheduled instead of creating duplicates. That is what makes
+ * a window refresh with nothing to do cost zero platform operations.
+ *
+ * Occurrences are written through the shared `ScheduleWriter`, like every other
+ * consumer notification, so a repeating tone gets its stop marker and the
+ * platform ceiling is respected here too.
+ */
+import type { RecurrenceRule, SeriesResult, SeriesSummary, LookaheadConfig } from '../contract/recurrence.js';
+import type { ResolvedTone } from '../contract/channel.js';
+import type { NotificationEngineAdapter } from '../engine/adapter.js';
+import type { StateManager } from '../state/record.js';
+import { type TimeZoneReader } from '../schedule/anchor.js';
+export interface RecurrenceDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly state: StateManager;
+    readonly resolveTone: (toneId: string) => ResolvedTone | undefined;
+    readonly timeZone: TimeZoneReader;
+    readonly now: () => number;
+    readonly lookahead: LookaheadConfig;
+    readonly canScheduleExactly: () => boolean;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export declare function createRecurrence(deps: RecurrenceDependencies): {
+    registerSeries(rule: RecurrenceRule): Promise<SeriesResult>;
+    /** Re-expands a tracked series. Called by the window-refresh maintenance step. */
+    refreshSeries(rule: RecurrenceRule): Promise<SeriesResult>;
+    cancelSeries(seriesId: string): Promise<readonly string[]>;
+    listSeries(): Promise<readonly SeriesSummary[]>;
+};
+export type Recurrence = ReturnType<typeof createRecurrence>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/recurrence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/recurrence/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,YAAY,EACZ,aAAa,EACb,eAAe,EACf,MAAM,2BAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAiB,CAAC;AACpD,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,uBAAoB,CAAC;AActE,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,CAAC;IACnE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,OAAO,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CAC3F;AAkCD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,sBAAsB;yBAkJhC,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAKjE,kFAAkF;wBACxD,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;2BAInC,MAAM,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;kBAgB5C,OAAO,CAAC,SAAS,aAAa,EAAE,CAAC;EAYtD;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/lib/typescript/module/repeat/expiry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Repeat expiry.
+ *
+ * When a stop marker is delivered, the alert it guards has run its declared
+ * course. This handler ends the sound and leaves the notification exactly where
+ * it is, then removes the marker.
+ *
+ * Nothing here imports the engine. It talks to the port, which is what lets the
+ * whole mechanism be proven on a virtual clock with no device.
+ */
+import type { DeliveryEvent, NotificationEngineAdapter } from '../engine/adapter.js';
+export interface RepeatExpiryDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export interface RepeatExpiryHandler {
+    /** Reacts to one delivery. Ignores anything that is not a stop marker. */
+    handle(event: DeliveryEvent): Promise<void>;
+    /** Removes the marker guarding a target, when the target is cancelled or replaced. */
+    release(targetId: string): Promise<void>;
+}
+export declare function createRepeatExpiryHandler(deps: RepeatExpiryDependencies): RepeatExpiryHandler;
+//# sourceMappingURL=expiry.d.ts.map

package/lib/typescript/module/repeat/expiry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expiry.d.ts","sourceRoot":"","sources":["../../../../src/repeat/expiry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,sBAAmB,CAAC;AAGlF,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CAC3F;AAED,MAAM,WAAW,mBAAmB;IACnC,0EAA0E;IAC1E,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,sFAAsF;IACtF,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,wBAAwB,GAAG,mBAAmB,CAsB7F"}

package/lib/typescript/module/repeat/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Repeat expiry — bounding an alert that repeats until it is handled.
+ *
+ * The one piece of this package a consumer has to wire up themselves. The
+ * engine registers its background task at module scope, outside the React tree,
+ * and no library can perform that registration on an app's behalf.
+ *
+ * An app that declares no repeating tone needs none of this.
+ */
+import type { InteractionEvent } from '../contract/interaction.js';
+import type { NotificationEngineAdapter } from '../engine/adapter.js';
+import type { StateStore } from '../state/store.js';
+export { createRepeatExpiryHandler } from './expiry.js';
+export type { RepeatExpiryHandler, RepeatExpiryDependencies } from './expiry.js';
+export { REPEAT_STOP_PREFIX, isRepeatStopId, markerIdFor, repeatStopFor } from './marker.js';
+export interface BackgroundHandlerRegistration {
+    readonly engine: NotificationEngineAdapter;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+    /**
+     * Handles a tap, action or dismissal that arrives while no part of the app is
+     * listening — typically a background action in a process the system started
+     * just for it (0.6.0). Runs inside the platform's background window, so keep
+     * it short. When the app's own `onInteraction` handlers are alive they get the
+     * event instead, with `appState: 'background'`.
+     */
+    readonly onInteraction?: (event: InteractionEvent) => Promise<void> | void;
+    /**
+     * Where to keep an interaction nobody handled, so `onInteraction` delivers it
+     * when the app next starts: the same store the runtime uses
+     * (`createMmkvStore()`). Used when `onInteraction` is absent or throws.
+     */
+    readonly store?: StateStore;
+    /** The clock for what is kept. Defaults to the system clock; injected in tests. */
+    readonly now?: () => number;
+}
+/**
+ * Registers the handler that ends a repeating alert while the app is dead.
+ *
+ * Call this at module scope in `index.js`, beside the app registration — not
+ * inside a component, and not inside an effect. By the time a component mounts,
+ * the process that needed this handler has already been asked to run it.
+ *
+ * Without it a repeating alert still starts and still stops when the user
+ * handles it, but nothing ends it on a device left face-down on a table. That
+ * is the whole reason the feature exists, so `apply()` reports its absence
+ * rather than letting anyone find out the hard way.
+ */
+export declare function registerBackgroundNotificationHandler(registration: BackgroundHandlerRegistration): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/repeat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/repeat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAmB,CAAC;AAGnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAgB,CAAC;AAGjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAU,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,aAAU,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAU,CAAC;AAE1F,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAC3F;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC3E;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACpD,YAAY,EAAE,6BAA6B,GACzC,IAAI,CAyCN"}

package/lib/typescript/module/repeat/marker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+import type { RepeatStop } from '../engine/adapter.js';
+/**
+ * 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.
+ */
+export declare const 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.
+ */
+export declare function markerIdFor(targetId: string): string;
+export declare function isRepeatStopId(id: string): boolean;
+/** Describes the stop for a target whose alert must end at a known instant. */
+export declare function repeatStopFor(targetId: string, deliveredAt: number, forMs: number): RepeatStop;
+//# sourceMappingURL=marker.d.ts.map

package/lib/typescript/module/repeat/marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.d.ts","sourceRoot":"","sources":["../../../../src/repeat/marker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAmB,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAM9F"}

package/lib/typescript/module/repeat/place.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+import type { NotificationEngineAdapter } from '../engine/adapter.js';
+import type { ResolvedTone } from '../contract/channel.js';
+export interface StopPlacement {
+    /**
+     * Places the marker for a repeating notification, replacing any it already
+     * had.
+     *
+     * Called on every schedule, replacements included: re-scheduling under an
+     * identifier that already had one must leave exactly one entry and exactly
+     * one marker, and the old marker's instant is no longer the right one.
+     *
+     * Nothing is placed when the tone does not repeat or the platform will not
+     * honour repetition, so a non-repeating notification costs no extra platform
+     * capacity at all.
+     */
+    sync(targetId: string, tone: ResolvedTone, deliversAt: number): Promise<void>;
+    /** Drops any marker still guarding an identifier. */
+    release(targetId: string): Promise<void>;
+    /** How many markers are outstanding: platform capacity they hold. */
+    count(): Promise<number>;
+    /**
+     * A placement for one pass of many operations (NOT-08). It reads the
+     * outstanding markers once and keeps that view current as it places and
+     * releases, instead of reading every pending trigger across the bridge for
+     * each operation — which made a reconcile of a few hundred changes do a few
+     * hundred full reads.
+     */
+    pass(): StopPlacement;
+}
+export declare function createStopPlacement(engine: NotificationEngineAdapter): StopPlacement;
+//# sourceMappingURL=place.d.ts.map

package/lib/typescript/module/repeat/place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place.d.ts","sourceRoot":"","sources":["../../../../src/repeat/place.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAqB,CAAC;AAGxD,MAAM,WAAW,aAAa;IAC7B;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,qDAAqD;IACrD,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,qEAAqE;IACrE,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB;;;;;;OAMG;IACH,IAAI,IAAI,aAAa,CAAC;CACtB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,aAAa,CAsEpF"}