@charivo/stt-core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zeikar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,463 @@
+# @charivo/stt-core
+
+Core STT (Speech-to-Text) functionality with transcription coordination, event emission, and shared utilities for Charivo.
+
+## Features
+
+- 🎤 **Transcription Coordination** - Manages STT transcribers with unified API
+- 📡 **Event Bus Integration** - Emit audio events for recording lifecycle
+- 🛠️ **MediaRecorder Helper** - Shared audio recording utility for transcribers
+- 🔌 **Transcriber Agnostic** - Works with any STT transcriber (Web, OpenAI, Remote, etc.)
+
+## Installation
+
+```bash
+pnpm add @charivo/stt-core @charivo/core
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { createSTTManager } from "@charivo/stt-core";
+import { createRemoteSTTTranscriber } from "@charivo/stt-transcriber-remote";
+
+// Create a STT transcriber
+const transcriber = createRemoteSTTTranscriber({
+  apiEndpoint: "/api/stt"
+});
+
+// Wrap with STTManager for event emission and coordination
+const sttManager = createSTTManager(transcriber);
+
+// Start recording (handled internally by transcriber)
+await sttManager.start();
+
+// Stop recording and get transcription
+const transcription = await sttManager.stop();
+console.log("User said:", transcription);
+```
+
+### With Event Bus
+
+```typescript
+import { EventBus } from "@charivo/core";
+
+const eventBus = new EventBus();
+const sttManager = createSTTManager(transcriber);
+
+// Connect event bus
+sttManager.setEventEmitter({
+  emit: (event, data) => eventBus.emit(event, data)
+});
+
+// Listen to events
+eventBus.on("stt:start", (data) => {
+  console.log("Recording started", data);
+});
+
+eventBus.on("stt:stop", (data) => {
+  console.log("Transcription:", data.transcription);
+});
+
+eventBus.on("stt:error", (data) => {
+  console.error("STT error:", data.error);
+});
+
+// Start recording
+await sttManager.start();
+// → "stt:start" emitted
+
+// Stop and transcribe
+const text = await sttManager.stop();
+// → Recording stops (handled by transcriber)
+// → Audio is transcribed
+// → "stt:stop" emitted with transcription
+```
+
+### Custom STT Transcriber
+
+Each transcriber handles recording internally:
+
+```typescript
+import { STTTranscriber, STTOptions } from "@charivo/core";
+import { MediaRecorderHelper, createSTTManager } from "@charivo/stt-core";
+
+class MyCustomSTTTranscriber implements STTTranscriber {
+  private recorder = new MediaRecorderHelper();
+  private recordingOptions?: STTOptions;
+
+  async startRecording(options?: STTOptions): Promise<void> {
+    this.recordingOptions = options;
+    await this.recorder.start();
+  }
+
+  async stopRecording(): Promise<string> {
+    const audioBlob = await this.recorder.stop();
+
+    // Call your STT API
+    const formData = new FormData();
+    formData.append("audio", audioBlob);
+    if (this.recordingOptions?.language) {
+      formData.append("language", this.recordingOptions.language);
+    }
+
+    const response = await fetch("https://my-stt-api.com/transcribe", {
+      method: "POST",
+      body: formData
+    });
+
+    const data = await response.json();
+    this.recordingOptions = undefined;
+    return data.transcription;
+  }
+
+  isRecording(): boolean {
+    return this.recorder.isRecording();
+  }
+}
+
+const sttManager = createSTTManager(new MyCustomSTTTranscriber());
+```
+
+### Check Recording State
+
+```typescript
+// Check if currently recording
+if (sttManager.isRecording()) {
+  console.log("Recording in progress...");
+} else {
+  console.log("Not recording");
+}
+```
+
+## API Reference
+
+### `STTManager`
+
+Main class for coordinating STT transcription and emitting events.
+
+#### Constructor
+
+```typescript
+new STTManager(transcriber: STTTranscriber)
+```
+
+#### Methods
+
+##### `setEventEmitter(eventEmitter)`
+Connect event emitter for STT event emission.
+
+```typescript
+sttManager.setEventEmitter({
+  emit: (event, data) => { /* ... */ }
+});
+```
+
+When set, the manager emits:
+- `stt:start` with `{ options?: STTOptions }` when recording starts
+- `stt:stop` with `{ transcription: string }` when transcription completes
+- `stt:error` with `{ error: Error }` when an error occurs
+
+##### `start(options?)`
+Start audio recording (delegates to transcriber).
+
+```typescript
+await sttManager.start();
+
+// With language option
+await sttManager.start({ language: "en-US" });
+```
+
+The transcriber handles microphone access and recording internally.
+
+##### `stop()`
+Stop recording and get transcribed text (delegates to transcriber).
+
+```typescript
+const transcription = await sttManager.stop();
+console.log("User said:", transcription);
+```
+
+Returns the transcribed text as a string.
+
+##### `isRecording()`
+Check if currently recording (delegates to transcriber).
+
+```typescript
+if (sttManager.isRecording()) {
+  console.log("Recording...");
+}
+```
+
+### `MediaRecorderHelper`
+
+Shared utility for audio recording (used by blob-based transcribers).
+
+#### Methods
+
+##### `start()`
+Start audio recording from microphone.
+
+```typescript
+const recorder = new MediaRecorderHelper();
+await recorder.start();
+```
+
+##### `stop()`
+Stop recording and return audio blob.
+
+```typescript
+const audioBlob = await recorder.stop();
+```
+
+##### `isRecording()`
+Check if currently recording.
+
+```typescript
+if (recorder.isRecording()) {
+  console.log("Recording...");
+}
+```
+
+##### `abort()`
+Abort recording immediately without returning data.
+
+```typescript
+recorder.abort();
+```
+
+## Events
+
+### `stt:start`
+
+Emitted when audio recording starts.
+
+```typescript
+{
+  options?: STTOptions
+}
+```
+
+Use this to:
+- Show "recording" indicator
+- Disable other audio inputs
+- Update UI state
+
+### `stt:stop`
+
+Emitted when audio recording stops and transcription completes.
+
+```typescript
+{
+  transcription: string
+}
+```
+
+Use this to:
+- Display transcribed text
+- Hide "recording" indicator
+- Process user input
+
+### `stt:error`
+
+Emitted when an error occurs during recording or transcription.
+
+```typescript
+{
+  error: Error
+}
+```
+
+Use this to:
+- Show error message to user
+- Clean up UI state
+- Retry logic
+
+## Integration with Charivo
+
+The STT system integrates seamlessly with the Charivo framework:
+
+```typescript
+import { Charivo } from "@charivo/core";
+import { createSTTManager } from "@charivo/stt-core";
+import { createWebSTTTranscriber } from "@charivo/stt-transcriber-web";
+
+const charivo = new Charivo();
+
+// Setup STT
+const transcriber = createWebSTTTranscriber();
+const sttManager = createSTTManager(transcriber);
+charivo.attachSTT(sttManager);
+
+// Start voice input
+await sttManager.start();
+
+// Stop and automatically send to character
+const transcription = await sttManager.stop();
+await charivo.userSay(transcription);
+// → Character responds with voice and animation
+```
+
+## Architecture
+
+```
+STTManager (coordination layer)
+  ├─ Event Emission
+  └─ STTTranscriber (handles recording internally)
+      ├─ WebSTTTranscriber
+      │   └─ Web Speech API (real-time)
+      ├─ OpenAISTTTranscriber
+      │   ├─ MediaRecorderHelper
+      │   └─ OpenAI Whisper API
+      └─ RemoteSTTTranscriber
+          ├─ MediaRecorderHelper
+          └─ Your Server API
+```
+
+## Available Transcribers
+
+### Web STT Transcriber (Free, Browser-native) ⭐ Recommended
+
+```bash
+pnpm add @charivo/stt-transcriber-web
+```
+
+```typescript
+import { createWebSTTTranscriber } from "@charivo/stt-transcriber-web";
+
+const transcriber = createWebSTTTranscriber();
+const sttManager = createSTTManager(transcriber);
+
+// Works with STTManager!
+await sttManager.start({ language: "en-US" });
+const text = await sttManager.stop();
+```
+
+Uses browser's built-in Web Speech API (no API key needed).
+
+**Advantages:**
+- 🆓 Completely free
+- ⚡ Real-time recognition
+- 🔒 No server required
+- 🎯 Perfect for development and production
+
+### Remote STT Transcriber (Production-ready)
+
+```bash
+pnpm add @charivo/stt-transcriber-remote
+```
+
+```typescript
+import { createRemoteSTTTranscriber } from "@charivo/stt-transcriber-remote";
+
+const transcriber = createRemoteSTTTranscriber({
+  apiEndpoint: "/api/stt" // Your server endpoint
+});
+```
+
+Calls your server API to keep credentials secure.
+
+### OpenAI STT Transcriber (Development/Testing Only)
+
+```bash
+pnpm add @charivo/stt-transcriber-openai
+```
+
+```typescript
+import { createOpenAISTTTranscriber } from "@charivo/stt-transcriber-openai";
+
+const transcriber = createOpenAISTTTranscriber({
+  apiKey: "your-api-key", // ⚠️ Exposed on client
+  defaultLanguage: "en"
+});
+```
+
+⚠️ **Warning**: API key is exposed on the client. Only use for development/testing.
+
+## Browser Compatibility
+
+STT transcribers use different browser APIs:
+
+**MediaRecorderHelper** (OpenAI/Remote):
+- Chrome/Edge 49+
+- Firefox 29+
+- Safari 14.1+
+
+**Web Speech API** (Web):
+- Chrome/Edge (fully supported)
+- Safari (limited support)
+- Firefox (not supported)
+
+## Error Handling
+
+```typescript
+try {
+  await sttManager.start();
+  const transcription = await sttManager.stop();
+} catch (error) {
+  if (error.name === "NotAllowedError") {
+    console.error("Microphone permission denied");
+  } else if (error.name === "NotFoundError") {
+    console.error("No microphone found");
+  } else {
+    console.error("STT error:", error);
+  }
+}
+```
+
+Common errors:
+- `NotAllowedError` - User denied microphone permission
+- `NotFoundError` - No microphone device available
+- `NotReadableError` - Microphone is already in use
+- Network errors - Transcription API failed
+
+## Best Practices
+
+1. **Use Web STT for most cases**: Free, fast, and browser-native
+2. **Request permission early**: Test microphone access before starting recording
+3. **Show recording indicator**: Always show visual feedback when recording
+4. **Handle errors gracefully**: Provide clear error messages to users
+
+```typescript
+// React example
+function VoiceInput() {
+  const [recording, setRecording] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleStart = async () => {
+    try {
+      setError(null);
+      await sttManager.start();
+      setRecording(true);
+    } catch (err) {
+      setError("Failed to start recording");
+    }
+  };
+
+  const handleStop = async () => {
+    try {
+      const text = await sttManager.stop();
+      setRecording(false);
+      onTranscription(text);
+    } catch (err) {
+      setError("Failed to transcribe");
+      setRecording(false);
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={recording ? handleStop : handleStart}>
+        {recording ? "Stop" : "Start"} Recording
+      </button>
+      {error && <div className="error">{error}</div>}
+    </div>
+  );
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,70 @@
+import { STTManager, STTTranscriber, STTOptions } from '@charivo/core';
+
+/**
+ * STT Manager - Manages STT session state
+ *
+ * Simplified design: Delegates to STTTranscriber
+ * - STTTranscriber handles recording internally
+ * - Manager only handles event emission
+ * - Thin wrapper for consistent API
+ */
+declare class STTManagerImpl implements STTManager {
+    private sttTranscriber;
+    private eventEmitter?;
+    constructor(sttTranscriber: STTTranscriber);
+    /**
+     * Set event emitter for STT events
+     */
+    setEventEmitter(eventEmitter: {
+        emit: (event: string, data: any) => void;
+    }): void;
+    /**
+     * Start audio recording (delegates to transcriber)
+     */
+    start(options?: STTOptions): Promise<void>;
+    /**
+     * Stop audio recording and get transcription (delegates to transcriber)
+     */
+    stop(): Promise<string>;
+    /**
+     * Check if currently recording (delegates to transcriber)
+     */
+    isRecording(): boolean;
+}
+/**
+ * Helper function to create STT Manager
+ */
+declare function createSTTManager(sttTranscriber: STTTranscriber): STTManager;
+
+/**
+ * MediaRecorderHelper - Browser audio recording utility
+ *
+ * Handles MediaRecorder lifecycle:
+ * - Start/stop recording
+ * - Audio chunk collection
+ * - Stream cleanup
+ * - Blob generation
+ */
+declare class MediaRecorderHelper {
+    private mediaRecorder;
+    private audioChunks;
+    private recording;
+    /**
+     * Start audio recording from user's microphone
+     */
+    start(): Promise<void>;
+    /**
+     * Stop audio recording and return the recorded audio as a Blob
+     */
+    stop(): Promise<Blob>;
+    /**
+     * Check if currently recording
+     */
+    isRecording(): boolean;
+    /**
+     * Abort recording immediately without returning data
+     */
+    abort(): void;
+}
+
+export { MediaRecorderHelper, STTManagerImpl, createSTTManager };

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { STTManager, STTTranscriber, STTOptions } from '@charivo/core';
+
+/**
+ * STT Manager - Manages STT session state
+ *
+ * Simplified design: Delegates to STTTranscriber
+ * - STTTranscriber handles recording internally
+ * - Manager only handles event emission
+ * - Thin wrapper for consistent API
+ */
+declare class STTManagerImpl implements STTManager {
+    private sttTranscriber;
+    private eventEmitter?;
+    constructor(sttTranscriber: STTTranscriber);
+    /**
+     * Set event emitter for STT events
+     */
+    setEventEmitter(eventEmitter: {
+        emit: (event: string, data: any) => void;
+    }): void;
+    /**
+     * Start audio recording (delegates to transcriber)
+     */
+    start(options?: STTOptions): Promise<void>;
+    /**
+     * Stop audio recording and get transcription (delegates to transcriber)
+     */
+    stop(): Promise<string>;
+    /**
+     * Check if currently recording (delegates to transcriber)
+     */
+    isRecording(): boolean;
+}
+/**
+ * Helper function to create STT Manager
+ */
+declare function createSTTManager(sttTranscriber: STTTranscriber): STTManager;
+
+/**
+ * MediaRecorderHelper - Browser audio recording utility
+ *
+ * Handles MediaRecorder lifecycle:
+ * - Start/stop recording
+ * - Audio chunk collection
+ * - Stream cleanup
+ * - Blob generation
+ */
+declare class MediaRecorderHelper {
+    private mediaRecorder;
+    private audioChunks;
+    private recording;
+    /**
+     * Start audio recording from user's microphone
+     */
+    start(): Promise<void>;
+    /**
+     * Stop audio recording and return the recorded audio as a Blob
+     */
+    stop(): Promise<Blob>;
+    /**
+     * Check if currently recording
+     */
+    isRecording(): boolean;
+    /**
+     * Abort recording immediately without returning data
+     */
+    abort(): void;
+}
+
+export { MediaRecorderHelper, STTManagerImpl, createSTTManager };

package/dist/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MediaRecorderHelper: () => MediaRecorderHelper,
+  STTManagerImpl: () => STTManagerImpl,
+  createSTTManager: () => createSTTManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/stt-manager.ts
+var STTManagerImpl = class {
+  sttTranscriber;
+  eventEmitter;
+  constructor(sttTranscriber) {
+    this.sttTranscriber = sttTranscriber;
+  }
+  /**
+   * Set event emitter for STT events
+   */
+  setEventEmitter(eventEmitter) {
+    console.log("\u{1F517} STT Manager: Event emitter connected");
+    this.eventEmitter = eventEmitter;
+  }
+  /**
+   * Start audio recording (delegates to transcriber)
+   */
+  async start(options) {
+    console.log("\u{1F3A4} STT Manager: Starting recording", options);
+    this.eventEmitter?.emit("stt:start", { options });
+    try {
+      await this.sttTranscriber.startRecording(options);
+      console.log("\u2705 STT Manager: Recording started");
+    } catch (error) {
+      console.error("\u274C STT Manager: Recording failed", error);
+      this.eventEmitter?.emit("stt:error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Stop audio recording and get transcription (delegates to transcriber)
+   */
+  async stop() {
+    console.log("\u{1F6D1} STT Manager: Stopping recording");
+    try {
+      const transcription = await this.sttTranscriber.stopRecording();
+      console.log("\u2705 STT Manager: Transcription completed", transcription);
+      this.eventEmitter?.emit("stt:stop", { transcription });
+      return transcription;
+    } catch (error) {
+      console.error("\u274C STT Manager: Transcription failed", error);
+      this.eventEmitter?.emit("stt:error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Check if currently recording (delegates to transcriber)
+   */
+  isRecording() {
+    return this.sttTranscriber.isRecording();
+  }
+};
+function createSTTManager(sttTranscriber) {
+  return new STTManagerImpl(sttTranscriber);
+}
+
+// src/media-recorder-helper.ts
+var MediaRecorderHelper = class {
+  mediaRecorder = null;
+  audioChunks = [];
+  recording = false;
+  /**
+   * Start audio recording from user's microphone
+   */
+  async start() {
+    if (this.recording) {
+      throw new Error("Already recording");
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    this.mediaRecorder = new MediaRecorder(stream);
+    this.audioChunks = [];
+    this.mediaRecorder.ondataavailable = (event) => {
+      if (event.data.size > 0) {
+        this.audioChunks.push(event.data);
+      }
+    };
+    this.mediaRecorder.start();
+    this.recording = true;
+  }
+  /**
+   * Stop audio recording and return the recorded audio as a Blob
+   */
+  async stop() {
+    if (!this.recording || !this.mediaRecorder) {
+      throw new Error("Not recording");
+    }
+    return new Promise((resolve, reject) => {
+      this.mediaRecorder.onstop = () => {
+        const audioBlob = new Blob(this.audioChunks, { type: "audio/webm" });
+        this.audioChunks = [];
+        this.mediaRecorder?.stream.getTracks().forEach((track) => track.stop());
+        this.mediaRecorder = null;
+        this.recording = false;
+        resolve(audioBlob);
+      };
+      this.mediaRecorder.onerror = (error) => {
+        this.recording = false;
+        reject(error);
+      };
+      this.mediaRecorder.stop();
+    });
+  }
+  /**
+   * Check if currently recording
+   */
+  isRecording() {
+    return this.recording;
+  }
+  /**
+   * Abort recording immediately without returning data
+   */
+  abort() {
+    if (this.mediaRecorder) {
+      this.mediaRecorder.stream.getTracks().forEach((track) => track.stop());
+      this.mediaRecorder = null;
+      this.audioChunks = [];
+      this.recording = false;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MediaRecorderHelper,
+  STTManagerImpl,
+  createSTTManager
+});

package/dist/index.mjs

@@ -0,0 +1,125 @@
+// src/stt-manager.ts
+var STTManagerImpl = class {
+  sttTranscriber;
+  eventEmitter;
+  constructor(sttTranscriber) {
+    this.sttTranscriber = sttTranscriber;
+  }
+  /**
+   * Set event emitter for STT events
+   */
+  setEventEmitter(eventEmitter) {
+    console.log("\u{1F517} STT Manager: Event emitter connected");
+    this.eventEmitter = eventEmitter;
+  }
+  /**
+   * Start audio recording (delegates to transcriber)
+   */
+  async start(options) {
+    console.log("\u{1F3A4} STT Manager: Starting recording", options);
+    this.eventEmitter?.emit("stt:start", { options });
+    try {
+      await this.sttTranscriber.startRecording(options);
+      console.log("\u2705 STT Manager: Recording started");
+    } catch (error) {
+      console.error("\u274C STT Manager: Recording failed", error);
+      this.eventEmitter?.emit("stt:error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Stop audio recording and get transcription (delegates to transcriber)
+   */
+  async stop() {
+    console.log("\u{1F6D1} STT Manager: Stopping recording");
+    try {
+      const transcription = await this.sttTranscriber.stopRecording();
+      console.log("\u2705 STT Manager: Transcription completed", transcription);
+      this.eventEmitter?.emit("stt:stop", { transcription });
+      return transcription;
+    } catch (error) {
+      console.error("\u274C STT Manager: Transcription failed", error);
+      this.eventEmitter?.emit("stt:error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Check if currently recording (delegates to transcriber)
+   */
+  isRecording() {
+    return this.sttTranscriber.isRecording();
+  }
+};
+function createSTTManager(sttTranscriber) {
+  return new STTManagerImpl(sttTranscriber);
+}
+
+// src/media-recorder-helper.ts
+var MediaRecorderHelper = class {
+  mediaRecorder = null;
+  audioChunks = [];
+  recording = false;
+  /**
+   * Start audio recording from user's microphone
+   */
+  async start() {
+    if (this.recording) {
+      throw new Error("Already recording");
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    this.mediaRecorder = new MediaRecorder(stream);
+    this.audioChunks = [];
+    this.mediaRecorder.ondataavailable = (event) => {
+      if (event.data.size > 0) {
+        this.audioChunks.push(event.data);
+      }
+    };
+    this.mediaRecorder.start();
+    this.recording = true;
+  }
+  /**
+   * Stop audio recording and return the recorded audio as a Blob
+   */
+  async stop() {
+    if (!this.recording || !this.mediaRecorder) {
+      throw new Error("Not recording");
+    }
+    return new Promise((resolve, reject) => {
+      this.mediaRecorder.onstop = () => {
+        const audioBlob = new Blob(this.audioChunks, { type: "audio/webm" });
+        this.audioChunks = [];
+        this.mediaRecorder?.stream.getTracks().forEach((track) => track.stop());
+        this.mediaRecorder = null;
+        this.recording = false;
+        resolve(audioBlob);
+      };
+      this.mediaRecorder.onerror = (error) => {
+        this.recording = false;
+        reject(error);
+      };
+      this.mediaRecorder.stop();
+    });
+  }
+  /**
+   * Check if currently recording
+   */
+  isRecording() {
+    return this.recording;
+  }
+  /**
+   * Abort recording immediately without returning data
+   */
+  abort() {
+    if (this.mediaRecorder) {
+      this.mediaRecorder.stream.getTracks().forEach((track) => track.stop());
+      this.mediaRecorder = null;
+      this.audioChunks = [];
+      this.recording = false;
+    }
+  }
+};
+export {
+  MediaRecorderHelper,
+  STTManagerImpl,
+  createSTTManager
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@charivo/stt-core",
+  "version": "0.0.1",
+  "description": "Core STT functionality for Charivo framework",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "charivo",
+    "stt",
+    "speech-to-text",
+    "audio",
+    "transcription"
+  ],
+  "dependencies": {
+    "@charivo/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@charivo/shared": "0.0.1"
+  },
+  "peerDependencies": {},
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeikar/charivo.git",
+    "directory": "packages/stt-core"
+  },
+  "author": {
+    "name": "Zeikar",
+    "url": "https://github.com/zeikar"
+  },
+  "homepage": "https://github.com/zeikar/charivo#readme",
+  "bugs": {
+    "url": "https://github.com/zeikar/charivo/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "clean": "rm -rf dist"
+  }
+}