@smileid/usesmileid 12.0.1 → 12.0.2

package/src/l10n/__tests__/use_smile_id_localizations_provider.test.tsx

@@ -0,0 +1,112 @@
+import { describe, it, expect } from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+import {
+  UseSmileIDLocalizationsProvider,
+  useStableLocalizations,
+  useUseSmileIDLocalizations,
+} from "../use_smile_id_localizations_provider";
+import { UseSmileIDLocalizations } from "../use_smile_id_localizations";
+
+function renderReader(children: React.ReactNode) {
+  let renderer!: ReturnType<typeof createRenderer>;
+  act(() => {
+    renderer = createRenderer(<>{children}</>);
+  });
+  return renderer;
+}
+
+describe("useUseSmileIDLocalizations", () => {
+  it("returns the English default when no provider wraps the caller", () => {
+    const seen: string[] = [];
+    function Reader() {
+      seen.push(useUseSmileIDLocalizations().siConsentAllow);
+      return null;
+    }
+
+    renderReader(<Reader />);
+
+    expect(seen).toEqual(["Allow"]);
+  });
+
+  it("returns the provider's instance when one is mounted", () => {
+    const localizations = new UseSmileIDLocalizations({
+      si_consent_allow: "Autoriser",
+    });
+    const seen: UseSmileIDLocalizations[] = [];
+    function Reader() {
+      seen.push(useUseSmileIDLocalizations());
+      return null;
+    }
+
+    renderReader(
+      <UseSmileIDLocalizationsProvider value={localizations}>
+        <Reader />
+      </UseSmileIDLocalizationsProvider>,
+    );
+
+    expect(seen[0]).toBe(localizations);
+    expect(seen[0]?.siConsentAllow).toBe("Autoriser");
+  });
+});
+
+describe("useStableLocalizations", () => {
+  it("builds a localizations instance from the overrides map", () => {
+    const overrides = { si_consent_allow: "Autoriser" };
+    const seen: UseSmileIDLocalizations[] = [];
+    function Reader() {
+      seen.push(useStableLocalizations(overrides));
+      return null;
+    }
+
+    renderReader(<Reader />);
+
+    expect(seen[0]).toBeInstanceOf(UseSmileIDLocalizations);
+    expect(seen[0]?.siConsentAllow).toBe("Autoriser");
+  });
+
+  it("keeps one instance across re-renders for a stable overrides object", () => {
+    const overrides = { si_consent_allow: "Autoriser" };
+    const seen: UseSmileIDLocalizations[] = [];
+    function Reader(_props: { tick: number }) {
+      seen.push(useStableLocalizations(overrides));
+      return null;
+    }
+
+    let renderer!: ReturnType<typeof createRenderer>;
+    act(() => {
+      renderer = createRenderer(<Reader tick={0} />);
+    });
+    act(() => {
+      renderer.update(<Reader tick={1} />);
+    });
+
+    expect(seen).toHaveLength(2);
+    expect(seen[0]).toBe(seen[1]);
+  });
+
+  it("rebuilds when the partner passes a fresh overrides object", () => {
+    const seen: UseSmileIDLocalizations[] = [];
+    function Reader({
+      overrides,
+    }: {
+      overrides: Partial<Record<string, string>>;
+    }) {
+      seen.push(useStableLocalizations(overrides));
+      return null;
+    }
+
+    let renderer!: ReturnType<typeof createRenderer>;
+    act(() => {
+      renderer = createRenderer(
+        <Reader overrides={{ si_consent_allow: "Autoriser" }} />,
+      );
+    });
+    act(() => {
+      renderer.update(<Reader overrides={{ si_consent_allow: "Permitir" }} />);
+    });
+
+    expect(seen[0]).not.toBe(seen[1]);
+    expect(seen[1]?.siConsentAllow).toBe("Permitir");
+  });
+});

package/src/l10n/__tests__/use_smile_id_localizations_surface.test.ts

