@mcptoolshop/voice-engine-dsp 0.0.1

package/dist/src/prosody/AccentRenderer.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccentRenderer = void 0;
+class AccentRenderer {
+    /**
+     * Renders prosodic accents into a per-frame control curve.
+     * Uses a raised cosine window for smooth parameter modulation.
+     *
+     * @param events List of prosody events to render
+     * @param totalFrames Total number of frames in the output buffer
+     * @param style Prosody style configuration
+     * @param frameRateHz Frame rate for time conversions (default 100)
+     * @returns Float32Array of rendered values (additive relative cents)
+     */
+    static render(events, totalFrames, style, frameRateHz = 100) {
+        const output = new Float32Array(totalFrames);
+        const { accentMaxCents, accentSpanSeconds, eventStrengthScale } = style;
+        // Convert seconds to frames
+        const defaultDurationFrames = Math.round(accentSpanSeconds * frameRateHz);
+        for (const event of events) {
+            // Only process accent events
+            if (event.type !== 'accent')
+                continue;
+            const time = event.time;
+            const strength = event.strength;
+            const shape = event.shape || 'rise';
+            // Use event duration if provided, else default from style
+            let duration = event.spanFrames;
+            if (!duration || duration <= 0) {
+                duration = defaultDurationFrames;
+            }
+            // Calculate peak cents: normalized strength * global scale * max cents
+            const peakCents = strength * eventStrengthScale * accentMaxCents;
+            const radius = duration / 2;
+            // Determine range of frames to process
+            const startFrame = Math.ceil(time - radius);
+            const endFrame = Math.floor(time + radius);
+            // Clamp to valid buffer range
+            const validStart = Math.max(0, startFrame);
+            const validEnd = Math.min(totalFrames - 1, endFrame);
+            // Determine sign based on shape
+            let sign = 1.0;
+            if (shape === 'fall' || shape === 'fall-rise') {
+                sign = -1.0;
+            }
+            // For complex shapes like fall-rise or rise-fall, simple sign flip might not be enough.
+            // But preserving existing logic for now:
+            // Existing logic: if fall or fall-rise, sign = -1.0.
+            for (let i = validStart; i <= validEnd; i++) {
+                const d = i - time;
+                if (radius > 0) {
+                    // Kernel: 0.5 * (1 + cos(pi * d / radius))
+                    // This creates a window from -radius to +radius
+                    // Check if d is within radius (it should be given loop range generally but good to verify)
+                    if (Math.abs(d) <= radius) {
+                        const ratio = d / radius;
+                        const w = 0.5 * (1 + Math.cos(Math.PI * ratio));
+                        output[i] += w * peakCents * sign;
+                    }
+                }
+            }
+        }
+        return output;
+    }
+}
+exports.AccentRenderer = AccentRenderer;

package/dist/src/prosody/Presets.d.ts

@@ -0,0 +1,3 @@
+import { ProsodyPresetV1 } from "../../../voice-engine-core/src/prosody/ProsodyV1.js";
+export declare const PRESETS: Record<string, ProsodyPresetV1>;
+//# sourceMappingURL=Presets.d.ts.map

package/dist/src/prosody/Presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Presets.d.ts","sourceRoot":"","sources":["../../../src/prosody/Presets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAqD,MAAM,qDAAqD,CAAC;AAsBzI,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAqDnD,CAAC"}

