@chipmobilesdk/rn-notification 0.6.0 → 0.7.0

package/lib/typescript/commonjs/notifications.d.ts

@@ -0,0 +1,78 @@
+/**
+ * One call that assembles the whole package (NOT-07).
+ *
+ * Until 0.5.0 an app wired a dozen factories itself — scheduler, reconciler,
+ * recurrence, permissions, channels, interactions, snapshot, maintenance steps
+ * — repeating the engine, tone resolver, clock and time-zone reader for each,
+ * and usually hard-coding `canScheduleExactly: () => true`. `createNotifications`
+ * does that wiring once, the way the package means it:
+ *
+ * - every part reports through the one redacting diagnostic emitter;
+ * - `canScheduleExactly` follows the exact-alarm permission the package last
+ *   read, instead of a guess;
+ * - automatic maintenance has the standard steps registered (re-anchoring after
+ *   a time-zone change, refreshing permissions, and refreshing recurrence
+ *   windows when the app supplies its rules), so it does something on every
+ *   return to the foreground.
+ *
+ * The individual factories stay exported for an app that needs a different
+ * wiring; they are also available from `@chipmobilesdk/rn-notification/advanced`.
+ */
+import type { Channels } from './channel/migrate';
+import type { InitializeResult, NotificationConfig } from './contract';
+import type { MaintenanceResult } from './contract/reconcile';
+import type { RecurrenceRule } from './contract/recurrence';
+import { type Snapshot } from './diagnostics/snapshot';
+import type { NotificationEngineAdapter } from './engine/adapter';
+import { type NotificationRuntime } from './initialize';
+import { type Interactions } from './interaction';
+import { type Permissions } from './permission';
+import type { PlatformInfo } from './permission/state';
+import { type Reconciler } from './reconcile';
+import { type Recurrence } from './recurrence';
+import { type Scheduler } from './schedule';
+import { type TimeZoneReader } from './schedule/anchor';
+import type { StateStore } from './state/store';
+export interface NotificationsDependencies {
+    /** Defaults to the notify-kit engine. Inject a fake in tests. */
+    readonly engine?: NotificationEngineAdapter;
+    /** Defaults to MMKV-backed state. */
+    readonly store?: StateStore;
+    readonly timeZone?: TimeZoneReader;
+    readonly now?: () => number;
+    /** Defaults to the running OS and, on Android, its API level. */
+    readonly platform?: PlatformInfo;
+    /**
+     * The recurrence rules the app has registered. With it, maintenance refreshes
+     * their windows on every foreground return; the package never stores a rule
+     * itself, because a rule carries notification content (FR-096a).
+     */
+    readonly recurrenceRules?: () => readonly RecurrenceRule[];
+    /** Whether the app holds a push token, for the snapshot. Presence only. */
+    readonly hasPushToken?: () => boolean;
+}
+export interface Notifications {
+    readonly scheduler: Scheduler;
+    readonly reconciler: Reconciler;
+    readonly recurrence: Recurrence;
+    readonly permissions: Permissions;
+    readonly channels: Channels;
+    readonly interactions: Interactions;
+    readonly snapshot: Snapshot;
+    /** State, diagnostics and the maintenance controller `initialize` assembled. */
+    readonly runtime: NotificationRuntime;
+    /** What initialization did: tones applied, migrations run, how long it took. */
+    readonly initialization: InitializeResult;
+    /** The time-zone reader every part schedules against. */
+    readonly timeZone: TimeZoneReader;
+    /** Handles a tap or action; a shortcut for `interactions.onInteraction`. */
+    onInteraction: Interactions['onInteraction'];
+    /** Runs maintenance now, whatever the app state. */
+    runMaintenance(): Promise<MaintenanceResult>;
+    /** Whether the exact-alarm capability is granted, as last read. */
+    canScheduleExactly(): boolean;
+    /** Stops the lifecycle observer and every listener. */
+    dispose(): void;
+}
+export declare function createNotifications(config: NotificationConfig, deps?: NotificationsDependencies): Promise<Notifications>;
+//# sourceMappingURL=notifications.d.ts.map

