@backbay/glia 0.2.0-alpha.1

package/dist/speakeasy/components/SpeakeasyOrb.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SpeakeasyOrb (MVP)
+ *
+ * Minimal orb UI that:
+ * - detects a public "knock" (triple tap) to request a challenge
+ * - captures a short gesture sequence while challenged
+ */
+import type { OrbVisualConfig } from '../types.js';
+export interface SpeakeasyOrbProps {
+    config?: Partial<OrbVisualConfig>;
+}
+export declare function SpeakeasyOrb({ config: partialConfig }: SpeakeasyOrbProps): import("react/jsx-runtime").JSX.Element;
+export default SpeakeasyOrb;
+//# sourceMappingURL=SpeakeasyOrb.d.ts.map

package/dist/speakeasy/components/SpeakeasyOrb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeakeasyOrb.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/components/SpeakeasyOrb.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EAA0B,eAAe,EAAE,MAAM,aAAa,CAAC;AAG3E,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CACnC;AAED,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,iBAAiB,2CA2JxE;AAED,eAAe,YAAY,CAAC"}

package/dist/speakeasy/components/SpeakeasyOrb.js

@@ -0,0 +1,128 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SpeakeasyOrb (MVP)
+ *
+ * Minimal orb UI that:
+ * - detects a public "knock" (triple tap) to request a challenge
+ * - captures a short gesture sequence while challenged
+ */
+import { motion } from 'motion/react';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useSpeakeasy } from '../SpeakeasyProvider.js';
+import { useGestureRecognizer } from '../hooks/useGestureRecognizer.js';
+import { DEFAULT_ORB_CONFIG } from '../types.js';
+export function SpeakeasyOrb({ config: partialConfig }) {
+    const config = useMemo(() => {
+        const merged = {
+            ...DEFAULT_ORB_CONFIG,
+            ...partialConfig,
+            glowIntensity: { ...DEFAULT_ORB_CONFIG.glowIntensity, ...partialConfig?.glowIntensity },
+            pulseSpeed: { ...DEFAULT_ORB_CONFIG.pulseSpeed, ...partialConfig?.pulseSpeed },
+            colors: { ...DEFAULT_ORB_CONFIG.colors, ...partialConfig?.colors },
+        };
+        return merged;
+    }, [partialConfig]);
+    const { state, knock, submitGesture, isAdmitted, timeRemaining } = useSpeakeasy();
+    const orbRef = useRef(null);
+    const finalizeTimeoutRef = useRef(null);
+    const knockTapCountRef = useRef(0);
+    const knockTapTimeoutRef = useRef(null);
+    const { handlers, startCapture, endCapture, reset } = useGestureRecognizer({
+        centerRef: orbRef,
+        onGestureStep: () => {
+            if (finalizeTimeoutRef.current)
+                clearTimeout(finalizeTimeoutRef.current);
+            finalizeTimeoutRef.current = setTimeout(async () => {
+                const sequence = await endCapture();
+                if (sequence) {
+                    await submitGesture(sequence);
+                }
+            }, 350);
+        },
+    });
+    // Start/stop capture based on doorman state.
+    useEffect(() => {
+        if (state === 'CHALLENGED') {
+            startCapture();
+            return;
+        }
+        reset();
+        if (finalizeTimeoutRef.current) {
+            clearTimeout(finalizeTimeoutRef.current);
+            finalizeTimeoutRef.current = null;
+        }
+    }, [state, startCapture, reset]);
+    const handleKnockTap = useCallback(() => {
+        // Triple tap within a short window.
+        knockTapCountRef.current += 1;
+        if (knockTapTimeoutRef.current)
+            clearTimeout(knockTapTimeoutRef.current);
+        if (knockTapCountRef.current >= 3) {
+            knockTapCountRef.current = 0;
+            knock();
+            return;
+        }
+        knockTapTimeoutRef.current = setTimeout(() => {
+            knockTapCountRef.current = 0;
+        }, 500);
+    }, [knock]);
+    // Map doorman state to orb visual state
+    const ORB_STATE_MAP = {
+        IDLE: 'idle',
+        CHALLENGED: 'challenged',
+        VERIFYING: 'verifying',
+        ADMITTED: 'admitted',
+        DECOY: 'decoy',
+        COOLDOWN: 'idle',
+        LOCKED: 'locked',
+    };
+    const orbState = ORB_STATE_MAP[state] ?? 'idle';
+    const glow = config.glowIntensity[orbState];
+    const color = config.colors[orbState];
+    const pulseMs = config.pulseSpeed[orbState];
+    // Accessible labels for each state
+    const ARIA_LABELS = {
+        IDLE: 'Speakeasy: triple-tap to knock',
+        CHALLENGED: 'Speakeasy: perform gesture now',
+        VERIFYING: 'Speakeasy: verifying your gesture',
+        ADMITTED: 'Speakeasy: access granted',
+        DECOY: 'Speakeasy: decoy mode active',
+        COOLDOWN: 'Speakeasy: please wait before retrying',
+        LOCKED: 'Speakeasy: temporarily locked',
+    };
+    const ariaLabel = ARIA_LABELS[state] ?? 'Speakeasy';
+    return (_jsxs(motion.div, { ref: orbRef, role: "button", "aria-label": ariaLabel, title: ariaLabel, onPointerDown: handlers.onPointerDown, onPointerMove: handlers.onPointerMove, onPointerUp: (e) => {
+            handlers.onPointerUp(e);
+            if (state === 'IDLE') {
+                handleKnockTap();
+            }
+        }, onPointerCancel: handlers.onPointerCancel, animate: pulseMs > 0 ? { opacity: [0.9, 1, 0.9] } : { opacity: 1 }, transition: pulseMs > 0 ? { duration: pulseMs / 1000, repeat: Infinity, ease: 'easeInOut' } : undefined, style: {
+            position: 'relative',
+            width: config.size,
+            height: config.size,
+            borderRadius: '50%',
+            border: `1px solid color-mix(in srgb, ${color} 40%, transparent)`,
+            background: 'linear-gradient(160deg, rgba(0, 0, 0, 0.55), rgba(8, 8, 10, 0.85))',
+            boxShadow: `0 0 ${24 + glow * 36}px color-mix(in srgb, ${color} ${20 + glow * 40}%, transparent), 0 6px 26px rgba(0, 0, 0, 0.45)`,
+            display: 'grid',
+            placeItems: 'center',
+            userSelect: 'none',
+            touchAction: 'none',
+            cursor: 'pointer',
+        }, children: [_jsx("div", { style: {
+                    width: config.size * 0.35,
+                    height: config.size * 0.35,
+                    borderRadius: '50%',
+                    background: `radial-gradient(circle at 30% 30%, color-mix(in srgb, ${color} 60%, white), color-mix(in srgb, ${color} 35%, transparent) 55%, transparent 70%)`,
+                    opacity: isAdmitted ? 1 : 0.9,
+                } }), typeof timeRemaining === 'number' && state !== 'IDLE' && (_jsx("div", { role: "status", "aria-live": "polite", "aria-atomic": "true", style: {
+                    position: 'absolute',
+                    top: config.size + 8,
+                    fontSize: 12,
+                    color: 'var(--text-muted, rgba(255,255,255,0.72))',
+                    fontFamily: 'ui-sans-serif, system-ui',
+                    textAlign: 'center',
+                    width: 140,
+                }, children: _jsxs("span", { "aria-label": `${state.toLowerCase()}, ${Math.ceil(timeRemaining / 1000)} seconds remaining`, children: [state.toLowerCase(), " \u00B7 ", Math.ceil(timeRemaining / 1000), "s"] }) }))] }));
+}
+export default SpeakeasyOrb;