package/dist/src/prosody/Presets.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESETS = void 0;
+const ProsodyPresets_js_1 = require("../../../voice-engine-core/src/config/ProsodyPresets.js");
+function createPreset(id, name, desc, overrides = {}) {
+    return {
+        id,
+        name,
+        description: desc,
+        analysis: { ...ProsodyPresets_js_1.DEFAULT_PROSODY_CONFIG_V1, ...(overrides.analysis || {}) },
+        stabilizer: { ...ProsodyPresets_js_1.DEFAULT_STABILIZER_CONFIG_V1, ...(overrides.stabilizer || {}) },
+        tuning: { ...ProsodyPresets_js_1.DEFAULT_TUNING_CONFIG_V1, ...(overrides.tuning || {}) },
+        correctionStrength: overrides.correctionStrength ?? 1.0,
+        attackMs: overrides.attackMs ?? 20,
+        releaseMs: overrides.releaseMs ?? 100
+    };
+}
+exports.PRESETS = {
+    DEFAULT_CLEAN: createPreset("default_clean", "Default Clean", "Balanced correction for clean speech", {
+        stabilizer: {
+            hysteresisCents: 15,
+            switchRampMs: 30
+        }
+    } // Uses defaults mostly
+    ),
+    HARD_TUNE: createPreset("hard_tune", "Hard Tune", "Zero hysteresis, fast ramp for maximum robotic effect", {
+        stabilizer: {
+            hysteresisCents: 0, // Note: SafetyRails may clamp this to 5
+            switchRampMs: 5, // Fast ramp
+            minHoldMs: 10 // Short hold
+        },
+        correctionStrength: 1.0,
+        attackMs: 5,
+        releaseMs: 5
+    }),
+    NO_WARBLE: createPreset("no_warble", "No Warble", "High hysteresis and slow ramp to prevent artifacts", {
+        stabilizer: {
+            hysteresisCents: 25,
+            switchRampMs: 100, // "Slow ramp" - interpreted as 100ms (approx 10 frames @ 100Hz)
+            minHoldMs: 100
+        },
+        analysis: {
+            voicingThresholdQ: 3000 // Conservative voicing (higher confidence required)
+        }
+    }),
+    SUBTLE: createPreset("subtle", "Subtle", "Low correction strength for natural enhancement", {
+        correctionStrength: 0.3
+    })
+};

package/dist/src/prosody/SafetyRails.d.ts

@@ -0,0 +1,21 @@
+import { ProsodyPresetV1 } from "../../../voice-engine-core/src/prosody/ProsodyV1.js";
+/**
+ * Validates and clamps a Prosody configuration to safe operating ranges.
+ * This prevents configurations that might cause severe audio artifacts
+ * (like rapid switching/warble due to 0 hysteresis or extreme sensitivity).
+ *
+ * @param config The configuration to validate
+ * @returns A new configuration object with clamped values
+ */
+export declare function validateAndClampConfig(config: ProsodyPresetV1): ProsodyPresetV1;
+/**
+ * Applies an expressiveness scale factor to the configuration.
+ *
+ * @param config The base configuration
+ * @param amount Amount of expressiveness (0.0 to 1.0).
+ *               0.0 = Robotic / Strict (Full Correction)
+ *               1.0 = Expressive / Natural (Zero Correction or reduced strength)
+ * @returns Modified configuration
+ */
+export declare function applyExpressiveness(config: ProsodyPresetV1, amount: number): ProsodyPresetV1;
+//# sourceMappingURL=SafetyRails.d.ts.map

package/dist/src/prosody/SafetyRails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SafetyRails.d.ts","sourceRoot":"","sources":["../../../src/prosody/SafetyRails.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qDAAqD,CAAC;AAEtF;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAoC/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAe5F"}