package/lib/typescript/commonjs/notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../../../src/notifications.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,KAAK,EAAkB,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,EAAc,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAItE,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,WAAW,yBAAyB;IACzC,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,CAAC;IAC5C,qCAAqC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IAC3D,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAC1C,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,4EAA4E;IAC5E,aAAa,EAAE,YAAY,CAAC,eAAe,CAAC,CAAC;IAC7C,oDAAoD;IACpD,cAAc,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC7C,mEAAmE;IACnE,kBAAkB,IAAI,OAAO,CAAC;IAC9B,uDAAuD;IACvD,OAAO,IAAI,IAAI,CAAC;CAChB;AAOD,wBAAsB,mBAAmB,CACxC,MAAM,EAAE,kBAAkB,EAC1B,IAAI,GAAE,yBAA8B,GAClC,OAAO,CAAC,aAAa,CAAC,CAkGxB"}

package/lib/typescript/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,57 @@
+/**
+ * Permission coordination.
+ *
+ * Two rules shape everything here. Reading state never prompts, so the consumer
+ * decides when the user is asked — a prompt at the wrong moment is a permanent
+ * denial. And a refusal never fails the caller's business operation: the user's
+ * actual work completes, and the lost capability is reported separately.
+ */
+import type { PermissionKind, PermissionReport, PermissionState, RestrictionReport } from '../contract/permission';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { StateManager } from '../state/record';
+import { type PlatformInfo } from './state';
+export interface PermissionDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly state: StateManager;
+    readonly platform: PlatformInfo;
+    readonly now: () => number;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+    /**
+     * Calls back when the app returns from the background. Defaults to rn-core's
+     * shared lifecycle; injected in tests.
+     */
+    readonly onForeground?: (listener: () => void) => () => void;
+}
+export type PermissionChangeHandler = (report: PermissionReport) => void;
+export declare function createPermissions(deps: PermissionDependencies): {
+    /** Reads every permission state without triggering any dialog. */
+    getPermissions(): Promise<PermissionReport>;
+    /** Requested independently — an app may need one and not the other. */
+    requestDisplayPermission(ownerTag?: string): Promise<PermissionState>;
+    requestExactAlarmPermission(ownerTag?: string): Promise<PermissionState>;
+    /** Whether the package has ever asked — the platform cannot answer this. */
+    hasEverRequested(kind: PermissionKind, ownerTag?: string): boolean;
+    /**
+     * Opens the settings screen for one specific permission.
+     *
+     * Telling a user to "find it in settings" is how you lose them, so a
+     * platform with no reachable screen is an error rather than a silent no-op.
+     */
+    openSettings(kind: PermissionKind): Promise<void>;
+    onPermissionChange(handler: PermissionChangeHandler): () => void;
+    /**
+     * Manufacturer background restrictions, reported for information only.
+     *
+     * `unknown` is a first-class answer: some vendors stop apps in ways with no
+     * detection API, and guessing would be worse than admitting it. The package
+     * changes none of these settings on the user's behalf.
+     */
+    getBackgroundRestrictions(): Promise<RestrictionReport>;
+    /** Called by the permission-refresh maintenance step. */
+    refresh(): Promise<{
+        readonly report: PermissionReport;
+        readonly changed: boolean;
+    }>;
+};
+export type Permissions = ReturnType<typeof createPermissions>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/permission/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,EAAiC,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAW3E,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,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;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAC7D;AAUD,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEzE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,sBAAsB;IA+G5D,kEAAkE;sBAC1C,OAAO,CAAC,gBAAgB,CAAC;IAMjD,uEAAuE;wCACnC,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;2CAI9B,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxE,4EAA4E;2BACrD,cAAc,aAAa,MAAM,GAAG,OAAO;IAIlE;;;;;OAKG;uBACsB,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;gCAW3B,uBAAuB,GAAG,MAAM,IAAI;IAOhE;;;;;;OAMG;iCACgC,OAAO,CAAC,iBAAiB,CAAC;IAoB7D,yDAAyD;eACxC,OAAO,CAAC;QAAE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;EAK3F;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/lib/typescript/commonjs/permission/state.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The permission state model.
+ *
+ * Six states, never collapsed. The two that matter most are the ones a naive
+ * model loses: `notAsked` must stay distinguishable from `denied`, or reading
+ * state without prompting buys nothing; and `notRequired` must never be
+ * reported as `denied`, because a platform version with no such concept never
+ * refused anything.
+ */
+import type { PermissionCapability, PermissionKind, PermissionState } from '../contract/permission';
+/** Android runtime notification permission arrived in API 33. */
+export declare const ANDROID_DISPLAY_PERMISSION_API = 33;
+/** Android exact-alarm permission arrived in API 31. */
+export declare const ANDROID_EXACT_ALARM_API = 31;
+export interface PlatformInfo {
+    readonly os: 'ios' | 'android' | 'other';
+    /** Android API level. Ignored on iOS. */
+    readonly apiLevel?: number;
+}
+/**
+ * Whether a permission concept exists at all on this platform version.
+ *
+ * Returning `supported: false` is what lets `notRequired` be reported honestly
+ * rather than inventing a refusal.
+ */
+export declare function capabilityFor(kind: PermissionKind, platform: PlatformInfo): PermissionCapability;
+/** Normalizes a platform reading into the six-state model. */
+export declare function normalizeState(kind: PermissionKind, raw: PermissionState, platform: PlatformInfo): PermissionState;
+/**
+ * Whether a state means the package can still show notifications.
+ *
+ * `provisional` counts: iOS quiet delivery still reaches the user, just without
+ * interrupting them. Treating it as denied would suppress notifications the
+ * user is in fact receiving.
+ */
+export declare function canDisplay(state: PermissionState): boolean;
+/** Whether asking again could produce a dialog, or whether settings is the only route. */
+export declare function isTerminal(state: PermissionState): boolean;
+/** Whether the package has ever asked, which the platform cannot answer after the fact. */
+export declare function shouldOfferSettings(state: PermissionState): boolean;
+//# sourceMappingURL=state.d.ts.map

