@blario/react-native 0.0.0-stage → 0.1.0

package/dist/agent-mode/frames.d.ts

@@ -0,0 +1,36 @@
+import { type UnknownRecord } from '../fiber/narrow.ts';
+export type AgentModeEvent = {
+    kind: 'progress';
+    message: string;
+    progressType: string | null;
+} | {
+    kind: 'message';
+    role: string;
+    text: string;
+    waitForResponse: boolean;
+} | {
+    kind: 'queued';
+    message: string | null;
+} | {
+    kind: 'execution_complete';
+} | {
+    kind: 'acknowledged';
+} | {
+    kind: 'cancelled';
+} | {
+    kind: 'session_closed';
+} | {
+    kind: 'history';
+    agentModeActive: boolean;
+    intent: string | null;
+    agentStatus: string | null;
+} | {
+    kind: 'thinking';
+} | {
+    kind: 'thinking_stop';
+} | {
+    kind: 'session_started';
+    sessionId: number;
+};
+export declare function readAgentModeEvent(frame: UnknownRecord): AgentModeEvent | null;
+export declare function isBubbleRole(role: string): boolean;

package/dist/agent-mode/haptics.d.ts

@@ -0,0 +1,6 @@
+export interface HapticsAdapter {
+    name: string;
+    warn: () => void;
+}
+export declare const HAPTICS_ADAPTER: HapticsAdapter | null;
+export declare function warnByHaptics(adapter: HapticsAdapter | null): void;

package/dist/agent-mode/keep-awake.d.ts

@@ -0,0 +1,19 @@
+export type KeepAwakeHolder = 'ai-turn' | 'agent-run';
+export interface KeepAwakeAdapter {
+    name: string;
+    activate: () => void;
+    deactivate: () => void;
+}
+export declare const KEEP_AWAKE_ADAPTER: KeepAwakeAdapter | null;
+export declare class KeepAwake {
+    private readonly adapter;
+    private readonly log?;
+    private readonly holders;
+    private reportedMissing;
+    constructor(adapter: KeepAwakeAdapter | null, log?: ((message: string) => void) | undefined);
+    hold(holder: KeepAwakeHolder): void;
+    release(holder: KeepAwakeHolder): void;
+    releaseAll(): void;
+    private invoke;
+    private reportMissing;
+}

package/dist/agent-mode/layer-stacking.d.ts

@@ -0,0 +1,7 @@
+export declare class LayerStacking {
+    private readonly countOpenModals;
+    private openModals;
+    constructor(countOpenModals: () => number);
+    baseline(): void;
+    coveredByNewModal(): boolean;
+}

package/dist/agent-mode/markdown.d.ts

@@ -0,0 +1,19 @@
+export type InlineKind = 'text' | 'bold' | 'italic' | 'code' | 'link';
+export interface Inline {
+    kind: InlineKind;
+    text: string;
+}
+export type MarkdownBlock = {
+    kind: 'paragraph';
+    inlines: Inline[];
+} | {
+    kind: 'bullet';
+    inlines: Inline[];
+} | {
+    kind: 'numbered';
+    marker: string;
+    inlines: Inline[];
+};
+export declare function parseInlines(source: string): Inline[];
+export declare function parseMarkdown(source: string): MarkdownBlock[];
+export declare function plainText(source: string): string;

package/dist/agent-mode/panel-geometry.d.ts

@@ -0,0 +1,6 @@
+import type { Band, Rect } from '../host/rect.ts';
+export type PanelDock = 'bottom' | 'top';
+export declare const STACK_GAP = 12;
+export declare function freeBand(safeTop: number, stackTop: number, keyboardTop: number): Band;
+export declare function messageCap(room: number): number;
+export declare function chooseDock(target: Rect, bottomStack: Rect, topStack: Rect): PanelDock;

package/dist/agent-mode/resume.d.ts