@@ -0,0 +1,231 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { UseSmileIDLocalizations } from "../use_smile_id_localizations";
+import { enStrings } from "../strings_en";
+
+/**
+ * Every localized accessor is a two-line `_s(key, enStrings[key])` /
+ * `_t(key, enStrings[key], params)` wrapper. Hand-writing one test per
+ * accessor would be ~130 near-identical tests, so this suite drives the
+ * whole surface off the prototype: a Proxy overrides map reports which
+ * `si_*` key each accessor asks for, which is then checked against the
+ * English default it returns. A typo'd key (the realistic defect — a
+ * copy-pasted getter reading its neighbour's key) fails here.
+ */
+
+const PARAM_VALUE = "SENTINEL-PARAM";
+
+type Accessor = {
+  readonly name: string;
+  readonly arity: number;
+  readonly call: (instance: UseSmileIDLocalizations) => string;
+};
+
+const accessors: readonly Accessor[] = Object.entries(
+  Object.getOwnPropertyDescriptors(UseSmileIDLocalizations.prototype),
+)
+  .filter(([name]) => name.startsWith("si"))
+  .map(([name, descriptor]): Accessor => {
+    if (descriptor.get) {
+      return {
+        name,
+        arity: 0,
+        call: (instance) =>
+          (instance as unknown as Record<string, string>)[name] as string,
+      };
+    }
+    const method = descriptor.value as (...args: string[]) => string;
+    const arity = method.length;
+    return {
+      name,
+      arity,
+      call: (instance) =>
+        method.apply(
+          instance,
+          Array.from({ length: arity }, () => PARAM_VALUE),
+        ),
+    };
+  });
+
+/** Overrides map that reports which key an accessor looked up. */
+function keyProbe(): Partial<Record<string, string>> {
+  return new Proxy(
+    {},
+    {
+      get: (_target, property) =>
+        typeof property === "string" ? `<<${property}>>` : undefined,
+    },
+  ) as Partial<Record<string, string>>;
+}
+
+function lookedUpKey(accessor: Accessor): string {
+  const probed = accessor.call(new UseSmileIDLocalizations(keyProbe()));
+  const match = /^<<(.+)>>$/.exec(probed);
+  if (!match?.[1]) {
+    throw new Error(
+      `${accessor.name} did not resolve through the overrides map (got ${probed})`,
+    );
+  }
+  return match[1];
+}
+
+describe("UseSmileIDLocalizations — accessor surface", () => {
+  it("exposes an accessor for every localized string", () => {
+    expect(accessors.length).toBeGreaterThan(100);
+  });
+
+  it.each(accessors.map((accessor) => [accessor.name, accessor] as const))(
+    "%s reads its own si_ key and defaults to the English string",
+    (_name, accessor) => {
+      const key = lookedUpKey(accessor);
+
+      expect(key).toMatch(/^si_/);
+      expect(enStrings).toHaveProperty(key);
+
+      const english = (enStrings as Record<string, string>)[key] as string;
+      const actual = accessor.call(new UseSmileIDLocalizations());
+      const expected =
+        accessor.arity === 0
+          ? english
+          : english.replace(
+              /\{[A-Za-z_][A-Za-z0-9_]*\}/g,
+              `\u2068${PARAM_VALUE}\u2069`,
+            );
+
+      expect(actual).toBe(expected);
+    },
+  );
+
+  it("maps each accessor to a distinct key — no copy-paste collisions", () => {
+    const keys = accessors.map(lookedUpKey);
+
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+
+  it("leaves no canonical string unreachable through the public surface", () => {
+    const reached = new Set(accessors.map(lookedUpKey));
+    const orphans = Object.keys(enStrings).filter((key) => !reached.has(key));
+
+    expect(orphans).toEqual([]);
+  });
+
+  it("substitutes named tokens only in the parameterized accessors", () => {
+    const parameterized = accessors.filter((accessor) => accessor.arity > 0);
+    expect(parameterized.length).toBeGreaterThan(0);
+
+    for (const accessor of parameterized) {
+      const rendered = accessor.call(new UseSmileIDLocalizations());
+      expect(rendered).toContain(PARAM_VALUE);
+      expect(rendered).not.toMatch(/\{[A-Za-z_][A-Za-z0-9_]*\}/);
+    }
+  });
+});
+
+describe("UseSmileIDLocalizations — locale registry", () => {
+  const originalResolver = UseSmileIDLocalizations.localeResolver;
+
+  beforeEach(() => {
+    UseSmileIDLocalizations.clearRegistry();
+  });
+
+  afterEach(() => {
+    UseSmileIDLocalizations.clearRegistry();
+    UseSmileIDLocalizations.localeResolver = originalResolver;
+  });
+
+  it("reports an empty registry until a locale is registered", () => {
+    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(false);
+
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
+
+    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(true);
+  });
+
+  it("clearRegistry empties it again", () => {
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
+    UseSmileIDLocalizations.clearRegistry();
+
+    expect(UseSmileIDLocalizations.hasRegisteredLocales()).toBe(false);
+  });
+
+  it("strips ARB metadata and non-string values on register", () => {
+    UseSmileIDLocalizations.register("fr", {
+      "@@locale": "fr",
+      "@si_consent_allow": { description: "Allow" },
+      si_consent_allow: "Autoriser",
+      si_consent_deny: 42,
+    });
+    UseSmileIDLocalizations.localeResolver = () => "fr";
+
+    const resolved = UseSmileIDLocalizations.forActiveLocale();
+
+    expect(resolved.siConsentAllow).toBe("Autoriser");
+    expect(resolved.siConsentDeny).toBe("Deny");
+  });
+
+  it("re-registering a locale replaces the prior translations", () => {
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Ancien" });
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
+    UseSmileIDLocalizations.localeResolver = () => "fr";
+
+    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
+      "Autoriser",
+    );
+  });
+
+  it("prefers an exact locale match over the language-only entry", () => {
+    UseSmileIDLocalizations.register("pt", { si_consent_allow: "Permitir" });
+    UseSmileIDLocalizations.register("pt-BR", {
+      si_consent_allow: "Permitir (BR)",
+    });
+    UseSmileIDLocalizations.localeResolver = () => "pt-BR";
+
+    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
+      "Permitir (BR)",
+    );
+  });
+
+  it("falls back to the language subtag when the region variant is unregistered", () => {
+    UseSmileIDLocalizations.register("pt", { si_consent_allow: "Permitir" });
+    UseSmileIDLocalizations.localeResolver = () => "pt-BR";
+
+    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
+      "Permitir",
+    );
+  });
+
+  it("falls back to English when neither the locale nor its language is registered", () => {
+    UseSmileIDLocalizations.register("fr", { si_consent_allow: "Autoriser" });
+    UseSmileIDLocalizations.localeResolver = () => "sw-KE";
+
+    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
+      "Allow",
+    );
+  });
+
+  it("falls back to English when the registry is empty", () => {
+    UseSmileIDLocalizations.localeResolver = () => "fr";
+
+    expect(UseSmileIDLocalizations.forActiveLocale().siConsentAllow).toBe(
+      "Allow",
+    );
+  });
+
+  it("resolves the device language subtag by default", () => {
+    const language = UseSmileIDLocalizations.localeResolver();
+
+    expect(language).toMatch(/^[a-z]{2,3}$/);
+    expect(language).not.toContain("-");
+  });
+
+  it("falls back to English when Intl is unavailable", () => {
+    const originalIntl = globalThis.Intl;
+    // Concrete scenario: a JS engine (or a locked-down Hermes build)
+    // without full-ICU — the resolver must not throw at flow mount.
+    (globalThis as { Intl?: unknown }).Intl = undefined;
+    try {
+      expect(originalResolver()).toBe("en");
+    } finally {
+      globalThis.Intl = originalIntl;
+    }
+  });
+});

