@fenixforce/edition-voices 0.1.0

package/dist/teacher/loop/teaching-loop.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Teaching Loop — Autonomous teaching loop called by the scheduler.
+ *
+ * Decision tree:
+ *  1. Skip if practiceFrequency is 'on-demand'
+ *  2. Skip if outside 30-min window of preferredPracticeTime
+ *  3. Check due review items → send practice exercise
+ *  4. Check inactivity → send nudge
+ *  5. Check milestones → send celebration
+ *  6. Nothing due → skip silently
+ */
+import type { LearnerProfile } from "../learner-model.js";
+import type { Exercise } from "../exercises/generator.js";
+import type { MessageEnvelope, Milestone } from "./message-builder.js";
+export interface TeachingLoopConfig {
+    enabled: boolean;
+    defaultSchedule: string;
+    inactivityNudgeDays: number;
+    milestoneThresholds: {
+        vocabulary: number[];
+        streak: number[];
+        unitCompletion: boolean;
+    };
+}
+export declare const DEFAULT_CONFIG: TeachingLoopConfig;
+export interface DueReviewItems {
+    vocab: {
+        id: string;
+        word?: string;
+    }[];
+    grammar: {
+        id: string;
+        concept?: string;
+    }[];
+}
+export interface ProgressSummary {
+    totalVocab: number;
+    completedUnits: number;
+}
+export interface TeachingLoopDeps {
+    getLearner: (learnerId: string) => Promise<LearnerProfile | null>;
+    getDueReviewItems: (learnerId: string) => Promise<DueReviewItems>;
+    getProgress: (learnerId: string) => Promise<ProgressSummary>;
+    generateReviewExercise: (learnerId: string) => Promise<Exercise>;
+    sendMessage: (envelope: MessageEnvelope) => Promise<void>;
+    getMilestonesSent: (learnerId: string) => Promise<Set<string>>;
+}
+/**
+ * Check if `now` is within ±30 minutes of the preferred practice time.
+ */
+export declare function isWithinPracticeWindow(preferredTime: string | undefined, timezone: string, now?: Date): boolean;
+/**
+ * Days elapsed since the learner's last session.
+ */
+export declare function daysSinceLastSession(lastSessionAt: string | undefined, now?: Date): number;
+export declare function detectMilestones(config: TeachingLoopConfig, learner: LearnerProfile, progress: ProgressSummary, alreadySent: Set<string>): Milestone[];
+export type LoopOutcome = {
+    action: "skipped";
+    reason: string;
+} | {
+    action: "review_sent";
+    exerciseId: string;
+} | {
+    action: "nudge_sent";
+    daysSince: number;
+} | {
+    action: "milestone_sent";
+    milestones: Milestone[];
+} | {
+    action: "nothing_due";
+};
+export declare function runTeachingLoop(deps: TeachingLoopDeps, learnerId: string, config?: TeachingLoopConfig, now?: Date): Promise<LoopOutcome>;

package/dist/teacher/scrapthing/batch-job.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Scrapthing Batch Job — Scheduled batch scraping with deduplication,
+ * rate limiting, and corpus import.
+ *
+ * Reads ScrapthingConfig from workspace profile, iterates configured
+ * sources, scrapes each, and imports results via the corpus importer.
+ */
+import type { Kysely } from "kysely";
+import type { ScrapthingConfig, FetchPageFn } from "./mcp-adapter.js";
+import type { CorpusItem } from "../corpus-importer.js";
+export interface BatchJobResult {
+    jobId: string;
+    startedAt: string;
+    endedAt: string;
+    sourcesProcessed: number;
+    totalItems: number;
+    newItems: number;
+    duplicateItems: number;
+    errors: BatchJobError[];
+}
+export interface BatchJobError {
+    source: string;
+    url: string;
+    message: string;
+}
+export interface BatchJobDeps {
+    db: Kysely<any>;
+    fetchPage: FetchPageFn;
+    config: ScrapthingConfig;
+    /** Optional event emitter for progress tracking. */
+    onProgress?: (event: BatchProgressEvent) => void;
+}
+export interface BatchProgressEvent {
+    type: "source_start" | "source_done" | "source_error" | "item_imported" | "item_duplicate";
+    source?: string;
+    url?: string;
+    count?: number;
+    message?: string;
+}
+/**
+ * Filter out duplicate items using content hashing.
+ */
+export declare function deduplicateItems(db: Kysely<any>, items: CorpusItem[]): Promise<{
+    newItems: CorpusItem[];
+    duplicateCount: number;
+}>;
+/**
+ * Simple domain-based rate limiter. Tracks last request time per domain
+ * and enforces a minimum delay between requests to the same domain.
+ */
+export declare class DomainRateLimiter {
+    private lastRequest;
+    private delayMs;
+    constructor(delayMs?: number);
+    waitForDomain(url: string): Promise<void>;
+}
+/**
+ * Run a batch scraping job across all configured sources.
+ */
+export declare function runBatchJob(deps: BatchJobDeps): Promise<BatchJobResult>;
+/**
+ * Parse a simple cron-like schedule string and determine if the job
+ * should run now. Supports: "daily", "hourly", "every-N-hours".
+ */
+export declare function shouldRunNow(schedule: string, lastRunAt: string | undefined, now?: Date): boolean;

