@chipmobilesdk/rn-camera 0.4.0 → 0.5.0

package/lib/module/native/cameraEngine.js

@@ -0,0 +1,83 @@
+"use strict";
+
+/**
+ * CameraEngine port + default react-native-vision-camera adapter.
+ *
+ * This is the only module that knows a native camera library exists. The
+ * default adapter lazily requires it, mirroring
+ * `packages/rn-auth/src/tokens/secureStore.ts`, so unit tests that inject a
+ * fake never load native code.
+ *
+ * Preview frames never cross this boundary: `capture` returns a file reference
+ * plus metadata and nothing else (PERF-002, FR-021a).
+ *
+ * Targets the VisionCamera v5 API, where devices come from an async
+ * `CameraDeviceFactory` and capture runs through the photo output owned by the
+ * mounted preview surface (see `visionSurface`).
+ */
+
+import { loadVisionCamera } from "./visionCameraPeer.js";
+import { CameraError } from "../diagnostics/errors.js";
+import { createSurfaceRegistry } from "./visionSurface.js";
+
+/** The subset of VisionCamera's `CameraDevice` this adapter reads. */
+
+/**
+ * Default engine. VisionCamera drives the preview through its own React
+ * component, so this adapter owns capability discovery while `CameraPreview`
+ * owns the rendered surface and the photo output that capture runs through.
+ */
+export function createVisionCameraEngine() {
+  // One registry per engine, so two controllers never share a surface.
+  const surfaces = createSurfaceRegistry();
+  // Loaded when the default adapter is created; a missing peer is `cameraUnavailable`.
+  const {
+    VisionCamera
+  } = loadVisionCamera();
+
+  // The factory is created once and reused: it keeps its own device list up to
+  // date, so re-creating it per call would only add latency.
+  let factory = null;
+  async function devices() {
+    factory ??= VisionCamera.createDeviceFactory();
+    return (await factory)?.cameraDevices ?? [];
+  }
+  return {
+    awaitsSurfaceStart: true,
+    attachSurface: surface => surfaces.attach(surface),
+    async start() {
+      // The preview component owns session activation; the engine only needs
+      // to confirm a device exists before the surface mounts.
+      const available = await devices();
+      if (available.length === 0) {
+        throw new CameraError('cameraUnavailable', 'No camera device is available');
+      }
+    },
+    async stop() {
+      // Teardown is driven by unmounting the preview surface.
+    },
+    async capture(request) {
+      const surface = surfaces.current();
+      if (!surface) {
+        throw new CameraError('notReady', 'The default VisionCamera engine captures through the CameraPreview ' + 'surface. Mount <CameraPreview> before calling capture().');
+      }
+      return surface.capture(request);
+    },
+    async setTorch() {
+      // Torch is a preview-surface prop; the controller mirrors the state and
+      // CameraPreview applies it.
+    },
+    async getCapabilities() {
+      const available = await devices();
+      const positions = Array.from(new Set(available.map(device => device.position).filter(p => p === 'front' || p === 'back')));
+      return {
+        availablePositions: positions,
+        hasFlash: available.some(device => device.hasFlash === true),
+        hasTorch: available.some(device => device.hasTorch === true),
+        supportsOrientationChange: true,
+        hasCameraHardware: available.length > 0
+      };
+    }
+  };
+}
+//# sourceMappingURL=cameraEngine.js.map