package/dist/src/prosody/SafetyRails.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndClampConfig = validateAndClampConfig;
+exports.applyExpressiveness = applyExpressiveness;
+/**
+ * Validates and clamps a Prosody configuration to safe operating ranges.
+ * This prevents configurations that might cause severe audio artifacts
+ * (like rapid switching/warble due to 0 hysteresis or extreme sensitivity).
+ *
+ * @param config The configuration to validate
+ * @returns A new configuration object with clamped values
+ */
+function validateAndClampConfig(config) {
+    const clamped = { ...config }; // Shallow copy is enough for top-level, but we need deep for nested
+    // Deep copy specific sections we modify
+    if (config.stabilizer) {
+        clamped.stabilizer = { ...config.stabilizer };
+    }
+    if (config.analysis) {
+        clamped.analysis = { ...config.analysis };
+    }
+    // Ensure min hysteresisCents >= 5
+    // Hysteresis < 5 cents can cause rapid oscillation between pitch classes (warble)
+    if (clamped.stabilizer) {
+        const currentHysteresis = clamped.stabilizer.hysteresisCents ?? 15;
+        if (currentHysteresis < 5) {
+            clamped.stabilizer.hysteresisCents = 5;
+        }
+    }
+    // Ensure voicingThresholdQ is reasonable
+    // Range: 0 to 10000. 
+    // < 100 implies almost everything is voiced (noise artifacts).
+    // > 9000 implies almost nothing is voiced.
+    if (clamped.analysis) {
+        let thresh = clamped.analysis.voicingThresholdQ;
+        if (thresh === undefined) {
+            // Default if missing
+            thresh = 2000;
+        }
+        // Clamp to [100, 9000]
+        clamped.analysis.voicingThresholdQ = Math.max(100, Math.min(9000, thresh));
+    }
+    return clamped;
+}
+/**
+ * Applies an expressiveness scale factor to the configuration.
+ *
+ * @param config The base configuration
+ * @param amount Amount of expressiveness (0.0 to 1.0).
+ *               0.0 = Robotic / Strict (Full Correction)
+ *               1.0 = Expressive / Natural (Zero Correction or reduced strength)
+ * @returns Modified configuration
+ */
+function applyExpressiveness(config, amount) {
+    const modified = { ...config };
+    // Clamp amount 0..1
+    const safeAmount = Math.max(0, Math.min(1, amount));
+    // Interpretation: "Expressiveness" reduces the correction strength.
+    // Base strength is scaled down by the expressiveness amount.
+    // If amount is 0 (No Expressiveness), we keep full strength.
+    // If amount is 1 (Full Expressiveness), we reduce strength to 0.
+    const baseStrength = config.correctionStrength ?? 1.0;
+    modified.correctionStrength = baseStrength * (1.0 - safeAmount);
+    return modified;
+}

package/dist/src/transformation/FormantStrategyV1.d.ts

@@ -0,0 +1,5 @@
+import { IFormantStrategy, AudioBufferV1 } from "@mcptoolshop/voice-engine-core";
+export declare class FormantStrategyV1 implements IFormantStrategy {
+    apply(tuned: AudioBufferV1, original: AudioBufferV1): Promise<AudioBufferV1>;
+}
+//# sourceMappingURL=FormantStrategyV1.d.ts.map

package/dist/src/transformation/FormantStrategyV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormantStrategyV1.d.ts","sourceRoot":"","sources":["../../../src/transformation/FormantStrategyV1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEjF,qBAAa,iBAAkB,YAAW,gBAAgB;IAChD,KAAK,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;CAsCrF"}

package/dist/src/transformation/FormantStrategyV1.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormantStrategyV1 = void 0;
+class FormantStrategyV1 {
+    async apply(tuned, original) {
+        const outData = new Float32Array(tuned.data[0]);
+        // const origData = original.data[0]; 
+        // 1. Spectral Tilt / Dynamics Guard (RMS Matching)
+        // Simple global RMS match for V1 to prevent massive gain changes
+        // Or frame-based? Global is safer.
+        /*
+        let sumSqTuned = 0;
+        let sumSqOrig = 0;
+        for (let i = 0; i < outData.length; i++) sumSqTuned += outData[i] * outData[i];
+        for (let i = 0; i < origData.length; i++) sumSqOrig += origData[i] * origData[i];
+        
+        const rmsGain = Math.sqrt((sumSqOrig + 1e-9) / (sumSqTuned + 1e-9));
+        // Apply Gain (Softly)
+        for (let i = 0; i < outData.length; i++) outData[i] *= rmsGain;
+        */
+        // 2. Artifact Guard (Limiter / Soft Clip)
+        // Soft clip: tanh
+        for (let i = 0; i < outData.length; i++) {
+            let s = outData[i];
+            // Soft Clip
+            if (s > 1.0 || s < -1.0) {
+                s = Math.tanh(s);
+            }
+            // De-click / Smoothing (Simple Lowpass)? 
+            // No, strictly limiter for V1 safety.
+            outData[i] = s;
+        }
+        return {
+            ...tuned,
+            data: [outData]
+        };
+    }
+}
+exports.FormantStrategyV1 = FormantStrategyV1;

package/dist/src/transformation/PitchShifterRefV1.d.ts

