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

package/src/components/StepIndicator.tsx

@@ -1,17 +1,23 @@
-import React from 'react';
-import { View } from 'react-native';
+import React, { useState } from 'react';
+import { PixelRatio, useWindowDimensions, View, type LayoutChangeEvent } from 'react-native';
 
 import { spacing } from '../config/theme';
+import { fitStepCircles, windowedSteps, type StepSlot } from '../lib/step-window';
 import { useTheme } from './runtime';
 import { MyazaText } from './Typography';
 import { Icon } from './Icon';
 
 // Segmented numbered step indicator — 1:1 with the Flutter SDK's _StepIndicator.
-// N circles connected by thin lines:
-//   • completed → filled primary + white check
-//   • active    → filled primary + white number
+// N numbered circles connected by thin lines:
+//   • completed → filled primary + number + a check BADGE
+//   • active    → filled primary + number
 //   • upcoming  → outlined (primary200) + muted number
 // activeIndex = round(progress * stepCount) - 1.
+//
+// Long flows COLLAPSE rather than overflow, but only as a LAST RESORT: the row
+// measures itself and shows as many real circles as the width allows, windowing
+// around the current step (first and last always shown) only once the connectors
+// would stop reading as a chain. See lib/step-window.
 
 export interface StepIndicatorProps {
   /** 0.0–1.0 progress fraction. */
@@ -19,47 +25,155 @@ export interface StepIndicatorProps {
   stepCount: number;
 }
 
+/** Base circle size, before text scaling. */
+const CIRCLE = 26;
+
 export function StepIndicator({ progress, stepCount }: StepIndicatorProps): React.ReactElement {
   const { colors } = useTheme();
   const active = Math.round(progress * stepCount) - 1;
 
+  // Grow the circle with the system text size, or the number inside it clips
+  // the moment a user turns Dynamic Type up — the circle was a hard 26px while
+  // the label scaled freely. Capped at 1.4: past that the row matters less than
+  // the step content below it, and an indicator that pushes the title off screen
+  // helps nobody.
+  const scale = Math.min(PixelRatio.getFontScale(), 1.4);
+  const size = Math.round(CIRCLE * scale);
+  const badge = Math.round(13 * scale);
+
+  // How many circles actually fit. Measured rather than assumed, so a flow
+  // collapses on a narrow phone and stays whole on a wide one instead of both
+  // obeying the same hardcoded cap. The window width is the first estimate — it
+  // is right on the first frame, which avoids rendering a collapsed row and then
+  // snapping to a full one — and onLayout corrects it if the row is inset by
+  // anything this does not know about.
+  const { width: screenWidth } = useWindowDimensions();
+  const [measured, setMeasured] = useState(0);
+  const rowWidth = measured || Math.max(0, screenWidth - spacing.md * 2);
+  const slots = windowedSteps(stepCount, active, fitStepCircles(rowWidth, size));
+
+  const onLayout = (e: LayoutChangeEvent): void => {
+    const w = e.nativeEvent.layout.width - spacing.md * 2;
+    // Only react to real changes (rotation, split screen). Setting state on
+    // every layout pass would re-render the row for nothing.
+    setMeasured((prev) => (Math.abs(prev - w) > 1 ? w : prev));
+  };
+
   return (
-    <View style={{ flexDirection: 'row', alignItems: 'center', paddingHorizontal: spacing.md }}>
-      {Array.from({ length: stepCount }).map((_, i) => {
-        const completed = i < active;
-        const isActive = i === active;
+    <View
+      style={{ flexDirection: 'row', alignItems: 'center', paddingHorizontal: spacing.md }}
+      onLayout={onLayout}
+      // ONE label for the whole row. Previously a screen reader walked ten
+      // unlabelled circles and announced a bare "6", which says nothing about
+      // how far through the flow that is.
+      accessible
+      accessibilityRole="progressbar"
+      accessibilityLabel={`Step ${Math.min(Math.max(active + 1, 1), stepCount)} of ${stepCount}`}
+      accessibilityValue={{
+        min: 1,
+        max: stepCount,
+        now: Math.min(Math.max(active + 1, 1), stepCount),
+      }}
+    >
+      {slots.map((slot: StepSlot, position) => {
+        const isEllipsis = slot === 'ellipsis';
+        const completed = !isEllipsis && slot < active;
+        const isActive = !isEllipsis && slot === active;
         const filled = completed || isActive;
         return (
-          <React.Fragment key={i}>
-            <View
-              style={{
-                width: 26,
-                height: 26,
-                borderRadius: 13,
-                alignItems: 'center',
-                justifyContent: 'center',
-                backgroundColor: filled ? colors.primary : 'transparent',
-                borderWidth: 1.5,
-                borderColor: filled ? colors.primary : colors.primary200,
-              }}
-            >
-              {completed ? (
-                <Icon name="check" size={14} color="#FFFFFF" />
-              ) : (
+          <React.Fragment key={isEllipsis ? `gap-${position}` : `step-${slot}`}>
+            {isEllipsis ? (
+              // Collapsed run. Sized to the circle's height so the connectors on
+              // either side stay on the same centre line and the chain reads as
+              // continuous rather than broken in two.
+              <View
+                style={{ height: size, justifyContent: 'center', paddingHorizontal: 2 }}
+                importantForAccessibility="no"
+              >
                 <MyazaText
                   variant="bodySmall"
-                  color={isActive ? '#FFFFFF' : colors.textMuted}
-                  style={{ fontSize: 11, fontWeight: '700' }}
+                  color={colors.textMuted}
+                  style={{ fontSize: 13, letterSpacing: 1 }}
+                  allowFontScaling={false}
                 >
-                  {i + 1}
+                  ···
                 </MyazaText>
-              )}
-            </View>
-            {i < stepCount - 1 ? (
+              </View>
+            ) : (
+              // Positioning context for the badge, which straddles the circle's
+              // edge. Nothing here clips, so the overhang renders.
+              <View style={{ width: size, height: size }} importantForAccessibility="no">
+                <View
+                  style={{
+                    width: size,
+                    height: size,
+                    borderRadius: size / 2,
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    backgroundColor: filled ? colors.primary : 'transparent',
+                    borderWidth: 1.5,
+                    borderColor: filled ? colors.primary : colors.primary200,
+                  }}
+                >
+                  {/* The NUMBER stays, completed or not. A check alone says a
+                      step is done but not WHICH step — and once the row is
+                      windowed ("1 ··· 5 6 7 ··· 10") that is precisely what the
+                      numbers are there to answer. */}
+                  <MyazaText
+                    variant="bodySmall"
+                    color={filled ? '#FFFFFF' : colors.textMuted}
+                    style={{ fontSize: 12, fontWeight: '700' }}
+                    // The circle already scales with the system text size, so
+                    // scaling the glyph again would overflow it.
+                    allowFontScaling={false}
+                  >
+                    {slot + 1}
+                  </MyazaText>
+                </View>
+
+                {/* Completion rides as a badge tucked onto the circle's corner.
+                    The ring is WHITE — the same colour as the number inside the
+                    circle — because the badge sits on the circle, not on the
+                    page. Ringing it in the page background (which the chip
+                    portrait's CheckBadge does, correctly, because it sits on a
+                    photo) painted a near-black blob around the check on the dark
+                    theme, where background is #040218. */}
+                {completed ? (
+                  <View
+                    style={{
+                      position: 'absolute',
+                      top: -3,
+                      right: -2,
+                      width: badge,
+                      height: badge,
+                      borderRadius: badge / 2,
+                      backgroundColor: colors.success,
+                      // 1px, not 1.5: on a 13px badge a 1.5px ring eats nearly a
+                      // quarter of the diameter and reads as a white outline
+                      // rather than a hairline separating badge from circle.
+                      borderWidth: 1,
+                      borderColor: '#FFFFFF',
+                      alignItems: 'center',
+                      justifyContent: 'center',
+                    }}
+                  >
+                    <Icon name="check" size={Math.round(badge * 0.6)} color="#FFFFFF" />
+                  </View>
+                ) : null}
+              </View>
+            )}
+            {position < slots.length - 1 ? (
               <View
                 style={{
                   flex: 1,
+                  // Floor, so an unforeseen overflow degrades to a visibly short
+                  // connector rather than a row of circles with no chain at all.
+                  minWidth: 6,
                   height: 2,
+                  // UNIFORM, deliberately: fitStepCircles budgets 3+3 per
+                  // connector, so widening this for completed steps made the row
+                  // need more space than was reserved. The badge is tucked in
+                  // far enough (right: -2) not to need the extra.
                   marginHorizontal: 3,
                   borderRadius: 1,
                   backgroundColor: completed ? colors.primary : colors.primary200,

package/src/components/fonts.ts

@@ -1,6 +1,10 @@
+import type { TextStyle } from 'react-native';
 import { useFonts } from 'expo-font';
 import { SpaceGrotesk_500Medium, SpaceGrotesk_600SemiBold, SpaceGrotesk_700Bold } from '@expo-google-fonts/space-grotesk';
 import { Karla_400Regular, Karla_500Medium, Karla_600SemiBold, Karla_700Bold } from '@expo-google-fonts/karla';
+import { fontFamilyFor } from '../config/font-resolve';
+import { useTheme } from './theme-provider';
+
 export { fontFamilyFor, markFamilyName, brandFamilyName, BRAND_WEIGHTS } from '../config/font-resolve';
 
 
@@ -30,3 +34,22 @@ export function useMyazaFonts(): boolean {
  * Returns `undefined` until fonts are loaded so text falls back to the system
  * font + `fontWeight` without triggering an "unrecognized font" warning.
  */
+
+/**
+ * The body font family for a TEXT INPUT, at the given weight.
+ *
+ * `TextInput` does not inherit `fontFamily` from any ancestor the way web
+ * inputs inherit from a stylesheet — RN resolves it per-element — so an input
+ * that never sets one renders in the system face while every `MyazaText`
+ * beside it renders in the brand's. The placeholder follows the input's own
+ * family too, which is why it looked wrong as well.
+ *
+ * Goes through the same resolver as MyazaText so an org's uploaded brand font
+ * reaches inputs, not just text. Returns undefined until fonts load, which is
+ * the caller's cue to leave `fontFamily` unset rather than name a family the
+ * platform has not registered.
+ */
+export function useInputFontFamily(weight: TextStyle['fontWeight'] = '400'): string | undefined {
+  const { fontsLoaded, brandFonts } = useTheme();
+  return fontFamilyFor(false, weight, fontsLoaded, brandFonts);
+}

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 {

package/src/emrtd/dg1.ts

@@ -0,0 +1,55 @@
+import { fromBase64 } from './bytes';
+import { findTlvDeep } from './der';
+import { parseMrz, type MrzScan } from '../mrz/parse';
+
+// ---------------------------------------------------------------------------
+// THE CHIP'S OWN MRZ.
+//
+// DG1 is the machine-readable zone exactly as the ISSUING STATE wrote it, and
+// passive authentication hashes it against the signed security object. It is
+// the strongest copy of the holder's details that exists on the document.
+//
+// The camera scan is a GUESS at the same characters, and it is not a safe
+// substitute for display. Measured on a real Nigerian passport read on a Galaxy
+// S24: the on-device recogniser read the first '<' of the '<<' surname
+// separator as 'K', so `INGWE<<RICHARD<UNIMKE` arrived as `INGWEK<RICHARD…`.
+// The split then never fired at the surname boundary and landed in the trailing
+// filler instead, yielding lastName "INGWEK RICHARD UNIMKE" and firstName
+// "KKKK" — displayed under a caption promising we had read the secure chip.
+//
+// TD3 carries NO check digit over the name field (only line 2 is protected), so
+// that corruption passes `parseMrz` validation silently. There is no way to
+// detect it from the scan alone, which is exactly why the chip has to be the
+// source once we hold it.
+//
+// Reuses `parseMrz` rather than parsing here: DG1's value IS the continuous
+// 88/90-character string that function already takes, and a second MRZ parser
+// would be one more thing to drift.
+// ---------------------------------------------------------------------------
+
+/** DG1's MRZ lives under tag 5F1F, inside the 0x61 template. */
+const TAG_MRZ = 0x5f1f;
+
+/**
+ * The MRZ read off the chip, or null when DG1 is absent, malformed, or not a
+ * size `parseMrz` recognises.
+ *
+ * Null is a normal outcome the caller falls back from, never an error: the
+ * read itself already succeeded and its bytes still go to the server, which
+ * parses DG1 authoritatively regardless of what this returns.
+ */
+export function parseDg1(dg1Base64: string | undefined | null): MrzScan | null {
+  if (!dg1Base64) return null;
+  try {
+    const bytes = fromBase64(dg1Base64);
+    const mrz = findTlvDeep(bytes, TAG_MRZ);
+    if (!mrz) return null;
+    let text = '';
+    for (const byte of mrz.value) text += String.fromCharCode(byte);
+    return parseMrz(text);
+  } catch {
+    // Display-path only. A malformed DG1 must never take down the success
+    // screen of a read that otherwise worked.
+    return null;
+  }
+}

package/src/emrtd/ec-curves.ts

@@ -0,0 +1,142 @@
+// ---------------------------------------------------------------------------
+// Standardised elliptic-curve domain parameters (ICAO 9303 / BSI TR-03110).
+//
+// A chip names its PACE curve by a standardised parameter id rather than
+// sending the parameters, so both sides must agree on this table. Every curve
+// here is a prime-field short-Weierstrass curve (y² = x³ + ax + b), so one set
+// of point arithmetic (ec.ts) covers all of them.
+//
+// The constants are transcribed from the authoritative sources — NIST FIPS
+// 186-4 for the secp/P- curves and RFC 5639 for the brainpool curves — and are
+// verified in ec.test.ts, which asserts G lies on each curve and that n·G is
+// the point at infinity. A transcription typo fails that test rather than a
+// passport.
+//
+// The six curves below are the ones issued eMRTDs actually use. The other
+// standardised ids (the 192/224-bit curves, DH groups) are left unmapped: an
+// unknown id resolves to null, which the caller treats exactly like a chip that
+// does not offer PACE — it reads over BAC. So the coverage gap can only ever
+// cost a fallback, never a failed read.
+// ---------------------------------------------------------------------------
+
+/** A prime-field short-Weierstrass curve and its generator. */
+export interface EcCurve {
+  readonly name: string;
+  /** Field prime. */
+  readonly p: bigint;
+  readonly a: bigint;
+  readonly b: bigint;
+  /** Generator coordinates. */
+  readonly gx: bigint;
+  readonly gy: bigint;
+  /** Group order. */
+  readonly n: bigint;
+  /** Field width in bytes — the fixed length x/y coordinates encode to. */
+  readonly byteLen: number;
+}
+
+const hex = (s: string): bigint => BigInt(`0x${s.replace(/\s+/g, '')}`);
+
+function curve(
+  name: string,
+  byteLen: number,
+  p: string,
+  a: string,
+  b: string,
+  gx: string,
+  gy: string,
+  n: string,
+): EcCurve {
+  return { name, byteLen, p: hex(p), a: hex(a), b: hex(b), gx: hex(gx), gy: hex(gy), n: hex(n) };
+}
+
+const secp256r1 = curve(
+  'secp256r1',
+  32,
+  'FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF',
+  'FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC',
+  '5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B',
+  '6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296',
+  '4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5',
+  'FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551',
+);
+
+const brainpoolP256r1 = curve(
+  'brainpoolP256r1',
+  32,
+  'A9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377',
+  '7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9',
+  '26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6',
+  '8BD2AEB9CB7E57CB2C4B482FFC81B7AFB9DE27E1E3BD23C23A4453BD9ACE3262',
+  '547EF835C3DAC4FD97F8461A14611DC9C27745132DED8E545C1D54C72F046997',
+  'A9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7',
+);
+
+const secp384r1 = curve(
+  'secp384r1',
+  48,
+  'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF',
+  'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC',
+  'B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF',
+  'AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7',
+  '3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F',
+  'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973',
+);
+
+const brainpoolP384r1 = curve(
+  'brainpoolP384r1',
+  48,
+  '8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC53',
+  '7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F90F8AA5814A503AD4EB04A8C7DD22CE2826',
+  '04A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62D57CB4390295DBC9943AB78696FA504C11',
+  '1D1C64F068CF45FFA2A63A81B7C13F6B8847A3E77EF14FE3DB7FCAFE0CBD10E8E826E03436D646AAEF87B2E247D4AF1E',
+  '8ABE1D7520F9C2A45CB1EB8E95CFD55262B70B29FEEC5864E19C054FF99129280E4646217791811142820341263C5315',
+  '8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425A7CF3AB6AF6B7FC3103B883202E9046565',
+);
+
+const brainpoolP512r1 = curve(
+  'brainpoolP512r1',
+  64,
+  'AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3',
+  '7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA',
+  '3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723',
+  '81AEE4BDD82ED9645A21322E9C4C6A9385ED9F70B5D916C1B43B62EEF4D0098EFF3B1F78E2D0D48D50D1687B93B97D5F7C6D5047406A5E688B352209BCB9F822',
+  '7DDE385D566332ECC0EABFA9CF7822FDF209F70024A57B1AA000C55B881F8111B2DCDE494A5F485E5BCA4BD88A2763AED1CA2B2FA8F0540678CD1E0F3AD80892',
+  'AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA70330870553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069',
+);
+
+const secp521r1 = curve(
+  'secp521r1',
+  66,
+  '01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
+  '01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC',
+  '0051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00',
+  '00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66',
+  '011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650',
+  '01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409',
+);
+
+/** ICAO standardised parameter id → curve, for the curves this build runs. */
+const BY_ID: Record<number, EcCurve> = {
+  12: secp256r1,
+  13: brainpoolP256r1,
+  15: secp384r1,
+  16: brainpoolP384r1,
+  17: brainpoolP512r1,
+  18: secp521r1,
+};
+
+/** The curve for a standardised parameter id, or null when unmapped. */
+export function curveForParameterId(id: number): EcCurve | null {
+  return BY_ID[id] ?? null;
+}
+
+/** Exposed for tests — every curve this build claims to support. */
+export const ALL_CURVES: readonly EcCurve[] = [
+  secp256r1,
+  brainpoolP256r1,
+  secp384r1,
+  brainpoolP384r1,
+  brainpoolP512r1,
+  secp521r1,
+];