@@ -0,0 +1,13 @@
+import type { AgentModePhase } from './state.ts';
+export interface SavedRun {
+    sessionId: number;
+    lastAgentFrameAt: number;
+}
+export declare const RESUME_MAX_AGE_MS = 120000;
+export declare function isResumable(run: SavedRun, sessionId: number, now: number): boolean;
+export declare function shouldResumeAgentMode(input: {
+    run: SavedRun | null;
+    sessionId: number;
+    phase: AgentModePhase;
+    now: number;
+}): boolean;

package/dist/agent-mode/run-memory.d.ts

@@ -0,0 +1,19 @@
+import type { KeyValueStorage } from '../backend/storage.ts';
+import type { SavedRun } from './resume.ts';
+export interface RunMemory {
+    recall: () => SavedRun | null;
+    remember: (at: number) => void;
+    forget: () => void;
+}
+export declare const NO_RUN_MEMORY: RunMemory;
+export declare class StoredRunMemory implements RunMemory {
+    private readonly storage;
+    private readonly key;
+    private readonly getSessionId;
+    private saved;
+    constructor(storage: KeyValueStorage, key: string, getSessionId: () => number | null);
+    load(): Promise<void>;
+    recall(): SavedRun | null;
+    remember(at: number): void;
+    forget(): void;
+}

package/dist/agent-mode/spotlight-controller.d.ts

@@ -0,0 +1,68 @@
+import type { ReadingRequest } from '../actions/services.ts';
+import type { ConfirmationOutcome, ConfirmationRequest } from '../confirmation/port.ts';
+import type { Band, Rect } from '../host/rect.ts';
+import { type Hole } from './spotlight.ts';
+import type { Timers } from './timers.ts';
+export type SpotlightSnapshot = {
+    kind: 'none';
+} | {
+    kind: 'reading';
+    id: number;
+    target: Rect;
+    hole: Hole;
+    text: string | null;
+    durationMs: number;
+    shown: boolean;
+} | {
+    kind: 'confirming';
+    id: number;
+    target: Rect | null;
+    hole: Hole | null;
+    request: ConfirmationRequest;
+    shown: boolean;
+};
+export interface SpotlightEnvironment {
+    timers: Timers;
+    isForeground: () => boolean;
+    stopRun: () => void;
+    alert: () => void;
+}
+type Listener = (snapshot: SpotlightSnapshot) => void;
+export declare const TRACK_MS = 33;
+export declare const CONFIRMATION_TIMEOUT_MS = 60000;
+export declare const REVEAL_MAX_MS = 1500;
+export declare class SpotlightController {
+    private readonly environment;
+    private snapshot;
+    private readonly listeners;
+    private finishReading;
+    private readingTimer;
+    private finishConfirmation;
+    private confirmationTimer;
+    private trackTimer;
+    private revealTimer;
+    private view;
+    private placing;
+    private shown;
+    constructor(environment: SpotlightEnvironment);
+    getSnapshot(): SpotlightSnapshot;
+    subscribe(listener: Listener): () => void;
+    read(request: ReadingRequest): Promise<boolean>;
+    confirm(request: ConfirmationRequest): Promise<ConfirmationOutcome>;
+    place(id: number, band: Band): Promise<void>;
+    approve(): void;
+    cancel(): void;
+    skip(): void;
+    backgrounded(): void;
+    clear(): void;
+    private awaitPlacement;
+    private show;
+    private settle;
+    private endConfirmation;
+    private endReading;
+    private track;
+    private stopTracking;
+    private clearTimer;
+    private publish;
+}
+export {};

package/dist/agent-mode/spotlight.d.ts

@@ -0,0 +1,6 @@
+import type { Rect } from '../host/rect.ts';
+export interface Hole extends Rect {
+    radius: number;
+}
+export declare const HOLE_PADDING = 8;
+export declare function holeAround(target: Rect, elementRadius: number): Hole;

package/dist/agent-mode/state.d.ts

@@ -0,0 +1,9 @@
+export type AgentModePhase = 'idle' | 'pending' | 'active' | 'exiting';
+export declare class AgentModeStateMachine {
+    private phase;
+    getPhase(): AgentModePhase;
+    isActive(): boolean;
+    isEngaged(): boolean;
+    transition(to: AgentModePhase): boolean;
+    forceIdle(): void;
+}

