@chipmobilesdk/rn-notification 0.5.0 → 0.7.0

package/lib/typescript/commonjs/engine/notify-kit/platform/index.d.ts

@@ -0,0 +1,12 @@
+import type { PlatformInfo } from '../../../permission/state';
+import type { NotifyKitModule } from '../module';
+import type { NotifyKitPlatform } from './types';
+export type { NotifyKitPlatform } from './types';
+/** The running OS and, on Android, its API level. */
+export declare function detectPlatform(): PlatformInfo;
+/**
+ * The strategy for `platform`, or for the running one. Only Android gets the
+ * Android strategy; anywhere else nothing channel- or alarm-specific is called.
+ */
+export declare function createNotifyKitPlatform(engine: () => NotifyKitModule, platform?: PlatformInfo): NotifyKitPlatform;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/engine/notify-kit/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/notify-kit/platform/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAYjD,qDAAqD;AACrD,wBAAgB,cAAc,IAAI,YAAY,CAQ7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,MAAM,eAAe,EAC7B,QAAQ,CAAC,EAAE,YAAY,GACrB,iBAAiB,CAUnB"}

package/lib/typescript/commonjs/engine/notify-kit/platform/ios.d.ts

@@ -0,0 +1,3 @@
+import type { NotifyKitPlatform } from './types';
+export declare function createIosPlatform(): NotifyKitPlatform;
+//# sourceMappingURL=ios.d.ts.map

package/lib/typescript/commonjs/engine/notify-kit/platform/ios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ios.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/notify-kit/platform/ios.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AASjD,wBAAgB,iBAAiB,IAAI,iBAAiB,CAsCrD"}

