@backbay/glia 0.2.0-alpha.1

package/dist/speakeasy/hooks/useGestureRecognizer.js

@@ -0,0 +1,337 @@
+/**
+ * useGestureRecognizer - Hook for capturing speakeasy gesture sequences
+ *
+ * Recognizes:
+ * - Tap sequences (single, double, triple+)
+ * - Hold gestures (with configurable threshold)
+ * - Radial drags (angle calculation, notch detection)
+ * - Flicks (direction + velocity)
+ *
+ * Outputs a GestureSequence with timing data for verification.
+ */
+import { useCallback, useRef, useState } from 'react';
+import { DEFAULT_GESTURE_CONFIG, } from '../types.js';
+/**
+ * Calculate distance between two points
+ */
+function distance(a, b) {
+    return Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+}
+/**
+ * Calculate angle from center to point (degrees, 0 = right, CCW positive)
+ */
+function angleFromCenter(center, point) {
+    const dx = point.x - center.x;
+    const dy = center.y - point.y; // Flip Y for standard math coords
+    const radians = Math.atan2(dy, dx);
+    return ((radians * 180) / Math.PI + 360) % 360;
+}
+/**
+ * Determine region (center vs edge) based on distance from center
+ */
+function getRegion(center, point, threshold) {
+    return distance(center, point) < threshold ? 'center' : 'edge';
+}
+/**
+ * Calculate rhythm hash from timing intervals (anti-replay)
+ */
+async function calculateRhythmHash(timings) {
+    const data = new TextEncoder().encode(timings.join(','));
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        throw new Error('[Speakeasy] crypto.subtle is required');
+    }
+    const hashBuffer = await subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+export function useGestureRecognizer(options) {
+    const config = { ...DEFAULT_GESTURE_CONFIG, ...options.config };
+    const { centerRef, onGestureComplete, onGestureStart, onGestureStep } = options;
+    // State
+    const [state, setState] = useState({
+        isActive: false,
+        startPoint: null,
+        currentPoint: null,
+        startTime: null,
+        steps: [],
+        pendingTapCount: 0,
+    });
+    // Refs for tracking across events
+    const stepsRef = useRef([]);
+    const timingsRef = useRef([]);
+    const captureStartRef = useRef(null);
+    const pointerStartRef = useRef(null);
+    const lastTapTimeRef = useRef(0);
+    const tapCountRef = useRef(0);
+    const tapTimeoutRef = useRef(null);
+    const isDraggingRef = useRef(false);
+    const dragStartAngleRef = useRef(null);
+    const notchesHitRef = useRef(new Set());
+    /**
+     * Get center point of the orb
+     */
+    const getCenter = useCallback(() => {
+        if (!centerRef.current) {
+            return { x: 0, y: 0 };
+        }
+        const rect = centerRef.current.getBoundingClientRect();
+        return {
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2,
+        };
+    }, [centerRef]);
+    /**
+     * Add a step to the sequence
+     */
+    const addStep = useCallback((step) => {
+        stepsRef.current.push(step);
+        timingsRef.current.push(Date.now() - (captureStartRef.current || Date.now()));
+        setState((s) => ({ ...s, steps: [...stepsRef.current] }));
+        onGestureStep?.(step);
+    }, [onGestureStep]);
+    /**
+     * Start capturing a new gesture sequence
+     */
+    const startCapture = useCallback(() => {
+        stepsRef.current = [];
+        timingsRef.current = [];
+        captureStartRef.current = Date.now();
+        tapCountRef.current = 0;
+        setState({
+            isActive: true,
+            startPoint: null,
+            currentPoint: null,
+            startTime: Date.now(),
+            steps: [],
+            pendingTapCount: 0,
+        });
+        onGestureStart?.();
+    }, [onGestureStart]);
+    /**
+     * End capture and return the sequence
+     */
+    const endCapture = useCallback(async () => {
+        const captureStart = captureStartRef.current;
+        if (!captureStart)
+            return null;
+        // Flush any pending taps
+        if (tapCountRef.current > 0 && tapTimeoutRef.current) {
+            clearTimeout(tapTimeoutRef.current);
+            tapTimeoutRef.current = null;
+            const center = getCenter();
+            const lastPoint = pointerStartRef.current?.point || center;
+            const region = getRegion(center, lastPoint, (centerRef.current?.clientWidth || 64) / 3);
+            addStep({ type: 'tap', count: tapCountRef.current, region });
+            tapCountRef.current = 0;
+        }
+        const totalDurationMs = Date.now() - captureStart;
+        const rhythmHash = await calculateRhythmHash(timingsRef.current);
+        const sequence = {
+            steps: [...stepsRef.current],
+            totalDurationMs,
+            rhythmHash,
+            timestamp: captureStart,
+        };
+        onGestureComplete?.(sequence);
+        captureStartRef.current = null;
+        pointerStartRef.current = null;
+        isDraggingRef.current = false;
+        dragStartAngleRef.current = null;
+        notchesHitRef.current.clear();
+        setState((s) => ({
+            ...s,
+            isActive: false,
+            startPoint: null,
+            currentPoint: null,
+            startTime: null,
+            pendingTapCount: 0,
+        }));
+        return sequence;
+    }, [getCenter, centerRef, addStep, onGestureComplete]);
+    /**
+     * Reset without emitting
+     */
+    const reset = useCallback(() => {
+        if (tapTimeoutRef.current)
+            clearTimeout(tapTimeoutRef.current);
+        stepsRef.current = [];
+        timingsRef.current = [];
+        captureStartRef.current = null;
+        pointerStartRef.current = null;
+        tapCountRef.current = 0;
+        isDraggingRef.current = false;
+        dragStartAngleRef.current = null;
+        notchesHitRef.current.clear();
+        setState({
+            isActive: false,
+            startPoint: null,
+            currentPoint: null,
+            startTime: null,
+            steps: [],
+            pendingTapCount: 0,
+        });
+    }, []);
+    /**
+     * Handle pointer down
+     */
+    const onPointerDown = useCallback((e) => {
+        if (!state.isActive)
+            return;
+        try {
+            e.currentTarget.setPointerCapture(e.pointerId);
+        }
+        catch {
+            // Ignore if pointer capture isn't supported
+        }
+        const point = { x: e.clientX, y: e.clientY };
+        const now = Date.now();
+        pointerStartRef.current = { point, time: now };
+        isDraggingRef.current = false;
+        notchesHitRef.current.clear();
+        const center = getCenter();
+        dragStartAngleRef.current = angleFromCenter(center, point);
+        const notch = Math.floor(dragStartAngleRef.current / config.radialNotchDegrees);
+        notchesHitRef.current.add(notch);
+        setState((s) => ({ ...s, startPoint: point, currentPoint: point }));
+    }, [state.isActive, config.radialNotchDegrees, getCenter]);
+    /**
+     * Handle pointer move
+     */
+    const onPointerMove = useCallback((e) => {
+        if (!state.isActive || !pointerStartRef.current)
+            return;
+        const point = { x: e.clientX, y: e.clientY };
+        const center = getCenter();
+        const dist = distance(pointerStartRef.current.point, point);
+        // Check if this is now a drag
+        if (!isDraggingRef.current && dist > config.dragMinDistancePx) {
+            isDraggingRef.current = true;
+        }
+        // Track radial notches during drag
+        if (isDraggingRef.current && dragStartAngleRef.current !== null) {
+            const currentAngle = angleFromCenter(center, point);
+            const notch = Math.floor(currentAngle / config.radialNotchDegrees);
+            notchesHitRef.current.add(notch);
+        }
+        setState((s) => ({ ...s, currentPoint: point }));
+    }, [state.isActive, config, getCenter]);
+    /**
+     * Handle pointer up
+     */
+    const onPointerUp = useCallback((e) => {
+        if (!state.isActive || !pointerStartRef.current)
+            return;
+        try {
+            e.currentTarget.releasePointerCapture(e.pointerId);
+        }
+        catch {
+            // Ignore if pointer capture wasn't active
+        }
+        const point = { x: e.clientX, y: e.clientY };
+        const now = Date.now();
+        const duration = now - pointerStartRef.current.time;
+        const dist = distance(pointerStartRef.current.point, point);
+        const center = getCenter();
+        if (isDraggingRef.current) {
+            // Was a drag - check for radial or flick
+            const velocity = dist / duration;
+            if (velocity > config.flickMinVelocity && duration < config.tapMaxDurationMs * 2) {
+                // Flick
+                const dx = point.x - pointerStartRef.current.point.x;
+                const dy = point.y - pointerStartRef.current.point.y;
+                let direction;
+                if (Math.abs(dx) > Math.abs(dy)) {
+                    direction = dx > 0 ? 'right' : 'left';
+                }
+                else {
+                    direction = dy > 0 ? 'down' : 'up';
+                }
+                addStep({ type: 'flick', direction, velocity });
+            }
+            else if (notchesHitRef.current.size > 1) {
+                // Radial drag
+                const fromAngle = dragStartAngleRef.current || 0;
+                const toAngle = angleFromCenter(center, point);
+                addStep({
+                    type: 'radial_drag',
+                    fromAngle,
+                    toAngle,
+                    notches: notchesHitRef.current.size,
+                });
+            }
+        }
+        else if (duration >= config.holdMinDurationMs && dist < config.tapMaxMovementPx) {
+            // Hold
+            const region = getRegion(center, point, (centerRef.current?.clientWidth || 64) / 3);
+            addStep({
+                type: 'hold',
+                durationMs: duration,
+                region,
+            });
+        }
+        else if (duration < config.tapMaxDurationMs && dist < config.tapMaxMovementPx) {
+            // Tap
+            if (tapTimeoutRef.current) {
+                clearTimeout(tapTimeoutRef.current);
+            }
+            const timeSinceLastTap = now - lastTapTimeRef.current;
+            if (timeSinceLastTap < config.tapIntervalMs) {
+                tapCountRef.current++;
+            }
+            else {
+                // Emit previous tap sequence if any
+                if (tapCountRef.current > 0) {
+                    const region = getRegion(center, point, (centerRef.current?.clientWidth || 64) / 3);
+                    addStep({ type: 'tap', count: tapCountRef.current, region });
+                }
+                tapCountRef.current = 1;
+            }
+            lastTapTimeRef.current = now;
+            // Wait for potential multi-tap
+            tapTimeoutRef.current = setTimeout(() => {
+                if (tapCountRef.current > 0) {
+                    const region = getRegion(center, point, (centerRef.current?.clientWidth || 64) / 3);
+                    addStep({ type: 'tap', count: tapCountRef.current, region });
+                    tapCountRef.current = 0;
+                }
+            }, config.tapIntervalMs);
+            setState((s) => ({ ...s, pendingTapCount: tapCountRef.current }));
+        }
+        // Reset pointer tracking
+        pointerStartRef.current = null;
+        isDraggingRef.current = false;
+        dragStartAngleRef.current = null;
+        notchesHitRef.current.clear();
+        setState((s) => ({ ...s, startPoint: null, currentPoint: null }));
+    }, [state.isActive, config, getCenter, centerRef, addStep]);
+    /**
+     * Handle pointer cancel
+     */
+    const onPointerCancel = useCallback((e) => {
+        try {
+            e.currentTarget.releasePointerCapture(e.pointerId);
+        }
+        catch {
+            // Ignore if pointer capture wasn't active
+        }
+        pointerStartRef.current = null;
+        isDraggingRef.current = false;
+        setState((s) => ({ ...s, startPoint: null, currentPoint: null }));
+    }, []);
+    return {
+        state,
+        steps: state.steps,
+        isCapturing: state.isActive,
+        handlers: {
+            onPointerDown,
+            onPointerMove,
+            onPointerUp,
+            onPointerCancel,
+        },
+        startCapture,
+        endCapture,
+        reset,
+    };
+}
+export default useGestureRecognizer;