package/dist/agent-mode/status.d.ts

@@ -0,0 +1,11 @@
+export type AgentStatus = {
+    kind: 'thinking';
+} | {
+    kind: 'executing';
+} | {
+    kind: 'text';
+    text: string;
+};
+export declare const THINKING: AgentStatus;
+export declare const EXECUTING: AgentStatus;
+export declare function isStepMessage(message: string, progressType: string | null): boolean;

package/dist/agent-mode/timers.d.ts

@@ -0,0 +1,6 @@
+export interface Timers {
+    set: (callback: () => void, milliseconds: number) => unknown;
+    clear: (handle: unknown) => void;
+    now: () => number;
+}
+export declare const SYSTEM_TIMERS: Timers;

package/dist/agent-mode/ui/AgentDock.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import type { Band, Rect } from '../../host/rect.ts';
+import type { UiStrings } from '../../ui/strings.ts';
+import type { SpotlightSnapshot } from '../spotlight-controller.ts';
+export interface DockActions {
+    place: (id: number, band: Band) => void | Promise<void>;
+    approve: () => void;
+    cancel: () => void;
+    skip: () => void;
+}
+export interface DockStatus {
+    status: string;
+    queued: string | null;
+    stopLabel: string;
+    pulse: number;
+    cleared: boolean;
+    onStop: () => void;
+}
+export interface DockLayout {
+    width: number;
+    height: number;
+    cardWidth: number;
+    bottom: number;
+    safeTop: number;
+}
+export interface AgentDockProps {
+    spotlight: SpotlightSnapshot;
+    actions: DockActions;
+    card: DockStatus;
+    strings: UiStrings;
+    color: string;
+    reduceMotion: boolean;
+    nudge: number;
+    layout: DockLayout;
+    onCardFrame: (frame: Rect) => void;
+}
+export declare function AgentDock({ spotlight, actions, card, strings, color, reduceMotion, nudge, layout, onCardFrame }: AgentDockProps): React.JSX.Element;

package/dist/agent-mode/ui/AgentLayer.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { UiStrings } from '../../ui/strings.ts';
+import type { AgentModeSnapshot } from '../controller.ts';
+import type { CursorSnapshot } from '../cursor.ts';
+import type { SpotlightSnapshot } from '../spotlight-controller.ts';
+import { type DockActions } from './AgentDock.tsx';
+export interface AgentLayerProps {
+    snapshot: AgentModeSnapshot;
+    strings: UiStrings;
+    color: string;
+    spotlight: SpotlightSnapshot;
+    spotlightActions: DockActions;
+    cursor: CursorSnapshot;
+    reduceMotion: boolean;
+    onCursorAttach: () => void;
+    onCursorDetach: () => void;
+    onStop: () => void;
+}
+export declare function AgentLayer({ snapshot, strings, color, spotlight, spotlightActions, cursor, reduceMotion, onCursorAttach, onCursorDetach, onStop }: AgentLayerProps): React.JSX.Element;

package/dist/agent-mode/ui/AgentLayerHost.d.ts

@@ -0,0 +1,8 @@
+import React, { type ReactNode } from 'react';
+export interface AgentLayerHostProps {
+    visible: boolean;
+    generation: number;
+    onRequestClose: () => void;
+    children: ReactNode;
+}
+export declare function AgentLayerHost({ visible, generation, onRequestClose, children }: AgentLayerHostProps): React.JSX.Element | null;

package/dist/agent-mode/ui/AgentPanel.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { UiStrings } from '../../ui/strings.ts';
+import type { PanelDock } from '../panel-geometry.ts';
+import type { SpotlightSnapshot } from '../spotlight-controller.ts';
+export type ActiveSpotlight = Exclude<SpotlightSnapshot, {
+    kind: 'none';
+}>;
+export interface AgentPanelProps {
+    spotlight: ActiveSpotlight;
+    dock: PanelDock;
+    strings: UiStrings;
+    color: string;
+    messageMaxHeight: number;
+    onConfirm: () => void;
+    onStop: () => void;
+    onSkip: () => void;
+}
+export declare function panelChrome(spotlight: ActiveSpotlight): number;
+export declare function AgentPanel({ spotlight, dock, strings, color, messageMaxHeight, onConfirm, onStop, onSkip }: AgentPanelProps): React.JSX.Element;

