@chipmobilesdk/rn-payment 0.4.1 → 0.5.0

package/src/core/timers.ts

@@ -11,6 +11,8 @@
  * it configured something it did not.
  */
 
+import { checkRange, type Range } from '@chipmobilesdk/rn-core';
+
 import { PaymentConfigError } from '../diagnostics/errors';
 import type { BackoffConfig, RetryConfig, TimeoutConfig } from '../config/types';
 
@@ -113,30 +115,31 @@ export const DEFAULT_FINALIZE_BACKOFF: Required<BackoffConfig> = {
 
 export const BACKOFF_MAX_DELAY_BOUNDS = { min: 5_000, max: 600_000 } as const;
 export const BACKOFF_ATTEMPT_BOUNDS = { min: 1, max: 10 } as const;
+/** A first retry sooner than this is a storm; later than this, the user has given up. */
+export const BACKOFF_INITIAL_DELAY_BOUNDS = { min: 100, max: 60_000 } as const;
+/** 1 is a constant delay; 0 or below would retry at once, forever (CORE-05). */
+export const BACKOFF_FACTOR_BOUNDS = { min: 1, max: 10 } as const;
 
-interface Bounds {
-	readonly min: number;
-	readonly max: number;
+function invalidConfig(label: string) {
+	return (message: string) =>
+		new PaymentConfigError({
+			code: 'PAYMENT_INVALID_CONFIG',
+			message,
+			operation: 'configure',
+			offenders: [label],
+		});
 }
 
 function requireInBounds(
 	label: string,
 	value: number | undefined,
 	fallback: number,
-	bounds: Bounds,
+	bounds: Range,
+	unit = 'ms',
 ): number {
-	if (value === undefined) {
-		return fallback;
-	}
-	if (!Number.isFinite(value) || value < bounds.min || value > bounds.max) {
-		throw new PaymentConfigError({
-			code: 'PAYMENT_INVALID_CATALOG',
-			message: `${label} must be between ${bounds.min} and ${bounds.max}ms, received ${value}`,
-			operation: 'configure',
-			offenders: [label],
-		});
-	}
-	return value;
+	return value === undefined
+		? fallback
+		: checkRange(label, value, bounds, invalidConfig(label), unit);
 }
 
 export interface ResolvedTimeouts {
@@ -205,11 +208,30 @@ function resolveBackoff(
 		config?.maxAttempts,
 		fallback.maxAttempts,
 		BACKOFF_ATTEMPT_BOUNDS,
+		'',
 	);
+	const initialDelayMs = requireInBounds(
+		`${label}.initialDelayMs`,
+		config?.initialDelayMs,
+		fallback.initialDelayMs,
+		BACKOFF_INITIAL_DELAY_BOUNDS,
+	);
+	const factor = requireInBounds(
+		`${label}.factor`,
+		config?.factor,
+		fallback.factor,
+		BACKOFF_FACTOR_BOUNDS,
+		'',
+	);
+	if (initialDelayMs > maxDelayMs) {
+		throw invalidConfig(`${label}.initialDelayMs`)(
+			`${label}.initialDelayMs (${initialDelayMs}ms) exceeds ${label}.maxDelayMs (${maxDelayMs}ms)`,
+		);
+	}
 	return {
-		initialDelayMs: config?.initialDelayMs ?? fallback.initialDelayMs,
+		initialDelayMs,
 		maxDelayMs,
-		factor: config?.factor ?? fallback.factor,
+		factor,
 		maxAttempts,
 		jitter: config?.jitter ?? fallback.jitter,
 	};

package/src/diagnostics/errors.ts

@@ -6,6 +6,10 @@
  * internal refactor and must never leak a store's own code.
  */
 
+import { REDACTED, SdkError, createRedactor } from '@chipmobilesdk/rn-core';
+
+const identifiers = createRedactor();
+
 export const PAYMENT_ERROR_CODES = [
 	'PAYMENT_NOT_CONFIGURED',
 	'PAYMENT_INVALID_CATALOG',
@@ -31,6 +35,11 @@ export const PAYMENT_ERROR_CODES = [
 	'PAYMENT_STORAGE_UNAVAILABLE',
 	/** `consume` on a transaction that is not a consumable, added in 0.3.2. */
 	'PAYMENT_NOT_CONSUMABLE',
+	/**
+	 * A timeout, backoff or interval outside its bounds, added in 0.5.0. These
+	 * used to be reported as `PAYMENT_INVALID_CATALOG`, which is about products.
+	 */
+	'PAYMENT_INVALID_CONFIG',
 ] as const;
 
 export type PaymentErrorCode = (typeof PAYMENT_ERROR_CODES)[number];
@@ -49,10 +58,9 @@ export type PaymentOperation =
 	| 'validate'
 	| 'persist';
 
-export class PaymentError extends Error {
-	readonly code: PaymentErrorCode;
+/** The package's error; an `SdkError` (`@chipmobilesdk/rn-core`) with `pkg: 'rn-payment'`. */
+export class PaymentError extends SdkError<PaymentErrorCode> {
 	readonly operation: PaymentOperation;
-	readonly retryable: boolean;
 	/** Redacted where appropriate — never a raw receipt, token, or store object (FR-074). */
 	readonly cause?: string;
 
@@ -63,11 +71,13 @@ export class PaymentError extends Error {
 		retryable?: boolean;
 		cause?: string;
 	}) {
-		super(init.message);
+		super('rn-payment', init.code, {
+			message: init.message,
+			retryable: init.retryable ?? false,
+			redactedCause: init.cause,
+		});
 		this.name = 'PaymentError';
-		this.code = init.code;
 		this.operation = init.operation;
-		this.retryable = init.retryable ?? false;
 		this.cause = init.cause;
 	}
 }
@@ -107,11 +117,8 @@ export class PaymentConfigError extends PaymentError {
  * purchase token or an account id and nothing here can tell which.
  */
 export function redact(value: unknown): string {
-	if (value instanceof PaymentError) {
-		return value.code;
-	}
-	if (value instanceof Error) {
-		return value.name;
-	}
-	return '[redacted]';
+	// An SDK error reduces to its code and any other Error to its class name
+	// (rn-core's identifier-only redactor). Strings never survive here, not even
+	// a leading constant: a store message is free text from a payments SDK.
+	return value instanceof Error ? identifiers.text(value) : REDACTED;
 }

package/src/diagnostics/events.ts

@@ -10,6 +10,16 @@
  * obfuscated account identifier, and the cache-scope token.
  */
 
+import {
+	createDiagnosticChannel,
+	createEmitter as createCoreEmitter,
+} from '@chipmobilesdk/rn-core';
+
+/** Every delivered event also goes to the app's SDK sinks (`installSdkSink`, CORE-08). */
+const channel = createDiagnosticChannel<PaymentEvent['type'] | 'listener_reporter_failed'>(
+	'rn-payment',
+);
+
 import { redact, type PaymentErrorCode, type PaymentOperation } from './errors';
 import type {
 	EntitlementKey,
@@ -188,49 +198,58 @@ export interface PaymentEmitter {
 export function createEmitter(
 	onListenerError?: (error: unknown, event: PaymentEvent) => void,
 ): PaymentEmitter {
-	const listeners = new Set<PaymentEventListener>();
+	// The event whose listeners are running, so a failure is reported against it.
+	let dispatching: PaymentEvent | null = null;
 	let isDisposed = false;
-
-	const emit = (event: PaymentEvent): void => {
-		if (isDisposed) {
-			return;
-		}
-		// Snapshot first: a listener that subscribes or unsubscribes during
-		// delivery must not mutate the set being iterated.
-		for (const listener of [...listeners]) {
+	// rn-core's emitter: a snapshot per emit, each listener isolated, idempotent
+	// unsubscribe. Even the error reporter is isolated: if it throws, rn-core
+	// rethrows that on a fresh task rather than into the emit.
+	const emitter = createCoreEmitter<PaymentEvent>({
+		onListenerError: error => {
+			if (!dispatching) return;
 			try {
-				listener(event);
-			} catch (error) {
-				try {
-					onListenerError?.(error, event);
-				} catch {
-					// Even the error reporter is not trusted to behave.
-				}
+				onListenerError?.(error, dispatching);
+			} catch {
+				// The app's own reporter failed: nothing in the app is left to tell, so
+				// the failure goes to the SDK sinks rather than becoming an uncaught
+				// error on some later tick (FR-080).
+				channel.emit('listener_reporter_failed', 'error', {
+					eventType: dispatching.type,
+				});
 			}
-		}
-	};
+		},
+	});
 
 	return {
-		emit,
-		subscribe(listener: PaymentEventListener): Unsubscribe {
+		emit(event) {
 			if (isDisposed) {
-				return () => undefined;
+				return;
 			}
-			listeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
+			const previous = dispatching;
+			dispatching = event;
+			try {
+				if (emitter.emit(event)) {
+					// The type and the cycle only: payment events carry product and
+					// entitlement keys an app may treat as personal.
+					channel.emit(
+						event.type,
+						/failed|error|blocked|rejected|revoked/.test(event.type) ? 'warn' : 'info',
+						undefined,
+						event.correlationId,
+					);
 				}
-				removed = true;
-				listeners.delete(listener);
-			};
+			} finally {
+				dispatching = previous;
+			}
+		},
+		subscribe(listener: PaymentEventListener): Unsubscribe {
+			return isDisposed ? () => undefined : emitter.subscribe(listener);
 		},
 		dispose(): void {
 			isDisposed = true;
-			listeners.clear();
+			emitter.dispose();
 		},
-		listenerCount: () => listeners.size,
+		listenerCount: () => emitter.listenerCount(),
 		disposed: () => isDisposed,
 	};
 }

package/src/diagnostics/messageKeys.ts

@@ -14,6 +14,8 @@
  */
 
 /** Copy an end user may reasonably be shown. */
+import { defineMessages } from '@chipmobilesdk/rn-core';
+
 export interface PaymentUserMessageMap {
 	'payment.state.pending': string;
 	'payment.state.alreadyOwned': string;
@@ -68,20 +70,24 @@ export const DEFAULT_DEVELOPER_MESSAGES: PaymentDeveloperMessageMap = {
 		'Purchase blocked: this environment may not create a real transaction',
 };
 
-export const DEFAULT_MESSAGES: PaymentMessageMap = {
-	...DEFAULT_USER_MESSAGES,
-	...DEFAULT_DEVELOPER_MESSAGES,
-};
+/**
+ * The catalog as an rn-core message set. Register `paymentMessages.user` with
+ * rn-i18n to translate it like app copy; the developer copy stays out of bundles.
+ */
+export const paymentMessages = defineMessages({
+	user: DEFAULT_USER_MESSAGES,
+	developer: DEFAULT_DEVELOPER_MESSAGES,
+});
+
+export const DEFAULT_MESSAGES: PaymentMessageMap = paymentMessages.defaults;
 
 /** Every user-actionable key, for an app building its translation resource. */
-export const USER_MESSAGE_KEYS = Object.keys(DEFAULT_USER_MESSAGES) as PaymentUserMessageKey[];
+export const USER_MESSAGE_KEYS = paymentMessages.userKeys as PaymentUserMessageKey[];
 
 /** Every developer-facing key, so an app can exclude them from user-visible bundles. */
-export const DEVELOPER_MESSAGE_KEYS = Object.keys(
-	DEFAULT_DEVELOPER_MESSAGES,
-) as PaymentDeveloperMessageKey[];
+export const DEVELOPER_MESSAGE_KEYS = paymentMessages.developerKeys as PaymentDeveloperMessageKey[];
 
 /** True for keys safe to show an end user. Lets an app assert that at its boundary. */
 export function isUserMessageKey(key: PaymentMessageKey): key is PaymentUserMessageKey {
-	return key in DEFAULT_USER_MESSAGES;
+	return paymentMessages.audienceOf(key) === 'user';
 }

package/src/engine/engine.ts

@@ -10,6 +10,8 @@
  * which is what keeps the binding replaceable and iOS additive (FR-002, FR-007).
  */
 
+import { createListenerSet, currentPlatform } from '@chipmobilesdk/rn-core';
+
 import {
 	assertEnvironmentSafe,
 	mayCreateRealTransaction,
@@ -60,6 +62,7 @@ import {
 	initialEntitlements,
 	type EntitlementMap,
 	type EntitlementState,
+	shareUnchanged,
 } from '../entitlements/aggregate';
 import { productKeyForStoreId } from '../entitlements/mapping';
 import { derivePending, pendingTransitions, samePending, UNKNOWN_PENDING } from './pending';
@@ -156,7 +159,10 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 	// Both run before anything connects: a bad catalog or an unsafe environment
 	// must fail at configuration time, not when a user taps Buy.
 	assertEnvironmentSafe(config);
-	const platform = deps.platform ?? 'android';
+	// rn-core's one platform source (CORE-09): this used to assume Android, so an
+	// iOS app validated its catalog against the Android product ids. Where neither
+	// OS applies, the store provider refuses everything as unsupported anyway.
+	const platform = deps.platform ?? (currentPlatform() === 'ios' ? 'ios' : 'android');
 	const resolved = validateConfig(config, platform);
 
 	const now = deps.now ?? (() => Date.now());
@@ -190,9 +196,15 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 
 	let pending: PendingPurchasesState = UNKNOWN_PENDING;
 
-	const statusListeners = new Set<(status: PaymentStatus) => void>();
-	const entitlementListeners = new Set<(map: EntitlementMap) => void>();
-	const pendingListeners = new Set<(pending: PendingPurchasesState) => void>();
+	// A broken consumer callback must not stop the others nor the state machine
+	// (FR-081); rn-core isolates each one and the failure goes to the logger.
+	const listenerOptions = {
+		onListenerError: (error: unknown) =>
+			config.logger?.error?.('payment listener threw', { reason: redact(error) }),
+	};
+	const statusListeners = createListenerSet<[PaymentStatus]>(listenerOptions);
+	const entitlementListeners = createListenerSet<[EntitlementMap]>(listenerOptions);
+	const pendingListeners = createListenerSet<[PendingPurchasesState]>(listenerOptions);
 	let connectionSub: Unsubscribe | undefined;
 	let purchaseSub: Unsubscribe | undefined;
 	let reconnectTimer: ReturnType<typeof setTimeout> | undefined;
@@ -222,14 +234,7 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			unavailableReason: status.unavailableReason,
 			retryable: status.retryable,
 		});
-		for (const listener of [...statusListeners]) {
-			// A throwing status listener must not break the state machine (FR-081).
-			try {
-				listener(status);
-			} catch {
-				/* reported through the emitter's own guard */
-			}
-		}
+		statusListeners.notify(status);
 	};
 
 	/**
@@ -244,13 +249,16 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			return;
 		}
 		const previous = entitlements;
-		entitlements = aggregate({
-			config: resolved,
-			snapshot: currentSnapshot,
-			hasSynced,
-			reportsGraceAndHoldDistinctly: provider.capabilities().reportsGraceAndHoldDistinctly,
-			now: now(),
-		});
+		entitlements = shareUnchanged(
+			previous,
+			aggregate({
+				config: resolved,
+				snapshot: currentSnapshot,
+				hasSynced,
+				reportsGraceAndHoldDistinctly: provider.capabilities().reportsGraceAndHoldDistinctly,
+				now: now(),
+			}),
+		);
 
 		for (const change of diffEntitlements(previous, entitlements)) {
 			if (change.next === 'entitled') {
@@ -268,12 +276,9 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			}
 		}
 
-		for (const listener of [...entitlementListeners]) {
-			try {
-				listener(entitlements);
-			} catch {
-				/* a broken consumer callback must not stop the others (FR-081) */
-			}
+		// Unchanged map, same object: nothing to tell a subscriber (PERF-03).
+		if (entitlements !== previous) {
+			entitlementListeners.notify(entitlements);
 		}
 
 		publishPending(
@@ -298,13 +303,7 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			return;
 		}
 		pending = next;
-		for (const listener of [...pendingListeners]) {
-			try {
-				listener(pending);
-			} catch {
-				/* a broken consumer callback must not stop the others (FR-081) */
-			}
-		}
+		pendingListeners.notify(pending);
 	};
 
 	const commit = (next: PersistedSnapshot): void => {
@@ -668,15 +667,7 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			if (disposed) {
 				return () => undefined;
 			}
-			statusListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				statusListeners.delete(listener);
-			};
+			return statusListeners.add(listener);
 		},
 
 		/** Synchronous, in-memory, zero I/O — it is read on render paths (PERF-001). */
@@ -699,30 +690,14 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			if (disposed) {
 				return () => undefined;
 			}
-			pendingListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				pendingListeners.delete(listener);
-			};
+			return pendingListeners.add(listener);
 		},
 
 		subscribeEntitlements(listener): Unsubscribe {
 			if (disposed) {
 				return () => undefined;
 			}
-			entitlementListeners.add(listener);
-			let removed = false;
-			return () => {
-				if (removed) {
-					return;
-				}
-				removed = true;
-				entitlementListeners.delete(listener);
-			};
+			return entitlementListeners.add(listener);
 		},
 
 		async sync(trigger: SyncTrigger = 'manual'): Promise<SyncOutcome> {
@@ -862,13 +837,7 @@ export function createEngine(config: PaymentConfig, deps: EngineDeps): PaymentEn
 			// Back to `unknown`, not `not_entitled`: after a logout the package has no
 			// basis for either claim until the next sync.
 			entitlements = initialEntitlements(resolved);
-			for (const listener of [...entitlementListeners]) {
-				try {
-					listener(entitlements);
-				} catch {
-					/* ignore */
-				}
-			}
+			entitlementListeners.notify(entitlements);
 			// Same reasoning, and no `purchase_pending_resolved`: the records were
 			// discarded locally, not ended at the store.
 			publishPending(UNKNOWN_PENDING);

package/src/engine/foreground.ts

@@ -0,0 +1,29 @@
+/**
+ * Opt-in foreground sync over rn-core's shared lifecycle port (PERF-07, FR-059).
+ *
+ * `handleForeground()` stays the app's to call: the engine does not decide what a
+ * foreground return is. An app that is happy with "back from the background" calls
+ * this once instead of wiring `AppState` itself, and shares the one native
+ * subscription every package uses. A trip through `inactive` alone (a biometric
+ * prompt, iOS Control Center) is not a return. On Android the Play purchase sheet
+ * does send the app to the background, so a purchase is followed by a sync; the
+ * engine's foreground rate limit keeps that to one request per interval.
+ */
+import {
+	appLifecycle,
+	onForeground,
+	type AppLifecyclePort,
+	type Unsubscribe,
+} from '@chipmobilesdk/rn-core';
+
+import type { PaymentEngine } from './engine';
+
+export function syncOnForeground(
+	engine: Pick<PaymentEngine, 'handleForeground'>,
+	lifecycle: AppLifecyclePort = appLifecycle(),
+): Unsubscribe {
+	return onForeground(() => {
+		// Sync reports its own failures through status and diagnostics.
+		engine.handleForeground().catch(() => undefined);
+	}, lifecycle);
+}

package/src/entitlements/aggregate.ts

@@ -16,6 +16,7 @@
  *   and the package says so rather than asserting the user did not pay.
  */
 
+import { shallowEqual } from '@chipmobilesdk/rn-core';
 import type { ResolvedConfig } from '../config/validate';
 import type { EntitlementKey, ProductKey } from '../config/types';
 import type { PersistedPurchase, PersistedSnapshot } from '../persistence/snapshot';
@@ -225,3 +226,36 @@ export function diffEntitlements(
 	}
 	return changes;
 }
+
+function sameEntitlement(a: EntitlementState, b: EntitlementState): boolean {
+	return (
+		a.status === b.status &&
+		a.isStale === b.isStale &&
+		a.lastSyncedAt === b.lastSyncedAt &&
+		a.sources.length === b.sources.length &&
+		a.sources.every((source, index) => source === b.sources[index]) &&
+		shallowEqual(a.subscription, b.subscription)
+	);
+}
+
+/**
+ * `next`, with every entitlement that did not change replaced by the object it
+ * replaces, and `previous` itself when nothing changed (PERF-03, PAY-08). A hook
+ * selecting one entitlement then sees the same object and does not re-render.
+ */
+export function shareUnchanged(previous: EntitlementMap, next: EntitlementMap): EntitlementMap {
+	const keys = Object.keys(next);
+	let changed = keys.length !== Object.keys(previous).length;
+	const shared: EntitlementMap = {};
+	for (const key of keys) {
+		const before = previous[key];
+		const after = next[key]!;
+		if (before && sameEntitlement(before, after)) {
+			shared[key] = before;
+		} else {
+			shared[key] = after;
+			changed = true;
+		}
+	}
+	return changed ? shared : previous;
+}

package/src/index.ts

@@ -120,6 +120,8 @@ export type {
 	SyncOutcome,
 } from './engine/engine';
 
+export { syncOnForeground } from './engine/foreground';
+
 // --- React -----------------------------------------------------------------
 export { PaymentProvider, usePaymentEngine } from './react/PaymentProvider';
 export type { PaymentProviderProps } from './react/PaymentProvider';
@@ -150,6 +152,7 @@ export type {
 export {
 	DEFAULT_DEVELOPER_MESSAGES,
 	DEFAULT_MESSAGES,
+	paymentMessages,
 	DEFAULT_USER_MESSAGES,
 	DEVELOPER_MESSAGE_KEYS,
 	USER_MESSAGE_KEYS,

package/src/persistence/mmkv-store.ts

@@ -14,19 +14,21 @@
  * attached to a transaction.
  */
 
+import { createMemoryKeyValue, lazyPeer, openDurable, type MmkvLike } from '@chipmobilesdk/rn-core';
+
 import { emptySnapshot, migrateSnapshot, type PersistedSnapshot } from './snapshot';
 
 const INSTANCE_ID = 'chipmobilesdk.payment';
 const KEY_PREFIX = 'snapshot';
 
-/** The slice of a react-native-mmkv v4 instance this store uses (v4 names). */
-interface MmkvLike {
-	getString(key: string): string | undefined;
-	set(key: string, value: string): void;
-	remove(key: string): unknown;
-	clearAll(): void;
-	getAllKeys(): string[];
-}
+const mmkv = lazyPeer('react-native-mmkv', () => {
+	// Inside `try`, so Metro bundles an app that leaves this optional peer out.
+	try {
+		return require('react-native-mmkv') as { createMMKV: (config?: { id?: string }) => MmkvLike };
+	} catch (cause) {
+		throw cause;
+	}
+});
 
 export interface SnapshotStore {
 	load(scopeToken?: string): PersistedSnapshot;
@@ -43,20 +45,6 @@ function scopeKey(scopeToken?: string): string {
 	return `${KEY_PREFIX}:${scopeToken ?? '__default__'}`;
 }
 
-/** In-memory fallback, used when the native module is absent. */
-function createMemoryBacking(): MmkvLike {
-	const map = new Map<string, string>();
-	return {
-		getString: key => map.get(key),
-		set(key, value) {
-			map.set(key, value);
-		},
-		remove: key => map.delete(key),
-		clearAll: () => map.clear(),
-		getAllKeys: () => [...map.keys()],
-	};
-}
-
 /**
  * Opens the MMKV instance through v4's `createMMKV`.
  *
@@ -67,15 +55,20 @@ function createMemoryBacking(): MmkvLike {
  * Tests could not see it, because the test double still exported a v3 class.
  */
 function resolveBacking(): { backing: MmkvLike; durable: boolean } {
-	try {
-		// Required lazily so the package loads where the native module is absent.
-		const { createMMKV } = require('react-native-mmkv') as {
-			createMMKV: (config?: { id?: string }) => MmkvLike;
-		};
-		return { backing: createMMKV({ id: INSTANCE_ID }), durable: true };
-	} catch {
-		return { backing: createMemoryBacking(), durable: false };
-	}
+	// rn-core's port: MMKV when it opens, otherwise memory with `durable: false`.
+	const port = openDurable(() =>
+		mmkv.require(peer => new Error(`${peer} is not installed`)).createMMKV({ id: INSTANCE_ID }),
+	);
+	return {
+		backing: {
+			getString: key => port.getString(key),
+			set: (key, value) => port.set(key, value),
+			remove: key => port.remove(key),
+			clearAll: () => port.clearAll(),
+			getAllKeys: () => port.keys(),
+		},
+		durable: port.durable,
+	};
 }
 
 /**
@@ -151,5 +144,15 @@ export function createSnapshotStore(injected?: {
 
 /** Test seam for driving the store without the native module. */
 export function createMemorySnapshotStore(): SnapshotStore {
-	return createSnapshotStore({ backing: createMemoryBacking(), durable: false });
+	const memory = createMemoryKeyValue();
+	return createSnapshotStore({
+		backing: {
+			getString: key => memory.getString(key),
+			set: (key, value) => memory.set(key, value),
+			remove: key => memory.remove(key),
+			clearAll: () => memory.clearAll(),
+			getAllKeys: () => memory.keys(),
+		},
+		durable: false,
+	});
 }