package/lib/module/native/cameraEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["loadVisionCamera","CameraError","createSurfaceRegistry","createVisionCameraEngine","surfaces","VisionCamera","factory","devices","createDeviceFactory","cameraDevices","awaitsSurfaceStart","attachSurface","surface","attach","start","available","length","stop","capture","request","current","setTorch","getCapabilities","positions","Array","from","Set","map","device","position","filter","p","availablePositions","hasFlash","some","hasTorch","supportsOrientationChange","hasCameraHardware"],"sourceRoot":"../../../src","sources":["native/cameraEngine.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,gBAAgB,QAAQ,uBAAoB;AAQrD,SAASC,WAAW,QAAQ,0BAAuB;AACnD,SAASC,qBAAqB,QAA4B,oBAAiB;;AA4B3E;;AAOA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,wBAAwBA,CAAA,EAAiB;EACxD;EACA,MAAMC,QAAQ,GAAGF,qBAAqB,CAAC,CAAC;EACxC;EACA,MAAM;IAAEG;EAAa,CAAC,GAAGL,gBAAgB,CAItC,CAAC;;EAEJ;EACA;EACA,IAAIM,OAAuE,GAAG,IAAI;EAElF,eAAeC,OAAOA,CAAA,EAAyC;IAC9DD,OAAO,KAAKD,YAAY,CAACG,mBAAmB,CAAC,CAAC;IAC9C,OAAO,CAAC,MAAMF,OAAO,GAAGG,aAAa,IAAI,EAAE;EAC5C;EAEA,OAAO;IACNC,kBAAkB,EAAE,IAAI;IAExBC,aAAa,EAAEC,OAAO,IAAIR,QAAQ,CAACS,MAAM,CAACD,OAAO,CAAC;IAElD,MAAME,KAAKA,CAAA,EAAG;MACb;MACA;MACA,MAAMC,SAAS,GAAG,MAAMR,OAAO,CAAC,CAAC;MACjC,IAAIQ,SAAS,CAACC,MAAM,KAAK,CAAC,EAAE;QAC3B,MAAM,IAAIf,WAAW,CAAC,mBAAmB,EAAE,+BAA+B,CAAC;MAC5E;IACD,CAAC;IAED,MAAMgB,IAAIA,CAAA,EAAG;MACZ;IAAA,CACA;IAED,MAAMC,OAAOA,CAACC,OAAuB,EAAE;MACtC,MAAMP,OAAO,GAAGR,QAAQ,CAACgB,OAAO,CAAC,CAAC;MAClC,IAAI,CAACR,OAAO,EAAE;QACb,MAAM,IAAIX,WAAW,CACpB,UAAU,EACV,qEAAqE,GACpE,0DACF,CAAC;MACF;MACA,OAAOW,OAAO,CAACM,OAAO,CAACC,OAAO,CAAC;IAChC,CAAC;IAED,MAAME,QAAQA,CAAA,EAAG;MAChB;MACA;IAAA,CACA;IAED,MAAMC,eAAeA,CAAA,EAA+B;MACnD,MAAMP,SAAS,GAAG,MAAMR,OAAO,CAAC,CAAC;MACjC,MAAMgB,SAAS,GAAGC,KAAK,CAACC,IAAI,CAC3B,IAAIC,GAAG,CACNX,SAAS,CACPY,GAAG,CAACC,MAAM,IAAIA,MAAM,CAACC,QAAQ,CAAC,CAC9BC,MAAM,CAAEC,CAAC,IAA4BA,CAAC,KAAK,OAAO,IAAIA,CAAC,KAAK,MAAM,CACrE,CACD,CAAC;MACD,OAAO;QACNC,kBAAkB,EAAET,SAAS;QAC7BU,QAAQ,EAAElB,SAAS,CAACmB,IAAI,CAACN,MAAM,IAAIA,MAAM,CAACK,QAAQ,KAAK,IAAI,CAAC;QAC5DE,QAAQ,EAAEpB,SAAS,CAACmB,IAAI,CAACN,MAAM,IAAIA,MAAM,CAACO,QAAQ,KAAK,IAAI,CAAC;QAC5DC,yBAAyB,EAAE,IAAI;QAC/BC,iBAAiB,EAAEtB,SAAS,CAACC,MAAM,GAAG;MACvC,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/native/visionCameraPeer.js

@@ -0,0 +1,24 @@
+"use strict";
+
+/**
+ * react-native-vision-camera, loaded on first use (rn-core's lazy peer). A missing
+ * or unlinked module is a `cameraUnavailable` CameraError, the code the controller
+ * already reports when the camera cannot be reached.
+ */
+import { lazyPeer } from '@chipmobilesdk/rn-core';
+import { CameraError } from "../diagnostics/errors.js";
+
+// The engine and the permission port each describe the slice they use.
+
+const visionCamera = lazyPeer('react-native-vision-camera', () => {
+  // Inside `try`, so Metro bundles an app that leaves this optional peer out.
+  try {
+    return require('react-native-vision-camera');
+  } catch (cause) {
+    throw cause;
+  }
+});
+export function loadVisionCamera() {
+  return visionCamera.require(peer => new CameraError('cameraUnavailable', `${peer} is not installed or its native module is not linked`));
+}
+//# sourceMappingURL=visionCameraPeer.js.map

package/lib/module/native/visionCameraPeer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lazyPeer","CameraError","visionCamera","require","cause","loadVisionCamera","peer"],"sourceRoot":"../../../src","sources":["native/visionCameraPeer.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA,SAASA,QAAQ,QAAQ,wBAAwB;AAEjD,SAASC,WAAW,QAAQ,0BAAuB;;AAEnD;;AAGA,MAAMC,YAAY,GAAGF,QAAQ,CAAC,4BAA4B,EAAE,MAAM;EACjE;EACA,IAAI;IACH,OAAOG,OAAO,CAAC,4BAA4B,CAAC;EAC7C,CAAC,CAAC,OAAOC,KAAK,EAAE;IACf,MAAMA,KAAK;EACZ;AACD,CAAC,CAAC;AAEF,OAAO,SAASC,gBAAgBA,CAAA,EAAS;EACxC,OAAOH,YAAY,CAACC,OAAO,CAC1BG,IAAI,IACH,IAAIL,WAAW,CACd,mBAAmB,EACnB,GAAGK,IAAI,sDACR,CACF,CAAC;AACF","ignoreList":[]}

package/lib/module/native/visionSurface.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * The port between a mounted preview surface and an engine.
+ *
+ * VisionCamera v5 owns capture through the session the `<Camera>` view
+ * configures, so the photo output only exists while a surface is mounted. The
+ * engine is created before any surface exists, so the surface attaches itself
+ * to the engine and the engine reads it back at capture time.
+ *
+ * The registry belongs to an engine instance, not to the module. A module-level
+ * slot meant two controllers — two screens in a stack — shared one, so a
+ * capture could run through the other screen's surface (CAM-20).
+ */
+
+/** What the mounted preview actually is, once the device and format are known. */
+
+/** What a surface reports back about its own session. */
+
+export function createSurfaceRegistry() {
+  let active = null;
+  return {
+    attach(surface) {
+      active = surface;
+      return () => {
+        if (active === surface) {
+          active = null;
+        }
+      };
+    },
+    current: () => active
+  };
+}
+//# sourceMappingURL=visionSurface.js.map

package/lib/module/native/visionSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createSurfaceRegistry","active","attach","surface","current"],"sourceRoot":"../../../src","sources":["native/visionSurface.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;;AAeA;;AAcA,OAAO,SAASA,qBAAqBA,CAAA,EAAoB;EACxD,IAAIC,MAA4B,GAAG,IAAI;EACvC,OAAO;IACNC,MAAMA,CAACC,OAAO,EAAE;MACfF,MAAM,GAAGE,OAAO;MAChB,OAAO,MAAM;QACZ,IAAIF,MAAM,KAAKE,OAAO,EAAE;UACvBF,MAAM,GAAG,IAAI;QACd;MACD,CAAC;IACF,CAAC;IACDG,OAAO,EAAEA,CAAA,KAAMH;EAChB,CAAC;AACF","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/permissions/permissionPort.js

@@ -0,0 +1,101 @@
+"use strict";
+
+/**
+ * PermissionPort + default react-native-vision-camera adapter (FR-004..FR-008).
+ *
+ * `getStatus` never prompts and never opens a session (FR-005); only `request`
+ * may prompt, and it refuses to re-prompt once the OS reports a permanent
+ * denial (FR-006). The default adapter lazily requires the native module so
+ * unit tests that inject a fake never load native code — same approach as
+ * `packages/rn-auth/src/tokens/secureStore.ts`.
+ *
+ * The adapter targets the VisionCamera v5 API: permissions live on the
+ * `VisionCamera` hybrid object, not on the `Camera` component (which carries no
+ * statics since v5).
+ */
+
+import { loadVisionCamera } from "../native/visionCameraPeer.js";
+import { appLifecycle, createListenerSet } from '@chipmobilesdk/rn-core';
+/**
+ * VisionCamera `PermissionStatus` mapped onto our seven-state contract.
+ *
+ * `not-determined` also covers "denied once, but the app may ask again" on
+ * Android, which is exactly the state where re-prompting is allowed, so it maps
+ * to `undetermined` rather than `denied`.
+ */
+function mapStatus(raw) {
+  switch (raw) {
+    case 'authorized':
+      return 'granted';
+    case 'not-determined':
+      return 'undetermined';
+    case 'denied':
+      return 'deniedPermanently';
+    case 'restricted':
+      return 'deniedPermanently';
+    default:
+      return 'unsupported';
+  }
+}
+export function createVisionCameraPermissions() {
+  // Loaded when the default adapter is created; a missing peer is `cameraUnavailable`.
+  const {
+    VisionCamera
+  } = loadVisionCamera();
+  const listeners = createListenerSet();
+  let last = null;
+  let stopWatchingLifecycle = null;
+  function read() {
+    try {
+      return mapStatus(VisionCamera.cameraPermissionStatus);
+    } catch {
+      // The native module is unreachable; report it rather than pretending
+      // the permission is merely undetermined.
+      return 'unsupported';
+    }
+  }
+  function emit(state) {
+    if (state !== last) {
+      last = state;
+      listeners.notify(state);
+    }
+    return state;
+  }
+  return {
+    async getStatus() {
+      return emit(read());
+    },
+    async request() {
+      // Never re-prompt after a permanent denial (FR-006); report the
+      // settings-required state instead so the app can route the user.
+      const current = read();
+      if (current === 'deniedPermanently') {
+        return emit(current);
+      }
+      await VisionCamera.requestCameraPermission();
+      // Re-read rather than trusting the boolean result: the status carries
+      // the richer distinction the contract needs.
+      return emit(read());
+    },
+    subscribe(listener) {
+      const remove = listeners.add(listener);
+      // Grants and revocations made in system Settings send the app through
+      // background/foreground, so re-reading on foreground is what surfaces
+      // them (FR-007). Attached only while somebody is listening.
+      // rn-core's shared lifecycle port, so this adds no native subscription of its own.
+      stopWatchingLifecycle ??= appLifecycle().subscribe(state => {
+        if (state === 'active') {
+          emit(read());
+        }
+      });
+      return () => {
+        remove();
+        if (listeners.size === 0 && stopWatchingLifecycle) {
+          stopWatchingLifecycle();
+          stopWatchingLifecycle = null;
+        }
+      };
+    }
+  };
+}
+//# sourceMappingURL=permissionPort.js.map

package/lib/module/permissions/permissionPort.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["loadVisionCamera","appLifecycle","createListenerSet","mapStatus","raw","createVisionCameraPermissions","VisionCamera","listeners","last","stopWatchingLifecycle","read","cameraPermissionStatus","emit","state","notify","getStatus","request","current","requestCameraPermission","subscribe","listener","remove","add","size"],"sourceRoot":"../../../src","sources":["permissions/permissionPort.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,gBAAgB,QAAQ,+BAA4B;AAC7D,SAASC,YAAY,EAAEC,iBAAiB,QAAQ,wBAAwB;AAaxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,SAASA,CAACC,GAAW,EAAyB;EACtD,QAAQA,GAAG;IACV,KAAK,YAAY;MAChB,OAAO,SAAS;IACjB,KAAK,gBAAgB;MACpB,OAAO,cAAc;IACtB,KAAK,QAAQ;MACZ,OAAO,mBAAmB;IAC3B,KAAK,YAAY;MAChB,OAAO,mBAAmB;IAC3B;MACC,OAAO,aAAa;EACtB;AACD;AAEA,OAAO,SAASC,6BAA6BA,CAAA,EAAmB;EAC/D;EACA,MAAM;IAAEC;EAAa,CAAC,GAAGN,gBAAgB,CAKtC,CAAC;EACJ,MAAMO,SAAS,GAAGL,iBAAiB,CAA0B,CAAC;EAC9D,IAAIM,IAAkC,GAAG,IAAI;EAC7C,IAAIC,qBAA0C,GAAG,IAAI;EAErD,SAASC,IAAIA,CAAA,EAA0B;IACtC,IAAI;MACH,OAAOP,SAAS,CAACG,YAAY,CAACK,sBAAsB,CAAC;IACtD,CAAC,CAAC,MAAM;MACP;MACA;MACA,OAAO,aAAa;IACrB;EACD;EAEA,SAASC,IAAIA,CAACC,KAA4B,EAAyB;IAClE,IAAIA,KAAK,KAAKL,IAAI,EAAE;MACnBA,IAAI,GAAGK,KAAK;MACZN,SAAS,CAACO,MAAM,CAACD,KAAK,CAAC;IACxB;IACA,OAAOA,KAAK;EACb;EAEA,OAAO;IACN,MAAME,SAASA,CAAA,EAAG;MACjB,OAAOH,IAAI,CAACF,IAAI,CAAC,CAAC,CAAC;IACpB,CAAC;IAED,MAAMM,OAAOA,CAAA,EAAG;MACf;MACA;MACA,MAAMC,OAAO,GAAGP,IAAI,CAAC,CAAC;MACtB,IAAIO,OAAO,KAAK,mBAAmB,EAAE;QACpC,OAAOL,IAAI,CAACK,OAAO,CAAC;MACrB;MACA,MAAMX,YAAY,CAACY,uBAAuB,CAAC,CAAC;MAC5C;MACA;MACA,OAAON,IAAI,CAACF,IAAI,CAAC,CAAC,CAAC;IACpB,CAAC;IAEDS,SAASA,CAACC,QAAQ,EAAE;MACnB,MAAMC,MAAM,GAAGd,SAAS,CAACe,GAAG,CAACF,QAAQ,CAAC;MACtC;MACA;MACA;MACA;MACAX,qBAAqB,KAAKR,YAAY,CAAC,CAAC,CAACkB,SAAS,CAACN,KAAK,IAAI;QAC3D,IAAIA,KAAK,KAAK,QAAQ,EAAE;UACvBD,IAAI,CAACF,IAAI,CAAC,CAAC,CAAC;QACb;MACD,CAAC,CAAC;MACF,OAAO,MAAM;QACZW,MAAM,CAAC,CAAC;QACR,IAAId,SAAS,CAACgB,IAAI,KAAK,CAAC,IAAId,qBAAqB,EAAE;UAClDA,qBAAqB,CAAC,CAAC;UACvBA,qBAAqB,GAAG,IAAI;QAC7B;MACD,CAAC;IACF;EACD,CAAC;AACF","ignoreList":[]}

package/lib/module/react/CameraPreview.js

@@ -0,0 +1,130 @@
+"use strict";
+
+/**
+ * Camera preview surface (FR-009..FR-013, UX-001, UX-003).
+ *
+ * Renders the camera feed and nothing else: no shutter button, no permission
+ * copy, no error text, and no theme dependency. Consuming apps draw their own
+ * controls and overlays through `children`, positioned with the geometry
+ * reported by `onGeometryChange`.
+ */
+
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { View } from 'react-native';
+import { useCameraState } from "./hooks.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** The feed module failed to load; distinct from `null`, which means not requested. */
+const FEED_UNAVAILABLE = 'unavailable';
+
+/**
+ * Nominal capture dimensions, until the mounted surface reports its own.
+ *
+ * Geometry built on these was landscape on a portrait phone, so every mapped
+ * rectangle was wrong on a real device (CAM-10). `onGeometryChange` now fires
+ * again with the real numbers as soon as the preview reports them, and apps
+ * that map coordinates should wait for `state.surface` rather than the first
+ * geometry.
+ */
+const DEFAULT_IMAGE_WIDTH = 1920;
+const DEFAULT_IMAGE_HEIGHT = 1080;
+export const CameraPreview = ({
+  controller,
+  resizeMode = 'cover',
+  style,
+  onGeometryChange,
+  accessibilityLabel,
+  accessibilityRole,
+  children
+}) => {
+  const [layout, setLayout] = useState(null);
+  // Subscribed, not read once: a plain `controller.state` read only refreshed
+  // when the parent happened to re-render, so the feed could stay unmounted
+  // after the session became active (or stay mounted after it stopped).
+  const state = useCameraState(controller);
+
+  // Tell the controller a surface exists so foregrounding can restart the
+  // session, and clear it on unmount so the camera is released (FR-016). Both
+  // calls are no-ops on an idle or disposed controller.
+  useEffect(() => {
+    controller.setSurfaceMounted(true);
+    return () => {
+      controller.setSurfaceMounted(false);
+      controller.stop().catch(() => undefined);
+    };
+  }, [controller]);
+  const attachSurface = useCallback(surface => controller.attachSurface(surface), [controller]);
+  const onSurfaceStarted = useCallback(info => controller.reportSurfaceStarted(info), [controller]);
+  const onSurfaceFailed = useCallback(code => controller.reportSurfaceFailed(code), [controller]);
+  const onLayout = useCallback(event => {
+    const {
+      width,
+      height
+    } = event.nativeEvent.layout;
+    setLayout({
+      width,
+      height
+    });
+  }, []);
+  const geometry = useMemo(() => {
+    if (!layout || layout.width === 0 || layout.height === 0) {
+      return null;
+    }
+    const surface = state.surface;
+    return {
+      imageWidth: surface && surface.imageWidth > 0 ? surface.imageWidth : DEFAULT_IMAGE_WIDTH,
+      imageHeight: surface && surface.imageHeight > 0 ? surface.imageHeight : DEFAULT_IMAGE_HEIGHT,
+      previewWidth: layout.width,
+      previewHeight: layout.height,
+      resizeMode,
+      orientation: surface?.orientation ?? 0,
+      isMirrored: (surface?.cameraPosition ?? state.cameraPosition) === 'front'
+    };
+  }, [layout, resizeMode, state.cameraPosition, state.surface]);
+  useEffect(() => {
+    if (geometry && onGeometryChange) {
+      onGeometryChange(geometry);
+    }
+  }, [geometry, onGeometryChange]);
+
+  // Mounted while the session is coming up, running, or paused: the surface is
+  // what makes it come up at all, and unmounting it on a pause meant rebuilding
+  // the device, the session and the photo output on every resume (CAM-08, CAM-09).
+  const feedRequested = state.permission === 'granted' && (state.session === 'starting' || state.session === 'active' || state.session === 'paused');
+
+  // Lazy require so importing this package never pulls in the native module
+  // for consumers that only use the pure utilities or the test adapter.
+  const Feed = useMemo(() => {
+    if (!feedRequested) {
+      return null;
+    }
+    try {
+      return require('./VisionCameraFeed').VisionCameraFeed;
+    } catch {
+      // Reported, not swallowed (CAM-21): the session fails with
+      // `cameraUnavailable` instead of showing a black preview.
+      return FEED_UNAVAILABLE;
+    }
+  }, [feedRequested]);
+  useEffect(() => {
+    if (Feed === FEED_UNAVAILABLE) {
+      controller.reportSurfaceUnavailable();
+    }
+  }, [Feed, controller]);
+  return /*#__PURE__*/_jsxs(View, {
+    style: style,
+    onLayout: onLayout,
+    accessibilityLabel: accessibilityLabel,
+    accessibilityRole: accessibilityRole,
+    testID: "rn-camera-preview",
+    children: [Feed && Feed !== FEED_UNAVAILABLE ? /*#__PURE__*/_jsx(Feed, {
+      cameraPosition: state.cameraPosition,
+      resizeMode: resizeMode,
+      torchEnabled: state.torchEnabled,
+      isActive: state.session !== 'paused',
+      attachSurface: attachSurface,
+      onStarted: onSurfaceStarted,
+      onFailed: onSurfaceFailed
+    }) : null, children]
+  });
+};
+//# sourceMappingURL=CameraPreview.js.map

package/lib/module/react/CameraPreview.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useCallback","useEffect","useMemo","useState","View","useCameraState","jsx","_jsx","jsxs","_jsxs","FEED_UNAVAILABLE","DEFAULT_IMAGE_WIDTH","DEFAULT_IMAGE_HEIGHT","CameraPreview","controller","resizeMode","style","onGeometryChange","accessibilityLabel","accessibilityRole","children","layout","setLayout","state","setSurfaceMounted","stop","catch","undefined","attachSurface","surface","onSurfaceStarted","info","reportSurfaceStarted","onSurfaceFailed","code","reportSurfaceFailed","onLayout","event","width","height","nativeEvent","geometry","imageWidth","imageHeight","previewWidth","previewHeight","orientation","isMirrored","cameraPosition","feedRequested","permission","session","Feed","require","VisionCameraFeed","reportSurfaceUnavailable","testID","torchEnabled","isActive","onStarted","onFailed"],"sourceRoot":"../../../src","sources":["react/CameraPreview.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/react/VisionCameraFeed.js

@@ -0,0 +1,190 @@
+"use strict";
+
+/**
+ * The live VisionCamera surface rendered inside `CameraPreview`.
+ *
+ * Split into its own module so `CameraPreview` can require it lazily: consumers
+ * that only use the pure utilities or the test adapter never load the native
+ * module, while the hooks this component needs (`useCameraDevice`,
+ * `usePhotoOutput`) can still be called normally.
+ *
+ * It also owns capture. In VisionCamera v5 the photo output belongs to the
+ * session the `<Camera>` view configures, so the output only exists while this
+ * surface is mounted; it is published to the engine through `visionSurface`.
+ */
+
+import React, { useEffect, useMemo, useState } from 'react';
+import { StyleSheet } from 'react-native';
+import { Camera, useCameraDevice, usePhotoOutput } from 'react-native-vision-camera';
+import { known, unavailable } from "../config/types.js";
+import { DEFAULT_QUALITY } from "../core/captureController.js";
+import { CameraError, isCameraError } from "../diagnostics/errors.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const styles = StyleSheet.create({
+  feed: {
+    flex: 1
+  }
+});
+const MIME_TYPES = {
+  jpeg: 'image/jpeg',
+  heic: 'image/heic',
+  dng: 'image/x-adobe-dng',
+  tiff: 'image/tiff'
+};
+
+/** VisionCamera reports orientation as a compass value; the contract wants degrees. */
+const ORIENTATION_DEGREES = {
+  up: 0,
+  right: 90,
+  down: 180,
+  left: 270
+};
+function orientationOf(orientation) {
+  const degrees = ORIENTATION_DEGREES[orientation];
+  return degrees === undefined ? unavailable() : known(degrees);
+}
+function toFileUri(path) {
+  return path.startsWith('file://') ? path : `file://${path}`;
+}
+function toFilePath(uri) {
+  return uri.startsWith('file://') ? uri.slice('file://'.length) : uri;
+}
+
+/**
+ * What a native session error means, from the code VisionCamera reports
+ * (CAM-08). Anything unrecognised is an interruption: the session is gone, and
+ * the app may try again.
+ */
+function nativeSessionCode(error) {
+  const code = String(error?.code ?? '').toLowerCase();
+  if (code.includes('permission')) return 'permissionDenied';
+  if (code.includes('in-use') || code.includes('already-in-use')) return 'cameraInUse';
+  if (code.includes('unavailable') || code.includes('no-device')) return 'cameraUnavailable';
+  if (code.includes('restricted') || code.includes('blocked')) return 'cameraBlocked';
+  return 'interrupted';
+}
+
+/** Native failures carry no code and may name a file path; never surface them raw. */
+function asCameraError(error, code) {
+  return isCameraError(error) ? error : new CameraError(code);
+}
+async function capturePhoto(photoOutput, request, /** The device actually mounted; the request cannot ask for another one. */
+cameraPosition) {
+  let photo;
+  try {
+    photo = await photoOutput.capturePhoto({
+      flashMode: request.flashMode ?? 'off'
+    }, {});
+  } catch (error) {
+    throw asCameraError(error, 'captureFailed');
+  }
+  try {
+    // A destination makes the artifact app-owned, so it is written straight
+    // there; otherwise it goes to a temporary file (FR-026a).
+    let path;
+    if (request.destination) {
+      try {
+        await photo.saveToFileAsync(toFilePath(request.destination));
+      } catch {
+        throw new CameraError('storageFailure', 'Could not write the capture to the requested destination');
+      }
+      path = request.destination;
+    } else {
+      // VisionCamera's own temporary directory. The controller moves the file
+      // into the artifact store, when it has one, so cleanup can reach it.
+      try {
+        path = await photo.saveToTemporaryFileAsync();
+      } catch (error) {
+        throw asCameraError(error, 'storageFailure');
+      }
+    }
+    return {
+      uri: toFileUri(path),
+      mimeType: MIME_TYPES[photo.containerFormat] ?? 'application/octet-stream',
+      width: photo.width,
+      height: photo.height,
+      timestamp: Date.now(),
+      // The camera that took it, not the one the request named (CAM-06).
+      cameraPosition,
+      // Ownership is decided by the controller from the original request;
+      // this value is overwritten there and is only a safe default.
+      ownership: request.destination ? 'appOwned' : 'packageTemporary',
+      // Quality is fixed on the photo output, not per capture, and nothing here
+      // resizes. Report what was actually applied rather than echo the hints.
+      effectiveQuality: DEFAULT_QUALITY,
+      effectiveMaxDimension: unavailable(),
+      // The native layer reports neither back after a save, and guessing them
+      // would be worse than saying so (FR-022).
+      fileSize: unavailable(),
+      orientation: orientationOf(photo.orientation)
+    };
+  } finally {
+    // Large native buffers must not wait for the JS GC.
+    photo.dispose();
+  }
+}
+
+/** What the device actually is, for coordinate mapping (CAM-10). */
+function surfaceInfoOf(device, fallback) {
+  const format = device?.formats?.[0];
+  return {
+    imageWidth: format?.photoWidth ?? format?.videoWidth ?? 0,
+    imageHeight: format?.photoHeight ?? format?.videoHeight ?? 0,
+    orientation: 0,
+    cameraPosition: device?.position === 'front' || device?.position === 'back' ? device.position : fallback
+  };
+}
+
+/** The slice of VisionCamera's `CameraDeviceFormat` the geometry needs. */
+
+export const VisionCameraFeed = ({
+  cameraPosition,
+  resizeMode,
+  torchEnabled,
+  isActive,
+  attachSurface,
+  onStarted,
+  onFailed
+}) => {
+  const device = useCameraDevice(cameraPosition);
+  const photoOutput = usePhotoOutput({
+    quality: DEFAULT_QUALITY
+  });
+  const surface = useMemo(() => ({
+    capture: request => capturePhoto(photoOutput, request, cameraPosition)
+  }), [photoOutput, cameraPosition]);
+  useEffect(() => attachSurface(surface), [attachSurface, surface]);
+
+  // VisionCamera applies `torchMode` on mount, before the camera is active, and
+  // leaves the native "Camera is not active" rejection unhandled — one red
+  // error per session start. Leave the prop unset until the torch is first
+  // turned on; after that 'off' must be sent explicitly to turn it back off.
+  const [torchTouched, setTorchTouched] = useState(false);
+  if (torchEnabled && !torchTouched) {
+    setTorchTouched(true);
+  }
+  const torchMode = torchEnabled ? 'on' : torchTouched ? 'off' : undefined;
+  if (!device) {
+    return null;
+  }
+  return /*#__PURE__*/_jsx(Camera, {
+    style: styles.feed,
+    device: device,
+    outputs: [photoOutput]
+    // Mounted through `paused` and `starting`: unmounting the view tore the
+    // session down and rebuilding it cost the first-frame budget (CAM-09).
+    ,
+    isActive: isActive
+    // The session is active when frames arrive, not when it was asked for.
+    ,
+    onStarted: () => onStarted(surfaceInfoOf(device, cameraPosition)),
+    onError: error => onFailed(nativeSessionCode(error)),
+    resizeMode: resizeMode
+    // Left unset until the app first touches the torch, so the device's own default stands.
+    ,
+    ...(torchMode === undefined ? {} : {
+      torchMode
+    })
+  });
+};
+//# sourceMappingURL=VisionCameraFeed.js.map

