From 1d1438b6211728227a26615013587a7716ac8438 Mon Sep 17 00:00:00 2001
From: tachengP <2638591622@qq.com>
Date: Fri, 19 Jun 2026 18:37:45 +0800
Subject: [PATCH 1/3] =?UTF-8?q?=E9=85=8D=E5=90=88DiffSinger=20for=20TuneLa?=
 =?UTF-8?q?b=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 RepositoryTuneLab checkout effect             |   20 +
 TuneLab.SDK/ControllerConfigs/ButtonConfig.cs |   21 +
 TuneLab.SDK/Voice/IPartPropertyContext.cs     |    3 +
 .../Controllers/PropertyObjectController.cs   |   51 +
 .../PropertySideBarContentProvider.cs         |   15 +-
 .../DiffSingerParamExtract.csproj             |   60 +
 .../DiffSingerParamExtractSession.cs          | 1647 +++++++++++++++++
 .../DiffSingerParamVoiceEngine.cs             |  295 +++
 .../DiffSingerParamExtract/DiffSingerUtils.cs |  216 +++
 .../DiffSingerParamExtract/DsConfig.cs        |  104 ++
 .../DiffSingerParamExtract/DsModelSession.cs  |  986 ++++++++++
 .../DiffSingerParamExtract/G2pDictionary.cs   |  267 +++
 .../DiffSingerParamExtract/VarianceMapping.cs |  100 +
 .../DiffSingerParamExtract/description.json   |   10 +
 tests/tmpverify/verify.cs                     |    9 +
 tests/tmpverify/verify.csproj                 |    7 +
 16 files changed, 3809 insertions(+), 2 deletions(-)
 create mode 100644 RepositoryTuneLab checkout effect
 create mode 100644 TuneLab.SDK/ControllerConfigs/ButtonConfig.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/DiffSingerParamExtract.csproj
 create mode 100644 tests/plugins/DiffSingerParamExtract/DiffSingerParamExtractSession.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/DiffSingerParamVoiceEngine.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/DiffSingerUtils.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/DsConfig.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/DsModelSession.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/G2pDictionary.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/VarianceMapping.cs
 create mode 100644 tests/plugins/DiffSingerParamExtract/description.json
 create mode 100644 tests/tmpverify/verify.cs
 create mode 100644 tests/tmpverify/verify.csproj

diff --git a/RepositoryTuneLab checkout effect b/RepositoryTuneLab checkout effect
new file mode 100644
index 00000000..444e6994
--- /dev/null
+++ b/RepositoryTuneLab checkout effect	
@@ -0,0 +1,20 @@
+f2c6b51 (HEAD -> feature/agent, origin/release/2.0.0, origin/feature/agent, release/2.0.0) Merge branch 'feature/agent' into release/2.0.0
+23ce42a refactor: 收紧 agent 工具描述——pitch line 与 vibrato 加性叠加、勿断开音高线
+2bbf396 feat: agent 对话分步可见 + 流式实时 Markdown + 取消回复气泡
+f8e55db feat: agent 加 add_vibrato 工具（创建真正的 Vibrato 对象）
+8a72108 Revert "refactor: effect 收口改订 effect.Modified，退掉 SynthesisBatch band-aid"
+f7823b9 fix: OpenAI 兼容流式 tool_call 被后续空 id/name 帧覆盖而丢失
+c343b21 feat: agent 工具集三层扩充（只读 / 业务写 / 批量 DSL）
+1b4b209 fix: Agent 报错/停止文案可复制——提示行改用 SelectableTextBlock
+e64f983 feat: Agent 换模型保上下文 + 连接模型提示 + 标题加固 + 报错保留已输出
+0644c43 refactor: effect 收口改订 effect.Modified，退掉 SynthesisBatch band-aid
+2d5b708 refactor: ITiming 死契约从 TuneLab.SDK 下沉到宿主 TuneLab.Data.Timing
+08e3a84 docs: 订正 plugin-development 的 voice/effect 章节到当前 SDK 模型
+74cda39 feat: effect 收敛阶段三——回显富类型换形 + effect 回显端到端
+6962336 fix: Agent 短回复时 token 数与 Copy 挤在一起——token 文本加右边距
+3576611 refactor: Agent 设置页 provider 选择复用属性面板样式 + 改名 Model Provider
+909ced3 feat: Agent 撞工具回合上限时强制收尾——再请求一次不带工具让模型总结
+65cbdad fix: DataObject merge 通知上行——中间态不漏成祖先 settled、收口沿父链补发
+9a7b359 feat: effect 收敛阶段二——厚 IEffectProcessor/每段一个 + 反应式 EffectGraph
+e4e922d feat: Agent 会话菜单 UI 完善——✕ 对齐 + 全名 tooltip + 原生观感
+f4e9907 feat: 原子写文件工具 SaveFile（仿 QSaveFile）+ 应用到 agent 写入点
diff --git a/TuneLab.SDK/ControllerConfigs/ButtonConfig.cs b/TuneLab.SDK/ControllerConfigs/ButtonConfig.cs
new file mode 100644
index 00000000..57e2ab57
--- /dev/null
+++ b/TuneLab.SDK/ControllerConfigs/ButtonConfig.cs
@@ -0,0 +1,21 @@
+using System;
+
+namespace TuneLab.SDK;
+
+// 按钮控件配置：在属性面板中渲染一个可点击的按钮。
+// 与值控件不同，ButtonConfig 不绑定数据，而是通过 Action 回调触发行为。
+// 由宿主侧 PropertyObjectController 的 ButtonCreator 渲染为 GUI Components.Button。
+public sealed class ButtonConfig : IControllerConfig
+{
+    /// <summary>按钮显示文本（经 L.Tr 翻译）。</summary>
+    public required string DisplayText { get; init; }
+
+    /// <summary>点击时的回调（在 UI 线程触发）。</summary>
+    public required Action? Action { get; init; }
+
+    /// <summary>按钮激活状态（true=可点击；false=灰显禁用）。</summary>
+    public bool IsEnabled { get; init; } = true;
+
+    /// <summary>按钮提示文字（鼠标悬停时显示）。</summary>
+    public string? Tooltip { get; init; }
+}
diff --git a/TuneLab.SDK/Voice/IPartPropertyContext.cs b/TuneLab.SDK/Voice/IPartPropertyContext.cs
index fe083b33..cf7174d5 100644
--- a/TuneLab.SDK/Voice/IPartPropertyContext.cs
+++ b/TuneLab.SDK/Voice/IPartPropertyContext.cs
@@ -24,4 +24,7 @@ public interface IPartPropertyContext
 public interface INotePropertyContext : IPartPropertyContext
 {
     PropertyObject NoteProperties { get; }
+    // 当前选中音符的时间范围（用于区段式操作，NaN 表示无选中）
+    double SelectionStartTime { get; }
+    double SelectionEndTime { get; }
 }
diff --git a/TuneLab/GUI/Controllers/PropertyObjectController.cs b/TuneLab/GUI/Controllers/PropertyObjectController.cs
index e1a49927..814484fb 100644
--- a/TuneLab/GUI/Controllers/PropertyObjectController.cs
+++ b/TuneLab/GUI/Controllers/PropertyObjectController.cs
@@ -370,6 +370,56 @@ public override void Dispose()
         readonly Components.CheckBox mController;
     }
 
+    // 按钮控件：渲染为可点击的按钮，触发 ButtonConfig.Action（在 UI 线程）。不绑定数据。
+    class ButtonCreator : Creator
+    {
+        public ButtonCreator(PropertyObjectController parent, string key, ButtonConfig config) : base(parent)
+        {
+            var text = config.DisplayText ?? key;
+
+            mButton = ObjectPoolManager.Get<Components.Button>();
+            mButton.Height = 32;
+            mButton.Margin = new(24, 8, 24, 8);
+            mButton.AddContent(new()
+            {
+                Item = new BorderItem() { CornerRadius = 4 },
+                ColorSet = new() { Color = Style.BUTTON_NORMAL, HoveredColor = Style.BUTTON_NORMAL_HOVER, PressedColor = Style.INTERFACE },
+            });
+            mButton.AddContent(new()
+            {
+                Item = new TextItem() { Text = text, FontSize = 13 },
+                ColorSet = new() { Color = Style.WHITE },
+            });
+
+            mAction = config.Action;
+            mButton.Clicked += OnClicked;
+        }
+
+        void OnClicked()
+        {
+            mAction?.Invoke();
+        }
+
+        public override Type ConfigType => typeof(ButtonConfig);
+        public override IEnumerable<Control> Views => [mButton];
+
+        public override void Update(IControllerConfig config)
+        {
+            var btn = (ButtonConfig)config;
+            mAction = btn.Action;
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            mButton.Clicked -= OnClicked;
+            ObjectPoolManager.Return(mButton);
+        }
+
+        readonly Components.Button mButton;
+        Action? mAction;
+    }
+
     static Label CreateTitle(string title, double height)
     {
         var label = ObjectPoolManager.Get<Label>();
@@ -389,6 +439,7 @@ static Label CreateTitle(string title, double height)
         { typeof(TextBoxConfig), (parent, key, config) => new SingleLineTextCreator(parent, key, (TextBoxConfig)config) },
         { typeof(ComboBoxConfig), (parent, key, config) => new ComboBoxCreator(parent, key, (ComboBoxConfig)config) },
         { typeof(CheckBoxConfig), (parent, key, config) => new CheckBoxCreator(parent, key, (CheckBoxConfig)config) },
+        { typeof(ButtonConfig), (parent, key, config) => new ButtonCreator(parent, key, (ButtonConfig)config) },
     };
 
     IDataPropertyObject? mDataObject;
diff --git a/TuneLab/UI/MainWindow/Editor/SideBar/Properties/PropertySideBarContentProvider.cs b/TuneLab/UI/MainWindow/Editor/SideBar/Properties/PropertySideBarContentProvider.cs
index 82758708..f9950126 100644
--- a/TuneLab/UI/MainWindow/Editor/SideBar/Properties/PropertySideBarContentProvider.cs
+++ b/TuneLab/UI/MainWindow/Editor/SideBar/Properties/PropertySideBarContentProvider.cs
@@ -212,7 +212,16 @@ IPartPropertyContext BuildPartContext()
         => new PartPropertyContext(mPart!.Voice.ID, mPart!.Properties.GetInfo());
 
     INotePropertyContext BuildNoteContext()
-        => new NotePropertyContext(mPart!.Voice.ID, mPart!.Properties.GetInfo(), MergeNoteSnapshots());
+    {
+        var selNotes = mPart!.Notes.AllSelectedItems().ToList();
+        double selStart = double.NaN, selEnd = double.NaN;
+        if (selNotes.Count > 0)
+        {
+            selStart = selNotes.Min(n => n.StartTime);
+            selEnd = selNotes.Max(n => n.EndTime);
+        }
+        return new NotePropertyContext(mPart!.Voice.ID, mPart!.Properties.GetInfo(), MergeNoteSnapshots(), selStart, selEnd);
+    }
 
     // 当前选中 note 的三态合并快照：同 key 各 note 全等给该值、不等给 Multiple、全缺则不出现（稀疏）。
     PropertyObject MergeNoteSnapshots()
@@ -254,11 +263,13 @@ sealed class PartPropertyContext(string voiceId, PropertyObject partProperties)
         public PropertyObject PartProperties => partProperties;
     }
 
-    sealed class NotePropertyContext(string voiceId, PropertyObject partProperties, PropertyObject noteProperties) : INotePropertyContext
+    sealed class NotePropertyContext(string voiceId, PropertyObject partProperties, PropertyObject noteProperties, double selStart, double selEnd) : INotePropertyContext
     {
         public string VoiceId => voiceId;
         public PropertyObject PartProperties => partProperties;
         public PropertyObject NoteProperties => noteProperties;
+        public double SelectionStartTime => selStart;
+        public double SelectionEndTime => selEnd;
     }
 
     void OnConfigChnaged()