package/lib/typescript/commonjs/permission/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/permission/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEpG,iEAAiE;AACjE,eAAO,MAAM,8BAA8B,KAAK,CAAC;AACjD,wDAAwD;AACxD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,EAAE,EAAE,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC;IACzC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,YAAY,GAAG,oBAAoB,CAchG;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAC7B,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,YAAY,GACpB,eAAe,CAKjB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE1D;AAED,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE1D;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAEnE"}

package/lib/typescript/commonjs/push/envelope.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Payload normalization.
+ *
+ * Every provider's payload is reduced to one envelope shape before it reaches
+ * the consumer, so changing provider costs consumer code nothing.
+ *
+ * Version handling is best-effort: a payload declaring a version this build
+ * does not implement is still processed, honouring the fields it understands
+ * and ignoring the rest. Servers deploy ahead of app adoption and old app
+ * versions live on devices for months, so gating every server-side change on
+ * app rollout is the more expensive failure.
+ *
+ * That is only safe under an append-only discipline — a released field's
+ * meaning must never be repurposed. The version-skew diagnostic exists so a
+ * misprocessing incident is traceable to the skew rather than investigated as a
+ * logic defect.
+ */
+import type { PushEnvelope } from './provider-adapter';
+/** The contract version this build implements. */
+export declare const IMPLEMENTED_PAYLOAD_VERSION = 1;
+export interface NormalizeResult {
+    readonly envelope: PushEnvelope;
+    readonly versionSkew: boolean;
+}
+/**
+ * Normalizes a raw provider payload.
+ *
+ * Throws only for a **structurally unparseable** payload — a broken message.
+ * An unrecognized version is a healthy message from a newer contract and must
+ * never collapse into the same condition.
+ */
+export declare function normalizeEnvelope(raw: unknown, receivedAt: number): NormalizeResult;
+//# sourceMappingURL=envelope.d.ts.map

package/lib/typescript/commonjs/push/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../../src/push/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,kDAAkD;AAClD,eAAO,MAAM,2BAA2B,IAAI,CAAC;AA2F7C,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,CAuCnF"}

package/lib/typescript/commonjs/push/fcm-provider.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The Firebase Cloud Messaging provider.
+ *
+ * Every `@react-native-firebase/messaging` import is confined to this file, so
+ * the rest of the package — and every consuming app — stays free of provider
+ * types. Substituting a provider is an adapter swap, not a rewrite.
+ *
+ * The module is required **lazily**. That matters more here than for the
+ * engine: messaging is an *optional* peer dependency, and an app that never
+ * enables push must not fail at import time for a package it deliberately did
+ * not install.
+ */
+import type { PushProviderAdapter } from './provider-adapter';
+/** Minimal shape used from the SDK, so its full surface never leaks into typing. */
+interface MessagingModule {
+    (): MessagingInstance;
+    AuthorizationStatus?: Record<string, number>;
+}
+interface MessagingInstance {
+    getToken(): Promise<string>;
+    deleteToken(): Promise<void>;
+    onTokenRefresh(handler: (token: string) => void): () => void;
+    onMessage(handler: (message: unknown) => Promise<void> | void): () => void;
+    setBackgroundMessageHandler(handler: (message: unknown) => Promise<void>): void;
+    getInitialNotification(): Promise<unknown | null>;
+    hasPermission?(): Promise<number>;
+    isDeviceRegisteredForRemoteMessages?: boolean;
+}
+export interface FcmProviderOptions {
+    /** Injected in tests; production resolves the real module. */
+    readonly module?: MessagingModule;
+    /**
+     * Registers the background message handler.
+     *
+     * Left to the consumer by default because the SDK requires it to be
+     * registered at module scope in `index.js`, outside React's lifecycle — a
+     * constraint the package documents rather than works around.
+     */
+    readonly onBackgroundMessage?: (message: unknown) => Promise<void>;
+}
+export declare function createFcmProvider(options?: FcmProviderOptions): PushProviderAdapter;
+export {};
+//# sourceMappingURL=fcm-provider.d.ts.map