package/lib/module/react/VisionCameraFeed.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useEffect","useMemo","useState","StyleSheet","Camera","useCameraDevice","usePhotoOutput","known","unavailable","DEFAULT_QUALITY","CameraError","isCameraError","jsx","_jsx","styles","create","feed","flex","MIME_TYPES","jpeg","heic","dng","tiff","ORIENTATION_DEGREES","up","right","down","left","orientationOf","orientation","degrees","undefined","toFileUri","path","startsWith","toFilePath","uri","slice","length","nativeSessionCode","error","code","String","toLowerCase","includes","asCameraError","capturePhoto","photoOutput","request","cameraPosition","photo","flashMode","destination","saveToFileAsync","saveToTemporaryFileAsync","mimeType","containerFormat","width","height","timestamp","Date","now","ownership","effectiveQuality","effectiveMaxDimension","fileSize","dispose","surfaceInfoOf","device","fallback","format","formats","imageWidth","photoWidth","videoWidth","imageHeight","photoHeight","videoHeight","position","VisionCameraFeed","resizeMode","torchEnabled","isActive","attachSurface","onStarted","onFailed","quality","surface","capture","torchTouched","setTorchTouched","torchMode","style","outputs","onError"],"sourceRoot":"../../../src","sources":["react/VisionCameraFeed.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/react/hooks.js

