@myazahq/kyc-sdk-react-native 2.2.0 → 2.4.0

package/src/components/glass/ChromeGlass.tsx

@@ -0,0 +1,65 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+
+import { GlassSurface } from './GlassSurface';
+
+// ---------------------------------------------------------------------------
+// ChromeGlass — the surface behind controls that float over the LIVE CAMERA.
+//
+// This is the strongest case for Liquid Glass in the SDK: the chrome floats
+// above content, it is interactive, and the background is a moving scene rather
+// than a flat tint, which is exactly the condition the material was designed
+// for (it is what the iOS Camera app does).
+//
+// Two properties are load-bearing, and both exist to protect the white glyphs:
+//
+//   • `colorScheme: 'dark'` — forced, NOT the app theme. These icons are white
+//     against a camera feed, not against the app's background, so a light app
+//     theme would put pale glass under white icons.
+//
+//   • `tintColor` — a dark bias over the glass. Plain glass is translucent, so
+//     a white passport page filling the frame would wash a white glyph out.
+//     The flat scrim this replaces guaranteed contrast; the tint is what buys
+//     that guarantee back while keeping the material's depth and adaptivity.
+//
+// Off iOS 26 it renders the ORIGINAL flat scrim, so Android and older iOS are
+// pixel-identical to before. Glass stays purely additive.
+// ---------------------------------------------------------------------------
+
+/** The flat scrim used before glass, and still the fallback everywhere else. */
+export const CHROME_SCRIM = 'rgba(0,0,0,0.55)';
+
+/** Dark bias laid over the glass so white glyphs survive a bright scene. */
+const CHROME_TINT = 'rgba(0,0,0,0.28)';
+
+export interface ChromeGlassProps {
+  children?: React.ReactNode;
+  style?: StyleProp<ViewStyle>;
+  /** Whether the glass reacts to touch. True for buttons, false for pills. */
+  interactive?: boolean;
+  /**
+   * Overrides the scrim on the fallback path. Pass the value the call site used
+   * before, so non-glass devices keep their exact previous appearance.
+   */
+  scrim?: string;
+}
+
+export function ChromeGlass({
+  children,
+  style,
+  interactive = false,
+  scrim = CHROME_SCRIM,
+}: ChromeGlassProps): React.ReactElement {
+  return (
+    <GlassSurface
+      glassStyle="regular"
+      colorScheme="dark"
+      tintColor={CHROME_TINT}
+      interactive={interactive}
+      fallbackColor={scrim}
+      style={style}
+    >
+      {children}
+    </GlassSurface>
+  );
+}

package/src/components/glass/FloatingSheet.tsx

