@mcptoolshop/voice-engine-dsp 0.0.1

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

@@ -0,0 +1,36 @@
+export declare class StreamingAutotuneEngine {
+    private state;
+    private config;
+    private preset;
+    private frameCount;
+    private eventScheduler;
+    private allowedSet;
+    private _lastOutputCents;
+    private _mockPitchHz;
+    constructor(config: any, preset: any);
+    private hzToCents;
+    private quantize;
+    getLastOutputCents(): number;
+    setMockPitch(hz: number): void;
+    enqueueEvents(events: any[]): void;
+    process(chunk: Float32Array): {
+        audio: Float32Array;
+        targets: Float32Array;
+    };
+    processFrame(analysis: {
+        energyDb: number;
+        confidenceQ: number;
+        pitchHz: number;
+    }, frameIndex: number): void;
+    processFramePipeline(analysis: {
+        energyDb: number;
+        confidenceQ: number;
+        pitchHz: number;
+    }, frameIndex: number): void;
+    private getCurrentRampValue;
+    private handleSegmentStart;
+    private handleSegmentEnd;
+    reset(): void;
+    private createInitialState;
+}
+//# sourceMappingURL=StreamingAutotuneEngine_Fixed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingAutotuneEngine_Fixed.d.ts","sourceRoot":"","sources":["../../../src/tuning/StreamingAutotuneEngine_Fixed.ts"],"names":[],"mappings":"AAiDA,qBAAa,uBAAuB;IAChC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,YAAY,CAAa;gBAErB,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG;IAUpC,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,QAAQ;IAuBT,kBAAkB,IAAI,MAAM;IAI5B,YAAY,CAAC,EAAE,EAAE,MAAM;IAIvB,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE;IAIlC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG;QAAE,KAAK,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,YAAY,CAAA;KAAE;IAsC5E,YAAY,CAAC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAI5G,oBAAoB,CAAC,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAqKpH,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,gBAAgB;IAOxB,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,kBAAkB;CAqC7B"}

