@360labs/live-transcribe 0.1.0 → 0.1.1

package/README.md

@@ -5,59 +5,104 @@
 [![npm version](https://img.shields.io/npm/v/@360labs/live-transcribe.svg)](https://www.npmjs.com/package/@360labs/live-transcribe)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.3+-blue.svg)](https://www.typescriptlang.org/)
-[![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)]()
+[![Tests](https://img.shields.io/badge/tests-236%20passing-brightgreen.svg)]()
 
 **Built by 360labs**
 
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Providers](#providers)
+  - [Web Speech API](#web-speech-api-browser)
+  - [Deepgram](#deepgram)
+  - [AssemblyAI](#assemblyai)
+  - [Custom Provider](#custom-provider)
+- [Session Management](#session-management)
+- [Events](#events)
+- [Export Formats](#export-formats)
+- [Supported Languages](#supported-languages)
+- [API Reference](#api-reference)
+- [Examples](#examples)
+- [Browser Support](#browser-support)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
 ## Features
 
-- **Multiple Provider Support** - Web Speech API, Deepgram, AssemblyAI
-- **Real-time Transcription** - Live results with interim and final transcripts
-- **40+ Languages** - Support for languages worldwide
-- **Audio Recording** - Built-in recording capabilities
-- **Session Management** - Easy session control and state management
-- **Voice Activity Detection** - Automatic speech detection
-- **Export Formats** - JSON, Text, SRT, VTT, CSV
-- **Fully Typed** - Complete TypeScript support with comprehensive types
-- **Event-driven** - Subscribe to transcription events easily
-- **Browser & Node.js** - Works in both environments
-- **Extensible** - Easy to add custom providers
+| Feature | Description |
+|---------|-------------|
+| **Multi-Provider Support** | Web Speech API, Deepgram, AssemblyAI, and custom providers |
+| **Real-time Transcription** | Live results with interim and final transcripts |
+| **40+ Languages** | Extensive language support across all providers |
+| **Session Management** | Full control with start, stop, pause, and resume |
+| **Voice Activity Detection** | Automatic speech detection (VAD) |
+| **Audio Recording** | Built-in recording capabilities |
+| **Export Formats** | JSON, Plain Text, SRT, VTT, CSV |
+| **TypeScript First** | Complete type definitions and IntelliSense support |
+| **Event-Driven** | Subscribe to transcription events easily |
+| **Lightweight** | ~200KB package size with zero runtime dependencies |
+| **Cross-Platform** | Works in browsers and Node.js |
+
+---
 
 ## Installation
 
 ```bash
+# npm
 npm install @360labs/live-transcribe
+
+# yarn
+yarn add @360labs/live-transcribe
+
+# pnpm
+pnpm add @360labs/live-transcribe
 ```
 
+---
+
 ## Quick Start
 
+### Basic Usage (Web Speech API)
+
 ```typescript
 import { createTranscriber, TranscriptionProvider } from '@360labs/live-transcribe';
 
-// Create a transcriber with Web Speech API (browser-native, no API key required)
+// Create a transcriber (Web Speech API - no API key required)
 const transcriber = createTranscriber({
   provider: TranscriptionProvider.WebSpeechAPI,
   language: 'en-US',
+  interimResults: true,
 });
 
-// Listen for transcription events
+// Listen for transcription results
 transcriber.on('transcript', (result) => {
-  console.log(result.text);
-  console.log('Is final:', result.isFinal);
+  if (result.isFinal) {
+    console.log('Final:', result.text);
+  } else {
+    console.log('Interim:', result.text);
+  }
 });
 
+// Handle errors
 transcriber.on('error', (error) => {
-  console.error('Transcription error:', error);
+  console.error('Error:', error.message);
 });
 
 // Start transcribing
+await transcriber.initialize();
 await transcriber.start();
 
 // Stop when done
 await transcriber.stop();
 ```
 
-## Session Management
+### Using Sessions (Recommended)
 
 ```typescript
 import { createSession, TranscriptionProvider } from '@360labs/live-transcribe';
@@ -68,98 +113,730 @@ const session = createSession({
   language: 'en-US',
 });
 
-// Start, pause, resume, stop
+// Access the provider for events
+session.provider.on('transcript', (result) => {
+  console.log(result.text);
+
+  // Add to session for later export
+  if (result.isFinal) {
+    session.addTranscript(result);
+  }
+});
+
+// Lifecycle control
 await session.start();
-session.pause();
-session.resume();
+session.pause();    // Pause transcription
+session.resume();   // Resume transcription
 await session.stop();
 
-// Get transcripts and export
+// Get results
 const transcripts = session.getTranscripts();
-const exported = session.export('srt'); // json, text, srt, vtt, csv
+const fullText = session.getFullText();
+const stats = session.getStatistics();
+
+// Export in various formats
+const srtFile = session.export('srt');
+const jsonFile = session.export('json');
 ```
 
-## Provider Configuration
+---
+
+## Providers
 
 ### Web Speech API (Browser)
 
+The Web Speech API is built into modern browsers and requires no API key. It's perfect for quick prototypes and applications that don't need cloud-based accuracy.
+
 ```typescript
+import { createTranscriber, TranscriptionProvider } from '@360labs/live-transcribe';
+
 const transcriber = createTranscriber({
   provider: TranscriptionProvider.WebSpeechAPI,
   language: 'en-US',
-  interimResults: true,
+  interimResults: true,  // Get real-time interim results
 });
+
+// Check browser support
+if (transcriber.isSupported()) {
+  await transcriber.initialize();
+  await transcriber.start();
+}
 ```
 
+**Pros:**
+- No API key required
+- Free to use
+- Works offline (in some browsers)
+- Low latency
+
+**Cons:**
+- Accuracy varies by browser
+- Limited language support compared to cloud providers
+- Requires internet connection in most browsers
+
+---
+
 ### Deepgram
 
+[Deepgram](https://deepgram.com) offers high-accuracy, real-time transcription with advanced features like speaker diarization and custom vocabularies.
+
 ```typescript
+import { createTranscriber, TranscriptionProvider } from '@360labs/live-transcribe';
+
 const transcriber = createTranscriber({
   provider: TranscriptionProvider.Deepgram,
   apiKey: 'your-deepgram-api-key',
   language: 'en-US',
-  model: 'nova-2',
+  model: 'nova-2',           // Latest model
+  punctuate: true,           // Auto-punctuation
+  interimResults: true,
+});
+
+transcriber.on('transcript', (result) => {
+  console.log(result.text);
+  console.log('Confidence:', result.confidence);
 });
+
+await transcriber.initialize();
+await transcriber.start();
 ```
 
+**Configuration Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | string | required | Your Deepgram API key |
+| `model` | string | 'nova-2' | Model to use (nova-2, nova, enhanced, base) |
+| `language` | string | 'en-US' | Language code |
+| `punctuate` | boolean | true | Enable auto-punctuation |
+| `interimResults` | boolean | true | Enable interim results |
+| `smartFormat` | boolean | false | Enable smart formatting |
+| `diarize` | boolean | false | Enable speaker diarization |
+
+---
+
 ### AssemblyAI
 
+[AssemblyAI](https://assemblyai.com) provides state-of-the-art transcription with features like automatic language detection and content moderation.
+
 ```typescript
+import { createTranscriber, TranscriptionProvider } from '@360labs/live-transcribe';
+
 const transcriber = createTranscriber({
   provider: TranscriptionProvider.AssemblyAI,
   apiKey: 'your-assemblyai-api-key',
   sampleRate: 16000,
 });
+
+transcriber.on('transcript', (result) => {
+  console.log(result.text);
+});
+
+await transcriber.initialize();
+await transcriber.start();
 ```
 
-## Supported Languages
+**Configuration Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | string | required | Your AssemblyAI API key |
+| `sampleRate` | number | 16000 | Audio sample rate in Hz |
+| `wordBoost` | string[] | [] | Words to boost recognition |
+
+---
+
+### Custom Provider
+
+You can create custom providers by extending the `BaseTranscriber` class:
+
+```typescript
+import { BaseTranscriber, TranscriptionConfig, SessionState } from '@360labs/live-transcribe';
+
+class MyCustomProvider extends BaseTranscriber {
+  private recognition: any;
+
+  constructor(config: TranscriptionConfig) {
+    super(config);
+  }
+
+  isSupported(): boolean {
+    return true; // Check if your provider is available
+  }
+
+  async initialize(): Promise<void> {
+    // Initialize your provider
+    this.setState(SessionState.INITIALIZING);
+  }
+
+  async start(): Promise<void> {
+    this.setState(SessionState.ACTIVE);
+    this.emit('start');
+    // Start transcription
+  }
+
+  async stop(): Promise<void> {
+    this.setState(SessionState.STOPPED);
+    this.emit('stop');
+    // Stop transcription
+  }
+
+  pause(): void {
+    this.setState(SessionState.PAUSED);
+    this.emit('pause');
+  }
+
+  resume(): void {
+    this.setState(SessionState.ACTIVE);
+    this.emit('resume');
+  }
+
+  sendAudio(audioData: ArrayBuffer): void {
+    // Send audio to your provider
+  }
+
+  async cleanup(): Promise<void> {
+    // Clean up resources
+  }
+}
+```
 
-The library supports 40+ languages including:
+---
 
-- **English** (US, UK, Australia, India, Canada)
-- **Spanish** (Spain, Mexico, Argentina)
-- **French** (France, Canada)
-- **German** (Germany, Austria)
-- **Portuguese** (Brazil, Portugal)
-- **Chinese** (Simplified, Traditional)
-- **Japanese, Korean, Hindi**
-- **Arabic, Hebrew, Persian**
-- **Russian, Ukrainian, Polish**
-- And many more...
+## Session Management
+
+Sessions provide a higher-level API for managing transcription with built-in transcript storage and export capabilities.
+
+```typescript
+import { createSession, SessionManager, TranscriptionProvider } from '@360labs/live-transcribe';
+
+// Single session
+const session = createSession({
+  provider: TranscriptionProvider.WebSpeechAPI,
+  language: 'en-US',
+});
+
+// Session properties
+console.log(session.id);        // Unique session ID
+console.log(session.getState()); // Current state
+
+// Multiple sessions with SessionManager
+const manager = new SessionManager();
+
+const session1 = manager.createSession({
+  provider: TranscriptionProvider.WebSpeechAPI,
+  language: 'en-US',
+});
+
+const session2 = manager.createSession({
+  provider: TranscriptionProvider.WebSpeechAPI,
+  language: 'es-ES',
+});
+
+// Get all sessions
+const allSessions = manager.getAllSessions();
+
+// Get session by ID
+const session = manager.getSession('session-id');
+
+// Get active sessions
+const activeSessions = manager.getActiveSessions();
+```
+
+### Session States
+
+```typescript
+import { SessionState } from '@360labs/live-transcribe';
+
+// Available states
+SessionState.IDLE         // Initial state
+SessionState.INITIALIZING // Provider initializing
+SessionState.ACTIVE       // Transcription in progress
+SessionState.PAUSED       // Transcription paused
+SessionState.STOPPING     // Stopping transcription
+SessionState.STOPPED      // Transcription stopped
+SessionState.ERROR        // Error occurred
+```
+
+---
 
 ## Events
 
+Subscribe to events for real-time updates:
+
 ```typescript
-transcriber.on('transcript', (result) => { /* Real-time transcripts */ });
-transcriber.on('final', (result) => { /* Final transcripts only */ });
-transcriber.on('interim', (result) => { /* Interim transcripts only */ });
-transcriber.on('start', () => { /* Transcription started */ });
-transcriber.on('stop', () => { /* Transcription stopped */ });
-transcriber.on('pause', () => { /* Transcription paused */ });
-transcriber.on('resume', () => { /* Transcription resumed */ });
-transcriber.on('error', (error) => { /* Handle errors */ });
-transcriber.on('stateChange', (state) => { /* State changed */ });
+const transcriber = createTranscriber({ /* config */ });
+
+// Transcript events
+transcriber.on('transcript', (result) => {
+  console.log('Text:', result.text);
+  console.log('Is Final:', result.isFinal);
+  console.log('Confidence:', result.confidence);
+  console.log('Timestamp:', result.timestamp);
+});
+
+transcriber.on('final', (result) => {
+  // Only final transcripts
+  console.log('Final transcript:', result.text);
+});
+
+transcriber.on('interim', (result) => {
+  // Only interim transcripts
+  console.log('Interim:', result.text);
+});
+
+// Lifecycle events
+transcriber.on('start', () => {
+  console.log('Transcription started');
+});
+
+transcriber.on('stop', () => {
+  console.log('Transcription stopped');
+});
+
+transcriber.on('pause', () => {
+  console.log('Transcription paused');
+});
+
+transcriber.on('resume', () => {
+  console.log('Transcription resumed');
+});
+
+// State changes
+transcriber.on('stateChange', (state) => {
+  console.log('State changed to:', state);
+});
+
+// Error handling
+transcriber.on('error', (error) => {
+  console.error('Error code:', error.code);
+  console.error('Error message:', error.message);
+  console.error('Provider:', error.provider);
+});
+
+// Remove listeners
+transcriber.off('transcript', myHandler);
+transcriber.removeAllListeners();
 ```
 
+### TranscriptionResult Object
+
+```typescript
+interface TranscriptionResult {
+  text: string;           // Transcribed text
+  isFinal: boolean;       // Is this a final result?
+  confidence?: number;    // Confidence score (0-1)
+  timestamp: number;      // Unix timestamp
+  speaker?: string;       // Speaker ID (if diarization enabled)
+  language?: string;      // Detected language
+  words?: Word[];         // Word-level timing
+}
+
+interface Word {
+  text: string;
+  start: number;  // Start time in ms
+  end: number;    // End time in ms
+  confidence?: number;
+}
+```
+
+---
+
+## Export Formats
+
+Export transcripts in multiple formats:
+
+```typescript
+const session = createSession({ /* config */ });
+
+// Add transcripts during session
+session.provider.on('transcript', (result) => {
+  if (result.isFinal) {
+    session.addTranscript(result);
+  }
+});
+
+// After transcription, export in various formats
+
+// JSON - Full data with metadata
+const jsonExport = session.export('json');
+console.log(jsonExport.data);     // JSON string
+console.log(jsonExport.filename); // 'transcript-{id}.json'
+console.log(jsonExport.mimeType); // 'application/json'
+
+// Plain Text - Just the text
+const textExport = session.export('text');
+// Output: "Hello world. How are you today?"
+
+// SRT - SubRip subtitles
+const srtExport = session.export('srt');
+// Output:
+// 1
+// 00:00:01,000 --> 00:00:03,500
+// Hello world.
+//
+// 2
+// 00:00:04,000 --> 00:00:06,500
+// How are you today?
+
+// VTT - WebVTT subtitles
+const vttExport = session.export('vtt');
+// Output:
+// WEBVTT
+//
+// 00:00:01.000 --> 00:00:03.500
+// Hello world.
+//
+// 00:00:04.000 --> 00:00:06.500
+// How are you today?
+
+// CSV - Spreadsheet format
+const csvExport = session.export('csv');
+// Output: timestamp,text,confidence,isFinal
+// 1234567890,Hello world,0.95,true
+
+// Download in browser
+function downloadTranscript(format: string) {
+  const exported = session.export(format);
+  const blob = new Blob([exported.data], { type: exported.mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = exported.filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+```
+
+---
+
+## Supported Languages
+
+The library supports 40+ languages. Language support varies by provider.
+
+### Web Speech API Languages
+
+| Language | Code | Language | Code |
+|----------|------|----------|------|
+| English (US) | `en-US` | English (UK) | `en-GB` |
+| English (Australia) | `en-AU` | English (India) | `en-IN` |
+| Spanish (Spain) | `es-ES` | Spanish (Mexico) | `es-MX` |
+| French (France) | `fr-FR` | French (Canada) | `fr-CA` |
+| German | `de-DE` | Italian | `it-IT` |
+| Portuguese (Brazil) | `pt-BR` | Portuguese (Portugal) | `pt-PT` |
+| Chinese (Simplified) | `zh-CN` | Chinese (Traditional) | `zh-TW` |
+| Japanese | `ja-JP` | Korean | `ko-KR` |
+| Hindi | `hi-IN` | Arabic (Saudi Arabia) | `ar-SA` |
+| Russian | `ru-RU` | Dutch | `nl-NL` |
+| Polish | `pl-PL` | Turkish | `tr-TR` |
+| Thai | `th-TH` | Vietnamese | `vi-VN` |
+| Indonesian | `id-ID` | Hebrew | `he-IL` |
+| Czech | `cs-CZ` | Greek | `el-GR` |
+| Swedish | `sv-SE` | Danish | `da-DK` |
+| Finnish | `fi-FI` | Norwegian | `no-NO` |
+| Ukrainian | `uk-UA` | Romanian | `ro-RO` |
+| Hungarian | `hu-HU` | Malay | `ms-MY` |
+
+### Setting Language
+
+```typescript
+// At creation
+const transcriber = createTranscriber({
+  provider: TranscriptionProvider.WebSpeechAPI,
+  language: 'es-ES', // Spanish (Spain)
+});
+
+// Or use session
+const session = createSession({
+  provider: TranscriptionProvider.WebSpeechAPI,
+  language: 'fr-FR', // French
+});
+```
+
+---
+
+## API Reference
+
+### createTranscriber(config)
+
+Creates a new transcriber instance.
+
+```typescript
+function createTranscriber(config: TranscriptionConfig): ITranscriptionProvider;
+```
+
+**Config Options:**
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `provider` | TranscriptionProvider | Yes | - | Provider to use |
+| `apiKey` | string | For cloud | - | API key for cloud providers |
+| `language` | string | No | 'en-US' | Language code |
+| `interimResults` | boolean | No | true | Enable interim results |
+| `punctuation` | boolean | No | true | Enable auto-punctuation |
+| `profanityFilter` | boolean | No | false | Filter profanity |
+
+### createSession(config)
+
+Creates a new transcription session.
+
+```typescript
+function createSession(config: TranscriptionConfig): TranscriptionSession;
+```
+
+### TranscriptionSession
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `start()` | Promise<void> | Start transcription |
+| `stop()` | Promise<void> | Stop transcription |
+| `pause()` | void | Pause transcription |
+| `resume()` | void | Resume transcription |
+| `getState()` | SessionState | Get current state |
+| `getTranscripts(finalOnly?)` | TranscriptionResult[] | Get all transcripts |
+| `getFullText()` | string | Get concatenated text |
+| `getStatistics()` | SessionStatistics | Get session stats |
+| `addTranscript(result)` | void | Add a transcript |
+| `export(format)` | ExportResult | Export transcripts |
+
+### SessionStatistics
+
+```typescript
+interface SessionStatistics {
+  wordCount: number;
+  transcriptCount: number;
+  duration: number;
+  averageConfidence: number;
+}
+```
+
+---
+
 ## Examples
 
-Check out the [examples](./examples) directory for more usage examples:
+### React Integration
+
+```tsx
+import React, { useState, useEffect, useRef } from 'react';
+import { createSession, TranscriptionProvider, TranscriptionSession } from '@360labs/live-transcribe';
+
+function TranscriptionComponent() {
+  const [isRecording, setIsRecording] = useState(false);
+  const [transcript, setTranscript] = useState('');
+  const sessionRef = useRef<TranscriptionSession | null>(null);
+
+  useEffect(() => {
+    return () => {
+      sessionRef.current?.stop();
+    };
+  }, []);
+
+  const startRecording = async () => {
+    const session = createSession({
+      provider: TranscriptionProvider.WebSpeechAPI,
+      language: 'en-US',
+    });
+
+    session.provider.on('transcript', (result) => {
+      if (result.isFinal) {
+        setTranscript(prev => prev + ' ' + result.text);
+        session.addTranscript(result);
+      }
+    });
+
+    sessionRef.current = session;
+    await session.start();
+    setIsRecording(true);
+  };
+
+  const stopRecording = async () => {
+    await sessionRef.current?.stop();
+    setIsRecording(false);
+  };
+
+  return (
+    <div>
+      <button onClick={isRecording ? stopRecording : startRecording}>
+        {isRecording ? 'Stop' : 'Start'} Recording
+      </button>
+      <p>{transcript}</p>
+    </div>
+  );
+}
+```
 
-- Basic transcription
-- React integration
-- Vue integration
-- Multiple providers
-- Session management
-- Export formats
-- Custom providers
+### Vue Integration
 
-## API Documentation
+```vue
+<template>
+  <div>
+    <button @click="toggleRecording">
+      {{ isRecording ? 'Stop' : 'Start' }} Recording
+    </button>
+    <p>{{ transcript }}</p>
+  </div>
+</template>
 
-See the [API Documentation](./docs/api.md) for detailed information on all available methods and options.
+<script setup lang="ts">
+import { ref, onUnmounted } from 'vue';
+import { createSession, TranscriptionProvider } from '@360labs/live-transcribe';
+
+const isRecording = ref(false);
+const transcript = ref('');
+let session: any = null;
+
+const toggleRecording = async () => {
+  if (isRecording.value) {
+    await session?.stop();
+    isRecording.value = false;
+  } else {
+    session = createSession({
+      provider: TranscriptionProvider.WebSpeechAPI,
+      language: 'en-US',
+    });
+
+    session.provider.on('transcript', (result: any) => {
+      if (result.isFinal) {
+        transcript.value += ' ' + result.text;
+      }
+    });
+
+    await session.start();
+    isRecording.value = true;
+  }
+};
+
+onUnmounted(() => {
+  session?.stop();
+});
+</script>
+```
+
+### Node.js with Deepgram
+
+```typescript
+import { createTranscriber, TranscriptionProvider } from '@360labs/live-transcribe';
+import { createReadStream } from 'fs';
+
+const transcriber = createTranscriber({
+  provider: TranscriptionProvider.Deepgram,
+  apiKey: process.env.DEEPGRAM_API_KEY,
+  language: 'en-US',
+});
+
+transcriber.on('transcript', (result) => {
+  console.log(result.text);
+});
+
+await transcriber.initialize();
+await transcriber.start();
+
+// Send audio data
+const audioStream = createReadStream('audio.wav');
+audioStream.on('data', (chunk) => {
+  transcriber.sendAudio(chunk);
+});
+
+audioStream.on('end', async () => {
+  await transcriber.stop();
+});
+```
+
+---
+
+## Browser Support
+
+| Browser | Web Speech API | WebSocket (Cloud) |
+|---------|---------------|-------------------|
+| Chrome 33+ | ✅ Full | ✅ Full |
+| Edge 79+ | ✅ Full | ✅ Full |
+| Safari 14.1+ | ✅ Partial | ✅ Full |
+| Firefox | ❌ | ✅ Full |
+| Opera 20+ | ✅ Full | ✅ Full |
+
+**Note:** Web Speech API requires an internet connection in most browsers as it uses cloud-based recognition.
+
+---
+
+## Error Handling
+
+```typescript
+import { TranscriptionError, ErrorCode } from '@360labs/live-transcribe';
+
+transcriber.on('error', (error: TranscriptionError) => {
+  switch (error.code) {
+    case ErrorCode.MICROPHONE_ACCESS_DENIED:
+      console.log('Please allow microphone access');
+      break;
+    case ErrorCode.NETWORK_ERROR:
+      console.log('Network error - check your connection');
+      break;
+    case ErrorCode.AUTHENTICATION_FAILED:
+      console.log('Invalid API key');
+      break;
+    case ErrorCode.UNSUPPORTED_BROWSER:
+      console.log('Browser not supported');
+      break;
+    default:
+      console.log('Error:', error.message);
+  }
+});
+```
+
+### Error Codes
+
+| Code | Description |
+|------|-------------|
+| `INITIALIZATION_FAILED` | Provider failed to initialize |
+| `AUTHENTICATION_FAILED` | Invalid or missing API key |
+| `NETWORK_ERROR` | Network connection error |
+| `MICROPHONE_ACCESS_DENIED` | Microphone permission denied |
+| `UNSUPPORTED_BROWSER` | Browser doesn't support required APIs |
+| `INVALID_CONFIG` | Invalid configuration provided |
+| `PROVIDER_ERROR` | Provider-specific error |
+| `UNKNOWN_ERROR` | Unknown error occurred |
+
+---
+
+## Audio Processing Utilities
+
+The library includes audio processing utilities:
+
+```typescript
+import { AudioProcessor } from '@360labs/live-transcribe';
+
+// Convert Float32 to Int16 (for sending to APIs)
+const int16Data = AudioProcessor.convertFloat32ToInt16(float32Array);
+
+// Convert Int16 to Float32
+const float32Data = AudioProcessor.convertInt16ToFloat32(int16Array);
+
+// Resample audio
+const resampled = AudioProcessor.resampleBuffer(buffer, 44100, 16000);
+
+// Normalize audio levels
+const normalized = AudioProcessor.normalizeBuffer(buffer);
+
+// Apply gain
+const amplified = AudioProcessor.applyGain(buffer, 1.5);
+
+// Mix two audio buffers
+const mixed = AudioProcessor.mixBuffers(buffer1, buffer2, 0.5);
+```
+
+---
 
 ## Contributing
 
-Contributions are welcome! Please read our [Contributing Guide](./CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+We welcome contributions! Please see our [Contributing Guide](./CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+---
 
 ## License
 
@@ -167,4 +844,11 @@ This project is licensed under the MIT License - see the [LICENSE](./LICENSE) fi
 
 ---
 
-**Made with care by 360labs**
+## Support
+
+- **Issues:** [GitHub Issues](https://github.com/360labs/live-transcribe/issues)
+- **Discussions:** [GitHub Discussions](https://github.com/360labs/live-transcribe/discussions)
+
+---
+
+**Made with ❤️ by 360labs**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@360labs/live-transcribe",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Professional live speech transcription library for TypeScript/JavaScript with multi-provider support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",