package/dist/speakeasy/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Speakeasy - Gesture-based authentication ritual
+ *
+ * A "universal digital speakeasy doorman" interaction that gates entry
+ * into a privileged UI/runtime mode via gesture-based signatures.
+ *
+ * @example
+ * ```tsx
+ * import { SpeakeasyProvider, useSpeakeasy, SpeakeasyOrb } from '@backbay/glia/speakeasy';
+ *
+ * function App() {
+ *   return (
+ *     <SpeakeasyProvider>
+ *       <Desktop />
+ *       <SpeakeasyOrb />
+ *     </SpeakeasyProvider>
+ *   );
+ * }
+ *
+ * function SecretPanel() {
+ *   const { isAdmitted, knock } = useSpeakeasy();
+ *
+ *   if (!isAdmitted) {
+ *     return <button onClick={knock}>Request Access</button>;
+ *   }
+ *
+ *   return <div>Secret content revealed!</div>;
+ * }
+ * ```
+ */
+export * from './types.js';
+export { useGestureRecognizer } from './hooks/useGestureRecognizer.js';
+export { useDoormanStore, startDoormanTimeouts, } from './doorman/DoormanStateMachine.js';
+export { SpeakeasyProvider, useSpeakeasy } from './SpeakeasyProvider.js';
+export { SpeakeasyOrb } from './components/SpeakeasyOrb.js';
+export { SpeakeasyRitualPad } from './components/SpeakeasyRitualPad.js';
+export { SpeakeasyRegistrationDialog } from './components/SpeakeasyRegistrationDialog.js';
+export { SpeakeasyConsentDialog } from './components/SpeakeasyConsentDialog.js';
+export { SpeakeasyAuth } from './auth/SpeakeasyAuth.js';
+export { fingerprintGestureSequence } from './auth/SpeakeasyAuth.js';
+export { createCapabilityToken, verifyCapabilityToken, } from './auth/CapabilityIssuer.js';
+export type { SpeakeasyStorage } from './auth/storage.js';
+export { createDefaultSpeakeasyStorage, createIndexedDbSpeakeasyStorage, createInMemorySpeakeasyStorage, createLocalStorageSpeakeasyStorage, createEncryptedSpeakeasyStorage, createEncryptedIndexedDbSpeakeasyStorage, createEncryptedLocalStorageSpeakeasyStorage, } from './auth/storage.js';
+export type { SpeakeasyDeviceSecretProvider } from './auth/deviceSecret.js';
+export { createDefaultDeviceSecretProvider, createInMemoryDeviceSecretProvider, createLocalStorageDeviceSecretProvider, } from './auth/deviceSecret.js';
+export { DEFAULT_PANIC_GESTURE_PATTERN, isPanicGesture, } from './doorman/panic.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/speakeasy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/speakeasy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAGvE,OAAO,EACL,eAAe,EACf,oBAAoB,GACrB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGzE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,2BAA2B,EAAE,MAAM,6CAA6C,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAGhF,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EACL,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EACL,6BAA6B,EAC7B,+BAA+B,EAC/B,8BAA8B,EAC9B,kCAAkC,EAElC,+BAA+B,EAC/B,wCAAwC,EACxC,2CAA2C,GAC5C,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EACL,iCAAiC,EACjC,kCAAkC,EAClC,sCAAsC,GACvC,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,6BAA6B,EAC7B,cAAc,GACf,MAAM,oBAAoB,CAAC"}