@@ -0,0 +1,9 @@
+import { IPitchShifter, AudioBufferV1, F0TrackV1, VoicingMaskV1, TargetCurveV1, CorrectionEnvelopeV1 } from "@mcptoolshop/voice-engine-core";
+export declare class PitchShifterRefV1 implements IPitchShifter {
+    readonly id = "voice-engine-dsp.pitch-shifter.v1";
+    readonly version = "1.0.0";
+    private formantStrategy;
+    capabilities(): string[];
+    shift(audio: AudioBufferV1, f0Track: F0TrackV1, voicing: VoicingMaskV1, target: TargetCurveV1, envelope: CorrectionEnvelopeV1, request?: any): Promise<AudioBufferV1>;
+}
+//# sourceMappingURL=PitchShifterRefV1.d.ts.map

package/dist/src/transformation/PitchShifterRefV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PitchShifterRefV1.d.ts","sourceRoot":"","sources":["../../../src/transformation/PitchShifterRefV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,aAAa,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAC/E,MAAM,gCAAgC,CAAC;AAIxC,qBAAa,iBAAkB,YAAW,aAAa;IACnD,QAAQ,CAAC,EAAE,uCAAuC;IAClD,QAAQ,CAAC,OAAO,WAAW;IAE3B,OAAO,CAAC,eAAe,CAA2B;IAElD,YAAY,IAAI,MAAM,EAAE;IAIlB,KAAK,CACP,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,aAAa,CAAC;CA4H5B"}

