@chipmobilesdk/rn-notification 0.4.0 → 0.5.0

package/src/diagnostics/redact.ts

@@ -1,72 +1,55 @@
-/**
- * Content redaction for diagnostics.
- *
- * A notification library that logs notification bodies has turned a diagnostic
- * aid into a privacy incident. Nothing content-bearing reaches an event unless
- * verbose diagnostics is explicitly enabled — and that setting is documented as
- * unsuitable for production.
- *
- * Values are replaced by their *shape* — a length, a type, a character position
- * — which is what actually helps someone debug a validation failure anyway.
- */
-
-/** Keys whose values are never emitted at any verbosity below verbose. */
-const REDACTED_KEYS = new Set([
-	'title',
-	'body',
-	'subtitle',
-	'content',
-	'routing',
-	'routingPayload',
-	'payload',
-	'token',
-	'pushToken',
-	'inputText',
-	'text',
-	'data',
-]);
-
-const REDACTED = '[redacted]';
-
-function describe(value: unknown): string {
-	if (value === null) return '[null]';
-	if (value === undefined) return '[undefined]';
-	if (typeof value === 'string') return `[string:${value.length}]`;
-	if (typeof value === 'number' || typeof value === 'boolean') return REDACTED;
-	if (Array.isArray(value)) return `[array:${value.length}]`;
-	if (typeof value === 'object') return `[object:${Object.keys(value).length}]`;
-	return REDACTED;
-}
-
-/**
- * Strips content values from a diagnostic context.
- *
- * Recurses so a nested `{ request: { content: { body } } }` is caught — a
- * top-level-only scrub is the kind of redaction that leaks the first time
- * anyone nests a payload.
- */
-export function redactContext(
-	context: Readonly<Record<string, unknown>> | undefined,
-	verbose: boolean,
-): Readonly<Record<string, unknown>> | undefined {
-	if (context === undefined) return undefined;
-	if (verbose) return context;
-
-	const walk = (value: unknown, depth: number): unknown => {
-		if (depth > 6 || value === null || typeof value !== 'object') return value;
-		if (Array.isArray(value)) return value.map(item => walk(item, depth + 1));
-
-		const output: Record<string, unknown> = {};
-		for (const [key, inner] of Object.entries(value as Record<string, unknown>)) {
-			output[key] = REDACTED_KEYS.has(key) ? describe(inner) : walk(inner, depth + 1);
-		}
-		return output;
-	};
-
-	return walk(context, 0) as Readonly<Record<string, unknown>>;
-}
-
-/** True when a key would be redacted. Exported so tests can assert the policy directly. */
-export function isRedactedKey(key: string): boolean {
-	return REDACTED_KEYS.has(key);
-}
+/**
+ * Content redaction for diagnostics.
+ *
+ * A notification library that logs notification bodies has turned a diagnostic
+ * aid into a privacy incident. Nothing content-bearing reaches an event unless
+ * verbose diagnostics is explicitly enabled — and that setting is documented as
+ * unsuitable for production.
+ *
+ * Values are replaced by their *shape* — a length, a type, a character position
+ * — which is what actually helps someone debug a validation failure anyway.
+ */
+
+import { createRedactor } from '@chipmobilesdk/rn-core';
+
+/** Keys whose values are never emitted at any verbosity below verbose. */
+const REDACTED_KEYS = new Set([
+	'title',
+	'body',
+	'subtitle',
+	'content',
+	'routing',
+	'routingPayload',
+	'payload',
+	'token',
+	'pushToken',
+	'inputText',
+	'text',
+	'data',
+]);
+
+/**
+ * rn-core's redactor: the keys above are replaced by their shape (a length, a
+ * type), and every other string is pattern-redacted, so a token or an e-mail
+ * address under an innocent key such as `reason` does not get through either.
+ */
+const redactor = createRedactor({ shapeKeys: REDACTED_KEYS });
+
+/**
+ * Strips content values from a diagnostic context.
+ *
+ * Recurses so a nested `{ request: { content: { body } } }` is caught — a
+ * top-level-only scrub is the kind of redaction that leaks the first time
+ * anyone nests a payload.
+ */
+export function redactContext(
+	context: Readonly<Record<string, unknown>> | undefined,
+	verbose: boolean,
+): Readonly<Record<string, unknown>> | undefined {
+	return verbose ? context : redactor.context(context);
+}
+
+/** True when a key would be redacted. Exported so tests can assert the policy directly. */
+export function isRedactedKey(key: string): boolean {
+	return REDACTED_KEYS.has(key);
+}