package/dist/speakeasy/index.js

@@ -0,0 +1,53 @@
+/**
+ * Speakeasy - Gesture-based authentication ritual
+ *
+ * A "universal digital speakeasy doorman" interaction that gates entry
+ * into a privileged UI/runtime mode via gesture-based signatures.
+ *
+ * @example
+ * ```tsx
+ * import { SpeakeasyProvider, useSpeakeasy, SpeakeasyOrb } from '@backbay/glia/speakeasy';
+ *
+ * function App() {
+ *   return (
+ *     <SpeakeasyProvider>
+ *       <Desktop />
+ *       <SpeakeasyOrb />
+ *     </SpeakeasyProvider>
+ *   );
+ * }
+ *
+ * function SecretPanel() {
+ *   const { isAdmitted, knock } = useSpeakeasy();
+ *
+ *   if (!isAdmitted) {
+ *     return <button onClick={knock}>Request Access</button>;
+ *   }
+ *
+ *   return <div>Secret content revealed!</div>;
+ * }
+ * ```
+ */
+// Types
+export * from './types.js';
+// Hooks
+export { useGestureRecognizer } from './hooks/useGestureRecognizer.js';
+// State Machine
+export { useDoormanStore, startDoormanTimeouts, } from './doorman/DoormanStateMachine.js';
+// Provider
+export { SpeakeasyProvider, useSpeakeasy } from './SpeakeasyProvider.js';
+// Components
+export { SpeakeasyOrb } from './components/SpeakeasyOrb.js';
+export { SpeakeasyRitualPad } from './components/SpeakeasyRitualPad.js';
+export { SpeakeasyRegistrationDialog } from './components/SpeakeasyRegistrationDialog.js';
+export { SpeakeasyConsentDialog } from './components/SpeakeasyConsentDialog.js';
+// Auth
+export { SpeakeasyAuth } from './auth/SpeakeasyAuth.js';
+export { fingerprintGestureSequence } from './auth/SpeakeasyAuth.js';
+export { createCapabilityToken, verifyCapabilityToken, } from './auth/CapabilityIssuer.js';
+export { createDefaultSpeakeasyStorage, createIndexedDbSpeakeasyStorage, createInMemorySpeakeasyStorage, createLocalStorageSpeakeasyStorage, 
+// Encrypted storage (AES-256-GCM with PBKDF2)
+createEncryptedSpeakeasyStorage, createEncryptedIndexedDbSpeakeasyStorage, createEncryptedLocalStorageSpeakeasyStorage, } from './auth/storage.js';
+export { createDefaultDeviceSecretProvider, createInMemoryDeviceSecretProvider, createLocalStorageDeviceSecretProvider, } from './auth/deviceSecret.js';
+// Panic ritual
+export { DEFAULT_PANIC_GESTURE_PATTERN, isPanicGesture, } from './doorman/panic.js';