package/lib/typescript/commonjs/engine/notify-kit/platform/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What differs between Android and iOS in the notify-kit engine (NOT-18, IOS-08).
+ *
+ * The engine picks one implementation when it is created and never branches on
+ * the OS again. Changing iOS behaviour touches `ios.ts` only, and the Android
+ * file that runs in production stays as it is.
+ */
+import type { ChannelGroup, ResolvedTone } from '../../../contract/channel';
+import type { PermissionKind, PermissionState, RestrictionReport } from '../../../contract/permission';
+import type { EngineCapabilities, ToneDeclarationOutcome } from '../../adapter';
+import type { NotifyKitModule } from '../module';
+export interface NotifyKitPlatform {
+    capabilities(): EngineCapabilities;
+    /** Creates the channel stop markers are posted on, the first time one is needed. */
+    ensureMarkerChannel(): Promise<void>;
+    withChannelSnapshot<T>(work: () => Promise<T>): Promise<T>;
+    declareTone(tone: ResolvedTone): Promise<ToneDeclarationOutcome>;
+    retireTone(channelId: string): Promise<boolean>;
+    declareGroups(groups: readonly ChannelGroup[]): Promise<void>;
+    listDeclaredChannels(): Promise<readonly string[]>;
+    /** The state of `kind`, from the engine's settings as just read. */
+    permissionFrom(kind: PermissionKind, settings: Record<string, unknown>): PermissionState;
+    /** Whether exact alarms are a capability the user grants here. */
+    gatesExactAlarms(): boolean;
+    restrictions(now: () => number): Promise<RestrictionReport>;
+}
+export interface PlatformContext {
+    /** The engine module, resolved lazily. */
+    readonly engine: () => NotifyKitModule;
+    /** Android API level, read when asked; undefined elsewhere or when unknown. */
+    readonly apiLevel: () => number | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/engine/notify-kit/platform/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/notify-kit/platform/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,KAAK,EACX,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,MAAM,WAAW,iBAAiB;IACjC,YAAY,IAAI,kBAAkB,CAAC;IACnC,oFAAoF;IACpF,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3D,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACjE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChD,aAAa,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,oBAAoB,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;IAEnD,oEAAoE;IACpE,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CAAC;IACzF,kEAAkE;IAClE,gBAAgB,IAAI,OAAO,CAAC;IAC5B,YAAY,CAAC,GAAG,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,eAAe;IAC/B,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,eAAe,CAAC;IACvC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;CAC5C"}

package/lib/typescript/commonjs/engine/notify-kit-engine.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The `react-native-notify-kit` engine implementation.
+ *
+ * Nothing above this adapter knows which engine is in use — which is what
+ * allowed the original Notifee choice to be swapped for its maintained fork
+ * without touching a requirement, a test, or a line of consumer code.
+ *
+ * This file is what both platforms share: scheduling, cancelling, reading the
+ * pending set, and routing events. The engine module and its constants live in
+ * `notify-kit/module.ts`, decoding in `notify-kit/events.ts`, and everything
+ * that differs between Android and iOS in `notify-kit/platform/` — chosen once
+ * when the engine is created (NOT-18, IOS-08).
+ */
+import type { NotificationEngineAdapter } from './adapter';
+import type { PlatformInfo } from '../permission/state';
+import { type NotifyKitModule } from './notify-kit/module';
+export interface NotifyKitEngineOptions {
+    /** Injected in tests; production resolves the real module. */
+    readonly module?: NotifyKitModule;
+    readonly now?: () => number;
+    /** Defaults to the running platform. Injected to test one platform's behaviour. */
+    readonly platform?: PlatformInfo;
+}
+export declare function createNotifyKitEngine(options?: NotifyKitEngineOptions): NotificationEngineAdapter;
+//# sourceMappingURL=notify-kit-engine.d.ts.map

package/lib/typescript/commonjs/engine/notify-kit-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify-kit-engine.d.ts","sourceRoot":"","sources":["../../../../src/engine/notify-kit-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACX,yBAAyB,EAIzB,MAAM,WAAW,CAAC;AAOnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD,OAAO,EASN,KAAK,eAAe,EACpB,MAAM,qBAAqB,CAAC;AAqB7B,MAAM,WAAW,sBAAsB;IACtC,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;CACjC;AAED,wBAAgB,qBAAqB,CACpC,OAAO,GAAE,sBAA2B,GAClC,yBAAyB,CAkQ3B"}

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

@@ -0,0 +1,106 @@
+/**
+ * @chipmobilesdk/rn-notification
+ *
+ * Default entrypoint: scheduling, recurrence, reconciliation, permissions,
+ * channels, interaction, and diagnostics.
+ *
+ * Push lives behind `@chipmobilesdk/rn-notification/push` so an app that never
+ * enables it ships no provider code, no push permissions, and no entitlements.
+ * Test doubles live behind `@chipmobilesdk/rn-notification/testing` so they
+ * never reach a production bundle.
+ *
+ * No engine, provider, or storage type is reachable from here — that is what
+ * makes each of them replaceable.
+ */
+export type { AnchoringMode, DeliveryMoment, NotificationContent, RoutingPayload, Action, NotificationRequest, PendingEntry, ScheduleResult, Weekday, DailyPattern, WeeklyPattern, MonthlyByDayPattern, RecurrencePattern, EndCondition, OccurrenceTemplate, RecurrenceRule, LookaheadConfig, SeriesResult, SeriesSummary, ReconcileInput, ReconcileResult, RejectedEntry, TruncationReport, PendingDiscrepancy, MaintenanceResult, PermissionKind, PermissionState, PermissionReport, PermissionCapability, RestrictionStatus, RestrictionReport, ToneUrgency, ToneSound, ToneRepeatAlert, ToneDeclaration, ChannelGroup, ChannelApplyResult, ResolvedTone, InteractionKind, AppStateAtInteraction, InteractionEvent, InteractionHandler, TargetMissingSignal, Unsubscribe, DiagnosticSeverity, DiagnosticEvent, EventSink, CollectionHealth, StateHealth, StateSnapshot, BurstThreshold, NotificationConfig, InitializeResult, } from './contract';
+export { DEFAULT_ANCHORING_MODE, DEFAULT_LOOKAHEAD, REPEAT_ALERT_BOUNDS, LOOKAHEAD_BOUNDS, INTERACTION_BUFFER_LIMITS, MAX_ROUTING_PAYLOAD_BYTES, MAX_ACTIONS_PER_NOTIFICATION, DEFAULT_BURST_THRESHOLD, DIAGNOSTIC_CODES, ALL_DIAGNOSTIC_CODES, NotificationError, isNotificationError, isNonFailure, } from './contract';
+export type { DiagnosticCode } from './contract';
+/**
+ * The engine port. Exported so a consuming app can supply its own engine, which
+ * is the mechanism behind provider and engine substitution.
+ */
+export type { NotificationEngineAdapter, DeliveryEvent, EngineCapabilities, EngineScheduleRequest, RepeatStop, ToneDeclarationOutcome, } from './engine/adapter';
+/** The default engine. Consumers may substitute their own via the port above. */
+export { createNotifyKitEngine } from './engine/notify-kit-engine';
+/**
+ * The whole package, assembled (0.6.0): scheduler, reconciler, recurrence,
+ * permissions, channels, interactions, snapshot and maintenance, wired the way the
+ * package means them to be. Start here; the factories below are for an app that
+ * needs a different wiring, and are also exported from `./advanced`.
+ */
+export { createNotifications } from './notifications';
+export type { Notifications, NotificationsDependencies } from './notifications';
+/** Initialization and the assembled runtime. */
+export { initialize } from './initialize';
+export type { RuntimeDependencies, NotificationRuntime } from './initialize';
+/** Scheduling operations. */
+export { createScheduler } from './schedule';
+export type { Scheduler, ScheduleDependencies } from './schedule';
+/** Reconciliation — always consumer-invoked, never automatic. */
+export { createReconciler } from './reconcile';
+export type { Reconciler, ReconcileDependencies } from './reconcile';
+/** Recurrence — declare a rule once; the package maintains a bounded window. */
+export { createRecurrence } from './recurrence';
+export type { Recurrence, RecurrenceDependencies } from './recurrence';
+export { occurrenceId } from './recurrence/expand';
+/** Channels and tones — declared once, mapped to each platform, migrated on change. */
+export { createChannels } from './channel/migrate';
+export type { Channels, ChannelDependencies } from './channel/migrate';
+export { channelIdFor, createToneResolver, parseChannelId, resolveTone } from './channel/tone-map';
+export { validateToneDeclaration, validateToneDeclarations } from './channel/validate-tone';
+/**
+ * Repeat expiry — what bounds an alert that repeats until it is handled.
+ *
+ * `registerBackgroundNotificationHandler` is the one piece a consumer wires up
+ * themselves, at module scope in `index.js`. An app that declares no repeating
+ * tone needs none of this.
+ */
+export { createRepeatExpiryHandler, registerBackgroundNotificationHandler, REPEAT_STOP_PREFIX, } from './repeat';
+export type { BackgroundHandlerRegistration, RepeatExpiryHandler, RepeatExpiryDependencies, } from './repeat';
+/** Interaction routing — one handler for foreground, background, and cold start. */
+export { createInteractions } from './interaction';
+export type { Interactions, InteractionDependencies } from './interaction';
+/** Observability — snapshot and burst detection. */
+export { createSnapshot } from './diagnostics/snapshot';
+export type { Snapshot, SnapshotDependencies } from './diagnostics/snapshot';
+export { createBurstDetector } from './diagnostics/burst';
+export type { BurstDetector, BurstStatus } from './diagnostics/burst';
+export { DiagnosticEmitter } from './diagnostics/events';
+/** Permission coordination — reading never prompts; a refusal never fails the caller. */
+export { createPermissions } from './permission';
+export type { Permissions, PermissionDependencies, PermissionChangeHandler } from './permission';
+export { canDisplay, capabilityFor, isTerminal, shouldOfferSettings } from './permission/state';
+export type { PlatformInfo } from './permission/state';
+/** Maintenance steps, registered with the runtime's registry. */
+export { createPermissionRefreshStep } from './maintenance/permission-refresh';
+export { createReAnchorStep } from './maintenance/reanchor';
+export { createVerifyStep } from './maintenance/verify';
+export { createWindowRefreshStep } from './maintenance/window-refresh';
+export type { MaintenanceStep, MaintenanceTrigger, MaintenanceContext } from './maintenance/cycle';
+export { MaintenanceRegistry, MaintenanceScopeViolation } from './maintenance/cycle';
+export { MaintenanceController } from './maintenance/toggle';
+/** Public state controls — the only two ways a consumer may touch persisted state. */
+export { resetState, clearOwner } from './state/reset';
+export type { ResetOutcome } from './state/reset';
+/**
+ * State plumbing. The record's *schema* stays private — a consumer can create
+ * and reset the store, but has no way to read or write what is inside it.
+ */
+export { createMmkvStore } from './state/mmkv-store';
+export { StateManager } from './state/record';
+export type { StateStore } from './state/store';
+/** Documented limits, exported so a consumer can validate before calling. */
+export { MAX_IDENTIFIER_LENGTH } from './schedule/validate-identifier';
+export { CONTENT_LIMITS } from './schedule/validate-content';
+export { PAST_TOLERANCE_MS } from './schedule/resolve-moment';
+/**
+ * Reads the platform time zone, which anchoring depends on.
+ *
+ * Exported because every consumer needs it and pure JavaScript cannot provide
+ * it reliably — `Intl.DateTimeFormat().resolvedOptions().timeZone` does not
+ * update when the device zone changes. Leaving consumers to write this
+ * themselves is how a subtly wrong version ends up in each of them.
+ */
+export { createPlatformTimeZoneReader, isValidTimeZone } from './schedule/anchor';
+export type { TimeZoneReader } from './schedule/anchor';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,74 @@
+/**
+ * Package initialization.
+ *
+ * Composes the parts that must be in place before the first schedule call:
+ * validate configuration, load persisted state, apply tone declarations, run
+ * any pending channel migration, and start the maintenance registry.
+ *
+ * Budgeted at 100 ms of app startup, which is why state loading is synchronous
+ * and tone declaration is the only platform round-trip.
+ *
+ * Automatic maintenance is started here too: whatever steps are registered on
+ * `runtime.registry` run when the app returns to the foreground, with the
+ * trigger reported as `timeZoneChange` when the device zone moved meanwhile.
+ * Until 0.4.0 nothing ever called `runAutomatic`, so "automatic" maintenance
+ * only ran when the app invoked it by hand.
+ */
+import type { InitializeResult, NotificationConfig } from './contract/diagnostics';
+import { type LookaheadConfig } from './contract/recurrence';
+import type { MaintenanceResult } from './contract/reconcile';
+import { DiagnosticEmitter } from './diagnostics/events';
+import { MaintenanceRegistry } from './maintenance/cycle';
+import { MaintenanceController } from './maintenance/toggle';
+import { StateManager } from './state/record';
+import type { StateStore } from './state/store';
+import type { NotificationEngineAdapter } from './engine/adapter';
+import { type Channels } from './channel/migrate';
+import { type TimeZoneReader } from './schedule/anchor';
+/** The slice of React Native's `AppState` the lifecycle observer uses. */
+export interface AppStateSource {
+    addEventListener(type: 'change', listener: (state: string) => void): {
+        remove(): void;
+    };
+}
+export interface RuntimeDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly store: StateStore;
+    readonly now?: () => number;
+    /** Injected in tests; defaults to rn-core's shared `appLifecycle()`. */
+    readonly appState?: AppStateSource;
+    /** Injected in tests; defaults to the platform zone reader. */
+    readonly timeZone?: TimeZoneReader;
+}
+/** Everything assembled at initialization, shared by the operation modules. */
+export interface NotificationRuntime {
+    readonly engine: NotificationEngineAdapter;
+    readonly state: StateManager;
+    readonly emitter: DiagnosticEmitter;
+    readonly registry: MaintenanceRegistry;
+    readonly maintenance: MaintenanceController;
+    /** The channel module that applied `config.tones`. Added in 0.4.0. */
+    readonly channels: Channels;
+    readonly lookahead: LookaheadConfig;
+    readonly config: NotificationConfig;
+    readonly now: () => number;
+    /** The result of the latest automatic cycle, if one has run. Added in 0.4.0. */
+    readonly lastAutomaticMaintenance: () => MaintenanceResult | undefined;
+    /** Stops the lifecycle observer. Added in 0.4.0. */
+    dispose(): void;
+}
+/**
+ * Clamps the lookahead into its documented bounds.
+ *
+ * Bounded on adjustment because the platform ceiling is not negotiable: a
+ * consumer asking for a five-year window would silently exhaust the 64-entry
+ * iOS ceiling on the first frequent series.
+ */
+export declare function resolveLookahead(partial: Partial<LookaheadConfig> | undefined): LookaheadConfig;
+/** Fails before any platform call, so a bad configuration never half-applies. */
+export declare function validateConfig(config: NotificationConfig): void;
+export declare function initialize(config: NotificationConfig, deps: RuntimeDependencies): Promise<{
+    runtime: NotificationRuntime;
+    result: InitializeResult;
+}>;
+//# sourceMappingURL=initialize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../../src/initialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EAAuC,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEtF,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC9B,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG;QAAE,MAAM,IAAI,IAAI,CAAA;KAAE,CAAC;CACxF;AASD,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;CACnC;AAED,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC;IAC5C,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,wBAAwB,EAAE,MAAM,iBAAiB,GAAG,SAAS,CAAC;IACvE,oDAAoD;IACpD,OAAO,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,GAAG,eAAe,CAY/F;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAsC/D;AAED,wBAAsB,UAAU,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,IAAI,EAAE,mBAAmB,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,CAAC,CA8FrE"}

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

