glirastes 0.4.0 → 0.5.0

package/dist/cjs/react/stt/recorded.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordedSttAdapter = void 0;
+exports.encodeWav = encodeWav;
+const deepgram_js_1 = require("./deepgram.js");
+const SAMPLE_RATE = 16_000;
+/** 16-bit mono PCM chunks as one WAV file. */
+function encodeWav(chunks, sampleRate) {
+    const samples = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const buffer = new ArrayBuffer(44 + samples * 2);
+    const view = new DataView(buffer);
+    const text = (offset, value) => {
+        for (let i = 0; i < value.length; i += 1)
+            view.setUint8(offset + i, value.charCodeAt(i));
+    };
+    text(0, 'RIFF');
+    view.setUint32(4, 36 + samples * 2, true);
+    text(8, 'WAVE');
+    text(12, 'fmt ');
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true); // PCM
+    view.setUint16(22, 1, true); // mono
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    text(36, 'data');
+    view.setUint32(40, samples * 2, true);
+    let offset = 44;
+    for (const chunk of chunks) {
+        for (let i = 0; i < chunk.length; i += 1, offset += 2)
+            view.setInt16(offset, chunk[i], true);
+    }
+    return buffer;
+}
+/**
+ * Speech input for a transcription model that takes a finished recording
+ * instead of a live stream (Parakeet, Whisper and the like): the audio is
+ * kept in the browser while the user speaks and sent once when they stop.
+ * There is no interim text; the transcript arrives as one final segment.
+ *
+ * The endpoint is the app's own route. It receives `audio/wav` (16 kHz, mono,
+ * 16 bit) with the language as a query parameter and answers `{ "text": … }`.
+ */
+class RecordedSttAdapter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async connect(input) {
+        const maxSamples = (this.options.maxSeconds ?? 120) * SAMPLE_RATE;
+        const chunks = [];
+        let kept = 0;
+        let discarded = false;
+        let sent = null;
+        const request = new AbortController();
+        let stopCapture = await (this.options.capture ?? deepgram_js_1.createPcmPipeline)(input.stream, (audio) => {
+            if (discarded || kept >= maxSamples)
+                return;
+            const chunk = new Int16Array(audio).slice(0, maxSamples - kept);
+            chunks.push(chunk);
+            kept += chunk.length;
+        });
+        const endCapture = async () => {
+            const stop = stopCapture;
+            stopCapture = null;
+            await stop?.();
+        };
+        const discard = async () => {
+            discarded = true;
+            chunks.length = 0;
+            request.abort();
+            await endCapture();
+        };
+        input.signal.addEventListener('abort', () => { void discard(); }, { once: true });
+        const send = async () => {
+            await endCapture();
+            if (discarded || kept === 0)
+                return;
+            const base = typeof window === 'undefined' ? undefined : window.location.href;
+            const url = new URL(this.options.url ?? '/api/ai/speech-recognize', base);
+            url.searchParams.set('language', input.language);
+            try {
+                const response = await (this.options.fetch ?? fetch)(url.toString(), {
+                    method: 'POST',
+                    headers: { ...this.options.getHeaders?.(), 'content-type': 'audio/wav' },
+                    body: encodeWav(chunks, SAMPLE_RATE),
+                    credentials: 'same-origin',
+                    signal: request.signal,
+                });
+                if (!response.ok)
+                    throw new Error('Transcription failed');
+                const result = await response.json();
+                const text = typeof result.text === 'string' ? result.text.trim() : '';
+                if (text && !discarded) {
+                    input.events.onSegment({ id: 'recording', sequence: 0, text, isFinal: true });
+                }
+            }
+            catch {
+                // The server's own words stay out of the UI.
+                if (!discarded)
+                    input.events.onError(new Error('Transcription failed'));
+            }
+            finally {
+                chunks.length = 0;
+            }
+        };
+        return {
+            finalize: () => (sent ??= send()),
+            cancel: discard,
+            close: discard,
+        };
+    }
+}
+exports.RecordedSttAdapter = RecordedSttAdapter;

package/dist/cjs/react/stt/segments.d.ts

@@ -0,0 +1,18 @@
+export interface SttSegment {
+    id: string;
+    sequence: number;
+    text: string;
+    isFinal: boolean;
+}
+interface StoredSttSegment extends SttSegment {
+    text: string;
+}
+export interface SttTranscript {
+    readonly segments: ReadonlyArray<StoredSttSegment>;
+    readonly finalText: string;
+    readonly interimText: string;
+    readonly displayText: string;
+}
+export declare function createSttTranscript(): SttTranscript;
+export declare function applySttSegment(transcript: SttTranscript, segment: SttSegment): SttTranscript;
+export {};