package/dist/teacher/scrapthing/content-cleaner.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Content Cleaner — Post-scrape content processing for Scrapthing.
+ *
+ * Strips HTML artifacts, extracts primary content blocks, splits into
+ * logical units, and validates language consistency.
+ */
+/**
+ * Clean raw HTML content by removing navigation, ads, scripts, and
+ * extracting readable text.
+ */
+export declare function cleanContent(html: string): string;
+/**
+ * Split cleaned text into individual content items.
+ * Uses double-newline paragraph boundaries, falling back to
+ * sentence boundaries for long paragraphs.
+ */
+export declare function splitIntoItems(text: string): string[];
+/**
+ * Character-range heuristics for common script families.
+ * Returns a confidence score (0-1) that the text matches the expected language.
+ */
+export declare function detectLanguageConfidence(text: string, expectedLang: string): number;
+/**
+ * Generate a simple content hash for deduplication.
+ * Normalizes whitespace and lowercases before hashing.
+ */
+export declare function contentHash(text: string): string;

package/dist/teacher/scrapthing/mcp-adapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Scrapthing MCP Adapter — Registers scrapthing as an MCP tool
+ * for background corpus growth.
+ *
+ * All scraped content is tagged source: 'scraped', reviewStatus: 'unreviewed'.
+ */
+import type { CorpusItem } from "../corpus-importer.js";
+export interface ScrapthingConfig {
+    enabled: boolean;
+    schedule: string;
+    maxPagesPerRun: number;
+    targetLanguages: string[];
+    sources: ScrapthingSource[];
+}
+export interface ScrapthingSource {
+    name: string;
+    url: string;
+    language: string;
+    contentSelector?: string;
+    fetcherType: "basic" | "dynamic" | "stealth";
+    contentType: string;
+}
+export interface ScrapeInput {
+    url: string;
+    language: string;
+    contentType?: string;
+    contentSelector?: string;
+}
+export interface ScrapeResult {
+    items: CorpusItem[];
+    url: string;
+    itemCount: number;
+}
+export type FetchPageFn = (url: string, selector?: string) => Promise<string>;
+export declare function scrapeUrl(fetchPage: FetchPageFn, input: ScrapeInput): Promise<ScrapeResult>;
+export declare const SCRAPTHING_TOOL: {
+    name: string;
+    description: string;
+    handler: (input: ScrapeInput, ctx: any) => Promise<ScrapeResult>;
+};
+/**
+ * Register the scrapthing tool with a tool registry.
+ */
+export declare function registerScrapthingTool(registry: {
+    tool: (serverName: string, toolName: string, def: {
+        name: string;
+        description?: string;
+        handler: (input: any, ctx: any) => Promise<any>;
+    }) => void;
+}, serverName?: string): void;