@@ -0,0 +1,53 @@
+/**
+ * Interaction routing.
+ *
+ * One handler covers foreground, background, and cold start. The hard case is
+ * the last one: the tap happens before any JavaScript exists to receive it, so
+ * the event has to wait — durably — until a handler registers.
+ *
+ * Events are delivered in occurrence order and never dropped for want of a
+ * listener. After delivery the notification leaves the tray, because a
+ * notification the user has already acted on sitting there is noise.
+ */
+import type { InteractionHandler, TargetMissingSignal, Unsubscribe } from '../contract/interaction';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { StateManager } from '../state/record';
+export interface InteractionDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly state: StateManager;
+    readonly now: () => number;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export declare function createInteractions(deps: InteractionDependencies): {
+    /**
+     * Registers a handler and immediately drains anything that was waiting.
+     *
+     * The drain is what makes a cold-start tap work: the event was persisted
+     * before this handler existed, possibly before this process existed.
+     */
+    onInteraction(handler: InteractionHandler): Unsubscribe;
+    /**
+     * Collects the interaction that launched the app, if any.
+     *
+     * Called once during startup. If no handler exists yet the event is
+     * buffered rather than discarded.
+     */
+    collectInitial(): Promise<void>;
+    /**
+     * Signals that a routing target no longer exists.
+     *
+     * The consumer chooses its own fallback screen. No platform error is ever
+     * shown to the user for this — a notification pointing at deleted data is
+     * an ordinary condition, not a crash.
+     */
+    reportTargetMissing(signal: TargetMissingSignal): void;
+    /** Reports that a background action exceeded the platform's execution window. */
+    reportBackgroundTimeout(notificationId: string, windowMs: number): void;
+    /** How many interactions are waiting for a handler. */
+    pendingCount(): number;
+    /** Settles outstanding deliveries. Exists for tests and orderly shutdown. */
+    flush(): Promise<void>;
+    dispose(): void;
+};
+export type Interactions = ReturnType<typeof createInteractions>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/interaction/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAEX,kBAAkB,EAClB,mBAAmB,EACnB,WAAW,EACX,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,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,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,uBAAuB;IA2C9D;;;;;OAKG;2BACoB,kBAAkB,GAAG,WAAW;IAYvD;;;;;OAKG;sBACqB,OAAO,CAAC,IAAI,CAAC;IAMrC;;;;;;OAMG;gCACyB,mBAAmB,GAAG,IAAI;IAQtD,iFAAiF;4CACzC,MAAM,YAAY,MAAM,GAAG,IAAI;IAQvE,uDAAuD;oBACvC,MAAM;IAItB,6EAA6E;aAC9D,OAAO,CAAC,IAAI,CAAC;eAIjB,IAAI;EAMhB;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/lib/typescript/commonjs/maintenance/cycle.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The automatic maintenance cycle.
+ *
+ * Covers exactly what only the package can know — window refresh, recurrence
+ * expansion, wall-clock re-anchoring, pending-set verification, permission
+ * re-reads. Full desired-set reconciliation is never automatic, because only
+ * the consumer knows what its data implies and a package that guessed would
+ * cancel notifications it does not understand.
+ *
+ * Steps register themselves here rather than being wired in a fixed order. That
+ * is what lets scheduling, reconciliation, recurrence, and permissions each
+ * contribute a step without importing one another.
+ *
+ * The rule that makes automatic work safe: a step may act only on notifications
+ * the package owns, and may never cancel anything else. It is enforced here
+ * rather than trusted to each step.
+ */
+import type { MaintenanceResult, PendingDiscrepancy } from '../contract/reconcile';
+export type MaintenanceTrigger = 'foreground' | 'delivery' | 'timeZoneChange' | 'permissionChange' | 'explicit';
+export interface MaintenanceContext {
+    readonly trigger: MaintenanceTrigger;
+    readonly now: number;
+    /**
+     * Identifiers the package owns — series occurrences and entries it created.
+     * A step may cancel only within this set.
+     */
+    readonly ownedIds: ReadonlySet<string>;
+}
+export interface StepOutcome {
+    readonly occurrencesScheduled?: number;
+    readonly reAnchored?: number;
+    readonly windowRefreshed?: boolean;
+    readonly timeZoneChanged?: boolean;
+    readonly permissionChanged?: boolean;
+    readonly discrepancy?: PendingDiscrepancy;
+    /** Platform operations issued. Zero on a no-change pass. */
+    readonly operationCount?: number;
+    /** Identifiers this step cancelled, checked against `ownedIds`. */
+    readonly cancelledIds?: readonly string[];
+}
+export interface MaintenanceStep {
+    readonly name: string;
+    /** Lower runs first. Re-anchoring must precede verification, or verification sees stale instants. */
+    readonly order: number;
+    run(context: MaintenanceContext): Promise<StepOutcome>;
+}
+export declare class MaintenanceScopeViolation extends Error {
+    readonly step: string;
+    readonly offendingIds: readonly string[];
+    constructor(step: string, offendingIds: readonly string[]);
+}
+export interface MaintenanceRegistryOptions {
+    /** Measures `durationMs`. `context.now` is the cycle's logical time and does not move. */
+    readonly clock?: () => number;
+}
+export declare class MaintenanceRegistry {
+    private steps;
+    private inFlight;
+    private readonly clock;
+    constructor(options?: MaintenanceRegistryOptions);
+    register(step: MaintenanceStep): () => void;
+    get registered(): readonly string[];
+    /**
+     * Runs every registered step in order.
+     *
+     * Overlapping cycles are joined rather than queued or dropped: a second
+     * caller arriving mid-cycle wants the work the running cycle is already
+     * doing, so it waits for that cycle and gets its result. It used to get an
+     * empty result at once. Since `initialize` started running a cycle on every
+     * foreground, an app that ran maintenance and then reconciled on the same
+     * event got that empty result and reconciled while the window refresh was
+     * still writing: a reminder the reconcile cancelled could be scheduled again.
+     */
+    run(context: MaintenanceContext): Promise<MaintenanceResult>;
+    private runSteps;
+}
+//# sourceMappingURL=cycle.d.ts.map