package/dist/agent-mode/ui/AgentTap.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { CursorSnapshot } from '../cursor.ts';
+export interface AgentTapProps {
+    snapshot: CursorSnapshot;
+    color: string;
+    reduceMotion: boolean;
+    onAttach: () => void;
+    onDetach: () => void;
+}
+export declare function AgentTap({ snapshot, color, reduceMotion, onAttach, onDetach }: AgentTapProps): React.JSX.Element;

package/dist/agent-mode/ui/MarkdownText.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type TextStyle } from 'react-native';
+export interface MarkdownTextProps {
+    source: string;
+    linkColor: string;
+    textStyle?: TextStyle;
+}
+export declare function MarkdownText({ source, linkColor, textStyle }: MarkdownTextProps): React.JSX.Element;

package/dist/agent-mode/ui/MessageBubbles.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { AgentBubble } from '../bubbles.ts';
+export interface MessageBubblesProps {
+    bubbles: AgentBubble[];
+    width: number;
+    bottom: number;
+    linkColor: string;
+}
+export declare function MessageBubbles({ bubbles, width, bottom, linkColor }: MessageBubblesProps): React.JSX.Element | null;

package/dist/agent-mode/ui/PendingOverlay.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface PendingOverlayProps {
+    text: string;
+}
+export declare function PendingOverlay({ text }: PendingOverlayProps): React.JSX.Element;

package/dist/agent-mode/ui/SpotlightLayer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { SpotlightSnapshot } from '../spotlight-controller.ts';
+export interface SpotlightLayerProps {
+    spotlight: SpotlightSnapshot;
+    color: string;
+    reduceMotion: boolean;
+    onBackdropPress: () => void;
+}
+export declare function SpotlightLayer({ spotlight, color, reduceMotion, onBackdropPress }: SpotlightLayerProps): React.JSX.Element | null;

package/dist/agent-mode/ui/SpotlightOverlay.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { Hole } from '../spotlight.ts';
+export interface SpotlightOverlayProps {
+    hole: Hole;
+}
+export declare const SPOTLIGHT_DIM = "rgba(0, 0, 0, 0.6)";
+export declare function SpotlightOverlay({ hole }: SpotlightOverlayProps): React.JSX.Element;

package/dist/agent-mode/ui/StatusCard.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface StatusCardProps {
+    status: string;
+    queued: string | null;
+    stopLabel: string;
+    color: string;
+    stopHidden: boolean;
+    corners: StatusCorners;
+    pulse: number;
+    cleared: boolean;
+    onStop: () => void;
+}
+export type StatusCorners = 'round' | 'square-top' | 'square-bottom';
+export declare function StatusCard({ status, queued, stopLabel, color, stopHidden, corners, pulse, cleared, onStop }: StatusCardProps): React.JSX.Element;

package/dist/agent-mode/ui/TargetPulse.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Rect } from '../../host/rect.ts';
+export interface TargetPulseProps {
+    target: Rect;
+    radius: number;
+    color: string;
+    reduceMotion: boolean;
+}
+export declare function TargetPulse({ target, radius, color, reduceMotion }: TargetPulseProps): React.JSX.Element;

package/dist/agent-mode/ui/TouchShield.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface TouchShieldProps {
+    onBlockedTap: () => void;
+}
+export declare function TouchShield({ onBlockedTap }: TouchShieldProps): React.JSX.Element;

package/dist/agent-mode/ui/WarningIcon.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface WarningIconProps {
+    color: string;
+    background: string;
+}
+export declare function WarningIcon({ color, background }: WarningIconProps): React.JSX.Element;

package/dist/agent-mode/ui/full-window-overlay.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentType, ReactNode } from 'react';
+export type OverlayComponent = ComponentType<{
+    children?: ReactNode;
+}>;
+export declare function loadFullWindowOverlay(): OverlayComponent | null;

package/dist/agent-mode/ui/layer-host.d.ts