@@ -0,0 +1,45 @@
+"use strict";
+
+/**
+ * React bindings for the camera controller.
+ *
+ * `useCameraController` owns the controller lifetime and disposes it on
+ * unmount, which is what guarantees the camera is released when a screen goes
+ * away (FR-016).
+ */
+
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { createCameraController } from "../core/controller.js";
+export function useCameraController(options) {
+  // Options usually arrive as a fresh object literal each render; capturing
+  // them in a ref keeps the controller stable for the component's lifetime.
+  const optionsRef = useRef(options);
+  // Construction has no side effects (the controller subscribes on first use),
+  // so a controller React builds and discards here costs nothing.
+  const [controller, setController] = useState(() => createCameraController(optionsRef.current));
+  const disposedRef = useRef(new WeakSet());
+  useEffect(() => {
+    // StrictMode, and React's planned offscreen reuse, run the cleanup and then
+    // this effect again on the same component. Disposal is final, so the old
+    // controller cannot be revived; replace it. Before this, the screen kept a
+    // dead controller after the remount and the camera never started.
+    const disposed = disposedRef.current;
+    if (disposed.has(controller)) {
+      setController(createCameraController(optionsRef.current));
+      return undefined;
+    }
+    return () => {
+      disposed.add(controller);
+      controller.dispose().catch(() => undefined);
+    };
+  }, [controller]);
+  return controller;
+}
+export function useCameraState(controller) {
+  // `subscribe` is a property of the controller object, so it is stable for the
+  // controller's lifetime, which is what useSyncExternalStore requires. The
+  // store read is tear-free, unlike the previous useState copy, which could
+  // miss a change made between render and effect.
+  return useSyncExternalStore(controller.subscribe, () => controller.state, () => controller.state);
+}
+//# sourceMappingURL=hooks.js.map