package/dist/speakeasy/components/SpeakeasyRegistrationDialog.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface SpeakeasyRegistrationDialogProps {
+    trigger?: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function SpeakeasyRegistrationDialog({ trigger, open: openProp, onOpenChange, }: SpeakeasyRegistrationDialogProps): import("react/jsx-runtime").JSX.Element;
+export default SpeakeasyRegistrationDialog;
+//# sourceMappingURL=SpeakeasyRegistrationDialog.d.ts.map

package/dist/speakeasy/components/SpeakeasyRegistrationDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeakeasyRegistrationDialog.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/components/SpeakeasyRegistrationDialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoD,MAAM,OAAO,CAAC;AA4CzE,MAAM,WAAW,gCAAgC;IAC/C,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,OAAO,EACP,IAAI,EAAE,QAAQ,EACd,YAAY,GACb,EAAE,gCAAgC,2CAgNlC;AAED,eAAe,2BAA2B,CAAC"}

package/dist/speakeasy/components/SpeakeasyRegistrationDialog.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, } from '../../primitives/ui/dialog';
+import { Button } from '../../primitives/ui/button';
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger, } from '../../primitives/ui/alert-dialog';
+import { fingerprintGestureSequence } from '../auth/SpeakeasyAuth.js';
+import { useSpeakeasy } from '../SpeakeasyProvider.js';
+import { SpeakeasyRitualPad } from './SpeakeasyRitualPad.js';
+function describeStep(step) {
+    switch (step.type) {
+        case 'tap':
+            return `tap ×${step.count} (${step.region})`;
+        case 'hold':
+            return `hold ${Math.round(step.durationMs)}ms (${step.region})`;
+        case 'radial_drag':
+            return `radial drag ${Math.round(step.fromAngle)}°→${Math.round(step.toAngle)}° (notches ${step.notches})`;
+        case 'flick':
+            return `flick ${step.direction} (${step.velocity.toFixed(2)}px/ms)`;
+    }
+}
+export function SpeakeasyRegistrationDialog({ trigger, open: openProp, onOpenChange, }) {
+    const [openInternal, setOpenInternal] = useState(false);
+    const open = openProp ?? openInternal;
+    const setOpen = onOpenChange ?? setOpenInternal;
+    const { isRegistered, register, clearRegistration } = useSpeakeasy();
+    const [phase, setPhase] = useState('idle');
+    const [first, setFirst] = useState(null);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!open) {
+            setPhase('idle');
+            setFirst(null);
+            setError(null);
+        }
+    }, [open]);
+    const stepsSummary = useMemo(() => {
+        if (!first)
+            return null;
+        return first.steps.map(describeStep);
+    }, [first]);
+    const start = useCallback(() => {
+        setError(null);
+        setFirst(null);
+        setPhase('record');
+    }, []);
+    const handleFirst = useCallback(async (sequence) => {
+        setError(null);
+        setFirst(sequence);
+        setPhase('confirm');
+    }, []);
+    const handleConfirm = useCallback(async (sequence) => {
+        if (!first)
+            return;
+        const a = fingerprintGestureSequence(first);
+        const b = fingerprintGestureSequence(sequence);
+        if (a !== b) {
+            setError('That didn’t match. Try again.');
+            setPhase('record');
+            setFirst(null);
+            return;
+        }
+        await register(first);
+        setError(null);
+        setPhase('success');
+    }, [first, register]);
+    return (_jsxs(Dialog, { open: open, onOpenChange: setOpen, children: [trigger ? _jsx(DialogTrigger, { asChild: true, children: trigger }) : null, _jsxs(DialogContent, { children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: "Speakeasy ritual" }), _jsx(DialogDescription, { children: "Register a short gesture sequence (3\u20135 steps). You\u2019ll need to repeat it to confirm." })] }), _jsxs("div", { style: { display: 'grid', gap: 12 }, children: [_jsxs("div", { style: {
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    justifyContent: 'space-between',
+                                    gap: 12,
+                                    padding: '10px 12px',
+                                    borderRadius: 10,
+                                    border: '1px solid rgba(255,255,255,0.08)',
+                                }, children: [_jsxs("div", { style: { display: 'grid', gap: 2 }, children: [_jsxs("div", { style: { fontWeight: 600 }, children: ["Status: ", isRegistered ? 'registered' : 'not registered'] }), _jsx("div", { style: { fontSize: 13, opacity: 0.8 }, children: "Stored secret is a verifier output (not raw gestures)." })] }), isRegistered ? (_jsxs(AlertDialog, { children: [_jsx(AlertDialogTrigger, { asChild: true, children: _jsx(Button, { variant: "outline", children: "Clear" }) }), _jsxs(AlertDialogContent, { children: [_jsxs(AlertDialogHeader, { children: [_jsx(AlertDialogTitle, { children: "Clear ritual?" }), _jsx(AlertDialogDescription, { children: "This removes the registered verifier from storage. You\u2019ll need to register again to enter." })] }), _jsxs(AlertDialogFooter, { children: [_jsx(AlertDialogCancel, { children: "Cancel" }), _jsx(AlertDialogAction, { onClick: async () => {
+                                                                    await clearRegistration();
+                                                                    setPhase('idle');
+                                                                    setFirst(null);
+                                                                }, children: "Clear" })] })] })] })) : null] }), error ? (_jsx("div", { style: {
+                                    padding: '10px 12px',
+                                    borderRadius: 10,
+                                    border: '1px solid rgba(239,68,68,0.35)',
+                                    background: 'rgba(239,68,68,0.10)',
+                                    color: 'rgba(255,255,255,0.92)',
+                                    fontSize: 13,
+                                }, children: error })) : null, phase === 'idle' ? (_jsxs("div", { style: { display: 'grid', gap: 12 }, children: [_jsx("div", { style: { fontSize: 13, opacity: 0.85 }, children: "Tip: Use rhythmic taps, a short hold, and a notch-like radial drag." }), _jsx("div", { style: { display: 'flex', justifyContent: 'flex-end', gap: 8 }, children: _jsx(Button, { onClick: start, children: isRegistered ? 'Replace ritual' : 'Register ritual' }) })] })) : null, phase === 'record' ? (_jsxs("div", { style: { display: 'grid', gap: 12, justifyItems: 'center' }, children: [_jsx("div", { style: { fontWeight: 600 }, children: "Step 1: Record your ritual" }), _jsx(SpeakeasyRitualPad, { onComplete: handleFirst }), _jsx("div", { style: { fontSize: 13, opacity: 0.8, textAlign: 'center' }, children: "Perform your gesture. It will auto-finish after a brief pause." }), _jsx("div", { style: { display: 'flex', justifyContent: 'flex-end', width: '100%' }, children: _jsx(Button, { variant: "outline", onClick: () => setPhase('idle'), children: "Cancel" }) })] })) : null, phase === 'confirm' ? (_jsxs("div", { style: { display: 'grid', gap: 12, justifyItems: 'center' }, children: [_jsx("div", { style: { fontWeight: 600 }, children: "Step 2: Repeat to confirm" }), _jsx(SpeakeasyRitualPad, { onComplete: handleConfirm }), stepsSummary ? (_jsxs("div", { style: { fontSize: 12, opacity: 0.75, width: '100%' }, children: [_jsx("div", { style: { fontWeight: 600, marginBottom: 4 }, children: "Recorded" }), _jsx("ol", { style: { margin: 0, paddingLeft: 18 }, children: stepsSummary.map((s, idx) => (_jsx("li", { children: s }, idx))) })] })) : null, _jsxs("div", { style: { display: 'flex', justifyContent: 'flex-end', width: '100%', gap: 8 }, children: [_jsx(Button, { variant: "outline", onClick: () => {
+                                                    setFirst(null);
+                                                    setPhase('record');
+                                                    setError(null);
+                                                }, children: "Redo" }), _jsx(Button, { variant: "outline", onClick: () => setPhase('idle'), children: "Cancel" })] })] })) : null, phase === 'success' ? (_jsxs("div", { style: { display: 'grid', gap: 12 }, children: [_jsx("div", { style: { fontWeight: 600 }, children: "Ritual registered." }), _jsx("div", { style: { fontSize: 13, opacity: 0.85 }, children: "You can now triple-tap to knock and perform your gesture to enter." })] })) : null] }), _jsx(DialogFooter, { children: _jsx(Button, { variant: "outline", onClick: () => {
+                                setOpen(false);
+                            }, children: "Close" }) })] })] }));
+}
+export default SpeakeasyRegistrationDialog;

