@ephia/dova-sdk 1.0.0

package/README.md

@@ -0,0 +1,89 @@
+# Ephia SDK
+
+Official JavaScript/TypeScript SDK for Ephia medical dictation.
+
+## Install
+
+```bash
+npm install @ephia/dova-sdk
+# or
+pnpm add @ephia/dova-sdk
+```
+
+## React quickstart
+
+```tsx
+import { EphiaProvider, useEphiaNativeTarget } from "@ephia/dova-sdk/react";
+import { EphiaFloatingButton } from "@ephia/dova-sdk/ui";
+import { useRef } from "react";
+
+function ReportTextarea() {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  useEphiaNativeTarget(ref, { id: "report", label: "Compte rendu" });
+  return <textarea ref={ref} placeholder="Dictez votre compte rendu..." />;
+}
+
+export function App() {
+  return (
+    <EphiaProvider bearerToken={token}>
+      <ReportTextarea />
+      <EphiaFloatingButton />
+    </EphiaProvider>
+  );
+}
+```
+
+## TipTap rich editor
+
+```tsx
+import {
+  useEphiaRichEditor,
+  createTiptapEphiaAdapter,
+} from "@ephia/dova-sdk/rich-editor";
+
+useEphiaRichEditor(
+  editor ? createTiptapEphiaAdapter(editor) : null,
+  { id: "report", label: "Compte rendu" }
+);
+```
+
+## Entry points
+
+| Import | Description |
+|---|---|
+| `@ephia/dova-sdk/react` | Provider, hooks, React components |
+| `@ephia/dova-sdk/rich-editor` | TipTap adapter and `useEphiaRichEditor` |
+| `@ephia/dova-sdk/headless` | `createEphiaClient` for non-React apps |
+| `@ephia/dova-sdk/bindings` | Low-level bindings (`NativeBinding`, `TiptapBinding`) |
+| `@ephia/dova-sdk/ui` | Standalone UI components |
+| `@ephia/dova-sdk/testing` | Test helpers |
+| `@ephia/dova-sdk/speechmike` | Philips SpeechMike support |
+| `@ephia/dova-sdk/style.css` | Default styles |
+
+## Production endpoint
+
+Default API endpoint:
+
+```txt
+https://api.ephia.app
+```
+
+## Documentation
+
+See the public documentation in `apps/ephia-docs`.
+
+## Architecture
+
+The SDK V2 follows a backend-first architecture:
+
+```txt
+Backend Ephia
+→ segment.preview / segment.operation
+→ SDK
+→ TargetManager
+→ NativeBinding / TiptapBinding
+→ client editor
+```
+
+The backend decides the final text, corrections, voice commands, layout and segment revisions.  
+The SDK applies the received operations into the right editable target.

package/dist/EphiaBinding-BvRmlqqC.d.ts

@@ -0,0 +1,36 @@
+import { EditorContext, SegmentStage } from 'ephia-protocol';
+
+type UpsertSegmentInput = {
+    id: string;
+    text: string;
+    stage: SegmentStage;
+    source?: string;
+};
+type PreviewSegmentInput = {
+    id: string;
+    text: string;
+};
+/**
+ * Interface V2 unifiée pour tous les bindings éditeurs Ephia.
+ *
+ * Règles :
+ *  - même segmentId + upsertSegment = update en place (never append)
+ *  - segmentId connu mais range perdu = warning + no append
+ *  - removeSegments est idempotent
+ *  - cleanup visuel ne supprime jamais l'identité segment
+ */
+interface EphiaBinding {
+    readonly kind: string;
+    /** Stable reference for this binding instance. Used for idempotent lifecycle management. */
+    readonly identity?: object | string;
+    attach(): void;
+    detach(): void;
+    getText(): string;
+    getEditorContext(targetId?: string): EditorContext;
+    previewSegment?(input: PreviewSegmentInput): void;
+    upsertSegment(input: UpsertSegmentInput): void;
+    removeSegment(id: string): void;
+    removeSegments(ids: string[]): void;
+}
+
+export type { EphiaBinding as E, PreviewSegmentInput as P, UpsertSegmentInput as U };

package/dist/EphiaFloatingButton-CxiF86VW.d.ts

