@symbiote-native/local-auth 0.0.1 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+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

@@ -1,40 +1,268 @@
 # @symbiote-native/local-auth
 
-Planned port of [`expo-local-authentication`](https://docs.expo.dev/versions/latest/sdk/local-authentication/)
-for [SymbioteNative](../../README.md) — FaceID/TouchID on iOS, the Fingerprint/Biometric API on
-Android, reachable from every adapter (React, Vue, Angular), not just React.
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-local-authentication`](https://github.com/expo/expo/tree/main/packages/expo-local-authentication)
+— FaceID/TouchID on iOS, the Fingerprint/Biometric API on Android — usable from **every**
+adapter, React, Vue, and Angular, not just React. Unlike this repo's other Expo wrapper
+([`@symbiote-native/sensors`](../sensors), an `EventEmitter` + live-subscription surface),
+every function here is a one-shot async call with no per-instance state, so there is no hook/
+composable/service to wrap — the React, Vue, and Angular entry points are plain re-exports of
+the same `core`.
 
-**Status: skeleton only.** This package is not implemented yet — no source, no native wiring, not
-functional. Published early to reserve the npm name. Built the same way as
-[`@symbiote-native/sensors`](../sensors), a prior `expo-modules-core`-based wrapper (see the
-`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
-depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
-`core/` rather than imported, and how autolinking picks up the native module).
+## Install
 