@@ -0,0 +1,190 @@
+import React, { useEffect, useRef } from 'react';
+import {
+  Animated,
+  Easing,
+  Modal,
+  PanResponder,
+  Pressable,
+  View,
+  type ViewStyle,
+} from 'react-native';
+import { initialWindowMetrics } from 'react-native-safe-area-context';
+
+import { radius, spacing } from '../../config/theme';
+import { useTheme } from '../runtime';
+import { GlassIconButton } from '../GlassIconButton';
+import { GlassSheet } from './GlassSheet';
+
+// ---------------------------------------------------------------------------
+// FloatingSheet — the shell every bottom sheet in the SDK sits in.
+//
+// It floats: inset from all three edges and rounded on every corner, rather
+// than welded to the bottom of the screen. That is what the glass is for. A
+// panel flush to the edge reads as part of the screen, so seeing through it
+// says nothing; a detached one reads as a layer that has risen above the flow.
+//
+// It offers three ways out, because a sheet that can only be dismissed one way
+// is a trap for whichever user does not find that way:
+//   • swipe it down,
+//   • the close button,
+//   • tap the backdrop.
+//
+// Shared rather than copied into each sheet: swipe-to-dismiss is the kind of
+// thing that rots when it exists in four places, and the sheets would drift
+// apart on handle size, dismiss threshold and safe-area maths.
+// ---------------------------------------------------------------------------
+
+/** How far down a drag must travel before release dismisses instead of springing back. */
+const DISMISS_DISTANCE = 90;
+/** A flick dismisses at any distance — velocity is intent, distance is only evidence of it. */
+const DISMISS_VELOCITY = 0.7;
+
+export interface FloatingSheetProps {
+  visible: boolean;
+  onClose: () => void;
+  children?: React.ReactNode;
+  /** Extra bottom offset, e.g. a raised keyboard. */
+  bottomOffset?: number;
+  /** Caps the panel; the body owns its own scrolling. */
+  maxHeight?: number;
+  /** Accessible label for the close button. */
+  closeLabel?: string;
+  /**
+   * Fires once the modal has finished going away (iOS only, from `Modal`).
+   *
+   * Needed by callers that must wait for THIS sheet to be gone before opening
+   * another one — iOS refuses to present a second modal while the first is
+   * still on screen.
+   */
+  onDismiss?: () => void;
+}
+
+export function FloatingSheet({
+  visible,
+  onClose,
+  children,
+  bottomOffset = 0,
+  maxHeight,
+  closeLabel = 'Close',
+  onDismiss,
+}: FloatingSheetProps): React.ReactElement {
+  const { colors } = useTheme();
+  const translateY = useRef(new Animated.Value(0)).current;
+
+  // The PanResponder is built once, so it would otherwise close over the FIRST
+  // onClose forever and stop dismissing after the parent re-renders.
+  const onCloseRef = useRef(onClose);
+  onCloseRef.current = onClose;
+
+  // A sheet reopened after being dragged away must not still be off-screen.
+  useEffect(() => {
+    if (visible) translateY.setValue(0);
+  }, [visible, translateY]);
+
+  const pan = useRef(
+    PanResponder.create({
+      // Claim on touch START, not just on move.
+      //
+      // The panel is wrapped in a Pressable to swallow backdrop taps, and a
+      // Pressable takes the responder the instant a finger lands. Asking only
+      // on move meant that Pressable had already won and the drag never began.
+      // `onStartShouldSetResponder` bubbles from the deepest view up, and this
+      // header is deeper than that wrapper, so claiming here beats it — while
+      // the close button, deeper still, keeps winning its own taps.
+      onStartShouldSetPanResponder: () => true,
+      // Kept for the case where a touch begins as something else and turns
+      // into a drag. Downward only: stealing horizontal or upward gestures
+      // would make the scrollable bodies below feel broken.
+      onMoveShouldSetPanResponder: (_, g) => g.dy > 4 && Math.abs(g.dy) > Math.abs(g.dx),
+      // Once the drag owns the gesture, nothing may take it mid-pull.
+      onPanResponderTerminationRequest: () => false,
+      onPanResponderMove: (_, g) => {
+        // Downward only: dragging up must not detach the sheet from its corner.
+        if (g.dy > 0) translateY.setValue(g.dy);
+      },
+      onPanResponderRelease: (_, g) => {
+        if (g.dy > DISMISS_DISTANCE || g.vy > DISMISS_VELOCITY) {
+          Animated.timing(translateY, {
+            toValue: 700,
+            duration: 180,
+            easing: Easing.in(Easing.cubic),
+            useNativeDriver: true,
+          }).start(() => onCloseRef.current());
+          return;
+        }
+        Animated.spring(translateY, {
+          toValue: 0,
+          useNativeDriver: true,
+          bounciness: 0,
+        }).start();
+      },
+    }),
+  ).current;
+
+  // Read once at module init like the rest of the SDK: these sheets are modal,
+  // so there is no provider above them to read live insets from.
+  const safeBottom = initialWindowMetrics?.insets?.bottom ?? 0;
+
+  const panel: ViewStyle = {
+    marginHorizontal: spacing.md,
+    // Clear the home indicator, and never sit flush even where there is none.
+    marginBottom: bottomOffset + Math.max(safeBottom, spacing.md),
+  };
+
+  return (
+    <Modal
+      visible={visible}
+      transparent
+      animationType="slide"
+      onRequestClose={onClose}
+      onDismiss={onDismiss}
+    >
+      <Pressable
+        onPress={onClose}
+        accessibilityLabel="Dismiss"
+        style={{ flex: 1, justifyContent: 'flex-end', backgroundColor: 'rgba(0,0,0,0.5)' }}
+      >
+        <Animated.View style={[panel, { transform: [{ translateY }] }]}>
+          {/* Swallows taps so only the backdrop dismisses. */}
+          <Pressable onPress={() => undefined}>
+            <GlassSheet style={{ borderRadius: radius.xl, maxHeight, overflow: 'hidden' }}>
+              {/* The drag lives on the header, NOT the whole panel: bodies here
+                  scroll, and a panel-wide responder fights the list for every
+                  downward swipe. */}
+              <View
+                {...pan.panHandlers}
+                style={{
+                  flexDirection: 'row',
+                  alignItems: 'center',
+                  paddingTop: spacing.sm,
+                  paddingHorizontal: spacing.sm,
+                }}
+              >
+                <View style={{ flex: 1 }} />
+                {/* Grab handle — says "draggable" without a caption. */}
+                <View
+                  style={{
+                    width: 36,
+                    height: 4,
+                    borderRadius: 2,
+                    backgroundColor: colors.border,
+                  }}
+                />
+                <View style={{ flex: 1, alignItems: 'flex-end' }}>
+                  <GlassIconButton
+                    icon="close"
+                    onPress={onClose}
+                    size={32}
+                    iconSize={18}
+                    accessibilityLabel={closeLabel}
+                  />
+                </View>
+              </View>
+              {children}
+            </GlassSheet>
+          </Pressable>
+        </Animated.View>
+      </Pressable>
+    </Modal>
+  );
+}