package/lib/typescript/commonjs/maintenance/cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEnF,MAAM,MAAM,kBAAkB,GAC7B,YAAY,GAAG,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,UAAU,CAAC;AAEhF,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IAC1C,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,mEAAmE;IACnE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACvD;AAED,qBAAa,yBAA0B,SAAQ,KAAK;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;gBAE7B,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE;CAUzD;AAED,MAAM,WAAW,0BAA0B;IAC1C,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC9B;AAED,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,QAAQ,CAA2C;IAC3D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,OAAO,GAAE,0BAA+B;IAIpD,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,IAAI;IAQ3C,IAAI,UAAU,IAAI,SAAS,MAAM,EAAE,CAElC;IAED;;;;;;;;;;OAUG;IACH,GAAG,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;YAW9C,QAAQ;CAgCtB"}

package/lib/typescript/commonjs/maintenance/permission-refresh.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The permission re-read maintenance step.
+ *
+ * The user can change permission in system settings while the app is
+ * backgrounded, and the platform does not tell anyone. Re-reading on foreground
+ * is the only way a consumer's interface avoids showing a stale answer.
+ *
+ * Runs last (order 30): permission state does not affect what the earlier steps
+ * expand or re-anchor, and reading it after they have run means the report
+ * reflects the device as the cycle leaves it.
+ */
+import type { MaintenanceStep } from './cycle';
+import type { Permissions } from '../permission';
+export declare const PERMISSION_REFRESH_ORDER = 30;
+export interface PermissionRefreshDependencies {
+    readonly permissions: Permissions;
+}
+export declare function createPermissionRefreshStep(deps: PermissionRefreshDependencies): MaintenanceStep;
+//# sourceMappingURL=permission-refresh.d.ts.map