-## Planned API surface
+```bash
+npm install @symbiote-native/local-auth
+```
+
+`expo-local-authentication` and `expo-modules-core` come along as regular dependencies, pinned
+to exact versions — never install either yourself, and never add the `expo` meta-package to
+your project (it bundles its own Metro/Babel pipeline, which conflicts with this project's own).
+
+## Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-local-authentication`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other
+`expo-modules-core` package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics live in the `symbiote-expo-native-module` project skill. Reference
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt`.
+
+Two platform permission strings ship with the native module itself — nothing to reimplement,
+just add the strings your app's own Info.plist/manifest needs:
+
+- iOS — `NSFaceIDUsageDescription` in `Info.plist` (without it, iOS silently falls back to the
+  device passcode instead of prompting FaceID).
+- Android — `USE_BIOMETRIC` in `AndroidManifest.xml`.
+
+## Shape
+
+```
+src/core/     hasHardwareAsync / isEnrolledAsync / getEnrolledLevelAsync /
+              supportedAuthenticationTypesAsync / authenticateAsync / cancelAuthenticate, plus
+              AuthenticationType, SecurityLevel, and the option/result/error types.
+              native-module.ts resolves the native module via expo-modules-core's
+              requireNativeModule.
+src/react/    @symbiote-native/local-auth/react   — export * from '../core'
+src/vue/      @symbiote-native/local-auth/vue     — export * from '../core'
+src/angular/  @symbiote-native/local-auth/angular — export * from '../core'
+```
+
+No per-adapter lifecycle wrapper exists because there's nothing to subscribe to or clean up —
+each adapter entry is a single-file re-export.
+
+## Use it
+
+```tsx
+// React
+import { useEffect, useState } from 'react';
+import { Platform, Pressable, Text, View } from '@symbiote-native/react';
+import {
+  authenticateAsync,
+  cancelAuthenticate,
+  hasHardwareAsync,
+  isEnrolledAsync,
+} from '@symbiote-native/local-auth/react';
+import type { ILocalAuthenticationResult } from '@symbiote-native/local-auth/react';
+
+function LocalAuthScreen() {
+  const [hasHardware, setHasHardware] = useState(false);
+  const [isEnrolled, setIsEnrolled] = useState(false);
+  const [authResult, setAuthResult] = useState<ILocalAuthenticationResult | null>(null);
+
+  useEffect(() => {
+    hasHardwareAsync().then(setHasHardware);
+    isEnrolledAsync().then(setIsEnrolled);
+  }, []);
+
+  const handleAuthenticate = () => {
+    authenticateAsync({ promptMessage: 'Confirm it is you' }).then(setAuthResult);
+  };
+
+  return (
+    <View>
+      <Text>{hasHardware && isEnrolled ? 'Ready to authenticate' : 'No biometrics enrolled'}</Text>
+      <Pressable onPress={handleAuthenticate}>
+        <Text>Authenticate</Text>
+      </Pressable>
+      {Platform.OS === 'android' && (
+        <Pressable onPress={() => cancelAuthenticate()}>
+          <Text>Cancel</Text>
+        </Pressable>
+      )}
+      {authResult && <Text>{authResult.success ? 'Success' : `Failed: ${authResult.error}`}</Text>}
+    </View>
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { Platform, Pressable, Text, View } from '@symbiote-native/vue';
+import {
+  authenticateAsync,
+  cancelAuthenticate,
+  hasHardwareAsync,
+  isEnrolledAsync,
+} from '@symbiote-native/local-auth/vue';
+import type { ILocalAuthenticationResult } from '@symbiote-native/local-auth/vue';
+
+const hasHardware = ref(false);
+const isEnrolled = ref(false);
+const authResult = ref<ILocalAuthenticationResult | null>(null);
+
+onMounted(() => {
+  void hasHardwareAsync().then(value => (hasHardware.value = value));
+  void isEnrolledAsync().then(value => (isEnrolled.value = value));
+});
+
+function handleAuthenticate(): void {
+  void authenticateAsync({ promptMessage: 'Confirm it is you' }).then(value => {
+    authResult.value = value;
+  });
+}
+</script>
+
+<template>
+  <View>
+    <Text>{{ hasHardware && isEnrolled ? 'Ready to authenticate' : 'No biometrics enrolled' }}</Text>
+    <Pressable @press="handleAuthenticate">
+      <Text>Authenticate</Text>
+    </Pressable>
+    <Pressable v-if="Platform.OS === 'android'" @press="cancelAuthenticate">
+      <Text>Cancel</Text>
+    </Pressable>
+    <Text v-if="authResult">{{ authResult.success ? 'Success' : `Failed: ${authResult.error}` }}</Text>
+  </View>
+</template>
+```
+
+```ts
+// Angular
+import { Component, signal } from '@angular/core';
+import { Platform, Pressable, Text, View } from '@symbiote-native/angular';
+import {
+  authenticateAsync,
+  cancelAuthenticate,
+  hasHardwareAsync,
+  isEnrolledAsync,
+} from '@symbiote-native/local-auth/angular';
+import type { ILocalAuthenticationResult } from '@symbiote-native/local-auth/angular';
+
+@Component({
+  standalone: true,
+  imports: [Pressable, Text, View],
+  template: `
+    <View>
+      <Text>{{ hasHardware() && isEnrolled() ? 'Ready to authenticate' : 'No biometrics enrolled' }}</Text>
+      <Pressable (press)="handleAuthenticate()">
+        <Text>Authenticate</Text>
+      </Pressable>
+      @if (Platform.OS === 'android') {
+        <Pressable (press)="handleCancel()">
+          <Text>Cancel</Text>
+        </Pressable>
+      }
+      @if (authResult(); as result) {
+        <Text>{{ result.success ? 'Success' : 'Failed: ' + result.error }}</Text>
+      }
+    </View>
+  `,
+})
+export class LocalAuthScreen {
+  readonly Platform = Platform;
+  readonly hasHardware = signal(false);
+  readonly isEnrolled = signal(false);
+  readonly authResult = signal<ILocalAuthenticationResult | null>(null);
+
+  constructor() {
+    hasHardwareAsync().then(value => this.hasHardware.set(value));
+    isEnrolledAsync().then(value => this.isEnrolled.set(value));
+  }
+
+  handleAuthenticate(): void {
+    authenticateAsync({ promptMessage: 'Confirm it is you' }).then(value => this.authResult.set(value));
+  }
+
+  handleCancel(): void {
+    cancelAuthenticate();
+  }
+}
+```
+
+There's no per-instance service to `inject()` in the Angular case — every function is a plain
+free function off the core package, called straight from the constructor. All three examples are
+trimmed from the real canary demo screens (`examples/expo-react/screens/LocalAuthScreen.tsx`,
+`examples/expo-vue-sfc/screens/LocalAuthScreen.vue`, `examples/expo-vue-tsx/screens/LocalAuthScreen.tsx`,
+`examples/expo-angular/src/screens/LocalAuthScreen.ts`), which also cover
+`getEnrolledLevelAsync`/`supportedAuthenticationTypesAsync` and render a capabilities card.
+
+## API
 
 Free functions, no event stream, no per-instance state — upstream ships a handful of async
-functions and two enums, not a subscribable sensor:
+functions and two enums, not a subscribable sensor, so the React/Vue/Angular entry points above
+are plain re-exports of `core` with nothing adapter-specific to add.
 
 ```ts
 hasHardwareAsync(): Promise<boolean>
+supportedAuthenticationTypesAsync(): Promise<AuthenticationType[]>
 isEnrolledAsync(): Promise<boolean>
 getEnrolledLevelAsync(): Promise<SecurityLevel>
-supportedAuthenticationTypesAsync(): Promise<AuthenticationType[]>
-authenticateAsync(options?: LocalAuthenticationOptions): Promise<LocalAuthenticationResult>
+authenticateAsync(options?: ILocalAuthenticationOptions): Promise<ILocalAuthenticationResult>
 cancelAuthenticate(): Promise<void> // Android only
 ```
 
-Plus `AuthenticationType`, `SecurityLevel`, `LocalAuthenticationOptions`,
-`LocalAuthenticationResult`, `LocalAuthenticationError`, `BiometricsSecurityLevel` — ported
-verbatim from upstream's `LocalAuthentication.types.ts`, since they're plain data with no native or
-React dependency.
+Plus `AuthenticationType`, `SecurityLevel`, `ILocalAuthenticationOptions`,
+`ILocalAuthenticationResult`, `ILocalAuthenticationError`, `IBiometricsSecurityLevel` — ported
+from upstream's `LocalAuthentication.types.ts`, renamed with this repo's `I`-prefix convention
+for exported types (`ts-js-best-practices`).
+
+```ts
+import { authenticateAsync, hasHardwareAsync } from '@symbiote-native/local-auth';
+// or the framework-scoped entry points — identical surface, re-exported verbatim:
+import { authenticateAsync } from '@symbiote-native/local-auth/react';
+import { authenticateAsync } from '@symbiote-native/local-auth/vue';
+import { authenticateAsync } from '@symbiote-native/local-auth/angular';
+```
+
+## Notes
+
+- **`not_enrolled` on Android almost always means the device's own lock screen has no PIN,
+  pattern, or password set.** A real symptom on a fresh emulator or factory-reset device:
+  `authenticateAsync` resolves `{ success: false, error: 'not_enrolled', warning:
+  'KeyguardManager#isDeviceSecure() returned false' }`. This is **not** a missing app
+  permission — the manifest permission this package needs is an ordinary build-time merge with
+  no runtime prompt, so there's nothing for your app to request. The fix lives on the device:
+  Settings → Security → Screen lock → set a PIN/pattern/password, then optionally enroll a
+  fingerprint (Extended Controls → Fingerprint on an emulator) to exercise the biometric path
+  too, not just the passcode fallback.
+- **iOS silently falls back to the device passcode without `NSFaceIDUsageDescription`.** Apple
+  requires apps using FaceID to declare why (`Info.plist`); skip it and `authenticateAsync`
+  still resolves, just via the passcode prompt instead of FaceID.
+
+## Test it
 
-## Not yet done
+No Fabric/Descriptor angle at all — every function here is a pure async-function surface, never
+a view or per-instance state. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/local-authentication.test.ts`,
+`src/core/types.test.ts`, `vitest`) — no `installFabric()`, no ViewConfig. Native rendering itself
+is verified on-device (see the parent [README](../../README.md) for the project's testing model).
 
-- `src/core` — ported types/enums + the six functions over `requireNativeModule('ExpoLocalAuthentication')`
-- `react`/`vue`/`angular` entry points — thin re-exports, no adapter-specific state needed
-- Native wiring in an example app (`use_expo_modules!`, Android Gradle autolinking,
-  `NSFaceIDUsageDescription` in `Info.plist`, `USE_BIOMETRIC`/`USE_FINGERPRINT` on Android)
-- Tests, following upstream's own fake-native-module pattern (no Fabric/Descriptor angle — this
-  wraps no native view)
+Native autolinking wiring is done in the four Expo canary apps
+(`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`, `examples/expo-angular`)
+— iOS Podfile/`AppDelegate.swift` + `NSFaceIDUsageDescription`, Android Gradle/
+`MainApplication.kt` + `USE_BIOMETRIC`, all four confirmed present. The one remaining gap: this
+package isn't yet demoed in the plain, non-Expo `examples/react`/`vue-sfc`/`vue-tsx`/`angular`
+canaries, since an `expo-modules-core` package needs the `expo-modules-autolinking` wiring only
+the `examples/expo-*` apps have set up so far.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/local-auth/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core/index.js';

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { hasHardwareAsync, supportedAuthenticationTypesAsync, isEnrolledAsync, getEnrolledLevelAsync, authenticateAsync, cancelAuthenticate, } from './local-authentication';
+export { AuthenticationType, SecurityLevel, type IBiometricsSecurityLevel, type ILocalAuthenticationOptions, type ILocalAuthenticationResult, type ILocalAuthenticationError, } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { hasHardwareAsync, supportedAuthenticationTypesAsync, isEnrolledAsync, getEnrolledLevelAsync, authenticateAsync, cancelAuthenticate, } from './local-authentication.js';
+export { AuthenticationType, SecurityLevel, } from './types.js';

package/build/core/local-authentication.d.ts

@@ -0,0 +1,33 @@
+import type { AuthenticationType, ILocalAuthenticationOptions, ILocalAuthenticationResult, SecurityLevel } from './types';
+/**
+ * Determine whether a face or fingerprint scanner is available on the device.
+ */
+export declare function hasHardwareAsync(): Promise<boolean>;
+/**
+ * Determine what kinds of authentications are available on the device. Devices can support
+ * multiple authentication methods — e.g. `[FINGERPRINT, FACIAL_RECOGNITION]` means the device
+ * supports both. Returns an empty array if none are supported.
+ */
+export declare function supportedAuthenticationTypesAsync(): Promise<AuthenticationType[]>;
+/**
+ * Determine whether the device has saved fingerprints or facial data to use for authentication.
+ */
+export declare function isEnrolledAsync(): Promise<boolean>;
+/**
+ * Determine what kind of authentication is enrolled on the device.
+ * > On Android devices prior to M, `SECRET` can be returned if only the SIM lock has been
+ * enrolled, which is not the method `authenticateAsync` prompts.
+ */
+export declare function getEnrolledLevelAsync(): Promise<SecurityLevel>;
+/**
+ * Attempts to authenticate via Fingerprint/TouchID (or FaceID if available on the device).
+ * > Apple requires apps which use FaceID to provide a description of why they use this API
+ * (`NSFaceIDUsageDescription` in `Info.plist`). Without it, the module authenticates using the
+ * device passcode instead.
+ */
+export declare function authenticateAsync(options?: ILocalAuthenticationOptions): Promise<ILocalAuthenticationResult>;
+/**
+ * Cancels the authentication flow.
+ * @platform android
+ */
+export declare function cancelAuthenticate(): Promise<void>;

package/build/core/local-authentication.js

@@ -0,0 +1,75 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import invariant from 'invariant';
+import { expoLocalAuthentication } from './native-module.js';
+const NATIVE_MODULE_NAME = 'expo-local-authentication';
+const DEFAULT_PROMPT_MESSAGE = 'Authenticate';
+const DEFAULT_CANCEL_LABEL = 'Cancel';
+/**
+ * Determine whether a face or fingerprint scanner is available on the device.
+ */
+export async function hasHardwareAsync() {
+    if (!expoLocalAuthentication.hasHardwareAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'hasHardwareAsync');
+    }
+    return expoLocalAuthentication.hasHardwareAsync();
+}
+/**
+ * Determine what kinds of authentications are available on the device. Devices can support
+ * multiple authentication methods — e.g. `[FINGERPRINT, FACIAL_RECOGNITION]` means the device
+ * supports both. Returns an empty array if none are supported.
+ */
+export async function supportedAuthenticationTypesAsync() {
+    if (!expoLocalAuthentication.supportedAuthenticationTypesAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'supportedAuthenticationTypesAsync');
+    }
+    return expoLocalAuthentication.supportedAuthenticationTypesAsync();
+}
+/**
+ * Determine whether the device has saved fingerprints or facial data to use for authentication.
+ */
+export async function isEnrolledAsync() {
+    if (!expoLocalAuthentication.isEnrolledAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isEnrolledAsync');
+    }
+    return expoLocalAuthentication.isEnrolledAsync();
+}
+/**
+ * Determine what kind of authentication is enrolled on the device.
+ * > On Android devices prior to M, `SECRET` can be returned if only the SIM lock has been
+ * enrolled, which is not the method `authenticateAsync` prompts.
+ */
+export async function getEnrolledLevelAsync() {
+    if (!expoLocalAuthentication.getEnrolledLevelAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getEnrolledLevelAsync');
+    }
+    return expoLocalAuthentication.getEnrolledLevelAsync();
+}
+/**
+ * Attempts to authenticate via Fingerprint/TouchID (or FaceID if available on the device).
+ * > Apple requires apps which use FaceID to provide a description of why they use this API
+ * (`NSFaceIDUsageDescription` in `Info.plist`). Without it, the module authenticates using the
+ * device passcode instead.
+ */
+export async function authenticateAsync(options = {}) {
+    if (!expoLocalAuthentication.authenticateAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'authenticateAsync');
+    }
+    if (options.promptMessage !== undefined) {
+        invariant(typeof options.promptMessage === 'string' && options.promptMessage.length > 0, 'LocalAuthentication.authenticateAsync: `options.promptMessage` must be a non-empty string.');
+    }
+    return expoLocalAuthentication.authenticateAsync({
+        ...options,
+        promptMessage: options.promptMessage || DEFAULT_PROMPT_MESSAGE,
+        cancelLabel: options.cancelLabel || DEFAULT_CANCEL_LABEL,
+    });
+}
+/**
+ * Cancels the authentication flow.
+ * @platform android
+ */
+export async function cancelAuthenticate() {
+    if (!expoLocalAuthentication.cancelAuthenticate) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'cancelAuthenticate');
+    }
+    await expoLocalAuthentication.cancelAuthenticate();
+}