package/src/l10n/strings_en.ts

@@ -81,6 +81,8 @@ export const enStrings = {
   si_capture_hold_steady: "Hold still…",
   si_capture_timeout: "Capture timed out. Try again.",
   si_capture_failed: "Capture failed. Please try again.",
+  si_capture_camera_unavailable:
+    "No camera frames received. Close other apps using the camera, then try again.",
   si_capture_adjusting: "Adjusting…",
   si_capture_bright_light: "Please move away from direct light",
   si_processing: "Processing…",
@@ -104,6 +106,8 @@ export const enStrings = {
     "Thank you for your submission. We are currently verifying your details.",
   si_processing_failed_title: "Submission Failed",
   si_processing_failed_message: "Reasons for failure",
+  si_processing_error_no_connection: "No internet connection.",
+  si_processing_error_generic: "Something went wrong. Try again.",
   si_processing_continue: "Continue",
   si_processing_retry: "Retry",
   si_processing_exit: "Exit",
@@ -169,4 +173,4 @@ export const enStrings = {
 export type SiKey = keyof typeof enStrings;
 
 /** Total canonical key count — pinned in tests to catch a missed addition/deletion at PR time. */
-export const CANONICAL_KEY_COUNT = 119 as const;
+export const CANONICAL_KEY_COUNT = 122 as const;

package/src/l10n/use_smile_id_localizations.ts

@@ -1,5 +1,28 @@
 import { enStrings, type SiKey } from "./strings_en";
 
+// Unicode bidi isolates: without them a substituted value of the opposite direction reorders the whole sentence.
+const FIRST_STRONG_ISOLATE = "⁨";
+const POP_DIRECTIONAL_ISOLATE = "⁩";
+
+// `__DEV__` is bundler-injected; outside Metro-like environments a bare reference throws rather than reading falsy.
+function isDevBuild(): boolean {
+  return typeof __DEV__ !== "undefined" && __DEV__;
+}
+
+const warnedLocales = new Set<string>();
+
+function warnLocaleFallback(locale: string): void {
+  if (!isDevBuild() || warnedLocales.has(locale)) return;
+  warnedLocales.add(locale);
+  // eslint-disable-next-line no-console
+  console.warn(
+    `[UseSmileID] No translations registered for locale '${locale}' — the SDK ` +
+      "is rendering English. Call UseSmileIDLocalizations.register('" +
+      locale +
+      "', …) at startup, or set b.localizations explicitly.",
+  );
+}
+
 /**
  * Localized string surface for the SDK. Canonical `si_*` keys default to English
  * (`strings_en.ts`); partners override per-locale by passing an `overrides` map to
@@ -42,6 +65,7 @@ export class UseSmileIDLocalizations {
   // JS hook for discovering bundled translation assets.
 
   private static _registry = new Map<string, Partial<Record<string, string>>>();
+  private static _registryRevision = 0;
 
   /**
    * Default device-locale resolver: reads the BCP 47 locale via
@@ -71,11 +95,13 @@ export class UseSmileIDLocalizations {
       if (typeof value === "string") filtered[key] = value;
     }
     UseSmileIDLocalizations._registry.set(locale, filtered);
+    UseSmileIDLocalizations._registryRevision += 1;
   }
 
   /** Clear the locale registry. Useful for tests; partners rarely call. */
   static clearRegistry(): void {
     UseSmileIDLocalizations._registry.clear();
+    UseSmileIDLocalizations._registryRevision += 1;
   }
 
   /** Whether any locale has been registered. */
@@ -83,6 +109,11 @@ export class UseSmileIDLocalizations {
     return UseSmileIDLocalizations._registry.size > 0;
   }
 
+  /** Identity of the translations `forActiveLocale()` would resolve right now; it changes on a locale switch or a late `register(...)`. */
+  static get activeLocaleKey(): string {
+    return `${UseSmileIDLocalizations.localeResolver()}#${UseSmileIDLocalizations._registryRevision}`;
+  }
+
   /**
    * Resolve the active locale via `localeResolver()` and return the matching
    * `UseSmileIDLocalizations`. Lookup order: exact match (`'pt-BR'`), then
@@ -99,26 +130,54 @@ export class UseSmileIDLocalizations {
       const fallback = UseSmileIDLocalizations._registry.get(language);
       if (fallback) return new UseSmileIDLocalizations(fallback);
     }
+    warnLocaleFallback(locale);
     return new UseSmileIDLocalizations();
   }
 
+  /** One dev-build warning per instance, so a partly translated bundle can't flood the console. */
+  private _warnedMissingKey = false;
+
+  private _lookup(key: SiKey, fallback: string): string {
+    const override = this._overrides[key];
+    if (override !== undefined) return override;
+    if (
+      isDevBuild() &&
+      !this._warnedMissingKey &&
+      Object.keys(this._overrides).length > 0
+    ) {
+      this._warnedMissingKey = true;
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[UseSmileID] '${key}' is missing from the supplied translations and is ` +
+          "rendering English; other keys may be too. Compare your overrides " +
+          "against the si_* key set in the SDK's English strings.",
+      );
+    }
+    return fallback;
+  }
+
   /** @internal Static-fallback string lookup. */
   private _s(key: SiKey, fallback: string): string {
-    return this._overrides[key] ?? fallback;
+    return this._lookup(key, fallback);
   }
 
   /**
    * @internal Templated lookup; replaces every `{name}` with `params[name]`. A
    * placeholder absent from the translation is left as-is (the `{name}` literal).
+   * Substituted values are bidi-isolated so they cannot reorder the sentence around them.
    */
   private _t(
     key: SiKey,
     fallback: string,
     params: Readonly<Record<string, string>>,
   ): string {
-    let value = this._overrides[key] ?? fallback;
+    let value = this._lookup(key, fallback);
     for (const [name, replacement] of Object.entries(params)) {
-      value = value.split(`{${name}}`).join(replacement);
+      const isolated =
+        replacement === ""
+          ? replacement
+          : `${FIRST_STRONG_ISOLATE}${replacement}${POP_DIRECTIONAL_ISOLATE}`;
+      value = value.split(`{${name}}`).join(isolated);
     }
     return value;
   }
@@ -389,6 +448,12 @@ export class UseSmileIDLocalizations {
   get siCaptureHoldSteady(): string {
     return this._s("si_capture_hold_steady", enStrings.si_capture_hold_steady);
   }
+  get siCaptureCameraUnavailable(): string {
+    return this._s(
+      "si_capture_camera_unavailable",
+      enStrings.si_capture_camera_unavailable,
+    );
+  }
   get siCaptureTimeout(): string {
     return this._s("si_capture_timeout", enStrings.si_capture_timeout);
   }
@@ -492,6 +557,18 @@ export class UseSmileIDLocalizations {
       enStrings.si_processing_failed_message,
     );
   }
+  get siProcessingErrorNoConnection(): string {
+    return this._s(
+      "si_processing_error_no_connection",
+      enStrings.si_processing_error_no_connection,
+    );
+  }
+  get siProcessingErrorGeneric(): string {
+    return this._s(
+      "si_processing_error_generic",
+      enStrings.si_processing_error_generic,
+    );
+  }
   get siProcessingContinue(): string {
     return this._s("si_processing_continue", enStrings.si_processing_continue);
   }

package/src/metadata/__tests__/device_orientation_sampling.test.ts

@@ -0,0 +1,165 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// `vi.mock` is hoisted above the imports, so anything its factory closes over
+// must be created with `vi.hoisted` or it is still in the TDZ when the factory
+// runs.
+const { loadExpoSensors } = vi.hoisted(() => ({ loadExpoSensors: vi.fn() }));
+
+vi.mock("../optional_native_modules", () => ({ loadExpoSensors }));
+
+import { DeviceOrientationCollector } from "../device_orientation_collector";
+
+/**
+ * Sampling behaviour of the accelerometer collector: the ~15 Hz throttle,
+ * the 90 s session cap, the movement-span computation, and the graceful
+ * no-op when `expo-sensors` is absent. The empty-session contract is pinned
+ * separately in `device_orientation_collector.test.ts`.
+ */
+
+type Sample = { x: number; y: number; z: number };
+
+function makeSensors() {
+  const listeners: Array<(data: Sample) => void> = [];
+  const remove = vi.fn(() => {
+    listeners.length = 0;
+  });
+  const setUpdateInterval = vi.fn();
+  const addListener = vi.fn((listener: (data: Sample) => void) => {
+    listeners.push(listener);
+    return { remove };
+  });
+  return {
+    module: { Accelerometer: { setUpdateInterval, addListener } },
+    emit: (sample: Sample) => {
+      for (const listener of [...listeners]) listener(sample);
+    },
+    setUpdateInterval,
+    addListener,
+    remove,
+    listenerCount: () => listeners.length,
+  };
+}
+
+describe("DeviceOrientationCollector — sampling", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-07-30T00:00:00.000Z"));
+    loadExpoSensors.mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("subscribes at the ~15 Hz sampling interval on start", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+
+    new DeviceOrientationCollector().start();
+
+    expect(sensors.setUpdateInterval).toHaveBeenCalledWith(66);
+    expect(sensors.addListener).toHaveBeenCalledTimes(1);
+  });
+
+  it("records epoch-stamped samples and the movement span", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+    collector.start();
+
+    const firstStamp = Date.now();
+    sensors.emit({ x: 0, y: 0, z: 1 });
+    vi.advanceTimersByTime(100);
+    const secondStamp = Date.now();
+    sensors.emit({ x: 0, y: 0, z: 2 });
+
+    expect(collector.devicePositions).toEqual([
+      `${firstStamp},0,0,1`,
+      `${secondStamp},0,0,2`,
+    ]);
+    // |1 − 0.981| = 0.019 and |2 − 0.981| = 1.019 → span 1.
+    expect(collector.deviceMovementDetected).toBeCloseTo(1, 10);
+  });
+
+  it("throttles samples arriving faster than the interval", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+    collector.start();
+
+    sensors.emit({ x: 1, y: 0, z: 0 });
+    vi.advanceTimersByTime(10);
+    sensors.emit({ x: 2, y: 0, z: 0 });
+    vi.advanceTimersByTime(10);
+    sensors.emit({ x: 3, y: 0, z: 0 });
+
+    expect(collector.devicePositions).toHaveLength(1);
+    expect(collector.devicePositions[0]).toContain(",1,0,0");
+  });
+
+  it("stops sampling once the 90 s session cap is exceeded", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+    collector.start();
+
+    sensors.emit({ x: 0, y: 0, z: 1 });
+    vi.advanceTimersByTime(90 * 1000 + 1);
+    sensors.emit({ x: 0, y: 0, z: 9 });
+
+    expect(collector.devicePositions).toHaveLength(1);
+    expect(sensors.remove).toHaveBeenCalledTimes(1);
+    expect(sensors.listenerCount()).toBe(0);
+  });
+
+  it("start() is idempotent while a session is already running", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+
+    collector.start();
+    collector.start();
+
+    expect(sensors.addListener).toHaveBeenCalledTimes(1);
+  });
+
+  it("stop() unsubscribes but preserves the collected data", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+    collector.start();
+    sensors.emit({ x: 0, y: 0, z: 1 });
+
+    collector.stop();
+
+    expect(sensors.remove).toHaveBeenCalledTimes(1);
+    expect(collector.devicePositions).toHaveLength(1);
+    // A second stop on an already-stopped collector is harmless.
+    collector.stop();
+    expect(sensors.remove).toHaveBeenCalledTimes(1);
+  });
+
+  it("a restart clears the previous session's samples", () => {
+    const sensors = makeSensors();
+    loadExpoSensors.mockReturnValue(sensors.module);
+    const collector = new DeviceOrientationCollector();
+    collector.start();
+    sensors.emit({ x: 0, y: 0, z: 1 });
+    collector.stop();
+
+    collector.start();
+    expect(collector.devicePositions).toHaveLength(0);
+    expect(collector.deviceMovementDetected).toBeNull();
+  });
+
+  it("no-ops when expo-sensors is not installed", () => {
+    loadExpoSensors.mockReturnValue(null);
+    const collector = new DeviceOrientationCollector();
+
+    collector.start();
+    collector.stop();
+
+    expect(collector.devicePositions).toHaveLength(0);
+    expect(collector.deviceMovementDetected).toBeNull();
+  });
+});