@mcptoolshop/voice-engine-dsp 0.0.1

package/dist/src/tuning/CorrectionController.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrectionController = void 0;
+class CorrectionController {
+    generate(f0, voicing, target, plan) {
+        const len = f0.f0MhzQ.length;
+        const strengthQ = new Int16Array(len);
+        const baseSnap = plan.parameters.snapStrengthQ / 10000.0; // 0..1
+        const protection = plan.parameters.consonantProtectionQ / 10000.0; // 0..1
+        const speedVal = plan.parameters.retuneSpeedQ; // 0..10000
+        // Phase 6 Controls
+        const globalMix = (plan.parameters.globalStrengthQ ?? 10000) / 10000.0; // 0..1
+        const attackMs = plan.parameters.attackMsQ ?? 0;
+        const releaseMs = plan.parameters.releaseMsQ ?? 0;
+        // Time constants
+        // const frameDur = f0.hopSamples / f0.sampleRateHz; // e.g. 0.01s
+        const frameDur = 0.01; // Force 10ms for debugging if needed
+        let alphaAtt = attackMs > 0 ? (1.0 - Math.exp(-frameDur / (attackMs / 1000.0))) : 1.0;
+        let alphaRel = releaseMs > 0 ? (1.0 - Math.exp(-frameDur / (releaseMs / 1000.0))) : 1.0;
+        let currentStrength = 0;
+        // Retune Speed Model:
+        // low speed => low alpha (lazy correction). high speed => high alpha.
+        // If speed=10000 (100%), alpha=1.0 (Instant).
+        // If speed=0 (0%), alpha=0.01 (Very slow).
+        // Exponential map typical for speed knobs? Linear is fine for V1.
+        const alpha = Math.max(0.01, speedVal / 10000.0);
+        let smoothDiff = 0;
+        for (let i = 0; i < len; i++) {
+            const isVoiced = voicing.voicedQ[i] > 0;
+            if (!isVoiced) {
+                strengthQ[i] = 0;
+                smoothDiff = 0; // Reset state on unvoiced
+                continue;
+            }
+            // 1. Calculate Raw Difference (Target - Input)
+            // Need Input Cents. Re-calc or assume we have it?
+            // Re-calc is safest (pure).
+            let f0Hz = f0.f0MhzQ[i] / 1000.0;
+            if (f0Hz < 20)
+                f0Hz = 20; // Guard
+            const inputCents = 6900 + 1200 * Math.log2(f0Hz / 440);
+            const targetVal = target.targetCentsQ[i] / 1000.0; // Milli-Cents to Cents
+            const rawDiff = targetVal - inputCents;
+            // 2. Apply Retune Speed (Smoothing the Correction)
+            smoothDiff += alpha * (rawDiff - smoothDiff);
+            // 3. Calculate Ratio Strength
+            // Wanted Correction = smoothDiff.
+            // Available Correction = rawDiff.
+            // Strength = smoothDiff / rawDiff.
+            let ratio = 0;
+            if (Math.abs(rawDiff) > 0.001) {
+                ratio = smoothDiff / rawDiff;
+            }
+            else {
+                ratio = 1.0; // Already there
+            }
+            // Clamp ratio 0..1? 
+            // If overshoot (ringing), ratio > 1. 
+            // Usually we clamp strength 0..1 for artifacts.
+            ratio = Math.max(0, Math.min(1, ratio));
+            // 4. Protection
+            // If confidence is low, reduce max strength.
+            // confQ: 0..10000.
+            const conf = f0.confQ[i] / 10000.0;
+            // protectedMax = 1.0 - protection * (1.0 - conf)
+            // If protection=1, and conf=0 => max=0.
+            // If protection=0 => max=1.
+            const confCheck = Math.max(0, 1.0 - protection * (1.0 - conf));
+            // 5. Final Strength
+            // Base Snap * Computed Ratio * Protection * Global Mix (Phase 6)
+            let targetStrength = baseSnap * ratio * confCheck * globalMix;
+            // 6. Attack / Release Smoothing
+            if (targetStrength > currentStrength) {
+                // console.log(`Debug Att: Target=${targetStrength}, Curr=${currentStrength}, Alpha=${alphaAtt}`);
+                currentStrength += (targetStrength - currentStrength) * alphaAtt;
+            }
+            else {
+                currentStrength += (targetStrength - currentStrength) * alphaRel;
+            }
+            strengthQ[i] = Math.floor(currentStrength * 10000);
+        }
+        return {
+            sampleRateHz: f0.sampleRateHz,
+            frameHz: f0.frameHz,
+            hopSamples: f0.hopSamples,
+            t0Samples: f0.t0Samples,
+            strengthQ
+        };
+    }
+}
+exports.CorrectionController = CorrectionController;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CorrectionControllerRefV1.d.ts","sourceRoot":"","sources":["../../../src/tuning/CorrectionControllerRefV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,oBAAoB,EAE9D,MAAM,gCAAgC,CAAC;AAExC,qBAAa,yBAAyB;;IAG3B,QAAQ,CACV,OAAO,EAAE,SAAS,EAClB,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,GACpB,oBAAoB;CA+D1B"}