@@ -0,0 +1,2 @@
+export type LayerHostKind = 'modal' | 'full-window-overlay' | 'root';
+export declare function chooseLayerHost(platform: string, hasFullWindowOverlay: boolean): LayerHostKind;

package/dist/backend/api-client.d.ts

@@ -0,0 +1,38 @@
+import { type BootstrapResponse, type HeartbeatResponse, type IdentifyRequest } from './api-types.ts';
+import type { BlarIdentity, IdentityProof, IdentityRefusalReason } from './identity.ts';
+export interface ApiClientHooks {
+    restoreSource?: () => Promise<string | null>;
+    onIdentityRefused?: (reason: IdentityRefusalReason) => void;
+}
+export interface ApiClientOptions {
+    apiBaseUrl: string;
+    publishableKey: string;
+}
+export declare class ApiClient {
+    private readonly options;
+    private sourceId;
+    private hooks;
+    private readonly proofs;
+    constructor(options: ApiClientOptions);
+    setHooks(hooks: ApiClientHooks): void;
+    setSourceId(sourceId: string | null): void;
+    getSourceId(): string | null;
+    getApiBaseUrl(): string;
+    getPublishableKey(): string;
+    setIdentity(identity: BlarIdentity | null): void;
+    getIdentity(): BlarIdentity | null;
+    getIdentityProof(): Promise<IdentityProof | null> | null;
+    refreshIdentityProof(): Promise<IdentityProof | null>;
+    loadSession(sourceId: string | null): Promise<BootstrapResponse>;
+    identifyUser(request: IdentifyRequest): Promise<BootstrapResponse>;
+    heartbeat(): Promise<HeartbeatResponse>;
+    createSession(): Promise<number | null>;
+    openNudge(tabId: string): Promise<number | null>;
+    dismissNudge(milestoneMessageId: number): Promise<void>;
+    snoozeNudge(milestoneMessageId: number): Promise<void>;
+    private requireBootstrap;
+    private buildHeaders;
+    private fetchWithTimeout;
+    private send;
+    private recover;
+}

package/dist/backend/api-types.d.ts

@@ -0,0 +1,25 @@
+import type { CustomFields } from './identity.ts';
+export interface BootstrapResponse {
+    sourceId: string;
+    conversationId: number | null;
+    sessionId: number | null;
+    aiActive: boolean;
+    isIdentityVerified: boolean;
+}
+export interface IdentifyRequest {
+    external_id: string;
+    email?: string;
+    name?: string;
+    phone?: string;
+    contact_company?: string;
+    contact_company_external_id?: string;
+    country?: string;
+    custom_fields?: CustomFields;
+}
+export interface HeartbeatResponse {
+    hasPendingNudge: boolean;
+    conversationId: number | null;
+}
+export declare function parseBootstrap(raw: unknown): BootstrapResponse | null;
+export declare function parseHeartbeat(raw: unknown): HeartbeatResponse;
+export declare function parseSessionId(raw: unknown): number | null;

package/dist/backend/app-info.d.ts

@@ -0,0 +1,14 @@
+export interface AppInfo {
+    platform: 'react-native';
+    os: string;
+    os_version: string;
+    rn_version: string;
+    new_arch: boolean;
+}
+interface GlobalMarkers {
+    nativeFabricUIManager?: unknown;
+    RN$Bridgeless?: unknown;
+}
+export declare function detectNewArchitecture(markers: GlobalMarkers): boolean;
+export declare function readAppInfo(): AppInfo;
+export {};

package/dist/backend/backend-transport.d.ts