package/dist/src/transformation/PitchShifterRefV1.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitchShifterRefV1 = void 0;
+const FormantStrategyV1_1 = require("./FormantStrategyV1");
+class PitchShifterRefV1 {
+    id = "voice-engine-dsp.pitch-shifter.v1";
+    version = "1.0.0";
+    formantStrategy = new FormantStrategyV1_1.FormantStrategyV1();
+    capabilities() {
+        return ["pitch-shift", "psola-lite", "formant-guard"];
+    }
+    async shift(audio, f0Track, voicing, target, envelope, request // Pass full request if needed
+    ) {
+        // Validation
+        const sr = audio.sampleRate;
+        if (sr !== f0Track.sampleRateHz) {
+            throw new Error("Sample rate mismatch");
+        }
+        const outData = new Float32Array(audio.data[0].length);
+        const inData = audio.data[0]; // Mono assumption V1
+        // Granular/PSOLA State
+        let phase = 0;
+        const frames = f0Track.f0MhzQ.length;
+        const hop = f0Track.hopSamples;
+        // Determine Mode (Default Preserve)
+        // If request provided, use it. But signature didn't have request.
+        // We'll update signature or assume preserve.
+        // IPitchShifter interface signature uses specific args.
+        // We can pass `formantMode` via a config object if we change interface?
+        // Or assume this is "V1 Deterministic" which is formant preserving.
+        // But for "Chipmunk" support:
+        const useChipmunk = false; // TODO: pipe from request
+        // Output pointer
+        for (let i = 0; i < outData.length; i++) {
+            // 1. Determine Frame Index
+            let frameIdx = Math.floor(i / hop);
+            if (frameIdx >= frames)
+                frameIdx = frames - 1;
+            if (frameIdx < 0)
+                frameIdx = 0;
+            // Debug
+            // if (i === 24000) console.log(`Debug Shifter Frame: ${frameIdx}, Voiced: ${voicing.voicedQ[frameIdx]}`);
+            // 2. Unvoiced Bypass
+            const isVoiced = voicing.voicedQ[frameIdx] > 0;
+            if (!isVoiced) {
+                outData[i] = inData[i]; // TODO: Crossfade
+                continue;
+            }
+            // 3. Calculate Target Pitch
+            const targetValCents = target.targetCentsQ[frameIdx] / 1000.0; // Assume Milli-Cents in Q
+            let inputF0Mhz = f0Track.f0MhzQ[frameIdx];
+            if (inputF0Mhz <= 0)
+                inputF0Mhz = 100000;
+            const strength = envelope.strengthQ[frameIdx] / 10000;
+            const inputHz = inputF0Mhz / 1000;
+            // Base: MIDI 69 (A4 440) = 6900 Cents
+            const inputCents = 6900 + 1200 * Math.log2(inputHz / 440);
+            const desiredCents = inputCents + (targetValCents - inputCents) * strength;
+            const shiftCents = (desiredCents - inputCents);
+            const ratio = Math.pow(2, shiftCents / 1200);
+            // 4. PSOLA-lite Grain Trigger
+            const outputF0 = inputHz * ratio;
+            phase += outputF0 / sr;
+            /*
+            if (i > 24000 && i < 24005) {
+                console.log(`Debug Shifter Loop: i=${i}, phase=${phase}, outF0=${outputF0}`);
+                console.log(`Debug Cents: InputC=${inputCents}, TargetC=${targetValCents}, DesiredC=${desiredCents}`);
+            }
+            */
+            if (phase >= 1) {
+                phase -= 1;
+                // Grain Length Strategy
+                // Preserve Formants: Length = 2 * InputPeriod
+                // Shift Formants (Chipmunk): Length = 2 * OutputPeriod
+                const pInput = sr / inputHz;
+                const pBase = useChipmunk ? (sr / outputF0) : pInput;
+                const grainLen = Math.floor(2 * pBase);
+                const overlapGain = inputHz / outputF0; // Simple density comp
+                // Refinement: Find local peak (Pitch Mark) within one period of input
+                // This aligns the grain to the waveform phase, crucial for coherence
+                let center = i;
+                const searchWin = Math.min(Math.floor(pInput / 2), 512);
+                let maxVal = -1;
+                let bestOffset = 0;
+                for (let o = -searchWin; o <= searchWin; o++) {
+                    const idx = i + o;
+                    if (idx >= 0 && idx < inData.length) {
+                        const val = Math.abs(inData[idx]);
+                        if (val > maxVal) {
+                            maxVal = val;
+                            bestOffset = o;
+                        }
+                    }
+                }
+                center = i + bestOffset;
+                for (let k = 0; k < grainLen; k++) {
+                    const pos = i - Math.floor(grainLen / 2) + k;
+                    // Read from Time-Aligned Input (center)
+                    // Input Grain is centered at 'center'
+                    // Window is centered at 'center'
+                    // k goes 0..grainLen. 
+                    // readPos should be relative to center.
+                    // readPos = center - grainLen/2 + k
+                    const readPos = center - Math.floor(grainLen / 2) + k;
+                    if (pos >= 0 && pos < outData.length && readPos >= 0 && readPos < inData.length) {
+                        const w = 0.5 - 0.5 * Math.cos(2 * Math.PI * k / grainLen);
+                        outData[pos] += inData[readPos] * w * overlapGain;
+                    }
+                }
+            }
+        }
+        // End Loop
+        // 5. Formant / Artifact Guard
+        const result = { ...audio, data: [outData] };
+        const guarded = await this.formantStrategy.apply(result, audio);
+        return guarded;
+    }
+}
+exports.PitchShifterRefV1 = PitchShifterRefV1;
+function floor(x) { return Math.floor(x); }

package/dist/src/tuning/AutotuneExecutor.d.ts

@@ -0,0 +1,16 @@
+import { TuneRequestV1, AudioBufferV1 } from "@mcptoolshop/voice-engine-core";
+export declare class AutotuneExecutor {
+    private resolver;
+    private tracker;
+    private curveGen;
+    private envGen;
+    private shifter;
+    private decomposer;
+    private segmenter;
+    private baselineModel;
+    private stabilizer;
+    private resolveProsodyPreset;
+    execute(req: TuneRequestV1, audio: AudioBufferV1): Promise<AudioBufferV1>;
+    private calculateEnergyDb;
+}
+//# sourceMappingURL=AutotuneExecutor.d.ts.map

package/dist/src/tuning/AutotuneExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutotuneExecutor.d.ts","sourceRoot":"","sources":["../../../src/tuning/AutotuneExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EAAE,aAAa,EAG/B,MAAM,gCAAgC,CAAC;AAqBxC,qBAAa,gBAAgB;IACzB,OAAO,CAAC,QAAQ,CAA0B;IAG1C,OAAO,CAAC,OAAO,CAKZ;IAEH,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,aAAa,CAA6B;IAClD,OAAO,CAAC,UAAU,CAA0B;IAE5C,OAAO,CAAC,oBAAoB;IActB,OAAO,CAAC,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IA0L/E,OAAO,CAAC,iBAAiB;CAqB5B"}

