@thinkable-labs/audio-enhancer 1.0.0 → 2.0.0

package/dist/enhancer.d.ts

@@ -6,14 +6,23 @@ export interface EnhanceOptions {
 export interface EnhanceItem {
     videoPath: string;
     voiceId: string;
+    /** Produce the isolated→voice-change variant. Default: true. */
+    withIsolation?: boolean;
+    /** Produce the direct (skip isolation) voice-change variant. Default: true. */
+    withoutIsolation?: boolean;
 }
+export type Variant = "isolated" | "direct";
 export type ItemStatus = "pending" | "extracting" | "isolating" | "voice-changing" | "success" | "error";
+export interface VariantResult {
+    variant: Variant;
+    outputPath: string;
+    status: "success" | "error";
+    error?: string;
+}
 export interface ItemResult {
     item: EnhanceItem;
     videoName: string;
-    outputPath: string;
-    status: ItemStatus;
-    error?: string;
+    outputs: VariantResult[];
 }
 export interface BatchEnhanceResult {
     results: ItemResult[];
@@ -25,10 +34,16 @@ export type ProgressCallback = (update: {
     current: number;
     total: number;
     videoName: string;
+    variant?: Variant;
     status: ItemStatus;
     outputPath?: string;
     error?: string;
 }) => void;
-export declare function enhanceVideo(item: EnhanceItem, options: EnhanceOptions): Promise<ItemResult>;
+export declare function enhanceVideo(item: EnhanceItem, options: EnhanceOptions, onProgress?: (update: {
+    variant?: Variant;
+    status: ItemStatus;
+    outputPath?: string;
+    error?: string;
+}) => void): Promise<ItemResult>;
 export declare function enhanceBatch(items: EnhanceItem[], options: EnhanceOptions, onProgress?: ProgressCallback): Promise<BatchEnhanceResult>;
 //# sourceMappingURL=enhancer.d.ts.map

package/dist/enhancer.js

@@ -39,41 +39,65 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const extractor_1 = require("./extractor");
 const elevenlabs_1 = require("./elevenlabs");
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function resolveVariants(item) {
+    const withIsolation = item.withIsolation ?? true;
+    const withoutIsolation = item.withoutIsolation ?? true;
+    const variants = [];
+    if (withIsolation)
+        variants.push("isolated");
+    if (withoutIsolation)
+        variants.push("direct");
+    return variants;
+}
+function variantOutputPath(outputDir, videoName, variant) {
+    const suffix = variant === "isolated" ? "isolated" : "direct";
+    return path.join(outputDir, `${videoName}-${suffix}.mp3`);
+}
 // ─── Enhance a single video ────────────────────────────────────────────────
-async function enhanceVideo(item, options) {
+async function enhanceVideo(item, options, onProgress) {
     const videoName = path.basename(item.videoPath, path.extname(item.videoPath));
-    const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
+    const variants = resolveVariants(item);
+    if (variants.length === 0) {
+        throw new Error(`No variants enabled for ${videoName}: at least one of withIsolation or withoutIsolation must be true`);
+    }
+    if (!fs.existsSync(options.outputDir)) {
+        fs.mkdirSync(options.outputDir, { recursive: true });
+    }
+    const outputs = [];
     let tempAudioPath = null;
     try {
-        // Step 1: Extract audio from video
+        // Step 1: Extract audio from video (shared by all variants)
+        onProgress?.({ status: "extracting" });
         tempAudioPath = await (0, extractor_1.extractAudio)(item.videoPath, options.ffmpegPath);
-        // Step 2: Isolate voice (remove background noise)
-        const isolatedAudio = await (0, elevenlabs_1.isolateAudio)(tempAudioPath, options.apiKey);
-        // Step 3: Voice change
-        const finalAudio = await (0, elevenlabs_1.changeVoice)(isolatedAudio, item.voiceId, options.apiKey);
-        // Save final audio
-        if (!fs.existsSync(options.outputDir)) {
-            fs.mkdirSync(options.outputDir, { recursive: true });
+        const extractedBuffer = fs.readFileSync(tempAudioPath);
+        // Step 2: Run each variant
+        for (const variant of variants) {
+            const outputPath = variantOutputPath(options.outputDir, videoName, variant);
+            try {
+                let voiceInput;
+                if (variant === "isolated") {
+                    onProgress?.({ variant, status: "isolating" });
+                    voiceInput = await (0, elevenlabs_1.isolateAudio)(tempAudioPath, options.apiKey);
+                }
+                else {
+                    voiceInput = extractedBuffer;
+                }
+                onProgress?.({ variant, status: "voice-changing" });
+                const finalAudio = await (0, elevenlabs_1.changeVoice)(voiceInput, item.voiceId, options.apiKey);
+                fs.writeFileSync(outputPath, finalAudio);
+                outputs.push({ variant, outputPath, status: "success" });
+                onProgress?.({ variant, status: "success", outputPath });
+            }
+            catch (err) {
+                const errorMsg = err?.message || String(err);
+                outputs.push({ variant, outputPath, status: "error", error: errorMsg });
+                onProgress?.({ variant, status: "error", error: errorMsg });
+            }
         }
-        fs.writeFileSync(outputPath, finalAudio);
-        return {
-            item,
-            videoName,
-            outputPath,
-            status: "success",
-        };
-    }
-    catch (err) {
-        return {
-            item,
-            videoName,
-            outputPath,
-            status: "error",
-            error: err?.message || String(err),
-        };
+        return { item, videoName, outputs };
     }
     finally {
-        // Clean up temp file
         if (tempAudioPath && fs.existsSync(tempAudioPath)) {
             try {
                 fs.unlinkSync(tempAudioPath);
@@ -93,53 +117,27 @@ async function enhanceBatch(items, options, onProgress) {
     for (let i = 0; i < items.length; i++) {
         const item = items[i];
         const videoName = path.basename(item.videoPath, path.extname(item.videoPath));
-        // Notify: extracting
-        onProgress?.({
-            current: i + 1,
-            total: items.length,
-            videoName,
-            status: "extracting",
-        });
-        let tempAudioPath = null;
         try {
-            // Step 1: Extract audio
-            tempAudioPath = await (0, extractor_1.extractAudio)(item.videoPath, options.ffmpegPath);
-            // Notify: isolating
-            onProgress?.({
-                current: i + 1,
-                total: items.length,
-                videoName,
-                status: "isolating",
-            });
-            // Step 2: Isolate voice
-            const isolatedAudio = await (0, elevenlabs_1.isolateAudio)(tempAudioPath, options.apiKey);
-            // Notify: voice changing
-            onProgress?.({
-                current: i + 1,
-                total: items.length,
-                videoName,
-                status: "voice-changing",
-            });
-            // Step 3: Voice change
-            const finalAudio = await (0, elevenlabs_1.changeVoice)(isolatedAudio, item.voiceId, options.apiKey);
-            // Save
-            const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
-            fs.writeFileSync(outputPath, finalAudio);
-            successCount++;
-            results.push({ item, videoName, outputPath, status: "success" });
-            onProgress?.({
-                current: i + 1,
-                total: items.length,
-                videoName,
-                status: "success",
-                outputPath,
+            const result = await enhanceVideo(item, options, (update) => {
+                onProgress?.({
+                    current: i + 1,
+                    total: items.length,
+                    videoName,
+                    ...update,
+                });
             });
+            results.push(result);
+            const allOk = result.outputs.every((o) => o.status === "success");
+            if (allOk)
+                successCount++;
+            else
+                errorCount++;
         }
         catch (err) {
-            errorCount++;
-            const outputPath = path.join(options.outputDir, `${videoName}.mp3`);
+            // Pre-variant failure (e.g., extraction failed, no variants enabled)
             const errorMsg = err?.message || String(err);
-            results.push({ item, videoName, outputPath, status: "error", error: errorMsg });
+            errorCount++;
+            results.push({ item, videoName, outputs: [] });
             onProgress?.({
                 current: i + 1,
                 total: items.length,
@@ -148,14 +146,6 @@ async function enhanceBatch(items, options, onProgress) {
                 error: errorMsg,
             });
         }
-        finally {
-            if (tempAudioPath && fs.existsSync(tempAudioPath)) {
-                try {
-                    fs.unlinkSync(tempAudioPath);
-                }
-                catch { }
-            }
-        }
     }
     return { results, totalCount: items.length, successCount, errorCount };
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { extractAudio } from "./extractor";
 export { isolateAudio, changeVoice } from "./elevenlabs";
 export { enhanceVideo, enhanceBatch } from "./enhancer";
-export type { EnhanceOptions, EnhanceItem, ItemStatus, ItemResult, BatchEnhanceResult, ProgressCallback, } from "./enhancer";
+export type { EnhanceOptions, EnhanceItem, ItemStatus, ItemResult, VariantResult, Variant, BatchEnhanceResult, ProgressCallback, } from "./enhancer";
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinkable-labs/audio-enhancer",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Extract audio from video, isolate voice with ElevenLabs, apply voice change",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",