@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/typescript/commonjs/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';
+import type { RejectedEntry } from '../contract/reconcile';
+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/commonjs/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,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,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/commonjs/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';
+import type { ResolvedTone } from '../contract/channel';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import { type TimeZoneReader } from '../schedule/anchor';
+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/commonjs/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,uBAAuB,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,oBAAoB,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/commonjs/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';
+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 declare function truncateToCeiling(desired: readonly NotificationRequest[], resolvedAt: ReadonlyMap<string, number>, ceiling: number): TruncationOutcome;
+//# sourceMappingURL=truncate.d.ts.map

package/lib/typescript/commonjs/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,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,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/commonjs/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';
+/** 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/commonjs/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,UAAU,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/commonjs/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';
+import type { AnchoringMode } from '../contract/notification';
+import { type WallClockParts } from '../schedule/anchor';
+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/commonjs/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,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,oBAAoB,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/commonjs/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';
+import type { ResolvedTone } from '../contract/channel';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { StateManager } from '../state/record';
+import { type TimeZoneReader } from '../schedule/anchor';
+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/commonjs/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,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,oBAAoB,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/commonjs/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';
+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/commonjs/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,mBAAmB,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/commonjs/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';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { StateStore } from '../state/store';
+export { createRepeatExpiryHandler } from './expiry';
+export type { RepeatExpiryHandler, RepeatExpiryDependencies } from './expiry';
+export { REPEAT_STOP_PREFIX, isRepeatStopId, markerIdFor, repeatStopFor } from './marker';
+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/commonjs/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,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,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/commonjs/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';
+/**
+ * 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/commonjs/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,mBAAmB,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/commonjs/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';
+import type { ResolvedTone } from '../contract/channel';
+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/commonjs/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,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,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"}

package/lib/typescript/commonjs/schedule/anchor.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+import type { AnchoringMode, PendingEntry } from '../contract/notification';
+/** Reads the platform time zone. Injected so the pure logic needs no native module. */
+export type TimeZoneReader = () => string;
+/**
+ * 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.
+ */
+export declare function createPlatformTimeZoneReader(): TimeZoneReader;
+/** The calendar fields a wall-clock moment actually names. */
+export interface WallClockParts {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+}
+/**
+ * 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`.
+ */
+export declare function isValidTimeZone(timeZone: string): boolean;
+/**
+ * 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.
+ */
+export declare function partsInZone(instant: number, timeZone: string): WallClockParts;
+/**
+ * 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.
+ */
+export declare function instantForParts(parts: WallClockParts, timeZone: string): number;
+export interface AnchorInput {
+    readonly at: number;
+    readonly anchoring?: AnchoringMode;
+}
+export interface AnchoredMoment {
+    readonly resolvedAt: number;
+    readonly anchoring: AnchoringMode;
+    /** The zone this was anchored against. Absent for absolute-instant moments. */
+    readonly generation?: string;
+}
+/**
+ * Resolves a caller-supplied moment into a firing instant.
+ *
+ * An absolute moment passes through untouched — that is the entire distinction.
+ */
+export declare function anchorMoment(input: AnchorInput, timeZone: string): AnchoredMoment;
+export interface ReAnchorPlan {
+    /** Entries whose firing instant must be rewritten, with their new instant. */
+    readonly rewrites: readonly {
+        readonly entry: PendingEntry;
+        readonly resolvedAt: number;
+    }[];
+    readonly fromZone: string | undefined;
+    readonly toZone: string;
+    readonly zoneChanged: boolean;
+    /**
+     * Entries carrying an anchoring generation the runtime cannot interpret.
+     *
+     * Left alone rather than re-anchored against a guess. Reported so a corrupted
+     * or older-build record is visible instead of quietly producing wrong firing
+     * instants.
+     */
+    readonly unreadableGeneration: readonly string[];
+}
+/**
+ * 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.
+ */
+export declare function planReAnchor(pending: readonly PendingEntry[], currentZone: string): ReAnchorPlan;
+/**
+ * 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.
+ */
+export declare function isStaleAnchor(entry: PendingEntry, currentZone: string): boolean;
+//# sourceMappingURL=anchor.d.ts.map

package/lib/typescript/commonjs/schedule/anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../../../src/schedule/anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG5E,uFAAuF;AACvF,MAAM,MAAM,cAAc,GAAG,MAAM,MAAM,CAAC;AAW1C;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,IAAI,cAAc,CAc7D;AAED,8DAA8D;AAC9D,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIzD;AAaD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAsB7E;AAgBD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkC/E;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAQjF;AAED,MAAM,WAAW,YAAY;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5F,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;CACjD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,YAAY,CAsChG;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAM/E"}

package/lib/typescript/commonjs/schedule/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+import type { NotificationRequest, PendingEntry, ScheduleResult } from '../contract/notification';
+import type { ResolvedTone } from '../contract/channel';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import { type TimeZoneReader } from './anchor';
+export interface ScheduleDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly resolveTone: (toneId: string) => ResolvedTone | undefined;
+    readonly timeZone: TimeZoneReader;
+    readonly now: () => number;
+    /** False when exact-alarm capability is unavailable, forcing approximate mode. */
+    readonly canScheduleExactly: () => boolean;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+/** Validates a request completely, before the engine is touched at all. */
+export declare function validateRequest(request: NotificationRequest, resolveTone: (toneId: string) => ResolvedTone | undefined): ResolvedTone;
+export declare function createScheduler(deps: ScheduleDependencies): {
+    schedule: (request: NotificationRequest, options?: {
+        readonly seriesId?: string;
+        readonly pushCreated?: boolean;
+    }) => Promise<ScheduleResult>;
+    cancel(id: string): Promise<void>;
+    cancelByGroup(groupTag: string): Promise<readonly string[]>;
+    cancelByOwner(ownerTag: string): Promise<readonly string[]>;
+    cancelAll(): Promise<void>;
+    getPending(): Promise<readonly PendingEntry[]>;
+};
+export type Scheduler = ReturnType<typeof createScheduler>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/schedule/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schedule/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAMnE,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAI7D,MAAM,WAAW,oBAAoB;IACpC,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,kFAAkF;IAClF,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;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAC9B,OAAO,EAAE,mBAAmB,EAC5B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,GACvD,YAAY,CA2Cd;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,oBAAoB;wBAM/C,mBAAmB,YACnB;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,KACrE,OAAO,CAAC,cAAc,CAAC;eAmDR,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;4BAQT,MAAM,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;4BASnC,MAAM,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;iBAS9C,OAAO,CAAC,IAAI,CAAC;kBAIZ,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;EAIrD;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}