package/dist/teacher/skills/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Teacher Skills Index — Exports and registers all teacher-layer
+ * agent skills with the tool registry.
+ */
+export { planLesson, buildExercisesFromUnit, PLAN_LESSON_TOOL } from "./plan-lesson.js";
+export type { LessonPlan, PlannedExercise, ReviewItem, PlanLessonDeps } from "./plan-lesson.js";
+export { runPlacementTest, determineLevel, shouldContinueTesting, getNextTestLevel, PLACEMENT_TEST_TOOL } from "./placement-test.js";
+export type { PlacementResult, PlacementExercise, TestedLevel, PlacementTestDeps } from "./placement-test.js";
+export declare const TEACHER_SKILLS: readonly [{
+    name: string;
+    description: string;
+    handler: (input: {
+        learnerId: string;
+    }, ctx: any) => Promise<import("./plan-lesson.js").LessonPlan>;
+}, {
+    name: string;
+    description: string;
+    handler: (input: {
+        learnerId: string;
+        language: string;
+    }, ctx: any) => Promise<import("./placement-test.js").PlacementResult>;
+}];
+/**
+ * Register all teacher skills with a tool registry.
+ *
+ * @param registry — ToolRegistry-compatible object (from Sovereign RAG)
+ * @param serverName — Namespace for the tools (default: 'teacher_skills')
+ */
+export declare function registerTeacherSkills(registry: {
+    tool: (serverName: string, toolName: string, def: {
+        name: string;
+        description?: string;
+        handler: (input: any, ctx: any) => Promise<any>;
+    }) => void;
+}, serverName?: string): void;

package/dist/teacher/skills/placement-test.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Placement Test Skill — Assesses a learner's current level in their
+ * target language by generating exercises at increasing difficulty.
+ *
+ * Stops when the learner scores below 0.5 on two consecutive levels.
+ * Sets the learner's currentLevel to the highest level passed.
+ *
+ * Registered as tool: placement_test
+ */
+import type { Kysely } from "kysely";
+import type { CEFRLevel } from "../learner-model.js";
+export interface PlacementExercise {
+    level: CEFRLevel;
+    prompt: string;
+    type: "translation" | "comprehension" | "grammar_choice";
+}
+export interface PlacementResult {
+    learnerId: string;
+    testedLevels: TestedLevel[];
+    assignedLevel: CEFRLevel;
+    recommendedUnitId?: string;
+}
+export interface TestedLevel {
+    level: CEFRLevel;
+    score: number;
+    passed: boolean;
+}
+export type ExerciseGeneratorFn = (level: CEFRLevel, language: string) => Promise<PlacementExercise[]>;
+export type ExerciseScorerFn = (exercises: PlacementExercise[], responses: string[]) => Promise<number>;
+export declare function determineLevel(testedLevels: TestedLevel[]): CEFRLevel;
+export declare function shouldContinueTesting(testedLevels: TestedLevel[]): boolean;
+export declare function getNextTestLevel(testedLevels: TestedLevel[]): CEFRLevel | null;
+export interface PlacementTestDeps {
+    db: Kysely<any>;
+    generateExercises: ExerciseGeneratorFn;
+    scoreExercises: ExerciseScorerFn;
+    getResponses: (exercises: PlacementExercise[]) => Promise<string[]>;
+}
+export declare function runPlacementTest(deps: PlacementTestDeps, learnerId: string, language: string): Promise<PlacementResult>;
+export declare const PLACEMENT_TEST_TOOL: {
+    name: string;
+    description: string;
+    handler: (input: {
+        learnerId: string;
+        language: string;
+    }, ctx: any) => Promise<PlacementResult>;
+};

package/dist/teacher/skills/plan-lesson.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Plan Lesson Skill — Generates a structured lesson plan for the
+ * current learner, mixing new curriculum material with spaced-repetition
+ * review items.
+ *
+ * Registered as tool: plan_lesson
+ */
+import type { Kysely } from "kysely";
+import type { CurriculumTemplate, CurriculumUnit } from "../curriculum/schema.js";
+export interface LessonPlan {
+    learnerId: string;
+    unitId: string;
+    sessionNumber: number;
+    objectives: string[];
+    exercises: PlannedExercise[];
+    estimatedDuration: number;
+    reviewItems: ReviewItem[];
+}
+export interface PlannedExercise {
+    type: string;
+    objective: string;
+    targetVocabulary?: string[];
+    targetGrammar?: string[];
+    contentQuery?: string;
+    difficulty: number;
+}
+export interface ReviewItem {
+    entryId: string;
+    entryType: "vocab" | "grammar";
+    word?: string;
+    concept?: string;
+    lastScore: number;
+}
+export declare function buildExercisesFromUnit(unit: CurriculumUnit, sessionNumber: number, maxExercises?: number): PlannedExercise[];
+export interface PlanLessonDeps {
+    db: Kysely<any>;
+    generateTemplate?: (language: string) => Promise<CurriculumTemplate>;
+}
+export declare function planLesson(deps: PlanLessonDeps, learnerId: string): Promise<LessonPlan>;
+export declare const PLAN_LESSON_TOOL: {
+    name: string;
+    description: string;
+    handler: (input: {
+        learnerId: string;
+    }, ctx: any) => Promise<LessonPlan>;
+};

