@backbay/glia 0.2.0-alpha.1

package/dist/speakeasy/SpeakeasyProvider.js

@@ -0,0 +1,249 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * SpeakeasyProvider
+ *
+ * React context that wires:
+ * - doorman state machine (Zustand)
+ * - auth verifier (gesture -> response)
+ * - capability token issuance
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
+import { startDoormanTimeouts, useDoormanStore } from './doorman/DoormanStateMachine.js';
+import { DEFAULT_DOORMAN_CONFIG } from './types.js';
+import { SpeakeasyAuth } from './auth/SpeakeasyAuth.js';
+import { createCapabilityToken } from './auth/CapabilityIssuer.js';
+import { isPanicGesture } from './doorman/panic.js';
+import { createDefaultDeviceSecretProvider, } from './auth/deviceSecret.js';
+// =============================================================================
+// Errors
+// =============================================================================
+/**
+ * Error thrown when an operation requires auth but device secret is not yet resolved.
+ */
+export class SpeakeasyNotReadyError extends Error {
+    constructor(operation) {
+        super(`[Speakeasy] ${operation}: device secret not yet resolved`);
+        this.name = 'SpeakeasyNotReadyError';
+    }
+}
+/**
+ * Asserts that auth is ready, throwing SpeakeasyNotReadyError if not.
+ * Use this for user-initiated operations that cannot silently fail.
+ */
+function assertAuthReady(auth, operation) {
+    if (!auth) {
+        throw new SpeakeasyNotReadyError(operation);
+    }
+}
+// =============================================================================
+// Context
+// =============================================================================
+/** Public context - safe for all components */
+const SpeakeasyPublicContext = createContext(null);
+/** Private context - only for trusted components handling sensitive data */
+const SpeakeasyPrivateContext = createContext(null);
+/** Legacy combined context (deprecated) */
+const SpeakeasyContext = createContext(null);
+export function SpeakeasyProvider({ children, doormanConfig, storage, domain, deviceSecret, deviceSecretProvider, issuer = 'bb-ui:speakeasy', scopes = ['speakeasy.*'], onAdmitted, onExit, }) {
+    const state = useDoormanStore((s) => s.state);
+    const capability = useDoormanStore((s) => s.capability);
+    const [resolvedDeviceSecret, setResolvedDeviceSecret] = useState(deviceSecret);
+    useEffect(() => {
+        let cancelled = false;
+        if (deviceSecret !== undefined) {
+            setResolvedDeviceSecret(deviceSecret);
+            return;
+        }
+        const provider = deviceSecretProvider ?? createDefaultDeviceSecretProvider();
+        provider.getOrCreateDeviceSecret().then((secret) => {
+            if (!cancelled)
+                setResolvedDeviceSecret(secret);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [deviceSecret, deviceSecretProvider]);
+    // Auth is only created once deviceSecret is resolved (prevents race condition)
+    const auth = useMemo(() => {
+        if (resolvedDeviceSecret === undefined) {
+            return null; // Not ready yet
+        }
+        return new SpeakeasyAuth({
+            storage,
+            domain,
+            deviceSecret: resolvedDeviceSecret,
+        });
+    }, [storage, domain, resolvedDeviceSecret]);
+    const [isRegistered, setIsRegistered] = useState(false);
+    const [tick, setTick] = useState(0);
+    // Apply config overrides
+    useEffect(() => {
+        if (!doormanConfig)
+            return;
+        useDoormanStore.getState().setConfig(doormanConfig);
+    }, [doormanConfig]);
+    // Start timeout management and reset state on unmount
+    useEffect(() => {
+        const cleanupTimeouts = startDoormanTimeouts();
+        return () => {
+            cleanupTimeouts();
+            useDoormanStore.getState().reset();
+        };
+    }, []);
+    // Load registration status (only when auth is ready)
+    useEffect(() => {
+        if (!auth) {
+            setIsRegistered(false);
+            return;
+        }
+        let cancelled = false;
+        auth.isRegistered().then((registered) => {
+            if (!cancelled)
+                setIsRegistered(registered);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [auth]);
+    // Basic tick to keep timeRemaining fresh for UI
+    useEffect(() => {
+        if (state !== 'CHALLENGED' &&
+            state !== 'COOLDOWN' &&
+            state !== 'LOCKED' &&
+            state !== 'ADMITTED') {
+            return;
+        }
+        const id = setInterval(() => setTick((t) => t + 1), 250);
+        return () => clearInterval(id);
+    }, [state]);
+    const knock = useCallback(() => {
+        useDoormanStore.getState().dispatch({ type: 'KNOCK_DETECTED', timestamp: Date.now() });
+    }, []);
+    const exit = useCallback(() => {
+        useDoormanStore.getState().dispatch({ type: 'EXIT_REQUESTED' });
+        onExit?.();
+    }, [onExit]);
+    const register = useCallback(async (gesture) => {
+        // User-initiated: throw if not ready
+        assertAuthReady(auth, 'register');
+        await auth.registerGesture(gesture);
+        setIsRegistered(true);
+    }, [auth]);
+    const clearRegistration = useCallback(async () => {
+        // User-initiated: throw if not ready
+        assertAuthReady(auth, 'clearRegistration');
+        await auth.clear();
+        setIsRegistered(false);
+    }, [auth]);
+    const submitGesture = useCallback(async (gesture) => {
+        // User-initiated: throw if not ready
+        assertAuthReady(auth, 'submitGesture');
+        const store = useDoormanStore.getState();
+        const challenge = store.challenge;
+        if (store.state !== 'CHALLENGED' || !challenge)
+            return;
+        // Atomically claim the VERIFYING state BEFORE any async work
+        // This prevents race conditions where multiple submissions could proceed
+        store.dispatch({ type: 'GESTURE_COMPLETE', gestureData: gesture });
+        // Re-check state after dispatch - if not VERIFYING, another submission won the race
+        if (useDoormanStore.getState().state !== 'VERIFYING') {
+            // Either challenge expired or another submission won the race; bail out
+            return;
+        }
+        // Now we have exclusive ownership of the VERIFYING state
+        // Check for panic gesture (must happen after claiming state to prevent bypass)
+        if (store.config.panicGestureEnabled && isPanicGesture(gesture)) {
+            store.dispatch({
+                type: 'PANIC_GESTURE',
+                decoyMode: store.config.panicAction === 'decoy',
+            });
+            return;
+        }
+        if (!(await auth.isRegistered())) {
+            // Not a failure attempt; just cancel the challenge.
+            store.dispatch({ type: 'EXIT_REQUESTED' });
+            return;
+        }
+        const result = await auth.verifyGesture(gesture, challenge);
+        if (!result.ok) {
+            store.dispatch({
+                type: 'VERIFICATION_FAILURE',
+                reason: result.reason ?? 'invalid',
+            });
+            return;
+        }
+        const verifier = await auth.getVerifier();
+        if (!verifier) {
+            store.dispatch({ type: 'VERIFICATION_FAILURE', reason: 'not_registered' });
+            return;
+        }
+        const config = store.config ?? DEFAULT_DOORMAN_CONFIG;
+        const token = await createCapabilityToken({
+            verifierKeyHex: verifier.hash,
+            issuer,
+            scopes,
+            ttlMs: config.admissionTtlMs,
+        });
+        store.dispatch({ type: 'VERIFICATION_SUCCESS', capability: token });
+        onAdmitted?.(token);
+    }, [auth, issuer, scopes, onAdmitted]);
+    const isReady = auth !== null;
+    const publicContextValue = useMemo(() => {
+        const store = useDoormanStore.getState();
+        return {
+            state,
+            isReady,
+            isAdmitted: state === 'ADMITTED',
+            isDecoy: state === 'DECOY',
+            knock,
+            exit,
+            timeRemaining: store.timeRemaining(),
+        };
+    }, [state, isReady, knock, exit, tick]);
+    const privateContextValue = useMemo(() => ({
+        capability,
+        isRegistered,
+        register,
+        clearRegistration,
+        submitGesture,
+    }), [capability, isRegistered, register, clearRegistration, submitGesture]);
+    // Combined context for legacy support
+    const contextValue = useMemo(() => ({
+        ...publicContextValue,
+        ...privateContextValue,
+    }), [publicContextValue, privateContextValue]);
+    return (_jsx(SpeakeasyPublicContext.Provider, { value: publicContextValue, children: _jsx(SpeakeasyPrivateContext.Provider, { value: privateContextValue, children: _jsx(SpeakeasyContext.Provider, { value: contextValue, children: children }) }) }));
+}
+/**
+ * Hook for public speakeasy state - safe for all components.
+ * Use this when you only need to read state or trigger knock/exit.
+ */
+export function useSpeakeasyPublic() {
+    const ctx = useContext(SpeakeasyPublicContext);
+    if (!ctx) {
+        throw new Error('useSpeakeasyPublic must be used within a SpeakeasyProvider');
+    }
+    return ctx;
+}
+/**
+ * Hook for private speakeasy state - only for trusted components.
+ * Use this when you need access to capability tokens or registration.
+ */
+export function useSpeakeasyPrivate() {
+    const ctx = useContext(SpeakeasyPrivateContext);
+    if (!ctx) {
+        throw new Error('useSpeakeasyPrivate must be used within a SpeakeasyProvider');
+    }
+    return ctx;
+}
+/**
+ * Combined hook for full speakeasy context.
+ * @deprecated Use useSpeakeasyPublic() or useSpeakeasyPrivate() for better security isolation.
+ */
+export function useSpeakeasy() {
+    const ctx = useContext(SpeakeasyContext);
+    if (!ctx) {
+        throw new Error('useSpeakeasy must be used within a SpeakeasyProvider');
+    }
+    return ctx;
+}

package/dist/speakeasy/auth/CapabilityIssuer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CapabilityIssuer (MVP)
+ *
+ * Issues locally-verifiable capability tokens using HMAC-SHA256.
+ *
+ * This intentionally mirrors the structure of Backbay capability tokens, but
+ * avoids adding Ed25519 dependencies inside bb-ui.
+ */
+import type { CapabilityToken } from '../types.js';
+export declare function createCapabilityToken(options: {
+    verifierKeyHex: string;
+    issuer: string;
+    scopes: string[];
+    ttlMs: number;
+    constraints?: CapabilityToken['constraints'];
+}): Promise<CapabilityToken>;
+export declare function verifyCapabilityToken(options: {
+    token: CapabilityToken;
+    verifierKeyHex: string;
+    now?: number;
+}): Promise<boolean>;
+//# sourceMappingURL=CapabilityIssuer.d.ts.map

package/dist/speakeasy/auth/CapabilityIssuer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityIssuer.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/auth/CapabilityIssuer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AA2BnD,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IACnD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;CAC9C,GAAG,OAAO,CAAC,eAAe,CAAC,CAqB3B;AAED,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IACnD,KAAK,EAAE,eAAe,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBnB"}

package/dist/speakeasy/auth/CapabilityIssuer.js

@@ -0,0 +1,70 @@
+/**
+ * CapabilityIssuer (MVP)
+ *
+ * Issues locally-verifiable capability tokens using HMAC-SHA256.
+ *
+ * This intentionally mirrors the structure of Backbay capability tokens, but
+ * avoids adding Ed25519 dependencies inside bb-ui.
+ */
+import { bytesToHex, hmacSha256, randomHex, timingSafeEqual, utf8ToBytes, hexToBytes } from './crypto.js';
+function createTokenId() {
+    try {
+        if (typeof globalThis.crypto !== 'undefined' && typeof globalThis.crypto.randomUUID === 'function') {
+            return globalThis.crypto.randomUUID();
+        }
+    }
+    catch {
+        // ignore
+    }
+    return randomHex(16);
+}
+function canonicalizePayload(payload) {
+    // Ensure stable key order by constructing a new object in fixed order.
+    const canonical = {
+        tokenId: payload.tokenId,
+        issuer: payload.issuer,
+        scopes: payload.scopes,
+        notBefore: payload.notBefore,
+        expiresAt: payload.expiresAt,
+        constraints: payload.constraints,
+    };
+    return JSON.stringify(canonical);
+}
+export async function createCapabilityToken(options) {
+    const notBefore = Date.now();
+    const expiresAt = notBefore + options.ttlMs;
+    const payload = {
+        tokenId: createTokenId(),
+        issuer: options.issuer,
+        scopes: options.scopes,
+        notBefore,
+        expiresAt,
+        constraints: options.constraints,
+    };
+    const msg = utf8ToBytes(canonicalizePayload(payload));
+    const keyBytes = hexToBytes(options.verifierKeyHex);
+    const sigBytes = await hmacSha256(keyBytes, msg);
+    return {
+        ...payload,
+        signature: bytesToHex(sigBytes),
+    };
+}
+export async function verifyCapabilityToken(options) {
+    const { token, verifierKeyHex } = options;
+    const now = options.now ?? Date.now();
+    if (now < token.notBefore || now > token.expiresAt)
+        return false;
+    const payload = {
+        tokenId: token.tokenId,
+        issuer: token.issuer,
+        scopes: token.scopes,
+        notBefore: token.notBefore,
+        expiresAt: token.expiresAt,
+        constraints: token.constraints,
+    };
+    const msg = utf8ToBytes(canonicalizePayload(payload));
+    const keyBytes = hexToBytes(verifierKeyHex);
+    const expected = await hmacSha256(keyBytes, msg);
+    const actual = hexToBytes(token.signature);
+    return timingSafeEqual(expected, actual);
+}

package/dist/speakeasy/auth/SpeakeasyAuth.d.ts

@@ -0,0 +1,43 @@
+/**
+ * SpeakeasyAuth
+ *
+ * MVP "doorman" verifier that:
+ * - stores a derived verifier key (not raw gestures)
+ * - verifies gesture-derived responses against stored verifier
+ *
+ * Note: In the MVP, leakage of the stored verifier key compromises the ritual.
+ */
+import type { Challenge, GestureSequence, Verifier } from '../types.js';
+import type { SpeakeasyStorage } from './storage.js';
+export interface SpeakeasyAuthVerifyResult {
+    ok: boolean;
+    reason?: 'not_registered' | 'domain_mismatch' | 'invalid_gesture';
+    response?: string;
+}
+export interface SpeakeasyAuthOptions {
+    storage?: SpeakeasyStorage;
+    /**
+     * Domain binding for anti-phishing. Defaults to `location.origin` when available.
+     */
+    domain?: string;
+    /**
+     * Optional device-bound secret (host-provided). This should NOT be the raw gesture.
+     */
+    deviceSecret?: string | Uint8Array;
+}
+export declare function fingerprintGestureSequence(sequence: GestureSequence): string;
+export declare class SpeakeasyAuth {
+    private readonly storage;
+    private readonly domain;
+    private readonly deviceSecret;
+    constructor(options: SpeakeasyAuthOptions & {
+        deviceSecret: string | Uint8Array;
+    });
+    getVerifier(): Promise<Verifier | null>;
+    isRegistered(): Promise<boolean>;
+    clear(): Promise<void>;
+    registerGesture(sequence: GestureSequence): Promise<Verifier>;
+    computeResponse(sequence: GestureSequence, challenge: Challenge): Promise<string>;
+    verifyGesture(sequence: GestureSequence, challenge: Challenge): Promise<SpeakeasyAuthVerifyResult>;
+}
+//# sourceMappingURL=SpeakeasyAuth.d.ts.map

package/dist/speakeasy/auth/SpeakeasyAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeakeasyAuth.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/auth/SpeakeasyAuth.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAe,QAAQ,EAAE,MAAM,aAAa,CAAC;AAWrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CACpC;AAyCD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAE5E;AA6BD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAa;gBAE9B,OAAO,EAAE,oBAAoB,GAAG;QAAE,YAAY,EAAE,MAAM,GAAG,UAAU,CAAA;KAAE;IAO3E,WAAW,IAAI,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IAIvC,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAIhC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAsB7D,eAAe,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IAgBjF,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,yBAAyB,CAAC;CA4BzG"}

package/dist/speakeasy/auth/SpeakeasyAuth.js

@@ -0,0 +1,147 @@
+/**
+ * SpeakeasyAuth
+ *
+ * MVP "doorman" verifier that:
+ * - stores a derived verifier key (not raw gestures)
+ * - verifies gesture-derived responses against stored verifier
+ *
+ * Note: In the MVP, leakage of the stored verifier key compromises the ritual.
+ */
+import { bytesToHex, concatBytes, hmacSha256, randomHex, sha256, timingSafeEqual, utf8ToBytes, hexToBytes, } from './crypto.js';
+import { createDefaultSpeakeasyStorage } from './storage.js';
+function defaultDomain() {
+    if (typeof globalThis.location !== 'undefined' && globalThis.location?.origin) {
+        return globalThis.location.origin;
+    }
+    return 'unknown';
+}
+function normalizeDeviceSecret(secret) {
+    if (!secret) {
+        throw new Error('[Speakeasy] deviceSecret is required for secure verifier derivation');
+    }
+    if (typeof secret === 'string')
+        return utf8ToBytes(secret);
+    return secret;
+}
+function canonicalizeGestureStep(step) {
+    switch (step.type) {
+        case 'tap':
+            return `tap:${step.count}:${step.region}`;
+        case 'hold': {
+            const durationBucket = Math.round(step.durationMs / 50) * 50;
+            return `hold:${durationBucket}:${step.region}`;
+        }
+        case 'radial_drag': {
+            const from = Math.round(step.fromAngle);
+            const to = Math.round(step.toAngle);
+            return `radial:${from}:${to}:${step.notches}`;
+        }
+        case 'flick': {
+            const velocityBucket = Math.round(step.velocity * 100) / 100;
+            return `flick:${step.direction}:${velocityBucket}`;
+        }
+    }
+}
+function canonicalizeGestureSequence(sequence) {
+    return sequence.steps.map(canonicalizeGestureStep).join('|');
+}
+export function fingerprintGestureSequence(sequence) {
+    return canonicalizeGestureSequence(sequence);
+}
+function buildChallengeMessage(challenge, rhythmHash) {
+    // Validate nonce format: 32 bytes = 64 hex characters
+    if (!/^[0-9a-fA-F]{64}$/.test(challenge.nonce)) {
+        throw new Error('[Speakeasy] Invalid nonce: expected 64 hex characters');
+    }
+    // Validate salt format: 16 bytes = 32 hex characters
+    if (!/^[0-9a-fA-F]{32}$/.test(challenge.salt)) {
+        throw new Error('[Speakeasy] Invalid salt: expected 32 hex characters');
+    }
+    // Keep this stable and versioned. Avoid including raw step values.
+    const message = `bb-ui:speakeasy:v1|nonce:${challenge.nonce}|salt:${challenge.salt}|rhythm:${rhythmHash}`;
+    return utf8ToBytes(message);
+}
+async function deriveVerifierKeyBytes(options) {
+    const canonical = canonicalizeGestureSequence(options.sequence);
+    const header = `bb-ui:speakeasy:verifier:v1|domain:${options.domain}|salt:${options.verifierSaltHex}|`;
+    const data = concatBytes(utf8ToBytes(header + canonical), options.deviceSecret);
+    return sha256(data);
+}
+export class SpeakeasyAuth {
+    storage;
+    domain;
+    deviceSecret;
+    constructor(options) {
+        // Validate deviceSecret at construction time - fail fast
+        this.deviceSecret = normalizeDeviceSecret(options.deviceSecret);
+        this.storage = options?.storage ?? createDefaultSpeakeasyStorage({ deviceSecret: this.deviceSecret });
+        this.domain = options?.domain ?? defaultDomain();
+    }
+    async getVerifier() {
+        return this.storage.getVerifier();
+    }
+    async isRegistered() {
+        return (await this.getVerifier()) !== null;
+    }
+    async clear() {
+        await this.storage.clearVerifier();
+    }
+    async registerGesture(sequence) {
+        const salt = randomHex(16);
+        const domain = this.domain;
+        const keyBytes = await deriveVerifierKeyBytes({
+            sequence,
+            domain,
+            verifierSaltHex: salt,
+            deviceSecret: this.deviceSecret,
+        });
+        const verifier = {
+            hash: bytesToHex(keyBytes),
+            salt,
+            domain,
+            createdAt: Date.now(),
+            version: 1,
+        };
+        await this.storage.setVerifier(verifier);
+        return verifier;
+    }
+    async computeResponse(sequence, challenge) {
+        const verifier = await this.getVerifier();
+        if (!verifier) {
+            throw new Error('[Speakeasy] Not registered');
+        }
+        const keyBytes = await deriveVerifierKeyBytes({
+            sequence,
+            domain: verifier.domain,
+            verifierSaltHex: verifier.salt,
+            deviceSecret: this.deviceSecret,
+        });
+        const messageBytes = buildChallengeMessage(challenge, sequence.rhythmHash);
+        const responseBytes = await hmacSha256(keyBytes, messageBytes);
+        return bytesToHex(responseBytes);
+    }
+    async verifyGesture(sequence, challenge) {
+        const verifier = await this.getVerifier();
+        if (!verifier) {
+            return { ok: false, reason: 'not_registered' };
+        }
+        if (verifier.domain !== this.domain) {
+            return { ok: false, reason: 'domain_mismatch' };
+        }
+        const storedKeyBytes = hexToBytes(verifier.hash);
+        const keyBytes = await deriveVerifierKeyBytes({
+            sequence,
+            domain: verifier.domain,
+            verifierSaltHex: verifier.salt,
+            deviceSecret: this.deviceSecret,
+        });
+        const messageBytes = buildChallengeMessage(challenge, sequence.rhythmHash);
+        const expected = await hmacSha256(storedKeyBytes, messageBytes);
+        const response = await hmacSha256(keyBytes, messageBytes);
+        const ok = timingSafeEqual(expected, response);
+        if (!ok) {
+            return { ok: false, reason: 'invalid_gesture' };
+        }
+        return { ok: true, response: bytesToHex(response) };
+    }
+}

package/dist/speakeasy/auth/crypto.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Speakeasy crypto helpers (browser-first WebCrypto)
+ */
+export declare function utf8ToBytes(value: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+export declare function randomHex(byteLength: number): string;
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare function sha256(data: Uint8Array): Promise<Uint8Array>;
+export declare function hmacSha256(keyBytes: Uint8Array, messageBytes: Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/speakeasy/auth/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/auth/crypto.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAErD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAIpD;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAUlD;AAED,wBAAgB,WAAW,CAAC,GAAG,KAAK,EAAE,UAAU,EAAE,GAAG,UAAU,CAS9D;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAUpD;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAOrE;AAUD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAIlE;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,UAAU,EACpB,YAAY,EAAE,UAAU,GACvB,OAAO,CAAC,UAAU,CAAC,CAWrB"}

package/dist/speakeasy/auth/crypto.js

@@ -0,0 +1,68 @@
+/**
+ * Speakeasy crypto helpers (browser-first WebCrypto)
+ */
+export function utf8ToBytes(value) {
+    return new TextEncoder().encode(value);
+}
+export function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+export function hexToBytes(hex) {
+    const normalized = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (normalized.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(normalized)) {
+        throw new Error('[Speakeasy] Invalid hex');
+    }
+    const out = new Uint8Array(normalized.length / 2);
+    for (let i = 0; i < out.length; i += 1) {
+        out[i] = Number.parseInt(normalized.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+export function concatBytes(...parts) {
+    const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+export function randomHex(byteLength) {
+    if (typeof globalThis.crypto === 'undefined' ||
+        typeof globalThis.crypto.getRandomValues !== 'function') {
+        throw new Error('[Speakeasy] crypto.getRandomValues is required');
+    }
+    const bytes = new Uint8Array(byteLength);
+    globalThis.crypto.getRandomValues(bytes);
+    return bytesToHex(bytes);
+}
+export function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}
+async function requireSubtle() {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        throw new Error('[Speakeasy] crypto.subtle is required');
+    }
+    return subtle;
+}
+export async function sha256(data) {
+    const subtle = await requireSubtle();
+    const hash = await subtle.digest('SHA-256', data);
+    return new Uint8Array(hash);
+}
+export async function hmacSha256(keyBytes, messageBytes) {
+    const subtle = await requireSubtle();
+    const key = await subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const sig = await subtle.sign('HMAC', key, messageBytes);
+    return new Uint8Array(sig);
+}

package/dist/speakeasy/auth/deviceSecret.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Device secret provider
+ *
+ * Hosts can implement this using a keychain/secure enclave and inject it into
+ * SpeakeasyProvider / SpeakeasyConsentDialog.
+ */
+export interface SpeakeasyDeviceSecretProvider {
+    getOrCreateDeviceSecret: () => Promise<Uint8Array>;
+    clearDeviceSecret: () => Promise<void>;
+}
+export declare function createInMemoryDeviceSecretProvider(): SpeakeasyDeviceSecretProvider;
+export declare function createLocalStorageDeviceSecretProvider(options?: {
+    key?: string;
+}): SpeakeasyDeviceSecretProvider;
+export declare function createDefaultDeviceSecretProvider(): SpeakeasyDeviceSecretProvider;
+export declare function encodeDeviceSecretHex(secret: Uint8Array): string;
+//# sourceMappingURL=deviceSecret.d.ts.map

package/dist/speakeasy/auth/deviceSecret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceSecret.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/auth/deviceSecret.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,6BAA6B;IAC5C,uBAAuB,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACnD,iBAAiB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED,wBAAgB,kCAAkC,IAAI,6BAA6B,CAalF;AAED,wBAAgB,sCAAsC,CAAC,OAAO,CAAC,EAAE;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,6BAA6B,CAyBhC;AAED,wBAAgB,iCAAiC,IAAI,6BAA6B,CASjF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEhE"}