package/dist/src/tuning/StreamingAutotuneEngine_Fixed.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingAutotuneEngine = void 0;
+const OnlineStats_1 = require("../../../voice-engine-core/src/prosody/OnlineStats");
+class EventScheduler {
+    queue = [];
+    startIndex = 0;
+    enqueue(events) {
+        this.queue.push(...events);
+        this.queue.sort((a, b) => a.time - b.time);
+        this.startIndex = 0;
+    }
+    getActiveEvents(currentTime) {
+        const active = [];
+        while (this.startIndex < this.queue.length) {
+            const e = this.queue[this.startIndex];
+            const end = e.endTime !== undefined ? e.endTime : (e.time + (e.duration || 10));
+            if (end < currentTime) {
+                this.startIndex++;
+            }
+            else {
+                break;
+            }
+        }
+        for (let i = this.startIndex; i < this.queue.length; i++) {
+            const e = this.queue[i];
+            if (e.endTime !== undefined) {
+                if (e.time <= currentTime && e.endTime >= currentTime)
+                    active.push(e);
+                else if (e.time > currentTime)
+                    break; // Future
+            }
+            else {
+                const limit = e.duration || 10;
+                if (Math.abs(e.time - currentTime) <= limit)
+                    active.push(e);
+                else if (e.time - limit > currentTime)
+                    break; // Future
+            }
+        }
+        return active;
+    }
+    pruneOldEvents(currentTime) {
+        if (this.startIndex > 50) {
+            this.queue.splice(0, this.startIndex);
+            this.startIndex = 0;
+        }
+    }
+}
+class StreamingAutotuneEngine {
+    state;
+    config;
+    preset;
+    frameCount = 0;
+    eventScheduler;
+    allowedSet;
+    _lastOutputCents = 0;
+    _mockPitchHz = 0;
+    constructor(config, preset) {
+        this.config = config;
+        this.preset = preset;
+        this.state = this.createInitialState();
+        this.eventScheduler = new EventScheduler();
+        const allowed = config.allowedPitchClasses || [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        this.allowedSet = new Set(allowed);
+    }
+    hzToCents(h) {
+        return (h > 1.0) ? (6900 + 1200 * Math.log2(h / 440)) : 0;
+    }
+    quantize(c) {
+        const rootOffset = this.config.rootOffsetCents || 0;
+        const local = c - rootOffset;
+        const midi = Math.round(local / 100);
+        const pc = ((midi % 12) + 12) % 12;
+        if (this.allowedSet.has(pc)) {
+            return { id: midi, center: midi * 100 + rootOffset };
+        }
+        for (let i = 1; i <= 6; i++) {
+            let m = midi + i;
+            let p = ((m % 12) + 12) % 12;
+            if (this.allowedSet.has(p))
+                return { id: m, center: m * 100 + rootOffset };
+            m = midi - i;
+            p = ((m % 12) + 12) % 12;
+            if (this.allowedSet.has(p))
+                return { id: m, center: m * 100 + rootOffset };
+        }
+        return { id: midi, center: midi * 100 + rootOffset };
+    }
+    getLastOutputCents() {
+        return this._lastOutputCents;
+    }
+    setMockPitch(hz) {
+        this._mockPitchHz = hz;
+    }
+    enqueueEvents(events) {
+        this.eventScheduler.enqueue(events);
+    }
+    process(chunk) {
+        const hopSize = 128;
+        const numFrames = Math.floor(chunk.length / hopSize);
+        const targets = new Float32Array(numFrames);
+        for (let i = 0; i < numFrames; i++) {
+            const startSample = i * hopSize;
+            // Mock Analysis (to be replaced by StreamingPitchTracker)
+            let sumSq = 0;
+            for (let j = 0; j < hopSize; j++) {
+                // Check bounds
+                if (startSample + j < chunk.length) {
+                    const s = chunk[startSample + j];
+                    sumSq += s * s;
+                }
+            }
+            const rms = Math.sqrt(sumSq / hopSize);
+            const energyDb = rms > 1e-9 ? 20 * Math.log10(rms) : -100;
+            // Mock Pitch/Confidence (0 confidence = unvoiced)
+            // In real impl, this comes from F0Decomposer
+            const isVoiced = energyDb > -50 && this._mockPitchHz > 0;
+            const frameAnalysis = {
+                energyDb,
+                confidenceQ: isVoiced ? 10000 : 0,
+                pitchHz: this._mockPitchHz
+            };
+            // Using the new pipeline
+            this.processFramePipeline(frameAnalysis, this.frameCount++);
+            targets[i] = this._lastOutputCents;
+        }
+        return { audio: chunk.slice(), targets: targets };
+    }
+    processFrame(analysis, frameIndex) {
+        this.processFramePipeline(analysis, frameIndex);
+    }
+    processFramePipeline(analysis, frameIndex) {
+        const { energyDb, confidenceQ, pitchHz } = analysis;
+        const config = this.config;
+        const segmenter = this.state.segmenter;
+        // Defaults
+        const silenceDb = config.silenceThresholdDb ?? -60;
+        const voicingLimit = config.voicingThresholdQ ?? 2000;
+        const enterLimit = config.voicedEnterFrames ?? 2;
+        const exitLimit = config.voicedExitFrames ?? 5;
+        // 1. Input Conditions
+        const isSpeechCandidate = energyDb > silenceDb;
+        const isVoicedCandidate = isSpeechCandidate && (confidenceQ > voicingLimit);
+        // 2. Hysteresis Logic
+        if (segmenter.isVoiced) {
+            if (!isVoicedCandidate) {
+                segmenter.exitCount++;
+                if (segmenter.exitCount > exitLimit) {
+                    this.handleSegmentEnd(frameIndex);
+                }
+            }
+            else {
+                segmenter.exitCount = 0;
+            }
+        }
+        else {
+            if (isVoicedCandidate) {
+                segmenter.enterCount++;
+                if (segmenter.enterCount >= enterLimit) {
+                    this.handleSegmentStart(frameIndex);
+                }
+            }
+            else {
+                segmenter.enterCount = 0;
+            }
+        }
+        // 3. Process Voiced Frame Pipeline
+        if (segmenter.isVoiced) {
+            segmenter.accumulatedConf += confidenceQ;
+            segmenter.accumulatedEnergy += energyDb;
+            // --- Pipeline Step 1: Decomposition ---
+            const rawCents = this.hzToCents(pitchHz);
+            // For now, assuming raw input IS the decomposition
+            const centerCents = rawCents;
+            const residualCents = 0;
+            // --- Pipeline Step 2: Baseline/Intent ---
+            // Update Online Baseline (using Cents for linear regression on pitch)
+            OnlineStats_1.OnlineStats.update(this.state.baseline, frameIndex, rawCents);
+            const { slope, intercept } = OnlineStats_1.OnlineStats.getRegression(this.state.baseline);
+            const intentCents = centerCents;
+            // --- Pipeline Step 3: Stability ---
+            const stabilizer = this.state.stabilizer;
+            const hysteresis = config.hysteresisCents ?? 15;
+            const minHoldFrames = config.minHoldFrames ?? 6;
+            const rampFrames = config.rampFrames ?? 3;
+            // Calc delta/slope for transition detection
+            const delta = 0; // TODO: Track previous raw cents
+            const isTransition = delta > (config.slopeThreshFrame ?? 5);
+            const cand = this.quantize(intentCents);
+            // Initialize if first voiced frame logic covered by handleSegmentStart -> default state
+            if (stabilizer.currentNoteId === 0) {
+                stabilizer.currentNoteId = cand.id;
+                stabilizer.lastTargetCents = cand.center;
+                stabilizer.holdFrames = 0;
+                stabilizer.rampActive = false;
+                stabilizer.rampEndCents = cand.center;
+                stabilizer.rampStartCents = cand.center;
+            }
+            else {
+                stabilizer.holdFrames++;
+                let shouldSwitch = false;
+                if (!isTransition && stabilizer.holdFrames >= minHoldFrames) {
+                    const currentErr = Math.abs(intentCents - stabilizer.lastTargetCents);
+                    const candErr = Math.abs(intentCents - cand.center);
+                    if (currentErr - candErr > hysteresis) {
+                        shouldSwitch = true;
+                    }
+                }
+                if (shouldSwitch) {
+                    stabilizer.rampStartCents = stabilizer.rampActive ?
+                        this.getCurrentRampValue(stabilizer) : stabilizer.lastTargetCents;
+                    stabilizer.rampEndCents = cand.center;
+                    stabilizer.rampActive = true;
+                    stabilizer.rampProgress = 0;
+                    stabilizer.currentNoteId = cand.id;
+                    stabilizer.lastTargetCents = cand.center;
+                    stabilizer.holdFrames = 0;
+                }
+            }
+            // Ramping
+            let macroCents = stabilizer.lastTargetCents;
+            if (stabilizer.rampActive) {
+                stabilizer.rampProgress++;
+                macroCents = this.getCurrentRampValue(stabilizer);
+                if (stabilizer.rampProgress >= rampFrames) {
+                    stabilizer.rampActive = false;
+                }
+            }
+            // --- Pipeline Step 4: Events/PFC ---
+            this.eventScheduler.pruneOldEvents(frameIndex);
+            const activeEvents = this.eventScheduler.getActiveEvents(frameIndex);
+            let accentOffset = 0;
+            for (const event of activeEvents) {
+                const duration = event.duration || 10;
+                const strength = event.strength || 0;
+                const shape = event.shape || 'rise';
+                const radius = duration / 2;
+                const d = frameIndex - event.time;
+                if (Math.abs(d) <= radius) {
+                    const sign = (shape === 'fall' || shape === 'fall-rise') ? -1.0 : 1.0;
+                    const w = 0.5 * (1 + Math.cos((Math.PI * d) / radius));
+                    accentOffset += w * strength * sign; // Simple additive
+                }
+            }
+            // Update PFC State
+            const pfc = this.state.pfc;
+            // Track max accent strength in recent window (simple approach)
+            const currentAbsAccent = Math.abs(accentOffset);
+            if (currentAbsAccent > 0.01) {
+                if (currentAbsAccent > pfc.focusStrength) {
+                    pfc.focusStrength = currentAbsAccent;
+                    pfc.focusTime = frameIndex;
+                }
+                pfc.activeFade = 1.0;
+            }
+            else {
+                pfc.activeFade *= 0.95; // Decay
+                pfc.focusStrength *= 0.95;
+            }
+            // --- Pipeline Step 5: Reconstruct ---
+            let finalCents = macroCents + accentOffset + residualCents;
+            // Apply PFC
+            if (this.state.pfc.activeFade > 0) {
+                const { slope, intercept } = OnlineStats_1.OnlineStats.getRegression(this.state.baseline);
+                const baselineAtT = intercept + slope * frameIndex;
+                const compressionStrength = this.config.pfcStrength ?? 0.5;
+                const factor = this.state.pfc.activeFade * compressionStrength;
+                if (!isNaN(intercept)) {
+                    finalCents = baselineAtT + (finalCents - baselineAtT) * (1.0 - factor);
+                }
+            }
+            this._lastOutputCents = finalCents;
+        }
+    }
+    getCurrentRampValue(stabilizer) {
+        // Simple linear interpolation
+        const total = this.config.rampFrames ?? 3;
+        if (stabilizer.rampProgress >= total)
+            return stabilizer.rampEndCents;
+        const t = stabilizer.rampProgress / total;
+        return stabilizer.rampStartCents + (stabilizer.rampEndCents - stabilizer.rampStartCents) * t;
+    }
+    handleSegmentStart(index) {
+        const segmenter = this.state.segmenter;
+        segmenter.isVoiced = true;
+        segmenter.enterCount = 0;
+        segmenter.exitCount = 0;
+        segmenter.currentSegmentStart = index;
+        segmenter.accumulatedConf = 0;
+        segmenter.accumulatedEnergy = 0;
+        // Reset Stabilizer
+        this.state.stabilizer.currentNoteId = 0;
+        this.state.stabilizer.holdFrames = 0;
+        this.state.stabilizer.rampActive = false;
+    }
+    handleSegmentEnd(index) {
+        const segmenter = this.state.segmenter;
+        segmenter.isVoiced = false;
+        segmenter.exitCount = 0;
+        segmenter.enterCount = 0;
+    }
+    reset() {
+        this.state = this.createInitialState();
+    }
+    createInitialState() {
+        return {
+            segmenter: {
+                isVoiced: false,
+                enterCount: 0,
+                exitCount: 0,
+                currentSegmentStart: 0,
+                accumulatedConf: 0,
+                accumulatedEnergy: 0
+            },
+            decomposer: {
+                buffer: new Float32Array(0),
+                microState: undefined
+            },
+            baseline: {
+                sumX: 0,
+                sumY: 0,
+                sumXY: 0,
+                sumXX: 0,
+                count: 0
+            },
+            stabilizer: {
+                currentNoteId: 0,
+                lastTargetCents: 0,
+                holdFrames: 0,
+                rampActive: false,
+                rampStartCents: 0,
+                rampEndCents: 0,
+                rampProgress: 0
+            },
+            pfc: {
+                focusTime: null,
+                focusStrength: 0,
+                activeFade: 0
+            }
+        };
+    }
+}
+exports.StreamingAutotuneEngine = StreamingAutotuneEngine;

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

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

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

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

package/dist/src/tuning/TargetCurveGenerator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetCurveGenerator = void 0;
+const ScaleQuantizer_js_1 = require("./ScaleQuantizer.js");
+class TargetCurveGenerator {
+    generate(f0, voicing, plan) {
+        const len = f0.f0MhzQ.length;
+        const targetCentsQ = new Int32Array(len);
+        const allowed = plan.scaleConfig.allowedPitchClasses;
+        const glideMs = plan.parameters.glideMsQ;
+        const dtMs = (f0.hopSamples / f0.sampleRateHz) * 1000;
+        // Glide Factor (1-pole exponential approach)
+        // alpha = 1 - exp(-dt / tau)
+        // usage: y = y + alpha * (target - y)
+        // If glideMs (tau) is 0, alpha = 1.
+        let alpha = 1.0;
+        if (glideMs > 0) {
+            alpha = 1.0 - Math.exp(-dtMs / Math.max(1, glideMs));
+        }
+        let currentCents = 0;
+        let p_initialized = false;
+        for (let i = 0; i < len; i++) {
+            // 1. Get Input Pitch
+            const isVoiced = voicing.voicedQ[i] > 0;
+            if (!isVoiced) {
+                // If not initialized, default to something sane (e.g. 6900)
+                // But generally hold last value.
+                if (!p_initialized) {
+                    currentCents = 6900;
+                    p_initialized = true;
+                }
+                // Hold last
+                targetCentsQ[i] = Math.round(currentCents * 1000);
+                continue;
+            }
+            let f0Hz = f0.f0MhzQ[i] / 1000.0;
+            // Sanity clamp
+            if (f0Hz < 20)
+                f0Hz = 20;
+            // MIDI 69 = A4 440Hz = 6900 cents
+            // Cents = 6900 + 1200 * log2(Hz/440)
+            const inputCents = 6900 + 1200 * Math.log2(f0Hz / 440);
+            // 2. Quantize
+            const targetNote = ScaleQuantizer_js_1.ScaleQuantizer.quantize(inputCents, allowed);
+            // 3. Glide
+            if (!p_initialized) {
+                currentCents = targetNote;
+                p_initialized = true;
+            }
+            else {
+                if (alpha >= 0.999) {
+                    currentCents = targetNote;
+                }
+                else {
+                    currentCents += alpha * (targetNote - currentCents);
+                }
+            }
+            targetCentsQ[i] = Math.round(currentCents * 1000);
+        }
+        return {
+            sampleRateHz: f0.sampleRateHz,
+            frameHz: f0.frameHz,
+            hopSamples: f0.hopSamples,
+            t0Samples: f0.t0Samples,
+            targetCentsQ
+        };
+    }
+}
+exports.TargetCurveGenerator = TargetCurveGenerator;

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

@@ -0,0 +1,6 @@
+import { F0TrackV1, VoicingMaskV1, TuneScoreV1, TargetCurveV1 } from "@mcptoolshop/voice-engine-core";
+export declare class TargetCurveRefV1 {
+    constructor();
+    generate(f0Track: F0TrackV1, voicing: VoicingMaskV1, score: TuneScoreV1): TargetCurveV1;
+}
+//# sourceMappingURL=TargetCurveRefV1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TargetCurveRefV1.d.ts","sourceRoot":"","sources":["../../../src/tuning/TargetCurveRefV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAGvD,MAAM,gCAAgC,CAAC;AAExC,qBAAa,gBAAgB;;IAGlB,QAAQ,CACX,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,GACnB,aAAa;CA4EnB"}

package/dist/src/tuning/TargetCurveRefV1.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetCurveRefV1 = void 0;
+const voice_engine_core_1 = require("@mcptoolshop/voice-engine-core");
+class TargetCurveRefV1 {
+    constructor() { }
+    generate(f0Track, voicing, score) {
+        // Validate inputs match in length/framing
+        const numFrames = f0Track.f0MhzQ.length;
+        const targetCentsQ = new Int32Array(numFrames);
+        // Parse Score
+        if (score.mode !== "scale") {
+            throw new Error("Only scale mode supported in V1");
+        }
+        const config = score;
+        const { tonicMidi } = (0, voice_engine_core_1.parseKey)(config.key);
+        const pitchClasses = (0, voice_engine_core_1.scaleToPitchClasses)(config.scale, tonicMidi);
+        // Glide Logic
+        const msPerFrame = 1000 / f0Track.frameHz;
+        const glideFrames = config.glideMsQ > 0 ? config.glideMsQ / msPerFrame : 0;
+        // Constant-Time Exponential Glide (1-pole IIR)
+        // k = 1 / (glideFrames + 1)
+        const k = glideFrames > 0 ? (1 / (glideFrames + 1)) : 1;
+        let currentCentsQ = 0; // State
+        let initialized = false;
+        for (let i = 0; i < numFrames; i++) {
+            const isVoiced = voicing.voicedQ[i] > 0;
+            if (!isVoiced) {
+                // If unvoiced, hold previous value.
+                // If never initialized, default to tonic.
+                if (!initialized) {
+                    currentCentsQ = tonicMidi * 1000;
+                    initialized = true;
+                }
+                targetCentsQ[i] = Math.round(currentCentsQ);
+                continue;
+            }
+            // 1. Measure F0 -> Cents
+            const f0Mhz = f0Track.f0MhzQ[i];
+            const f0Hz = f0Mhz / 1000;
+            // Safety check for invalid f0
+            if (f0Hz <= 1) { // Basic safety floor
+                targetCentsQ[i] = Math.round(currentCentsQ);
+                continue;
+            }
+            // Standard MIDI Cents: 69000 + 12000 * log2(f / 440)
+            const centsQ = 69000 + 12000 * Math.log2(f0Hz / 440);
+            // 2. Quantize
+            const goalCentsQ = (0, voice_engine_core_1.nearestAllowedPitch)(Math.round(centsQ), pitchClasses);
+            // 3. Initialize if needed
+            if (!initialized) {
+                currentCentsQ = goalCentsQ;
+                initialized = true;
+            }
+            // 4. Glide
+            currentCentsQ += (goalCentsQ - currentCentsQ) * k;
+            // 5. Store
+            targetCentsQ[i] = Math.round(currentCentsQ);
+        }
+        return {
+            sampleRateHz: f0Track.sampleRateHz,
+            frameHz: f0Track.frameHz,
+            hopSamples: f0Track.hopSamples,
+            t0Samples: f0Track.t0Samples,
+            targetCentsQ
+        };
+    }
+}
+exports.TargetCurveRefV1 = TargetCurveRefV1;

package/dist/src/utils/AudioBufferUtils.d.ts

@@ -0,0 +1,3 @@
+import { AudioBufferV1 } from "@mcptoolshop/voice-engine-core";
+export declare function monoDownmix(buffer: AudioBufferV1): Float32Array;
+//# sourceMappingURL=AudioBufferUtils.d.ts.map

package/dist/src/utils/AudioBufferUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioBufferUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/AudioBufferUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,CAkB/D"}

package/dist/src/utils/AudioBufferUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monoDownmix = monoDownmix;
+function monoDownmix(buffer) {
+    if (buffer.channels === 1) {
+        return buffer.data[0];
+    }
+    const length = buffer.data[0].length;
+    const output = new Float32Array(length);
+    const channelCount = buffer.channels;
+    for (let i = 0; i < length; i++) {
+        let sum = 0;
+        for (let ch = 0; ch < channelCount; ch++) {
+            sum += buffer.data[ch][i];
+        }
+        output[i] = sum / channelCount;
+    }
+    return output;
+}

package/dist/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PROSODY_API_VERSION = "1.0.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/src/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,UAAU,CAAC"}

package/dist/src/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROSODY_API_VERSION = void 0;
+exports.PROSODY_API_VERSION = '1.0.0';

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mcptoolshop/voice-engine-dsp",
+  "version": "0.0.1",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcp-tool-shop-org/mcp-voice-engine.git"
+  },
+  "keywords": [
+    "voice",
+    "prosody",
+    "autotune",
+    "streaming",
+    "dsp",
+    "mcp"
+  ],
+  "author": "MCP Voice Engine Maintainers",
+  "license": "MIT",
+  "scripts": {
+    "test": "npx vitest run",
+    "test:meaning": "npx vitest run test/streaming_golden.test.ts",
+    "test:determinism": "npx vitest run test/determinism_matrix.test.ts",
+    "bench:rtf": "npx vitest run test/rtf_benchmark.test.ts",
+    "smoke": "npx tsx tools/smoke-cli.ts"
+  },
+  "dependencies": {
+    "@mcptoolshop/voice-engine-core": "0.0.1"
+  }
+}