@@ -0,0 +1,70 @@
+import type { OutboundFrame } from '../agent/frames.ts';
+import { type RunMemory } from '../agent-mode/run-memory.ts';
+import type { AgentTransport } from '../transport/transport.ts';
+import type { BlarIdentity } from './identity.ts';
+import { type SessionState } from './session.ts';
+import { type SocketState } from './session-socket.ts';
+import { type KeyValueStorage } from './storage.ts';
+export interface BackendTransportOptions {
+    publishableKey: string;
+    apiBaseUrl: string;
+    user: BlarIdentity | null;
+    storage?: KeyValueStorage;
+    onSocketState?: (state: SocketState) => void;
+    onConnecting?: (sessionId: number) => void;
+    onSessionChanged?: () => void;
+    log?: (message: string) => void;
+}
+export interface WidgetProof {
+    identityToken?: string;
+    identitySignature?: string;
+}
+type FrameListener = (frame: Record<string, unknown>) => void;
+export declare class BackendTransport implements AgentTransport {
+    private readonly api;
+    private readonly session;
+    private readonly runMemory;
+    private readonly health;
+    private readonly presence;
+    private readonly socket;
+    private readonly tabId;
+    private readonly frameListeners;
+    private readonly identityListeners;
+    private agentListener;
+    private lastSeenSeq;
+    private connectedKey;
+    private stopped;
+    private refreshing;
+    private initialUser;
+    private readonly log;
+    private readonly onConnecting;
+    private booted;
+    constructor(options: BackendTransportOptions);
+    onMessage(listener: (raw: string) => void): void;
+    getRunMemory(): RunMemory;
+    onFrame(listener: FrameListener): () => void;
+    onIdentityChange(listener: () => void): () => void;
+    start(): void;
+    stop(): void;
+    setUser(identity: BlarIdentity): Promise<void>;
+    logout(): Promise<void>;
+    isConnected(): boolean;
+    refreshSession(): Promise<void>;
+    switchSession(sessionId: number): Promise<void>;
+    leaveSession(): void;
+    openNudge(): Promise<number | null>;
+    dismissNudge(milestoneMessageId: number): Promise<void>;
+    snoozeNudge(milestoneMessageId: number): Promise<void>;
+    getState(): SessionState;
+    getTabId(): string;
+    getIdentity(): BlarIdentity | null;
+    readWidgetProof(): Promise<WidgetProof | null>;
+    noteInteraction(): void;
+    send(frame: OutboundFrame): void;
+    private boot;
+    private connect;
+    private receive;
+    private describeCommand;
+    private trackSequence;
+}
+export {};

package/dist/backend/backoff.d.ts

@@ -0,0 +1,9 @@
+export interface BackoffPolicy {
+    baseMs: number;
+    decay: number;
+    maxMs: number;
+    maxAttempts: number;
+}
+export declare const SOCKET_BACKOFF: BackoffPolicy;
+export declare function backoffDelay(policy: BackoffPolicy, attempt: number): number;
+export declare function isExhausted(policy: BackoffPolicy, attempt: number): boolean;

package/dist/backend/base64.d.ts

@@ -0,0 +1 @@
+export declare function decodeBase64Url(input: string): string | null;

package/dist/backend/errors.d.ts

@@ -0,0 +1,17 @@
+export type ApiErrorKind = 'http' | 'network' | 'timeout';
+export declare class ApiRequestError extends Error {
+    readonly kind: ApiErrorKind;
+    readonly status: number;
+    readonly code: string | null;
+    readonly endpoint: string;
+    constructor(options: {
+        kind: ApiErrorKind;
+        endpoint: string;
+        status?: number;
+        code?: string | null;
+        message: string;
+    });
+    static http(endpoint: string, status: number, statusText: string, code: string | null): ApiRequestError;
+    static transport(endpoint: string, kind: 'network' | 'timeout'): ApiRequestError;
+}
+export declare function isIdentityRejection(error: unknown): error is ApiRequestError;

package/dist/backend/foreground.d.ts

@@ -0,0 +1 @@
+export declare function watchForeground(onActive: () => void): () => void;

package/dist/backend/health.d.ts

@@ -0,0 +1,17 @@
+export interface ClientHealth {
+    visibility: 'visible' | 'hidden';
+    hidden_ms: number;
+    lag_ms: number;
+    sdk_version: string;
+}
+export declare class ClientHealthProbe {
+    private timer;
+    private subscription;
+    private expectedTickAt;
+    private worstLagMs;
+    private hiddenSince;
+    start(): void;
+    stop(): void;
+    take(): ClientHealth;
+    private onStateChange;
+}