package/dist/src/tuning/AutotuneExecutor.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutotuneExecutor = void 0;
+const voice_engine_core_1 = require("@mcptoolshop/voice-engine-core");
+const PitchTrackerRefV1_js_1 = require("../analysis/PitchTrackerRefV1.js");
+const PitchShifterRefV1_js_1 = require("../transformation/PitchShifterRefV1.js");
+const TargetCurveGenerator_js_1 = require("./TargetCurveGenerator.js");
+const CorrectionController_js_1 = require("./CorrectionController.js");
+const F0Decomposer_js_1 = require("../../../voice-engine-core/src/prosody/F0Decomposer.js");
+const ProsodySegmenter_js_1 = require("../../../voice-engine-core/src/prosody/ProsodySegmenter.js");
+const PhraseBaselineModel_js_1 = require("../../../voice-engine-core/src/prosody/PhraseBaselineModel.js");
+const TargetStabilizer_js_1 = require("../../../voice-engine-core/src/prosody/TargetStabilizer.js");
+const AccentRenderer_js_1 = require("../prosody/AccentRenderer.js");
+const ProsodyPresets_js_1 = require("../../../voice-engine-core/src/config/ProsodyPresets.js");
+const ProsodyStyles_js_1 = require("../../../voice-engine-core/src/config/ProsodyStyles.js");
+class AutotuneExecutor {
+    resolver = new voice_engine_core_1.TunePlanResolver();
+    // Default trackers - could be overridden or config passed in
+    tracker = new PitchTrackerRefV1_js_1.PitchTrackerRefV1({
+        windowMs: 40,
+        hopMs: 10,
+        f0Min: 50,
+        f0Max: 1000
+    });
+    curveGen = new TargetCurveGenerator_js_1.TargetCurveGenerator();
+    envGen = new CorrectionController_js_1.CorrectionController();
+    shifter = new PitchShifterRefV1_js_1.PitchShifterRefV1(); // "PSOLA-lite"
+    decomposer = new F0Decomposer_js_1.F0Decomposer();
+    segmenter = new ProsodySegmenter_js_1.ProsodySegmenter();
+    baselineModel = new PhraseBaselineModel_js_1.PhraseBaselineModel();
+    stabilizer = new TargetStabilizer_js_1.TargetStabilizer();
+    resolveProsodyPreset(presetName) {
+        switch (presetName) {
+            case "hard":
+            case "robot":
+                return ProsodyPresets_js_1.HARD_TUNE_PRESET;
+            case "subtle":
+                return ProsodyPresets_js_1.SUBTLE_PRESET;
+            case "natural":
+            case "pop":
+            default:
+                return ProsodyPresets_js_1.NATURAL_PRESET;
+        }
+    }
+    async execute(req, audio) {
+        // 1. Resolve Plan
+        const plan = this.resolver.resolve(req);
+        const preset = this.resolveProsodyPreset(req.preset);
+        // 2. Analyze Pitch
+        const f0Analysis = this.tracker.analyze(audio);
+        const frameCount = f0Analysis.f0MhzQ.length;
+        // 3. Decompose Pitch (New in Phase 7.2)
+        // We separate macro (intonation) from micro (jitter/vibrato).
+        const decomposition = this.decomposer.decompose(f0Analysis);
+        // 3b. Prosody Segmentation (Phase 7.1)
+        // Identify voiced vs unvoiced vs silence phrases.
+        const segments = this.segmenter.segment(audio.data[0], f0Analysis, preset.analysis);
+        // 3c. Phrase Baseline (Phase 7.3)
+        // Model the declination trend of each phrase.
+        const baseline = this.baselineModel.analyze(segments, decomposition.macro.valuesHz);
+        // 3d. Derive Voicing (Enhanced with Segments)
+        // Instead of raw heuristic, we can now use the segments to define the voicing mask.
+        const voicedQ = new Uint8Array(frameCount);
+        const voicingProbQ = new Int16Array(frameCount);
+        for (const seg of segments) {
+            if (seg.kind === 'voiced') {
+                for (let i = seg.startFrame; i < seg.endFrame; i++) {
+                    voicedQ[i] = 1;
+                    voicingProbQ[i] = 10000;
+                }
+            }
+        }
+        const voicing = {
+            sampleRateHz: f0Analysis.sampleRateHz,
+            frameHz: f0Analysis.frameHz,
+            hopSamples: f0Analysis.hopSamples,
+            t0Samples: f0Analysis.t0Samples,
+            voicedQ,
+            voicingProbQ
+        };
+        // 4. Generate Control Curves
+        // Old Method:
+        // const target = this.curveGen.generate(f0Analysis, voicing, plan);
+        // Phase 7.4 Target Stabilizer Integration:
+        // Stabilize the INTENT curve (macro - baseline)
+        const stabilized = this.stabilizer.stabilize(baseline.intentHz, segments, {
+            allowedPitchClasses: plan.scaleConfig?.allowedPitchClasses,
+            hysteresisCents: preset.stabilizer.hysteresisCents,
+            minHoldMs: preset.stabilizer.minHoldMs,
+            switchRampMs: preset.stabilizer.switchRampMs,
+            transitionSlopeThreshCentsPerSec: preset.stabilizer.transitionSlopeThreshCentsPerSec,
+            rootOffsetCents: 0
+        }, f0Analysis.frameHz);
+        // Phase 8: Expressive Rendering (8.4 Style Profiles)
+        const style = (0, ProsodyStyles_js_1.resolveProsodyStyle)(req.style || 'speech_neutral');
+        if (req.events && req.events.length > 0) {
+            const frameRateHz = f0Analysis.sampleRateHz / f0Analysis.hopSamples;
+            const accentOffsets = AccentRenderer_js_1.AccentRenderer.render(req.events, frameCount, style, frameRateHz);
+            // Add offsets to stabilized target
+            for (let i = 0; i < frameCount; i++) {
+                if (stabilized.noteIds[i] >= 0) {
+                    stabilized.targetCents[i] += accentOffsets[i];
+                }
+            }
+            // Phase 8.5: Post-Focus Compression (PFC)
+            // Reduces pitch range/variance after a strong focus event to de-accentuate specific information.
+            if (style.postFocusCompression > 0) {
+                // 1. Find the strongest accent (focus)
+                let maxStrength = 0;
+                let focusTime = -1;
+                // Simple approach: global max in request
+                for (const event of req.events) {
+                    if (event.type === 'accent' && event.strength > maxStrength) {
+                        maxStrength = event.strength;
+                        focusTime = event.time;
+                    }
+                }
+                // Threshold to trigger PFC (e.g. > 0.5 strength)
+                if (maxStrength > 0.5 && focusTime >= 0 && focusTime < frameCount - 1) {
+                    const pfcStrength = style.postFocusCompression;
+                    // Apply compression for frames AFTER the focus event
+                    // We can retain a small buffer (e.g. 50ms) before compressing fully
+                    // But for now, let's just start compressing after focusTime + span/2 or similar?
+                    // User said: For frames t > focusTime (center).
+                    // Let's add a small grace period (e.g. 10 frames = 100ms) to let the accent finish falling.
+                    // Or just strict t > focusTime.
+                    for (let t = focusTime; t < frameCount; t++) {
+                        // We need baseline in Cents.
+                        // baseline.baselineHz[t] -> Cents (MIDI absolute)
+                        // 440Hz = 6900 cents.
+                        // cents = 6900 + 1200 * log2(hz / 440)
+                        const bHz = baseline.baselineHz[t];
+                        if (bHz > 10) { // avoid log(0)
+                            const baselineCents = 6900 + 1200 * Math.log2(bHz / 440);
+                            // Calculate deviation of current target from baseline
+                            const currentCents = stabilized.targetCents[t];
+                            const deviation = currentCents - baselineCents;
+                            // Compress deviation
+                            // newDeviation = deviation * (1 - pfcStrength)
+                            // newTarget = baselineCents + newDeviation
+                            // Ramp-in the compression? 
+                            // Let's do a simple linear ramp over 20 frames (200ms)
+                            let ramp = 1.0;
+                            if (t < focusTime + 20) {
+                                ramp = (t - focusTime) / 20.0;
+                            }
+                            const effectiveCompression = pfcStrength * ramp;
+                            stabilized.targetCents[t] = baselineCents + (deviation * (1 - effectiveCompression));
+                        }
+                    }
+                }
+            }
+        }
+        // Re-construct the Final Target Curve
+        // Final Target = Stabilized Intent + Micro (Vibrato)
+        // Note: baseline is discarded (flattened out) if we just use Stabilized.
+        // If we want to strictly follow the scale, we discard the baseline declination.
+        const finalTargetCentsQ = new Int32Array(frameCount);
+        for (let i = 0; i < frameCount; i++) {
+            if (stabilized.noteIds[i] >= 0) {
+                // Stabilized Cents (e.g. 6900.0)
+                const stabCents = stabilized.targetCents[i];
+                // Micro deviation in Hz -> Cents
+                // microHz is deviation from macroHz
+                // We approximate Cents Micro: 1200 * log2((macro + micro) / macro)
+                // Wait, micro is deviation around 0? No, F0Decomposer says "Relative Pitch Deviation (e.g., +2.5)".
+                const macroHz = decomposition.macro.valuesHz[i];
+                const microHz = decomposition.micro.valuesHz[i];
+                let microCents = 0;
+                if (macroHz > 10) {
+                    microCents = 1200 * Math.log2((macroHz + microHz) / macroHz);
+                }
+                // Final Cents = Stabilized + Micro
+                const finalCents = stabCents + microCents;
+                // Convert to Int32 Scaled (x1000)
+                finalTargetCentsQ[i] = Math.round(finalCents * 1000);
+            }
+            else {
+                // Unvoiced - hold last or default?
+                // Let's copy from curveGen behavior or input pitch
+                // Here we just use 0 or last. Shifter usually ignores target for unvoiced.
+                finalTargetCentsQ[i] = 0;
+            }
+        }
+        const target = {
+            sampleRateHz: f0Analysis.sampleRateHz,
+            frameHz: f0Analysis.frameHz,
+            hopSamples: f0Analysis.hopSamples,
+            t0Samples: f0Analysis.t0Samples,
+            targetCentsQ: finalTargetCentsQ
+        };
+        const envelope = this.envGen.generate(f0Analysis, voicing, target, plan);
+        // 5. Apply Pitch Shift
+        const result = await this.shifter.shift(audio, f0Analysis, voicing, target, envelope);
+        return result;
+    }
+    calculateEnergyDb(signal, frameCount, hopSamples, windowSamples) {
+        const energyDb = new Float32Array(frameCount);
+        const len = signal.length;
+        for (let i = 0; i < frameCount; i++) {
+            const start = i * hopSamples;
+            const end = Math.min(start + windowSamples, len);
+            if (end <= start) {
+                energyDb[i] = -120;
+                continue;
+            }
+            let sumSq = 0;
+            for (let j = start; j < end; j++) {
+                sumSq += signal[j] * signal[j];
+            }
+            const rms = Math.sqrt(sumSq / (end - start));
+            energyDb[i] = rms > 1e-9 ? 20 * Math.log10(rms) : -120;
+        }
+        return energyDb;
+    }
+}
+exports.AutotuneExecutor = AutotuneExecutor;

package/dist/src/tuning/CorrectionController.d.ts

@@ -0,0 +1,5 @@
+import { F0TrackV1, VoicingMaskV1, TunePlanV1, TargetCurveV1, CorrectionEnvelopeV1 } from "@mcptoolshop/voice-engine-core";
+export declare class CorrectionController {
+    generate(f0: F0TrackV1, voicing: VoicingMaskV1, target: TargetCurveV1, plan: TunePlanV1): CorrectionEnvelopeV1;
+}
+//# sourceMappingURL=CorrectionController.d.ts.map

package/dist/src/tuning/CorrectionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CorrectionController.d.ts","sourceRoot":"","sources":["../../../src/tuning/CorrectionController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3H,qBAAa,oBAAoB;IAC7B,QAAQ,CACJ,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,UAAU,GACjB,oBAAoB;CAoG1B"}