diff --git a/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtract.csproj b/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtract.csproj
new file mode 100644
index 00000000..1e864706
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtract.csproj
@@ -0,0 +1,60 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>DiffSinger</AssemblyName>
+    <RootNamespace>DiffSinger</RootNamespace>
+    <OutputPath>$(MSBuildThisFileDirectory)..\..\packages\DiffSinger\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\TuneLab.Foundation\TuneLab.Foundation.csproj" Private="false" />
+    <ProjectReference Include="..\..\..\TuneLab.SDK\TuneLab.SDK.csproj" Private="false" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.ML.OnnxRuntime" Version="1.21.0" GeneratePathProperty="true" />
+    <PackageReference Include="Microsoft.ML.OnnxRuntime.Extensions" Version="0.13.0" />
+    <PackageReference Include="Microsoft.ML.OnnxRuntime.DirectML" Version="1.21.0" />
+    <PackageReference Include="YamlDotNet" Version="16.3.0" />
+    <PackageReference Include="K4os.Hash.xxHash" Version="1.0.8" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="description.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <!-- Copy NuGet dependency DLLs to the output package directory -->
+  <Target Name="CopyDeps" AfterTargets="Build">
+    <ItemGroup>
+      <_DepsFiles Include="$(TargetDir)publish\*" Condition="Exists('$(TargetDir)publish')" />
+      <_DepsFiles Include="$(TargetDir)YamlDotNet.dll" />
+      <_DepsFiles Include="$(TargetDir)K4os.Hash.xxHash.dll" />
+      <_DepsFiles Include="$(TargetDir)Microsoft.ML.OnnxRuntime.dll" />
+      <_DepsFiles Include="$(TargetDir)Microsoft.ML.OnnxRuntime.Managed.dll" />
+      <_DepsFiles Include="$(TargetDir)onnxruntime.*.dll" />
+      <_DepsFiles Include="$(TargetDir)runtimes\**\*.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(_DepsFiles)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(_DepsFiles->'%(RootDir)%(Directory)%(FileName)%(Extension)')" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" />
+  </Target>
+
+  <!-- Fallback: copy from NuGet cache -->
+  <Target Name="CopyNuGetDlls" AfterTargets="Build" Condition="'$(CopyDepsDisabled)' != 'true'">
+    <PropertyGroup>
+      <_NuGetRoot>$(NuGetPackageRoot)</_NuGetRoot>
+    </PropertyGroup>
+    <ItemGroup>
+      <_NuGetCopy Include="$(_NuGetRoot)\YamlDotNet\16.3.0\lib\net8.0\YamlDotNet.dll" />
+      <_NuGetCopy Include="$(_NuGetRoot)\K4os.Hash.xxHash\1.0.8\lib\net6.0\K4os.Hash.xxHash.dll" />
+      <_NuGetCopy Include="$(_NuGetRoot)\microsoft.ml.onnxruntime\1.21.0\lib\netstandard2.0\Microsoft.ML.OnnxRuntime.dll" />
+      <_NuGetCopy Include="$(_NuGetRoot)\microsoft.ml.onnxruntime.managed\1.21.0\lib\netstandard2.0\Microsoft.ML.OnnxRuntime.Managed.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(_NuGetCopy)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" Condition="Exists('%(Identity)')" />
+  </Target>
+
+</Project>
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtractSession.cs b/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtractSession.cs
new file mode 100644
index 00000000..b51c847c
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DiffSingerParamExtractSession.cs
@@ -0,0 +1,1647 @@
+using TuneLab.Foundation;
+using TuneLab.SDK;
+
+namespace DiffSinger;
+
+/// <summary>
+/// Internal data produced by one Piece (segment) of synthesis.
+/// </summary>
+internal class SynthesizedParams
+{
+    public float[]? PitchCurve { get; init; }
+    public double[] FrameTimes { get; init; } = Array.Empty<double>();
+    public List<SynthesizedPhoneme> Phonemes { get; init; } = new();
+    public Dictionary<string, List<Point>> ParameterCurves { get; init; } = new();
+    public Dictionary<string, List<Point>> MappedParameterCurves { get; init; } = new();
+}
+
+/// <summary>
+/// A segment (piece) of the synthesis timeline that can be independently synthesized.
+/// </summary>
+internal class Piece
+{
+    public List<ILiveNote> Notes { get; set; } = new();
+    public double StartTime { get; set; }
+    public double EndTime { get; set; }
+    public bool Dirty { get; set; } = true;
+    public bool Synthesizing { get; set; }
+    public bool Failed { get; set; }
+    public string? Error { get; set; }
+    public SynthesizedParams? SynthesizedParams { get; set; }
+}
+
+/// <summary>
+/// DiffSinger voice engine session.
+///
+/// Features:
+/// 1. Loads dsdur, dspitch, dsvariance model directories
+/// 2. G2P conversion of lyrics via DiffSinger dictionary (language-specific)
+/// 3. Runs linguistic + duration model for phoneme timing
+/// 4. Runs pitch model for F0 curve
+/// 5. Runs variance model for energy/breathiness/voicing/tension curves
+/// 6. Optional acoustic model + vocoder for full audio synthesis
+/// 7. User-configurable variance parameter → target engine parameter mapping
+/// 8. Expressiveness, blend, steps, and device controls
+/// 9. Phoneme mismatch handling (discard or error)
+/// 10. Smart phoneme alignment: merges multiple DS vowels/consonants when target has only 1
+/// 11. Auto-scan voicebanks from configured singers directories
+/// 12. Model path persistence to user config
+/// </summary>
+public sealed class DiffSingerSession : ISynthesisSession
+{
+    public string DefaultLyric => "la";
+
+    // Model session
+    private readonly DsModelSession _dsSession = new();
+    private readonly PluginConfig _config = new();
+
+    // State
+    private readonly List<Piece> _pieces = new();
+    private bool _needResegment = true;
+
+    // Context & subscriptions
+    private readonly ISynthesisContext _context;
+    private readonly IDisposable _notesSubscription;
+    private readonly Dictionary<ILiveNote, Action> _noteHandlers = new();
+
+    // Config persistence
+    private static readonly string ConfigFilePath =
+        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "TuneLab", "DiffSinger", "config.json");
+
+    // Track all available context automations for target parameter selection
+    private IReadOnlyList<string> _targetAutomationKeys = Array.Empty<string>();
+
+    public DiffSingerSession(ISynthesisContext context)
+    {
+        _context = context;
+
+        LoadConfig();
+
+        _notesSubscription = TuneLab.Foundation.NotifiableExtensions.WhenAny(
+            context.Notes, SubscribeNote, UnsubscribeNote);
+        context.Notes.ItemAdded += OnNotesStructureChanged;
+        context.Notes.ItemRemoved += OnNotesStructureChanged;
+        context.PartProperties.Modified += MarkAllDirty;
+        context.Committed += OnCommitted;
+        context.Pitch.RangeModified += OnRangeModified;
+        context.PitchDeviation.RangeModified += OnRangeModified;
+
+        _needResegment = true;
+    }
+
+    /// <summary>
+    /// Auto-configure model paths from a detected singer.
+    /// Called by the engine when user selects a scanned voicebank.
+    /// </summary>
+    public void AutoConfigureFromSinger(SingerDetectionInfo singer)
+    {
+        _config.SingerRootPath = singer.RootPath;
+        _config.DurModelPath = singer.DurPath ?? string.Empty;
+        _config.PitchModelPath = singer.PitchPath ?? string.Empty;
+        _config.VarianceModelPath = singer.VariancePath ?? string.Empty;
+        if (singer.Languages.Count > 0 && _config.Language == "default")
+            _config.Language = singer.Languages[0];
+        SaveConfig();
+    }
+
+    // ================================================================
+    //  Config Persistence
+    // ================================================================
+
+    private void LoadConfig()
+    {
+        try
+        {
+            if (File.Exists(ConfigFilePath))
+            {
+                var json = File.ReadAllText(ConfigFilePath);
+                var loaded = System.Text.Json.JsonSerializer.Deserialize<PluginConfig>(json);
+                if (loaded != null)
+                {
+                    _config.DurModelPath = loaded.DurModelPath;
+                    _config.PitchModelPath = loaded.PitchModelPath;
+                    _config.VarianceModelPath = loaded.VarianceModelPath;
+                    _config.SingerRootPath = loaded.SingerRootPath;
+                    _config.Language = loaded.Language;
+                    _config.Device = loaded.Device;
+                    _config.GpuIndex = loaded.GpuIndex;
+                    _config.DurSteps = loaded.DurSteps;
+                    _config.AcousticSteps = loaded.AcousticSteps;
+                    _config.PitchSteps = loaded.PitchSteps;
+                    _config.VarianceSteps = loaded.VarianceSteps;
+                    _config.DiffusionDepth = loaded.DiffusionDepth;
+                    _config.Expressiveness = loaded.Expressiveness;
+                    _config.BlendPercent = loaded.BlendPercent;
+                    _config.TensorCache = loaded.TensorCache;
+                    _config.VarianceLocalPitchPatch = loaded.VarianceLocalPitchPatch;
+                    _config.UnvoicedF0Interpolate = loaded.UnvoicedF0Interpolate;
+                    _config.DiscardOnMismatch = loaded.DiscardOnMismatch;
+                    _config.Mode = loaded.Mode;
+                    _config.VarianceMappings = loaded.VarianceMappings ?? new();
+                }
+            }
+        }
+        catch { /* use defaults */ }
+    }
+
+    private void SaveConfig()
+    {
+        try
+        {
+            var dir = Path.GetDirectoryName(ConfigFilePath);
+            if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
+            var json = System.Text.Json.JsonSerializer.Serialize(_config, new System.Text.Json.JsonSerializerOptions { WriteIndented = true });
+            File.WriteAllText(ConfigFilePath, json);
+        }
+        catch { /* silent fail */ }
+    }
+
+    // ================================================================
+    //  Part / Note Property Configs (UI)
+    // ================================================================
+
+    public ObjectConfig GetPartPropertyConfig(IPartPropertyContext context)
+    {
+        var properties = new OrderedMap<string, IControllerConfig>();
+
+        // ================================================================
+        //  Section: Singers Directory (global scan path)
+        // ================================================================
+        properties.Add("__singers_header", new TextBoxConfig
+        {
+            DefaultValue = "── Singer Discovery ──",
+            DisplayText = "Singer Discovery"
+        });
+
+        string currentSingersDir = DiffSingerEngine.LoadSingersDirectory();
+        properties.Add("singers_directory", new TextBoxConfig
+        {
+            DefaultValue = currentSingersDir,
+            DisplayText = "Singers Directory (restart to scan)"
+        });
+
+        // ================================================================
+        //  Section: Model Paths (persisted between sessions)
+        // ================================================================
+        properties.Add("__model_paths_header", new TextBoxConfig
+        {
+            DefaultValue = "── Model Paths ──",
+            DisplayText = "DiffSinger Model Directories"
+        });
+
+        properties.Add("dur_model_path", new TextBoxConfig
+        {
+            DefaultValue = _config.DurModelPath,
+            DisplayText = "dsdur Model Directory"
+        });
+        properties.Add("pitch_model_path", new TextBoxConfig
+        {
+            DefaultValue = _config.PitchModelPath,
+            DisplayText = "dspitch Model Directory"
+        });
+        properties.Add("variance_model_path", new TextBoxConfig
+        {
+            DefaultValue = _config.VarianceModelPath,
+            DisplayText = "dsvariance Model Directory"
+        });
+        properties.Add("singer_root_path", new TextBoxConfig
+        {
+            DefaultValue = _config.SingerRootPath,
+            DisplayText = "Singer Root (acoustic+vocoder)"
+        });
+
+        // ================================================================
+        //  Section: Language Selection
+        // ================================================================
+        var languages = _dsSession.IsDurLoaded ? _dsSession.GetAvailableLanguages() : Array.Empty<string>();
+        if (languages.Length == 0) languages = new[] { "default" };
+        properties.Add("language", new ComboBoxConfig
+        {
+            DefaultOption = new ComboBoxOption(_config.Language),
+            Options = languages.Select(l => new ComboBoxOption(l)).ToList(),
+            DisplayText = "Language (for G2P)"
+        });
+
+        // ================================================================
+        //  Section: Render Settings
+        // ================================================================
+        properties.Add("__render_header", new TextBoxConfig
+        {
+            DefaultValue = "── Render Settings ──",
+            DisplayText = "Render Settings"
+        });
+
+        // --- Device Selection ---
+        properties.Add("exec_device", new ComboBoxConfig
+        {
+            DefaultOption = new ComboBoxOption(_config.Device == ExecutionDevice.DirectML ? "DirectML" : "CPU"),
+            Options = new List<ComboBoxOption>
+            {
+                new("CPU"),
+                new("DirectML")
+            },
+            DisplayText = "Execution Device"
+        });
+
+        // --- GPU Index (for DirectML multi-GPU) ---
+        properties.Add("gpu_index", new SliderConfig
+        {
+            DefaultValue = _config.GpuIndex,
+            MinValue = 0,
+            MaxValue = 8,
+            DisplayText = "GPU Device Index"
+        });
+
+        // ================================================================
+        //  Section: Sampling Steps (mirrors OpenUtau DiffSingerSteps*)
+        // ================================================================
+        properties.Add("__steps_header", new TextBoxConfig
+        {
+            DefaultValue = "── Sampling Steps ──",
+            DisplayText = "Sampling Steps"
+        });
+
+        // --- Dur Steps ---
+        properties.Add("dur_steps", new SliderConfig
+        {
+            DefaultValue = _config.DurSteps,
+            MinValue = 1,
+            MaxValue = 100,
+            DisplayText = "Dur Steps"
+        });
+
+        // --- Acoustic Steps (DiffSingerSteps) ---
+        properties.Add("acoustic_steps", new SliderConfig
+        {
+            DefaultValue = _config.AcousticSteps,
+            MinValue = 1,
+            MaxValue = 100,
+            DisplayText = "Acoustic Steps"
+        });
+
+        // --- Pitch Steps (DiffSingerStepsPitch) ---
+        properties.Add("pitch_steps", new SliderConfig
+        {
+            DefaultValue = _config.PitchSteps,
+            MinValue = 1,
+            MaxValue = 100,
+            DisplayText = "Pitch Steps"
+        });
+
+        // --- Variance Steps (DiffSingerStepsVariance) ---
+        properties.Add("variance_steps", new SliderConfig
+        {
+            DefaultValue = _config.VarianceSteps,
+            MinValue = 1,
+            MaxValue = 100,
+            DisplayText = "Variance Steps"
+        });
+
+        // --- Diffusion Depth (DiffSingerDepth) ---
+        properties.Add("diffusion_depth", new SliderConfig
+        {
+            DefaultValue = _config.DiffusionDepth,
+            MinValue = 0.01,
+            MaxValue = 1.0,
+            DisplayText = "Diffusion Depth"
+        });
+
+        // ================================================================
+        //  Section: Performance Sliders
+        // ================================================================
+        properties.Add("__perf_header", new TextBoxConfig
+        {
+            DefaultValue = "── Performance ──",
+            DisplayText = "Performance"
+        });
+
+        // --- Expressiveness ---
+        properties.Add("expressiveness", new SliderConfig
+        {
+            DefaultValue = _config.Expressiveness,
+            MinValue = 0,
+            MaxValue = 200,
+            DisplayText = "Expressiveness (%)"
+        });
+
+        // --- Blend ---
+        properties.Add("blend", new SliderConfig
+        {
+            DefaultValue = _config.BlendPercent,
+            MinValue = 0,
+            MaxValue = 100,
+            DisplayText = "Blend (%)"
+        });
+
+        // ================================================================
+        //  Section: Advanced (mirrors OpenUtau DiffSinger flags)
+        // ================================================================
+        properties.Add("__advanced_header", new TextBoxConfig
+        {
+            DefaultValue = "── Advanced ──",
+            DisplayText = "Advanced"
+        });
+
+        // --- Tensor Cache ---
+        properties.Add("tensor_cache", new CheckBoxConfig
+        {
+            DefaultValue = _config.TensorCache,
+            DisplayText = "Tensor Cache"
+        });
+
+        // --- Variance Local Pitch Patch ---
+        properties.Add("variance_patch", new CheckBoxConfig
+        {
+            DefaultValue = _config.VarianceLocalPitchPatch,
+            DisplayText = "Variance Local Pitch Patch"
+        });
+
+        // --- Unvoiced F0 Interpolate ---
+        properties.Add("unvoiced_f0", new CheckBoxConfig
+        {
+            DefaultValue = _config.UnvoicedF0Interpolate,
+            DisplayText = "Unvoiced F0 Interpolate"
+        });
+
+        // --- Phoneme Mismatch ---
+        properties.Add("discard_mismatch", new CheckBoxConfig
+        {
+            DefaultValue = _config.DiscardOnMismatch,
+            DisplayText = "Discard on phoneme mismatch"
+        });
+
+        // --- Apply Mode ---
+        properties.Add("apply_mode", new ComboBoxConfig
+        {
+            DefaultOption = new ComboBoxOption(_config.Mode == ApplyMode.SelectedNotes ? "Selected Notes" : "Whole Track"),
+            Options = new[] { new ComboBoxOption("Selected Notes"), new ComboBoxOption("Whole Track") },
+            DisplayText = "Apply Mode"
+        });
+
+        // ================================================================
+        //  Section: Variance Parameter Mappings
+        // ================================================================
+        var availableVarianceParams = _dsSession.IsVarianceLoaded
+            ? _dsSession.AvailableVarianceParams.ToList()
+            : VarianceParamTypes.All.ToList();
+
+        RefreshTargetAutomationKeys();
+
+        properties.Add("__variance_header", new TextBoxConfig
+        {
+            DefaultValue = "── Variance Mappings ──",
+            DisplayText = "Variance Parameter Mappings"
+        });
+
+        for (int i = 0; i < 6; i++)
+        {
+            string idx = i.ToString();
+            var existingMapping = i < _config.VarianceMappings.Count ? _config.VarianceMappings[i] : null;
+
+            string sourceDefault = existingMapping?.SourceParam ?? "";
+            string targetDefault = existingMapping?.TargetParam ?? "";
+
+            var sourceOptions = new List<ComboBoxOption> { new("") };
+            sourceOptions.AddRange(availableVarianceParams.Select(p => new ComboBoxOption(p)));
+
+            var targetOptions = new List<ComboBoxOption> { new("") };
+            targetOptions.AddRange(_targetAutomationKeys.Select(k => new ComboBoxOption(k)));
+
+            properties.Add($"variance_map_{idx}_source", new ComboBoxConfig
+            {
+                DefaultOption = new ComboBoxOption(sourceDefault),
+                Options = sourceOptions,
+                DisplayText = $"Map {i + 1}: DS Param (source)"
+            });
+
+            properties.Add($"variance_map_{idx}_target", new ComboBoxConfig
+            {
+                DefaultOption = new ComboBoxOption(targetDefault),
+                Options = targetOptions,
+                DisplayText = $"Map {i + 1}: → Target Param"
+            });
+        }
+
+        return new ObjectConfig { Properties = properties };
+    }
+
+    public ObjectConfig GetNotePropertyConfig(INotePropertyContext context)
+    {
+        return new ObjectConfig { Properties = new OrderedMap<string, IControllerConfig>() };
+    }
+
+    // ================================================================
+    //  Automation Configs
+    // ================================================================
+
+    public IReadOnlyOrderedMap<string, AutomationConfig> GetAutomationConfigs(IPartPropertyContext context)
+    {
+        return new OrderedMap<string, AutomationConfig>();
+    }
+
+    public IReadOnlyOrderedMap<string, AutomationConfig> GetSynthesizedParameterConfigs(IPartPropertyContext context)
+    {
+        var configs = new OrderedMap<string, AutomationConfig>();
+
+        // Always declare the DS variance parameters (pre-declared, visible before rendering)
+        var availableParams = _dsSession.IsVarianceLoaded
+            ? _dsSession.AvailableVarianceParams
+            : VarianceParamTypes.All.ToArray();
+
+        foreach (var param in availableParams)
+        {
+            if (VarianceDisplayConfigs.TryGetValue(param, out var cfg))
+                configs.Add($"ds_{param}", cfg);
+            else
+                configs.Add($"ds_{param}", new AutomationConfig
+                {
+                    DisplayText = $"DS {param}",
+                    DefaultValue = double.NaN,
+                    MinValue = -96,
+                    MaxValue = 0,
+                    Color = "#888888"
+                });
+        }
+
+        // Always declare mapped parameter slots (even before models are loaded)
+        foreach (var mapping in _config.VarianceMappings)
+        {
+            if (!string.IsNullOrEmpty(mapping.TargetParam) &&
+                !configs.ContainsKey($"mapped_{mapping.TargetParam}"))
+            {
+                configs.Add($"mapped_{mapping.TargetParam}", new AutomationConfig
+                {
+                    DisplayText = $"[DS→{mapping.TargetParam}]",
+                    DefaultValue = double.NaN,
+                    MinValue = -96,
+                    MaxValue = 0,
+                    Color = "#FFAA44"
+                });
+            }
+        }
+
+        return configs;
+    }
+
+    private static readonly Dictionary<string, AutomationConfig> VarianceDisplayConfigs = new()
+    {
+        ["energy"] = new AutomationConfig
+        {
+            DisplayText = "DS Energy",
+            DefaultValue = double.NaN,
+            MinValue = -96, MaxValue = 0,
+            Color = "#E5A573"
+        },
+        ["breathiness"] = new AutomationConfig
+        {
+            DisplayText = "DS Breathiness",
+            DefaultValue = double.NaN,
+            MinValue = -96, MaxValue = 0,
+            Color = "#73C2E5"
+        },
+        ["voicing"] = new AutomationConfig
+        {
+            DisplayText = "DS Voicing",
+            DefaultValue = double.NaN,
+            MinValue = -96, MaxValue = 0,
+            Color = "#E573B0"
+        },
+        ["tension"] = new AutomationConfig
+        {
+            DisplayText = "DS Tension",
+            DefaultValue = double.NaN,
+            MinValue = -10, MaxValue = 10,
+            Color = "#73E5A5"
+        },
+    };
+
+    // ================================================================
+    //  Synthesis Pipeline
+    // ================================================================
+
+    public SynthesisSegment? GetNextSegment(double startTime, double endTime)
+    {
+        if (_needResegment) Resegment();
+
+        foreach (var piece in _pieces)
+        {
+            if (!piece.Dirty || piece.Synthesizing)
+                continue;
+            if (piece.EndTime < startTime || piece.StartTime > endTime)
+                continue;
+            return new SynthesisSegment(piece.StartTime, piece.EndTime);
+        }
+        return null;
+    }
+
+    public async Task SynthesizeNext(SynthesisSegment segment, CancellationToken cancellation = default)
+    {
+        var piece = _pieces.FirstOrDefault(p =>
+            p.StartTime == segment.StartTime && p.EndTime == segment.EndTime);
+        if (piece == null || !piece.Dirty)
+            return;
+
+        UpdateConfigFromContext();
+
+        var snapshot = _context.GetSnapshot(
+            piece.Notes,
+            piece.Notes[0].StartTime.Value,
+            piece.Notes[^1].EndTime.Value);
+
+        piece.Dirty = false;
+        piece.Synthesizing = true;
+        StatusChanged?.Invoke();
+
+        try
+        {
+            SynthesizedParams? result = null;
+            float[]? audioSamples = null;
+            int audioSampleRate = 44100;
+
+            await Task.Run(() =>
+            {
+                result = ExtractParameters(snapshot, piece.Notes, _config, cancellation);
+
+                // If acoustic model + vocoder are loaded, synthesize audio
+                if (result != null && _dsSession.IsAcousticLoaded && _dsSession.IsVocoderLoaded)
+                {
+                    audioSamples = RenderAudio(result, _config, cancellation);
+                    var vc = _dsSession.VocoderConfig;
+                    if (vc != null) audioSampleRate = vc.sample_rate;
+                }
+            }, CancellationToken.None);
+
+            if (result != null)
+            {
+                piece.SynthesizedParams = result;
+                if (audioSamples != null && audioSamples.Length > 0)
+                {
+                    long sampleOffset = (long)(segment.StartTime * audioSampleRate);
+                    var seg = _context.CreateAudioSegment(sampleOffset, audioSamples.Length, audioSampleRate);
+                    seg.Write(0, audioSamples);
+                    seg.Commit();
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            piece.Failed = true;
+            piece.Error = ex.Message;
+        }
+        finally
+        {
+            piece.Synthesizing = false;
+            StatusChanged?.Invoke();
+        }
+    }
+
+    // ================================================================
+    //  Core Parameter Extraction
+    // ================================================================
+
+    /// <summary>
+    /// Render audio from extracted DS parameters using acoustic model + vocoder.
+    /// </summary>
+    private float[]? RenderAudio(SynthesizedParams dsParams, PluginConfig config, CancellationToken cancellation)
+    {
+        if (dsParams.Phonemes.Count == 0 || dsParams.PitchCurve == null) return null;
+
+        var frameMs = _dsSession.GetFrameMs();
+        var durationsFrames = new List<int>();
+        foreach (var ph in dsParams.Phonemes)
+        {
+            int frames = Math.Max(1, (int)((ph.EndTime - ph.StartTime) * 1000.0 / frameMs));
+            durationsFrames.Add(frames);
+        }
+        int totalFrames = durationsFrames.Sum();
+        if (totalFrames == 0) return null;
+
+        var phonemeSymbols = dsParams.Phonemes.Select(p => p.Symbol).ToArray();
+        double startTime = dsParams.Phonemes[0].StartTime;
+
+        // F0 in Hz
+        var f0Hz = new float[totalFrames];
+        for (int f = 0; f < Math.Min(totalFrames, dsParams.PitchCurve.Length); f++)
+            f0Hz[f] = (float)DsModelSession.ToneToFreq(dsParams.PitchCurve[f] * 0.01 + 69);
+
+        // Variance params
+        Dictionary<string, float[]>? varianceParams = null;
+        if (dsParams.ParameterCurves.Count > 0)
+        {
+            varianceParams = new Dictionary<string, float[]>();
+            foreach (var (name, points) in dsParams.ParameterCurves)
+            {
+                if (points.Count == 0) continue;
+                var curve = new float[totalFrames];
+                for (int f = 0; f < totalFrames; f++)
+                {
+                    double t = startTime + f * frameMs / 1000.0;
+                    curve[f] = (float)points.OrderBy(p => Math.Abs(p.X - t)).First().Y;
+                }
+                varianceParams[name] = curve;
+            }
+        }
+
+        float depth = Math.Clamp((float)config.DiffusionDepth, 0.01f, 1f);
+        var mel = _dsSession.PredictAcoustic(
+            phonemeSymbols, durationsFrames.ToArray(), f0Hz,
+            totalFrames, config.AcousticSteps, depth, varianceParams);
+
+        if (cancellation.IsCancellationRequested) return null;
+
+        return _dsSession.PredictVocoder(mel, f0Hz);
+    }
+
+    private SynthesizedParams? ExtractParameters(
+        SynthesisSnapshot snapshot,
+        IReadOnlyList<ILiveNote> origins,
+        PluginConfig config,
+        CancellationToken cancellation)
+    {
+        if (snapshot.Notes.Count == 0) return null;
+
+        // ---- Step 1: Determine which notes to process ----
+        IReadOnlyList<SynthesisNoteSnapshot> notes;
+        if (config.Mode == ApplyMode.SelectedNotes)
+        {
+            var noteList = new List<SynthesisNoteSnapshot>(origins.Count);
+            foreach (var o in origins)
+            {
+                var phonemeList = o.Phonemes.Value;
+                noteList.Add(new SynthesisNoteSnapshot
+                {
+                    StartTime = o.StartTime.Value,
+                    EndTime = o.EndTime.Value,
+                    Pitch = o.Pitch.Value,
+                    Lyric = o.Lyric.Value,
+                Phonemes = phonemeList.Select(p => new PinnedPhoneme { Symbol = p.Symbol, StartTime = p.StartTime, EndTime = p.EndTime }).ToArray(),
+                    Properties = PropertyObject.Empty
+                });
+            }
+            notes = noteList;
+        }
+        else
+        {
+            notes = snapshot.Notes.ToArray();
+        }
+
+        if (notes.Count == 0) return null;
+
+        // ---- Step 2: Ensure models are loaded ----
+        EnsureModelsLoaded(config);
+
+        // ---- Step 3: G2P conversion ----
+        var lyricToPhonemes = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
+        var allPhonemes = new List<string>();
+        var midiTones = new List<int>();
+        var noteEndTimesMs = new List<double>();
+        var phonemeToNoteMap = new List<int>();
+
+        double startTime = notes[0].StartTime;
+        double endTime = notes.Max(n => n.EndTime);
+
+        foreach (var note in notes)
+        {
+            if (cancellation.IsCancellationRequested) return null;
+
+            string lyric = string.IsNullOrEmpty(note.Lyric) ? DefaultLyric : note.Lyric;
+
+            if (lyric == "R" || lyric == "r")
+            {
+                lyricToPhonemes[lyric] = new[] { "SP" };
+                allPhonemes.Add("SP");
+                midiTones.Add(notes[^1].Pitch);
+                noteEndTimesMs.Add(notes[^1].EndTime * 1000.0);
+                phonemeToNoteMap.Add(phonemeToNoteMap.Count);
+                continue;
+            }
+
+            string[]? phonemes;
+            if (!lyricToPhonemes.TryGetValue(lyric, out phonemes))
+            {
+                if (_dsSession.G2p != null)
+                {
+                    phonemes = _dsSession.G2p.Query(lyric);
+                }
+                else
+                {
+                    phonemes = null;
+                }
+
+                if (phonemes is null or { Length: 0 })
+                {
+                    phonemes = new[] { lyric };
+                }
+                lyricToPhonemes[lyric] = phonemes;
+            }
+
+            allPhonemes.AddRange(phonemes);
+            int nPitch = note.Pitch;
+            double nEndMs = note.EndTime * 1000.0;
+            foreach (var _ in phonemes)
+            {
+                midiTones.Add(nPitch);
+                noteEndTimesMs.Add(nEndMs);
+                phonemeToNoteMap.Add(phonemeToNoteMap.Count);
+            }
+        }
+
+        if (allPhonemes.Count == 0) return null;
+
+        // ---- Step 4: Run dur model ----
+        double frameMs = _dsSession.GetFrameMs();
+        var durResult = _dsSession.PredictDuration(
+            allPhonemes.ToArray(),
+            midiTones.ToArray(),
+            noteEndTimesMs.ToArray(),
+            startTime * 1000.0,
+            frameMs,
+            steps: config.DurSteps);
+
+        // ---- Step 5: Smart phoneme alignment (per-note vowel/consonant alignment) ----
+        // Collect per-note G2P results for alignment
+        var noteG2pResults = new List<(string lyric, string[] dsPhonemes)>();
+        foreach (var note in notes)
+        {
+            string lyric = string.IsNullOrEmpty(note.Lyric) ? DefaultLyric : note.Lyric;
+            var phonemes = lyricToPhonemes.GetValueOrDefault(lyric, new[] { lyric });
+            noteG2pResults.Add((lyric, phonemes));
+        }
+
+        var alignmentResult = SmartAlignPhonemeDurations(
+            durResult,
+            noteG2pResults,
+            notes,
+            config.DiscardOnMismatch,
+            frameMs);
+
+        durResult = alignmentResult.AlignedDurResult;
+        var alignedMidiTones = alignmentResult.AlignedMidiTones;
+        var alignedPhonemeToNoteMap = alignmentResult.AlignedPhonemeToNoteMap;
+        allPhonemes = alignmentResult.AlignedPhonemes;
+
+        // ---- Step 6: Build phoneme timings ----
+        int nPhonemes = durResult.PhonemeSymbols.Length;
+        var phonemeStartTimes = new List<double>();
+        double currentTime = startTime * 1000.0;
+        foreach (var d in durResult.DurationsMs)
+        {
+            phonemeStartTimes.Add(currentTime / 1000.0);
+            currentTime += d;
+        }
+
+        var durationsFrames = durResult.DurationsFrames;
+        int totalFrames = durResult.TotalFrames;
+
+        // ---- Step 7: Read existing automation curves for blend ----
+        var existingCurves = new Dictionary<string, float[]>();
+        foreach (var mapping in config.VarianceMappings)
+        {
+            if (string.IsNullOrEmpty(mapping.TargetParam)) continue;
+            var curve = SampleExistingCurve(mapping.TargetParam, startTime, endTime, totalFrames, frameMs);
+            if (curve != null)
+                existingCurves[mapping.TargetParam] = curve;
+        }
+
+        // ---- Step 8: Run pitch model ----
+        float[]? pitchCurve = null;
+        if (_dsSession.IsPitchLoaded)
+        {
+            pitchCurve = _dsSession.PredictPitch(
+                durResult.PhonemeSymbols,
+                alignedMidiTones.ToArray(),
+                durationsFrames,
+                totalFrames,
+                frameMs,
+                config.Expressiveness,
+                startTime * 1000.0,
+                steps: config.PitchSteps);
+        }
+
+        // ---- Step 9: Run variance model ----
+        Dictionary<string, float[]>? varianceCurves = null;
+        if (_dsSession.IsVarianceLoaded)
+        {
+            varianceCurves = _dsSession.PredictVariance(
+                durResult.PhonemeSymbols,
+                alignedMidiTones.ToArray(),
+                durationsFrames,
+                totalFrames,
+                frameMs,
+                config.Expressiveness,
+                pitchCurve,
+                steps: config.VarianceSteps);
+        }
+
+        // ---- Step 10: Build frame time array ----
+        var frameTimes = new double[totalFrames];
+        for (int f = 0; f < totalFrames; f++)
+        {
+            frameTimes[f] = startTime + f * frameMs / 1000.0;
+        }
+
+        // ---- Step 11: Build synthesized parameter curves ----
+        var result = new SynthesizedParams
+        {
+            PitchCurve = pitchCurve,
+            FrameTimes = frameTimes,
+        };
+
+        if (varianceCurves != null)
+        {
+            float bf = config.BlendFactor;
+
+            foreach (var (paramName, curveData) in varianceCurves)
+            {
+                if (!_dsSession.AvailableVarianceParams.Contains(paramName))
+                    continue;
+
+                var points = new List<Point>();
+                for (int f = 0; f < Math.Min(curveData.Length, totalFrames); f++)
+                {
+                    float value = curveData[f];
+                    float existingValue = 0f;
+                    var existingParam = config.VarianceMappings
+                        .FirstOrDefault(m => m.SourceParam == paramName);
+                    if (existingParam != null && existingCurves.TryGetValue(existingParam.TargetParam, out var existingArr))
+                    {
+                        if (f < existingArr.Length)
+                            existingValue = existingArr[f];
+                    }
+
+                    float finalValue = value * bf + existingValue * (1f - bf);
+                    double displayValue = NormalizeVarianceParam(paramName, finalValue);
+                    points.Add(new Point(frameTimes[f], displayValue));
+                }
+                result.ParameterCurves[paramName] = points;
+            }
+
+            foreach (var mapping in config.VarianceMappings)
+            {
+                if (string.IsNullOrEmpty(mapping.SourceParam) || string.IsNullOrEmpty(mapping.TargetParam))
+                    continue;
+
+                if (!varianceCurves.TryGetValue(mapping.SourceParam, out var sourceData))
+                    continue;
+
+                existingCurves.TryGetValue(mapping.TargetParam, out var existingTargetCurve);
+
+                float bf2 = config.BlendFactor;
+                var mappedPoints = new List<Point>();
+                for (int f = 0; f < Math.Min(sourceData.Length, totalFrames); f++)
+                {
+                    float dsValue = sourceData[f];
+                    float existingVal = (existingTargetCurve != null && f < existingTargetCurve.Length)
+                        ? existingTargetCurve[f] : 0f;
+
+                    float blended = dsValue * bf2 + existingVal * (1f - bf2);
+                    mappedPoints.Add(new Point(frameTimes[f], blended));
+                }
+                result.MappedParameterCurves[mapping.TargetParam] = mappedPoints;
+            }
+        }
+
+        // ---- Step 12: Build phoneme output ----
+        int phIdx = 0;
+        for (int ni = 0; ni < notes.Count && phIdx < nPhonemes; ni++)
+        {
+            var note = notes[ni];
+            string lyric = string.IsNullOrEmpty(note.Lyric) ? DefaultLyric : note.Lyric;
+
+            if (!lyricToPhonemes.TryGetValue(lyric, out var phonemes))
+                continue;
+
+            if (phonemes == null) continue;
+
+            for (int p = 0; p < phonemes.Length && phIdx < nPhonemes; p++)
+            {
+                double phStart = phonemeStartTimes[phIdx];
+                double phEnd = phStart + durResult.DurationsMs[phIdx] / 1000.0;
+
+                result.Phonemes.Add(new SynthesizedPhoneme
+                {
+                    Symbol = durResult.PhonemeSymbols[phIdx],
+                    StartTime = phStart,
+                    EndTime = phEnd,
+                    Note = ni < origins.Count ? origins[ni] : null,
+                    StretchWeight = phEnd - phStart,
+                });
+                phIdx++;
+            }
+        }
+
+        return result;
+    }
+
+    // ================================================================
+    //  Smart Phoneme Alignment
+    // ================================================================
+
+    /// <summary>
+    /// Result of the smart phoneme alignment process.
+    /// </summary>
+    private class PhonemeAlignmentResult
+    {
+        public DurInferenceResult AlignedDurResult { get; init; } = null!;
+        public List<int> AlignedMidiTones { get; init; } = new();
+        public List<int> AlignedPhonemeToNoteMap { get; init; } = new();
+        public List<string> AlignedPhonemes { get; init; } = new();
+    }
+
+    /// <summary>
+    /// Align DS phoneme durations to target engine phonemes using vowel/consonant
+    /// per-note matching. If target has 1 vowel but DS has N, merge those N DS 
+    /// vowel durations into one. Same for consonants.
+    /// </summary>
+    private static PhonemeAlignmentResult SmartAlignPhonemeDurations(
+        DurInferenceResult durResult,
+        IReadOnlyList<(string lyric, string[] dsPhonemes)> noteG2pResults,
+        IReadOnlyList<SynthesisNoteSnapshot> targetNotes,
+        bool discardOnMismatch,
+        double frameMs)
+    {
+        var alignedSymbols = new List<string>();
+        var alignedDurationsMs = new List<double>();
+        var alignedDurationsFrames = new List<int>();
+        var alignedMidiTones = new List<int>();
+        var alignedPhonemeToNoteMap = new List<int>();
+        var alignedPhonemes = new List<string>();
+
+        int dsGlobalIdx = 0; // Index into durResult.PhonemeSymbols
+
+        for (int noteIdx = 0; noteIdx < noteG2pResults.Count; noteIdx++)
+        {
+            var (lyric, dsPhonemes) = noteG2pResults[noteIdx];
+            var targetNote = targetNotes[noteIdx];
+            int midiPitch = targetNote.Pitch;
+
+            // Skip rest notes
+            if (lyric == "R" || lyric == "r")
+            {
+                if (dsGlobalIdx < durResult.PhonemeSymbols.Length)
+                {
+                    alignedSymbols.Add(durResult.PhonemeSymbols[dsGlobalIdx]);
+                    alignedDurationsMs.Add(durResult.DurationsMs[dsGlobalIdx]);
+                    alignedDurationsFrames.Add(durResult.DurationsFrames[dsGlobalIdx]);
+                    alignedMidiTones.Add(midiPitch);
+                    alignedPhonemeToNoteMap.Add(noteIdx);
+                    alignedPhonemes.Add("SP");
+                    dsGlobalIdx++;
+                }
+                continue;
+            }
+
+            // Get the DS phoneme slice for this note
+            int dsNotePhonemeCount = dsPhonemes.Length;
+            if (dsGlobalIdx + dsNotePhonemeCount > durResult.PhonemeSymbols.Length)
+            {
+                // Not enough DS phonemes - trim
+                dsNotePhonemeCount = Math.Max(0, durResult.PhonemeSymbols.Length - dsGlobalIdx);
+            }
+
+            if (dsNotePhonemeCount <= 0)
+                continue;
+
+            // Collect DS phoneme symbols, durations, and classifications
+            var dsSliceSymbols = new List<string>();
+            var dsSliceDurationsMs = new List<double>();
+            var dsSliceDurationsFrames = new List<int>();
+            for (int i = 0; i < dsNotePhonemeCount; i++)
+            {
+                int idx = dsGlobalIdx + i;
+                dsSliceSymbols.Add(durResult.PhonemeSymbols[idx]);
+                dsSliceDurationsMs.Add(durResult.DurationsMs[idx]);
+                dsSliceDurationsFrames.Add(durResult.DurationsFrames[idx]);
+            }
+
+            // Classify DS phonemes: true = vowel-like, false = consonant-like
+            // For phoneme symbols like "zh/a", extract the part after "/"
+            var dsIsVowel = dsSliceSymbols.Select(s => IsLikelyVowel(s)).ToList();
+
+            // Get target phoneme count for this note (from the target engine)
+            var targetPhonemes = targetNote.Phonemes?.Select(p => p.Symbol).ToArray() ?? Array.Empty<string>();
+            var targetIsVowel = targetPhonemes.Select(s => IsLikelyVowel(s)).ToList();
+
+            if (targetPhonemes.Length == 0)
+            {
+                // No target phonemes - just pass through DS phonemes
+                for (int i = 0; i < dsNotePhonemeCount; i++)
+                {
+                    int idx = dsGlobalIdx + i;
+                    alignedSymbols.Add(durResult.PhonemeSymbols[idx]);
+                    alignedDurationsMs.Add(durResult.DurationsMs[idx]);
+                    alignedDurationsFrames.Add(durResult.DurationsFrames[idx]);
+                    alignedMidiTones.Add(midiPitch);
+                    alignedPhonemeToNoteMap.Add(noteIdx);
+                    alignedPhonemes.Add(dsPhonemes[i]);
+                }
+                dsGlobalIdx += dsNotePhonemeCount;
+                continue;
+            }
+
+            // Align DS phonemes to target phonemes by vowel/consonant categories
+            try
+            {
+                var mergedSymbols = new List<string>();
+                var mergedDurationsMs = new List<double>();
+                var mergedDurationsFrames = new List<int>();
+                var mergedPhonemes = new List<string>();
+
+                int dsIdx = 0;
+                foreach (var targetType in targetIsVowel)
+                {
+                    if (dsIdx >= dsSliceSymbols.Count)
+                        break;
+
+                    // Collect all DS phonemes of the same type (or until type changes)
+                    double accMs = 0;
+                    int accFrames = 0;
+                    var accSymbols = new List<string>();
+                    var accPhonemes = new List<string>();
+
+                    // If target has 1 of this type, merge all consecutive DS of same type
+                    // If target has N of this type where N == DS count, do 1:1
+                    while (dsIdx < dsSliceSymbols.Count && dsIsVowel[dsIdx] == targetType)
+                    {
+                        accMs += dsSliceDurationsMs[dsIdx];
+                        accFrames += dsSliceDurationsFrames[dsIdx];
+                        accSymbols.Add(dsSliceSymbols[dsIdx]);
+                        accPhonemes.Add(dsIdx < dsPhonemes.Length ? dsPhonemes[dsIdx] : dsSliceSymbols[dsIdx]);
+                        dsIdx++;
+                    }
+
+                    if (accSymbols.Count > 0)
+                    {
+                        // Merge: take the last symbol (or combined) for the merged result
+                        mergedSymbols.Add(accSymbols[^1]); // Use last symbol
+                        mergedDurationsMs.Add(accMs);
+                        mergedDurationsFrames.Add(accFrames);
+                        mergedPhonemes.Add(string.Join(" ", accPhonemes));
+                    }
+                }
+
+                // Handle any remaining DS phonemes (extra consonants/vowels after target runs out)
+                while (dsIdx < dsSliceSymbols.Count)
+                {
+                    // If we have remaining DS phonemes and target ran out, merge them into last segment
+                    if (mergedSymbols.Count > 0)
+                    {
+                        mergedDurationsMs[^1] += dsSliceDurationsMs[dsIdx];
+                        mergedDurationsFrames[^1] += dsSliceDurationsFrames[dsIdx];
+                        mergedPhonemes[^1] += " " + dsSliceSymbols[dsIdx];
+                    }
+                    dsIdx++;
+                }
+
+                // Now add the aligned results
+                for (int i = 0; i < mergedSymbols.Count; i++)
+                {
+                    alignedSymbols.Add(mergedSymbols[i]);
+                    alignedDurationsMs.Add(i < mergedDurationsMs.Count ? mergedDurationsMs[i] : 0);
+                    alignedDurationsFrames.Add(i < mergedDurationsFrames.Count ? mergedDurationsFrames[i] : 1);
+                    alignedMidiTones.Add(midiPitch);
+                    alignedPhonemeToNoteMap.Add(noteIdx);
+                    alignedPhonemes.Add(i < mergedPhonemes.Count ? mergedPhonemes[i] : mergedSymbols[i]);
+                }
+            }
+            catch
+            {
+                // Fallback: pass through DS phonemes as-is
+                for (int i = 0; i < dsNotePhonemeCount; i++)
+                {
+                    int idx = dsGlobalIdx + i;
+                    alignedSymbols.Add(durResult.PhonemeSymbols[idx]);
+                    alignedDurationsMs.Add(durResult.DurationsMs[idx]);
+                    alignedDurationsFrames.Add(durResult.DurationsFrames[idx]);
+                    alignedMidiTones.Add(midiPitch);
+                    alignedPhonemeToNoteMap.Add(noteIdx);
+                    alignedPhonemes.Add(i < dsPhonemes.Length ? dsPhonemes[i] : durResult.PhonemeSymbols[idx]);
+                }
+            }
+
+            dsGlobalIdx += dsNotePhonemeCount;
+        }
+
+        // Handle remaining DS phonemes (discard if discardOnMismatch, otherwise include)
+        if (!discardOnMismatch)
+        {
+            while (dsGlobalIdx < durResult.PhonemeSymbols.Length)
+            {
+                int lastPitch = alignedMidiTones.Count > 0 ? alignedMidiTones[^1] : 60;
+                int lastNoteIdx = alignedPhonemeToNoteMap.Count > 0 ? alignedPhonemeToNoteMap[^1] : 0;
+                alignedSymbols.Add(durResult.PhonemeSymbols[dsGlobalIdx]);
+                alignedDurationsMs.Add(durResult.DurationsMs[dsGlobalIdx]);
+                alignedDurationsFrames.Add(durResult.DurationsFrames[dsGlobalIdx]);
+                alignedMidiTones.Add(lastPitch);
+                alignedPhonemeToNoteMap.Add(lastNoteIdx);
+                alignedPhonemes.Add(durResult.PhonemeSymbols[dsGlobalIdx]);
+                dsGlobalIdx++;
+            }
+        }
+
+        // Build aligned DurInferenceResult
+        int totalFrames = alignedDurationsFrames.Sum();
+        var alignedDurResult = new DurInferenceResult
+        {
+            PhonemeSymbols = alignedSymbols.ToArray(),
+            DurationsMs = alignedDurationsMs.ToArray(),
+            DurationsFrames = alignedDurationsFrames.ToArray(),
+            TotalFrames = totalFrames,
+            FrameMs = frameMs,
+        };
+
+        return new PhonemeAlignmentResult
+        {
+            AlignedDurResult = alignedDurResult,
+            AlignedMidiTones = alignedMidiTones,
+            AlignedPhonemeToNoteMap = alignedPhonemeToNoteMap,
+            AlignedPhonemes = alignedPhonemes,
+        };
+    }
+
+    /// <summary>
+    /// Determine if a phoneme symbol is likely a vowel.
+    /// Checks the phoneme part after "/" if present, or the full symbol.
+    /// </summary>
+    private static bool IsLikelyVowel(string symbol)
+    {
+        if (string.IsNullOrEmpty(symbol))
+            return false;
+
+        // Get the part after "/" (e.g., "zh/a" -> "a")
+        int slashIdx = symbol.IndexOf('/');
+        string core = slashIdx >= 0 ? symbol[(slashIdx + 1)..] : symbol;
+
+        if (string.IsNullOrEmpty(core))
+            return false;
+
+        // Special phonemes
+        if (core == "SP" || core == "AP" || core == "ExAP")
+            return true;
+
+        // Check first character
+        char first = core[0];
+        return first == 'a' || first == 'e' || first == 'i' || first == 'o' || first == 'u' ||
+               first == 'A' || first == 'E' || first == 'I' || first == 'O' || first == 'U';
+    }
+
+    private float[]? SampleExistingCurve(string paramName, double startTime, double endTime,
+        int totalFrames, double frameMs)
+    {
+        if (!_context.TryGetAutomation(paramName, out var automation))
+            return null;
+
+        var result = new float[totalFrames];
+        var times = new double[totalFrames];
+        for (int f = 0; f < totalFrames; f++)
+        {
+            times[f] = startTime + f * frameMs / 1000.0;
+        }
+        try
+        {
+            var values = automation.Evaluate(times);
+            for (int f = 0; f < totalFrames; f++)
+            {
+                result[f] = (float)values[f];
+            }
+        }
+        catch
+        {
+            Array.Fill(result, 0f);
+        }
+        return result;
+    }
+
+    // ================================================================
+    //  Helpers
+    // ================================================================
+
+    private static float NormalizeVarianceParam(string paramName, float value)
+    {
+        return paramName.ToLowerInvariant() switch
+        {
+            "tension" => Math.Clamp((value + 10f) / 20f, 0f, 1f),
+            "energy" or "breathiness" or "voicing" => Math.Clamp((value + 96f) / 96f, 0f, 1f),
+            _ => Math.Clamp(value, 0f, 1f)
+        };
+    }
+
+    private void EnsureModelsLoaded(PluginConfig config)
+    {
+        // Set device first (will trigger reload if changed)
+        _dsSession.SetDevice(config.Device);
+
+        bool pathsChanged = false;
+
+        // Check dsdur model
+        if (!string.IsNullOrEmpty(config.DurModelPath) &&
+            (_durModelDirCached != config.DurModelPath || !_dsSession.IsDurLoaded))
+        {
+            _dsSession.LoadDurModel(config.DurModelPath);
+            _dsSession.LoadG2p(config.Language);
+            _durModelDirCached = config.DurModelPath;
+            pathsChanged = true;
+        }
+
+        // Check dspitch model
+        if (!string.IsNullOrEmpty(config.PitchModelPath) &&
+            (_pitchModelDirCached != config.PitchModelPath || !_dsSession.IsPitchLoaded))
+        {
+            _dsSession.LoadPitchModel(config.PitchModelPath);
+            _pitchModelDirCached = config.PitchModelPath;
+            pathsChanged = true;
+        }
+
+        // Check dsvariance model
+        if (!string.IsNullOrEmpty(config.VarianceModelPath) &&
+            (_varianceModelDirCached != config.VarianceModelPath || !_dsSession.IsVarianceLoaded))
+        {
+            _dsSession.LoadVarianceModel(config.VarianceModelPath);
+            _varianceModelDirCached = config.VarianceModelPath;
+            pathsChanged = true;
+        }
+
+        // Check acoustic model + vocoder (singer root)
+        if (!string.IsNullOrEmpty(config.SingerRootPath) &&
+            (_singerRootDirCached != config.SingerRootPath || !_dsSession.IsAcousticLoaded))
+        {
+            _dsSession.LoadAcousticModel(config.SingerRootPath);
+            _singerRootDirCached = config.SingerRootPath;
+            pathsChanged = true;
+        }
+
+        // Load vocoder after acoustic model is loaded
+        if (!string.IsNullOrEmpty(config.SingerRootPath) &&
+            _dsSession.IsAcousticLoaded &&
+            !_dsSession.IsVocoderLoaded)
+        {
+            _dsSession.LoadVocoder(config.SingerRootPath);
+            pathsChanged = true;
+        }
+
+        if (pathsChanged)
+            SaveConfig();
+    }
+
+    private void RefreshTargetAutomationKeys()
+    {
+        var keys = new List<string>
+        {
+            "pitch",
+            "pitch_deviation",
+            "TENC",
+            "BRE",
+            "VOIC",
+            "ENER",
+            "CLR",
+            "VEL",
+        };
+        _targetAutomationKeys = keys;
+    }
+
+    private void UpdateConfigFromContext()
+    {
+        var props = _context.PartProperties;
+
+        // Model paths
+        _config.DurModelPath = ReadPropertyString(props, "dur_model_path", _config.DurModelPath);
+        _config.PitchModelPath = ReadPropertyString(props, "pitch_model_path", _config.PitchModelPath);
+        _config.VarianceModelPath = ReadPropertyString(props, "variance_model_path", _config.VarianceModelPath);
+        _config.SingerRootPath = ReadPropertyString(props, "singer_root_path", _config.SingerRootPath);
+
+        // Singers directory (save globally when changed)
+        string newSingersDir = ReadPropertyString(props, "singers_directory", _config.SingerRootPath);
+        string currentSingersDir = DiffSingerEngine.LoadSingersDirectory();
+        if (!string.IsNullOrEmpty(newSingersDir) && newSingersDir != currentSingersDir)
+        {
+            DiffSingerEngine.SaveSingersDirectory(newSingersDir);
+        }
+
+        // Language
+        _config.Language = ReadPropertyString(props, "language", _config.Language);
+
+        // Device
+        var deviceStr = ReadPropertyString(props, "exec_device", "CPU");
+        _config.Device = deviceStr == "DirectML" ? ExecutionDevice.DirectML : ExecutionDevice.CPU;
+        _config.GpuIndex = (int)ReadPropertyFloat(props, "gpu_index", (float)_config.GpuIndex);
+
+        // Sampling Steps
+        _config.DurSteps = (int)ReadPropertyFloat(props, "dur_steps", (float)_config.DurSteps);
+        _config.AcousticSteps = (int)ReadPropertyFloat(props, "acoustic_steps", (float)_config.AcousticSteps);
+        _config.PitchSteps = (int)ReadPropertyFloat(props, "pitch_steps", (float)_config.PitchSteps);
+        _config.VarianceSteps = (int)ReadPropertyFloat(props, "variance_steps", (float)_config.VarianceSteps);
+        _config.DiffusionDepth = ReadPropertyFloat(props, "diffusion_depth", (float)_config.DiffusionDepth);
+
+        // Performance Sliders
+        _config.Expressiveness = ReadPropertyFloat(props, "expressiveness", _config.Expressiveness);
+        _config.BlendPercent = ReadPropertyFloat(props, "blend", _config.BlendPercent);
+
+        // Advanced toggles
+        _config.TensorCache = ReadPropertyBool(props, "tensor_cache", _config.TensorCache);
+        _config.VarianceLocalPitchPatch = ReadPropertyBool(props, "variance_patch", _config.VarianceLocalPitchPatch);
+        _config.UnvoicedF0Interpolate = ReadPropertyBool(props, "unvoiced_f0", _config.UnvoicedF0Interpolate);
+        _config.DiscardOnMismatch = ReadPropertyBool(props, "discard_mismatch", _config.DiscardOnMismatch);
+
+        // Apply mode
+        var modeStr = ReadPropertyString(props, "apply_mode", "Selected Notes");
+        _config.Mode = modeStr == "Whole Track" ? ApplyMode.WholeTrack : ApplyMode.SelectedNotes;
+
+        // Variance mappings (up to 6)
+        _config.VarianceMappings.Clear();
+        for (int i = 0; i < 6; i++)
+        {
+            var idx = i.ToString();
+            var source = ReadPropertyString(props, $"variance_map_{idx}_source", "");
+            var target = ReadPropertyString(props, $"variance_map_{idx}_target", "");
+
+            if (!string.IsNullOrEmpty(source) && !string.IsNullOrEmpty(target))
+            {
+                _config.VarianceMappings.Add(new VarianceMapping
+                {
+                    SourceParam = source,
+                    TargetParam = target
+                });
+            }
+        }
+
+        // Sync device to model session
+        if (_dsSession.GetDevice() != _config.Device)
+        {
+            _dsSession.SetDevice(_config.Device);
+            // Force model reload on next extraction
+            _durModelDirCached = null;
+            _pitchModelDirCached = null;
+            _varianceModelDirCached = null;
+        }
+    }
+
+    // Track cached model dirs to detect changes
+    private string? _durModelDirCached;
+    private string? _pitchModelDirCached;
+    private string? _varianceModelDirCached;
+    private string? _singerRootDirCached;
+
+    // Helper to read from IReadOnlyNotifiablePropertyObject
+    private static string ReadPropertyString(IReadOnlyNotifiablePropertyObject props, string key, string defaultValue)
+    {
+        var prop = props.StringField(key, defaultValue);
+        return prop.Value;
+    }
+
+    private static float ReadPropertyFloat(IReadOnlyNotifiablePropertyObject props, string key, float defaultValue)
+    {
+        var prop = props.NumberField(key, defaultValue);
+        return (float)prop.Value;
+    }
+
+    private static bool ReadPropertyBool(IReadOnlyNotifiablePropertyObject props, string key, bool defaultValue)
+    {
+        var prop = props.BoolField(key, defaultValue);
+        return prop.Value;
+    }
+
+    // ================================================================
+    //  Output Properties
+    // ================================================================
+
+    public IReadOnlyList<IReadOnlyList<Point>> SynthesizedPitch
+    {
+        get
+        {
+            var segments = new List<IReadOnlyList<Point>>();
+            foreach (var piece in _pieces)
+            {
+                if (piece.SynthesizedParams?.PitchCurve == null) continue;
+
+                var pitchData = piece.SynthesizedParams.PitchCurve;
+                var frameTimes = piece.SynthesizedParams.FrameTimes;
+
+                if (pitchData.Length == 0 || frameTimes.Length == 0) continue;
+
+                var points = new List<Point>();
+                for (int f = 0; f < Math.Min(pitchData.Length, frameTimes.Length); f++)
+                {
+                    double semitones = pitchData[f] * 0.01;
+                    points.Add(new Point(frameTimes[f], semitones));
+                }
+                if (points.Count > 0)
+                    segments.Add(points);
+            }
+            return segments;
+        }
+    }
+
+    public IReadOnlyMap<string, SynthesizedParameter> SynthesizedParameters
+    {
+        get
+        {
+            var map = new Map<string, SynthesizedParameter>();
+
+            var allParamNames = new HashSet<string>();
+            var allMappedNames = new HashSet<string>();
+            foreach (var piece in _pieces)
+            {
+                if (piece.SynthesizedParams == null) continue;
+                foreach (var key in piece.SynthesizedParams.ParameterCurves.Keys)
+                    allParamNames.Add(key);
+                foreach (var key in piece.SynthesizedParams.MappedParameterCurves.Keys)
+                    allMappedNames.Add(key);
+            }
+
+            // DS variance parameters: prefix with "ds_"
+            foreach (var paramName in allParamNames)
+            {
+                var segments = new List<IReadOnlyList<Point>>();
+                foreach (var piece in _pieces)
+                {
+                    if (piece.SynthesizedParams == null) continue;
+                    if (piece.SynthesizedParams.ParameterCurves.TryGetValue(paramName, out var points) && points.Count > 0)
+                        segments.Add(points);
+                }
+                if (segments.Count > 0)
+                    map[$"ds_{paramName}"] = new SynthesizedParameter { Segments = segments };
+            }
+
+            // Mapped parameters: prefix with "mapped_"
+            foreach (var mappedName in allMappedNames)
+            {
+                var segments = new List<IReadOnlyList<Point>>();
+                foreach (var piece in _pieces)
+                {
+                    if (piece.SynthesizedParams == null) continue;
+                    if (piece.SynthesizedParams.MappedParameterCurves.TryGetValue(mappedName, out var points) && points.Count > 0)
+                        segments.Add(points);
+                }
+                if (segments.Count > 0)
+                    map[$"mapped_{mappedName}"] = new SynthesizedParameter { Segments = segments };
+            }
+
+            return map;
+        }
+    }
+
+    public IReadOnlyList<SynthesizedPhoneme> Phonemes
+    {
+        get
+        {
+            var result = new List<SynthesizedPhoneme>();
+            foreach (var piece in _pieces)
+            {
+                if (piece.SynthesizedParams != null)
+                    result.AddRange(piece.SynthesizedParams.Phonemes);
+            }
+            return result;
+        }
+    }
+
+    public IReadOnlyList<SynthesisStatusSegment> GetStatus()
+    {
+        var result = new List<SynthesisStatusSegment>(_pieces.Count);
+        foreach (var piece in _pieces)
+        {
+            var status = piece.Failed ? SynthesisSegmentStatus.Failed
+                : piece.Synthesizing ? SynthesisSegmentStatus.Synthesizing
+                : piece.Dirty ? SynthesisSegmentStatus.Pending
+                : SynthesisSegmentStatus.Synthesized;
+
+            string? message = piece.Failed
+                ? $"Error: {piece.Error}"
+                : piece.Synthesizing ? "Extracting DS parameters..." : null;
+
+            result.Add(new SynthesisStatusSegment
+            {
+                StartTime = piece.StartTime,
+                EndTime = piece.EndTime,
+                Status = status,
+                Message = message,
+                Progress = piece.Synthesizing ? 0 : 1,
+            });
+        }
+        return result;
+    }
+
+    public event Action? StatusChanged;
+
+    public void Dispose()
+    {
+        _notesSubscription.Dispose();
+        _context.Notes.ItemAdded -= OnNotesStructureChanged;
+        _context.Notes.ItemRemoved -= OnNotesStructureChanged;
+        _context.PartProperties.Modified -= MarkAllDirty;
+        _context.Committed -= OnCommitted;
+        _context.Pitch.RangeModified -= OnRangeModified;
+        _context.PitchDeviation.RangeModified -= OnRangeModified;
+        _dsSession.Dispose();
+    }
+
+    // ================================================================
+    //  Piece Management
+    // ================================================================
+
+    private void Resegment()
+    {
+        _needResegment = false;
+
+        var groups = new List<List<ILiveNote>>();
+        List<ILiveNote>? current = null;
+        double groupMaxEnd = 0;
+
+        foreach (var note in _context.Notes)
+        {
+            if (current == null || note.StartTime.Value > groupMaxEnd)
+            {
+                current = new List<ILiveNote>();
+                groups.Add(current);
+                groupMaxEnd = note.EndTime.Value;
+            }
+            else
+            {
+                groupMaxEnd = Math.Max(groupMaxEnd, note.EndTime.Value);
+            }
+            current.Add(note);
+        }
+
+        var newPieces = new List<Piece>(groups.Count);
+        foreach (var notes in groups)
+        {
+            double pieceEnd = notes.Max(n => n.EndTime.Value);
+            var existing = _pieces.FirstOrDefault(p => p.Notes.SequenceEqual(notes));
+            if (existing != null)
+            {
+                _pieces.Remove(existing);
+                existing.StartTime = notes[0].StartTime.Value;
+                existing.EndTime = pieceEnd;
+                newPieces.Add(existing);
+            }
+            else
+            {
+                newPieces.Add(new Piece
+                {
+                    Notes = notes,
+                    StartTime = notes[0].StartTime.Value,
+                    EndTime = pieceEnd,
+                    Dirty = true,
+                });
+            }
+        }
+        _pieces.Clear();
+        _pieces.AddRange(newPieces);
+    }
+
+    // Event handlers
+    private void OnNotesStructureChanged(ILiveNote note)
+    {
+        _needResegment = true;
+        MarkAllDirty();
+    }
+
+    private void OnCommitted()
+    {
+        if (_needResegment) Resegment();
+    }
+
+    private void OnRangeModified(double startTime, double endTime)
+    {
+        MarkAllDirty();
+    }
+
+    private void MarkAllDirty()
+    {
+        _needResegment = true;
+        foreach (var piece in _pieces)
+            piece.Dirty = true;
+        StatusChanged?.Invoke();
+    }
+
+    private void MarkDirtyOnNoteChange()
+    {
+        foreach (var piece in _pieces)
+            piece.Dirty = true;
+        StatusChanged?.Invoke();
+    }
+
+    private void SubscribeNote(ILiveNote note)
+    {
+        var handler = new Action(MarkDirtyOnNoteChange);
+        note.StartTime.Modified += handler;
+        note.EndTime.Modified += handler;
+        note.Pitch.Modified += handler;
+        note.Lyric.Modified += handler;
+        _noteHandlers[note] = handler;
+        MarkAllDirty();
+    }
+
+    private void UnsubscribeNote(ILiveNote note)
+    {
+        if (_noteHandlers.TryGetValue(note, out var handler))
+        {
+            note.StartTime.Modified -= handler;
+            note.EndTime.Modified -= handler;
+            note.Pitch.Modified -= handler;
+            note.Lyric.Modified -= handler;
+            _noteHandlers.Remove(note);
+        }
+    }
+
+}
diff --git a/tests/plugins/DiffSingerParamExtract/DiffSingerParamVoiceEngine.cs b/tests/plugins/DiffSingerParamExtract/DiffSingerParamVoiceEngine.cs
new file mode 100644
index 00000000..be4161d7
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DiffSingerParamVoiceEngine.cs
@@ -0,0 +1,295 @@
+using TuneLab.Foundation;
+using TuneLab.SDK;
+using System.Text.Json;
+
+namespace DiffSinger;
+
+/// <summary>
+/// Detected DiffSinger singer information.
+/// </summary>
+public record SingerDetectionInfo
+{
+    public required string Name { get; init; }
+    public required string RootPath { get; init; }
+    public string? DurPath { get; init; }
+    public string? PitchPath { get; init; }
+    public string? VariancePath { get; init; }
+    public bool HasAcousticModel { get; init; }
+    public List<string> Languages { get; init; } = new();
+}
+
+/// <summary>
+/// DiffSinger voice engine for TuneLab.
+/// Auto-scans configured singers directories for DiffSinger voicebanks during Init().
+/// </summary>
+[VoiceEngine("DiffSinger")]
+public sealed class DiffSingerEngine : IVoiceEngine
+{
+    private readonly OrderedMap<string, VoiceSourceInfo> _sources = new();
+    internal static readonly Dictionary<string, SingerDetectionInfo> DetectedSingers = new();
+
+    // Plugin-level config (separate from session-level PluginConfig)
+    internal static string PluginConfigPath => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+        "TuneLab", "DiffSinger", "plugin_config.json");
+
+    public IReadOnlyOrderedMap<string, VoiceSourceInfo> VoiceSourceInfos => _sources;
+
+    public void Init()
+    {
+        // Write debug log to file
+        var logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TuneLab", "DiffSinger", "init_debug.log");
+        void Log(string msg) { try { File.AppendAllText(logPath, $"[{DateTime.Now:HH:mm:ss}] {msg}\n"); } catch { } }
+        try { Directory.CreateDirectory(Path.GetDirectoryName(logPath) ?? ""); } catch { }
+
+        Log($"=== DiffSinger Init() START ===");
+        Log($"PluginConfigPath: {PluginConfigPath}");
+        Log($"Assembly.Location: {System.Reflection.Assembly.GetExecutingAssembly().Location}");
+
+        try
+        {
+            DetectedSingers.Clear();
+            _sources.Clear();
+
+            var scanDirs = new HashSet<string>();
+
+            // 1. From saved config
+            string savedDir = LoadSingersDirectory();
+            Log($"LoadSingersDirectory() = '{savedDir}'");
+            if (!string.IsNullOrEmpty(savedDir) && Directory.Exists(savedDir))
+                scanDirs.Add(savedDir);
+
+            // 2. Common directories
+            string[] commonDirs = [
+                @"D:\Program Files\OpenUTAU\Singers",
+                @"D:\Program Files\OpenUtau\Singers",
+                @"C:\Program Files\OpenUTAU\Singers",
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TuneLab", "Singers"),
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "OpenUtau", "Singers"),
+            ];
+            foreach (var d in commonDirs)
+            {
+                if (Directory.Exists(d)) { scanDirs.Add(d); Log($"  Found: {d}"); }
+                else Log($"  Not found: {d}");
+            }
+
+            // 3. Drive roots
+            foreach (var drive in DriveInfo.GetDrives())
+            {
+                if (!drive.IsReady) continue;
+                var p = Path.Combine(drive.RootDirectory.FullName, "Program Files", "OpenUTAU", "Singers");
+                if (Directory.Exists(p)) { scanDirs.Add(p); Log($"  Drive: {p}"); }
+            }
+
+            Log($"Total scan dirs: {scanDirs.Count}");
+            bool foundAny = false;
+
+            foreach (var scanDir in scanDirs)
+            {
+                Log($"Scanning: {scanDir}");
+                if (!Directory.Exists(scanDir)) continue;
+                foreach (var subDir in Directory.GetDirectories(scanDir))
+                {
+                    var name = Path.GetFileName(subDir);
+                    Log($"  Subdir: {name}");
+                    if (DetectedSingers.ContainsKey($"ds-{name}")) continue;
+                    var info = DetectSinger(subDir);
+                    if (info != null)
+                    {
+                        Log($"    DETECTED: {info.Name}");
+                        var key = $"ds-{name}";
+                        DetectedSingers[key] = info;
+                        _sources.Add(key, new VoiceSourceInfo { Name = $"[DS] {info.Name}", Description = subDir });
+                        foundAny = true;
+                    }
+                    else Log($"    Not a DS singer");
+                }
+            }
+
+            Log($"FoundAny={foundAny}, Sources before manual={_sources.Count}");
+
+            _sources.Add("ds-manual", new VoiceSourceInfo
+            {
+                Name = foundAny ? "Manual Config..." : "DiffSinger (Manual)",
+                Description = "Manually configure model paths in the property panel"
+            });
+
+            if (!foundAny)
+            {
+                _sources.Insert(0, "ds-setup", new VoiceSourceInfo
+                {
+                    Name = "⚙ Set Singers Path",
+                    Description = "Configure the DiffSinger voicebank directory in property panel"
+                });
+            }
+
+            Log($"Final sources count={_sources.Count}");
+            foreach (var s in _sources) Log($"  [{s.Key}] = {s.Value.Name}");
+        }
+        catch (Exception ex)
+        {
+            Log($"EXCEPTION: {ex.GetType().Name}: {ex.Message}");
+            _sources.Clear();
+            _sources.Add("ds-manual", new VoiceSourceInfo { Name = "DiffSinger (Manual)", Description = "Manual config" });
+        }
+        Log("=== DiffSinger Init() END ===");
+    }
+
+    public void Destroy() { }
+
+    public ISynthesisSession CreateSession(string voiceId, ISynthesisContext context)
+    {
+        var session = new DiffSingerSession(context);
+
+        // If a detected singer was selected, auto-configure paths
+        if (DetectedSingers.TryGetValue(voiceId, out var info))
+        {
+            session.AutoConfigureFromSinger(info);
+        }
+
+        return session;
+    }
+
+    // ================================================================
+    //  Singer Detection
+    // ================================================================
+
+    private static SingerDetectionInfo? DetectSinger(string dirPath)
+    {
+        var dirName = Path.GetFileName(dirPath);
+
+        string? durPath = null;
+        string? pitchPath = null;
+        string? variancePath = null;
+        bool hasAcoustic = false;
+        var languages = new List<string>();
+
+        var dsdurDir = Path.Combine(dirPath, "dsdur");
+        var dspitchDir = Path.Combine(dirPath, "dspitch");
+        var dsvarianceDir = Path.Combine(dirPath, "dsvariance");
+        var rootConfig = Path.Combine(dirPath, "dsconfig.yaml");
+
+        // Check dsdur
+        if (Directory.Exists(dsdurDir) && File.Exists(Path.Combine(dsdurDir, "dsconfig.yaml")))
+        {
+            durPath = dsdurDir;
+            // Detect languages from dsdict-*.yaml files
+            foreach (var f in Directory.GetFiles(dsdurDir, "dsdict-*.yaml"))
+            {
+                var langCode = Path.GetFileNameWithoutExtension(f).Replace("dsdict-", "");
+                if (!string.IsNullOrEmpty(langCode)) languages.Add(langCode);
+            }
+            if (File.Exists(Path.Combine(dsdurDir, "dsdict.yaml")))
+                languages.Insert(0, "default");
+        }
+
+        // Check dspitch
+        if (Directory.Exists(dspitchDir) && File.Exists(Path.Combine(dspitchDir, "dsconfig.yaml")))
+            pitchPath = dspitchDir;
+
+        // Check dsvariance
+        if (Directory.Exists(dsvarianceDir) && File.Exists(Path.Combine(dsvarianceDir, "dsconfig.yaml")))
+            variancePath = dsvarianceDir;
+
+        // Check root dsconfig.yaml for acoustic model
+        if (File.Exists(rootConfig))
+        {
+            try
+            {
+                var yaml = File.ReadAllText(rootConfig);
+                var deserializer = new YamlDotNet.Serialization.DeserializerBuilder()
+                    .IgnoreUnmatchedProperties().Build();
+                var config = deserializer.Deserialize<DsConfig>(yaml);
+                hasAcoustic = !string.IsNullOrEmpty(config.acoustic);
+            }
+            catch { }
+        }
+
+        // Must have at least dsdur OR root acoustic model
+        if (durPath == null && !hasAcoustic)
+            return null;
+
+        // Determine display name from character.txt first, then directory name
+        string name = dirName;
+        var charTxt = Path.Combine(dirPath, "character.txt");
+        if (File.Exists(charTxt))
+        {
+            try
+            {
+                foreach (var line in File.ReadAllLines(charTxt))
+                {
+                    if (line.StartsWith("name=", StringComparison.OrdinalIgnoreCase))
+                    {
+                        name = line.Substring("name=".Length).Trim();
+                        break;
+                    }
+                }
+            }
+            catch { }
+        }
+
+        return new SingerDetectionInfo
+        {
+            Name = name,
+            RootPath = dirPath,
+            DurPath = durPath,
+            PitchPath = pitchPath,
+            VariancePath = variancePath,
+            HasAcousticModel = hasAcoustic,
+            Languages = languages,
+        };
+    }
+
+    // ================================================================
+    //  Plugin Config Persistence (singers directory)
+    // ================================================================
+
+    internal static string LoadSingersDirectory()
+    {
+        try
+        {
+            if (File.Exists(PluginConfigPath))
+            {
+                var json = File.ReadAllText(PluginConfigPath);
+                var doc = JsonDocument.Parse(json);
+                if (doc.RootElement.TryGetProperty("singersDirectory", out var dir))
+                {
+                    var path = dir.GetString();
+                    if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
+                        return path;
+                }
+            }
+        }
+        catch { }
+
+        // Default: check common locations in priority order
+        string[] candidates = [
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "TuneLab", "Singers"),
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "OpenUtau", "Singers"),
+            @"C:\Program Files\OpenUTAU\Singers",
+            @"D:\Program Files\OpenUTAU\Singers",
+            @"D:\Program Files\OpenUtau\Singers",
+        ];
+
+        foreach (var candidate in candidates)
+        {
+            if (Directory.Exists(candidate))
+                return candidate;
+        }
+
+        return string.Empty;
+    }
+
+    internal static void SaveSingersDirectory(string path)
+    {
+        try
+        {
+            var dir = Path.GetDirectoryName(PluginConfigPath);
+            if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
+            var config = new Dictionary<string, string> { { "singersDirectory", path } };
+            var json = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
+            File.WriteAllText(PluginConfigPath, json);
+        }
+        catch { }
+    }
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/DiffSingerUtils.cs b/tests/plugins/DiffSingerParamExtract/DiffSingerUtils.cs
new file mode 100644
index 00000000..e82c26b7
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DiffSingerUtils.cs
@@ -0,0 +1,216 @@
+using System.Text.RegularExpressions;
+
+namespace DiffSinger;
+
+/// <summary>
+/// Utility functions ported from OpenUtau's DiffSinger implementation.
+/// </summary>
+public static class DiffSingerUtils
+{
+    /// <summary>Head padding frames (consonant anticipation).</summary>
+    public const int HeadFrames = 16;
+    /// <summary>Tail padding frames.</summary>
+    public const int TailFrames = 16;
+
+    /// <summary>
+    /// Load phoneme-to-token mapping from a phoneme list file.
+    /// </summary>
+    public static Dictionary<string, int> LoadPhonemes(string phonemesPath)
+    {
+        var lines = File.ReadAllLines(phonemesPath);
+        var dict = new Dictionary<string, int>();
+        for (int i = 0; i < lines.Length; i++)
+        {
+            var line = lines[i].Trim();
+            if (!string.IsNullOrEmpty(line) && !line.StartsWith("#"))
+            {
+                dict[line] = i;
+            }
+        }
+        return dict;
+    }
+
+    /// <summary>
+    /// Load language IDs mapping from a YAML file.
+    /// </summary>
+    public static Dictionary<string, int> LoadLanguageIds(string langIdPath)
+    {
+        var lines = File.ReadAllLines(langIdPath);
+        var dict = new Dictionary<string, int>();
+        foreach (var line in lines)
+        {
+            var trimmed = line.Trim();
+            if (string.IsNullOrEmpty(trimmed) || trimmed.StartsWith("#"))
+                continue;
+            var parts = trimmed.Split(':');
+            if (parts.Length == 2 && int.TryParse(parts[1].Trim(), out int id))
+            {
+                dict[parts[0].Trim()] = id;
+            }
+        }
+        return dict;
+    }
+
+    /// <summary>
+    /// Extract language code from a phoneme symbol (e.g., "en/AA" -> "en").
+    /// </summary>
+    public static string PhonemeLanguage(string phoneme)
+    {
+        int slash = phoneme.IndexOf('/');
+        return slash >= 0 ? phoneme[..slash] : string.Empty;
+    }
+
+    /// <summary>
+    /// Sample a float curve at regular intervals and convert using a value function.
+    /// </summary>
+    public static double[] SampleCurve(
+        IReadOnlyList<float> curve,
+        double startValue,
+        double frameMs,
+        int totalFrames,
+        int headFrames,
+        int tailFrames,
+        Func<double, double> valueFunc)
+    {
+        var result = new double[totalFrames];
+        for (int i = 0; i < totalFrames; i++)
+        {
+            double t = (i - headFrames) * frameMs / 1000.0;
+            int idx = (int)(t * 100); // Assuming 100Hz control rate
+            idx = Math.Clamp(idx, 0, Math.Max(0, curve.Count - 1));
+            result[i] = valueFunc(curve.Count > 0 ? curve[idx] : startValue);
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Calculate padded phoneme durations in frames.
+    /// </summary>
+    public static int[] PaddedPhoneDurations(
+        IReadOnlyList<double> phonemeEndsMs,
+        IReadOnlyList<double> noteDurationsMs,
+        double frameMs,
+        int headFrames,
+        int tailFrames)
+    {
+        if (phonemeEndsMs.Count == 0)
+            return Array.Empty<int>();
+
+        double firstPhonemeStart = 0;
+        double lastPhonemeEnd = phonemeEndsMs[^1];
+
+        var durations = new List<int>();
+        // Head padding
+        durations.Add(headFrames);
+
+        // Phoneme durations in frames
+        double prevEnd = firstPhonemeStart;
+        for (int i = 0; i < phonemeEndsMs.Count; i++)
+        {
+            double durMs = phonemeEndsMs[i] - prevEnd;
+            int frames = Math.Max(1, (int)Math.Round(durMs / frameMs));
+            durations.Add(frames);
+            prevEnd = phonemeEndsMs[i];
+        }
+
+        // Tail padding
+        durations.Add(tailFrames);
+
+        return durations.ToArray();
+    }
+
+    /// <summary>
+    /// Convert tone (semitones relative to A4=69) to frequency in Hz.
+    /// </summary>
+    public static double ToneToFreq(double tone)
+    {
+        return 440.0 * Math.Pow(2.0, (tone - 69.0) / 12.0);
+    }
+
+    /// <summary>
+    /// Validate tensor shape.
+    /// </summary>
+    public static bool ValidateShape(ReadOnlySpan<int> shape, ReadOnlySpan<int> expected)
+    {
+        if (shape.Length != expected.Length) return false;
+        for (int i = 0; i < shape.Length; i++)
+        {
+            if (expected[i] >= 0 && shape[i] != expected[i]) return false;
+        }
+        return true;
+    }
+
+    public static string ShapeString(ReadOnlySpan<int> shape)
+    {
+        return "[" + string.Join(", ", shape.ToArray()) + "]";
+    }
+
+    /// <summary>
+    /// Compute cumulative sum of a sequence.
+    /// </summary>
+    public static IEnumerable<double> CumulativeSum(IEnumerable<double> sequence, double start = 0)
+    {
+        double sum = start;
+        foreach (var item in sequence)
+        {
+            sum += item;
+            yield return sum;
+        }
+    }
+
+    public static IEnumerable<int> CumulativeSum(IEnumerable<int> sequence, int start = 0)
+    {
+        int sum = start;
+        foreach (var item in sequence)
+        {
+            sum += item;
+            yield return sum;
+        }
+    }
+
+    /// <summary>
+    /// Stretch a duration sequence to fit within an end position.
+    /// </summary>
+    public static List<double> Stretch(IList<double> source, double ratio, double endPos)
+    {
+        double startPos = endPos - source.Sum() * ratio;
+        var result = CumulativeSum(source.Select(x => x * ratio).Prepend(0), startPos).ToList();
+        result.RemoveAt(result.Count - 1);
+        return result;
+    }
+
+    /// <summary>
+    /// Resample a padded curve from one frame rate/offset to another.
+    /// </summary>
+    public static float[] ResamplePaddedCurve(
+        float[] sourceCurve,
+        int targetFrames,
+        int sourceHeadFrames,
+        int sourceTailFrames,
+        int targetHeadFrames,
+        int targetTailFrames,
+        double sourceFrameMs,
+        double targetFrameMs)
+    {
+        if (sourceCurve.Length == 0) return Array.Empty<float>();
+
+        int sourceContentFrames = sourceCurve.Length - sourceHeadFrames - sourceTailFrames;
+        if (sourceContentFrames <= 0) return Enumerable.Repeat(0f, targetFrames).ToArray();
+
+        var result = new float[targetFrames];
+        double sourceContentDurationMs = sourceContentFrames * sourceFrameMs;
+
+        for (int i = 0; i < targetFrames; i++)
+        {
+            double tMs = (i - targetHeadFrames) * targetFrameMs;
+            double ratio = tMs / sourceContentDurationMs;
+            double srcIdx = sourceHeadFrames + ratio * sourceContentFrames;
+            int srcIdx0 = Math.Clamp((int)srcIdx, 0, sourceCurve.Length - 2);
+            int srcIdx1 = srcIdx0 + 1;
+            double frac = srcIdx - srcIdx0;
+            result[i] = (float)(sourceCurve[srcIdx0] * (1 - frac) + sourceCurve[srcIdx1] * frac);
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/DsConfig.cs b/tests/plugins/DiffSingerParamExtract/DsConfig.cs
new file mode 100644
index 00000000..9540e09b
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DsConfig.cs
@@ -0,0 +1,104 @@
+using YamlDotNet.Serialization;
+
+namespace DiffSinger;
+
+/// <summary>
+/// dsconfig.yaml model for DiffSinger model configuration.
+/// </summary>
+[Serializable]
+public class DsConfig
+{
+    public string phonemes = "phonemes.txt";
+    public string? languages;
+    public string? acoustic;
+    public string? vocoder;
+    public List<string>? speakers;
+    public int hiddenSize = 256;
+    public bool useKeyShiftEmbed;
+    public bool useSpeedEmbed;
+    public bool useEnergyEmbed;
+    public bool useBreathinessEmbed;
+    public bool useVoicingEmbed;
+    public bool useTensionEmbed;
+    public AugmentationArgs? augmentationArgs;
+    public bool useContinuousAcceleration;
+    public bool use_lang_id;
+    [YamlMember(Alias = "use_shallow_diffusion")] public bool? _useShallowDiffusion;
+    [YamlMember(Alias = "use_variable_depth")] public bool? _useVariableDepth;
+
+    [YamlIgnore]
+    public bool useVariableDepth
+    {
+        get
+        {
+            if (_useVariableDepth.HasValue) return _useVariableDepth.Value;
+            if (_useShallowDiffusion.HasValue) return _useShallowDiffusion.Value;
+            return false;
+        }
+    }
+
+    [YamlMember(Alias = "max_depth")] public double _maxDepth;
+    [YamlIgnore] public double maxDepth => useContinuousAcceleration ? _maxDepth : _maxDepth / 1000.0;
+
+    public string? dur;
+    public string? linguistic;
+    public string? pitch;
+    public string? variance;
+    public bool predict_dur = true;
+    public bool predict_energy = true;
+    public bool predict_breathiness = true;
+    public bool predict_voicing;
+    public bool predict_tension;
+    public bool use_expr;
+    public bool use_note_rest;
+    public int sample_rate = 44100;
+    public int hop_size = 512;
+    public int win_size = 2048;
+    public int fft_size = 2048;
+    public int num_mel_bins = 128;
+    public double mel_fmin = 40;
+    public double mel_fmax = 16000;
+    public string mel_base = "10";
+    public string mel_scale = "slaney";
+    public string unvoiced_phonemes = "dsunvoiced.yaml";
+
+    public float frameMs() => 1000f * hop_size / sample_rate;
+}
+
+[Serializable]
+public class RandomPitchShifting
+{
+    public float[]? range;
+}
+
+[Serializable]
+public class AugmentationArgs
+{
+    public RandomPitchShifting? randomPitchShifting;
+}
+
+/// <summary>
+/// Known DS variance parameter types.
+/// </summary>
+public static class VarianceParamTypes
+{
+    public const string Energy = "energy";
+    public const string Breathiness = "breathiness";
+    public const string Voicing = "voicing";
+    public const string Tension = "tension";
+
+    public static readonly IReadOnlyList<string> All = new[] { Energy, Breathiness, Voicing, Tension };
+
+    /// <summary>
+    /// Returns which variance params are predicted by the model according to dsconfig.
+    /// </summary>
+    public static string[] GetPredictedParams(DsConfig config)
+    {
+        var result = new List<string>();
+        if (config.predict_energy) result.Add(Energy);
+        if (config.predict_breathiness) result.Add(Breathiness);
+        if (config.predict_voicing) result.Add(Voicing);
+        if (config.predict_tension) result.Add(Tension);
+        return result.ToArray();
+    }
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/DsModelSession.cs b/tests/plugins/DiffSingerParamExtract/DsModelSession.cs
new file mode 100644
index 00000000..d46fbc2a
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/DsModelSession.cs
@@ -0,0 +1,986 @@
+using Microsoft.ML.OnnxRuntime;
+using Microsoft.ML.OnnxRuntime.Tensors;
+using System.Text;
+
+namespace DiffSinger;
+
+/// <summary>
+/// Manages DiffSinger ONNX model sessions for linguistic, duration, pitch, and variance models.
+/// Each model (dur/pitch/variance) has its own linguistic encoder per DiffSinger architecture.
+/// </summary>
+public partial class DsModelSession : IDisposable
+{
+    // ---- Dur model resources ----
+    private InferenceSession? _durLinguisticSession;
+    private InferenceSession? _durationSession;
+    private DsConfig? _durConfig;
+    private string _durDir = string.Empty;
+
+    // ---- Pitch model resources ----
+    private InferenceSession? _pitchLinguisticSession;
+    private InferenceSession? _pitchSession;
+    private DsConfig? _pitchConfig;
+    private string _pitchDir = string.Empty;
+
+    // ---- Variance model resources ----
+    private InferenceSession? _varianceLinguisticSession;
+    private InferenceSession? _varianceSession;
+    private DsConfig? _varianceConfig;
+    private string _varianceDir = string.Empty;
+
+    // ---- Shared resources ----
+    private Dictionary<string, int>? _durPhonemeTokens;
+    private Dictionary<string, int>? _pitchPhonemeTokens;
+    private Dictionary<string, int>? _variancePhonemeTokens;
+    private G2pEngine? _g2p;
+
+    public G2pEngine? G2p => _g2p;
+    public DsConfig? DurConfig => _durConfig;
+    public DsConfig? PitchConfig => _pitchConfig;
+    public DsConfig? VarianceConfig => _varianceConfig;
+    public string DurDir => _durDir;
+    public string PitchDir => _pitchDir;
+    public string VarianceDir => _varianceDir;
+
+    public bool IsDurLoaded => _durationSession != null;
+    public bool IsPitchLoaded => _pitchSession != null;
+    public bool IsVarianceLoaded => _varianceSession != null;
+
+    /// <summary>Available variance parameter names predicted by the variance model.</summary>
+    public string[] AvailableVarianceParams { get; private set; } = Array.Empty<string>();
+
+    private bool _disposed;
+    private ExecutionDevice _device = ExecutionDevice.CPU;
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        _durLinguisticSession?.Dispose();
+        _durationSession?.Dispose();
+        _pitchLinguisticSession?.Dispose();
+        _pitchSession?.Dispose();
+        _varianceLinguisticSession?.Dispose();
+        _varianceSession?.Dispose();
+        _acousticSession?.Dispose();
+        _vocoderSession?.Dispose();
+    }
+
+    // ================================================================
+    //  Session Options
+    // ================================================================
+
+    private SessionOptions CreateSessionOptions()
+    {
+        var options = new SessionOptions();
+        if (_device == ExecutionDevice.DirectML)
+        {
+            try
+            {
+                // DirectML execution provider (DML)
+                options.AppendExecutionProvider_DML(deviceId: 0);
+            }
+            catch
+            {
+                // Fall back to CPU if DirectML unavailable
+            }
+        }
+        return options;
+    }
+
+    private byte[] ReadModelBytes(string dirPath, string modelRelativePath)
+    {
+        var path = Path.Combine(dirPath, modelRelativePath);
+        if (!File.Exists(path))
+            throw new FileNotFoundException($"Model not found: {path}");
+        return File.ReadAllBytes(path);
+    }
+
+    private InferenceSession CreateSession(byte[] modelBytes)
+    {
+        var opts = CreateSessionOptions();
+        return new InferenceSession(modelBytes, opts);
+    }
+
+    // ================================================================
+    //  Model Loading
+    // ================================================================
+
+    /// <summary>Set the execution device for subsequent model loads.</summary>
+    public void SetDevice(ExecutionDevice device)
+    {
+        if (_device != device)
+        {
+            _device = device;
+            // Force reload of all models with new device
+            UnloadAll();
+        }
+    }
+
+    public ExecutionDevice GetDevice() => _device;
+
+    private void UnloadAll()
+    {
+        _durLinguisticSession?.Dispose(); _durLinguisticSession = null;
+        _durationSession?.Dispose(); _durationSession = null;
+        _pitchLinguisticSession?.Dispose(); _pitchLinguisticSession = null;
+        _pitchSession?.Dispose(); _pitchSession = null;
+        _varianceLinguisticSession?.Dispose(); _varianceLinguisticSession = null;
+        _varianceSession?.Dispose(); _varianceSession = null;
+        _acousticSession?.Dispose(); _acousticSession = null;
+        _vocoderSession?.Dispose(); _vocoderSession = null;
+        _durConfig = null; _pitchConfig = null; _varianceConfig = null;
+        _durPhonemeTokens = null; _pitchPhonemeTokens = null; _variancePhonemeTokens = null;
+        _acousticPhonemeTokens = null;
+        _durDir = _pitchDir = _varianceDir = _singerRootDir = string.Empty;
+        _speakerEmbed = null;
+    }
+
+    /// <summary>Load the dsdur model (linguistic + duration ONNX).</summary>
+    public void LoadDurModel(string dirPath)
+    {
+        if (!Directory.Exists(dirPath))
+            throw new DirectoryNotFoundException($"dsdur directory not found: {dirPath}");
+
+        _durDir = dirPath;
+        var config = LoadConfig(dirPath);
+        _durConfig = config;
+
+        // Phoneme list
+        var phonemesPath = Path.Combine(dirPath, config.phonemes);
+        if (!File.Exists(phonemesPath))
+            throw new FileNotFoundException($"Phoneme list not found: {phonemesPath}");
+        _durPhonemeTokens = DiffSingerUtils.LoadPhonemes(phonemesPath);
+
+        // Dur linguistic model
+        if (string.IsNullOrEmpty(config.linguistic))
+            throw new InvalidDataException("dsconfig.yaml missing 'linguistic' for dur model");
+        _durLinguisticSession?.Dispose();
+        _durLinguisticSession = CreateSession(ReadModelBytes(dirPath, config.linguistic));
+
+        // Duration model
+        if (string.IsNullOrEmpty(config.dur))
+            throw new InvalidDataException("dsconfig.yaml missing 'dur' field for dur model");
+        _durationSession?.Dispose();
+        _durationSession = CreateSession(ReadModelBytes(dirPath, config.dur));
+    }
+
+    /// <summary>Load the dspitch model (linguistic + pitch ONNX).</summary>
+    public void LoadPitchModel(string dirPath)
+    {
+        if (!Directory.Exists(dirPath))
+            throw new DirectoryNotFoundException($"dspitch directory not found: {dirPath}");
+
+        _pitchDir = dirPath;
+        var config = LoadConfig(dirPath);
+        _pitchConfig = config;
+
+        // Phoneme list — pitch model may have its own
+        var phonemesPath = Path.Combine(dirPath, config.phonemes);
+        if (File.Exists(phonemesPath))
+            _pitchPhonemeTokens = DiffSingerUtils.LoadPhonemes(phonemesPath);
+
+        // Pitch linguistic model
+        if (string.IsNullOrEmpty(config.linguistic))
+            throw new InvalidDataException("dsconfig.yaml missing 'linguistic' for pitch model");
+        _pitchLinguisticSession?.Dispose();
+        _pitchLinguisticSession = CreateSession(ReadModelBytes(dirPath, config.linguistic));
+
+        // Pitch model
+        if (string.IsNullOrEmpty(config.pitch))
+            throw new InvalidDataException("dsconfig.yaml missing 'pitch' field");
+        _pitchSession?.Dispose();
+        _pitchSession = CreateSession(ReadModelBytes(dirPath, config.pitch));
+    }
+
+    /// <summary>Load the dsvariance model (linguistic + variance ONNX).</summary>
+    public void LoadVarianceModel(string dirPath)
+    {
+        if (!Directory.Exists(dirPath))
+            throw new DirectoryNotFoundException($"dsvariance directory not found: {dirPath}");
+
+        _varianceDir = dirPath;
+        var config = LoadConfig(dirPath);
+        _varianceConfig = config;
+
+        // Phoneme list — variance model may have its own
+        var phonemesPath = Path.Combine(dirPath, config.phonemes);
+        if (File.Exists(phonemesPath))
+            _variancePhonemeTokens = DiffSingerUtils.LoadPhonemes(phonemesPath);
+
+        // Variance linguistic model
+        if (string.IsNullOrEmpty(config.linguistic))
+            throw new InvalidDataException("dsconfig.yaml missing 'linguistic' for variance model");
+        _varianceLinguisticSession?.Dispose();
+        _varianceLinguisticSession = CreateSession(ReadModelBytes(dirPath, config.linguistic));
+
+        // Variance model
+        if (string.IsNullOrEmpty(config.variance))
+            throw new InvalidDataException("dsconfig.yaml missing 'variance' field");
+        _varianceSession?.Dispose();
+        _varianceSession = new InferenceSession(File.ReadAllBytes(Path.Combine(dirPath, config.variance)));
+
+        // Determine predicted variance params
+        AvailableVarianceParams = VarianceParamTypes.GetPredictedParams(config);
+    }
+
+    /// <summary>
+    /// Load G2P dictionary for a specific language from the dsdur directory.
+    /// Looks for dsdict-{langCode}.yaml, falls back to dsdict.yaml.
+    /// If fallback fails, returns null (caller can decide what to do).
+    /// </summary>
+    public bool LoadG2p(string langCode)
+    {
+        if (_durDir == string.Empty)
+            throw new InvalidOperationException("Load dsdur model first before loading G2P.");
+
+        var langDictPath = Path.Combine(_durDir, $"dsdict-{langCode}.yaml");
+        if (File.Exists(langDictPath))
+        {
+            _g2p = G2pEngine.Load(langDictPath);
+            return true;
+        }
+
+        var defaultDictPath = Path.Combine(_durDir, "dsdict.yaml");
+        if (File.Exists(defaultDictPath))
+        {
+            _g2p = G2pEngine.Load(defaultDictPath);
+            return true;
+        }
+
+        _g2p = null;
+        return false;
+    }
+
+    /// <summary>Get available language codes from dsdict-*.yaml files.</summary>
+    public string[] GetAvailableLanguages()
+    {
+        if (_durDir == string.Empty) return Array.Empty<string>();
+
+        var languages = new List<string>();
+        foreach (var file in Directory.GetFiles(_durDir, "dsdict-*.yaml"))
+        {
+            var name = Path.GetFileNameWithoutExtension(file);
+            var langCode = name.Substring("dsdict-".Length);
+            if (!string.IsNullOrEmpty(langCode))
+                languages.Add(langCode);
+        }
+
+        if (File.Exists(Path.Combine(_durDir, "dsdict.yaml")))
+            languages.Insert(0, "default");
+
+        return languages.ToArray();
+    }
+
+    // ================================================================
+    //  Frame rate helpers
+    // ================================================================
+
+    public double GetFrameMs()
+    {
+        return _durConfig?.frameMs() ?? _pitchConfig?.frameMs() ?? _varianceConfig?.frameMs() ?? 10.0;
+    }
+
+    // ================================================================
+    //  Inference: DURATION
+    // ================================================================
+
+    /// <summary>
+    /// Run linguistic encoder + duration predictor.
+    /// </summary>
+    /// <param name="phonemeSequence">DS phoneme symbols (after G2P).</param>
+    /// <param name="midiTones">One MIDI tone per phoneme.</param>
+    /// <param name="noteEndTimesMs">End time in ms for each phoneme's parent note.</param>
+    /// <param name="noteStartTimeMs">Start time in ms of the first note.</param>
+    /// <param name="frameMs">Frame period from config.</param>
+    public DurInferenceResult PredictDuration(
+        string[] phonemeSequence,
+        int[] midiTones,
+        double[] noteEndTimesMs,
+        double noteStartTimeMs,
+        double frameMs,
+        int steps = 20)
+    {
+        if (_durLinguisticSession == null || _durationSession == null || _durPhonemeTokens == null)
+            throw new InvalidOperationException("dsdur model not loaded.");
+
+        // 1. Tokenize phonemes (with SP padding)
+        var paddedPhonemes = phonemeSequence.Prepend("SP").Append("SP").ToArray();
+        var tokens = paddedPhonemes.Select(p =>
+        {
+            if (!_durPhonemeTokens.TryGetValue(p, out int token))
+                throw new InvalidDataException($"Phoneme '{p}' not found in dur model phoneme list.");
+            return (long)token;
+        }).ToArray();
+
+        int nPhonemes = phonemeSequence.Length;
+        int nPadded = nPhonemes + 2;
+
+        // 2. Build note duration frames for word encoding
+        // Each phoneme belongs to a note; word boundaries are at note boundaries
+        var wordDiv = new List<long>();
+        var wordDur = new List<long>();
+        int phIdx = 0;
+        while (phIdx < nPhonemes)
+        {
+            int wordLen = 0;
+            double noteEnd = noteEndTimesMs[phIdx];
+            double wordEndMs = noteEnd;
+            // Count phonemes belonging to the same note (same end time)
+            while (phIdx < nPhonemes && Math.Abs(noteEndTimesMs[phIdx] - noteEnd) < 0.001)
+            {
+                wordLen++;
+                phIdx++;
+            }
+            wordDiv.Add(wordLen + 1); // +1 for leading SP of this word
+            // word duration in frames
+            double wordStartMs = phIdx > 0 ? noteEndTimesMs[phIdx - wordLen - 1] : noteStartTimeMs;
+            double wordDurMs = wordEndMs - wordStartMs;
+            wordDur.Add(Math.Max(1, (long)Math.Round(wordDurMs / frameMs)));
+        }
+
+        // Add head SP as separate word
+        wordDiv.Insert(0, 1);
+        wordDur.Insert(0, Math.Max(1, (long)Math.Round(8 * frameMs / frameMs))); // head frames
+
+        // Add tail SP as separate word
+        wordDiv.Add(1);
+        wordDur.Add(Math.Max(1, (long)Math.Round(8 * frameMs / frameMs))); // tail frames
+
+        var wordDivArr = wordDiv.ToArray();
+        var wordDurArr = wordDur.ToArray();
+
+        // 3. Build linguistic encoder inputs
+        var lingInputs = new List<NamedOnnxValue>();
+
+        lingInputs.Add(NamedOnnxValue.CreateFromTensor("tokens",
+            new DenseTensor<long>(tokens, new int[] { 1, nPadded })));
+
+        if (_durConfig!.predict_dur)
+        {
+            // Word encoding mode
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_div",
+                new DenseTensor<long>(wordDivArr, new int[] { 1, wordDivArr.Length })));
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_dur",
+                new DenseTensor<long>(wordDurArr, new int[] { 1, wordDurArr.Length })));
+        }
+        else
+        {
+            // Phoneme encoding mode: ph_dur from note durations
+            double prevMs = noteStartTimeMs;
+            var phDurMs = new List<long>();
+            for (int i = 0; i < nPhonemes; i++)
+            {
+                double durMs = noteEndTimesMs[i] - prevMs;
+                phDurMs.Add(Math.Max(1, (long)Math.Round(durMs / frameMs)));
+                prevMs = noteEndTimesMs[i];
+            }
+            // Add head/tail paddings
+            phDurMs.Insert(0, 8); // head frames
+            phDurMs.Add(8);       // tail frames
+            var phDurArr = phDurMs.ToArray();
+
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("ph_dur",
+                new DenseTensor<long>(phDurArr, new int[] { 1, phDurArr.Length })));
+        }
+
+        // Language IDs
+        if (_durConfig.use_lang_id && _durConfig.languages != null)
+        {
+            var langPath = Path.Combine(_durDir, _durConfig.languages);
+            if (File.Exists(langPath))
+            {
+                var langIds = DiffSingerUtils.LoadLanguageIds(langPath);
+                var langIdByPhone = paddedPhonemes
+                    .Select(p => (long)langIds.GetValueOrDefault(DiffSingerUtils.PhonemeLanguage(p), 0))
+                    .ToArray();
+                lingInputs.Add(NamedOnnxValue.CreateFromTensor("languages",
+                    new DenseTensor<long>(langIdByPhone, new int[] { 1, langIdByPhone.Length })));
+            }
+        }
+
+        // 4. Run linguistic encoder
+        var lingOutputs = _durLinguisticSession.Run(lingInputs).ToList();
+        var encoderOut = lingOutputs.First(o => o.Name == "encoder_out").AsTensor<float>();
+        var xMasks = lingOutputs.First(o => o.Name == "x_masks").AsTensor<bool>();
+
+        // 5. Run duration predictor
+        var durInputs = new List<NamedOnnxValue>();
+        durInputs.Add(NamedOnnxValue.CreateFromTensor("encoder_out", encoderOut));
+        durInputs.Add(NamedOnnxValue.CreateFromTensor("x_masks", xMasks));
+        durInputs.Add(NamedOnnxValue.CreateFromTensor("ph_midi",
+            new DenseTensor<long>(midiTones.Select(t => (long)t).ToArray(), new int[] { 1, nPhonemes })));
+
+        var durOutputs = _durationSession.Run(durInputs).ToList();
+        var durPred = durOutputs.First().AsTensor<float>();
+
+        // 6. Parse output: dur_pred should have shape [1, nPhonemes, 1] or [1, nPhonemes]
+        var durFrames = new float[nPhonemes];
+        for (int i = 0; i < nPhonemes; i++)
+        {
+            int flatIdx = i; // Assume [1, nPhonemes]
+            if (durPred.Length == nPhonemes * 1)
+                flatIdx = i;
+            else if (durPred.Length == nPhonemes)
+                flatIdx = i;
+            else
+                flatIdx = i; // Try best effort
+            durFrames[i] = durPred.ToArray()[flatIdx];
+        }
+
+        // Clamp minimum to 1 frame
+        for (int i = 0; i < durFrames.Length; i++)
+            durFrames[i] = Math.Max(1, durFrames[i]);
+
+        var durationsMs = durFrames.Select(f => f * frameMs).ToArray();
+
+        return new DurInferenceResult
+        {
+            PhonemeSymbols = phonemeSequence,
+            DurationsMs = durationsMs,
+            DurationsFrames = durFrames.Select(f => (int)Math.Round(f)).ToArray(),
+            TotalFrames = (int)Math.Round(durFrames.Sum()),
+            FrameMs = frameMs,
+        };
+    }
+
+    // ================================================================
+    //  Inference: PITCH
+    // ================================================================
+
+    /// <summary>
+    /// Run linguistic encoder + pitch predictor.
+    /// Returns per-frame pitch values (normalized cents: value * 0.01 gives semitones).
+    /// </summary>
+    public float[] PredictPitch(
+        string[] phonemeSequence,
+        int[] midiTones,
+        int[] durationsFrames,
+        int totalFrames,
+        double frameMs,
+        float expressiveness,
+        double startTimeMs,
+        int steps = 10)
+    {
+        if (_pitchLinguisticSession == null || _pitchSession == null)
+            throw new InvalidOperationException("dspitch model not loaded.");
+
+        int nPhonemes = phonemeSequence.Length;
+
+        // Tokenize
+        var tokens = phonemeSequence
+            .Prepend("SP").Append("SP")
+            .Select(p =>
+            {
+                if (_pitchPhonemeTokens != null && _pitchPhonemeTokens.TryGetValue(p, out int token))
+                    return (long)token;
+                if (_durPhonemeTokens != null && _durPhonemeTokens.TryGetValue(p, out int token2))
+                    return (long)token2;
+                return (long)0;
+            }).ToArray();
+
+        int nPadded = nPhonemes + 2;
+
+        // Build ph_dur with head/tail padding
+        var phDur = durationsFrames
+            .Select(f => (long)f)
+            .Prepend(8)  // head frames
+            .Append(8)   // tail frames
+            .ToArray();
+
+        // Build linguistic inputs
+        var lingInputs = new List<NamedOnnxValue>();
+        lingInputs.Add(NamedOnnxValue.CreateFromTensor("tokens",
+            new DenseTensor<long>(tokens, new int[] { 1, tokens.Length })));
+
+        if (_pitchConfig!.predict_dur)
+        {
+            // Simplified word encoding — use note boundaries
+            var wordDiv = new long[] { (long)(nPadded) };
+            var wordDur = new long[] { phDur.Sum() };
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_div",
+                new DenseTensor<long>(wordDiv, new int[] { 1, wordDiv.Length })));
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_dur",
+                new DenseTensor<long>(wordDur, new int[] { 1, wordDur.Length })));
+        }
+        else
+        {
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("ph_dur",
+                new DenseTensor<long>(phDur, new int[] { 1, phDur.Length })));
+        }
+
+        // Language IDs
+        if (_pitchConfig.use_lang_id && _pitchConfig.languages != null)
+        {
+            var langPath = Path.Combine(_pitchDir, _pitchConfig.languages);
+            if (File.Exists(langPath))
+            {
+                var langIds = DiffSingerUtils.LoadLanguageIds(langPath);
+                var langIdByPhone = phonemeSequence
+                    .Prepend("").Append("")
+                    .Select(p => (long)langIds.GetValueOrDefault(DiffSingerUtils.PhonemeLanguage(p), 0))
+                    .ToArray();
+                lingInputs.Add(NamedOnnxValue.CreateFromTensor("languages",
+                    new DenseTensor<long>(langIdByPhone, new int[] { 1, langIdByPhone.Length })));
+            }
+        }
+
+        // Run linguistic
+        var lingOutputs = _pitchLinguisticSession.Run(lingInputs).ToList();
+        var encoderOut = lingOutputs.First(o => o.Name == "encoder_out").AsTensor<float>();
+
+        // Build note-level info (simplified: one note per phoneme group)
+        int nNotes = phonemeSequence.Length; // Simplified: 1 phoneme = 1 "note segment"
+        var noteMidi = midiTones.Select(t => (float)t).ToArray();
+        var noteDur = durationsFrames.Select(f => (long)f).ToArray();
+        var noteRest = new bool[nNotes];
+
+        // Build initial pitch (all zeros / target MIDI)
+        var initPitch = new float[totalFrames];
+        int cumulativeFrames = 0;
+        for (int i = 0; i < nNotes && cumulativeFrames < totalFrames; i++)
+        {
+            int noteFrames = Math.Min(durationsFrames[i], totalFrames - cumulativeFrames);
+            float midiFloat = midiTones[i] * 0.01f; // Normalize to match DS convention
+            for (int f = 0; f < noteFrames; f++)
+                initPitch[cumulativeFrames + f] = midiFloat;
+            cumulativeFrames += noteFrames;
+        }
+
+        var retake = Enumerable.Repeat(true, totalFrames).ToArray();
+
+        // Build pitch model inputs
+        var pitchInputs = new List<NamedOnnxValue>();
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("encoder_out", encoderOut));
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("note_midi",
+            new DenseTensor<float>(noteMidi, new int[] { 1, nNotes })));
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("note_dur",
+            new DenseTensor<long>(noteDur, new int[] { 1, nNotes })));
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("ph_dur",
+            new DenseTensor<long>(phDur, new int[] { 1, phDur.Length })));
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("pitch",
+            new DenseTensor<float>(initPitch, new int[] { 1, totalFrames })));
+        pitchInputs.Add(NamedOnnxValue.CreateFromTensor("retake",
+            new DenseTensor<bool>(retake, new int[] { 1, totalFrames })));
+
+        // Sampling steps (use the dedicated steps parameter, not expressiveness)
+        if (_pitchConfig.useContinuousAcceleration)
+        {
+            pitchInputs.Add(NamedOnnxValue.CreateFromTensor("steps",
+                new DenseTensor<long>(new long[] { Math.Max(1, steps) }, new int[] { 1 })));
+        }
+        else
+        {
+            int speedup = Math.Max(1, 1000 / Math.Max(1, steps));
+            pitchInputs.Add(NamedOnnxValue.CreateFromTensor("speedup",
+                new DenseTensor<long>(new long[] { speedup }, new int[] { 1 })));
+        }
+
+        // Expressiveness curve (expr)
+        if (_pitchConfig.use_expr)
+        {
+            var exprCurve = Enumerable.Repeat(Math.Clamp(expressiveness / 100f, 0f, 1f), totalFrames).ToArray();
+            pitchInputs.Add(NamedOnnxValue.CreateFromTensor("expr",
+                new DenseTensor<float>(exprCurve, new int[] { 1, totalFrames })));
+        }
+
+        // Note rest
+        if (_pitchConfig.use_note_rest)
+        {
+            pitchInputs.Add(NamedOnnxValue.CreateFromTensor("note_rest",
+                new DenseTensor<bool>(noteRest, new int[] { 1, nNotes })));
+        }
+
+        // Run pitch model
+        var pitchOutputs = _pitchSession.Run(pitchInputs).ToList();
+        var pitchOut = pitchOutputs.First().AsTensor<float>().ToArray();
+
+        return pitchOut;
+    }
+
+    // ================================================================
+    //  Inference: VARIANCE
+    // ================================================================
+
+    /// <summary>
+    /// Run linguistic encoder + variance predictor.
+    /// Returns a dictionary of paramName → per-frame float values.
+    /// </summary>
+    public Dictionary<string, float[]> PredictVariance(
+        string[] phonemeSequence,
+        int[] midiTones,
+        int[] durationsFrames,
+        int totalFrames,
+        double frameMs,
+        float expressiveness,
+        float[]? existingPitch = null,
+        int steps = 20)
+    {
+        if (_varianceLinguisticSession == null || _varianceSession == null)
+            throw new InvalidOperationException("dsvariance model not loaded.");
+
+        int nPhonemes = phonemeSequence.Length;
+
+        // Tokenize
+        var tokens = phonemeSequence
+            .Prepend("SP").Append("SP")
+            .Select(p =>
+            {
+                if (_variancePhonemeTokens != null && _variancePhonemeTokens.TryGetValue(p, out int token))
+                    return (long)token;
+                if (_durPhonemeTokens != null && _durPhonemeTokens.TryGetValue(p, out int token2))
+                    return (long)token2;
+                return (long)0;
+            }).ToArray();
+
+        // Build ph_dur with padding
+        var phDur = durationsFrames
+            .Select(f => (long)f)
+            .Prepend(8)
+            .Append(8)
+            .ToArray();
+
+        // Linguistic encoder
+        var lingInputs = new List<NamedOnnxValue>();
+        lingInputs.Add(NamedOnnxValue.CreateFromTensor("tokens",
+            new DenseTensor<long>(tokens, new int[] { 1, tokens.Length })));
+
+        if (_varianceConfig!.predict_dur)
+        {
+            var wordDiv = new long[] { (long)(nPhonemes + 2) };
+            var wordDur = new long[] { phDur.Sum() };
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_div",
+                new DenseTensor<long>(wordDiv, new int[] { 1, wordDiv.Length })));
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("word_dur",
+                new DenseTensor<long>(wordDur, new int[] { 1, wordDur.Length })));
+        }
+        else
+        {
+            lingInputs.Add(NamedOnnxValue.CreateFromTensor("ph_dur",
+                new DenseTensor<long>(phDur, new int[] { 1, phDur.Length })));
+        }
+
+        if (_varianceConfig.use_lang_id && _varianceConfig.languages != null)
+        {
+            var langPath = Path.Combine(_varianceDir, _varianceConfig.languages);
+            if (File.Exists(langPath))
+            {
+                var langIds = DiffSingerUtils.LoadLanguageIds(langPath);
+                var langIdByPhone = phonemeSequence
+                    .Prepend("").Append("")
+                    .Select(p => (long)langIds.GetValueOrDefault(DiffSingerUtils.PhonemeLanguage(p), 0))
+                    .ToArray();
+                lingInputs.Add(NamedOnnxValue.CreateFromTensor("languages",
+                    new DenseTensor<long>(langIdByPhone, new int[] { 1, langIdByPhone.Length })));
+            }
+        }
+
+        var lingOutputs = _varianceLinguisticSession.Run(lingInputs).ToList();
+        var encoderOut = lingOutputs.First(o => o.Name == "encoder_out").AsTensor<float>();
+
+        // Build pitch input for variance model
+        var pitch = existingPitch ?? new float[totalFrames];
+        if (existingPitch == null)
+        {
+            int cumulativeFrames = 0;
+            for (int i = 0; i < nPhonemes && cumulativeFrames < totalFrames; i++)
+            {
+                int noteFrames = Math.Min(durationsFrames[i], totalFrames - cumulativeFrames);
+                float midiCents = midiTones[i] * 0.01f;
+                for (int f = 0; f < noteFrames; f++)
+                    pitch[cumulativeFrames + f] = midiCents;
+                cumulativeFrames += noteFrames;
+            }
+        }
+
+        // Build variance model inputs
+        var varianceInputs = new List<NamedOnnxValue>();
+        varianceInputs.Add(NamedOnnxValue.CreateFromTensor("encoder_out", encoderOut));
+        varianceInputs.Add(NamedOnnxValue.CreateFromTensor("ph_dur",
+            new DenseTensor<long>(phDur, new int[] { 1, phDur.Length })));
+        varianceInputs.Add(NamedOnnxValue.CreateFromTensor("pitch",
+            new DenseTensor<float>(pitch, new int[] { 1, totalFrames })));
+
+        // Initialize variance inputs with zeros
+        int numVariances = 0;
+        if (_varianceConfig.predict_energy)
+        {
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("energy",
+                new DenseTensor<float>(new float[totalFrames], new int[] { 1, totalFrames })));
+            numVariances++;
+        }
+        if (_varianceConfig.predict_breathiness)
+        {
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("breathiness",
+                new DenseTensor<float>(new float[totalFrames], new int[] { 1, totalFrames })));
+            numVariances++;
+        }
+        if (_varianceConfig.predict_voicing)
+        {
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("voicing",
+                new DenseTensor<float>(new float[totalFrames], new int[] { 1, totalFrames })));
+            numVariances++;
+        }
+        if (_varianceConfig.predict_tension)
+        {
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("tension",
+                new DenseTensor<float>(new float[totalFrames], new int[] { 1, totalFrames })));
+            numVariances++;
+        }
+
+        // Retake mask
+        var retake = Enumerable.Repeat(true, totalFrames * Math.Max(1, numVariances)).ToArray();
+        varianceInputs.Add(NamedOnnxValue.CreateFromTensor("retake",
+            new DenseTensor<bool>(retake, new int[] { 1, totalFrames, Math.Max(1, numVariances) })));
+
+        // Steps / speedup (use the dedicated steps parameter, not expressiveness)
+        if (_varianceConfig.useContinuousAcceleration)
+        {
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("steps",
+                new DenseTensor<long>(new long[] { Math.Max(1, steps) }, new int[] { 1 })));
+        }
+        else
+        {
+            int speedup = Math.Max(1, 1000 / Math.Max(1, steps));
+            varianceInputs.Add(NamedOnnxValue.CreateFromTensor("speedup",
+                new DenseTensor<long>(new long[] { speedup }, new int[] { 1 })));
+        }
+
+        // Run variance model
+        var varianceOutputs = _varianceSession.Run(varianceInputs).ToList();
+
+        var result = new Dictionary<string, float[]>();
+        foreach (var output in varianceOutputs)
+        {
+            var name = output.Name;
+            var tensor = output.AsTensor<float>();
+            result[name] = tensor.ToArray();
+        }
+
+        return result;
+    }
+
+    // ================================================================
+    //  Helpers
+    // ================================================================
+
+    private static DsConfig LoadConfig(string dirPath)
+    {
+        var configPath = Path.Combine(dirPath, "dsconfig.yaml");
+        if (!File.Exists(configPath))
+            throw new FileNotFoundException($"dsconfig.yaml not found in {dirPath}");
+        var yaml = File.ReadAllText(configPath);
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder()
+            .IgnoreUnmatchedProperties()
+            .Build();
+        return deserializer.Deserialize<DsConfig>(yaml);
+    }
+}
+
+/// <summary>Result of duration inference.</summary>
+public class DurInferenceResult
+{
+    public required string[] PhonemeSymbols { get; init; }
+    public required double[] DurationsMs { get; init; }
+    public required int[] DurationsFrames { get; init; }
+    public required int TotalFrames { get; init; }
+    public required double FrameMs { get; init; }
+}
+
+// ================================================================
+//  Vocoder Config (loaded from vocoder.yaml)
+// ================================================================
+
+[Serializable]
+public class DsVocoderConfig
+{
+    public string name = "vocoder";
+    public string model = "model.onnx";
+    public int sample_rate = 44100;
+    public int hop_size = 512;
+    public int win_size = 2048;
+    public int fft_size = 2048;
+    public int num_mel_bins = 128;
+    public double mel_fmin = 40;
+    public double mel_fmax = 16000;
+    public string mel_base = "10";
+    public string mel_scale = "slaney";
+    public bool pitch_controllable = false;
+
+    public float FrameMs() => 1000f * hop_size / sample_rate;
+}
+
+// ================================================================
+//  Acoustic Model & Vocoder — extensions to DsModelSession
+//  These methods are called from the session when SingerRootPath is configured.
+// ================================================================
+
+partial class DsModelSession
+{
+    // ---- Acoustic/Vocoder model resources ----
+    private InferenceSession? _acousticSession;
+    private InferenceSession? _vocoderSession;
+    private DsVocoderConfig? _vocoderConfig;
+    private Dictionary<string, int>? _acousticPhonemeTokens;
+    private string _singerRootDir = string.Empty;
+    private float[]? _speakerEmbed;
+    private int _hiddenSize = 256;
+
+    public bool IsAcousticLoaded => _acousticSession != null;
+    public bool IsVocoderLoaded => _vocoderSession != null;
+    public DsVocoderConfig? VocoderConfig => _vocoderConfig;
+
+    public void LoadAcousticModel(string rootDir)
+    {
+        if (!Directory.Exists(rootDir))
+            throw new DirectoryNotFoundException($"Singer root directory not found: {rootDir}");
+
+        _singerRootDir = rootDir;
+        var config = LoadConfig(rootDir);
+        _hiddenSize = config.hiddenSize;
+
+        if (string.IsNullOrEmpty(config.phonemes))
+            throw new InvalidDataException("dsconfig.yaml missing 'phonemes' for acoustic model");
+        var phonemesPath = Path.Combine(rootDir, config.phonemes);
+        if (!File.Exists(phonemesPath))
+            throw new FileNotFoundException($"Phoneme list not found: {phonemesPath}");
+        _acousticPhonemeTokens = DiffSingerUtils.LoadPhonemes(phonemesPath);
+
+        if (string.IsNullOrEmpty(config.acoustic))
+            throw new InvalidDataException("dsconfig.yaml missing 'acoustic' field");
+        _acousticSession?.Dispose();
+        _acousticSession = CreateSession(ReadModelBytes(rootDir, config.acoustic));
+
+        // Load speaker embedding (first speaker)
+        if (config.speakers != null && config.speakers.Count > 0)
+        {
+            var embPath = Path.Combine(rootDir, config.speakers[0] + ".emb");
+            if (File.Exists(embPath))
+            {
+                using var reader = new BinaryReader(File.OpenRead(embPath));
+                var embed = new float[_hiddenSize];
+                for (int i = 0; i < _hiddenSize && reader.BaseStream.Position < reader.BaseStream.Length; i++)
+                    embed[i] = reader.ReadSingle();
+                _speakerEmbed = embed;
+            }
+        }
+    }
+
+    public void LoadVocoder(string rootDir)
+    {
+        var config = LoadConfig(rootDir);
+        if (string.IsNullOrEmpty(config.vocoder))
+            throw new InvalidDataException("dsconfig.yaml missing 'vocoder' field");
+
+        var vocoderDir = Path.Combine(rootDir, config.vocoder);
+        if (!Directory.Exists(vocoderDir))
+            throw new DirectoryNotFoundException($"Vocoder directory not found: {vocoderDir}");
+
+        var vocoderConfigPath = Path.Combine(vocoderDir, "vocoder.yaml");
+        if (!File.Exists(vocoderConfigPath))
+            throw new FileNotFoundException($"vocoder.yaml not found: {vocoderConfigPath}");
+
+        var yaml = File.ReadAllText(vocoderConfigPath);
+        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder()
+            .IgnoreUnmatchedProperties()
+            .Build();
+        _vocoderConfig = deserializer.Deserialize<DsVocoderConfig>(yaml);
+
+        var modelPath = Path.Combine(vocoderDir, _vocoderConfig.model);
+        if (!File.Exists(modelPath))
+            throw new FileNotFoundException($"Vocoder model not found: {modelPath}");
+
+        _vocoderSession?.Dispose();
+        _vocoderSession = CreateSession(File.ReadAllBytes(modelPath));
+    }
+
+    public int AcousticPhonemeTokenize(string phoneme)
+    {
+        if (_acousticPhonemeTokens == null)
+            throw new InvalidOperationException("Acoustic model not loaded.");
+        return _acousticPhonemeTokens.TryGetValue(phoneme, out int token) ? token : 0;
+    }
+
+    public Tensor<float> PredictAcoustic(
+        string[] phonemeSequence, int[] durationsFrames, float[] f0Hz,
+        int totalFrames, int steps, float depth,
+        Dictionary<string, float[]>? varianceParams = null)
+    {
+        if (_acousticSession == null || _acousticPhonemeTokens == null)
+            throw new InvalidOperationException("Acoustic model not loaded.");
+
+        var config = LoadConfig(_singerRootDir);
+        int headFrames = 8, tailFrames = 8;
+
+        var tokens = phonemeSequence
+            .Prepend("SP").Append("SP")
+            .Select(p => (long)AcousticPhonemeTokenize(p))
+            .ToArray();
+
+        var durations = durationsFrames
+            .Select(f => (long)f)
+            .Prepend(headFrames).Append(tailFrames)
+            .ToArray();
+
+        var inputs = new List<NamedOnnxValue>();
+        inputs.Add(NamedOnnxValue.CreateFromTensor("tokens", new DenseTensor<long>(tokens, new[] { 1, tokens.Length })));
+        inputs.Add(NamedOnnxValue.CreateFromTensor("durations", new DenseTensor<long>(durations, new[] { 1, durations.Length })));
+        inputs.Add(NamedOnnxValue.CreateFromTensor("f0", new DenseTensor<float>(f0Hz, new[] { 1, totalFrames })));
+
+        if (config.useContinuousAcceleration)
+        {
+            if (config.useVariableDepth)
+                inputs.Add(NamedOnnxValue.CreateFromTensor("depth", new DenseTensor<float>(new[] { depth }, new[] { 1 })));
+            inputs.Add(NamedOnnxValue.CreateFromTensor("steps", new DenseTensor<long>(new[] { (long)Math.Max(1, steps) }, new[] { 1 })));
+        }
+        else
+        {
+            int speedup = Math.Max(1, 1000 / Math.Max(1, steps));
+            inputs.Add(NamedOnnxValue.CreateFromTensor("speedup", new DenseTensor<long>(new[] { (long)speedup }, new[] { 1 })));
+        }
+
+        if (config.use_lang_id && !string.IsNullOrEmpty(config.languages))
+        {
+            var langIds = phonemeSequence.Select(p => (long)0).Prepend(0).Append(0).ToArray();
+            inputs.Add(NamedOnnxValue.CreateFromTensor("languages", new DenseTensor<long>(langIds, new[] { 1, langIds.Length })));
+        }
+
+        if (config.speakers != null && config.speakers.Count > 0 && _speakerEmbed != null)
+        {
+            var spk = new float[totalFrames * _hiddenSize];
+            for (int i = 0; i < totalFrames; i++)
+                Array.Copy(_speakerEmbed, 0, spk, i * _hiddenSize, _hiddenSize);
+            inputs.Add(NamedOnnxValue.CreateFromTensor("spk_embed", new DenseTensor<float>(spk, new[] { 1, totalFrames, _hiddenSize })));
+        }
+
+        if (varianceParams != null)
+        {
+            foreach (var (name, curve) in varianceParams)
+            {
+                if (curve != null && curve.Length > 0)
+                    inputs.Add(NamedOnnxValue.CreateFromTensor(name, new DenseTensor<float>(curve.Take(totalFrames).ToArray(), new[] { 1, totalFrames })));
+            }
+        }
+
+        var outputs = _acousticSession.Run(inputs).ToList();
+        return outputs.First().AsTensor<float>();
+    }
+
+    public float[] PredictVocoder(Tensor<float> mel, float[] f0Hz)
+    {
+        if (_vocoderSession == null || _vocoderConfig == null)
+            throw new InvalidOperationException("Vocoder not loaded.");
+
+        var inputs = new List<NamedOnnxValue>();
+        inputs.Add(NamedOnnxValue.CreateFromTensor("mel", mel));
+        inputs.Add(NamedOnnxValue.CreateFromTensor("f0", new DenseTensor<float>(f0Hz, new[] { 1, f0Hz.Length })));
+
+        var outputs = _vocoderSession.Run(inputs).ToList();
+        var tensor = outputs.First().AsTensor<float>();
+        var samples = new float[tensor.Length];
+        for (int i = 0; i < tensor.Length; i++) samples[i] = tensor.ToArray()[i];
+        return samples;
+    }
+
+    public static double ToneToFreq(double tone) => 440.0 * Math.Pow(2.0, (tone - 69.0) / 12.0);
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/G2pDictionary.cs b/tests/plugins/DiffSingerParamExtract/G2pDictionary.cs
new file mode 100644
index 00000000..0250a625
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/G2pDictionary.cs
@@ -0,0 +1,267 @@
+using System.Text.RegularExpressions;
+using YamlDotNet.Serialization;
+
+namespace DiffSinger;
+
+/// <summary>
+/// DiffSinger G2P dictionary data model (YAML-based).
+/// Supports both legacy format (dictionary + symbols with vowel bool)
+/// and the current DiffSinger format (entries + symbols with type string).
+/// </summary>
+public class DiffSingerG2pDictionaryData
+{
+    public struct Replacement
+    {
+        public string from;
+        public string to;
+    }
+
+    // Current DiffSinger format
+    public List<EntryV2>? entries;
+    public List<SymbolV2>? symbols;
+
+    // Legacy format
+    public List<SymbolEntry>? legacy_symbols;
+    public List<DictionaryEntry>? dictionary;
+    public Replacement[]? replacements;
+
+    public Dictionary<string, string> replacementsDict()
+    {
+        var dict = new Dictionary<string, string>();
+        if (replacements != null)
+        {
+            foreach (var r in replacements)
+            {
+                dict[r.from] = r.to;
+            }
+        }
+        return dict;
+    }
+}
+
+/// <summary>Symbol entry in current DiffSinger format (type as string).</summary>
+public class SymbolV2
+{
+    [YamlMember(Alias = "symbol")]
+    public string Symbol { get; set; } = string.Empty;
+
+    [YamlMember(Alias = "type")]
+    public string Type { get; set; } = string.Empty;
+
+    public bool IsVowel => Type == "vowel";
+}
+
+/// <summary>Dictionary entry in current DiffSinger format (entries array).</summary>
+public class EntryV2
+{
+    [YamlMember(Alias = "grapheme")]
+    public string Grapheme { get; set; } = string.Empty;
+
+    [YamlMember(Alias = "phonemes")]
+    public List<string>? Phonemes { get; set; }
+}
+
+/// <summary>Legacy symbol entry (vowel as bool).</summary>
+public class SymbolEntry
+{
+    public string symbol = string.Empty;
+    public bool? vowel;
+}
+
+/// <summary>Legacy dictionary entry (phonemes as space-separated string).</summary>
+public class DictionaryEntry
+{
+    public string grapheme = string.Empty;
+    public string phonemes = string.Empty;
+}
+
+/// <summary>
+/// Simple G2P (grapheme-to-phoneme) engine that queries a dictionary.
+/// </summary>
+public class G2pEngine
+{
+    private readonly Dictionary<string, string[]> _dict = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _symbols = new();
+    private readonly HashSet<string> _vowels = new();
+    private readonly Dictionary<string, string> _replacements = new();
+
+    /// <summary>All known phoneme symbols.</summary>
+    public IReadOnlySet<string> Symbols => _symbols;
+
+    /// <summary>Vowel symbols.</summary>
+    public IReadOnlySet<string> Vowels => _vowels;
+
+    public bool IsValidSymbol(string symbol) => _symbols.Contains(symbol);
+    public bool IsVowel(string symbol) => _vowels.Contains(symbol);
+
+    /// <summary>
+    /// Load from a YAML dictionary file.
+    /// Supports both legacy format and current DiffSinger format.
+    /// </summary>
+    public static G2pEngine Load(string yamlPath)
+    {
+        var engine = new G2pEngine();
+
+        var yaml = File.ReadAllText(yamlPath);
+        var deserializer = new DeserializerBuilder()
+            .IgnoreUnmatchedProperties()
+            .Build();
+        var data = deserializer.Deserialize<DiffSingerG2pDictionaryData>(yaml);
+
+        // Load symbols (current DiffSinger format: type: vowel/consonant)
+        if (data.symbols != null)
+        {
+            foreach (var entry in data.symbols)
+            {
+                var sym = entry.Symbol?.Trim();
+                if (!string.IsNullOrEmpty(sym))
+                {
+                    engine._symbols.Add(sym);
+                    if (entry.IsVowel)
+                        engine._vowels.Add(sym);
+                }
+            }
+        }
+
+        // Load symbols (legacy format: vowel: true/false)
+        if (data.legacy_symbols != null)
+        {
+            foreach (var entry in data.legacy_symbols)
+            {
+                var sym = entry.symbol.Trim();
+                if (!string.IsNullOrEmpty(sym))
+                {
+                    engine._symbols.Add(sym);
+                    if (entry.vowel == true)
+                        engine._vowels.Add(sym);
+                }
+            }
+        }
+
+        // SP and AP are always vowels
+        engine._symbols.Add("SP");
+        engine._symbols.Add("AP");
+        engine._vowels.Add("SP");
+        engine._vowels.Add("AP");
+
+        // Load replacements
+        if (data.replacements != null)
+        {
+            foreach (var r in data.replacements)
+            {
+                engine._replacements[r.from] = r.to;
+            }
+        }
+
+        // Load dictionary entries (current format: entries array with phonemes list)
+        if (data.entries != null)
+        {
+            foreach (var entry in data.entries)
+            {
+                var grapheme = entry.Grapheme?.Trim();
+                if (string.IsNullOrEmpty(grapheme) || entry.Phonemes == null || entry.Phonemes.Count == 0)
+                    continue;
+
+                var phonemes = entry.Phonemes
+                    .Select(p => p?.Trim() ?? string.Empty)
+                    .Where(p => p.Length > 0)
+                    .ToArray();
+
+                if (phonemes.Length > 0)
+                {
+                    engine._dict[grapheme] = phonemes;
+                }
+            }
+        }
+
+        // Load dictionary entries (legacy format: dictionary array with space-separated phonemes)
+        if (data.dictionary != null)
+        {
+            foreach (var entry in data.dictionary)
+            {
+                var grapheme = entry.grapheme.Trim();
+                var phonemeStr = entry.phonemes.Trim();
+                var phonemes = Regex.Split(phonemeStr, @"\s+")
+                    .Where(p => !string.IsNullOrEmpty(p))
+                    .ToArray();
+
+                if (!string.IsNullOrEmpty(grapheme) && phonemes.Length > 0)
+                {
+                    engine._dict[grapheme] = phonemes;
+                }
+            }
+        }
+
+        return engine;
+    }
+
+    /// <summary>
+    /// Query G2P for a lyric. Returns the phoneme sequence or null if not found.
+    /// If not found in exact match, finds the closest entry by edit distance.
+    /// </summary>
+    public string[]? Query(string lyric)
+    {
+        if (string.IsNullOrEmpty(lyric))
+            return null;
+
+        // Exact match
+        if (_dict.TryGetValue(lyric, out var result))
+            return result;
+
+        // Lowercase match
+        if (_dict.TryGetValue(lyric.ToLowerInvariant(), out result))
+            return result;
+
+        // No match found - find closest by edit distance
+        return FindClosest(lyric);
+    }
+
+    private string[]? FindClosest(string input)
+    {
+        if (_dict.Count == 0) return null;
+
+        var lower = input.ToLowerInvariant();
+        int bestDist = int.MaxValue;
+        string? bestKey = null;
+
+        foreach (var key in _dict.Keys)
+        {
+            int dist = LevenshteinDistance(lower, key.ToLowerInvariant());
+            if (dist < bestDist)
+            {
+                bestDist = dist;
+                bestKey = key;
+            }
+        }
+
+        // If the best distance is reasonable (within half the input length)
+        if (bestKey != null && bestDist <= Math.Max(1, lower.Length / 2))
+        {
+            return _dict[bestKey];
+        }
+
+        return null;
+    }
+
+    private static int LevenshteinDistance(string a, string b)
+    {
+        int m = a.Length, n = b.Length;
+        var dp = new int[m + 1, n + 1];
+
+        for (int i = 0; i <= m; i++) dp[i, 0] = i;
+        for (int j = 0; j <= n; j++) dp[0, j] = j;
+
+        for (int i = 1; i <= m; i++)
+        {
+            for (int j = 1; j <= n; j++)
+            {
+                int cost = a[i - 1] == b[j - 1] ? 0 : 1;
+                dp[i, j] = Math.Min(
+                    Math.Min(dp[i - 1, j] + 1, dp[i, j - 1] + 1),
+                    dp[i - 1, j - 1] + cost);
+            }
+        }
+
+        return dp[m, n];
+    }
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/VarianceMapping.cs b/tests/plugins/DiffSingerParamExtract/VarianceMapping.cs
new file mode 100644
index 00000000..e81b4468
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/VarianceMapping.cs
@@ -0,0 +1,100 @@
+namespace DiffSinger;
+
+/// <summary>
+/// Defines a mapping from a DS variance parameter to a target engine parameter.
+/// </summary>
+public class VarianceMapping
+{
+    /// <summary>DS variance parameter name (e.g., "tension", "breathiness").</summary>
+    public string SourceParam { get; set; } = string.Empty;
+
+    /// <summary>Target engine parameter abbreviation (e.g., "TENC", "BRE").</summary>
+    public string TargetParam { get; set; } = string.Empty;
+
+    /// <summary>Display name for the mapping.</summary>
+    public string DisplayName => $"{SourceParam} → {TargetParam}";
+}
+
+/// <summary>
+/// Apply mode for the plugin.
+/// </summary>
+public enum ApplyMode
+{
+    SelectedNotes,
+    WholeTrack
+}
+
+/// <summary>
+/// Execution provider for ONNX inference.
+/// </summary>
+public enum ExecutionDevice
+{
+    CPU,
+    DirectML
+}
+
+/// <summary>
+/// Stores the configuration state for the DiffSinger for TuneLab plugin.
+/// Mirrors all key settings from OpenUtau's DiffSinger preferences.
+/// </summary>
+public class PluginConfig
+{
+    // ================================================================
+    //  Model Paths
+    // ================================================================
+    public string DurModelPath { get; set; } = string.Empty;       // dsdur/ subdirectory
+    public string PitchModelPath { get; set; } = string.Empty;     // dspitch/ subdirectory
+    public string VarianceModelPath { get; set; } = string.Empty;  // dsvariance/ subdirectory
+    public string SingerRootPath { get; set; } = string.Empty;     // Singer root (acoustic model + vocoder)
+
+    // ================================================================
+    //  Language
+    // ================================================================
+    public string Language { get; set; } = "default";
+
+    // ================================================================
+    //  Execution Device (mirrors OpenUtau OnnxRunner)
+    // ================================================================
+    public ExecutionDevice Device { get; set; } = ExecutionDevice.CPU;
+    public int GpuIndex { get; set; } = 0;  // DirectML GPU device index
+
+    // ================================================================
+    //  Rendering Steps (mirrors OpenUtau DiffSingerSteps*)
+    // ================================================================
+    public int DurSteps { get; set; } = 20;         // Duration model steps
+    public int AcousticSteps { get; set; } = 20;    // Acoustic model steps (DiffSingerSteps)
+    public int PitchSteps { get; set; } = 10;       // Pitch model steps (DiffSingerStepsPitch)
+    public int VarianceSteps { get; set; } = 20;    // Variance model steps (DiffSingerStepsVariance)
+
+    // ================================================================
+    //  Diffusion Depth (mirrors OpenUtau DiffSingerDepth)
+    // ================================================================
+    public double DiffusionDepth { get; set; } = 1.0;
+
+    // ================================================================
+    //  Performance Sliders
+    // ================================================================
+    public float Expressiveness { get; set; } = 100f;
+    public float BlendPercent { get; set; } = 100f;
+
+    // ================================================================
+    //  Advanced Toggles (mirrors OpenUtau DiffSinger* flags)
+    // ================================================================
+    public bool TensorCache { get; set; } = true;                            // DiffSingerTensorCache
+    public bool VarianceLocalPitchPatch { get; set; } = true;               // DiffSingerVarianceLocalPitchPatch
+    public bool UnvoicedF0Interpolate { get; set; } = true;                 // DiffSingerUnvoicedConsonantAcousticF0Interpolate
+    public bool DiscardOnMismatch { get; set; } = true;
+
+    // ================================================================
+    //  Apply Mode
+    // ================================================================
+    public ApplyMode Mode { get; set; } = ApplyMode.SelectedNotes;
+
+    // ================================================================
+    //  Variance Mappings (DS param → target engine param)
+    // ================================================================
+    public List<VarianceMapping> VarianceMappings { get; set; } = new();
+
+    /// <summary>Get the blend factor (0..1).</summary>
+    public float BlendFactor => BlendPercent / 100f;
+}
\ No newline at end of file
diff --git a/tests/plugins/DiffSingerParamExtract/description.json b/tests/plugins/DiffSingerParamExtract/description.json
new file mode 100644
index 00000000..b4f94da5
--- /dev/null
+++ b/tests/plugins/DiffSingerParamExtract/description.json
@@ -0,0 +1,10 @@
+{
+  "id": "com.tunelab.diffSinger",
+  "name": "DiffSinger",
+  "version": "1.0.0",
+  "author": "TuneLab Plugins",
+  "description": "Full DiffSinger voice engine: auto-scan voicebanks, G2P, dur/pitch/variance, acoustic model, vocoder, variance mapping.",
+  "sdk-version": "1.0",
+  "type": "voice",
+  "assemblies": ["DiffSinger.dll"]
+}
\ No newline at end of file
diff --git a/tests/tmpverify/verify.cs b/tests/tmpverify/verify.cs
new file mode 100644
index 00000000..d748f78d
--- /dev/null
+++ b/tests/tmpverify/verify.cs
@@ -0,0 +1,9 @@
+using System.Reflection;
+var asm = Assembly.LoadFrom(@"d:\Documents\Repository\Tunelab\tests\packages\DiffSinger\DiffSinger.dll");
+System.Console.WriteLine("DLL: " + asm.FullName);
+foreach(var t in asm.GetExportedTypes()) {
+    foreach(var a in t.GetCustomAttributesData()) {
+        if (a.AttributeType.Name.Contains("VoiceEngine"))
+            System.Console.WriteLine($"FOUND: {t.FullName} -> engineType='{a.ConstructorArguments[0].Value}'");
+    }
+}
diff --git a/tests/tmpverify/verify.csproj b/tests/tmpverify/verify.csproj
new file mode 100644
index 00000000..97af7c8c
--- /dev/null
+++ b/tests/tmpverify/verify.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net8.0</TargetFramework></PropertyGroup>
+  <ItemGroup>
+    <Reference Include="TuneLab.Foundation" HintPath="D:\Documents\Repository\Tunelab\TuneLab.Foundation\bin\Debug\net8.0\TuneLab.Foundation.dll" />
+    <Reference Include="TuneLab.SDK" HintPath="D:\Documents\Repository\Tunelab\TuneLab.SDK\bin\Debug\net8.0\TuneLab.SDK.dll" />
+  </ItemGroup>
+</Project>

From 7d9ba6f6b3fc28d1c85d290c05bd68c00ebffc1e Mon Sep 17 00:00:00 2001
From: tachengP <2638591622@qq.com>
Date: Sat, 20 Jun 2026 13:26:46 +0800
Subject: [PATCH 2/3] =?UTF-8?q?=E4=B8=BADiffSinger=20for=20TuneLab?=
 =?UTF-8?q?=E6=96=B0=E5=A2=9E=E5=8A=9F=E8=83=BD=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../ControllerConfigs/PhonemeEditorConfig.cs  |  45 ++++
 TuneLab.SDK/Voice/SynthesizedParameter.cs     |   5 +
 TuneLab/GUI/Assets.cs                         |   2 +
 .../Controllers/PropertyObjectController.cs   | 223 ++++++++++++++++++
 .../ParameterArea/AutomationRenderer.cs       |  32 ++-
 5 files changed, 303 insertions(+), 4 deletions(-)
 create mode 100644 TuneLab.SDK/ControllerConfigs/PhonemeEditorConfig.cs

diff --git a/TuneLab.SDK/ControllerConfigs/PhonemeEditorConfig.cs b/TuneLab.SDK/ControllerConfigs/PhonemeEditorConfig.cs
new file mode 100644
index 00000000..289a4fb8
--- /dev/null
+++ b/TuneLab.SDK/ControllerConfigs/PhonemeEditorConfig.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+
+namespace TuneLab.SDK;
+
+/// <summary>一个音素条目（含语言前缀与符号）。</summary>
+public sealed class PhonemeEntry
+{
+    /// <summary>完整符号，如 "ja/b" 或 "zh/a"。</summary>
+    public string Symbol { get; set; } = string.Empty;
+    /// <summary>是否是元音</summary>
+    public bool IsVowel { get; set; }
+    /// <summary>是否是滑音</summary>
+    public bool IsGlide { get; set; }
+}
+
+/// <summary>
+/// 音素编辑器控件配置：在属性面板中渲染一个可编辑的音素列表（辅音/元音分组）。
+/// 数据通过 dataKey 绑定到 PropertyObject 的字符串字段（JSON 格式）。
+/// </summary>
+public sealed class PhonemeEditorConfig : IControllerConfig
+{
+    public required string DisplayText { get; init; }
+
+    /// <summary>在 PropertyObject 中存储音素 JSON 的 key。</summary>
+    public string DataKey { get; init; } = "_phonemes";
+
+    /// <summary>当前音素列表（只读快照，用于 UI 渲染）。</summary>
+    public IReadOnlyList<PhonemeEntry> Phonemes { get; init; } = Array.Empty<PhonemeEntry>();
+
+    /// <summary>可用语言的列表（前缀选项）。</summary>
+    public IReadOnlyList<string> AvailableLanguages { get; init; } = Array.Empty<string>();
+
+    /// <summary>语言属性在 PropertyObject 中的 key。</summary>
+    public string LanguageDataKey { get; init; } = "language";
+
+    /// <summary>添加辅音时的回调（参数：更新后的 JSON）。</summary>
+    public Action<string>? OnChanged { get; init; }
+
+    /// <summary>辅音是否能删除（至少保留一个）。</summary>
+    public bool CanDeleteConsonant { get; init; } = true;
+
+    /// <summary>元音是否能删除（至少保留一个）。</summary>
+    public bool CanDeleteVowel { get; init; } = true;
+}
diff --git a/TuneLab.SDK/Voice/SynthesizedParameter.cs b/TuneLab.SDK/Voice/SynthesizedParameter.cs
index b8948fae..c93bade2 100644
--- a/TuneLab.SDK/Voice/SynthesizedParameter.cs
+++ b/TuneLab.SDK/Voice/SynthesizedParameter.cs
@@ -12,4 +12,9 @@ public sealed class SynthesizedParameter
     // 各连续段，按时间升序、互不重叠；段内 Points 为 (全局秒, 值) 折线。
     // 空集合 = 整条无值；段间间隙 = NaN 区（绘制断开）。
     public required IReadOnlyList<IReadOnlyList<Point>> Segments { get; init; }
+
+    // 每段的透明度渐变控制点（可选）。每段对应一组 Point，每个 Point 的 X=相对位置(0~1), Y=透明度(0~1)。
+    // 渲染器据此创建 LinearGradientBrush 的多 GradientStop，实现像素级平滑渐变。
+    // null = 整段使用默认透明度 0.25。
+    public IReadOnlyList<IReadOnlyList<Point>>? SegmentOpacityStops { get; init; }
 }
diff --git a/TuneLab/GUI/Assets.cs b/TuneLab/GUI/Assets.cs
index 03f59d69..b4ba1ac5 100644
--- a/TuneLab/GUI/Assets.cs
+++ b/TuneLab/GUI/Assets.cs
@@ -57,6 +57,8 @@ internal static class Assets
     public static SvgIcon General = new("<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n<path d=\"M15.4227 5.07227C15.7799 5.07227 16.1102 5.26287 16.2889 5.57227L19.7117 11.5C19.8902 11.8093 19.8902 12.1907 19.7117 12.5L16.2889 18.4277C16.1102 18.7371 15.7799 18.9277 15.4227 18.9277H8.57697C8.21985 18.9276 7.8903 18.737 7.71173 18.4277L4.28888 12.5C4.11025 12.1906 4.11025 11.8094 4.28888 11.5L7.71173 5.57227C7.8903 5.26298 8.21985 5.0724 8.57697 5.07227H15.4227ZM11.9998 9C10.343 9.0001 8.99982 10.3432 8.99982 12C8.99982 13.6568 10.343 14.9999 11.9998 15C13.6567 15 14.9998 13.6569 14.9998 12C14.9998 10.3431 13.6567 9 11.9998 9Z\" fill=\"white\"/>\n</svg>");
     public static SvgIcon Appearance = new("<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n<path d=\"M12 21C15 21 11 17 12 15C13.5 12 20 18 20 11.9999C20 5.99985 15.5 3 12 3C8.5 3 4 6 4 11.9999C4 17 8 21 12 21Z\" stroke=\"white\" stroke-width=\"2\" stroke-miterlimit=\"1.01391\" stroke-linejoin=\"round\"/>\n<circle cx=\"8\" cy=\"10.5\" r=\"1.5\" fill=\"white\"/>\n<circle cx=\"10\" cy=\"7.5\" r=\"1.5\" fill=\"white\"/>\n<circle cx=\"14\" cy=\"7.5\" r=\"1.5\" fill=\"white\"/>\n<circle cx=\"16\" cy=\"10.5\" r=\"1.5\" fill=\"white\"/>\n</svg>");
     public static SvgIcon Editing = new("<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n<rect width=\"16\" height=\"1\" rx=\"0.5\" transform=\"matrix(1 0 0 -1 4 19)\" fill=\"white\"/>\n<path d=\"M16 6C16.6011 6 17.1422 6.20275 17.4697 6.53027C17.8087 6.86923 18.0098 7.41087 18.0078 8.00488C18.0058 8.59988 17.8005 9.13897 17.4697 9.46973L8.68945 18.25H5.75V15.3105L14.5303 6.53027C14.8578 6.20276 15.3989 6 16 6Z\" stroke=\"white\" stroke-width=\"1.5\"/>\n<line x1=\"13.5303\" y1=\"7.46967\" x2=\"16.5303\" y2=\"10.4697\" stroke=\"white\" stroke-width=\"1.5\"/>\n</svg>");
+    public static SvgIcon PhonemeAdd = new("<svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n<path d=\"M3 8H13M8 3V13\" stroke=\"white\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n</svg>");
+    public static SvgIcon PhonemeDelete = new("<svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n<path d=\"M4 8H12\" stroke=\"white\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n</svg>");
     public static SvgIcon None = new("");
 
     public static FontFamily NotoMono = new FontFamily("NotoMono");
diff --git a/TuneLab/GUI/Controllers/PropertyObjectController.cs b/TuneLab/GUI/Controllers/PropertyObjectController.cs
index 814484fb..70483580 100644
--- a/TuneLab/GUI/Controllers/PropertyObjectController.cs
+++ b/TuneLab/GUI/Controllers/PropertyObjectController.cs
@@ -370,6 +370,228 @@ public override void Dispose()
         readonly Components.CheckBox mController;
     }
 