package/src/diagnostics/snapshot.ts

@@ -1,64 +1,100 @@
-/**
- * The state snapshot.
- *
- * The readable answer to "why didn't it arrive?" — assembled in one place so
- * that question can be answered without attaching a native debugger.
- *
- * The push token appears as **presence only**. Its value is never exposed here
- * or anywhere else, because a snapshot is the thing most likely to be pasted
- * into a bug report.
- */
-
-import type { StateSnapshot } from '../contract/diagnostics';
-import type { PendingEntry } from '../contract/notification';
-import type { PermissionReport, RestrictionReport } from '../contract/permission';
-import type { MaintenanceResult, PendingDiscrepancy, ReconcileResult } from '../contract/reconcile';
-import type { NotificationEngineAdapter } from '../engine/adapter';
-import type { StateManager } from '../state/record';
-
-export interface SnapshotDependencies {
-	readonly engine: NotificationEngineAdapter;
-	readonly state: StateManager;
-	readonly now: () => number;
-	readonly permissions: () => Promise<PermissionReport>;
-	readonly restrictions: () => Promise<RestrictionReport>;
-	readonly appliedTones: () => readonly { readonly toneId: string; readonly appliedVersion: number }[];
-	readonly lastReconcile: () => ReconcileResult | undefined;
-	readonly lastMaintenance: () => MaintenanceResult | undefined;
-	/** Presence only — never the value. */
-	readonly hasPushToken: () => boolean;
-}
-
-export function createSnapshot(deps: SnapshotDependencies) {
-	return {
-		async capture(): Promise<StateSnapshot> {
-			const [permissions, restrictions, pending] = await Promise.all([
-				deps.permissions(),
-				deps.restrictions(),
-				deps.engine.getPending(),
-			]);
-
-			const maintenance = deps.lastMaintenance();
-			const discrepancy: PendingDiscrepancy | undefined = maintenance?.discrepancy;
-
-			return {
-				permissions,
-				restrictions,
-				tones: deps.appliedTones().map(tone => ({
-					id: tone.toneId,
-					appliedVersion: tone.appliedVersion,
-				})),
-				pendingCount: pending.length,
-				pending: pending as readonly PendingEntry[],
-				lastReconcile: deps.lastReconcile(),
-				lastMaintenance: maintenance,
-				discrepancy,
-				stateHealth: deps.state.health(),
-				pushTokenPresent: deps.hasPushToken(),
-				capturedAt: deps.now(),
-			};
-		},
-	};
-}
-
-export type Snapshot = ReturnType<typeof createSnapshot>;
+/**
+ * The state snapshot.
+ *
+ * The readable answer to "why didn't it arrive?" — assembled in one place so
+ * that question can be answered without attaching a native debugger.
+ *
+ * The push token appears as **presence only**. Its value is never exposed here
+ * or anywhere else, because a snapshot is the thing most likely to be pasted
+ * into a bug report.
+ */
+
+import { describeShape } from '@chipmobilesdk/rn-core';
+
+import type { StateSnapshot } from '../contract/diagnostics';
+import type { PendingEntry } from '../contract/notification';
+import type { PermissionReport, RestrictionReport } from '../contract/permission';
+import type { MaintenanceResult, PendingDiscrepancy, ReconcileResult } from '../contract/reconcile';
+import type { NotificationEngineAdapter } from '../engine/adapter';
+import type { StateManager } from '../state/record';
+
+export interface SnapshotDependencies {
+	readonly engine: NotificationEngineAdapter;
+	readonly state: StateManager;
+	readonly now: () => number;
+	readonly permissions: () => Promise<PermissionReport>;
+	readonly restrictions: () => Promise<RestrictionReport>;
+	readonly appliedTones: () => readonly {
+		readonly toneId: string;
+		readonly appliedVersion: number;
+	}[];
+	readonly lastReconcile: () => ReconcileResult | undefined;
+	readonly lastMaintenance: () => MaintenanceResult | undefined;
+	/** Presence only — never the value. */
+	readonly hasPushToken: () => boolean;
+	/**
+	 * Whether verbose diagnostics are on. Off (the default), pending entries carry
+	 * the shape of their content and routing (`[string:12]`), not the values.
+	 */
+	readonly verbose?: () => boolean;
+}
+
+/**
+ * A pending entry with content replaced by its shape. A snapshot is the thing
+ * most likely to be pasted into a bug report, so it never carries notification
+ * text or routing values unless verbose diagnostics is on (NOT-14).
+ */
+function withoutContent(entry: PendingEntry): PendingEntry {
+	const { content, routing } = entry;
+	return {
+		...entry,
+		content: {
+			title: describeShape(content.title),
+			body: describeShape(content.body),
+			...(content.subtitle === undefined ? {} : { subtitle: describeShape(content.subtitle) }),
+		},
+		...(routing === undefined
+			? {}
+			: {
+					routing: Object.fromEntries(
+						Object.entries(routing).map(([key, value]) => [key, describeShape(value)]),
+					),
+				}),
+	};
+}
+
+export function createSnapshot(deps: SnapshotDependencies) {
+	return {
+		async capture(): Promise<StateSnapshot> {
+			const [permissions, restrictions, pending] = await Promise.all([
+				deps.permissions(),
+				deps.restrictions(),
+				deps.engine.getPending(),
+			]);
+
+			const maintenance = deps.lastMaintenance();
+			const discrepancy: PendingDiscrepancy | undefined = maintenance?.discrepancy;
+
+			return {
+				permissions,
+				restrictions,
+				tones: deps.appliedTones().map(tone => ({
+					id: tone.toneId,
+					appliedVersion: tone.appliedVersion,
+				})),
+				pendingCount: pending.length,
+				pending: deps.verbose?.()
+					? (pending as readonly PendingEntry[])
+					: pending.map(entry => withoutContent(entry as PendingEntry)),
+				lastReconcile: deps.lastReconcile(),
+				lastMaintenance: maintenance,
+				discrepancy,
+				stateHealth: deps.state.health(),
+				pushTokenPresent: deps.hasPushToken(),
+				capturedAt: deps.now(),
+			};
+		},
+	};
+}
+
+export type Snapshot = ReturnType<typeof createSnapshot>;

