@structured-id/ui-core 0.1.5

package/README.md

@@ -0,0 +1,47 @@
+# @structured-id/ui-core
+
+Shared UI package for StructuredID applications. Provides Vue 3 composables, Pinia stores, protobuf-ts generated clients, and reusable components.
+
+## What's Inside
+
+- **Proto clients** -- gRPC-Web clients generated from [proto](https://github.com/structured-id/proto) via protobuf-ts
+- **Composables** -- `useAuth`, `useAuthApi`, `useAccountApi`, `useIdentityApi`, `useSecurityLevel`, `useOpaqueAuth`
+- **Components** -- `SidLoginForm`, `SidRegistrationForm`, `SidMfaChallenge`, `SidPrincipalInput`, profile management pages
+- **Utilities** -- `normalizePrincipal`, `detectLoginInputType`, validators, formatters
+
+## Usage
+
+```ts
+import { useAuth, getTransport, initGrpc } from "@structured-id/ui-core";
+import { SidLoginForm } from "@structured-id/ui-core/profile";
+
+// Initialize gRPC transport
+initGrpc({ baseUrl: "http://localhost:9080" });
+```
+
+## Development
+
+```bash
+yarn install
+yarn build       # Build library
+yarn test        # Run tests (vitest)
+yarn typecheck   # vue-tsc --noEmit
+```
+
+## Architecture
+
+```
+src/
+  composables/     # Vue 3 composition API (useAuth, useAuthApi)
+  stores/          # Pinia stores (auth)
+  profile/         # Profile components and composables
+    components/    # SidLoginForm, SidRegistrationForm, SidMfaChallenge
+    composables/   # useOpaqueAuth, useAccountApi, useIdentityApi
+  utils/           # normalizePrincipal, validators, formatters
+  generated/       # protobuf-ts generated clients (do not edit)
+  proto/           # Proto definitions submodule
+```
+
+## License
+
+AGPL-3.0-only -- see [LICENSE](LICENSE) for details.

package/dist/browser-vp/index.cjs

@@ -0,0 +1,349 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+var _chunkC3Q766CYcjs = require('../chunk-C3Q766CY.cjs');
+
+// src/browser-vp/prf.ts
+var PRF_EVAL_LABEL = "sid-ppk-v1";
+var PRF_PROBE_LABEL = "sid-probe";
+var encoder = new TextEncoder();
+async function hasPrfSupport() {
+  try {
+    if (typeof window === "undefined" || !window.PublicKeyCredential) {
+      return false;
+    }
+    if (typeof PublicKeyCredential.getClientCapabilities === "function") {
+      try {
+        const caps = await PublicKeyCredential.getClientCapabilities();
+        if (caps && "prf" in caps) {
+          return Boolean(caps.prf);
+        }
+      } catch (e) {
+      }
+    }
+    const result = await navigator.credentials.get({
+      publicKey: {
+        challenge: crypto.getRandomValues(new Uint8Array(32)),
+        rpId: window.location.hostname,
+        userVerification: "discouraged",
+        extensions: {
+          prf: {
+            eval: {
+              first: encoder.encode(PRF_PROBE_LABEL)
+            }
+          }
+        }
+      }
+    });
+    if (!result) return false;
+    const ext = result.getClientExtensionResults();
+    const prfResults = _optionalChain([ext, 'optionalAccess', _ => _.prf]);
+    return _optionalChain([prfResults, 'optionalAccess', _2 => _2.results, 'optionalAccess', _3 => _3.first]) != null;
+  } catch (e2) {
+    return false;
+  }
+}
+async function evaluatePrf(credentialId) {
+  try {
+    const allowCredentials = credentialId ? [{ type: "public-key", id: credentialId }] : void 0;
+    const result = await navigator.credentials.get({
+      publicKey: {
+        challenge: crypto.getRandomValues(new Uint8Array(32)),
+        rpId: window.location.hostname,
+        userVerification: "required",
+        allowCredentials,
+        extensions: {
+          prf: {
+            eval: {
+              first: encoder.encode(PRF_EVAL_LABEL)
+            }
+          }
+        }
+      }
+    });
+    if (!result) return null;
+    const ext = result.getClientExtensionResults();
+    const prfResults = _optionalChain([ext, 'optionalAccess', _4 => _4.prf]);
+    return _nullishCoalesce(_optionalChain([prfResults, 'optionalAccess', _5 => _5.results, 'optionalAccess', _6 => _6.first]), () => ( null));
+  } catch (e3) {
+    return null;
+  }
+}
+async function createPasskeyWithPrf(userId, userName, rpName) {
+  try {
+    const result = await navigator.credentials.create({
+      publicKey: {
+        challenge: crypto.getRandomValues(new Uint8Array(32)),
+        rp: {
+          name: rpName,
+          id: window.location.hostname
+        },
+        user: {
+          id: userId,
+          name: userName,
+          displayName: userName
+        },
+        pubKeyCredParams: [
+          { alg: -7, type: "public-key" },
+          // ES256
+          { alg: -257, type: "public-key" }
+          // RS256 fallback
+        ],
+        authenticatorSelection: {
+          residentKey: "required",
+          userVerification: "required"
+        },
+        extensions: {
+          prf: {
+            eval: {
+              first: encoder.encode(PRF_EVAL_LABEL)
+            }
+          }
+        }
+      }
+    });
+    if (!result) return null;
+    const credential = result;
+    const ext = credential.getClientExtensionResults();
+    const prfResults = _optionalChain([ext, 'optionalAccess', _7 => _7.prf]);
+    const prfOutput = _optionalChain([prfResults, 'optionalAccess', _8 => _8.results, 'optionalAccess', _9 => _9.first]);
+    if (!prfOutput) return null;
+    return { credential, prfOutput };
+  } catch (e4) {
+    return null;
+  }
+}
+
+// src/browser-vp/crypto.ts
+var PRF_SALT = "sid-ppk-v1";
+var SIGNING_INFO = "signing-key";
+var DATA_KEY_INFO = "data-encryption-key";
+var encoder2 = new TextEncoder();
+async function deriveKeysFromPrf(prfOutput) {
+  const baseKey = await crypto.subtle.importKey(
+    "raw",
+    prfOutput,
+    "HKDF",
+    false,
+    ["deriveBits"]
+  );
+  const salt = encoder2.encode(PRF_SALT);
+  const signingBits = await crypto.subtle.deriveBits(
+    { name: "HKDF", hash: "SHA-256", salt, info: encoder2.encode(SIGNING_INFO) },
+    baseKey,
+    256
+  );
+  const dataKeyBits = await crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt,
+      info: encoder2.encode(DATA_KEY_INFO)
+    },
+    baseKey,
+    256
+  );
+  const signingKey = await importEcdsaFromSeed(signingBits);
+  const dataKey = await crypto.subtle.importKey(
+    "raw",
+    dataKeyBits,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  return { signingKey, dataKey };
+}
+async function generateDeviceKey() {
+  return crypto.subtle.generateKey(
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    // non-extractable
+    ["sign", "verify"]
+  );
+}
+async function generateDataKey() {
+  return crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function wrapKey(keyToWrap, wrappingKey) {
+  return crypto.subtle.wrapKey("jwk", keyToWrap, wrappingKey, "AES-KW");
+}
+async function unwrapSigningKey(wrappedKey, wrappingKey) {
+  return crypto.subtle.unwrapKey(
+    "jwk",
+    wrappedKey,
+    wrappingKey,
+    "AES-KW",
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    // non-extractable
+    ["sign"]
+  );
+}
+async function deriveWrappingKey(sessionExportKey) {
+  const baseKey = await crypto.subtle.importKey(
+    "raw",
+    sessionExportKey,
+    "HKDF",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: encoder2.encode("sid-device-key-wrap"),
+      info: encoder2.encode("wrapping-key")
+    },
+    baseKey,
+    { name: "AES-KW", length: 256 },
+    false,
+    ["wrapKey", "unwrapKey"]
+  );
+}
+async function encrypt(data, key) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    data
+  );
+  const result = new Uint8Array(iv.length + ciphertext.byteLength);
+  result.set(iv, 0);
+  result.set(new Uint8Array(ciphertext), iv.length);
+  return result.buffer;
+}
+async function decrypt(data, key) {
+  const bytes = new Uint8Array(data);
+  const iv = bytes.slice(0, 12);
+  const ciphertext = bytes.slice(12);
+  return crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+}
+async function sign(data, privateKey) {
+  return crypto.subtle.sign(
+    { name: "ECDSA", hash: "SHA-256" },
+    privateKey,
+    data
+  );
+}
+async function exportPublicKey(keyPair) {
+  return crypto.subtle.exportKey("raw", keyPair.publicKey);
+}
+async function sha256(data) {
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function importEcdsaFromSeed(_seed) {
+  return crypto.subtle.generateKey(
+    { name: "ECDSA", namedCurve: "P-256" },
+    false,
+    ["sign", "verify"]
+  );
+}
+
+// src/browser-vp/vp.ts
+var encoder3 = new TextEncoder();
+async function createVp(request, signingKey, profileBlob) {
+  const binding = await _chunkC3Q766CYcjs.loadBinding.call(void 0, request.serviceSector);
+  if (!binding) {
+    return null;
+  }
+  if (binding.certExpiry < /* @__PURE__ */ new Date()) {
+    return null;
+  }
+  const payload = buildPayload(request, binding, profileBlob);
+  const signature = await sign(payload, signingKey);
+  await _chunkC3Q766CYcjs.saveBinding.call(void 0, request.serviceSector, {
+    ...binding,
+    lastUsedAt: /* @__PURE__ */ new Date()
+  });
+  return {
+    serviceSector: request.serviceSector,
+    bindingId: binding.bindingId,
+    payload,
+    signature,
+    certChain: binding.certChain,
+    nonce: request.nonce,
+    audience: request.audience
+  };
+}
+function buildPayload(request, binding, _profileBlob) {
+  const payload = {
+    nonce: request.nonce,
+    aud: request.audience,
+    sub: binding.bindingId,
+    iat: Math.floor(Date.now() / 1e3),
+    claims: request.requestedClaims
+  };
+  return encoder3.encode(JSON.stringify(payload)).buffer;
+}
+function needsRenewal(binding) {
+  const sevenDays = 7 * 24 * 60 * 60 * 1e3;
+  return binding.certExpiry.getTime() - Date.now() < sevenDays;
+}
+async function getExpiringSoon() {
+  const { listBindings: listBindings2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("../storage-4CB2JTLW.cjs")));
+  const all = await listBindings2();
+  return all.filter((b) => needsRenewal(b));
+}
+
+// src/browser-vp/index.ts
+async function detectStrategy() {
+  if (typeof window === "undefined") return null;
+  if (!_chunkC3Q766CYcjs.isIndexedDbAvailable.call(void 0, )) return null;
+  if (!_optionalChain([window, 'access', _10 => _10.crypto, 'optionalAccess', _11 => _11.subtle])) return null;
+  if (await hasPrfSupport()) {
+    return "prf";
+  }
+  return "device-key";
+}
+async function initBrowserVp(profileId) {
+  const strategy = await detectStrategy();
+  if (!strategy) return null;
+  const { loadProfileState: loadProfileState2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("../storage-4CB2JTLW.cjs")));
+  const state = await loadProfileState2(profileId);
+  return {
+    strategy,
+    profileId,
+    ready: state != null && state.strategy === strategy
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.clearAll = _chunkC3Q766CYcjs.clearAll; exports.createPasskeyWithPrf = createPasskeyWithPrf; exports.createVp = createVp; exports.decrypt = decrypt; exports.deleteBinding = _chunkC3Q766CYcjs.deleteBinding; exports.deleteProfileState = _chunkC3Q766CYcjs.deleteProfileState; exports.deriveKeysFromPrf = deriveKeysFromPrf; exports.deriveWrappingKey = deriveWrappingKey; exports.detectStrategy = detectStrategy; exports.encrypt = encrypt; exports.evaluatePrf = evaluatePrf; exports.exportPublicKey = exportPublicKey; exports.generateDataKey = generateDataKey; exports.generateDeviceKey = generateDeviceKey; exports.getExpiringSoon = getExpiringSoon; exports.hasPrfSupport = hasPrfSupport; exports.initBrowserVp = initBrowserVp; exports.isIndexedDbAvailable = _chunkC3Q766CYcjs.isIndexedDbAvailable; exports.listBindings = _chunkC3Q766CYcjs.listBindings; exports.loadBinding = _chunkC3Q766CYcjs.loadBinding; exports.loadProfileState = _chunkC3Q766CYcjs.loadProfileState; exports.needsRenewal = needsRenewal; exports.saveBinding = _chunkC3Q766CYcjs.saveBinding; exports.saveProfileState = _chunkC3Q766CYcjs.saveProfileState; exports.sha256 = sha256; exports.sign = sign; exports.unwrapSigningKey = unwrapSigningKey; exports.wrapKey = wrapKey;

package/dist/browser-vp/index.d.cts

@@ -0,0 +1,287 @@
+/**
+ * Browser VP types.
+ *
+ * See arch/auth/browser-vp.md for full specification.
+ */
+/** VP strategy — automatically selected based on browser capabilities. */
+type VpStrategy = "prf" | "device-key";
+/** Profile state stored in IndexedDB. */
+interface ProfileState {
+    /** Which strategy this profile uses. */
+    strategy: VpStrategy;
+    /** Encrypted profile blob (< 1MB typical). */
+    encryptedBlob: ArrayBuffer;
+    /** Optimistic sync version with SID server. */
+    blobVersion: number;
+    /** PRF salt identifier (for versioning). */
+    prfSalt?: string;
+    /** SHA-256 of master public key (authenticator change detection). */
+    masterPublicKeyHash?: string;
+    /** Non-extractable CryptoKey reference (browser-managed). */
+    cryptoKeyRef?: CryptoKey;
+    /** Last sync timestamp with SID server. */
+    lastSyncedAt: Date;
+    /** SID device ID for this browser instance. */
+    deviceId: string;
+}
+/** Per-service binding stored in IndexedDB. */
+interface BindingEntry {
+    /** Opaque BindingId (pairwise per-service). */
+    bindingId: string;
+    /** HD derivation index for this binding. */
+    bindingIndex: number;
+    /** Per-binding certificate chain (DER-encoded). */
+    certChain: ArrayBuffer;
+    /** Certificate expiry date. */
+    certExpiry: Date;
+    /** Last time a VP was created for this binding. */
+    lastUsedAt: Date;
+}
+/** Key material derived from PRF or generated via WebCrypto. */
+interface DerivedKeys {
+    /** ECDSA P-256 signing key (non-extractable). */
+    signingKey: CryptoKeyPair;
+    /** AES-256-GCM data encryption key. */
+    dataKey: CryptoKey;
+}
+/** Verifiable Presentation payload. */
+interface VerifiablePresentation {
+    /** The service sector this VP is bound to. */
+    serviceSector: string;
+    /** Binding ID (pairwise). */
+    bindingId: string;
+    /** Signed VP payload (CBOR or JSON). */
+    payload: ArrayBuffer;
+    /** Signature over payload. */
+    signature: ArrayBuffer;
+    /** Certificate chain for verification. */
+    certChain: ArrayBuffer;
+    /** Nonce from relying party (replay protection). */
+    nonce: string;
+    /** Audience (relying party origin). */
+    audience: string;
+}
+/** Options for VP creation request from a relying party. */
+interface VpRequest {
+    /** Nonce for replay protection. */
+    nonce: string;
+    /** Requested claims (e.g., ["email", "name"]). */
+    requestedClaims: string[];
+    /** Audience (relying party origin). */
+    audience: string;
+    /** Service sector identifier. */
+    serviceSector: string;
+}
+/** Result of browser VP initialization. */
+interface BrowserVpContext {
+    /** Active strategy. */
+    strategy: VpStrategy;
+    /** Profile ID. */
+    profileId: string;
+    /** Whether VP creation is available (keys + blob + cert ready). */
+    ready: boolean;
+}
+
+/**
+ * WebAuthn PRF extension support (Strategy A).
+ *
+ * PRF (Pseudo-Random Function) extension allows deriving
+ * deterministic secrets from a passkey. Same passkey on any
+ * synced device produces the same PRF output → same keys.
+ *
+ * See arch/auth/browser-vp.md § Strategy A: Passkey-Derived PPK.
+ */
+/**
+ * Detect whether the browser supports WebAuthn PRF extension.
+ *
+ * Attempts a PRF evaluation on an existing passkey. Returns false
+ * if PRF is unsupported — no error thrown.
+ *
+ * Browser support (2026): Chrome 116+, Edge 116+, Safari 17.4+,
+ * Chrome Android, Safari iOS 17.4+. ~90% coverage.
+ */
+declare function hasPrfSupport(): Promise<boolean>;
+/**
+ * Evaluate PRF extension during passkey authentication.
+ *
+ * Returns the raw PRF output (32 bytes) which serves as the
+ * entropy source for key derivation.
+ *
+ * @param credentialId - Optional: specific credential to use.
+ * @returns PRF output bytes, or null if PRF evaluation failed.
+ */
+declare function evaluatePrf(credentialId?: ArrayBuffer): Promise<ArrayBuffer | null>;
+/**
+ * Create a passkey with PRF extension (first-time setup).
+ *
+ * Returns both the credential and the initial PRF output.
+ */
+declare function createPasskeyWithPrf(userId: ArrayBuffer, userName: string, rpName: string): Promise<{
+    credential: PublicKeyCredential;
+    prfOutput: ArrayBuffer;
+} | null>;
+
+/**
+ * Cryptographic primitives for Browser VP.
+ *
+ * All operations use Web Crypto API. Keys are non-extractable.
+ * See arch/auth/browser-vp.md § Key derivation.
+ */
+
+/**
+ * Derive signing key (ECDSA P-256) and data key (AES-256-GCM)
+ * from a PRF output using HKDF-SHA256.
+ *
+ * Both keys are deterministic from the same PRF seed.
+ * Same passkey on any device → same keys.
+ */
+declare function deriveKeysFromPrf(prfOutput: ArrayBuffer): Promise<DerivedKeys>;
+/**
+ * Generate a random ECDSA P-256 key pair (Strategy B).
+ * The private key is non-extractable.
+ */
+declare function generateDeviceKey(): Promise<CryptoKeyPair>;
+/**
+ * Generate a random AES-256-GCM data key (Strategy B).
+ */
+declare function generateDataKey(): Promise<CryptoKey>;
+/**
+ * Wrap a CryptoKey with AES-KW for upload to SID (Strategy B).
+ * Returns the wrapped key bytes.
+ */
+declare function wrapKey(keyToWrap: CryptoKey, wrappingKey: CryptoKey): Promise<ArrayBuffer>;
+/**
+ * Unwrap a CryptoKey from SID (Strategy B, new browser).
+ * Returns non-extractable ECDSA P-256 key pair.
+ */
+declare function unwrapSigningKey(wrappedKey: ArrayBuffer, wrappingKey: CryptoKey): Promise<CryptoKey>;
+/**
+ * Derive AES-256-KW wrapping key from OPAQUE session export key (Strategy B).
+ */
+declare function deriveWrappingKey(sessionExportKey: ArrayBuffer): Promise<CryptoKey>;
+/**
+ * Encrypt data with AES-256-GCM.
+ * Returns IV (12 bytes) prepended to ciphertext.
+ */
+declare function encrypt(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
+/**
+ * Decrypt data encrypted with `encrypt()`.
+ * Expects IV (12 bytes) prepended to ciphertext.
+ */
+declare function decrypt(data: ArrayBuffer, key: CryptoKey): Promise<ArrayBuffer>;
+/**
+ * Sign data with ECDSA P-256 (SHA-256).
+ */
+declare function sign(data: ArrayBuffer, privateKey: CryptoKey): Promise<ArrayBuffer>;
+/**
+ * Export public key as raw bytes (for CSR / certificate request).
+ */
+declare function exportPublicKey(keyPair: CryptoKeyPair): Promise<ArrayBuffer>;
+/**
+ * Compute SHA-256 hash (for authenticator change detection).
+ */
+declare function sha256(data: ArrayBuffer): Promise<string>;
+
+/**
+ * IndexedDB storage for Browser VP.
+ *
+ * Database: sid-browser-vp
+ *   ├── bindings       — per-service binding entries (key: service_sector)
+ *   └── profile-state  — profile state + encrypted blob (key: profile_id)
+ *
+ * See arch/auth/browser-vp.md § IndexedDB Storage Schema.
+ */
+
+/** Save or update profile state. */
+declare function saveProfileState(profileId: string, state: ProfileState): Promise<void>;
+/** Load profile state by ID. Returns null if not found. */
+declare function loadProfileState(profileId: string): Promise<ProfileState | null>;
+/** Delete profile state. */
+declare function deleteProfileState(profileId: string): Promise<void>;
+/** Save or update a binding entry. */
+declare function saveBinding(serviceSector: string, entry: BindingEntry): Promise<void>;
+/** Load a binding by service sector. */
+declare function loadBinding(serviceSector: string): Promise<BindingEntry | null>;
+/** List all stored bindings. */
+declare function listBindings(): Promise<Array<{
+    serviceSector: string;
+} & BindingEntry>>;
+/** Delete a binding. */
+declare function deleteBinding(serviceSector: string): Promise<void>;
+/** Clear all data (profile state + bindings). */
+declare function clearAll(): Promise<void>;
+/** Check if IndexedDB is available in this environment. */
+declare function isIndexedDbAvailable(): boolean;
+
+/**
+ * Verifiable Presentation creation.
+ *
+ * Builds and signs VPs using cached keys and profile blob.
+ * VP creation is fully offline (~50ms with biometric cache).
+ *
+ * See arch/auth/browser-vp.md § VP Creation.
+ */
+
+/**
+ * Create a Verifiable Presentation for a service.
+ *
+ * @param request - VP request from the relying party.
+ * @param signingKey - ECDSA P-256 private key (master or per-binding).
+ * @param profileBlob - Decrypted profile blob.
+ * @returns Signed VP, or null if binding not found.
+ */
+declare function createVp(request: VpRequest, signingKey: CryptoKey, profileBlob: ArrayBuffer): Promise<VerifiablePresentation | null>;
+/**
+ * Check if a binding's certificate needs renewal.
+ *
+ * Renewal is attempted 7 days before expiry (background).
+ */
+declare function needsRenewal(binding: BindingEntry): boolean;
+/**
+ * List all bindings that need certificate renewal.
+ */
+declare function getExpiringSoon(): Promise<Array<{
+    serviceSector: string;
+} & BindingEntry>>;
+
+/**
+ * Browser VP — Zero-Load Auth in Browser.
+ *
+ * Public API for browser-based Verifiable Presentation creation.
+ * Automatically selects the best strategy based on browser capabilities:
+ *
+ * - **Strategy A (PRF):** Passkey PRF extension → deterministic keys.
+ *   Cross-device via passkey sync. ~90% browser coverage (2026).
+ *
+ * - **Strategy B (device-key):** Random WebCrypto key, wrapped for sync.
+ *   Each browser = separate device. Fallback for non-PRF browsers.
+ *
+ * See arch/auth/browser-vp.md for full specification.
+ *
+ * Reference: Prudnikov, D. (2026). "Client-Side Verifiable Presentation System
+ * with Passkey-Derived Persistent Keys and Pairwise Service Bindings."
+ * doi:10.5281/zenodo.19387768 — https://doi.org/10.5281/zenodo.19387768
+ */
+
+/**
+ * Detect the best VP strategy for this browser.
+ *
+ * Returns "prf" if WebAuthn PRF extension is supported,
+ * "device-key" otherwise. Returns null if Browser VP is
+ * not possible (no IndexedDB, no WebCrypto).
+ */
+declare function detectStrategy(): Promise<VpStrategy | null>;
+/**
+ * Initialize Browser VP for a profile.
+ *
+ * This is the main entry point. It:
+ * 1. Detects the best strategy
+ * 2. Checks for existing state in IndexedDB
+ * 3. Returns a context object indicating readiness
+ *
+ * If not ready, the caller should trigger setup flow
+ * (passkey creation for PRF, or key generation for device-key).
+ */
+declare function initBrowserVp(profileId: string): Promise<BrowserVpContext | null>;
+
+export { type BindingEntry, type BrowserVpContext, type DerivedKeys, type ProfileState, type VerifiablePresentation, type VpRequest, type VpStrategy, clearAll, createPasskeyWithPrf, createVp, decrypt, deleteBinding, deleteProfileState, deriveKeysFromPrf, deriveWrappingKey, detectStrategy, encrypt, evaluatePrf, exportPublicKey, generateDataKey, generateDeviceKey, getExpiringSoon, hasPrfSupport, initBrowserVp, isIndexedDbAvailable, listBindings, loadBinding, loadProfileState, needsRenewal, saveBinding, saveProfileState, sha256, sign, unwrapSigningKey, wrapKey };