+    // 音素编辑器控件
+    class PhonemeEditorCreator : Creator
+    {
+        public PhonemeEditorCreator(PropertyObjectController parent, string key, PhonemeEditorConfig config) : base(parent)
+        {
+            mKey = key;
+            mPanel = ObjectPoolManager.Get<StackPanel>();
+            mPanel.Margin = new(0, 8);
+            mDataProp = Parent.DataObject.StringField(config.DataKey, "[]");
+
+            // 监听语言属性变化：当语言被用户（而非音素编辑器）修改时，清除自定义音素以强制 G2P 重生
+            if (!string.IsNullOrEmpty(config.LanguageDataKey))
+            {
+                mLangField = Parent.DataObject.ValueField(config.LanguageDataKey, PropertyValue.Create(string.Empty));
+                mLangField.Modified.Subscribe(OnLanguageFieldChanged, s);
+            }
+
+            Apply(config);
+        }
+
+        // 语言属性被外部（语言下拉）修改时清除自定义音素
+        void OnLanguageFieldChanged()
+        {
+            if (mSettingLanguage) return; // 音素编辑器自身提交导致的语言变更，不理
+            if (mLangField == null) return;
+            var curVal = mLangField.Value.ToString(out var lang) ? lang : string.Empty;
+            if (string.IsNullOrEmpty(curVal) || curVal == "multi")
+                return; // 空或 multi 不清除
+            // 用户主动选择了具体语言 → 清除自定义音素，强制 G2P 重生
+            mDataProp.Set("[]");
+        }
+
+        static string Serialize(IReadOnlyList<PhonemeEntry> phonemes)
+        {
+            var sb = new System.Text.StringBuilder();
+            sb.Append('[');
+            for (int i = 0; i < phonemes.Count; i++)
+            {
+                if (i > 0) sb.Append(',');
+                sb.Append("{\"s\":\"");
+                sb.Append(phonemes[i].Symbol.Replace("\\", "\\\\").Replace("\"", "\\\""));
+                sb.Append("\",\"v\":");
+                sb.Append(phonemes[i].IsVowel ? "true" : "false");
+                sb.Append('}');
+            }
+            sb.Append(']');
+            return sb.ToString();
+        }
+
+        void Commit(IReadOnlyList<PhonemeEntry> phonemes)
+        {
+            var json = Serialize(phonemes);
+            mDataProp.Set(json);
+            // 从音素符号中检测语言，回写语言属性
+            DetectAndSetLanguage(phonemes);
+            if (mConfig.OnChanged != null)
+                mConfig.OnChanged(json);
+        }
+
+        // 从音素符号中检测语言，回写语言属性。设 mSettingLanguage 标志以阻止 OnLanguageFieldChanged 清除音素。
+        void DetectAndSetLanguage(IReadOnlyList<PhonemeEntry> phonemes)
+        {
+            string? detectedLang = null;
+            bool mixed = false;
+            foreach (var ph in phonemes)
+            {
+                int idx = ph.Symbol.IndexOf('/');
+                if (idx < 0) continue;
+                string lang = ph.Symbol.Substring(0, idx);
+                if (detectedLang == null)
+                    detectedLang = lang;
+                else if (detectedLang != lang)
+                {
+                    mixed = true;
+                    break;
+                }
+            }
+            if (detectedLang == null) return;
+
+            string langKey = mConfig.LanguageDataKey;
+            string newLang = mixed ? "multi" : detectedLang;
+            var current = Parent.DataObject.GetValue(langKey, PropertyValue.Create(string.Empty));
+            if (current.ToString(out var curStr) && curStr == newLang)
+                return;
+            mSettingLanguage = true;
+            try { Parent.DataObject.SetValue(langKey, PropertyValue.Create(newLang)); }
+            finally { mSettingLanguage = false; }
+        }
+
+        // 字段
+        bool mSettingLanguage;
+        IDataProperty<PropertyValue>? mLangField;
+
+        void Apply(PhonemeEditorConfig config)
+        {
+            mPanel.Children.Clear();
+            mConfig = config;
+
+            var title = CreateTitle(config.DisplayText ?? mKey, 26);
+            mPanel.Children.Add(title);
+
+            RenderGroup("  Consonant", config.Phonemes.Where(p => !p.IsVowel).ToList(), isVowel: false);
+            RenderGroup("  Vowel", config.Phonemes.Where(p => p.IsVowel).ToList(), isVowel: true);
+        }
+
+        void RenderGroup(string label, List<PhonemeEntry> entries, bool isVowel)
+        {
+            var lbl = new Label { Content = label, FontSize = 11, Foreground = Style.LIGHT_WHITE.ToBrush(), Margin = new(24, 4, 0, 2) };
+            mPanel.Children.Add(lbl);
+
+            foreach (var phoneme in entries)
+            {
+                var row = CreatePhonemeRow(phoneme, isVowel);
+                mPanel.Children.Add(row);
+            }
+        }
+
+        // 布局：[lang↓(70px左)] [音素(弹性拉伸)] [+(22px)] [-(22px最右)]
+        // 注意 DockPanel LastChildFill=true，最后一个添加的 child 填充剩余空间
+        DockPanel CreatePhonemeRow(PhonemeEntry phoneme, bool isVowel)
+        {
+            int rowH = 24;
+            var dock = new DockPanel { Height = rowH + 4, Margin = new(24, 2, 24, 2) };
+            int phIdx = mConfig.Phonemes.IndexOf(phoneme);
+
+            // 1. 左端：语言前缀下拉（70px，无前缀时显示「??」）
+            string langPrefix = phoneme.Symbol.Contains('/') ? phoneme.Symbol.Split('/')[0] : "??";
+            var langCombo = new DropDown { Height = rowH, Width = 70, FontSize = 11, MinHeight = rowH, MaxHeight = rowH, Padding = new(6, 0) };
+            langCombo.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
+            foreach (var l in mConfig.AvailableLanguages) langCombo.Items.Add(l);
+            langCombo.SelectedItem = langPrefix;
+            langCombo.PlaceholderText = "??";
+            int capIdx2 = phIdx;
+            langCombo.SelectionChanged += (_, _) =>
+            {
+                if (capIdx2 < mConfig.Phonemes.Count && langCombo.SelectedItem is string newLang)
+                {
+                    var list = mConfig.Phonemes.ToList();
+                    if (capIdx2 < list.Count)
+                    {
+                        var entry = list[capIdx2];
+                        string p = entry.Symbol.Contains('/') ? entry.Symbol.Split('/')[1] : entry.Symbol;
+                        list[capIdx2] = new PhonemeEntry { Symbol = $"{newLang}/{p}", IsVowel = isVowel };
+                        Commit(list);
+                    }
+                }
+            };
+            DockPanel.SetDock(langCombo, Dock.Left);
+            dock.Children.Add(langCombo);
+
+            // 2. 右端：删除按钮（-）始终显示，仅一个时半透明
+            bool canDelete = isVowel ? mConfig.CanDeleteVowel : mConfig.CanDeleteConsonant;
+            var delBtn = new TuneLab.GUI.Components.Button { Width = 22, Height = rowH, Opacity = canDelete ? 1.0 : 0.5 };
+            int cap = phIdx;
+            delBtn.Clicked += () =>
+            {
+                if (!canDelete) return;
+                var list = mConfig.Phonemes.ToList();
+                if (cap < list.Count) list.RemoveAt(cap);
+                Commit(list);
+            };
+            delBtn.AddContent(new() { Item = new IconItem() { Icon = Assets.PhonemeDelete }, ColorSet = new() { Color = Style.WHITE } });
+            delBtn.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
+            DockPanel.SetDock(delBtn, Dock.Right);
+            dock.Children.Add(delBtn);
+
+            // 3. 右2：添加按钮（+）
+            var addBtn = new TuneLab.GUI.Components.Button { Width = 22, Height = rowH };
+            int capAdd = phIdx;
+            addBtn.Clicked += () =>
+            {
+                var list = mConfig.Phonemes.ToList();
+                var newEntry = new PhonemeEntry { Symbol = mConfig.AvailableLanguages.FirstOrDefault() ?? "??", IsVowel = isVowel };
+                list.Insert(capAdd + 1, newEntry);
+                Commit(list);
+            };
+            addBtn.AddContent(new() { Item = new IconItem() { Icon = Assets.PhonemeAdd }, ColorSet = new() { Color = Style.WHITE } });
+            addBtn.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
+            DockPanel.SetDock(addBtn, Dock.Right);
+            dock.Children.Add(addBtn);
+
+            // 4. 最后：音素文本输入（弹性拉伸填充剩余空间，高度匹配下拉栏）
+            string plain = phoneme.Symbol.Contains('/') ? phoneme.Symbol.Split('/')[1] : phoneme.Symbol;
+            var textInput = new TextInput { Height = rowH, MinHeight = rowH, MaxHeight = rowH, FontSize = 12, Text = plain, Padding = new(6, 0) };
+            textInput.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
+            textInput.Margin = new(4, 0, 4, 0);
+            int capIdx = phIdx;
+            textInput.ValueCommitted.Subscribe(() =>
+            {
+                var list = mConfig.Phonemes.ToList();
+                if (capIdx < list.Count)
+                {
+                    var entry = list[capIdx];
+                    string lang = entry.Symbol.Contains('/') ? entry.Symbol.Split('/')[0] : "";
+                    list[capIdx] = new PhonemeEntry { Symbol = string.IsNullOrEmpty(lang) ? textInput.Text : $"{lang}/{textInput.Text}", IsVowel = isVowel };
+                    Commit(list);
+                }
+            }, s);
+            // 作为最后一个 child，自动填充
+            dock.Children.Add(textInput);
+
+            return dock;
+        }
+
+        public override Type ConfigType => typeof(PhonemeEditorConfig);
+        public override IEnumerable<Control> Views => [mPanel];
+
+        public override void Update(IControllerConfig config) => Apply((PhonemeEditorConfig)config);
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            mPanel.Children.Clear();
+            ObjectPoolManager.Return(mPanel);
+        }
+
+        readonly string mKey;
+        readonly StackPanel mPanel;
+        PhonemeEditorConfig mConfig = null!;
+        readonly IDataProperty<string> mDataProp;
+    }
+
     // 按钮控件：渲染为可点击的按钮，触发 ButtonConfig.Action（在 UI 线程）。不绑定数据。
     class ButtonCreator : Creator
     {
@@ -440,6 +662,7 @@ static Label CreateTitle(string title, double height)
         { typeof(ComboBoxConfig), (parent, key, config) => new ComboBoxCreator(parent, key, (ComboBoxConfig)config) },
         { typeof(CheckBoxConfig), (parent, key, config) => new CheckBoxCreator(parent, key, (CheckBoxConfig)config) },
         { typeof(ButtonConfig), (parent, key, config) => new ButtonCreator(parent, key, (ButtonConfig)config) },
+        { typeof(PhonemeEditorConfig), (parent, key, config) => new PhonemeEditorCreator(parent, key, (PhonemeEditorConfig)config) },
     };
 
     IDataPropertyObject? mDataObject;