package/dist/speakeasy/types.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Speakeasy Doorman - Type Definitions
+ *
+ * Gesture-based authentication ritual for gating entry into privileged UI/runtime mode.
+ */
+export type GestureStepType = 'tap' | 'hold' | 'radial_drag' | 'flick';
+export interface TapStep {
+    type: 'tap';
+    count: number;
+    region: 'center' | 'edge';
+}
+export interface HoldStep {
+    type: 'hold';
+    durationMs: number;
+    region: 'center' | 'edge';
+}
+export interface RadialDragStep {
+    type: 'radial_drag';
+    fromAngle: number;
+    toAngle: number;
+    notches: number;
+}
+export interface FlickStep {
+    type: 'flick';
+    direction: 'up' | 'down' | 'left' | 'right';
+    velocity: number;
+}
+export type GestureStep = TapStep | HoldStep | RadialDragStep | FlickStep;
+export interface GestureSequence {
+    steps: GestureStep[];
+    totalDurationMs: number;
+    rhythmHash: string;
+    timestamp: number;
+}
+export type DoormanState = 'IDLE' | 'CHALLENGED' | 'VERIFYING' | 'ADMITTED' | 'DECOY' | 'COOLDOWN' | 'LOCKED';
+export type DoormanEvent = {
+    type: 'KNOCK_DETECTED';
+    timestamp: number;
+} | {
+    type: 'GESTURE_COMPLETE';
+    gestureData: GestureSequence;
+} | {
+    type: 'VERIFICATION_SUCCESS';
+    capability: CapabilityToken;
+} | {
+    type: 'VERIFICATION_FAILURE';
+    reason: string;
+} | {
+    type: 'CHALLENGE_TIMEOUT';
+} | {
+    type: 'COOLDOWN_ELAPSED';
+} | {
+    type: 'LOCK_EXPIRED';
+} | {
+    type: 'EXIT_REQUESTED';
+} | {
+    type: 'ADMISSION_TIMEOUT';
+} | {
+    type: 'PANIC_GESTURE';
+    decoyMode: boolean;
+};
+export interface DoormanConfig {
+    challengeWindowMs: number;
+    admissionTtlMs: number;
+    decoyTtlMs: number;
+    maxConsecutiveFailures: number;
+    cooldownBaseMs: number;
+    lockDurationMs: number;
+    panicGestureEnabled: boolean;
+    panicAction: 'lock' | 'decoy';
+    panicLockMultiplier: number;
+}
+export declare const DEFAULT_DOORMAN_CONFIG: DoormanConfig;
+export interface DoormanContext {
+    state: DoormanState;
+    challenge: Challenge | null;
+    consecutiveFailures: number;
+    cooldownEndsAt: number | null;
+    lockEndsAt: number | null;
+    admissionEndsAt: number | null;
+    capability: CapabilityToken | null;
+}
+export interface Challenge {
+    nonce: string;
+    salt: string;
+    issuedAt: number;
+    expiresAt: number;
+}
+export interface Verifier {
+    /** KDF output (MVP stores this verifier directly) */
+    hash: string;
+    /** Random salt used during registration (hex) */
+    salt: string;
+    /** Domain binding for anti-phishing */
+    domain: string;
+    /** When verifier was created */
+    createdAt: number;
+    /** Schema/version for forwards compatibility */
+    version: 1;
+}
+export interface CapabilityToken {
+    /** Token ID for revocation */
+    tokenId: string;
+    /** Issuer public key hex */
+    issuer: string;
+    /** Scope patterns (e.g., "speakeasy.*", "speakeasy.private_feeds") */
+    scopes: string[];
+    /** Unix timestamp - token invalid before */
+    notBefore: number;
+    /** Unix timestamp - token invalid after */
+    expiresAt: number;
+    /** Optional constraints */
+    constraints?: {
+        maxUses?: number;
+        allowedOrigins?: string[];
+    };
+    /** Ed25519 signature over payload */
+    signature: string;
+}
+export interface GestureRecognizerConfig {
+    /** Tap: max duration to count as tap (default: 200ms) */
+    tapMaxDurationMs: number;
+    /** Tap: max movement to count as tap (default: 10px) */
+    tapMaxMovementPx: number;
+    /** Tap: max interval between multi-taps (default: 300ms) */
+    tapIntervalMs: number;
+    /** Hold: min duration to count as hold (default: 500ms) */
+    holdMinDurationMs: number;
+    /** Drag: min distance to register (default: 20px) */
+    dragMinDistancePx: number;
+    /** Flick: min velocity to register (default: 0.5 px/ms) */
+    flickMinVelocity: number;
+    /** Radial: notch angle size (default: 30 degrees) */
+    radialNotchDegrees: number;
+}
+export declare const DEFAULT_GESTURE_CONFIG: GestureRecognizerConfig;
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface GestureRecognizerState {
+    isActive: boolean;
+    startPoint: Point | null;
+    currentPoint: Point | null;
+    startTime: number | null;
+    steps: GestureStep[];
+    pendingTapCount: number;
+}
+export type OrbState = 'idle' | 'challenged' | 'verifying' | 'admitted' | 'decoy' | 'locked';
+export interface OrbVisualConfig {
+    /** Base orb size in pixels */
+    size: number;
+    /** Glow intensity (0-1) for each state */
+    glowIntensity: Record<OrbState, number>;
+    /** Pulse speed (ms) for each state */
+    pulseSpeed: Record<OrbState, number>;
+    /** Colors for each state */
+    colors: Record<OrbState, string>;
+}
+export declare const DEFAULT_ORB_CONFIG: OrbVisualConfig;
+/**
+ * Public context - safe for all components.
+ * Contains only read-only state and non-sensitive actions.
+ */
+export interface SpeakeasyPublicContextValue {
+    /** Current doorman state */
+    state: DoormanState;
+    /** Whether the provider is fully initialized (device secret resolved) */
+    isReady: boolean;
+    /** Whether user is in speakeasy mode */
+    isAdmitted: boolean;
+    /** Whether user is in panic/decoy mode */
+    isDecoy: boolean;
+    /** Initiate the knock sequence */
+    knock: () => void;
+    /** Exit speakeasy mode */
+    exit: () => void;
+    /** Time remaining in current state (ms) */
+    timeRemaining: number | null;
+}
+/**
+ * Private context - only for trusted components.
+ * Contains sensitive capability data and registration methods.
+ */
+export interface SpeakeasyPrivateContextValue {
+    /** Current capability token (if admitted) */
+    capability: CapabilityToken | null;
+    /** Whether gesture secret has been registered */
+    isRegistered: boolean;
+    /** Register a new gesture secret */
+    register: (gesture: GestureSequence) => Promise<void>;
+    /** Clear the registered gesture secret */
+    clearRegistration: () => Promise<void>;
+    /** Submit a gesture for verification (typical entry flow) */
+    submitGesture: (gesture: GestureSequence) => Promise<void>;
+}
+/**
+ * Combined context value (legacy - deprecated).
+ * Use SpeakeasyPublicContextValue or SpeakeasyPrivateContextValue instead.
+ */
+export interface SpeakeasyContextValue extends SpeakeasyPublicContextValue, SpeakeasyPrivateContextValue {
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/speakeasy/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/speakeasy/types.ts"],"names":[],"mappings":"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"}