package/src/engine/adapter.ts

@@ -1,172 +1,172 @@
-/**
- * The port every local notification engine satisfies.
- *
- * No engine type appears in any signature here. That is what makes the engine
- * replaceable — and it has already been exercised once, when the archived
- * Notifee was swapped for its maintained fork with no consumer impact.
- */
-
-import type { PendingEntry, NotificationRequest } from '../contract/notification';
-import type { PermissionKind, PermissionState, RestrictionReport } from '../contract/permission';
-import type { ResolvedTone, ChannelGroup } from '../contract/channel';
-import type { InteractionEvent, Unsubscribe } from '../contract/interaction';
-
-/** A request whose anchoring has already been resolved to a firing instant. */
-export interface EngineScheduleRequest {
-	readonly request: NotificationRequest;
-	/** The absolute instant the platform should fire, after anchoring resolution. */
-	readonly resolvedAt: number;
-	/** Resolved platform channel and category for the request's tone. */
-	readonly tone: ResolvedTone;
-	/**
-	 * The IANA time zone this moment was anchored against.
-	 *
-	 * Carried explicitly because the adapter has to round-trip it through the
-	 * platform data bag — `getPending` must report it (FR-010) so a consumer can
-	 * detect the one case re-anchoring cannot fix (FR-007c). Absent for
-	 * absolute-instant moments, which are never anchored to a zone at all.
-	 */
-	readonly anchoringGeneration?: string;
-	/** True when exact-alarm capability is unavailable and approximate mode applies. */
-	readonly approximate: boolean;
-	readonly seriesId?: string;
-	readonly pushCreated?: boolean;
-	/**
-	 * Marks this request as a package-owned stop marker rather than a consumer
-	 * notification.
-	 *
-	 * Carried here rather than smuggled through `ownerTag` or `routing` so it can
-	 * never collide with a value a consumer owns, and so the adapter can keep
-	 * markers out of `getPending` without inspecting consumer data.
-	 */
-	readonly repeatStop?: RepeatStop;
-}
-
-export interface EngineCapabilities {
-	/** iOS holds only the 64 soonest pending notifications and silently drops the rest. */
-	readonly pendingCeiling: number;
-	readonly supportsExactAlarms: boolean;
-	readonly supportsChannels: boolean;
-	readonly supportsTextInputActions: boolean;
-	readonly supportsDoNotDisturbBypass: boolean;
-	/**
-	 * Whether a notification's alert sound can be made to repeat until handled.
-	 *
-	 * Decides two things: whether a refused repeat is reported to the caller, and
-	 * whether a stop marker is placed at all. Where this is false no marker is
-	 * created, so the platform's pending ceiling is untouched by the feature.
-	 */
-	readonly supportsRepeatingAlert: boolean;
-	/** Milliseconds a background action or silent payload may run for. */
-	readonly backgroundWindowMs: number;
-}
-
-/**
- * What applying a tone declaration actually did.
- *
- * A boolean cannot carry this: a caller has to tell a label correction from a
- * newly created channel from a no-op, and reporting a refresh as a creation
- * would make every apply look like a write.
- */
-export type ToneDeclarationOutcome = 'created' | 'labelsRefreshed' | 'unchanged';
-
-/**
- * A package-owned artifact scheduled to end a repeating alert.
- *
- * Never a consumer notification. It exists because no platform offers "stop the
- * sound at time T but keep the notification", so something has to run at T.
- */
-export interface RepeatStop {
-	readonly markerId: string;
-	/** The consumer notification whose alert this stops. */
-	readonly targetId: string;
-	readonly dueAt: number;
-}
-
-/** A notification arriving, as opposed to a user acting on one. */
-export interface DeliveryEvent {
-	readonly notificationId: string;
-	readonly occurredAt: number;
-	/** Present when this delivery is a package-owned stop marker rather than a real notification. */
-	readonly repeatStop?: RepeatStop;
-}
-
-export interface NotificationEngineAdapter {
-	readonly name: string;
-
-	getCapabilities(): Promise<EngineCapabilities>;
-
-	/** Scheduling an existing identifier replaces it; exactly one entry results. */
-	schedule(request: EngineScheduleRequest): Promise<void>;
-
-	cancel(id: string): Promise<void>;
-	cancelMany(ids: readonly string[]): Promise<void>;
-	cancelAll(): Promise<void>;
-
-	/** Full detail, so callers can diff rather than merely count. */
-	getPending(): Promise<readonly PendingEntry[]>;
-
-	/**
-	 * Applies a channel or category declaration.
-	 *
-	 * Must return `labelsRefreshed` only when a label actually changed. Returning
-	 * it unconditionally would turn every apply into a write and quietly break
-	 * the zero-operation guarantee reconciliation idempotence rests on.
-	 */
-	declareTone(tone: ResolvedTone): Promise<ToneDeclarationOutcome>;
-	/** Removes a retired channel. Returns true when one was actually removed. */
-	retireTone(channelId: string): Promise<boolean>;
-	declareGroups(groups: readonly ChannelGroup[]): Promise<void>;
-	/** Channel ids the platform currently holds, which re-declaration cannot reveal. */
-	listDeclaredChannels(): Promise<readonly string[]>;
-
-	getPermission(kind: PermissionKind): Promise<PermissionState>;
-	requestPermission(kind: PermissionKind): Promise<PermissionState>;
-	openSettings(kind: PermissionKind): Promise<void>;
-	getRestrictions(): Promise<RestrictionReport>;
-
-	/** Interactions arriving before a handler registers are the caller's problem to buffer, not the engine's. */
-	subscribeToInteractions(handler: (event: InteractionEvent) => void): Unsubscribe;
-	/** Any interaction that launched the app, consumed exactly once. */
-	takeInitialInteraction(): Promise<InteractionEvent | undefined>;
-
-	/**
-	 * Stops a delivered notification's repeating alert without removing it.
-	 *
-	 * Re-posts the notification under the same identifier with the alert
-	 * suppressed. The same identifier means the same tray slot, so it replaces in
-	 * place: the sound stops and the notification stays. Cancelling instead would
-	 * be worse than never alerting at all — the user comes home to a silent phone
-	 * and no idea what they missed.
-	 *
-	 * Returns false when the notification is no longer displayed, which is the
-	 * ordinary case once the user has handled it.
-	 */
-	silenceDelivered(id: string): Promise<boolean>;
-
-	/** Package-owned stop markers currently scheduled. Never consumer notifications. */
-	listRepeatStops(): Promise<readonly RepeatStop[]>;
-
-	/**
-	 * Deliveries, as distinct from interactions.
-	 *
-	 * `subscribeToInteractions` deliberately discards delivery events, because
-	 * reporting an arrival as a tap would cancel a notification the user never
-	 * touched. Repeat expiry needs exactly the events that filter throws away, so
-	 * it gets its own subscription rather than loosening that one.
-	 */
-	subscribeToDeliveries(handler: (event: DeliveryEvent) => void): Unsubscribe;
-
-	/**
-	 * Registers the handler that runs when the app process is not alive.
-	 *
-	 * Must be called at module scope, outside the React tree, because that is
-	 * where the engine registers its headless task. The package cannot do this on
-	 * a consumer's behalf, which is why it is a documented setup step rather than
-	 * an internal detail — and why its absence is reported rather than guessed at.
-	 */
-	registerBackgroundDeliveryHandler(handler: (event: DeliveryEvent) => Promise<void>): void;
-
-	/** Whether a background delivery handler has been registered in this process. */
-	hasBackgroundDeliveryHandler(): boolean;
-}
+/**
+ * The port every local notification engine satisfies.
+ *
+ * No engine type appears in any signature here. That is what makes the engine
+ * replaceable — and it has already been exercised once, when the archived
+ * Notifee was swapped for its maintained fork with no consumer impact.
+ */
+
+import type { PendingEntry, NotificationRequest } from '../contract/notification';
+import type { PermissionKind, PermissionState, RestrictionReport } from '../contract/permission';
+import type { ResolvedTone, ChannelGroup } from '../contract/channel';
+import type { InteractionEvent, Unsubscribe } from '../contract/interaction';
+
+/** A request whose anchoring has already been resolved to a firing instant. */
+export interface EngineScheduleRequest {
+	readonly request: NotificationRequest;
+	/** The absolute instant the platform should fire, after anchoring resolution. */
+	readonly resolvedAt: number;
+	/** Resolved platform channel and category for the request's tone. */
+	readonly tone: ResolvedTone;
+	/**
+	 * The IANA time zone this moment was anchored against.
+	 *
+	 * Carried explicitly because the adapter has to round-trip it through the
+	 * platform data bag — `getPending` must report it (FR-010) so a consumer can
+	 * detect the one case re-anchoring cannot fix (FR-007c). Absent for
+	 * absolute-instant moments, which are never anchored to a zone at all.
+	 */
+	readonly anchoringGeneration?: string;
+	/** True when exact-alarm capability is unavailable and approximate mode applies. */
+	readonly approximate: boolean;
+	readonly seriesId?: string;
+	readonly pushCreated?: boolean;
+	/**
+	 * Marks this request as a package-owned stop marker rather than a consumer
+	 * notification.
+	 *
+	 * Carried here rather than smuggled through `ownerTag` or `routing` so it can
+	 * never collide with a value a consumer owns, and so the adapter can keep
+	 * markers out of `getPending` without inspecting consumer data.
+	 */
+	readonly repeatStop?: RepeatStop;
+}
+
+export interface EngineCapabilities {
+	/** iOS holds only the 64 soonest pending notifications and silently drops the rest. */
+	readonly pendingCeiling: number;
+	readonly supportsExactAlarms: boolean;
+	readonly supportsChannels: boolean;
+	readonly supportsTextInputActions: boolean;
+	readonly supportsDoNotDisturbBypass: boolean;
+	/**
+	 * Whether a notification's alert sound can be made to repeat until handled.
+	 *
+	 * Decides two things: whether a refused repeat is reported to the caller, and
+	 * whether a stop marker is placed at all. Where this is false no marker is
+	 * created, so the platform's pending ceiling is untouched by the feature.
+	 */
+	readonly supportsRepeatingAlert: boolean;
+	/** Milliseconds a background action or silent payload may run for. */
+	readonly backgroundWindowMs: number;
+}
+
+/**
+ * What applying a tone declaration actually did.
+ *
+ * A boolean cannot carry this: a caller has to tell a label correction from a
+ * newly created channel from a no-op, and reporting a refresh as a creation
+ * would make every apply look like a write.
+ */
+export type ToneDeclarationOutcome = 'created' | 'labelsRefreshed' | 'unchanged';
+
+/**
+ * A package-owned artifact scheduled to end a repeating alert.
+ *
+ * Never a consumer notification. It exists because no platform offers "stop the
+ * sound at time T but keep the notification", so something has to run at T.
+ */
+export interface RepeatStop {
+	readonly markerId: string;
+	/** The consumer notification whose alert this stops. */
+	readonly targetId: string;
+	readonly dueAt: number;
+}
+
+/** A notification arriving, as opposed to a user acting on one. */
+export interface DeliveryEvent {
+	readonly notificationId: string;
+	readonly occurredAt: number;
+	/** Present when this delivery is a package-owned stop marker rather than a real notification. */
+	readonly repeatStop?: RepeatStop;
+}
+
+export interface NotificationEngineAdapter {
+	readonly name: string;
+
+	getCapabilities(): Promise<EngineCapabilities>;
+
+	/** Scheduling an existing identifier replaces it; exactly one entry results. */
+	schedule(request: EngineScheduleRequest): Promise<void>;
+
+	cancel(id: string): Promise<void>;
+	cancelMany(ids: readonly string[]): Promise<void>;
+	cancelAll(): Promise<void>;
+
+	/** Full detail, so callers can diff rather than merely count. */
+	getPending(): Promise<readonly PendingEntry[]>;
+
+	/**
+	 * Applies a channel or category declaration.
+	 *
+	 * Must return `labelsRefreshed` only when a label actually changed. Returning
+	 * it unconditionally would turn every apply into a write and quietly break
+	 * the zero-operation guarantee reconciliation idempotence rests on.
+	 */
+	declareTone(tone: ResolvedTone): Promise<ToneDeclarationOutcome>;
+	/** Removes a retired channel. Returns true when one was actually removed. */
+	retireTone(channelId: string): Promise<boolean>;
+	declareGroups(groups: readonly ChannelGroup[]): Promise<void>;
+	/** Channel ids the platform currently holds, which re-declaration cannot reveal. */
+	listDeclaredChannels(): Promise<readonly string[]>;
+
+	getPermission(kind: PermissionKind): Promise<PermissionState>;
+	requestPermission(kind: PermissionKind): Promise<PermissionState>;
+	openSettings(kind: PermissionKind): Promise<void>;
+	getRestrictions(): Promise<RestrictionReport>;
+
+	/** Interactions arriving before a handler registers are the caller's problem to buffer, not the engine's. */
+	subscribeToInteractions(handler: (event: InteractionEvent) => void): Unsubscribe;
+	/** Any interaction that launched the app, consumed exactly once. */
+	takeInitialInteraction(): Promise<InteractionEvent | undefined>;
+
+	/**
+	 * Stops a delivered notification's repeating alert without removing it.
+	 *
+	 * Re-posts the notification under the same identifier with the alert
+	 * suppressed. The same identifier means the same tray slot, so it replaces in
+	 * place: the sound stops and the notification stays. Cancelling instead would
+	 * be worse than never alerting at all — the user comes home to a silent phone
+	 * and no idea what they missed.
+	 *
+	 * Returns false when the notification is no longer displayed, which is the
+	 * ordinary case once the user has handled it.
+	 */
+	silenceDelivered(id: string): Promise<boolean>;
+
+	/** Package-owned stop markers currently scheduled. Never consumer notifications. */
+	listRepeatStops(): Promise<readonly RepeatStop[]>;
+
+	/**
+	 * Deliveries, as distinct from interactions.
+	 *
+	 * `subscribeToInteractions` deliberately discards delivery events, because
+	 * reporting an arrival as a tap would cancel a notification the user never
+	 * touched. Repeat expiry needs exactly the events that filter throws away, so
+	 * it gets its own subscription rather than loosening that one.
+	 */
+	subscribeToDeliveries(handler: (event: DeliveryEvent) => void): Unsubscribe;
+
+	/**
+	 * Registers the handler that runs when the app process is not alive.
+	 *
+	 * Must be called at module scope, outside the React tree, because that is
+	 * where the engine registers its headless task. The package cannot do this on
+	 * a consumer's behalf, which is why it is a documented setup step rather than
+	 * an internal detail — and why its absence is reported rather than guessed at.
+	 */
+	registerBackgroundDeliveryHandler(handler: (event: DeliveryEvent) => Promise<void>): void;
+
+	/** Whether a background delivery handler has been registered in this process. */
+	hasBackgroundDeliveryHandler(): boolean;
+}