package/dist/src/tuning/CorrectionControllerRefV1.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrectionControllerRefV1 = void 0;
+class CorrectionControllerRefV1 {
+    constructor() { }
+    generate(f0Track, voicing, score) {
+        const numFrames = f0Track.f0MhzQ.length;
+        const strengthQ = new Int16Array(numFrames);
+        if (score.mode !== "scale") {
+            throw new Error("Only scale mode supported in V1");
+        }
+        const config = score;
+        const baseStrength = config.snapStrengthQ;
+        // Pass 1: Raw Strength Calculation
+        for (let i = 0; i < numFrames; i++) {
+            const isVoiced = voicing.voicedQ[i] > 0;
+            if (!isVoiced) {
+                strengthQ[i] = 0;
+            }
+            else {
+                const conf = f0Track.confQ[i];
+                // strength = snapStrengthQ * (confQ / 10000)
+                // Linear scaling by confidence
+                strengthQ[i] = Math.round(baseStrength * (conf / 10000));
+            }
+        }
+        // Pass 2: Boundary Softening (Distance Transform)
+        // If dist(unvoiced) < 3, strength *= dist/3
+        const dist = new Int32Array(numFrames).fill(numFrames + 1);
+        // Init distance 0 at unvoiced frames
+        for (let i = 0; i < numFrames; i++) {
+            if (voicing.voicedQ[i] === 0) {
+                dist[i] = 0;
+            }
+        }
+        // Forward scan
+        for (let i = 1; i < numFrames; i++) {
+            dist[i] = Math.min(dist[i], dist[i - 1] + 1);
+        }
+        // Backward scan
+        for (let i = numFrames - 2; i >= 0; i--) {
+            dist[i] = Math.min(dist[i], dist[i + 1] + 1);
+        }
+        // Apply erosion
+        for (let i = 0; i < numFrames; i++) {
+            const d = dist[i];
+            if (d < 3) {
+                // d=0 -> strength=0 (already set)
+                // d=1 -> strength*=1/3
+                // d=2 -> strength*=2/3
+                strengthQ[i] = Math.floor((strengthQ[i] * d) / 3);
+            }
+        }
+        return {
+            sampleRateHz: f0Track.sampleRateHz,
+            frameHz: f0Track.frameHz,
+            hopSamples: f0Track.hopSamples,
+            t0Samples: f0Track.t0Samples,
+            strengthQ
+        };
+    }
+}
+exports.CorrectionControllerRefV1 = CorrectionControllerRefV1;

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

@@ -0,0 +1,7 @@
+export declare class ScaleQuantizer {
+    /**
+     * Quantizes an input pitch (in cents relative to A4=440Hz=6900) to the nearest allowed note.
+     */
+    static quantize(inputCents: number, allowedPitchClasses: number[]): number;
+}
+//# sourceMappingURL=ScaleQuantizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScaleQuantizer.d.ts","sourceRoot":"","sources":["../../../src/tuning/ScaleQuantizer.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACvB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,GAAG,MAAM;CAuC7E"}

package/dist/src/tuning/ScaleQuantizer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleQuantizer = void 0;
+class ScaleQuantizer {
+    /**
+     * Quantizes an input pitch (in cents relative to A4=440Hz=6900) to the nearest allowed note.
+     */
+    static quantize(inputCents, allowedPitchClasses) {
+        // 1. Determine Octave and Semitone
+        // MIDI 0 = C-1 = 0 cents? No. A4=6900.
+        // C4 = 6000 cents.
+        // 1200 cents per octave.
+        // pitchClass = floor(cents / 100) % 12 ? No, cents are absolute.
+        // Let's align to MIDI numbers.
+        // midiVal = inputCents / 100.
+        const midiVal = inputCents / 100.0;
+        const noteIndex = Math.round(midiVal);
+        // Optimize: check if noteIndex is allowed
+        const pc = ((noteIndex % 12) + 12) % 12;
+        if (allowedPitchClasses.includes(pc)) {
+            return noteIndex * 100;
+        }
+        // Search nearest allowed
+        // Brute force is fast enough (12 classes max).
+        // Check neighbors up/down.
+        let bestDist = Infinity;
+        let bestCandidate = noteIndex;
+        // Check +/- 12 semitones is sufficient
+        for (let i = -6; i <= 6; i++) {
+            const candidate = noteIndex + i;
+            const cpc = ((candidate % 12) + 12) % 12;
+            if (allowedPitchClasses.includes(cpc)) {
+                const dist = Math.abs(candidate - midiVal);
+                if (dist < bestDist) {
+                    bestDist = dist;
+                    bestCandidate = candidate;
+                }
+            }
+        }
+        return bestCandidate * 100;
+    }
+}
+exports.ScaleQuantizer = ScaleQuantizer;

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