package/lib/typescript/commonjs/maintenance/permission-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-refresh.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/permission-refresh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAmC,MAAM,SAAS,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CAClC;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,6BAA6B,GAAG,eAAe,CAiBhG"}

package/lib/typescript/commonjs/maintenance/reanchor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The re-anchoring maintenance step.
+ *
+ * Registers itself with the maintenance registry rather than being wired into
+ * a fixed sequence, which is what keeps scheduling independent of
+ * reconciliation, recurrence, and permissions despite all four contributing a
+ * step.
+ *
+ * Runs early (order 10) because verification compares firing instants: if
+ * verification ran first it would compare against instants re-anchoring is
+ * about to rewrite, and report discrepancies that do not exist.
+ */
+import type { MaintenanceStep } from './cycle';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { ResolvedTone } from '../contract/channel';
+import { type TimeZoneReader } from '../schedule/anchor';
+export interface ReAnchorStepDependencies {
+    readonly engine: NotificationEngineAdapter;
+    readonly timeZone: TimeZoneReader;
+    readonly resolveTone: (toneId: string) => ResolvedTone | undefined;
+    readonly canScheduleExactly: () => boolean;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export declare const RE_ANCHOR_ORDER = 10;
+export declare function createReAnchorStep(deps: ReAnchorStepDependencies): MaintenanceStep;
+//# sourceMappingURL=reanchor.d.ts.map

package/lib/typescript/commonjs/maintenance/reanchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reanchor.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/reanchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAmC,MAAM,SAAS,CAAC;AAChF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGvE,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,CAAC;IACnE,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,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,wBAAwB,GAAG,eAAe,CAuElF"}

package/lib/typescript/commonjs/maintenance/toggle.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The automatic-maintenance switch.
+ *
+ * A package that acts on its own must offer a way to stop it — and a consumer
+ * that takes control must not lose a feature as the price. Disabling automatic
+ * maintenance leaves every operation explicitly invocable through
+ * `runMaintenance()`, producing identical device state.
+ */
+import type { MaintenanceResult } from '../contract/reconcile';
+import type { MaintenanceRegistry, MaintenanceTrigger } from './cycle';
+export interface MaintenanceControllerOptions {
+    readonly registry: MaintenanceRegistry;
+    readonly now: () => number;
+    /**
+     * Identifiers the package owns at the start of a cycle. May read the device,
+     * since ownership is decided per pending occurrence, not per series.
+     */
+    readonly ownedIds: () => ReadonlySet<string> | Promise<ReadonlySet<string>>;
+    readonly enabled?: boolean;
+}
+export declare class MaintenanceController {
+    private enabled;
+    private readonly registry;
+    private readonly now;
+    private readonly ownedIds;
+    constructor(options: MaintenanceControllerOptions);
+    get isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    /** Called by lifecycle observers. A no-op when automatic maintenance is off. */
+    runAutomatic(trigger: Exclude<MaintenanceTrigger, 'explicit'>): Promise<MaintenanceResult | undefined>;
+    /** Always runs, regardless of the switch. This is what preserves capability parity. */
+    runExplicit(): Promise<MaintenanceResult>;
+    private execute;
+}
+//# sourceMappingURL=toggle.d.ts.map

package/lib/typescript/commonjs/maintenance/toggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toggle.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/toggle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAsB,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE3F,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,qBAAqB;IACjC,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAC/C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2D;gBAExE,OAAO,EAAE,4BAA4B;IAOjD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC,gFAAgF;IAC1E,YAAY,CACjB,OAAO,EAAE,OAAO,CAAC,kBAAkB,EAAE,UAAU,CAAC,GAC9C,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAKzC,uFAAuF;IACjF,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;YAIjC,OAAO;CAQrB"}

package/lib/typescript/commonjs/maintenance/verify.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Pending-set verification.
+ *
+ * Engine boot restoration coverage varies by manufacturer, so after a restart
+ * the device may hold fewer notifications than the package expects. This step
+ * notices that.
+ *
+ * It **detects and reports only**. It never re-registers, cancels, or repairs
+ * anything — the package deliberately does not persist a desired set, so it
+ * cannot tell a restoration gap from an intentional consumer change. Guessing
+ * would mean either resurrecting notifications the user cancelled or deleting
+ * ones they still want. Repair is consumer-invoked reconciliation.
+ *
+ * Runs at order 20, after re-anchoring (order 10): re-anchoring rewrites firing
+ * instants, and verifying first would compare against instants that are about
+ * to change.
+ */
+import type { MaintenanceStep } from './cycle';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+export declare const VERIFY_ORDER = 20;
+export interface VerifyStepDependencies {
+    readonly engine: NotificationEngineAdapter;
+    /**
+     * Identifiers the package expects the device to hold — the union of series
+     * occurrences and the last reconciliation's result. Absent expectations mean
+     * nothing to verify, which is different from expecting nothing.
+     */
+    readonly expectedIds: () => ReadonlySet<string> | undefined;
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export declare function createVerifyStep(deps: VerifyStepDependencies): MaintenanceStep;
+//# sourceMappingURL=verify.d.ts.map

package/lib/typescript/commonjs/maintenance/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAmC,MAAM,SAAS,CAAC;AAChF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAInE,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,MAAM,EAAE,yBAAyB,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC5D,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,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,sBAAsB,GAAG,eAAe,CA8C9E"}

package/lib/typescript/commonjs/maintenance/window-refresh.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The window-refresh maintenance step.
+ *
+ * Runs at order 15 — after re-anchoring (10) so it expands against corrected
+ * instants, before verification (20) so verification sees the refreshed set
+ * rather than reporting occurrences the refresh was about to add.
+ *
+ * This step is the reason automatic maintenance exists at all: only the package
+ * knows when a series' horizon has moved, and it can act on that without ever
+ * needing a desired set from the consumer.
+ */
+import type { MaintenanceStep } from './cycle';
+import type { RecurrenceRule } from '../contract/recurrence';
+import type { Recurrence } from '../recurrence';
+export declare const WINDOW_REFRESH_ORDER = 15;
+export interface WindowRefreshDependencies {
+    readonly recurrence: Recurrence;
+    /**
+     * Rules the consumer has registered, supplied as a lookup rather than stored.
+     *
+     * The ledger records what the package expanded; the rule itself belongs to
+     * the consumer, because persisting a rule would mean persisting its content
+     * template — and FR-096a forbids the package holding notification content.
+     */
+    readonly registeredRules: () => readonly RecurrenceRule[];
+    readonly emit?: (code: string, message: string, context?: Record<string, unknown>) => void;
+}
+export declare function createWindowRefreshStep(deps: WindowRefreshDependencies): MaintenanceStep;
+//# sourceMappingURL=window-refresh.d.ts.map

package/lib/typescript/commonjs/maintenance/window-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-refresh.d.ts","sourceRoot":"","sources":["../../../../src/maintenance/window-refresh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAmC,MAAM,SAAS,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,MAAM,WAAW,yBAAyB;IACzC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,SAAS,cAAc,EAAE,CAAC;IAC1D,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,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,yBAAyB,GAAG,eAAe,CAgCxF"}