package/dist/teacher/spaced-repetition.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SM-2 Spaced Repetition Algorithm
+ *
+ * Based on the SuperMemo SM-2 algorithm by Piotr Wozniak.
+ * Calculates optimal review intervals based on recall quality.
+ *
+ * Quality scale (0–5):
+ *   0 — Complete blackout
+ *   1 — Incorrect; correct answer remembered after seeing it
+ *   2 — Incorrect; correct answer seemed easy to recall
+ *   3 — Correct with serious difficulty
+ *   4 — Correct after hesitation
+ *   5 — Perfect recall
+ */
+export interface SM2State {
+    /** Number of consecutive correct recalls (quality >= 3) */
+    repetitions: number;
+    /** Current inter-repetition interval in days */
+    interval: number;
+    /** Ease factor (minimum 1.3) */
+    easeFactor: number;
+}
+export interface SM2Result extends SM2State {
+    /** Next review date as ISO string */
+    nextReviewAt: string;
+}
+/**
+ * Calculates the next review state using the SM-2 algorithm.
+ *
+ * @param quality  — Recall quality (0–5)
+ * @param state    — Current SM-2 state (repetitions, interval, easeFactor)
+ * @param now      — Reference date for computing nextReviewAt (defaults to Date.now)
+ * @returns          Updated SM-2 state with nextReviewAt
+ */
+export declare function calculateNextReview(quality: number, state: SM2State, now?: Date): SM2Result;
+/**
+ * Maps an exercise score (0.0–1.0) to SM-2 quality (0–5).
+ *
+ * Mapping:
+ *   0.0–0.19 → 0 (complete blackout)
+ *   0.2–0.39 → 1 (incorrect, remembered after seeing answer)
+ *   0.4–0.59 → 2 (incorrect, seemed easy to recall)
+ *   0.6–0.69 → 3 (correct with difficulty)
+ *   0.7–0.89 → 4 (correct after hesitation)
+ *   0.9–1.0  → 5 (perfect recall)
+ */
+export declare function scoreToQuality(score: number): number;
+/** Returns the default initial SM-2 state for a new item. */
+export declare function initialSM2State(): SM2State;