@@ -0,0 +1,65 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default, { ButtonHTMLAttributes, ReactNode } from 'react';
+import { E as EphiaStatus } from './types-D5SXPSwR.js';
+import { E as EphiaSessionOptions } from './session-APaXR48R.js';
+import { T as Transport } from './Transport-zdeA4Pou.js';
+
+type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    variant?: "primary" | "danger" | "ghost" | "outline";
+    size?: "sm" | "md" | "lg";
+    isLoading?: boolean;
+    children: ReactNode;
+};
+declare function Button({ variant, size, isLoading, children, className, disabled, ...rest }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+type SpinnerProps = {
+    size?: "sm" | "md" | "lg";
+    className?: string;
+};
+declare function Spinner({ size, className }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+/** Border radius presets for {@link EphiaFloatingButton}. */
+type EphiaFloatingButtonBorderRadius = "sm" | "md" | "lg" | "full";
+
+type EphiaFloatingButtonPosition = "bottom-right" | "bottom-left" | "bottom-center" | "top-right" | "top-left" | "top-center";
+type EphiaFloatingButtonTheme = "light" | "dark";
+type EphiaFloatingButtonSize = "S" | "M" | "L";
+type EphiaFloatingButtonVariant = "minimal" | "standard";
+type EphiaFloatingButtonInteractionMode = "toggle" | "push-to-talk";
+type EphiaFloatingButtonCustomColors = {
+    /** Ink color: logo, visualiseur Standard, texte. Any valid CSS color. */
+    primary: string;
+    /** Background color. Any valid CSS color. */
+    secondary: string;
+};
+interface EphiaFloatingButtonProps {
+    /**
+     * API URL. Optional override (ex. http://localhost:8000 en dev).
+     * Sans override : EPHIA_SDK_ENDPOINT, sinon https://api.ephia.app.
+     */
+    apiUrl?: string;
+    apiKey?: string;
+    bearerToken?: string;
+    clientType?: string;
+    transport?: Transport;
+    position?: EphiaFloatingButtonPosition;
+    theme?: EphiaFloatingButtonTheme;
+    size?: EphiaFloatingButtonSize;
+    variant?: EphiaFloatingButtonVariant;
+    colors?: EphiaFloatingButtonCustomColors;
+    /** Corner radius of the dictation control. Default `md`. */
+    borderRadius?: EphiaFloatingButtonBorderRadius;
+    /** Interaction model. `"toggle"` (default): click to start, click to stop. `"push-to-talk"`: hold to record, release to stop. */
+    interactionMode?: EphiaFloatingButtonInteractionMode;
+    className?: string;
+    style?: React__default.CSSProperties;
+    sessionOptions?: EphiaSessionOptions;
+    onError?: (error: {
+        code: string;
+        message: string;
+    }) => void;
+    onStatusChange?: (status: EphiaStatus) => void;
+}
+declare function EphiaFloatingButton({ apiUrl, apiKey, bearerToken, clientType, transport, position, theme, size, variant, borderRadius, interactionMode, colors, className, style, sessionOptions, onError, onStatusChange, }: EphiaFloatingButtonProps): react_jsx_runtime.JSX.Element;
+
+export { Button as B, EphiaFloatingButton as E, Spinner as S, type ButtonProps as a, type EphiaFloatingButtonBorderRadius as b, type EphiaFloatingButtonPosition as c, type EphiaFloatingButtonProps as d, type EphiaFloatingButtonSize as e, type EphiaFloatingButtonTheme as f, type SpinnerProps as g };

package/dist/EphiaTextarea-B4_CAVUg.d.ts

@@ -0,0 +1,183 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default from 'react';
+import { b as EphiaAudioClientOptions, a as EphiaStartOptions, E as EphiaStartResult } from './client-options-Uo6jXO8k.js';
+import { E as EphiaStatus, b as EphiaError, c as EphiaPartial } from './types-D5SXPSwR.js';
+import { E as EphiaConnectionState } from './connection-state-Bk33YprE.js';
+import { a as EphiaAudioState } from './audio-state-kZ3KSvux.js';
+import { ResetReason, EphiaServerEvent } from 'ephia-protocol';
+import { Editor } from '@tiptap/core';
+
+interface EphiaProviderProps {
+    children: React__default.ReactNode;
+    apiUrl?: string;
+    apiKey?: string;
+    bearerToken?: string;
+    clientType?: string;
+    transport?: EphiaAudioClientOptions["transport"];
+    options?: {
+        language?: string;
+        medicalDomain?: string;
+        sessionOptions?: EphiaAudioClientOptions["sessionOptions"];
+    };
+    onError?: (error: {
+        code: string;
+        message: string;
+    }) => void;
+    onStatusChange?: (status: EphiaStatus) => void;
+    preloadSession?: boolean;
+    preloadInitialTargetId?: string;
+    noiseFilter?: boolean;
+    vadGate?: boolean;
+    audioInputDeviceId?: string;
+}
+declare function EphiaProvider({ children, apiUrl, apiKey, bearerToken, clientType, transport, options, onError, onStatusChange, preloadSession, preloadInitialTargetId, noiseFilter, vadGate, audioInputDeviceId, }: EphiaProviderProps): react_jsx_runtime.JSX.Element;
+
+interface EphiaAutoProps {
+    children: React__default.ReactNode;
+    /** CSS selector for target elements. Defaults to [data-ephia-target]. */
+    selector?: string;
+}
+/**
+ * Scans its descendants for [data-ephia-target] elements (textarea/input only)
+ * and registers them automatically as V2 NativeBinding targets.
+ *
+ * Uses a MutationObserver to handle dynamically added/removed elements.
+ *
+ * @example
+ * <EphiaProvider getToken={getToken}>
+ *   <EphiaAuto>
+ *     <textarea data-ephia-target="report" />
+ *   </EphiaAuto>
+ * </EphiaProvider>
+ */
+declare function EphiaAuto({ children, selector }: EphiaAutoProps): react_jsx_runtime.JSX.Element;
+
+interface UseEphiaReturn {
+    status: EphiaStatus;
+    sessionId: string | null;
+    activeTargetId: string | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    isIdle: boolean;
+    isRecording: boolean;
+    isProcessing: boolean;
+    isBusy: boolean;
+    hasError: boolean;
+    start: (targetId?: string, options?: EphiaStartOptions) => Promise<EphiaStartResult>;
+    stop: () => Promise<void>;
+    toggle: (targetId?: string, options?: EphiaStartOptions) => Promise<void>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    endSession: () => Promise<void>;
+    warmupMic: () => Promise<void>;
+    setActiveTarget: (id: string) => void;
+    resetTarget: (id?: string, reason?: ResetReason) => Promise<void>;
+    resetSession: (reason?: ResetReason) => Promise<void>;
+    sendEditorContext: (id?: string) => Promise<void>;
+    applyServerEvent: (event: EphiaServerEvent) => void;
+}
+declare function useEphia(): UseEphiaReturn;
+/** Re-rend uniquement sur changement de status. */
+declare function useEphiaStatus(): EphiaStatus;
+/** Comme useEphiaStatus mais retourne undefined en dehors d'un EphiaProvider. */
+declare function useOptionalEphiaStatus(): EphiaStatus | undefined;
+/** Re-rend uniquement sur changement d'erreur session (ex. session.error STT). */
+declare function useEphiaError(): EphiaError | null;
+/** Re-rend sur chaque partial — à utiliser uniquement dans les composants d'affichage. */
+declare function useEphiaPartial(): EphiaPartial | null;
+/** Re-rend sur changement de connexion. */
+declare function useEphiaConnection(): EphiaConnectionState;
+/** Comme useEphiaConnection mais retourne undefined en dehors d'un EphiaProvider. */
+declare function useOptionalEphiaConnection(): EphiaConnectionState | undefined;
+/** Re-rend sur changement de niveau audio. */
+declare function useEphiaAudioLevel(): EphiaAudioState;
+/** Re-rend uniquement sur changement d'état parole (VAD gate). */
+declare function useEphiaSpeaking(): boolean;
+
+interface UseEphiaNativeTargetOptions {
+    id: string;
+    mode?: string;
+    label?: string;
+    enabled?: boolean;
+}
+/** @deprecated Use `UseEphiaNativeTargetOptions` instead. */
+type UseEphiaTargetOptions = UseEphiaNativeTargetOptions;
+/**
+ * Registers a textarea or input element as a V2 Ephia target.
+ * Creates a NativeBinding and wires it to the TargetManager via context.
+ *
+ * @example
+ * const ref = useRef<HTMLTextAreaElement>(null)
+ * useEphiaNativeTarget(ref, { id: 'report', label: 'Compte rendu' })
+ * return <textarea ref={ref} />
+ */
+declare function useEphiaNativeTarget<T extends HTMLInputElement | HTMLTextAreaElement>(ref: React.RefObject<T | null>, options: UseEphiaNativeTargetOptions): void;
+/**
+ * @deprecated Use `useEphiaNativeTarget` for textarea/input fields.
+ */
+declare const useEphiaTarget: typeof useEphiaNativeTarget;
+
+/**
+ * @deprecated Use `useEphiaRichEditor(createTiptapEphiaAdapter(editor), options)`.
+ *
+ * @example
+ * const ref = useEphiaRichEditor(
+ *   createTiptapEphiaAdapter(editor),
+ *   { id: 'compte-rendu', label: 'Compte rendu' },
+ * );
+ */
+declare function useEphiaTiptap(editor: Editor | null, options: UseEphiaNativeTargetOptions): React.RefObject<HTMLDivElement | null>;
+
+interface EphiaDictationButtonRenderProps {
+    status: EphiaStatus;
+    isRecording: boolean;
+    toggle: () => void;
+    disabled: boolean;
+}
+interface EphiaDictationButtonProps {
+    targetId?: string;
+    disabled?: boolean;
+    className?: string;
+    onError?: (error: unknown) => void;
+    /**
+     * Render prop — le dev fournit son propre rendu.
+     * Si absent, un bouton minimaliste est rendu.
+     *
+     * @example
+     * <EphiaDictationButton>
+     *   {({ isRecording, toggle }) => (
+     *     <MyButton onClick={toggle} variant={isRecording ? 'danger' : 'primary'} />
+     *   )}
+     * </EphiaDictationButton>
+     */
+    children?: (props: EphiaDictationButtonRenderProps) => React__default.ReactNode;
+}
+declare function EphiaDictationButton({ targetId, disabled, className, onError, children, }: EphiaDictationButtonProps): react_jsx_runtime.JSX.Element;
+
+interface EphiaStatusBarRenderProps {
+    status: EphiaStatus;
+    partialText: string | null;
+}
+interface EphiaStatusBarProps {
+    className?: string;
+    children?: (props: EphiaStatusBarRenderProps) => React__default.ReactNode;
+}
+declare function EphiaStatusBar({ className, children, }: EphiaStatusBarProps): react_jsx_runtime.JSX.Element | null;
+
+interface EphiaTextareaProps extends React__default.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    targetId: string;
+    mode?: string;
+    insertion?: "preview-inline" | "preview-floating" | "final-only" | "none";
+}
+/**
+ * Textarea avec overlay de preview du partial en streaming.
+ *
+ * Stratégie (Dragon Medical-style) :
+ * - La `<textarea>` contient uniquement le texte committed (color: transparent).
+ * - L'overlay div par-dessous affiche : texte committed + partial grisé.
+ */
+declare const EphiaTextarea: React__default.ForwardRefExoticComponent<EphiaTextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+
+export { EphiaAuto as E, type UseEphiaReturn as U, EphiaDictationButton as a, EphiaProvider as b, type EphiaProviderProps as c, EphiaStatusBar as d, EphiaTextarea as e, useEphiaAudioLevel as f, useEphiaConnection as g, useEphiaError as h, useEphiaNativeTarget as i, useEphiaPartial as j, useEphiaSpeaking as k, useEphiaStatus as l, useEphiaTarget as m, useEphiaTiptap as n, useOptionalEphiaConnection as o, useOptionalEphiaStatus as p, type UseEphiaNativeTargetOptions as q, type UseEphiaTargetOptions as r, useEphia as u };

package/dist/NativeBinding-ChG0GeSz.d.ts

@@ -0,0 +1,53 @@
+import { EditorContext } from 'ephia-protocol';
+import { E as EphiaBinding, P as PreviewSegmentInput, U as UpsertSegmentInput } from './EphiaBinding-BvRmlqqC.js';
+
+/**
+ * Binding V2 pour <textarea> et <input type="text">.
+ *
+ * Modèle : prefix | segments dictés | preview | suffix
+ *
+ * Le prefix et le suffix sont verrouillés à l'attach() depuis la sélection
+ * courante. Tous les segments dictés sont insérés entre les deux.
+ * Même segmentId = mise à jour en place (jamais d'append).
+ */
+declare class NativeBinding implements EphiaBinding {
+    readonly kind = "native";
+    readonly identity: HTMLInputElement | HTMLTextAreaElement;
+    private readonly el;
+    private readonly warn;
+    private prefix;
+    private suffix;
+    private readonly segmentTexts;
+    private readonly knownSegmentIds;
+    private readonly segmentBoundaryPrefixes;
+    private previewSegmentId;
+    private previewText;
+    constructor(el: HTMLInputElement | HTMLTextAreaElement, options?: {
+        warn?: (msg: string, details?: Record<string, unknown>) => void;
+    });
+    attach(): void;
+    /**
+     * Resync prefix/suffix and clear segment memory from the current DOM value.
+     * Called before each dictation so manual edits between sessions are preserved.
+     */
+    prepareForDictation(): void;
+    detach(): void;
+    getText(): string;
+    getEditorContext(targetId?: string): EditorContext;
+    previewSegment(input: PreviewSegmentInput): void;
+    upsertSegment(input: UpsertSegmentInput): void;
+    removeSegment(id: string): void;
+    removeSegments(ids: string[]): void;
+    private _syncInsertionAnchor;
+    private _committedText;
+    /**
+     * Canonical upserts (incl. absorb/merge) may carry the full corrected phrase.
+     * Drop segment/binding prefixes that would duplicate its opening.
+     */
+    private _reconcileCanonicalSegmentInsertion;
+    /** Trim binding.prefix when canonical text already opens with its trailing words. */
+    private _trimBindingPrefixOverlap;
+    private _render;
+}
+
+export { NativeBinding as N };

package/dist/TargetBinding-BKGQwUMc.d.ts

@@ -0,0 +1,89 @@
+import { DocumentOperation } from 'ephia-protocol';
+
+interface SessionAnchor {
+    /** Position où la dictée a commencé (immutable pendant la session). */
+    readonly initialStart: number;
+    /** Fin initiale (égale à initialStart si pas de sélection). */
+    readonly initialEnd: number;
+    /** True si la session a démarré avec une sélection non-vide. */
+    readonly hadSelection: boolean;
+    /** Position courante de la fin du texte dicté (mise à jour à chaque insert). */
+    end: number;
+    /**
+     * True tant que la sélection initiale n'a pas encore été supprimée.
+     * Le binding la supprimera atomiquement avec le premier insert de texte dicté.
+     */
+    selectionPendingDelete: boolean;
+}
+interface BeginSessionOptions {
+    /**
+     * Si true, la sélection courante (si non vide) sera supprimée au premier
+     * insert et remplacée par le texte dicté. Défaut : true.
+     */
+    replaceSelection?: boolean;
+}
+interface CommitFinalOptions {
+    absorbedSegmentIds?: string[];
+}
+interface TargetBinding {
+    kind: string;
+    attach(): void;
+    detach(): void;
+    /**
+     * Verrouille un anchor au début d'une session de dictée. Tous les inserts
+     * suivants se feront relativement à cet anchor, indépendamment du curseur
+     * de l'utilisateur. Si l'utilisateur avait une sélection non-vide, elle
+     * sera remplacée (sauf si replaceSelection: false).
+     */
+    beginSession?(opts?: BeginSessionOptions): SessionAnchor;
+    /** Termine la session et relâche l'anchor. Les textes restent dans le document. */
+    endSession?(): void;
+    /** Retourne l'anchor courant, ou null si pas de session active. */
+    getSessionAnchor?(): SessionAnchor | null;
+    /** Position visuelle du point d'insertion (anchor.end pendant la session, curseur sinon). */
+    getCursorRect?(): DOMRect | null;
+    /**
+     * Rectangle englobant d'une plage de texte. Utilisé pour le flash visuel
+     * (revised, committed). Retourne null si non supporté ou plage hors vue.
+     */
+    getRangeRect?(start: number, end: number): DOMRect | null;
+    insertPartial?(segmentId: string, text: string, revision: number): void;
+    commitFinal(segmentId: string, text: string, options?: CommitFinalOptions): void;
+    clearPartial(segmentId: string): void;
+    clearAll?(): void;
+    /** Retourne la plage [start, end] d'un segment commis dans le document, ou null si inconnu. */
+    getSegmentRange?(segmentId: string): {
+        start: number;
+        end: number;
+    } | null;
+    /** Récupère le texte complet du document */
+    getText(): string;
+    /** Récupère la sélection actuelle */
+    getSelection?(): {
+        text: string;
+        range: {
+            start: number;
+            end: number;
+        };
+    } | null;
+    /** Récupère la position du curseur */
+    getCursorOffset?(): number | null;
+    /** Applique une opération structurée au document */
+    applyOperation(operation: DocumentOperation): void;
+    /**
+     * Applique une séquence d'opérations (ex: insert_text/line_break/paragraph_break
+     * issue de textToDocumentOperations()). applyOperation() seul ne traite
+     * qu'une opération à la fois et n'a pas de notion de curseur implicite entre
+     * deux appels — un binding qui veut positionner correctement chaque
+     * opération relativement aux précédentes (ex: TipTap, cf. P4) doit fournir
+     * sa propre implémentation. Sinon, applyOperationsSequentially() (ci-dessous)
+     * sert de filet par défaut.
+     */
+    applyOperations?(operations: DocumentOperation[]): void;
+    /** Appelé quand un segment passe en état "reviewing" (correction SMART en cours) */
+    notifyReviewing?(): void;
+    /** Appelé quand la review d'un segment est terminée (corrected ou confirmed) */
+    notifyReviewDone?(): void;
+}
+
+export type { TargetBinding as T };

package/dist/TiptapBinding-B-agfV2H.d.ts

@@ -0,0 +1,45 @@
+import { Mark, Editor } from '@tiptap/core';
+import { EditorContext } from 'ephia-protocol';
+import { E as EphiaBinding, P as PreviewSegmentInput, U as UpsertSegmentInput } from './EphiaBinding-BvRmlqqC.js';
+
+declare const EphiaV2PreviewMark: Mark<any, any>;
+declare const EphiaV2CommittedMark: Mark<any, any>;
+type TiptapBindingOptions = {
+    warn?: (msg: string, details?: Record<string, unknown>) => void;
+};
+/**
+ * Binding V2 pour TipTap.
+ *
+ * Règles :
+ *  - même segmentId + upsertSegment = update in place (never append)
+ *  - segmentId connu mais range perdu = warning + no append
+ *  - removeSegments idempotent
+ *  - cleanup visuel ne supprime jamais l'identité segment
+ *  - le préfixe de boundary SDK est stable sur preview -> provisional -> canonical
+ */
+declare class TiptapBinding implements EphiaBinding {
+    readonly kind = "tiptap";
+    readonly identity: Editor;
+    private readonly editor;
+    private readonly warn;
+    private readonly knownSegmentIds;
+    private readonly insertionPrefixes;
+    private readonly visualTimeouts;
+    private previewSegmentId;
+    constructor(editor: Editor, options?: TiptapBindingOptions);
+    attach(): void;
+    detach(): void;
+    getText(): string;
+    getEditorContext(targetId?: string): EditorContext;
+    previewSegment(input: PreviewSegmentInput): void;
+    upsertSegment(input: UpsertSegmentInput): void;
+    removeSegment(id: string): void;
+    removeSegments(ids: string[]): void;
+    private _clearPreview;
+    private _textWithStableBoundary;
+    private _scheduleVisualCleanup;
+    private _clearVisualTimeout;
+    private _removeVisualMarkForSegment;
+}
+
+export { EphiaV2CommittedMark as E, TiptapBinding as T, EphiaV2PreviewMark as a };

package/dist/Transport-zdeA4Pou.d.ts

@@ -0,0 +1,63 @@
+import { EphiaClientMessage, EphiaAudioEvent, EphiaServerEvent } from 'ephia-protocol';
+import { b as EphiaSdkError } from './audio-state-kZ3KSvux.js';
+
+/**
+ * Interface abstraite du transport Ephia Audio.
+ *
+ * LiveKit est une implémentation. MockTransport en est une autre.
+ */
+
+type TransportConnectParams = {
+    livekitUrl: string;
+    token: string;
+    roomName: string;
+};
+type TransportConnectionStatus = "idle" | "connecting" | "connected" | "reconnecting" | "reconnected" | "disconnected" | "error";
+type TransportState = {
+    status: TransportConnectionStatus;
+    roomName?: string;
+    participantIdentity?: string;
+    connectionQuality?: "unknown" | "poor" | "good" | "excellent";
+    krispActive?: boolean;
+    localAudioPublished: boolean;
+    localAudioMuted: boolean;
+    reconnectCount: number;
+    lastError?: EphiaSdkError;
+};
+interface Transport {
+    /** Connecte le transport. */
+    connect(params: TransportConnectParams): Promise<void>;
+    /** Déconnecte proprement. */
+    disconnect(reason?: string): Promise<void>;
+    /** Publie une piste audio. */
+    publishAudio(track: MediaStreamTrack, options?: {
+        enableNoiseFilter?: boolean;
+    }): Promise<void>;
+    /** Dé-publie l'audio local. */
+    unpublishAudio(): Promise<void>;
+    /** Envoie un message client vers le serveur. */
+    sendMessage(message: EphiaClientMessage): Promise<void>;
+    /** Écoute les events Ephia. Retourne un unsubscriber. */
+    onEvent(callback: (event: EphiaAudioEvent) => void): () => void;
+    /** Écoute les events serveur V2 bruts (sans inférence). Retourne un unsubscriber. */
+    onServerEvent(callback: (event: EphiaServerEvent) => void): () => void;
+    /** Écoute les changements d'état transport. Retourne un unsubscriber. */
+    onTransportState(callback: (state: TransportState) => void): () => void;
+    /** Écoute les erreurs transport. Retourne un unsubscriber. */
+    onError(callback: (error: EphiaSdkError) => void): () => void;
+    /** Retourne l'état courant. */
+    getState(): TransportState;
+    /** Publication audio locale (pour VAD gate mute/unmute). */
+    getLocalAudioPublication?(): {
+        mute(): Promise<unknown>;
+        unmute(): Promise<unknown>;
+    } | null;
+    /** Pré-chauffe la connexion WebRTC (DNS + TLS). Non bloquant. Optionnel. */
+    prepareConnection?(url: string, token?: string): Promise<void>;
+    /** Appel RPC vers le serveur. */
+    performRpc?(method: string, payload: unknown, timeout?: number): Promise<string>;
+    /** Change le périphérique actif. */
+    switchActiveDevice?(kind: MediaDeviceKind, deviceId: string): Promise<boolean>;
+}
+
+export type { Transport as T, TransportState as a, TransportConnectParams as b };

package/dist/audio-state-kZ3KSvux.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Erreurs typées du SDK Ephia.
+ */
+type EphiaSdkErrorCode = "config.invalid" | "session.create_failed" | "session.token_missing" | "transport.connect_failed" | "transport.reconnecting" | "transport.disconnected" | "transport.not_connected" | "audio.permission_denied" | "audio.no_input_device" | "audio.device_in_use" | "audio.track_publish_failed" | "audio.silence_detected" | "protocol.invalid_event" | "protocol.seq_gap" | "protocol.seq_gap_sync_failed" | "client.invalid_state" | "client.start_failed" | "client.finalization_timeout" | "binding.target_not_found" | "binding.unsupported_editor";
+declare class EphiaSdkError extends Error {
+    code: EphiaSdkErrorCode;
+    details?: Record<string, unknown> | undefined;
+    constructor(code: EphiaSdkErrorCode, message: string, details?: Record<string, unknown> | undefined);
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * État audio local (micro, niveau, silence, permission).
+ */
+type EphiaAudioPermission = "unknown" | "prompt" | "granted" | "denied";
+type EphiaAudioState = {
+    permission: EphiaAudioPermission;
+    inputDeviceId?: string;
+    inputDeviceLabel?: string;
+    hasInputDevice: boolean;
+    level: number;
+    rms: number;
+    peak: number;
+    isSilent: boolean;
+    silenceDurationMs: number;
+    muted: boolean;
+    localAudioPublished: boolean;
+    /** true si le VADGate détecte de la parole active */
+    speaking: boolean;
+    /** True dès que getUserMedia a réussi, même si le transport n'est pas encore connecté. */
+    micReady?: boolean;
+    error?: {
+        code: string;
+        message: string;
+    };
+};
+declare const initialAudioState: EphiaAudioState;
+
+export { type EphiaAudioPermission as E, type EphiaAudioState as a, EphiaSdkError as b, type EphiaSdkErrorCode as c, initialAudioState as i };

package/dist/chunk-35AJK2IO.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-35AJK2IO.js.map

package/dist/chunk-35AJK2IO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}