package/build/core/native-module.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationType, ILocalAuthenticationOptions, ILocalAuthenticationResult, SecurityLevel } from './types';
+export type INativeLocalAuthenticationModule = {
+    hasHardwareAsync?(): Promise<boolean>;
+    supportedAuthenticationTypesAsync?(): Promise<AuthenticationType[]>;
+    isEnrolledAsync?(): Promise<boolean>;
+    getEnrolledLevelAsync?(): Promise<SecurityLevel>;
+    authenticateAsync?(options: ILocalAuthenticationOptions & {
+        promptMessage: string;
+        cancelLabel: string;
+    }): Promise<ILocalAuthenticationResult>;
+    cancelAuthenticate?(): Promise<void>;
+};
+export declare const expoLocalAuthentication: INativeLocalAuthenticationModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_LOCAL_AUTHENTICATION_MODULE_NAME = 'ExpoLocalAuthentication';
+export const expoLocalAuthentication = requireNativeModule(EXPO_LOCAL_AUTHENTICATION_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,83 @@
+export type ILocalAuthenticationResult = {
+    success: true;
+} | {
+    success: false;
+    error: ILocalAuthenticationError;
+    warning?: string;
+};
+export declare enum AuthenticationType {
+    /** Indicates fingerprint support. */
+    FINGERPRINT = 1,
+    /** Indicates facial recognition support. */
+    FACIAL_RECOGNITION = 2,
+    /**
+     * Indicates iris recognition support.
+     * @platform android
+     */
+    IRIS = 3
+}
+export declare enum SecurityLevel {
+    /** Indicates no enrolled authentication. */
+    NONE = 0,
+    /** Indicates non-biometric authentication (e.g. PIN, Pattern). */
+    SECRET = 1,
+    /**
+     * Indicates biometric authentication.
+     * @deprecated please use `BIOMETRIC_STRONG` or `BIOMETRIC_WEAK` instead.
+     * @hidden
+     */
+    BIOMETRIC,
+    /**
+     * Indicates weak biometric authentication. For example, a 2D image-based face unlock. There
+     * are currently no weak biometric authentication options on iOS.
+     */
+    BIOMETRIC_WEAK = 2,
+    /** Indicates strong biometric authentication. For example, a fingerprint scan or 3D face unlock. */
+    BIOMETRIC_STRONG = 3
+}
+/**
+ * Security level of the biometric authentication to allow.
+ * @platform android
+ */
+export type IBiometricsSecurityLevel = 'weak' | 'strong';
+export type ILocalAuthenticationOptions = {
+    /** A message that is shown alongside the TouchID or FaceID prompt. */
+    promptMessage?: string;
+    /**
+     * A subtitle displayed below the prompt message in the authentication prompt.
+     * @platform android
+     */
+    promptSubtitle?: string;
+    /**
+     * A description displayed in the middle of the authentication prompt.
+     * @platform android
+     */
+    promptDescription?: string;
+    /** Allows customizing the default `Cancel` label shown. */
+    cancelLabel?: string;
+    /**
+     * After several failed attempts, the system falls back to the device passcode. This setting
+     * allows you to disable this option and instead handle the fallback yourself. Defaults to `false`.
+     */
+    disableDeviceFallback?: boolean;
+    /**
+     * Sets a hint to the system for whether to require user confirmation after authentication.
+     * Defaults to `true`.
+     * @platform android
+     */
+    requireConfirmation?: boolean;
+    /**
+     * Sets the security class of biometric authentication to allow. `strong` allows only Android
+     * Class 3 biometrics; `weak` allows both Class 3 and Class 2.
+     * @platform android
+     * @default 'weak'
+     */
+    biometricsSecurityLevel?: IBiometricsSecurityLevel;
+    /**
+     * Allows customizing the default `Use Passcode` label shown after several failed attempts. An
+     * empty string disables the button.
+     * @platform ios
+     */
+    fallbackLabel?: string;
+};
+export type ILocalAuthenticationError = 'not_enrolled' | 'user_cancel' | 'app_cancel' | 'not_available' | 'lockout' | 'no_space' | 'timeout' | 'unable_to_process' | 'unknown' | 'system_cancel' | 'user_fallback' | 'invalid_context' | 'passcode_not_set' | 'authentication_failed';

package/build/core/types.js

@@ -0,0 +1,55 @@
+// expo-local-authentication's own types file imports Platform from the `expo` meta-package. We
+// never depend on `expo` itself (it drags in a second Metro/babel pipeline — see the
+// symbiote-expo-native-module skill) so this pulls Platform straight from expo-modules-core,
+// which is where `expo` re-exports it from — same source device-sensor.ts (packages/sensors)
+// uses for the same reason.
+import { Platform } from 'expo-modules-core';
+export var AuthenticationType;
+(function (AuthenticationType) {
+    /** Indicates fingerprint support. */
+    AuthenticationType[AuthenticationType["FINGERPRINT"] = 1] = "FINGERPRINT";
+    /** Indicates facial recognition support. */
+    AuthenticationType[AuthenticationType["FACIAL_RECOGNITION"] = 2] = "FACIAL_RECOGNITION";
+    /**
+     * Indicates iris recognition support.
+     * @platform android
+     */
+    AuthenticationType[AuthenticationType["IRIS"] = 3] = "IRIS";
+})(AuthenticationType || (AuthenticationType = {}));
+export var SecurityLevel;
+(function (SecurityLevel) {
+    /** Indicates no enrolled authentication. */
+    SecurityLevel[SecurityLevel["NONE"] = 0] = "NONE";
+    /** Indicates non-biometric authentication (e.g. PIN, Pattern). */
+    SecurityLevel[SecurityLevel["SECRET"] = 1] = "SECRET";
+    /**
+     * Indicates biometric authentication.
+     * @deprecated please use `BIOMETRIC_STRONG` or `BIOMETRIC_WEAK` instead.
+     * @hidden
+     */
+    SecurityLevel[SecurityLevel["BIOMETRIC"] = Platform.OS === 'android'
+        ? SecurityLevel.BIOMETRIC_WEAK
+        : SecurityLevel.BIOMETRIC_STRONG] = "BIOMETRIC";
+    /**
+     * Indicates weak biometric authentication. For example, a 2D image-based face unlock. There
+     * are currently no weak biometric authentication options on iOS.
+     */
+    SecurityLevel[SecurityLevel["BIOMETRIC_WEAK"] = 2] = "BIOMETRIC_WEAK";
+    /** Indicates strong biometric authentication. For example, a fingerprint scan or 3D face unlock. */
+    SecurityLevel[SecurityLevel["BIOMETRIC_STRONG"] = 3] = "BIOMETRIC_STRONG";
+})(SecurityLevel || (SecurityLevel = {}));
+// Upstream deprecation shim: SecurityLevel.BIOMETRIC used to be a real enum member; it's now a
+// getter aliasing to the platform-correct strong/weak member, so old call sites still resolve
+// but see a console warning steering them to the non-deprecated name.
+Object.defineProperty(SecurityLevel, 'BIOMETRIC', {
+    get() {
+        const additionalMessage = Platform.OS === 'android'
+            ? '. `SecurityLevel.BIOMETRIC` is currently an alias for `SecurityLevel.BIOMETRIC_WEAK` on Android, which might lead to unexpected behaviour.'
+            : '';
+        console.warn('`SecurityLevel.BIOMETRIC` has been deprecated. Use `SecurityLevel.BIOMETRIC_WEAK` or `SecurityLevel.BIOMETRIC_STRONG` instead' +
+            additionalMessage);
+        return Platform.OS === 'android'
+            ? SecurityLevel.BIOMETRIC_WEAK
+            : SecurityLevel.BIOMETRIC_STRONG;
+    },
+});

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/local-auth/react: the React entry over the framework-agnostic core.
+// Upstream ships free async functions and two enums, no per-instance state and no event
+// stream (unlike the sensor family in @symbiote-native/sensors) — there is nothing for a hook
+// to wrap, so this is a plain re-export, mirroring how Pedometer's free functions pass through
+// packages/sensors/src/react/index.ts untouched.
+export * from '../core/index.js';

package/build/svelte/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/svelte/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/local-auth/svelte: the Svelte entry over the framework-agnostic core.
+// Upstream ships free async functions and two enums, no per-instance state and no event stream
+// (unlike the sensor family in @symbiote-native/sensors) — there is nothing for a rune to wrap,
+// so this is a plain re-export. Svelte's lifecycle bucket is `runes/` (adapters/svelte/src/runes
+// — never React's `hooks` or Vue's `composables`), and this package has none to fill.
+export * from '../core/index.js';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/local-auth/vue: the Vue entry over the framework-agnostic core. Same
+// reasoning as the React entry — no per-instance state or event stream to wire onto Vue's
+// reactivity, so this is a plain re-export.
+export * from '../core/index.js';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/local-auth/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,0FAA0F;AAC1F,yCAAyC;AACzC,cAAc,SAAS,CAAC"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,2 @@
+export { hasHardwareAsync, supportedAuthenticationTypesAsync, isEnrolledAsync, getEnrolledLevelAsync, authenticateAsync, cancelAuthenticate, } from './local-authentication';
+export { AuthenticationType, SecurityLevel, type IBiometricsSecurityLevel, type ILocalAuthenticationOptions, type ILocalAuthenticationResult, type ILocalAuthenticationError, } from './types';