package/dist/teacher/teacher-memory.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Teacher Memory Fact Registration
+ *
+ * Registers teacher-layer fact categories with the Sovereign RAG ToolRegistry
+ * for progressive disclosure: the agent sees a compact learner stub by default
+ * and only expands to full detail when session planning requires it.
+ *
+ * Fact categories:
+ *   teacher:profile  — learner profile snapshot
+ *   teacher:vocab    — vocabulary mastery data
+ *   teacher:grammar  — grammar mastery data
+ *   teacher:session  — session history and focus areas
+ */
+import type { Kysely } from "kysely";
+import type { LearnerStub } from "./learner-model.js";
+export type TeacherFactCategory = "teacher:profile" | "teacher:vocab" | "teacher:grammar" | "teacher:session";
+export declare const TEACHER_FACT_CATEGORIES: readonly TeacherFactCategory[];
+export interface FactCategoryDefinition {
+    category: TeacherFactCategory;
+    description: string;
+    /** Returns compact data for progressive disclosure (always loaded). */
+    fetchStub: (db: Kysely<any>, learnerId: string) => Promise<unknown>;
+    /** Returns full detail (loaded on demand during session planning). */
+    fetchDetail: (db: Kysely<any>, learnerId: string) => Promise<unknown>;
+}
+/**
+ * Register all teacher fact categories.
+ * Safe to call multiple times — subsequent calls are no-ops.
+ */
+export declare function registerTeacherFacts(): void;
+/** Check whether a specific fact category is registered. */
+export declare function isFactCategoryRegistered(category: TeacherFactCategory): boolean;
+/** List all registered fact categories. */
+export declare function listRegisteredFactCategories(): TeacherFactCategory[];
+/** Get a category definition by name. */
+export declare function getFactCategoryDefinition(category: TeacherFactCategory): FactCategoryDefinition | undefined;
+/** Compact context provided to the agent by default. */
+export interface TeacherContextStub {
+    learnerId: string;
+    stub: LearnerStub;
+    factSummaries: Record<TeacherFactCategory, unknown>;
+}
+/**
+ * Builds the compact agent context for a learner.
+ * This is the progressive disclosure entry point — returns only the stub data
+ * so the agent context stays small until detail is explicitly requested.
+ */
+export declare function buildTeacherContextStub(db: Kysely<any>, learnerId: string): Promise<TeacherContextStub | null>;
+/**
+ * Expands a single fact category to full detail.
+ * Called when the agent needs deeper data during session planning.
+ */
+export declare function expandFactCategory(db: Kysely<any>, learnerId: string, category: TeacherFactCategory): Promise<unknown>;
+/**
+ * Expands all fact categories to full detail.
+ * Used when full session planning context is needed.
+ */
+export declare function expandAllFacts(db: Kysely<any>, learnerId: string): Promise<Record<TeacherFactCategory, unknown>>;
+/**
+ * Registers teacher memory fact tools with a Sovereign RAG ToolRegistry.
+ *
+ * Tools registered under `serverName` (default: 'teacher'):
+ *   - teacher.stub         — Fetch compact learner context
+ *   - teacher.expand       — Expand a single fact category to full detail
+ *   - teacher.expand_all   — Expand all fact categories
+ *   - teacher.due_reviews  — Get items due for review
+ *   - teacher.progress     — Get progress summary
+ *
+ * @param registry  — ToolRegistry instance from Sovereign RAG
+ * @param db        — Kysely database instance
+ * @param serverName — Registration namespace (default: 'teacher')
+ */
+export declare function registerTeacherMemoryTools(registry: {
+    tool: (serverName: string, toolName: string, def: {
+        name: string;
+        description?: string;
+        handler: (input: any, ctx: any) => Promise<any>;
+    }) => void;
+}, db: Kysely<any>, serverName?: string): void;

package/dist/teacher/voice/custom-vocabulary.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Custom Vocabulary — sounds-like mappings for African language terms.
+ *
+ * Critical for Ejiogbe Voices where general-purpose STT frequently
+ * misrecognizes Yoruba, Igbo, Hausa, and Swahili terms.
+ *
+ * These vocabulary entries are passed to STT providers that support
+ * the customVocabulary capability (e.g., Speechmatics, Deepgram, Google).
+ */
+export interface CustomVocabularyEntry {
+    content: string;
+    soundsLike?: string[];
+}
+export declare const YORUBA_VOCABULARY: CustomVocabularyEntry[];
+export declare const IGBO_VOCABULARY: CustomVocabularyEntry[];
+export declare const HAUSA_VOCABULARY: CustomVocabularyEntry[];
+export declare const SWAHILI_VOCABULARY: CustomVocabularyEntry[];
+export declare const BUSINESS_VOCABULARY: CustomVocabularyEntry[];
+export declare const VOCABULARY_BY_LANGUAGE: Record<string, CustomVocabularyEntry[]>;
+/**
+ * Get custom vocabulary entries for a language.
+ * Returns empty array if no custom vocabulary exists.
+ */
+export declare function getVocabularyForLanguage(language: string): CustomVocabularyEntry[];
+/**
+ * Merge multiple vocabulary lists, deduplicating by content.
+ */
+export declare function mergeVocabulary(...lists: CustomVocabularyEntry[][]): CustomVocabularyEntry[];