package/dist/speakeasy/components/SpeakeasyRitualPad.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SpeakeasyRitualPad
+ *
+ * Generic capture surface for gesture rituals.
+ */
+import React from 'react';
+import type { GestureSequence, GestureStep } from '../types.js';
+export interface SpeakeasyRitualPadProps {
+    disabled?: boolean;
+    autoStart?: boolean;
+    onComplete: (sequence: GestureSequence) => void | Promise<void>;
+    onStep?: (step: GestureStep) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function SpeakeasyRitualPad({ disabled, autoStart, onComplete, onStep, className, style, }: SpeakeasyRitualPadProps): import("react/jsx-runtime").JSX.Element;
+export default SpeakeasyRitualPad;
+//# sourceMappingURL=SpeakeasyRitualPad.d.ts.map

package/dist/speakeasy/components/SpeakeasyRitualPad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeakeasyRitualPad.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/components/SpeakeasyRitualPad.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAqC,MAAM,OAAO,CAAC;AAG1D,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;CAC7B;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAgB,EAChB,SAAgB,EAChB,UAAU,EACV,MAAM,EACN,SAAS,EACT,KAAK,GACN,EAAE,uBAAuB,2CA+EzB;AAED,eAAe,kBAAkB,CAAC"}

package/dist/speakeasy/components/SpeakeasyRitualPad.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SpeakeasyRitualPad
+ *
+ * Generic capture surface for gesture rituals.
+ */
+import { useEffect, useMemo, useRef } from 'react';
+import { useGestureRecognizer } from '../hooks/useGestureRecognizer.js';
+export function SpeakeasyRitualPad({ disabled = false, autoStart = true, onComplete, onStep, className, style, }) {
+    const padRef = useRef(null);
+    const finalizeTimeoutRef = useRef(null);
+    const { handlers, startCapture, endCapture, reset } = useGestureRecognizer({
+        centerRef: padRef,
+        onGestureStep: (step) => {
+            onStep?.(step);
+            if (finalizeTimeoutRef.current)
+                clearTimeout(finalizeTimeoutRef.current);
+            finalizeTimeoutRef.current = setTimeout(async () => {
+                const sequence = await endCapture();
+                if (sequence) {
+                    await onComplete(sequence);
+                }
+            }, 350);
+        },
+    });
+    useEffect(() => {
+        if (!autoStart || disabled)
+            return;
+        startCapture();
+        return () => reset();
+    }, [autoStart, disabled, startCapture, reset]);
+    const mergedStyle = useMemo(() => ({
+        position: 'relative',
+        width: 240,
+        height: 240,
+        borderRadius: 24,
+        border: '1px solid rgba(255,255,255,0.10)',
+        background: 'radial-gradient(circle at 35% 30%, rgba(212,168,75,0.18), rgba(0,0,0,0.25) 60%, rgba(0,0,0,0.55) 100%)',
+        boxShadow: '0 10px 30px rgba(0,0,0,0.35)',
+        touchAction: 'none',
+        userSelect: 'none',
+        opacity: disabled ? 0.55 : 1,
+        ...style,
+    }), [disabled, style]);
+    return (_jsxs("div", { ref: padRef, className: className, style: mergedStyle, "aria-disabled": disabled, onPointerDown: disabled ? undefined : handlers.onPointerDown, onPointerMove: disabled ? undefined : handlers.onPointerMove, onPointerUp: disabled ? undefined : handlers.onPointerUp, onPointerCancel: disabled ? undefined : handlers.onPointerCancel, children: [_jsx("div", { style: {
+                    position: 'absolute',
+                    inset: 14,
+                    borderRadius: 18,
+                    border: '1px dashed rgba(255,255,255,0.18)',
+                    pointerEvents: 'none',
+                } }), _jsx("div", { style: {
+                    position: 'absolute',
+                    bottom: 10,
+                    left: 12,
+                    right: 12,
+                    fontSize: 12,
+                    color: 'rgba(255,255,255,0.72)',
+                    fontFamily: 'ui-sans-serif, system-ui',
+                    textAlign: 'center',
+                    pointerEvents: 'none',
+                }, children: "Tap \u00B7 hold \u00B7 radial drag \u00B7 flick" })] }));
+}
+export default SpeakeasyRitualPad;

package/dist/speakeasy/doorman/DoormanStateMachine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * DoormanStateMachine - State machine for speakeasy doorman interaction
+ *
+ * States: IDLE → CHALLENGED → VERIFYING → ADMITTED → COOLDOWN/LOCKED
+ *
+ * Mirrors the HSM pattern from kernel/src/cyntra/core/topology/hsm_engine.py
+ * but implemented as a Zustand store for React integration.
+ */
+import { type DoormanState, type DoormanEvent, type DoormanConfig, type DoormanContext } from '../types.js';
+interface Transition {
+    from: DoormanState;
+    to: DoormanState;
+    event: DoormanEvent['type'];
+    guard?: (context: DoormanContext, event: DoormanEvent) => boolean;
+    action?: (context: DoormanContext, event: DoormanEvent) => Partial<DoormanContext>;
+}
+interface DoormanStore extends DoormanContext {
+    config: DoormanConfig;
+    transitions: Transition[];
+    dispatch: (event: DoormanEvent) => void;
+    reset: () => void;
+    setConfig: (config: Partial<DoormanConfig>) => void;
+    isAdmitted: () => boolean;
+    timeRemaining: () => number | null;
+}
+export declare const useDoormanStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<DoormanStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: DoormanStore, previousSelectedState: DoormanStore) => void): () => void;
+        <U>(selector: (state: DoormanStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+/**
+ * Start automatic timeout handling based on state changes
+ */
+export declare function startDoormanTimeouts(): () => void;
+export default useDoormanStore;
+//# sourceMappingURL=DoormanStateMachine.d.ts.map

package/dist/speakeasy/doorman/DoormanStateMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DoormanStateMachine.d.ts","sourceRoot":"","sources":["../../../src/speakeasy/doorman/DoormanStateMachine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EAEpB,MAAM,aAAa,CAAC;AAMrB,UAAU,UAAU;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC5B,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC;IAClE,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CACpF;AAuQD,UAAU,YAAa,SAAQ,cAAc;IAC3C,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,UAAU,EAAE,CAAC;IAG1B,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC;IAGpD,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,aAAa,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACpC;AAYD,eAAO,MAAM,eAAe;;;;;;;;EAmE3B,CAAC;AAWF;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CAqEjD;AAED,eAAe,eAAe,CAAC"}