package/src/components/glass/GlassSheet.tsx

@@ -0,0 +1,38 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+
+import { useTheme } from '../runtime';
+import { GlassSurface } from './GlassSurface';
+
+// ---------------------------------------------------------------------------
+// GlassSheet — the panel of a bottom sheet that floats above the flow.
+//
+// A sheet is a surface, not a control, which is the one case where glass is
+// right for something non-interactive: it is a layer that has risen above the
+// content, and letting that content show through is what says so.
+//
+// `glassStyle: 'regular'` rather than `'clear'` on purpose. These panels are
+// full of list text that has to stay readable, and `regular` is the frosted
+// variant; `clear` is for chrome over imagery, where there is little to read.
+//
+// The colour scheme follows the APP theme (unlike the camera chrome, which is
+// pinned dark) because a sheet sits over the SDK's own background, so its text
+// is themed text on a themed surface.
+//
+// Off iOS 26 it is the opaque themed panel it has always been.
+// ---------------------------------------------------------------------------
+
+export interface GlassSheetProps {
+  children?: React.ReactNode;
+  /** Panel geometry — corner radii and padding. */
+  style?: StyleProp<ViewStyle>;
+}
+
+export function GlassSheet({ children, style }: GlassSheetProps): React.ReactElement {
+  const { colors } = useTheme();
+  return (
+    <GlassSurface glassStyle="regular" fallbackColor={colors.background} style={style}>
+      {children}
+    </GlassSurface>
+  );
+}

package/src/components/glass/GlassSurface.tsx

@@ -1,6 +1,11 @@
 import React from 'react';
 import { Platform, View, type StyleProp, type ViewStyle } from 'react-native';
-import { GlassView, isLiquidGlassAvailable, type GlassStyle } from 'expo-glass-effect';
+import {
+  GlassView,
+  isLiquidGlassAvailable,
+  type GlassColorScheme,
+  type GlassStyle,
+} from 'expo-glass-effect';
 
 import { useTheme } from '../runtime';
 
@@ -10,7 +15,21 @@ import { useTheme } from '../runtime';
 // On iOS 26+ (where `isLiquidGlassAvailable()` is true) it renders a native
 // `GlassView`; everywhere else (Android, iOS < 26) it falls back to a plain
 // token-styled surface. Glass is purely additive — every screen looks correct
-// without it. Used for the sheet shell, header, primary buttons, and ID cards.
+// without it.
+//
+// Where it is used, and the rule behind that: glass is for things that FLOAT
+// above content — surfaces (the sheet shell + header, bottom sheets via
+// `GlassSheet`) and interactive chrome (the header icon buttons, the camera
+// controls via `ChromeGlass`).
+//
+// Deliberately NOT used for:
+//   • the primary CTA — it needs a solid brand fill to read as the one clear
+//     action, and a translucent one competes with everything behind it;
+//   • labels and status pills (the brand bar, capture hints, the sandbox
+//     strip) — at capsule scale glass reads as a control, so wrapping static
+//     text in it promises a tap that does nothing;
+//   • any "on" state (torch lit, toggle active) — a material that samples
+//     what is behind it cannot state a binary unambiguously.
 // ---------------------------------------------------------------------------
 
 const liquidGlass = Platform.OS === 'ios' && isLiquidGlassAvailable();