package/dist/teacher/voice/exercise-voice.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Exercise Voice — Renders audio for exercises that require TTS.
+ *
+ * Handles listening comprehension, dictation, pronunciation, and
+ * dialogue roleplay (multi-speaker via MOSS-TTSD).
+ */
+import type { Exercise } from "../exercises/generator.js";
+import { type WorkspaceVoiceConfig } from "./language-voices.js";
+export interface AudioOutput {
+    audio: Buffer;
+    format: "mp3" | "wav" | "ogg";
+    durationMs: number;
+    voiceId: string;
+}
+export interface DialogueTurn {
+    speaker: string;
+    text: string;
+}
+export interface MossTtsdRequest {
+    turns: DialogueTurn[];
+    voices: Record<string, string>;
+    format: "mp3" | "wav";
+}
+export type TtsFn = (text: string, voiceId: string) => Promise<Buffer>;
+export type MossTtsdFn = (request: MossTtsdRequest) => Promise<Buffer>;
+export interface ExerciseVoiceDeps {
+    tts?: TtsFn;
+    mossTtsd?: MossTtsdFn;
+    workspaceVoiceConfig?: WorkspaceVoiceConfig;
+}
+/**
+ * Build a MOSS-TTSD multi-speaker synthesis request from exercise metadata.
+ */
+export declare function buildDialogueRequest(exercise: Exercise, language: string, workspaceConfig?: WorkspaceVoiceConfig): MossTtsdRequest;
+/**
+ * Render audio for an exercise that has `audioRequired: true`.
+ * Selects the appropriate synthesis method based on exercise type.
+ */
+export declare function renderExerciseAudio(deps: ExerciseVoiceDeps, exercise: Exercise, language: string): Promise<AudioOutput | null>;

package/dist/teacher/voice/language-voices.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Language Voices — Per-language voice identity configuration.
+ *
+ * Maps languages to TTS voice configs, supports workspace-level
+ * overrides, and falls back to a multilingual voice when no
+ * language-specific voice is configured.
+ */
+export interface VoiceIdentity {
+    voiceId: string;
+    languageCode: string;
+    name: string;
+    gender: "male" | "female" | "neutral";
+    provider: "google" | "cartesia" | "murf" | "moss-ttsd";
+}
+export interface WorkspaceVoiceConfig {
+    overrides?: Record<string, VoiceIdentity>;
+}
+/**
+ * Get the TTS voice identity for a given language code.
+ * Checks workspace overrides first, then defaults, then multilingual fallback.
+ */
+export declare function getVoiceForLanguage(language: string, workspaceConfig?: WorkspaceVoiceConfig): VoiceIdentity;
+/**
+ * List all languages with dedicated voice support.
+ */
+export declare function listSupportedLanguages(): string[];

package/dist/teacher/voice/pronunciation-scorer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pronunciation Scorer — Evaluates learner pronunciation by comparing
+ * STT transcription against expected text at the word level.
+ */
+export interface PronunciationResult {
+    score: number;
+    transcript: string;
+    feedback: string;
+    wordDetails: WordDetail[];
+}
+export interface WordDetail {
+    expected: string;
+    spoken: string | null;
+    match: "exact" | "partial" | "missed";
+}
+export interface PronunciationDeps {
+    /** Transcribe audio buffer to text. */
+    stt?: (audio: Buffer, language: string) => Promise<string>;
+}
+/**
+ * Compare expected words against transcribed words.
+ * Returns per-word match details.
+ */
+export declare function compareWords(expected: string, transcript: string): WordDetail[];
+/**
+ * Calculate pronunciation score from word details (0.0 – 1.0).
+ * Exact matches score 1, partial matches score 0.5, misses score 0.
+ */
+export declare function scoreFromDetails(details: WordDetail[]): number;
+/**
+ * Generate human-readable feedback from word details.
+ */
+export declare function buildFeedback(details: WordDetail[], score: number): string;
+/**
+ * Score learner pronunciation by transcribing spoken audio and comparing
+ * word-by-word against the expected phrase.
+ */
+export declare function scorePronunciation(deps: PronunciationDeps, expected: string, spokenAudio: Buffer, language: string): Promise<PronunciationResult>;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@fenixforce/edition-voices",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ejiogbevoices/projectfenix.git",
+    "directory": "packages/edition-voices"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --format=esm --platform=node --target=es2022 --minify --outfile=dist/index.js --external:@fenixforce/kernel --external:kysely --external:nanoid && tsc --emitDeclarationOnly --project tsconfig.build.json",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@fenixforce/kernel": "workspace:*",
+    "kysely": "^0.27.0",
+    "nanoid": "^5.1.6"
+  },
+  "devDependencies": {}
+}