diff --git a/TuneLab/UI/MainWindow/Editor/PianoWindow/ParameterArea/AutomationRenderer.cs b/TuneLab/UI/MainWindow/Editor/PianoWindow/ParameterArea/AutomationRenderer.cs
index d4471729..2086ee3b 100644
--- a/TuneLab/UI/MainWindow/Editor/PianoWindow/ParameterArea/AutomationRenderer.cs
+++ b/TuneLab/UI/MainWindow/Editor/PianoWindow/ParameterArea/AutomationRenderer.cs
@@ -372,21 +372,24 @@ void DrawReadbackParameters(DrawingContext context)
                 continue;
 
             var config = kvp.Value;
-            DrawReadbackArea(context, parameter.Segments, config.MinValue, config.MaxValue, Color.Parse(config.Color));
+            DrawReadbackArea(context, parameter.Segments, config.MinValue, config.MaxValue, Color.Parse(config.Color),
+                parameter.SegmentOpacityStops);
         }
     }
 
     // 一条回显轨：各分段（按段交付，段间空、跨段不连线）各自绘制为独立填充面积（仅面积、无描边）。
-    void DrawReadbackArea(DrawingContext context, IReadOnlyList<IReadOnlyList<Foundation.Point>> segments, double min, double max, Color color)
+    // 支持逐段多 GradientStop 透明度渐变：segmentStops[si] 为 Point 列表，X=相对位置(0~1), Y=透明度(0~1)。
+    void DrawReadbackArea(DrawingContext context, IReadOnlyList<IReadOnlyList<Foundation.Point>> segments, double min, double max, Color color,
+        IReadOnlyList<IReadOnlyList<Foundation.Point>>? segmentStops = null)
     {
         var tempoManager = Part!.TempoManager;
         double minVisibleTick = TickAxis.MinVisibleTick;
         double maxVisibleTick = TickAxis.MaxVisibleTick;
-        var fillBrush = color.Opacity(0.25).ToBrush();
         double baselineY = Bounds.Height;
 
-        foreach (var segment in segments)
+        for (int si = 0; si < segments.Count; si++)
         {
+            var segment = segments[si];
             if (segment.Count == 0)
                 continue;
 
@@ -415,6 +418,27 @@ void DrawReadbackArea(DrawingContext context, IReadOnlyList<IReadOnlyList<Founda
             for (int i = 0; i < count; i++)
                 points[i] = new(i + startX, ValueToY(ys[i], min, max));
 
+            // 构造画刷：用 segmentStops 创建多 GradientStop LinearGradientBrush 实现像素级渐变
+            IBrush fillBrush;
+            var stops = segmentStops != null && si < segmentStops.Count ? segmentStops[si] : null;
+            if (stops != null && stops.Count >= 2)
+            {
+                var gradBrush = new Avalonia.Media.LinearGradientBrush
+                {
+                    StartPoint = new RelativePoint(startX, 0, RelativeUnit.Absolute),
+                    EndPoint = new RelativePoint(endX, 0, RelativeUnit.Absolute),
+                    SpreadMethod = GradientSpreadMethod.Pad,
+                };
+                foreach (var sp in stops)
+                    gradBrush.GradientStops.Add(new GradientStop(color.Opacity(Math.Clamp(sp.Y, 0, 1)), Math.Clamp(sp.X, 0, 1)));
+                fillBrush = gradBrush;
+            }
+            else
+            {
+                // 无 stops 或仅 1 个 stop → 均匀 0.25
+                fillBrush = color.Opacity(0.25).ToBrush();
+            }
+
             context.FillCurveArea(points, baselineY, fillBrush);
         }
     }

From b4560188a55c82d54ca55c7435d23f05059dc631 Mon Sep 17 00:00:00 2001
From: tachengP <2638591622@qq.com>
Date: Sun, 21 Jun 2026 19:29:58 +0800
Subject: [PATCH 3/3] =?UTF-8?q?=E6=88=91=E4=B9=9F=E5=BF=98=E4=BA=86?=
 =?UTF-8?q?=E6=94=B9=E5=95=A5=E4=BA=86=E5=8F=8D=E6=AD=A3=E9=85=8D=E5=90=88?=
 =?UTF-8?q?=E5=90=8C=E6=9C=9Fds4tl=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 TuneLab/Data/Synthesis/VoiceSynthesisPipeline.cs                | 2 +-
 .../PianoWindow/PianoScrollView/PianoScrollViewOperation.cs     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/TuneLab/Data/Synthesis/VoiceSynthesisPipeline.cs b/TuneLab/Data/Synthesis/VoiceSynthesisPipeline.cs
index 20f09471..33709d05 100644
--- a/TuneLab/Data/Synthesis/VoiceSynthesisPipeline.cs
+++ b/TuneLab/Data/Synthesis/VoiceSynthesisPipeline.cs
@@ -187,7 +187,7 @@ void WriteBackPhonemes()
             }
             foreach (var note in mPart.Notes)
             {
-                note.SynthesizedPhonemes = map.TryGetValue(note, out var list) ? list.ToArray() : null;
+                note.SynthesizedPhonemes = map.TryGetValue(note, out var list) ? list.ToArray() : [];
             }
         }
         catch (Exception ex)
diff --git a/TuneLab/UI/MainWindow/Editor/PianoWindow/PianoScrollView/PianoScrollViewOperation.cs b/TuneLab/UI/MainWindow/Editor/PianoWindow/PianoScrollView/PianoScrollViewOperation.cs
index b49611aa..c0b0202f 100644
--- a/TuneLab/UI/MainWindow/Editor/PianoWindow/PianoScrollView/PianoScrollViewOperation.cs
+++ b/TuneLab/UI/MainWindow/Editor/PianoWindow/PianoScrollView/PianoScrollViewOperation.cs
@@ -196,7 +196,7 @@ bool DetectWaveformPrimaryButton()
                                                 List<INote> removeNotes = new();
                                                 foreach (var note in selectedNotes)
                                                 {
-                                                    if (note.SynthesizedPhonemes == null)
+                                                    if (note.SynthesizedPhonemes == null || note.SynthesizedPhonemes.IsEmpty())
                                                         continue;
 
                                                     foreach (var phoneme in note.SynthesizedPhonemes)