@fixback/expo 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fixback
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# @fixback/expo
+
+The [Fixback](https://github.com/wemuda/fixback) capture SDK for **Expo / React
+Native apps**: shake the device to open a feedback composer, and every report
+ships with trace Evidence — console output, network metadata, screen changes —
+plus an optional screenshot. Uncaught JS errors report themselves
+(`source: auto`), exactly like the web SDK.
+
+## Install
+
+```bash
+npm install @fixback/expo
+npx expo install expo-sensors react-native-view-shot @react-native-async-storage/async-storage
+```
+
+The three Expo-ecosystem packages are peer dependencies (they carry the native
+modules for the accelerometer, screenshots, and id persistence). All of them
+work in Expo Go.
+
+## Quick start
+
+```tsx
+import { FixbackProvider } from "@fixback/expo";
+
+export default function App() {
+  return (
+    <FixbackProvider
+      options={{
+        key: "pk_…",                      // the Project's publishable key
+        origin: "https://com.acme.myapp", // an origin allowlisted on the Project
+      }}
+    >
+      <RootNavigator />
+    </FixbackProvider>
+  );
+}
+```
+
+Shake the device → the composer opens → write a comment, review (or remove)
+the screenshot, send. There is no Kind to pick — Fixback's analysis classifies
+the Issue (bug / improvement / idea) server-side.
+
+### The `origin` option
+
+Fixback's ingest matches every request's `Origin` header against the Project's
+allowed origins. Browsers send that header automatically; a native app does
+not, so the SDK sends the `origin` you configure — canonicalized the same way
+the dashboard stores allowlist entries (lowercased host, default ports elided,
+path dropped), so a pasted mixed-case bundle id still matches. Add the same
+value to your Project's **allowed origins** in the Fixback dashboard.
+Convention: your app's reverse-DNS id as an https host
+(`https://com.acme.myapp`), or simply your product's existing web origin.
+Until the origin is allowlisted the SDK stays dormant (a dev-build warning
+explains why).
+
+## Triggers
+
+- **Shake** (default): tuned to a deliberate shake — threshold, peak count,
+  window, and cooldown are configurable via `options.shake`;
+  `shake: { enabled: false }` turns the gesture off.
+- **Programmatic**: `useFixback().present()` in a component, or the
+  module-level `Fixback.present()` anywhere.
+
+> **Development builds:** the Expo dev menu also opens on shake, so both
+> appear. Use `present()` while developing; production builds have no dev
+> menu.
+
+## Screens in reports
+
+React Native has no URL, so tell Fixback where the Reporter is:
+
+```tsx
+const { trackScreen } = useFixback();
+// e.g. in your navigation container's state-change handler:
+trackScreen(routeName);
+```
+
+Each change records a `navigation` trace crumb, and the active screen names
+the report's URL (`<origin>/<screen>`).
+
+## Options
+
+| Option | Default | What it does |
+| --- | --- | --- |
+| `key` | — | The Project's publishable key (required). |
+| `origin` | — | The origin sent on every request (required in practice — see above). |
+| `apiUrl` | `https://api.fixback.dev` | Self-hosted Fixback API base. |
+| `signedIdentity` | — | A server-minted identity JWT (`internal` tier). |
+| `reporterName` / `reporterEmail` | — | Display-only reporter fields. |
+| `capture` | server config | `{ console?, network? }` per-stream trace toggles. |
+| `autoCapture` | `true` | Automatic uncaught-error reports. |
+| `screenshots` | `true` | Capture a screenshot when the composer opens. |
+| `beforeSend` | — | Reshape or drop (`null`) any report before transport. |
+| `scrub` | `true` | The built-in URL/PII scrubbers. |
+| `beforeBreadcrumb` | — | Filter/edit trace entries at the source. |
+| `shake` | on | `{ enabled?, thresholdG?, minPeaks?, windowMs?, minGapMs?, cooldownMs?, sampleIntervalMs? }`. |
+
+## Privacy
+
+The same client-side scrubbing as the web SDK: URLs lose query strings and
+path PII, console/error text loses emails, bearer tokens, and long digit runs,
+network crumbs never carry bodies or headers. One difference is deliberate:
+mobile screenshots are **not** auto-masked — so a screenshot only ever ships
+from the composer, where the Reporter sees exactly what will be sent and can
+remove it. **Automatic error reports never attach a screenshot.** A screenshot
+the Reporter removes (or that has been delivered) is deleted from the app's
+cache, and `screenshots: false` disables capture entirely. `beforeSend`
+remains the programmatic choke point.
+
+## What's not here (yet)
+
+Invite redemption (deep links), element annotation/drawing, session replay,
+unhandled-promise-rejection and native-crash capture. See the repo's
+`docs/specs/0004-expo-reporter-sdk.md` and ADR-0021 for the full contract.
+
+## License
+
+MIT

package/dist/FeedbackModal.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The feedback **composer** — the mobile counterpart of the web overlay's
+ * report panel (spec 0004 §C), styled in the Signal language from the vendored
+ * token slice. Opens on shake (or `present()`), collects Kind + comment, shows
+ * the exact screenshot that will ship (removable — the mobile privacy stance,
+ * ADR-0021), and submits through the client the provider hands in.
+ *
+ * Deliberately thin: every decision beyond local UI state lives in
+ * `client.ts`, which is where the behaviour is unit-tested.
+ */
+import type { ComposerDraft } from "./client";
+import type { ScreenshotFile, SubmitResult } from "./submit";
+/** What the provider wires into the composer. */
+export interface FeedbackModalProps {
+    readonly visible: boolean;
+    /** The screenshot captured as the composer opened, if any. */
+    readonly screenshot: ScreenshotFile | null;
+    readonly onDismiss: () => void;
+    readonly onSubmit: (draft: ComposerDraft) => Promise<SubmitResult>;
+    /** Release a screenshot the Reporter removed or abandoned (spec 0004 §C). */
+    readonly onDiscardScreenshot?: (screenshot: ScreenshotFile) => void;
+}
+export declare function FeedbackModal({ visible, screenshot, onDismiss, onSubmit, onDiscardScreenshot, }: FeedbackModalProps): import("react").JSX.Element;

package/dist/FeedbackModal.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The feedback **composer** — the mobile counterpart of the web overlay's
+ * report panel (spec 0004 §C), styled in the Signal language from the vendored
+ * token slice. Opens on shake (or `present()`), collects Kind + comment, shows
+ * the exact screenshot that will ship (removable — the mobile privacy stance,
+ * ADR-0021), and submits through the client the provider hands in.
+ *
+ * Deliberately thin: every decision beyond local UI state lives in
+ * `client.ts`, which is where the behaviour is unit-tested.
+ */
+import { useEffect, useRef, useState } from "react";
+import { ActivityIndicator, Image, KeyboardAvoidingView, Modal, Platform, Pressable, StyleSheet, Text, TextInput, View, } from "react-native";
+import { signal } from "./tokens";
+const MONO_FONT = Platform.select({ ios: "Menlo", default: "monospace" });
+/** How long the "Sent" confirmation lingers before the composer closes. */
+const SENT_DISMISS_MS = 900;
+export function FeedbackModal({ visible, screenshot, onDismiss, onSubmit, onDiscardScreenshot, }) {
+    const [comment, setComment] = useState("");
+    const [includeScreenshot, setIncludeScreenshot] = useState(true);
+    const [phase, setPhase] = useState("compose");
+    const dismissTimer = useRef(null);
+    // A fresh open starts a fresh draft.
+    useEffect(() => {
+        if (visible) {
+            setComment("");
+            setIncludeScreenshot(true);
+            setPhase("compose");
+        }
+        return () => {
+            if (dismissTimer.current) {
+                clearTimeout(dismissTimer.current);
+                dismissTimer.current = null;
+            }
+        };
+    }, [visible]);
+    const busy = phase === "sending" || phase === "sent";
+    async function send() {
+        if (busy)
+            return;
+        setPhase("sending");
+        // No Kind on the draft — analysis classifies the Issue server-side (ADR-0023).
+        const result = await onSubmit({
+            comment,
+            screenshot: includeScreenshot ? screenshot : null,
+        });
+        if (result.ok) {
+            setPhase("sent");
+            dismissTimer.current = setTimeout(onDismiss, SENT_DISMISS_MS);
+        }
+        else {
+            setPhase("failed");
+        }
+    }
+    /**
+     * Dismissal is never blocked — a stalled submission must not trap the
+     * Reporter in the composer (the in-flight request continues harmlessly).
+     * A draft's unsent screenshot is released on the way out; while sending or
+     * sent, the transport owns the file (released by the client on delivery).
+     */
+    function dismiss() {
+        if (screenshot &&
+            includeScreenshot &&
+            (phase === "compose" || phase === "failed")) {
+            onDiscardScreenshot?.(screenshot);
+        }
+        onDismiss();
+    }
+    function removeScreenshot() {
+        if (screenshot)
+            onDiscardScreenshot?.(screenshot);
+        setIncludeScreenshot(false);
+    }
+    return (_jsx(Modal, { visible: visible, transparent: true, animationType: "slide", onRequestClose: dismiss, children: _jsxs(View, { style: styles.backdrop, children: [_jsx(Pressable, { style: styles.backdropTouch, accessibilityLabel: "Dismiss feedback", onPress: dismiss }), _jsx(KeyboardAvoidingView, { behavior: Platform.OS === "ios" ? "padding" : undefined, children: _jsxs(View, { style: styles.sheet, children: [_jsx(Text, { style: styles.overline, children: "FIXBACK \u00B7 REPORT" }), _jsx(Text, { style: styles.title, children: "Send feedback" }), _jsx(TextInput, { style: styles.comment, multiline: true, editable: !busy, placeholder: "What happened? What did you expect?", placeholderTextColor: signal.textGhost, value: comment, onChangeText: setComment, accessibilityLabel: "Feedback comment" }), screenshot && includeScreenshot ? (_jsxs(View, { style: styles.screenshotRow, children: [_jsx(Image, { source: { uri: screenshot.uri }, style: styles.screenshotThumb, resizeMode: "cover", accessibilityLabel: "Screenshot preview" }), _jsxs(View, { style: styles.screenshotMeta, children: [_jsx(Text, { style: styles.screenshotLabel, children: "Screenshot attached" }), _jsx(Text, { style: styles.screenshotHint, children: "Exactly this image is sent \u2014 remove it if it shows something private." })] }), _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Remove screenshot", disabled: busy, onPress: removeScreenshot, children: _jsx(Text, { style: styles.removeLabel, children: "Remove" }) })] })) : null, phase === "failed" ? (_jsx(Text, { style: styles.failed, children: "Couldn't send \u2014 check your connection and try again." })) : null, phase === "sent" ? (_jsx(Text, { style: styles.sent, children: "Sent \u2014 thank you." })) : null, _jsxs(View, { style: styles.footer, children: [_jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Cancel", onPress: dismiss, style: styles.cancelButton, children: _jsx(Text, { style: styles.cancelLabel, children: "Cancel" }) }), _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Send feedback", disabled: busy, onPress: () => void send(), style: [styles.sendButton, busy && styles.sendButtonBusy], children: phase === "sending" ? (_jsx(ActivityIndicator, { size: "small", color: signal.onEmphasis })) : (_jsx(Text, { style: styles.sendLabel, children: "Send" })) })] })] }) })] }) }));
+}
+const styles = StyleSheet.create({
+    backdrop: {
+        flex: 1,
+        justifyContent: "flex-end",
+        backgroundColor: signal.scrim,
+    },
+    backdropTouch: {
+        flex: 1,
+    },
+    sheet: {
+        backgroundColor: signal.surface,
+        borderTopLeftRadius: 14,
+        borderTopRightRadius: 14,
+        borderColor: signal.border,
+        borderWidth: 1,
+        paddingHorizontal: 16,
+        paddingTop: 14,
+        paddingBottom: 24,
+    },
+    overline: {
+        fontFamily: MONO_FONT,
+        fontSize: 10,
+        letterSpacing: 1.2,
+        color: signal.textFaint,
+        marginBottom: 2,
+    },
+    title: {
+        fontSize: 15,
+        fontWeight: "600",
+        color: signal.text,
+        marginBottom: 12,
+    },
+    comment: {
+        minHeight: 96,
+        borderWidth: 1,
+        borderColor: signal.borderControl,
+        borderRadius: 8,
+        backgroundColor: signal.canvas,
+        color: signal.text,
+        fontSize: 13,
+        padding: 10,
+        textAlignVertical: "top",
+        marginBottom: 12,
+    },
+    screenshotRow: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: 10,
+        borderWidth: 1,
+        borderColor: signal.border,
+        borderRadius: 8,
+        backgroundColor: signal.sunken,
+        padding: 8,
+        marginBottom: 12,
+    },
+    screenshotThumb: {
+        width: 40,
+        height: 72,
+        borderRadius: 4,
+        borderWidth: 1,
+        borderColor: signal.borderStrong,
+        backgroundColor: signal.surface,
+    },
+    screenshotMeta: {
+        flex: 1,
+    },
+    screenshotLabel: {
+        fontSize: 12,
+        fontWeight: "600",
+        color: signal.textPanel,
+    },
+    screenshotHint: {
+        fontSize: 11,
+        color: signal.textFaint,
+        marginTop: 2,
+    },
+    removeLabel: {
+        fontSize: 12,
+        fontWeight: "600",
+        color: signal.danger,
+        padding: 4,
+    },
+    failed: {
+        fontSize: 12,
+        color: signal.danger,
+        marginBottom: 10,
+    },
+    sent: {
+        fontSize: 12,
+        color: signal.success,
+        marginBottom: 10,
+    },
+    footer: {
+        flexDirection: "row",
+        justifyContent: "flex-end",
+        gap: 8,
+    },
+    cancelButton: {
+        borderWidth: 1,
+        borderColor: signal.borderControl,
+        borderRadius: 8,
+        paddingHorizontal: 14,
+        paddingVertical: 9,
+        backgroundColor: signal.surface,
+    },
+    cancelLabel: {
+        fontSize: 13,
+        color: signal.textMuted,
+    },
+    sendButton: {
+        borderRadius: 8,
+        paddingHorizontal: 18,
+        paddingVertical: 9,
+        backgroundColor: signal.accent,
+        minWidth: 72,
+        alignItems: "center",
+    },
+    sendButtonBusy: {
+        opacity: 0.8,
+    },
+    sendLabel: {
+        fontSize: 13,
+        fontWeight: "600",
+        color: signal.onEmphasis,
+    },
+});

package/dist/FixbackProvider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `<FixbackProvider>` — the one component a host app mounts (spec 0004 §A).
+ *
+ * A thin React shell over the headless client: it starts/stops the client with
+ * the component lifecycle, arms the shake gesture while the client is ready,
+ * listens for composer-open requests, and renders the composer modal inside
+ * the app's own tree. `useFixback()` (and the module-level `Fixback` object,
+ * for non-React call sites) expose `present` / `dismiss` / `trackScreen`.
+ */
+import { type ReactNode } from "react";
+import { type FixbackOptions } from "./client";
+/** What `useFixback()` returns. */
+export interface FixbackHandle {
+    /** Open the feedback composer (a no-op while the SDK is dormant). */
+    present: () => void;
+    /** Close the composer if it is open. */
+    dismiss: () => void;
+    /** Record a screen change for the trace and the report `url` (spec 0004 §D). */
+    trackScreen: (name: string) => void;
+}
+/**
+ * The provider's handle, or an inert one outside a provider — the SDK never
+ * throws into the host app, hooks included.
+ */
+export declare function useFixback(): FixbackHandle;
+/**
+ * The module-level escape hatch (spec 0004 §B): `Fixback.present()` from any
+ * plain function — a settings row, a dev menu item, an error boundary.
+ */
+export declare const Fixback: FixbackHandle;
+export interface FixbackProviderProps {
+    readonly options: FixbackOptions;
+    readonly children?: ReactNode;
+}
+export declare function FixbackProvider({ options, children }: FixbackProviderProps): import("react").JSX.Element;

package/dist/FixbackProvider.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * `<FixbackProvider>` — the one component a host app mounts (spec 0004 §A).
+ *
+ * A thin React shell over the headless client: it starts/stops the client with
+ * the component lifecycle, arms the shake gesture while the client is ready,
+ * listens for composer-open requests, and renders the composer modal inside
+ * the app's own tree. `useFixback()` (and the module-level `Fixback` object,
+ * for non-React call sites) expose `present` / `dismiss` / `trackScreen`.
+ */
+import { createContext, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { createNativeAdapters, startShakeListener } from "./adapters";
+import { createFixbackClient, } from "./client";
+import { FeedbackModal } from "./FeedbackModal";
+import { createShakeDetector } from "./shake";
+const NOOP_HANDLE = {
+    present: () => { },
+    dismiss: () => { },
+    trackScreen: () => { },
+};
+const FixbackContext = createContext(null);
+/**
+ * The provider's handle, or an inert one outside a provider — the SDK never
+ * throws into the host app, hooks included.
+ */
+export function useFixback() {
+    return useContext(FixbackContext) ?? NOOP_HANDLE;
+}
+/** The most recently mounted provider's handle, for non-React call sites. */
+let activeHandle = null;
+/**
+ * The module-level escape hatch (spec 0004 §B): `Fixback.present()` from any
+ * plain function — a settings row, a dev menu item, an error boundary.
+ */
+export const Fixback = {
+    present: () => activeHandle?.present(),
+    dismiss: () => activeHandle?.dismiss(),
+    trackScreen: (name) => activeHandle?.trackScreen(name),
+};
+export function FixbackProvider({ options, children }) {
+    // The client is created once per mounted provider; option changes after
+    // mount are deliberately ignored (remount to reconfigure), matching the web
+    // SDK's one-shot `init`.
+    const [client] = useState(() => createFixbackClient(options, createNativeAdapters()));
+    const [status, setStatus] = useState(client.getStatus());
+    const [composer, setComposer] = useState(null);
+    const composerOpenRef = useRef(false);
+    useEffect(() => {
+        const unsubscribe = client.onStatus(setStatus);
+        void client.start();
+        return () => {
+            unsubscribe();
+            client.destroy();
+        };
+    }, [client]);
+    useEffect(() => {
+        return client.onPresent((context) => {
+            if (composerOpenRef.current) {
+                // The composer is already open — this capture is never shown, so
+                // release its tmpfile instead of leaking it.
+                client.discardScreenshot(context.screenshot);
+                return;
+            }
+            composerOpenRef.current = true;
+            setComposer(context);
+        });
+    }, [client]);
+    // The shake gesture is armed only while the client can actually submit, so
+    // a dormant SDK never keeps the accelerometer running.
+    useEffect(() => {
+        if (status !== "ready")
+            return;
+        const config = client.shakeConfig();
+        if (!config.enabled)
+            return;
+        const detector = createShakeDetector({
+            ...config,
+            onShake: () => {
+                if (!composerOpenRef.current)
+                    void client.present();
+            },
+        });
+        const subscription = startShakeListener((sample) => detector.sample(sample), config.sampleIntervalMs);
+        return () => subscription.remove();
+    }, [client, status]);
+    const handle = useMemo(() => ({
+        present: () => void client.present(),
+        dismiss: () => {
+            composerOpenRef.current = false;
+            setComposer(null);
+        },
+        trackScreen: (name) => client.trackScreen(name),
+    }), [client]);
+    useEffect(() => {
+        activeHandle = handle;
+        return () => {
+            if (activeHandle === handle)
+                activeHandle = null;
+        };
+    }, [handle]);
+    return (_jsxs(FixbackContext.Provider, { value: handle, children: [children, _jsx(FeedbackModal, { visible: composer !== null, screenshot: composer?.screenshot ?? null, onDismiss: handle.dismiss, onSubmit: (draft) => client.submit(draft), onDiscardScreenshot: (shot) => client.discardScreenshot(shot) })] }));
+}

package/dist/adapters.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The real React Native / Expo adapters behind the client's injectable seams
+ * (`FixbackAdapters`), plus the accelerometer wiring for the shake gesture.
+ *
+ * This is the only module (besides the UI) that imports platform packages, so
+ * everything else stays unit-testable in plain node. Every adapter is
+ * defensive: a missing native module or a capture failure degrades that one
+ * capability instead of throwing into the host app.
+ */
+import type { FixbackAdapters } from "./client";
+import type { ShakeSample } from "./shake";
+/** Build the real adapter set `FixbackProvider` hands to the client. */
+export declare function createNativeAdapters(): FixbackAdapters;
+/** How often the accelerometer reports while the gesture is armed. */
+export declare const SHAKE_UPDATE_INTERVAL_MS = 80;
+/** A removable shake-listener handle. */
+export interface ShakeSubscription {
+    remove(): void;
+}
+/**
+ * Feed accelerometer samples to a listener (the shake detector). Availability
+ * is checked first (a simulator has no accelerometer); an unavailable or
+ * missing sensor resolves to an inert subscription. `remove` also cancels a
+ * subscription still waiting on the availability check.
+ */
+export declare function startShakeListener(onSample: (sample: ShakeSample) => void, updateIntervalMs?: number): ShakeSubscription;

package/dist/adapters.js

@@ -0,0 +1,143 @@
+/**
+ * The real React Native / Expo adapters behind the client's injectable seams
+ * (`FixbackAdapters`), plus the accelerometer wiring for the shake gesture.
+ *
+ * This is the only module (besides the UI) that imports platform packages, so
+ * everything else stays unit-testable in plain node. Every adapter is
+ * defensive: a missing native module or a capture failure degrades that one
+ * capability instead of throwing into the host app.
+ */
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { Accelerometer } from "expo-sensors";
+import { AppState, Dimensions, Platform } from "react-native";
+import { captureScreen, releaseCapture } from "react-native-view-shot";
+import { globalConsole, globalXhr } from "./breadcrumbs";
+import { globalErrorUtils } from "./error-capture";
+/** Read the device environment: window size + `<os> <version>`. */
+function readEnvironment() {
+    try {
+        const { width, height } = Dimensions.get("window");
+        return {
+            windowWidth: width,
+            windowHeight: height,
+            os: `${Platform.OS} ${String(Platform.Version)}`,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Capture the current screen as a png tmpfile — best-effort: any failure (no
+ * native module, capture denied) resolves to `null` and the report simply
+ * ships without a screenshot (spec 0004 §C).
+ */
+async function captureScreenshot() {
+    try {
+        const uri = await captureScreen({
+            format: "png",
+            quality: 0.9,
+            result: "tmpfile",
+        });
+        if (typeof uri !== "string" || uri.length === 0)
+            return null;
+        return { uri, name: "screenshot.png", type: "image/png" };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Delete a captured screenshot's tmpfile. Best-effort and repeat-safe — an
+ * image the Reporter removed as private must not linger in the app's cache
+ * (spec 0004 §C).
+ */
+function releaseScreenshot(uri) {
+    try {
+        releaseCapture(uri);
+    }
+    catch {
+        /* release is best-effort */
+    }
+}
+/** A development-only warning; production builds stay silent. */
+function devWarn(message) {
+    const g = globalThis;
+    if (g.__DEV__ === true) {
+        try {
+            g.console?.warn?.(message);
+        }
+        catch {
+            /* never throw into the host app */
+        }
+    }
+}
+/** Build the real adapter set `FixbackProvider` hands to the client. */
+export function createNativeAdapters() {
+    return {
+        storage: AsyncStorage,
+        environment: readEnvironment,
+        captureScreenshot,
+        releaseScreenshot,
+        consoleObj: globalConsole() ?? null,
+        xhr: globalXhr() ?? null,
+        errorUtils: globalErrorUtils() ?? null,
+        appState: AppState,
+        warn: devWarn,
+    };
+}
+/** How often the accelerometer reports while the gesture is armed. */
+export const SHAKE_UPDATE_INTERVAL_MS = 80;
+/**
+ * Feed accelerometer samples to a listener (the shake detector). Availability
+ * is checked first (a simulator has no accelerometer); an unavailable or
+ * missing sensor resolves to an inert subscription. `remove` also cancels a
+ * subscription still waiting on the availability check.
+ */
+export function startShakeListener(onSample, updateIntervalMs = SHAKE_UPDATE_INTERVAL_MS) {
+    let removed = false;
+    let subscription = null;
+    void (async () => {
+        try {
+            const available = await Accelerometer.isAvailableAsync();
+            if (!available || removed)
+                return;
+            // The update interval is global to the sensor, shared with the host
+            // app's own listeners — only claim it when nobody else is listening, so
+            // arming the gesture never degrades a host feature's sample rate.
+            const listenerCount = typeof Accelerometer.getListenerCount === "function"
+                ? Accelerometer.getListenerCount()
+                : 0;
+            if (listenerCount === 0) {
+                Accelerometer.setUpdateInterval(updateIntervalMs);
+            }
+            subscription = Accelerometer.addListener(({ x, y, z }) => {
+                try {
+                    onSample({ x, y, z, at: Date.now() });
+                }
+                catch {
+                    /* the detector must never throw into the sensor callback */
+                }
+            });
+            if (removed) {
+                subscription.remove();
+                subscription = null;
+            }
+        }
+        catch {
+            // No sensor module — the gesture simply stays unarmed.
+        }
+    })();
+    return {
+        remove() {
+            removed = true;
+            try {
+                subscription?.remove();
+            }
+            catch {
+                /* teardown is best-effort */
+            }
+            subscription = null;
+        },
+    };
+}