@@ -34,6 +53,14 @@ export interface GlassSurfaceProps {
    * theme's elevated surface (`backgroundSecondary`).
    */
   fallbackColor?: string;
+  /**
+   * Forces the glass to render light or dark, overriding the app theme.
+   *
+   * Chrome that floats over the CAMERA needs this: its glyphs are white against
+   * a live scene, not against the app's background, so following a light app
+   * theme would render pale glass under white icons.
+   */
+  colorScheme?: GlassColorScheme;
 }
 
 export function GlassSurface({
@@ -43,6 +70,7 @@ export function GlassSurface({
   tintColor,
   interactive = false,
   fallbackColor,
+  colorScheme,
 }: GlassSurfaceProps): React.ReactElement {
   const { colors, mode } = useTheme();
 
@@ -53,7 +81,7 @@ export function GlassSurface({
         glassEffectStyle={glassStyle}
         tintColor={tintColor}
         isInteractive={interactive}
-        colorScheme={mode}
+        colorScheme={colorScheme ?? mode}
       >
         {children}
       </GlassView>

package/src/components/viewfinder/ImmersiveBottomBar.tsx

@@ -1,13 +1,25 @@
 import React from 'react';
-import { ActivityIndicator, Pressable, View } from 'react-native';
+import { ActivityIndicator, Pressable, View, type ViewStyle } from 'react-native';
 import Svg, { Circle } from 'react-native-svg';
 
 import { radius, spacing } from '../../config/theme';
 import { useTheme } from '../runtime';
 import { MyazaText } from '../Typography';
 import { Icon } from '../Icon';
+import { CHROME_SCRIM, ChromeGlass } from '../glass/ChromeGlass';
 
-const SCRIM = 'rgba(0,0,0,0.55)';
+const SCRIM = CHROME_SCRIM;
+
+/** The torch's own scrim, kept as-is so non-glass devices look unchanged. */
+const TORCH_SCRIM = 'rgba(0,0,0,0.45)';
+
+/** Fills a sized Pressable with a round surface. */
+const ROUND_FILL: ViewStyle = {
+  flex: 1,
+  borderRadius: radius.full,
+  alignItems: 'center',
+  justifyContent: 'center',
+};
 
 /**
  * Fixed slots either side of the shutter.
@@ -147,22 +159,21 @@ export function BottomBar({
               onPress={onToggleTorch}
               accessibilityRole="button"
               accessibilityLabel={torch ? 'Turn off the torch' : 'Turn on the torch'}
-              style={{
-                width: 36,
-                height: 36,
-                borderRadius: radius.full,
-                // Inverted when on, so "lit" reads at a glance rather than
-                // needing the icon to be decoded.
-                backgroundColor: torch ? '#FFFFFF' : 'rgba(0,0,0,0.45)',
-                alignItems: 'center',
-                justifyContent: 'center',
-              }}
+              style={{ width: 36, height: 36 }}
             >
-              <Icon
-                name={torch ? 'zap' : 'zap-off'}
-                size={18}
-                color={torch ? colors.primary : '#FFFFFF'}
-              />
+              {torch ? (
+                // Inverted when on, so "lit" reads at a glance rather than
+                // needing the icon to be decoded. Solid rather than glass: a
+                // translucent surface samples the scene behind it, so "on"
+                // would look different depending on where the camera points.
+                <View style={[ROUND_FILL, { backgroundColor: '#FFFFFF' }]}>
+                  <Icon name="zap" size={18} color={colors.primary} />
+                </View>
+              ) : (
+                <ChromeGlass interactive scrim={TORCH_SCRIM} style={ROUND_FILL}>
+                  <Icon name="zap-off" size={18} color="#FFFFFF" />
+                </ChromeGlass>
+              )}
             </Pressable>
           ) : null}
         </View>

package/src/components/viewfinder/ImmersiveControls.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ActivityIndicator, Pressable, View } from 'react-native';
+import { ActivityIndicator, Pressable, View, type ViewStyle } from 'react-native';
 import Svg, { Circle } from 'react-native-svg';
 
 import { radius, spacing } from '../../config/theme';
@@ -7,6 +7,7 @@ import { useTheme } from '../runtime';
 import { MyazaText } from '../Typography';
 import { Icon } from '../Icon';
 import { CountryFlag } from '../CountryFlag';
+import { CHROME_SCRIM, ChromeGlass } from '../glass/ChromeGlass';
 
 // ---------------------------------------------------------------------------
 // Immersive capture chrome — 1:1 with the Flutter SDK's full-screen camera.
@@ -18,9 +19,16 @@ import { CountryFlag } from '../CountryFlag';
 //   • the side badge and document pill sit top, out of the frame's way.
 // ---------------------------------------------------------------------------
 
-const SCRIM = 'rgba(0,0,0,0.55)';
+const SCRIM = CHROME_SCRIM;
 
-/** Round translucent control — back, torch. */
+/**
+ * Round translucent control — back, torch.
+ *
+ * Liquid Glass when idle; SOLID brand fill when `active`. An "on" state has to
+ * be unmistakable, and a translucent material that samples the scene behind it
+ * cannot promise that — the torch would look on or off depending on what the
+ * camera happened to be pointed at.
+ */
 export function RoundControl({
   icon,
   label,
@@ -37,23 +45,27 @@ export function RoundControl({
   style: object;
 }): React.ReactElement {
   const { colors } = useTheme();
+  const fill: ViewStyle = {
+    flex: 1,
+    borderRadius: radius.full,
+    alignItems: 'center',
+    justifyContent: 'center',
+  };
+  const glyph = <Icon name={icon} size={20} color="#FFFFFF" />;
   return (
     <Pressable
       onPress={onPress}
       accessibilityRole="button"
       accessibilityLabel={label}
-      style={{
-        position: 'absolute',
-        width: size,
-        height: size,
-        borderRadius: radius.full,
-        backgroundColor: active ? colors.primary : SCRIM,
-        alignItems: 'center',
-        justifyContent: 'center',
-        ...style,
-      }}
+      style={{ position: 'absolute', width: size, height: size, ...style }}
     >
-      <Icon name={icon} size={20} color="#FFFFFF" />
+      {active ? (
+        <View style={[fill, { backgroundColor: colors.primary }]}>{glyph}</View>
+      ) : (
+        <ChromeGlass interactive style={fill}>
+          {glyph}
+        </ChromeGlass>
+      )}
     </Pressable>
   );
 }

package/src/components/viewfinder/ViewfinderControls.tsx

@@ -1,11 +1,23 @@
 import React from 'react';
-import { ActivityIndicator, Pressable, View } from 'react-native';
+import { ActivityIndicator, Pressable, View, type ViewStyle } from 'react-native';
 import Svg, { Circle } from 'react-native-svg';
 
 import { radius, spacing } from '../../config/theme';
 import { useTheme } from '../runtime';
 import { MyazaText } from '../Typography';
 import { Icon } from '../Icon';
+import { ChromeGlass } from '../glass/ChromeGlass';
+
+/** This overlay's own scrim, kept so non-glass devices look unchanged. */
+const OVERLAY_SCRIM = 'rgba(0,0,0,0.4)';
+
+/** Fills a sized Pressable with a round surface. */
+const ROUND_FILL: ViewStyle = {
+  flex: 1,
+  borderRadius: radius.full,
+  alignItems: 'center',
+  justifyContent: 'center',
+};
 
 /** Top offset that clears the status bar when the camera runs full-bleed. */
 export function topInset(fill: boolean): number {
@@ -49,7 +61,13 @@ export function HintBanner({
   );
 }
 
-/** A round overlay button — the torch and the immersive back control. */
+/**
+ * A round overlay button — the torch and the immersive back control.
+ *
+ * Liquid Glass when idle; SOLID brand fill when `active`. An "on" state has to
+ * be unmistakable, and a translucent material that samples the scene behind it
+ * cannot promise that.
+ */
 export function OverlayButton({
   icon,
   onPress,
@@ -77,13 +95,17 @@ export function OverlayButton({
         [side]: spacing.md,
         width: 36,
         height: 36,
-        borderRadius: radius.full,
-        backgroundColor: active ? colors.primary : 'rgba(0,0,0,0.4)',
-        alignItems: 'center',
-        justifyContent: 'center',
       }}
     >
-      <Icon name={icon} size={18} color="#FFFFFF" />
+      {active ? (
+        <View style={[ROUND_FILL, { backgroundColor: colors.primary }]}>
+          <Icon name={icon} size={18} color="#FFFFFF" />
+        </View>
+      ) : (
+        <ChromeGlass interactive scrim={OVERLAY_SCRIM} style={ROUND_FILL}>
+          <Icon name={icon} size={18} color="#FFFFFF" />
+        </ChromeGlass>
+      )}
     </Pressable>
   );
 }

package/src/config/questionnaire.ts

@@ -39,17 +39,24 @@ export function currencyKeyFor(field: QuestionnaireField): string {
   return `${field.key}_currency`;
 }
 
+/** The companion key holding what an "Other" choice actually was. */
+export function otherKeyFor(field: QuestionnaireField): string {
+  return `${field.key}_other`;
+}
+
 /**
- * Every answer key a definition can produce — money questions contribute two.
- * The server uses the same expansion to cross-check decision-graph references,
- * so anything reasoning about "the keys this questionnaire yields" must use it
- * rather than mapping over `fields`.
+ * Every answer key a definition can produce — money questions contribute two,
+ * and so does a choice question offering an "Other". The server uses the same
+ * expansion to cross-check decision-graph references, so anything reasoning
+ * about "the keys this questionnaire yields" must use it rather than mapping
+ * over `fields`.
  */
 export function questionnaireAnswerKeys(questionnaire: QuestionnaireConfig | undefined): string[] {
   const keys: string[] = [];
   for (const field of questionnaire?.fields ?? []) {
     keys.push(field.key);
     if (field.type === 'money') keys.push(currencyKeyFor(field));
+    if ((field.options ?? []).some((o) => o.requiresDetail)) keys.push(otherKeyFor(field));
   }
   return keys;
 }
@@ -78,6 +85,23 @@ export function validateQuestionnaire(
       continue;
     }
 
+    // An "Other" choice obliges a description, whether or not the question
+    // itself is required: an unexplained "Other" is the answer that most needs
+    // explaining. Checked before the per-type rules so it applies to select and
+    // multiselect alike.
+    const detailOption = (field.options ?? []).find(
+      (o) =>
+        o.requiresDetail &&
+        (Array.isArray(value) ? (value as string[]).includes(o.value) : value === o.value),
+    );
+    if (detailOption) {
+      const detail = answers[`${field.key}_other`];
+      if (typeof detail !== 'string' || !detail.trim()) {
+        errors[field.key] = `Tell us more about "${detailOption.label}".`;
+        continue;
+      }
+    }
+
     if (field.type === 'number' || field.type === 'money') {
       const num = Number(value);
       if (!Number.isFinite(num) || (field.type === 'money' && num < 0)) {
@@ -147,6 +171,23 @@ export function questionnairePayload(
     }
 
     payload[field.key] = value as QuestionnaireAnswerValue;
+
+    // The description behind an "Other" choice. Carried explicitly for the same
+    // reason `_currency` is: this builds the request from the FIELD LIST, so a
+    // companion answer that is not named here is silently dropped — the user
+    // types it, the client accepts it, and the server then rejects the
+    // submission for a missing detail it was never sent.
+    const detailOption = (field.options ?? []).find(
+      (o) =>
+        o.requiresDetail &&
+        (Array.isArray(value) ? (value as string[]).includes(o.value) : value === o.value),
+    );
+    if (detailOption) {
+      const detail = answers[otherKeyFor(field)];
+      if (typeof detail === 'string' && detail.trim() !== '') {
+        payload[otherKeyFor(field)] = detail.trim();
+      }
+    }
   }
 
   return payload;

package/src/config/workflowMerge.ts

@@ -30,6 +30,7 @@ export const WORKFLOW_KEYS = [
   'requireMobileDevice',
   'voiceGuidance',
   'showThemeToggle',
+  'progressStyle',
   'disableClose',
   'appearance',
   'consent',

package/src/emrtd/crypto.ts

@@ -99,7 +99,7 @@ export function deriveKey(
 }
 
 // The MRZ-derived key lives in ./mrzKey; re-exported so callers keep one import.
-export { keySeed, mrzKeySeedInput, type MrzKeyFields } from './mrzKey';
+export { keySeed, paceKeySeed, mrzKeySeedInput, type MrzKeyFields } from './mrzKey';
 
 /** The pair of session keys derived from a seed. */
 export interface SessionKeys {