@@ -0,0 +1,43 @@
+import { ProsodyRuntimeStateV1 } from '../../../voice-engine-core/src/prosody/StreamingProsodyTypes';
+export declare class StreamingAutotuneEngine {
+    private state;
+    private config;
+    private preset;
+    private frameCount;
+    private eventScheduler;
+    private _reusableEventList;
+    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;
+    snapshot(): {
+        version: string;
+        state: ProsodyRuntimeStateV1;
+    };
+    restore(snapshot: any): void;
+    reset(): void;
+    private createInitialState;
+}
+//# sourceMappingURL=StreamingAutotuneEngine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingAutotuneEngine.d.ts","sourceRoot":"","sources":["../../../src/tuning/StreamingAutotuneEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAY,MAAM,8DAA8D,CAAC;AA4D/G,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,CAAsB;IAC5C,OAAO,CAAC,kBAAkB,CAAa;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;IAMrB,QAAQ,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,qBAAqB,CAAA;KAAE;IASzD,OAAO,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAqCnC,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,kBAAkB;CAqC7B"}

package/dist/src/tuning/StreamingAutotuneEngine.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingAutotuneEngine = void 0;
+const OnlineStats_1 = require("../../../voice-engine-core/src/prosody/OnlineStats");
+const version_1 = require("../version");
+class RingBufferScheduler {
+    buffer;
+    capacity;
+    head = 0;
+    count = 0;
+    constructor(capacity = 1024) {
+        this.capacity = capacity;
+        this.buffer = new Array(capacity);
+    }
+    enqueue(events) {
+        // Sort incoming batch to ensure local order
+        events.sort((a, b) => a.time - b.time);
+        for (const e of events) {
+            if (this.count === this.capacity) {
+                // Buffer full. Drop oldest (head) to make room.
+                this.head = (this.head + 1) % this.capacity;
+            }
+            else {
+                this.count++;
+            }
+            const tail = (this.head + this.count - 1) % this.capacity;
+            this.buffer[tail] = e;
+        }
+    }
+    pruneOldEvents(currentTime) {
+        while (this.count > 0) {
+            const e = this.buffer[this.head];
+            const end = e.endTime !== undefined ? e.endTime : (e.time + (e.duration || 10));
+            if (end < currentTime) {
+                this.buffer[this.head] = undefined;
+                this.head = (this.head + 1) % this.capacity;
+                this.count--;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    getActiveEvents(currentTime, outList) {
+        outList.length = 0;
+        for (let i = 0; i < this.count; i++) {
+            const idx = (this.head + i) % this.capacity;
+            const e = this.buffer[idx];
+            if (!e)
+                continue;
+            const end = e.endTime !== undefined ? e.endTime : (e.time + (e.duration || 10));
+            if (e.time <= currentTime && end >= currentTime) {
+                outList.push(e);
+            }
+        }
+    }
+}
+class StreamingAutotuneEngine {
+    state;
+    config;
+    preset;
+    frameCount = 0;
+    eventScheduler;
+    _reusableEventList = [];
+    allowedSet;
+    _lastOutputCents = 0;
+    _mockPitchHz = 0;
+    constructor(config, preset) {
+        this.config = config;
+        this.preset = preset;
+        this.state = this.createInitialState();
+        this.eventScheduler = new RingBufferScheduler();
+        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);
+            this.eventScheduler.getActiveEvents(frameIndex, this._reusableEventList);
+            let accentOffset = 0;
+            for (const event of this._reusableEventList) {
+                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;
+    }
+    snapshot() {
+        // Deep copy state to prevent mutation of the snapshot
+        const stateCopy = JSON.parse(JSON.stringify(this.state));
+        return {
+            version: version_1.PROSODY_API_VERSION,
+            state: stateCopy
+        };
+    }
+    restore(snapshot) {
+        if (!snapshot || typeof snapshot !== 'object') {
+            throw new Error('Invalid snapshot format');
+        }
+        const { version, state } = snapshot;
+        if (!version || typeof version !== 'string') {
+            throw new Error('Snapshot missing version');
+        }
+        const currentMajor = version_1.PROSODY_API_VERSION.split('.')[0];
+        const snapshotMajor = version.split('.')[0];
+        if (currentMajor !== snapshotMajor) {
+            throw new Error(`Incompatible snapshot version. Current: ${version_1.PROSODY_API_VERSION}, Snapshot: ${version}`);
+        }
+        if (!state) {
+            throw new Error('Snapshot missing state');
+        }
+        this.state = state;
+        // Rehydrate Float32Arrays if they were serialized to objects
+        if (this.state.decomposer && this.state.decomposer.buffer && !(this.state.decomposer.buffer instanceof Float32Array)) {
+            const buf = this.state.decomposer.buffer;
+            const len = Object.keys(buf).length;
+            const newBuf = new Float32Array(len);
+            for (let i = 0; i < len; i++) {
+                newBuf[i] = buf[i];
+            }
+            this.state.decomposer.buffer = newBuf;
+        }
+    }
+    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;