package/dist/cjs/react/stt/segments.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSttTranscript = createSttTranscript;
+exports.applySttSegment = applySttSegment;
+function joinText(segments) {
+    return segments
+        .map((segment) => segment.text.trim())
+        .filter(Boolean)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function materialize(segments) {
+    const ordered = [...segments].sort((left, right) => (left.sequence - right.sequence || left.id.localeCompare(right.id)));
+    return {
+        segments: ordered,
+        finalText: joinText(ordered.filter((segment) => segment.isFinal)),
+        interimText: joinText(ordered.filter((segment) => !segment.isFinal)),
+        displayText: joinText(ordered),
+    };
+}
+function createSttTranscript() {
+    return materialize([]);
+}
+function applySttSegment(transcript, segment) {
+    const text = segment.text.trim();
+    if (!text)
+        return transcript;
+    const next = transcript.segments.filter((candidate) => candidate.id !== segment.id);
+    next.push({ ...segment, text });
+    return materialize(next);
+}

package/dist/cjs/react/stt/use-stt.d.ts

@@ -0,0 +1,17 @@
+import { type SttProviderAdapter, type SttSessionSnapshot } from './controller.js';
+export interface UseSttOptions {
+    adapter: SttProviderAdapter;
+    language: string;
+    onInterimTranscript?: (text: string) => void;
+    onError?: (error: string) => void;
+}
+export interface UseSttReturn extends SttSessionSnapshot {
+    isRecording: boolean;
+    isConnecting: boolean;
+    stream: MediaStream | null;
+    startRecording: (previousDraft?: string) => Promise<void>;
+    stopRecording: () => Promise<string>;
+    cancelRecording: () => Promise<string>;
+    retry: () => Promise<void>;
+}
+export declare function useStt(options: UseSttOptions): UseSttReturn;

package/dist/cjs/react/stt/use-stt.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStt = useStt;
+const react_1 = require("react");
+const controller_js_1 = require("./controller.js");
+function useStt(options) {
+    const controller = (0, react_1.useMemo)(() => new controller_js_1.SttSessionController({
+        adapter: options.adapter,
+        language: options.language,
+    }), [options.adapter, options.language]);
+    const snapshot = (0, react_1.useSyncExternalStore)((listener) => controller.subscribe(listener), () => controller.snapshot, () => controller.snapshot);
+    (0, react_1.useEffect)(() => () => {
+        void controller.dispose();
+    }, [controller]);
+    (0, react_1.useEffect)(() => {
+        if (snapshot.phase === 'failed' && snapshot.error) {
+            options.onError?.(snapshot.error);
+        }
+    }, [options.onError, snapshot.error, snapshot.phase]);
+    (0, react_1.useEffect)(() => {
+        if (snapshot.interimTranscript) {
+            options.onInterimTranscript?.(snapshot.displayTranscript);
+        }
+    }, [
+        options.onInterimTranscript,
+        snapshot.displayTranscript,
+        snapshot.interimTranscript,
+    ]);
+    const startRecording = (0, react_1.useCallback)((previousDraft = '') => controller.start(previousDraft), [controller]);
+    return {
+        ...snapshot,
+        isRecording: snapshot.phase === 'recording' || snapshot.phase === 'finalizing',
+        isConnecting: snapshot.phase === 'requesting_permission'
+            || snapshot.phase === 'connecting',
+        stream: controller.getStream(),
+        startRecording,
+        stopRecording: () => controller.stop(),
+        cancelRecording: () => controller.cancel(),
+        retry: () => controller.retry(),
+    };
+}

package/dist/cjs/react/stt/waveform.d.ts

@@ -0,0 +1,5 @@
+export interface StreamAnalyser {
+    readLevel(): number;
+    close(): Promise<void>;
+}
+export declare function createStreamAnalyser(stream: MediaStream, createContext?: () => AudioContext): StreamAnalyser;

package/dist/cjs/react/stt/waveform.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamAnalyser = createStreamAnalyser;
+function createStreamAnalyser(stream, createContext = () => new AudioContext()) {
+    const context = createContext();
+    const source = context.createMediaStreamSource(stream);
+    const analyser = context.createAnalyser();
+    analyser.fftSize = 256;
+    source.connect(analyser);
+    const values = new Uint8Array(analyser.frequencyBinCount);
+    let closed = false;
+    return {
+        readLevel() {
+            analyser.getByteTimeDomainData(values);
+            let sumOfSquares = 0;
+            for (const value of values) {
+                const normalized = (value - 128) / 128;
+                sumOfSquares += normalized * normalized;
+            }
+            return Math.min(1, Math.sqrt(sumOfSquares / Math.max(values.length, 1)) * 4);
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            source.disconnect();
+            analyser.disconnect();
+            await context.close();
+        },
+    };
+}