package/lib/typescript/commonjs/push/fcm-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fcm-provider.d.ts","sourceRoot":"","sources":["../../../../src/push/fcm-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAoB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAGhF,oFAAoF;AACpF,UAAU,eAAe;IACxB,IAAI,iBAAiB,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,UAAU,iBAAiB;IAC1B,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,cAAc,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC7D,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,MAAM,IAAI,CAAC;IAC3E,2BAA2B,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChF,sBAAsB,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAClD,aAAa,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,mCAAmC,CAAC,EAAE,OAAO,CAAC;CAC9C;AAkBD,MAAM,WAAW,kBAAkB;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,mBAAmB,CA+FvF"}

package/lib/typescript/commonjs/push/gate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The push gate.
+ *
+ * Everything a consumer sees about push comes through here, in one normalized
+ * shape with zero provider types. Substituting a provider is therefore an
+ * adapter swap rather than a consumer rewrite.
+ *
+ * Two behaviours are deliberate and easy to get wrong. A push arriving in the
+ * **foreground is never auto-displayed** — presentation is the app's decision,
+ * and a library that decided for it would fight every consumer's design. And a
+ * malformed payload is **dropped safely**, because a broken message from a
+ * server must not be able to crash an installed app.
+ */
+import type { PushEnvelope, PushProviderAdapter, PushAvailability } from './provider-adapter';
+import type { StateManager } from '../state/record';
+import type { Unsubscribe } from '../contract/interaction';
+export type PushHandler = (envelope: PushEnvelope) => void | Promise<void>;
+export interface PushGateDependencies {
+    readonly provider: PushProviderAdapter;
+    readonly state: StateManager;
+    readonly now: () => number;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export type UndeliverableCause = 'missingPermission' | 'expiredToken' | 'platformRestriction' | 'malformedPayload' | 'suspectedRateLimit';
+export declare function createPushGate(deps: PushGateDependencies): {
+    /** Reports whether platform push services exist, so degradation is controlled. */
+    getAvailability(): Promise<PushAvailability>;
+    /** Waits for a genuine token. Never returns a placeholder presented as one. */
+    getToken(): Promise<string>;
+    onTokenChange(handler: (token: string) => void): Unsubscribe;
+    invalidateToken(): Promise<boolean>;
+    /**
+     * Subscribes to inbound payloads.
+     *
+     * Nothing is displayed automatically — the consumer decides whether and how
+     * to present a foreground push.
+     */
+    onPushReceived(handler: PushHandler): Unsubscribe;
+    /**
+     * Processes a payload delivered while the app was in the background, from
+     * the module-scope handler `setBackgroundMessageHandler` requires (NOT-24).
+     *
+     * The same normalization and the same persisted deduplication as a
+     * foreground payload, so a redelivery after the process restarted is
+     * suppressed rather than handled twice. Resolves once every handler has run.
+     */
+    handleBackground(raw: unknown): Promise<PushEnvelope | undefined>;
+    /** Processes the payload that launched the app, if any. */
+    collectInitial(): Promise<PushEnvelope | undefined>;
+    /** Reports a specific cause rather than leaving a non-delivery unexplained. */
+    reportUndeliverable(cause: UndeliverableCause, context?: Record<string, unknown>): void;
+    /** Exposed for tests and orderly shutdown. */
+    flush(): Promise<void>;
+    dispose(): void;
+};
+export type PushGate = ReturnType<typeof createPushGate>;
+//# sourceMappingURL=gate.d.ts.map

package/lib/typescript/commonjs/push/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../../../src/push/gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC9F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAK3D,MAAM,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE3E,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,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,MAAM,kBAAkB,GAC3B,mBAAmB,GACnB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,GAClB,oBAAoB,CAAC;AAExB,wBAAgB,cAAc,CAAC,IAAI,EAAE,oBAAoB;IA+DvD,kFAAkF;uBACzD,OAAO,CAAC,gBAAgB,CAAC;IAYlD,+EAA+E;gBAC7D,OAAO,CAAC,MAAM,CAAC;2BAcV,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,WAAW;uBAUnC,OAAO,CAAC,OAAO,CAAC;IAYzC;;;;;OAKG;4BACqB,WAAW,GAAG,WAAW;IASjD;;;;;;;OAOG;0BACyB,OAAO,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAMvE,2DAA2D;sBACnC,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAKzD,+EAA+E;+BACpD,kBAAkB,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQvF,8CAA8C;aAC/B,OAAO,CAAC,IAAI,CAAC;eAIjB,IAAI;EAUhB;AAED,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Push surface: `@chipmobilesdk/rn-notification/push`
+ *
+ * Separate from the default entrypoint so an app that never imports this ships
+ * zero provider code, zero push permissions, and zero entitlements — and takes
+ * on none of the provider's data-collection declarations.
+ */
+export { createPushGate } from './gate';
+export type { PushGate, PushGateDependencies, PushHandler, UndeliverableCause } from './gate';
+export { createFcmProvider } from './fcm-provider';
+export type { FcmProviderOptions } from './fcm-provider';
+export { createSignOut } from './signout';
+export type { SignOut, SignOutDependencies, SignOutResult } from './signout';
+export { createInstructionHandler } from './instructions';
+export type { InstructionHandler, InstructionDependencies, InstructionOutcome, } from './instructions';
+export { normalizeEnvelope, IMPLEMENTED_PAYLOAD_VERSION } from './envelope';
+export type { NormalizeResult } from './envelope';
+export type { PushProviderAdapter, PushEnvelope, PushConfig, PushAvailability, } from './provider-adapter';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/push/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,YAAY,EAAE,QAAQ,EAAE,oBAAoB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAE9F,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,YAAY,EAAE,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,YAAY,EACX,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,GAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAC5E,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,YAAY,EACX,mBAAmB,EACnB,YAAY,EACZ,UAAU,EACV,gBAAgB,GAChB,MAAM,oBAAoB,CAAC"}

package/lib/typescript/commonjs/push/instructions.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Push-driven local scheduling.
+ *
+ * Where the two paths meet. A server can schedule or cancel a local
+ * notification, and it gets **no privileged path**: an instruction arriving by
+ * push passes exactly the same identifier validation, moment validation, tone
+ * resolution, and permission rules as a request from app code.
+ *
+ * That symmetry is the point. A server that could bypass validation would be
+ * able to put the device into a state the app itself could not produce, and no
+ * amount of local correctness would survive it.
+ */
+import type { PushEnvelope } from './provider-adapter';
+import type { Scheduler } from '../schedule';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+export interface InstructionDependencies {
+    readonly scheduler: Scheduler;
+    readonly engine: NotificationEngineAdapter;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export type InstructionOutcome = {
+    readonly kind: 'scheduled';
+    readonly id: string;
+    readonly replaced: boolean;
+} | {
+    readonly kind: 'cancelled';
+    readonly id: string;
+} | {
+    readonly kind: 'suppressed';
+    readonly id: string;
+    readonly reason: string;
+} | {
+    readonly kind: 'rejected';
+    readonly id: string;
+    readonly code: string;
+    readonly reason: string;
+} | {
+    readonly kind: 'ignored';
+    readonly id: string;
+};
+export declare function createInstructionHandler(deps: InstructionDependencies): {
+    handle(envelope: PushEnvelope): Promise<InstructionOutcome>;
+};
+export type InstructionHandler = ReturnType<typeof createInstructionHandler>;
+//# sourceMappingURL=instructions.d.ts.map

package/lib/typescript/commonjs/push/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../../../src/push/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAGnE,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,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,MAAM,kBAAkB,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7E;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACvB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,uBAAuB;qBAkB7C,YAAY,GAAG,OAAO,CAAC,kBAAkB,CAAC;EAyDlE;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/lib/typescript/commonjs/push/provider-adapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The port every push provider satisfies.
+ *
+ * No provider type appears in any signature, which is what makes swapping the
+ * provider cost the consumer nothing.
+ */
+import type { RoutingPayload, NotificationContent } from '../contract/notification';
+import type { Unsubscribe } from '../contract/interaction';
+/** The single normalized shape every provider's payload is reduced to. */
+export interface PushEnvelope {
+    /** Contract version carried by the payload. See contracts/push-payload.md. */
+    readonly version: number;
+    readonly kind: 'display' | 'data' | 'schedule' | 'cancel';
+    readonly id: string;
+    readonly ownerTag?: string;
+    readonly content?: NotificationContent;
+    readonly tone?: string;
+    readonly moment?: {
+        readonly at: number;
+        readonly anchoring?: 'wallClock' | 'absolute';
+    };
+    readonly routing?: RoutingPayload;
+    /** De-duplication key, falling back to `id` when absent. */
+    readonly dedupId: string;
+    readonly receivedAt: number;
+    /**
+     * True when the payload declared a version this build does not implement and
+     * was processed best-effort, honouring known fields and ignoring the rest.
+     */
+    readonly versionSkew: boolean;
+}
+export interface PushConfig {
+    /** Called when the provider reports a new or refreshed registration token. */
+    readonly onTokenChange?: (token: string) => void;
+}
+export type PushAvailability = 'available' | 'unavailable' | 'unknown';
+export interface PushProviderAdapter {
+    readonly name: string;
+    /** Reports whether platform push services exist, so degradation is controlled rather than opaque. */
+    getAvailability(): Promise<PushAvailability>;
+    /** Waits for a genuine token. Never returns a placeholder presented as a token. */
+    getToken(): Promise<string>;
+    onTokenChange(handler: (token: string) => void): Unsubscribe;
+    invalidateToken(): Promise<boolean>;
+    /** Raw provider payloads, normalized by the gate rather than by the adapter. */
+    subscribeToMessages(handler: (raw: unknown) => void): Unsubscribe;
+    /** A payload that launched the app, consumed exactly once. */
+    takeInitialMessage(): Promise<unknown | undefined>;
+}
+//# sourceMappingURL=provider-adapter.d.ts.map

package/lib/typescript/commonjs/push/provider-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-adapter.d.ts","sourceRoot":"","sources":["../../../../src/push/provider-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,CAAA;KAAE,CAAC;IACzF,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IAC1B,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACjD;AAED,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,qGAAqG;IACrG,eAAe,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE7C,mFAAmF;IACnF,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,aAAa,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,WAAW,CAAC;IAC7D,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEpC,gFAAgF;IAChF,mBAAmB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAAG,WAAW,CAAC;IAClE,8DAA8D;IAC9D,kBAAkB,IAAI,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;CACnD"}

package/lib/typescript/commonjs/push/signout.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Sign-out cleanup.
+ *
+ * Three things must happen together, and the order matters: invalidate the
+ * token first so no further messages arrive for the account being left, then
+ * cancel its notifications, then clear its persisted state.
+ *
+ * Deliberately **scoped to one owner tag**. On a shared device, signing one
+ * account out must not clear another's deduplication history or cancel their
+ * reminders — and must not discard the channel migration ledger, which
+ * describes the device rather than any account.
+ */
+import type { PushGate } from './gate';
+import type { Scheduler } from '../schedule';
+import type { StateManager } from '../state/record';
+export interface SignOutDependencies {
+    readonly scheduler: Scheduler;
+    readonly state: StateManager;
+    /** Absent for a local-only app, which still needs the rest of the cleanup. */
+    readonly push?: PushGate;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export interface SignOutResult {
+    readonly ownerTag: string;
+    readonly tokenInvalidated: boolean;
+    readonly cancelledIds: readonly string[];
+    readonly clearedCollections: readonly string[];
+}
+export declare function createSignOut(deps: SignOutDependencies): {
+    signOut(ownerTag: string): Promise<SignOutResult>;
+};
+export type SignOut = ReturnType<typeof createSignOut>;
+//# sourceMappingURL=signout.d.ts.map

package/lib/typescript/commonjs/push/signout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signout.d.ts","sourceRoot":"","sources":["../../../../src/push/signout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,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,aAAa;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,mBAAmB;sBAE7B,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;EA2BxD;AAED,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/lib/typescript/commonjs/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/commonjs/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/commonjs/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';
+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/commonjs/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,0BAA0B,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"}