diff --git a/Assets/Editor/FrameAnimation/FrameAnimationEditorServices.cs b/Assets/Editor/FrameAnimation/FrameAnimationEditorServices.cs
index 53ca236e8..d9434ca82 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationEditorServices.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationEditorServices.cs
@@ -122,7 +122,7 @@ namespace AibisDream.FrameAnimation.Editor
         {
             if (clip == null || !clip.IsImported)
             {
-                return "Manual";
+                return clip != null && clip.HasStandaloneImportSource ? "Standalone Source" : "Manual";
             }
             var sourceId = clip.ImportInfo?.ImportSourceId;
             if (sourceNames != null && !string.IsNullOrEmpty(sourceId) &&
@@ -232,7 +232,7 @@ namespace AibisDream.FrameAnimation.Editor
             if (clip.IsImported || AssetDatabase.IsSubAsset(clip) ||
                 string.IsNullOrEmpty(AssetDatabase.GetAssetPath(clip)))
             {
-                error = "只能添加独立 .asset 形式的 Manual Clip。";
+                error = "只能添加独立 .asset 形式、且不由 Graph ImportSource 管理的 Clip。";
                 return false;
             }
             if (graph.Clips.Contains(clip))
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationGraphEditorWindow.cs b/Assets/Editor/FrameAnimation/FrameAnimationGraphEditorWindow.cs
index e9244f119..6c328f3cf 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationGraphEditorWindow.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationGraphEditorWindow.cs
@@ -68,6 +68,7 @@ namespace AibisDream.FrameAnimation.Editor
         private SerializedObject clipSerializedObject;
         private FrameClip frameListClip;
         private ReorderableList frameList;
+        private bool frameListEditable;
         private readonly FrameAnimationPreviewCoordinator previewCoordinator = new FrameAnimationPreviewCoordinator();
         private readonly List<Slider> previewTimelineSliders = new List<Slider>();
         private readonly List<Label> previewTimeLabels = new List<Label>();
@@ -1419,7 +1420,10 @@ namespace AibisDream.FrameAnimation.Editor
             }
             EnsureFrameList(clip);
             clipSerializedObject.Update();
-            EditorGUILayout.LabelField(clip.IsImported ? "Imported Clip" : "Manual Clip", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField(
+                clip.IsImported ? "Graph Imported Clip" :
+                clip.HasStandaloneImportSource ? "Source-linked External Clip" : "Manual Clip",
+                EditorStyles.boldLabel);
             using (new EditorGUI.DisabledScope(true))
             {
                 EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("id"));
@@ -1440,14 +1444,29 @@ namespace AibisDream.FrameAnimation.Editor
                 EditorGUILayout.LabelField("Source Tag", clip.ImportInfo.SourceTagName);
                 EditorGUILayout.LabelField("Missing", clip.ImportInfo.IsMissingFromSource ? "Yes" : "No");
             }
+            else if (clip.HasStandaloneImportSource)
+            {
+                EditorGUILayout.LabelField("Source Tag",
+                    string.IsNullOrEmpty(clip.StandaloneImportSource.LastImportedTagName)
+                        ? "<all frames>"
+                        : clip.StandaloneImportSource.LastImportedTagName);
+                if (GUILayout.Button("Open Standalone Clip Editor"))
+                {
+                    FrameClipEditorWindow.Open(clip);
+                }
+            }
             if (clipSerializedObject.ApplyModifiedProperties())
             {
                 EditorUtility.SetDirty(clip);
             }
 
-            if (!clip.IsImported)
+            if (!clip.IsImported && !clip.HasStandaloneImportSource)
             {
                 frameList.DoLayoutList();
+                if (clipSerializedObject.ApplyModifiedProperties())
+                {
+                    EditorUtility.SetDirty(clip);
+                }
                 if (frameList.index >= 0 && GUILayout.Button("Duplicate Selected Frame"))
                 {
                     DuplicateFrame(clipSerializedObject.FindProperty("frames"), frameList.index);
@@ -1476,6 +1495,13 @@ namespace AibisDream.FrameAnimation.Editor
                     });
                 }
             }
+            else if (clip.HasStandaloneImportSource)
+            {
+                using (new EditorGUI.DisabledScope(true))
+                {
+                    frameList.DoLayoutList();
+                }
+            }
 
             if (GUILayout.Button("Rename Clip ID"))
             {
@@ -1493,17 +1519,20 @@ namespace AibisDream.FrameAnimation.Editor
 
         private void EnsureFrameList(FrameClip clip)
         {
-            if (frameListClip == clip && frameList != null)
+            var editable = !clip.IsImported && !clip.HasStandaloneImportSource;
+            if (frameListClip == clip && frameList != null && frameListEditable == editable)
             {
                 return;
             }
             frameListClip = clip;
+            frameListEditable = editable;
             clipSerializedObject = new SerializedObject(clip);
             var frames = clipSerializedObject.FindProperty("frames");
-            frameList = new ReorderableList(clipSerializedObject, frames, !clip.IsImported, true, !clip.IsImported, !clip.IsImported)
+            frameList = new ReorderableList(clipSerializedObject, frames, editable, true, editable, editable)
             {
                 elementHeight = 72f,
-                drawHeaderCallback = rect => EditorGUI.LabelField(rect, "Frames (frameName/sourceIndex are read-only)"),
+                drawHeaderCallback = rect => EditorGUI.LabelField(rect,
+                    editable ? "Frames (frameName/sourceIndex are read-only)" : "Frames (source-managed, read-only)"),
                 drawElementCallback = (rect, index, active, focused) => DrawFrameElement(frames, rect, index),
                 onAddCallback = list => AddFrame(frames),
                 onRemoveCallback = list =>
@@ -2472,6 +2501,11 @@ namespace AibisDream.FrameAnimation.Editor
             }
             if (asset is FrameClip clip)
             {
+                if (!AssetDatabase.IsSubAsset(clip))
+                {
+                    FrameClipEditorWindow.Open(clip);
+                    return true;
+                }
                 var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
                 if (owners.Count == 1)
                 {
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationImportModels.cs b/Assets/Editor/FrameAnimation/FrameAnimationImportModels.cs
index 53f5a66d3..1def48af9 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationImportModels.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationImportModels.cs
@@ -273,7 +273,13 @@ namespace AibisDream.FrameAnimation.Editor
         }
     }
 
-    internal sealed class FrameAnimationImportSourcePreview
+    internal interface IFrameAnimationImportPreviewSink
+    {
+        void AddIssue(FrameAnimationImportIssue issue);
+        void AddSpriteDiff(FrameAnimationSpriteDiff diff);
+    }
+
+    internal sealed class FrameAnimationImportSourcePreview : IFrameAnimationImportPreviewSink
     {
         private readonly List<FrameAnimationImportIssue> issues = new List<FrameAnimationImportIssue>();
         private readonly List<FrameAnimationClipDiff> clipDiffs = new List<FrameAnimationClipDiff>();
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationImportService.cs b/Assets/Editor/FrameAnimation/FrameAnimationImportService.cs
index b54637d96..53311fe0f 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationImportService.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationImportService.cs
@@ -434,6 +434,13 @@ namespace AibisDream.FrameAnimation.Editor
                     source.ManageSpriteSlicing && source.Texture != null).Select(source => (currentGraph, source)));
             }
 
+            var standaloneOwners = AssetDatabase.FindAssets("t:FrameClip")
+                .Select(guid => AssetDatabase.LoadAssetAtPath<FrameClip>(AssetDatabase.GUIDToAssetPath(guid)))
+                .Where(clip => clip?.StandaloneImportSource != null &&
+                               clip.StandaloneImportSource.ManageSpriteSlicing &&
+                               clip.StandaloneImportSource.Texture != null)
+                .ToArray();
+
             foreach (var pair in targetPreviews.Where(pair => pair.Key.ManageSpriteSlicing && pair.Key.Texture != null))
             {
                 var conflicts = owners.Where(item => item.source.Texture == pair.Key.Texture &&
@@ -444,6 +451,14 @@ namespace AibisDream.FrameAnimation.Editor
                         $"Texture '{pair.Key.Texture.name}' 已被其他可写 ImportSource 占用：" +
                         string.Join(", ", conflicts.Select(item => $"{item.graph.name}/{item.source.DisplayName}"))));
                 }
+                var standaloneConflicts = standaloneOwners.Where(clip =>
+                    clip.StandaloneImportSource.Texture == pair.Key.Texture).ToArray();
+                if (standaloneConflicts.Length > 0)
+                {
+                    pair.Value.AddIssue(Error(pair.Key, FrameAnimationImportIssueCode.TextureOwnershipConflict,
+                        $"Texture '{pair.Key.Texture.name}' 已被独立 Clip 来源占用：" +
+                        string.Join(", ", standaloneConflicts.Select(clip => clip.name))));
+                }
             }
         }
 
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationPlayerEditor.cs b/Assets/Editor/FrameAnimation/FrameAnimationPlayerEditor.cs
index 01d073699..01ccb2019 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationPlayerEditor.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationPlayerEditor.cs
@@ -40,6 +40,13 @@ namespace AibisDream.FrameAnimation.Editor
             var spriteRenderer = player.GetComponent<SpriteRenderer>();
             var image = player.GetComponent<Image>();
 
+            if (player.GetComponent<FrameClipPlayer>() != null)
+            {
+                EditorGUILayout.HelpBox(
+                    "同一 GameObject 不能同时包含 FrameAnimationPlayer 和 FrameClipPlayer。",
+                    MessageType.Error);
+            }
+
             if (spriteRenderer == null && image == null)
             {
                 EditorGUILayout.HelpBox(
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationPreview.cs b/Assets/Editor/FrameAnimation/FrameAnimationPreview.cs
index 9cdda4828..fa502a58b 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationPreview.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationPreview.cs
@@ -526,7 +526,7 @@ namespace AibisDream.FrameAnimation.Editor
             var resolved = TargetKind switch
             {
                 FrameAnimationPreviewTargetKind.Clip when target is FrameClip clip =>
-                    FrameAnimationResolver.TryResolve(graph, clip.Id, default, out plan, out var clipError)
+                    TryResolvePreviewClip(clip, out plan, out var clipError)
                         ? FrameAnimationPlaybackError.None : clipError,
                 FrameAnimationPreviewTargetKind.Node when target is AnimationNode node =>
                     FrameAnimationResolver.TryResolveNode(graph, node, out plan, out var nodeError)
@@ -552,6 +552,16 @@ namespace AibisDream.FrameAnimation.Editor
             }
         }
 
+        private bool TryResolvePreviewClip(
+            FrameClip clip,
+            out ResolvedPlaybackPlan resolvedPlan,
+            out FrameAnimationPlaybackError error)
+        {
+            return graph != null
+                ? FrameAnimationResolver.TryResolve(graph, clip.Id, default, out resolvedPlan, out error)
+                : FrameAnimationResolver.TryResolveClip(clip, default, out resolvedPlan, out error);
+        }
+
         private void ApplyEvaluation(FrameAnimationSessionEvaluation evaluation)
         {
             if (evaluation.IsFailed)
diff --git a/Assets/Editor/FrameAnimation/FrameAnimationSpriteUtility.cs b/Assets/Editor/FrameAnimation/FrameAnimationSpriteUtility.cs
index 589fc1ae2..ff1c3b586 100644
--- a/Assets/Editor/FrameAnimation/FrameAnimationSpriteUtility.cs
+++ b/Assets/Editor/FrameAnimation/FrameAnimationSpriteUtility.cs
@@ -10,6 +10,36 @@ using UnityEngine;
 
 namespace AibisDream.FrameAnimation.Editor
 {
+    internal readonly struct FrameAnimationSpriteSourceContext
+    {
+        public string SourceId { get; }
+        public Texture2D Texture { get; }
+        public TextAsset AsepriteJson { get; }
+        public Vector2 Pivot { get; }
+        public bool ManageSpriteSlicing { get; }
+
+        public FrameAnimationSpriteSourceContext(
+            string sourceId,
+            Texture2D texture,
+            TextAsset asepriteJson,
+            Vector2 pivot,
+            bool manageSpriteSlicing)
+        {
+            SourceId = sourceId ?? string.Empty;
+            Texture = texture;
+            AsepriteJson = asepriteJson;
+            Pivot = pivot;
+            ManageSpriteSlicing = manageSpriteSlicing;
+        }
+
+        public static FrameAnimationSpriteSourceContext From(FrameAnimationImportSource source)
+        {
+            return new FrameAnimationSpriteSourceContext(
+                source?.InternalId, source?.Texture, source?.AsepriteJson,
+                source?.Pivot ?? new Vector2(0.5f, 0.5f), source?.ManageSpriteSlicing == true);
+        }
+    }
+
     internal sealed class FrameAnimationSpritePlan
     {
         public string TexturePath { get; }
@@ -91,6 +121,15 @@ namespace AibisDream.FrameAnimation.Editor
             FrameAnimationImportSource source,
             AsepriteSourceDocument document,
             FrameAnimationImportSourcePreview preview)
+        {
+            return BuildPlan(FrameAnimationSpriteSourceContext.From(source), document, preview);
+        }
+
+        public static FrameAnimationSpritePlan BuildPlan(
+            FrameAnimationSpriteSourceContext source,
+            AsepriteSourceDocument document,
+            IFrameAnimationImportPreviewSink preview,
+            IReadOnlyCollection<int> includedSourceIndices = null)
         {
             var texturePath = AssetDatabase.GetAssetPath(source.Texture);
             var importer = AssetImporter.GetAtPath(texturePath) as TextureImporter;
@@ -105,8 +144,8 @@ namespace AibisDream.FrameAnimation.Editor
                 ? Array.Empty<SpriteRect>()
                 : ReadSpriteRects(importer);
             return source.ManageSpriteSlicing
-                ? BuildWritablePlan(source, document, preview, texturePath, existingRects)
-                : BuildReadOnlyPlan(source, document, preview, texturePath, existingRects);
+                ? BuildWritablePlan(source, document, preview, texturePath, existingRects, includedSourceIndices)
+                : BuildReadOnlyPlan(source, document, preview, texturePath, existingRects, includedSourceIndices);
         }
 
         public static Rect ToUnityRect(RectInt asepriteRect, int textureHeight)
@@ -175,7 +214,14 @@ namespace AibisDream.FrameAnimation.Editor
             FrameAnimationImportSource source,
             IReadOnlyList<SpriteRect> spriteRects = null)
         {
-            if (source == null || source.Texture == null || source.AsepriteJson == null)
+            return ComputeSourceHash(FrameAnimationSpriteSourceContext.From(source), spriteRects);
+        }
+
+        public static string ComputeSourceHash(
+            FrameAnimationSpriteSourceContext source,
+            IReadOnlyList<SpriteRect> spriteRects = null)
+        {
+            if (source.Texture == null || source.AsepriteJson == null)
             {
                 return string.Empty;
             }
@@ -214,17 +260,18 @@ namespace AibisDream.FrameAnimation.Editor
         }
 
         private static FrameAnimationSpritePlan BuildWritablePlan(
-            FrameAnimationImportSource source,
+            FrameAnimationSpriteSourceContext source,
             AsepriteSourceDocument document,
-            FrameAnimationImportSourcePreview preview,
+            IFrameAnimationImportPreviewSink preview,
             string texturePath,
-            IReadOnlyList<SpriteRect> existingRects)
+            IReadOnlyList<SpriteRect> existingRects,
+            IReadOnlyCollection<int> includedSourceIndices)
         {
             var planned = CloneRects(existingRects).ToList();
             var originalRects = planned.ToArray();
             var assigned = new HashSet<SpriteRect>();
             var spriteNamesBySourceIndex = new Dictionary<int, string>();
-            foreach (var slot in document.SpriteSlots)
+            foreach (var slot in EnumerateSlots(document, includedSourceIndices))
             {
                 var unityRect = ToUnityRect(slot.Rect, source.Texture.height);
                 SpriteRect matched = null;
@@ -331,15 +378,16 @@ namespace AibisDream.FrameAnimation.Editor
         }
 
         private static FrameAnimationSpritePlan BuildReadOnlyPlan(
-            FrameAnimationImportSource source,
+            FrameAnimationSpriteSourceContext source,
             AsepriteSourceDocument document,
-            FrameAnimationImportSourcePreview preview,
+            IFrameAnimationImportPreviewSink preview,
             string texturePath,
-            IReadOnlyList<SpriteRect> existingRects)
+            IReadOnlyList<SpriteRect> existingRects,
+            IReadOnlyCollection<int> includedSourceIndices)
         {
             var sprites = AssetDatabase.LoadAllAssetsAtPath(texturePath).OfType<Sprite>().ToArray();
             var matches = new Dictionary<int, Sprite>();
-            foreach (var slot in document.SpriteSlots)
+            foreach (var slot in EnumerateSlots(document, includedSourceIndices))
             {
                 var unityRect = ToUnityRect(slot.Rect, source.Texture.height);
                 var rectMatches = sprites.Where(sprite => RectEquals(sprite.rect, unityRect)).ToArray();
@@ -382,6 +430,32 @@ namespace AibisDream.FrameAnimation.Editor
             }
         }
 
+        private static IEnumerable<AsepriteSpriteSlot> EnumerateSlots(
+            AsepriteSourceDocument document,
+            IReadOnlyCollection<int> includedSourceIndices)
+        {
+            if (includedSourceIndices == null)
+            {
+                return document.SpriteSlots;
+            }
+
+            var included = new HashSet<int>(includedSourceIndices);
+            return document.SpriteSlots.Select(slot =>
+            {
+                var indices = new List<int>();
+                var names = new List<string>();
+                for (var index = 0; index < slot.SourceIndices.Count; index++)
+                {
+                    if (!included.Contains(slot.SourceIndices[index])) continue;
+                    indices.Add(slot.SourceIndices[index]);
+                    names.Add(slot.FrameNames[index]);
+                }
+                return indices.Count == 0
+                    ? null
+                    : new AsepriteSpriteSlot(slot.Rect, names[0], indices, names);
+            }).Where(slot => slot != null);
+        }
+
         private static string BuildSlotSummary(string prefix, AsepriteSpriteSlot slot)
         {
             return slot.SourceIndices.Count > 1
@@ -440,15 +514,15 @@ namespace AibisDream.FrameAnimation.Editor
         }
 
         private static FrameAnimationImportIssue Error(
-            FrameAnimationImportSource source,
+            FrameAnimationSpriteSourceContext source,
             FrameAnimationImportIssueCode code,
             string message)
         {
             return new FrameAnimationImportIssue(
                 FrameAnimationValidationSeverity.Error,
                 code,
-                source?.InternalId,
-                source?.InternalId,
+                source.SourceId,
+                source.SourceId,
                 message);
         }
     }
diff --git a/Assets/Editor/FrameAnimation/FrameClipEditor.cs b/Assets/Editor/FrameAnimation/FrameClipEditor.cs
index a9407a9b3..20051edcf 100644
--- a/Assets/Editor/FrameAnimation/FrameClipEditor.cs
+++ b/Assets/Editor/FrameAnimation/FrameClipEditor.cs
@@ -11,7 +11,10 @@ namespace AibisDream.FrameAnimation.Editor
         {
             var clip = (FrameClip)target;
             var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
-            EditorGUILayout.LabelField(clip.IsImported ? "Imported FrameClip" : "Manual FrameClip", EditorStyles.boldLabel);
+            var kind = clip.IsImported
+                ? "Graph Imported FrameClip"
+                : clip.HasStandaloneImportSource ? "Source-linked External FrameClip" : "Manual FrameClip";
+            EditorGUILayout.LabelField(kind, EditorStyles.boldLabel);
             using (new EditorGUI.DisabledScope(true))
             {
                 EditorGUILayout.TextField("ID", clip.Id);
@@ -23,6 +26,8 @@ namespace AibisDream.FrameAnimation.Editor
                 EditorGUILayout.TextField("Storage", AssetDatabase.IsSubAsset(clip) ? "Graph sub-asset" : "External .asset");
                 EditorGUILayout.TextField("Source Tag", clip.ImportInfo?.SourceTagName ?? string.Empty);
                 EditorGUILayout.Toggle("Missing", clip.ImportInfo?.IsMissingFromSource ?? false);
+                EditorGUILayout.ObjectField("Standalone Texture", clip.StandaloneImportSource?.Texture, typeof(Texture2D), false);
+                EditorGUILayout.ObjectField("Standalone JSON", clip.StandaloneImportSource?.AsepriteJson, typeof(TextAsset), false);
             }
             if (!AssetDatabase.IsSubAsset(clip) && owners.Count > 1)
             {
@@ -31,8 +36,14 @@ namespace AibisDream.FrameAnimation.Editor
                     MessageType.Warning);
             }
             EditorGUILayout.HelpBox(
-                "Clip id、帧表和资产所有权操作只能在 Frame Animation Graph Editor 中执行。",
+                AssetDatabase.IsSubAsset(clip)
+                    ? "Graph sub-asset 的 Clip 数据请在 Frame Animation Graph Editor 中编辑。"
+                    : "双击资产或使用下方按钮，在独立 Frame Clip Editor 中编辑。",
                 MessageType.Info);
+            if (!AssetDatabase.IsSubAsset(clip) && GUILayout.Button("Open Frame Clip Editor"))
+            {
+                FrameClipEditorWindow.Open(clip);
+            }
             if (owners.Count == 0)
             {
                 EditorGUILayout.HelpBox("当前没有 FrameAnimationGraph 引用该 Clip。", MessageType.Info);
diff --git a/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs b/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs
new file mode 100644
index 000000000..de8fd1d7c
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs
@@ -0,0 +1,360 @@
+using System;
+using System.Linq;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace AibisDream.FrameAnimation.Editor
+{
+    public sealed class FrameClipEditorWindow : EditorWindow
+    {
+        private FrameClip clip;
+        private SerializedObject clipSerializedObject;
+        private ReorderableList frameList;
+        private Vector2 scroll;
+        private readonly FrameAnimationPreviewCoordinator preview = new FrameAnimationPreviewCoordinator();
+        private FrameClipImportPreview importPreview;
+        private double lastUpdateTime;
+
+        [MenuItem("Window/AibisDream/Frame Animation/Frame Clip Editor")]
+        public static void ShowWindow()
+        {
+            GetWindow<FrameClipEditorWindow>("Frame Clip Editor");
+        }
+
+        public static void Open(FrameClip value)
+        {
+            var window = GetWindow<FrameClipEditorWindow>("Frame Clip Editor");
+            window.SetClip(value);
+            window.Show();
+            window.Focus();
+        }
+
+        private void OnEnable()
+        {
+            EditorApplication.update += OnEditorUpdate;
+            Undo.undoRedoPerformed += OnUndoRedo;
+            lastUpdateTime = EditorApplication.timeSinceStartup;
+        }
+
+        private void OnDisable()
+        {
+            EditorApplication.update -= OnEditorUpdate;
+            Undo.undoRedoPerformed -= OnUndoRedo;
+        }
+
+        private void OnUndoRedo()
+        {
+            RebuildSerializedState();
+            preview.RefreshTarget(false);
+            Repaint();
+        }
+
+        private void OnEditorUpdate()
+        {
+            var now = EditorApplication.timeSinceStartup;
+            var delta = Math.Max(0d, now - lastUpdateTime);
+            lastUpdateTime = now;
+            if (preview.Tick(delta, null)) Repaint();
+        }
+
+        private void OnGUI()
+        {
+            var next = (FrameClip)EditorGUILayout.ObjectField("FrameClip", clip, typeof(FrameClip), false);
+            if (next != clip) SetClip(next);
+            if (clip == null)
+            {
+                EditorGUILayout.HelpBox("选择一个外部 FrameClip .asset 开始编辑。", MessageType.Info);
+                return;
+            }
+            if (AssetDatabase.IsSubAsset(clip))
+            {
+                EditorGUILayout.HelpBox("Graph sub-asset Clip 请在 Frame Animation Graph Editor 中编辑。", MessageType.Info);
+                if (GUILayout.Button("Open Referencing Graph"))
+                {
+                    var owner = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip).FirstOrDefault();
+                    if (owner != null) FrameAnimationGraphEditorWindow.Open(owner);
+                }
+                return;
+            }
+
+            DrawPreview();
+            scroll = EditorGUILayout.BeginScrollView(scroll);
+            DrawClipProperties();
+            EditorGUILayout.Space();
+            DrawSourceProperties();
+            EditorGUILayout.Space();
+            frameList?.DoLayoutList();
+            if (clipSerializedObject != null && clipSerializedObject.ApplyModifiedProperties())
+            {
+                EditorUtility.SetDirty(clip);
+                preview.RefreshTarget(false);
+            }
+            if (!clip.IsImported && !clip.HasStandaloneImportSource &&
+                frameList != null && frameList.index >= 0 && GUILayout.Button("Duplicate Selected Frame"))
+            {
+                var frames = clipSerializedObject.FindProperty("frames");
+                frames.InsertArrayElementAtIndex(frameList.index);
+                clipSerializedObject.ApplyModifiedProperties();
+                EditorUtility.SetDirty(clip);
+                preview.RefreshTarget(false);
+            }
+            EditorGUILayout.EndScrollView();
+        }
+
+        private void DrawPreview()
+        {
+            var rect = GUILayoutUtility.GetRect(100f, 260f, GUILayout.ExpandWidth(true));
+            EditorGUI.DrawRect(rect, new Color(0.12f, 0.12f, 0.12f));
+            var sprite = preview.CurrentSprite;
+            if (sprite != null && sprite.texture != null)
+            {
+                var uv = new Rect(
+                    sprite.textureRect.x / sprite.texture.width,
+                    sprite.textureRect.y / sprite.texture.height,
+                    sprite.textureRect.width / sprite.texture.width,
+                    sprite.textureRect.height / sprite.texture.height);
+                var scale = Mathf.Min(rect.width / sprite.rect.width, rect.height / sprite.rect.height);
+                var size = sprite.rect.size * scale;
+                var destination = new Rect(rect.center - size * 0.5f, size);
+                GUI.DrawTextureWithTexCoords(destination, sprite.texture, uv, true);
+            }
+            else
+            {
+                GUI.Label(rect, preview.Error.Code == FrameAnimationPlaybackErrorCode.None
+                    ? "Empty Frame" : preview.Error.Message, EditorStyles.centeredGreyMiniLabel);
+            }
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                if (GUILayout.Button(preview.State == FrameAnimationPreviewState.Playing ? "Pause" : "Play"))
+                {
+                    if (preview.State == FrameAnimationPreviewState.Playing) preview.Pause();
+                    else preview.Play();
+                }
+                if (GUILayout.Button("Stop")) preview.Stop();
+                if (GUILayout.Button("<")) preview.Step(-1);
+                if (GUILayout.Button(">")) preview.Step(1);
+            }
+            var duration = preview.Timeline?.DisplayDurationSeconds ?? 0d;
+            var position = EditorGUILayout.Slider("Time", (float)preview.PositionSeconds, 0f,
+                Mathf.Max(0.0001f, (float)duration));
+            if (!Mathf.Approximately(position, (float)preview.PositionSeconds)) preview.Seek(position);
+        }
+
+        private void DrawClipProperties()
+        {
+            clipSerializedObject.Update();
+            EditorGUILayout.LabelField(clip.HasStandaloneImportSource ? "Source-linked External Clip" : "Manual External Clip",
+                EditorStyles.boldLabel);
+            var idProperty = clipSerializedObject.FindProperty("id");
+            var nextId = EditorGUILayout.DelayedTextField("ID", idProperty.stringValue);
+            if (nextId != idProperty.stringValue) RenameClip(nextId);
+            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("displayName"));
+            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("speed"));
+            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("defaultEndBehavior"));
+            EditorGUILayout.LabelField("Frame Count", clip.FrameCount.ToString());
+            EditorGUILayout.LabelField("Total Duration", clip.TotalDurationMs + " ms");
+            var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
+            EditorGUILayout.LabelField("Referencing Graphs", owners.Count.ToString());
+            if (owners.Count > 1)
+                EditorGUILayout.HelpBox("该 Clip 被多个 Graph 共享，ID 重命名被锁定。", MessageType.Warning);
+            if (clipSerializedObject.ApplyModifiedProperties())
+            {
+                EditorUtility.SetDirty(clip);
+                preview.RefreshTarget(false);
+                importPreview = null;
+            }
+        }
+
+        private void DrawSourceProperties()
+        {
+            EditorGUILayout.LabelField("Standalone Import Source", EditorStyles.boldLabel);
+            if (!clip.HasStandaloneImportSource)
+            {
+                if (GUILayout.Button("Enable Texture + JSON Source"))
+                {
+                    if (!FrameClipImportService.EnableSource(clip, out var error))
+                        EditorUtility.DisplayDialog("无法启用来源", error, "确定");
+                    RebuildSerializedState();
+                }
+                return;
+            }
+
+            clipSerializedObject.Update();
+            var source = clipSerializedObject.FindProperty("standaloneImportSource");
+            EditorGUILayout.PropertyField(source.FindPropertyRelative("texture"));
+            EditorGUILayout.PropertyField(source.FindPropertyRelative("asepriteJson"));
+            EditorGUILayout.PropertyField(source.FindPropertyRelative("pivot"));
+            EditorGUILayout.PropertyField(source.FindPropertyRelative("manageSpriteSlicing"));
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.PropertyField(source.FindPropertyRelative("lastImportedTagName"));
+                EditorGUILayout.PropertyField(source.FindPropertyRelative("lastSourceHash"));
+            }
+            if (clipSerializedObject.ApplyModifiedProperties())
+            {
+                EditorUtility.SetDirty(clip);
+                importPreview = null;
+            }
+
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                if (GUILayout.Button("Preview Import")) importPreview = FrameClipImportService.Preview(clip);
+                if (GUILayout.Button("Refresh"))
+                {
+                    importPreview = FrameClipImportService.Preview(clip);
+                    ApplyImportPreview();
+                }
+                if (GUILayout.Button("Detach Source"))
+                {
+                    if (EditorUtility.DisplayDialog("断开来源", "保留当前帧并转为手工 Clip？", "断开", "取消"))
+                    {
+                        FrameClipImportService.DetachSource(clip);
+                        importPreview = null;
+                        RebuildSerializedState();
+                    }
+                }
+            }
+            DrawImportPreview();
+        }
+
+        private void DrawImportPreview()
+        {
+            if (importPreview == null) return;
+            EditorGUILayout.LabelField("Import Preview", EditorStyles.boldLabel);
+            EditorGUILayout.LabelField("Selected Tag",
+                string.IsNullOrEmpty(importPreview.SourceTagName) ? "<all frames>" : importPreview.SourceTagName);
+            EditorGUILayout.LabelField("Selected Frames", importPreview.SourceIndices.Count.ToString());
+            EditorGUILayout.LabelField("Frame Changes", importPreview.HasFrameChanges ? "Yes" : "No");
+            EditorGUILayout.LabelField("Sprite Changes", importPreview.HasSpriteChanges ? "Yes" : "No");
+            foreach (var issue in importPreview.Issues)
+            {
+                var type = issue.Severity == FrameAnimationValidationSeverity.Error
+                    ? MessageType.Error : MessageType.Warning;
+                EditorGUILayout.HelpBox($"{issue.Code}: {issue.Message}", type);
+            }
+        }
+
+        private void ApplyImportPreview()
+        {
+            if (importPreview == null || importPreview.HasErrors) return;
+            var allow = !importPreview.HasSpriteChanges || EditorUtility.DisplayDialog(
+                "确认修改 TextureImporter",
+                "独立 Clip 刷新需要更新 Sprite 切图。是否继续？",
+                "应用切图并刷新",
+                "取消");
+            if (!allow) return;
+            if (!FrameClipImportService.Apply(importPreview, true, out var error))
+            {
+                EditorUtility.DisplayDialog("刷新失败", error, "确定");
+                return;
+            }
+            importPreview = FrameClipImportService.Preview(clip);
+            RebuildSerializedState();
+            preview.RefreshTarget(false);
+        }
+
+        private void RenameClip(string newId)
+        {
+            if (string.IsNullOrWhiteSpace(newId))
+            {
+                EditorUtility.DisplayDialog("无法重命名", "Clip ID 不能为空。", "确定");
+                return;
+            }
+            var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
+            if (owners.Count > 1)
+            {
+                EditorUtility.DisplayDialog("无法重命名", "共享外部 Clip 被多个 Graph 引用。", "确定");
+                return;
+            }
+            if (owners.Count == 1)
+            {
+                if (!FrameAnimationAssetOperations.RenameClip(owners[0], clip, newId, out var error))
+                    EditorUtility.DisplayDialog("无法重命名", error, "确定");
+                return;
+            }
+            Undo.RecordObject(clip, "Rename Standalone Frame Clip");
+            clip.SetId(newId);
+            EditorUtility.SetDirty(clip);
+        }
+
+        private void SetClip(FrameClip value)
+        {
+            clip = value;
+            importPreview = null;
+            RebuildSerializedState();
+            preview.SetGraph(null);
+            if (clip != null) preview.SetTarget(FrameAnimationPreviewTargetKind.Clip, clip);
+            else preview.ClearTarget();
+            Repaint();
+        }
+
+        private void RebuildSerializedState()
+        {
+            clipSerializedObject = clip != null ? new SerializedObject(clip) : null;
+            frameList = clip != null ? BuildFrameList() : null;
+        }
+
+        private ReorderableList BuildFrameList()
+        {
+            var frames = clipSerializedObject.FindProperty("frames");
+            var editable = !clip.IsImported && !clip.HasStandaloneImportSource;
+            var list = new ReorderableList(clipSerializedObject, frames, editable, true, editable, editable)
+            {
+                elementHeight = 72f,
+                drawHeaderCallback = rect => EditorGUI.LabelField(rect,
+                    editable ? "Frames" : "Frames (source-linked, read-only)"),
+                drawElementCallback = (rect, index, active, focused) => DrawFrame(frames, rect, index),
+                onAddCallback = value =>
+                {
+                    var index = frames.arraySize;
+                    frames.InsertArrayElementAtIndex(index);
+                    var element = frames.GetArrayElementAtIndex(index);
+                    element.FindPropertyRelative("sprite").objectReferenceValue = null;
+                    element.FindPropertyRelative("durationMs").intValue = 100;
+                    element.FindPropertyRelative("frameName").stringValue = string.Empty;
+                    element.FindPropertyRelative("sourceIndex").intValue = -1;
+                    clipSerializedObject.ApplyModifiedProperties();
+                    value.index = index;
+                    EditorUtility.SetDirty(clip);
+                    preview.RefreshTarget(false);
+                },
+                onRemoveCallback = value =>
+                {
+                    ReorderableList.defaultBehaviours.DoRemoveButton(value);
+                    clipSerializedObject.ApplyModifiedProperties();
+                    EditorUtility.SetDirty(clip);
+                    preview.RefreshTarget(false);
+                },
+                onReorderCallback = _ =>
+                {
+                    clipSerializedObject.ApplyModifiedProperties();
+                    EditorUtility.SetDirty(clip);
+                    preview.RefreshTarget(false);
+                }
+            };
+            return list;
+        }
+
+        private static void DrawFrame(SerializedProperty frames, Rect rect, int index)
+        {
+            if (index < 0 || index >= frames.arraySize) return;
+            var element = frames.GetArrayElementAtIndex(index);
+            rect.y += 2f;
+            var line = EditorGUIUtility.singleLineHeight;
+            EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, line),
+                element.FindPropertyRelative("sprite"), new GUIContent($"#{index} Sprite"));
+            EditorGUI.PropertyField(new Rect(rect.x, rect.y + line + 2f, rect.width, line),
+                element.FindPropertyRelative("durationMs"));
+            using (new EditorGUI.DisabledScope(true))
+            {
+                var half = (rect.width - 4f) * 0.5f;
+                EditorGUI.PropertyField(new Rect(rect.x, rect.y + (line + 2f) * 2f, half, line),
+                    element.FindPropertyRelative("frameName"));
+                EditorGUI.PropertyField(new Rect(rect.x + half + 4f, rect.y + (line + 2f) * 2f, half, line),
+                    element.FindPropertyRelative("sourceIndex"));
+            }
+        }
+    }
+}
diff --git a/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs.meta b/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs.meta
new file mode 100644
index 000000000..5e61bca08
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipEditorWindow.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5673c406c6069e241b0fad51881213fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Editor/FrameAnimation/FrameClipImportService.cs b/Assets/Editor/FrameAnimation/FrameClipImportService.cs
new file mode 100644
index 000000000..7ab3c5102
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipImportService.cs
@@ -0,0 +1,333 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace AibisDream.FrameAnimation.Editor
+{
+    internal sealed class FrameClipImportPreview : IFrameAnimationImportPreviewSink
+    {
+        private readonly List<FrameAnimationImportIssue> issues = new List<FrameAnimationImportIssue>();
+        private readonly List<FrameAnimationSpriteDiff> spriteDiffs = new List<FrameAnimationSpriteDiff>();
+
+        public FrameClip Clip { get; }
+        public AsepriteSourceDocument Document { get; internal set; }
+        public FrameAnimationSpritePlan SpritePlan { get; internal set; }
+        public IReadOnlyList<int> SourceIndices { get; internal set; } = Array.Empty<int>();
+        public string SourceTagName { get; internal set; } = string.Empty;
+        public string CurrentHash { get; internal set; } = string.Empty;
+        public bool HasFrameChanges { get; internal set; }
+        public IReadOnlyList<FrameAnimationImportIssue> Issues => issues;
+        public IReadOnlyList<FrameAnimationSpriteDiff> SpriteDiffs => spriteDiffs;
+        public bool HasErrors => issues.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error);
+        public bool HasSpriteChanges => spriteDiffs.Any(diff =>
+            diff.Kind == FrameAnimationSpriteChangeKind.Added ||
+            diff.Kind == FrameAnimationSpriteChangeKind.Updated);
+
+        public FrameClipImportPreview(FrameClip clip)
+        {
+            Clip = clip;
+        }
+
+        public void AddIssue(FrameAnimationImportIssue issue)
+        {
+            if (issue != null) issues.Add(issue);
+        }
+
+        public void AddSpriteDiff(FrameAnimationSpriteDiff diff)
+        {
+            if (diff != null) spriteDiffs.Add(diff);
+        }
+    }
+
+    internal static class FrameClipImportService
+    {
+        public static bool EnableSource(FrameClip clip, out string error)
+        {
+            error = string.Empty;
+            if (!IsExternalClip(clip))
+            {
+                error = "独立来源只能添加到外部 .asset FrameClip。";
+                return false;
+            }
+            if (clip.IsImported)
+            {
+                error = "Graph Imported Clip 必须继续由所属 Graph 的 ImportSource 管理。";
+                return false;
+            }
+            if (clip.HasStandaloneImportSource) return true;
+            Undo.RecordObject(clip, "Enable Standalone Frame Clip Source");
+            clip.GetOrCreateStandaloneImportSource();
+            EditorUtility.SetDirty(clip);
+            return true;
+        }
+
+        public static void DetachSource(FrameClip clip)
+        {
+            if (clip == null || !clip.HasStandaloneImportSource) return;
+            Undo.RecordObject(clip, "Detach Standalone Frame Clip Source");
+            clip.ClearStandaloneImportSource();
+            EditorUtility.SetDirty(clip);
+        }
+
+        public static FrameClipImportPreview Preview(FrameClip clip)
+        {
+            var preview = new FrameClipImportPreview(clip);
+            if (!IsExternalClip(clip))
+            {
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.ImportedClipOwnershipInvalid,
+                    "独立来源只能用于外部 .asset FrameClip。"));
+                return preview;
+            }
+            var source = clip.StandaloneImportSource;
+            if (source == null)
+            {
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.ImportSourceReferenceInvalid,
+                    "FrameClip 尚未启用独立来源。"));
+                return preview;
+            }
+            if (source.Texture == null)
+            {
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.TextureMissing, "独立来源缺少 Texture。"));
+                return preview;
+            }
+            if (source.AsepriteJson == null)
+            {
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.JsonMissing, "独立来源缺少 Aseprite JSON。"));
+                return preview;
+            }
+
+            var sourceId = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(clip));
+            if (!AsepriteJsonParser.TryParse(source.AsepriteJson.text, sourceId, out var document, out var parseIssue))
+            {
+                preview.AddIssue(parseIssue);
+                return preview;
+            }
+            preview.Document = document;
+            ValidateFrames(clip, source, document, preview);
+            if (preview.HasErrors) return preview;
+
+            if (document.Tags.Count > 0)
+            {
+                var first = document.Tags[0];
+                preview.SourceTagName = first.Name;
+                if (string.IsNullOrWhiteSpace(first.Name))
+                {
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.TagNameInvalid,
+                        "第一个 Tag 的名称不能为空。"));
+                    return preview;
+                }
+                if (!AsepriteJsonParser.TryExpandTag(first, document.Frames.Count, sourceId,
+                        out var indices, out var tagIssue))
+                {
+                    preview.AddIssue(tagIssue);
+                    return preview;
+                }
+                preview.SourceIndices = indices;
+            }
+            else
+            {
+                preview.SourceIndices = Enumerable.Range(0, document.Frames.Count).ToArray();
+            }
+
+            ValidateTextureOwnership(clip, source, preview);
+            if (preview.HasErrors) return preview;
+
+            var context = Context(clip, source);
+            preview.SpritePlan = FrameAnimationSpriteUtility.BuildPlan(
+                context, document, preview, preview.SourceIndices.Distinct().ToArray());
+            preview.CurrentHash = FrameAnimationSpriteUtility.ComputeSourceHash(context);
+            preview.HasFrameChanges = !FramesEqual(clip, preview);
+            if (!string.IsNullOrEmpty(source.LastSourceHash) && source.LastSourceHash != preview.CurrentHash)
+            {
+                preview.AddIssue(new FrameAnimationImportIssue(
+                    FrameAnimationValidationSeverity.Warning,
+                    FrameAnimationImportIssueCode.SourceChanged,
+                    sourceId,
+                    clip.Id,
+                    "来源内容或切图设置自上次刷新后已发生变化。"));
+            }
+            return preview;
+        }
+
+        public static bool Apply(FrameClipImportPreview preview, bool allowSpriteChanges, out string error)
+        {
+            error = string.Empty;
+            if (preview?.Clip == null || preview.Document == null || preview.SpritePlan == null)
+            {
+                error = "独立 Clip 导入预览无效。";
+                return false;
+            }
+            if (preview.HasErrors)
+            {
+                error = "导入预览包含阻断错误，未修改任何资产。";
+                return false;
+            }
+            if (preview.HasSpriteChanges && !allowSpriteChanges)
+            {
+                error = "导入需要修改 TextureImporter，但尚未获得确认。";
+                return false;
+            }
+
+            var clip = preview.Clip;
+            var source = clip.StandaloneImportSource;
+            FrameAnimationTextureSnapshot snapshot = null;
+            Undo.IncrementCurrentGroup();
+            var group = Undo.GetCurrentGroup();
+            Undo.SetCurrentGroupName("Refresh Standalone Frame Clip Source");
+            try
+            {
+                if (source.ManageSpriteSlicing && preview.HasSpriteChanges)
+                {
+                    snapshot = FrameAnimationSpriteUtility.CaptureSnapshot(preview.SpritePlan);
+                    FrameAnimationSpriteUtility.ApplyPlan(preview.SpritePlan);
+                }
+                var sprites = source.ManageSpriteSlicing
+                    ? FrameAnimationSpriteUtility.LoadSpritesByName(preview.SpritePlan.TexturePath)
+                    : null;
+                var frames = preview.SourceIndices.Select(sourceIndex =>
+                {
+                    var sourceFrame = preview.Document.Frames[sourceIndex];
+                    if (!preview.SpritePlan.TryResolveSprite(sourceIndex, sprites, out var sprite))
+                        throw new InvalidOperationException($"刷新后找不到 SourceFrame '{sourceFrame.FrameName}' 对应的 Sprite。");
+                    return new FrameAnimationFrame(sprite, sourceFrame.DurationMs, sourceFrame.FrameName, sourceIndex);
+                }).ToArray();
+
+                Undo.RecordObject(clip, "Refresh Standalone Frame Clip");
+                clip.SetFrames(frames);
+                if (string.IsNullOrWhiteSpace(clip.Id))
+                {
+                    var initialId = !string.IsNullOrWhiteSpace(preview.SourceTagName)
+                        ? preview.SourceTagName
+                        : Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(clip));
+                    clip.SetId(initialId);
+                    if (string.IsNullOrWhiteSpace(clip.DisplayName)) clip.SetDisplayName(initialId);
+                }
+                source.SetLastImport(
+                    FrameAnimationSpriteUtility.ComputeSourceHash(Context(clip, source)),
+                    preview.SourceTagName);
+                EditorUtility.SetDirty(clip);
+                AssetDatabase.SaveAssets();
+                Undo.CollapseUndoOperations(group);
+                return true;
+            }
+            catch (Exception exception)
+            {
+                Undo.RevertAllDownToGroup(group);
+                if (snapshot != null) FrameAnimationSpriteUtility.RestoreSnapshot(snapshot);
+                AssetDatabase.SaveAssets();
+                error = $"独立 Clip 导入失败，已尝试回滚：{exception.Message}";
+                Debug.LogException(exception);
+                return false;
+            }
+        }
+
+        private static void ValidateFrames(
+            FrameClip clip,
+            FrameClipImportSource source,
+            AsepriteSourceDocument document,
+            FrameClipImportPreview preview)
+        {
+            if (document.Frames.Count == 0)
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.FramesMissing, "Aseprite JSON 的 frames 为空。"));
+            foreach (var duplicate in document.Frames.GroupBy(frame => frame.FrameName).Where(group => group.Count() > 1))
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.FrameNameDuplicate,
+                    $"frameName '{duplicate.Key}' 在来源内重复。"));
+            for (var index = 0; index < document.Frames.Count; index++)
+            {
+                var frame = document.Frames[index];
+                if (string.IsNullOrWhiteSpace(frame.FrameName))
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.FrameNameInvalid,
+                        $"SourceFrame[{index}] 的 frameName 为空。"));
+                if (frame.DurationMs <= 0)
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.FrameDurationInvalid,
+                        $"SourceFrame '{frame.FrameName}' 的 duration 必须大于 0。"));
+                if (frame.Rect.width <= 0 || frame.Rect.height <= 0 || frame.Rect.x < 0 || frame.Rect.y < 0 ||
+                    frame.Rect.xMax > source.Texture.width || frame.Rect.yMax > source.Texture.height)
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.FrameRectInvalid,
+                        $"SourceFrame '{frame.FrameName}' 的 rect 越出 Texture 范围。"));
+                if (frame.Trimmed)
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.TrimmedUnsupported,
+                        $"SourceFrame '{frame.FrameName}' 使用了不支持的 trimmed。"));
+                if (frame.Rotated)
+                    preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.RotatedUnsupported,
+                        $"SourceFrame '{frame.FrameName}' 使用了不支持的 rotated。"));
+            }
+            if (document.TextureSize.x != source.Texture.width || document.TextureSize.y != source.Texture.height)
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.TextureSizeMismatch,
+                    $"meta.size {document.TextureSize.x}x{document.TextureSize.y} 与 Texture {source.Texture.width}x{source.Texture.height} 不一致。"));
+        }
+
+        private static void ValidateTextureOwnership(
+            FrameClip clip,
+            FrameClipImportSource source,
+            FrameClipImportPreview preview)
+        {
+            if (!source.ManageSpriteSlicing) return;
+            var owners = new List<string>();
+            foreach (var guid in AssetDatabase.FindAssets("t:FrameAnimationGraph"))
+            {
+                var graph = AssetDatabase.LoadAssetAtPath<FrameAnimationGraph>(AssetDatabase.GUIDToAssetPath(guid));
+                if (graph == null) continue;
+                owners.AddRange(graph.ImportSources.Where(item => item != null && item.IsEnabled &&
+                        item.ManageSpriteSlicing && item.Texture == source.Texture)
+                    .Select(item => $"Graph '{graph.name}' / {item.DisplayName}"));
+            }
+            foreach (var guid in AssetDatabase.FindAssets("t:FrameClip"))
+            {
+                var other = AssetDatabase.LoadAssetAtPath<FrameClip>(AssetDatabase.GUIDToAssetPath(guid));
+                var otherSource = other?.StandaloneImportSource;
+                if (other == null || other == clip || otherSource == null || !otherSource.ManageSpriteSlicing ||
+                    otherSource.Texture != source.Texture) continue;
+                owners.Add($"FrameClip '{other.name}'");
+            }
+            if (owners.Count > 0)
+                preview.AddIssue(Error(clip, FrameAnimationImportIssueCode.TextureOwnershipConflict,
+                    $"Texture '{source.Texture.name}' 已有其他可写来源：{string.Join(", ", owners)}"));
+        }
+
+        private static bool FramesEqual(FrameClip clip, FrameClipImportPreview preview)
+        {
+            if (clip.FrameCount != preview.SourceIndices.Count) return false;
+            for (var index = 0; index < preview.SourceIndices.Count; index++)
+            {
+                var sourceIndex = preview.SourceIndices[index];
+                var sourceFrame = preview.Document.Frames[sourceIndex];
+                var frame = clip.Frames[index];
+                if (frame == null || frame.SourceIndex != sourceIndex || frame.FrameName != sourceFrame.FrameName ||
+                    frame.DurationMs != sourceFrame.DurationMs ||
+                    !preview.SpritePlan.MatchesSprite(sourceIndex, frame.Sprite)) return false;
+            }
+            return true;
+        }
+
+        private static FrameAnimationSpriteSourceContext Context(FrameClip clip, FrameClipImportSource source)
+        {
+            return new FrameAnimationSpriteSourceContext(
+                AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(clip)),
+                source.Texture, source.AsepriteJson, source.Pivot, source.ManageSpriteSlicing);
+        }
+
+        private static bool IsExternalClip(FrameClip clip)
+        {
+            return clip != null && !AssetDatabase.IsSubAsset(clip) &&
+                   !string.IsNullOrEmpty(AssetDatabase.GetAssetPath(clip));
+        }
+
+        private static FrameAnimationImportIssue Error(
+            FrameClip clip,
+            FrameAnimationImportIssueCode code,
+            string message)
+        {
+            var path = clip != null ? AssetDatabase.GetAssetPath(clip) : string.Empty;
+            return new FrameAnimationImportIssue(
+                FrameAnimationValidationSeverity.Error,
+                code,
+                AssetDatabase.AssetPathToGUID(path),
+                clip != null ? clip.Id : string.Empty,
+                message);
+        }
+    }
+}
diff --git a/Assets/Editor/FrameAnimation/FrameClipImportService.cs.meta b/Assets/Editor/FrameAnimation/FrameClipImportService.cs.meta
new file mode 100644
index 000000000..fb809d2e9
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipImportService.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4448f0db0909671479f225061710e439
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs b/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs
new file mode 100644
index 000000000..06b6f1f3a
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs
@@ -0,0 +1,51 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace AibisDream.FrameAnimation.Editor
+{
+    [CustomEditor(typeof(FrameClipPlayer))]
+    public sealed class FrameClipPlayerEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("clip"));
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("playOnEnable"));
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("speed"));
+            DrawWarnings();
+            serializedObject.ApplyModifiedProperties();
+
+            if (!Application.isPlaying) return;
+            var player = (FrameClipPlayer)target;
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Runtime State", EditorStyles.boldLabel);
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.EnumPopup("State", player.State);
+                EditorGUILayout.ObjectField("Clip", player.CurrentClip, typeof(FrameClip), false);
+                EditorGUILayout.TextField("Clip ID", player.CurrentClipId);
+                EditorGUILayout.IntField("Frame", player.CurrentFrameIndex);
+            }
+            Repaint();
+        }
+
+        private void DrawWarnings()
+        {
+            var player = (FrameClipPlayer)target;
+            var renderer = player.GetComponent<SpriteRenderer>();
+            var image = player.GetComponent<Image>();
+            if (player.GetComponent<FrameAnimationPlayer>() != null)
+                EditorGUILayout.HelpBox("同一 GameObject 不能同时包含 FrameAnimationPlayer 和 FrameClipPlayer。", MessageType.Error);
+            if (renderer == null && image == null)
+                EditorGUILayout.HelpBox("同一 GameObject 上必须存在一个 SpriteRenderer 或 Image。", MessageType.Error);
+            else if (renderer != null && image != null)
+                EditorGUILayout.HelpBox("同一 GameObject 不能同时存在 SpriteRenderer 和 Image。", MessageType.Error);
+            if (serializedObject.FindProperty("clip").objectReferenceValue == null)
+                EditorGUILayout.HelpBox("尚未绑定默认 FrameClip；仍可通过 Play(FrameClip) 临时播放。", MessageType.Info);
+            var value = serializedObject.FindProperty("speed").floatValue;
+            if (!FrameAnimationValueUtility.IsValidSpeed(value))
+                EditorGUILayout.HelpBox("Speed 必须是有限且不小于 0 的数值。", MessageType.Error);
+        }
+    }
+}
diff --git a/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs.meta b/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs.meta
new file mode 100644
index 000000000..87e406281
--- /dev/null
+++ b/Assets/Editor/FrameAnimation/FrameClipPlayerEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d7eddf60189f61740be2fe59cda06957
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/GameContent/Test/FrameAnimation/Preview/PreviewSampleGraph.asset b/Assets/GameContent/Test/FrameAnimation/Preview/PreviewSampleGraph.asset
index f88352e8f..df72d6359 100644
--- a/Assets/GameContent/Test/FrameAnimation/Preview/PreviewSampleGraph.asset
+++ b/Assets/GameContent/Test/FrameAnimation/Preview/PreviewSampleGraph.asset
@@ -30,6 +30,14 @@ MonoBehaviour:
     importSourceId: 
     sourceTagName: 
     isMissingFromSource: 0
+  hasStandaloneImportSource: 0
+  standaloneImportSource:
+    texture: {fileID: 0}
+    asepriteJson: {fileID: 0}
+    pivot: {x: 0.5, y: 0.5}
+    manageSpriteSlicing: 0
+    lastSourceHash: 
+    lastImportedTagName: 
 --- !u!114 &-1587622970102939646
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -64,6 +72,14 @@ MonoBehaviour:
     importSourceId: 
     sourceTagName: 
     isMissingFromSource: 0
+  hasStandaloneImportSource: 0
+  standaloneImportSource:
+    texture: {fileID: 0}
+    asepriteJson: {fileID: 0}
+    pivot: {x: 0.5, y: 0.5}
+    manageSpriteSlicing: 0
+    lastSourceHash: 
+    lastImportedTagName: 
 --- !u!114 &11400000
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -241,3 +257,11 @@ MonoBehaviour:
     importSourceId: 
     sourceTagName: 
     isMissingFromSource: 0
+  hasStandaloneImportSource: 0
+  standaloneImportSource:
+    texture: {fileID: 0}
+    asepriteJson: {fileID: 0}
+    pivot: {x: 0.5, y: 0.5}
+    manageSpriteSlicing: 0
+    lastSourceHash: 
+    lastImportedTagName: 
diff --git a/Assets/Scripts/FrameAnimation/Runtime/AssemblyInfo.cs b/Assets/Scripts/FrameAnimation/Runtime/AssemblyInfo.cs
index f9c13e6e9..9a8dbb09e 100644
--- a/Assets/Scripts/FrameAnimation/Runtime/AssemblyInfo.cs
+++ b/Assets/Scripts/FrameAnimation/Runtime/AssemblyInfo.cs
@@ -1,5 +1,6 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Editor")]
+[assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Timeline")]
 [assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Tests.EditMode")]
 [assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Tests.PlayMode")]
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationData.cs b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationData.cs
index 347a8f3d8..078b49095 100644
--- a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationData.cs
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationData.cs
@@ -56,6 +56,34 @@ namespace AibisDream.FrameAnimation
         }
     }
 
+    /// <summary>
+    /// Editor-time source settings owned by an external FrameClip asset.
+    /// This is intentionally separate from graph-owned FrameClipImportInfo.
+    /// </summary>
+    [Serializable]
+    public sealed class FrameClipImportSource
+    {
+        [SerializeField] private Texture2D texture;
+        [SerializeField] private TextAsset asepriteJson;
+        [SerializeField] private Vector2 pivot = new Vector2(0.5f, 0.5f);
+        [SerializeField] private bool manageSpriteSlicing;
+        [SerializeField] private string lastSourceHash = string.Empty;
+        [SerializeField] private string lastImportedTagName = string.Empty;
+
+        public Texture2D Texture => texture;
+        public TextAsset AsepriteJson => asepriteJson;
+        public Vector2 Pivot => pivot;
+        public bool ManageSpriteSlicing => manageSpriteSlicing;
+        public string LastSourceHash => lastSourceHash;
+        public string LastImportedTagName => lastImportedTagName;
+
+        internal void SetLastImport(string sourceHash, string tagName)
+        {
+            lastSourceHash = sourceHash ?? string.Empty;
+            lastImportedTagName = tagName ?? string.Empty;
+        }
+    }
+
     [Serializable]
     public sealed class AnimationFlow
     {
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationPlayer.cs b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationPlayer.cs
index 698a55b46..82ebc0089 100644
--- a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationPlayer.cs
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationPlayer.cs
@@ -407,6 +407,15 @@ namespace AibisDream.FrameAnimation
             out IFrameAnimationTarget resolvedTarget,
             out FrameAnimationPlaybackError error)
         {
+            if (GetComponent<FrameClipPlayer>() != null)
+            {
+                resolvedTarget = null;
+                error = new FrameAnimationPlaybackError(
+                    FrameAnimationPlaybackErrorCode.TargetConflict,
+                    "同一 GameObject 不能同时包含 FrameAnimationPlayer 和 FrameClipPlayer。");
+                return false;
+            }
+
             var spriteRenderer = GetComponent<SpriteRenderer>();
             var image = GetComponent<Image>();
             if (spriteRenderer != null && image != null)
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationResolver.cs b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationResolver.cs
index b41573ef2..13d604f4c 100644
--- a/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationResolver.cs
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameAnimationResolver.cs
@@ -135,15 +135,14 @@ namespace AibisDream.FrameAnimation
 
             if (clipMatches.Count == 1)
             {
-                return TryResolveClip(clipMatches[0], playableId, options, out plan, out error);
+                return TryResolveClip(clipMatches[0], options, out plan, out error);
             }
 
             return TryResolveFlow(graph, flowMatches[0], options, out plan, out error);
         }
 
-        private static bool TryResolveClip(
+        internal static bool TryResolveClip(
             FrameClip clip,
-            string playableId,
             FrameAnimationPlayOptions options,
             out ResolvedPlaybackPlan plan,
             out FrameAnimationPlaybackError error)
@@ -156,7 +155,7 @@ namespace AibisDream.FrameAnimation
 
             var endBehavior = options.EndBehaviorOverride ?? clip.DefaultEndBehavior;
             plan = new ResolvedPlaybackPlan(
-                playableId,
+                clip != null ? clip.Id : string.Empty,
                 false,
                 new[] { new ResolvedPlaybackStep(clip, string.Empty, clip.Speed, endBehavior) });
             return true;
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameClip.cs b/Assets/Scripts/FrameAnimation/Runtime/FrameClip.cs
index 9f86d50ee..187e7a12a 100644
--- a/Assets/Scripts/FrameAnimation/Runtime/FrameClip.cs
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameClip.cs
@@ -13,6 +13,8 @@ namespace AibisDream.FrameAnimation
         [SerializeField] private FrameClipEndBehavior defaultEndBehavior = FrameClipEndBehavior.HoldLastFrame;
         [SerializeField] private bool hasImportInfo;
         [SerializeField] private FrameClipImportInfo importInfo;
+        [SerializeField] private bool hasStandaloneImportSource;
+        [SerializeField] private FrameClipImportSource standaloneImportSource;
 
         public string Id => id;
         public string DisplayName => displayName;
@@ -21,6 +23,9 @@ namespace AibisDream.FrameAnimation
         public FrameClipEndBehavior DefaultEndBehavior => defaultEndBehavior;
         public FrameClipImportInfo ImportInfo => hasImportInfo ? importInfo : null;
         public bool IsImported => ImportInfo != null;
+        public FrameClipImportSource StandaloneImportSource =>
+            hasStandaloneImportSource ? standaloneImportSource : null;
+        public bool HasStandaloneImportSource => StandaloneImportSource != null;
 
         public int FrameCount => frames?.Count ?? 0;
 
@@ -115,5 +120,18 @@ namespace AibisDream.FrameAnimation
                 ? new List<FrameAnimationFrame>(value)
                 : new List<FrameAnimationFrame>();
         }
+
+        internal FrameClipImportSource GetOrCreateStandaloneImportSource()
+        {
+            standaloneImportSource ??= new FrameClipImportSource();
+            hasStandaloneImportSource = true;
+            return standaloneImportSource;
+        }
+
+        internal void ClearStandaloneImportSource()
+        {
+            hasStandaloneImportSource = false;
+            standaloneImportSource = null;
+        }
     }
 }
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs b/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs
new file mode 100644
index 000000000..7d110ac7a
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs
@@ -0,0 +1,583 @@
+using System;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace AibisDream.FrameAnimation
+{
+    [DisallowMultipleComponent]
+    public sealed class FrameClipPlayer : MonoBehaviour
+    {
+        [SerializeField] private FrameClip clip;
+        [SerializeField] private bool playOnEnable;
+        [SerializeField] private float speed = 1f;
+
+        private static long nextRequestId;
+        private IFrameAnimationTarget target;
+        private FrameAnimationPlaybackSession session;
+        private FrameAnimationPlaybackHandle activeHandle;
+        private FrameAnimationPlaybackState state = FrameAnimationPlaybackState.Stopped;
+        private bool skipInitialPlayOnEnable;
+        private bool timelineControlled;
+        private FrameClip timelineClip;
+        private Sprite timelineBaselineSprite;
+        private bool timelineBaselineEnabled;
+
+        public FrameClip Clip => clip;
+        public bool PlayOnEnable => playOnEnable;
+        public FrameAnimationPlaybackState State => state;
+        public FrameClip CurrentClip => session?.CurrentClip;
+        public string CurrentClipId => session?.CurrentClipId ?? string.Empty;
+        public int CurrentFrameIndex => session?.CurrentFrameIndex ?? -1;
+        public float Speed => speed;
+
+        private void Awake()
+        {
+            skipInitialPlayOnEnable = playOnEnable;
+            if (TryCreateTarget(out var resolvedTarget, out _))
+            {
+                target = resolvedTarget;
+            }
+        }
+
+        private void OnEnable()
+        {
+            if (!playOnEnable) return;
+            if (skipInitialPlayOnEnable)
+            {
+                skipInitialPlayOnEnable = false;
+                return;
+            }
+            TryAutoPlay();
+        }
+
+        private void Start()
+        {
+            if (playOnEnable) TryAutoPlay();
+        }
+
+        private void TryAutoPlay()
+        {
+            var handle = Play();
+            if (handle.IsCompleted && handle.Result.Reason == FrameAnimationCompletionReason.Failed)
+            {
+                Debug.LogError($"FrameClipPlayer 自动播放失败：{handle.Result.Error}", this);
+            }
+        }
+
+        private void Update()
+        {
+            if (timelineControlled) return;
+            Evaluate(Time.deltaTime);
+        }
+
+        private void OnDisable()
+        {
+            ReleaseTimelineControl(null);
+            TerminateActive(FrameAnimationCompletionReason.Stopped, FrameAnimationPlaybackError.None);
+        }
+
+        private void OnDestroy()
+        {
+            ReleaseTimelineControl(null);
+            TerminateActive(FrameAnimationCompletionReason.Stopped, FrameAnimationPlaybackError.None);
+        }
+
+        public FrameAnimationPlaybackHandle Play()
+        {
+            return PlayInternal(clip, default);
+        }
+
+        public FrameAnimationPlaybackHandle Play(FrameAnimationPlayOptions options)
+        {
+            return PlayInternal(clip, options);
+        }
+
+        public FrameAnimationPlaybackHandle Play(FrameClip value)
+        {
+            return PlayInternal(value, default);
+        }
+
+        public FrameAnimationPlaybackHandle Play(FrameClip value, FrameAnimationPlayOptions options)
+        {
+            return PlayInternal(value, options);
+        }
+
+        public FrameAnimationPlaybackHandle RestoreTerminalState()
+        {
+            return RestoreTerminalState(clip);
+        }
+
+        public FrameAnimationPlaybackHandle RestoreTerminalState(FrameClip value)
+        {
+            ReleaseTimelineControl(null);
+            var requestId = Interlocked.Increment(ref nextRequestId);
+            var handle = new FrameAnimationPlaybackHandle(requestId);
+            var playableId = value != null ? value.Id : string.Empty;
+            if (!TryPrepare(value, default, handle, out var plan, out var resolvedTarget)) return handle;
+
+            if (activeHandle != null && !activeHandle.IsCompleted)
+            {
+                CompleteHandle(activeHandle, CurrentClipId, FrameAnimationCompletionReason.Replaced,
+                    FrameAnimationPlaybackError.None);
+            }
+
+            target = resolvedTarget;
+            target.Enabled = true;
+            var terminalStep = plan.Steps[plan.Steps.Count - 1];
+            if (terminalStep.TerminalEndBehavior == FrameClipEndBehavior.Loop)
+            {
+                session = new FrameAnimationPlaybackSession(plan);
+                activeHandle = handle;
+                state = FrameAnimationPlaybackState.Playing;
+                session.Start(ApplySprite);
+                return handle;
+            }
+
+            ApplySprite(terminalStep.Clip.Frames[terminalStep.Clip.FrameCount - 1]?.Sprite);
+            ApplyEndBehavior(terminalStep.TerminalEndBehavior);
+            session = null;
+            activeHandle = null;
+            state = FrameAnimationPlaybackState.Stopped;
+            CompleteHandle(handle, playableId, FrameAnimationCompletionReason.Completed,
+                FrameAnimationPlaybackError.None);
+            return handle;
+        }
+
+        public CustomYieldInstruction WaitForFirstPass(FrameAnimationPlaybackHandle playbackHandle)
+        {
+            if (playbackHandle == null) throw new ArgumentNullException(nameof(playbackHandle));
+            return new FirstPassYieldInstruction(this, playbackHandle);
+        }
+
+        public void Stop(FrameAnimationStopMode mode = FrameAnimationStopMode.HoldCurrentFrame)
+        {
+            ReleaseTimelineControl(null);
+            TerminateActive(FrameAnimationCompletionReason.Stopped, FrameAnimationPlaybackError.None);
+            if (target == null || !target.IsValid)
+            {
+                if (!TryCreateTarget(out var resolvedTarget, out _)) return;
+                target = resolvedTarget;
+            }
+            ApplyStopMode(mode);
+        }
+
+        public void Pause()
+        {
+            if (state == FrameAnimationPlaybackState.Playing && session != null)
+                state = FrameAnimationPlaybackState.Paused;
+        }
+
+        public void Resume()
+        {
+            if (state == FrameAnimationPlaybackState.Paused && session != null)
+                state = FrameAnimationPlaybackState.Playing;
+        }
+
+        public void SetSpeed(float value)
+        {
+            if (!FrameAnimationValueUtility.IsValidSpeed(value))
+            {
+                Debug.LogError($"FrameClipPlayer speed 必须是有限且不小于 0 的数值，收到：{value}", this);
+                return;
+            }
+            speed = value;
+        }
+
+        internal void ConfigureForAuthoring(FrameClip value, bool shouldPlayOnEnable, float playerSpeed)
+        {
+            clip = value;
+            playOnEnable = shouldPlayOnEnable;
+            speed = playerSpeed;
+        }
+
+        internal void EvaluateForTests(double deltaTimeSeconds)
+        {
+            Evaluate(deltaTimeSeconds);
+        }
+
+        internal FrameAnimationPlaybackError BeginTimelineControl()
+        {
+            if (timelineControlled)
+            {
+                return FrameAnimationPlaybackError.None;
+            }
+
+            if (!TryCreateTarget(out var resolvedTarget, out var targetError))
+            {
+                return targetError;
+            }
+
+            TerminateActive(
+                FrameAnimationCompletionReason.Replaced,
+                FrameAnimationPlaybackError.None);
+            target = resolvedTarget;
+            timelineBaselineSprite = target.Sprite;
+            timelineBaselineEnabled = target.Enabled;
+            timelineClip = null;
+            timelineControlled = true;
+            state = FrameAnimationPlaybackState.Stopped;
+            return FrameAnimationPlaybackError.None;
+        }
+
+        internal FrameAnimationPlaybackError SampleTimeline(FrameClip value, double timeSeconds)
+        {
+            var beginError = BeginTimelineControl();
+            if (beginError.Code != FrameAnimationPlaybackErrorCode.None)
+            {
+                return beginError;
+            }
+
+            if (value == null)
+            {
+                return new FrameAnimationPlaybackError(
+                    FrameAnimationPlaybackErrorCode.PlayableNotFound,
+                    "Timeline Clip 没有绑定 FrameClip。");
+            }
+
+            if (timelineClip != value || session == null)
+            {
+                if (!FrameAnimationResolver.TryResolveClip(
+                        value,
+                        default,
+                        out var plan,
+                        out var resolveError))
+                {
+                    session = null;
+                    timelineClip = null;
+                    state = FrameAnimationPlaybackState.Stopped;
+                    return resolveError;
+                }
+
+                timelineClip = value;
+                session = new FrameAnimationPlaybackSession(plan);
+                session.Start(ApplySprite);
+            }
+
+            target.Enabled = true;
+            state = FrameAnimationPlaybackState.Playing;
+            var evaluation = session.Seek(Math.Max(0d, timeSeconds), ApplySprite);
+            if (evaluation.IsFailed)
+            {
+                session = null;
+                timelineClip = null;
+                state = FrameAnimationPlaybackState.Stopped;
+                return evaluation.Error;
+            }
+
+            if (evaluation.IsCompleted)
+            {
+                ApplyEndBehavior(evaluation.EndBehavior);
+            }
+
+            return FrameAnimationPlaybackError.None;
+        }
+
+        internal FrameAnimationPlaybackError ApplyTimelineEndBehavior(FrameClip value)
+        {
+            var beginError = BeginTimelineControl();
+            if (beginError.Code != FrameAnimationPlaybackErrorCode.None)
+            {
+                return beginError;
+            }
+
+            if (value == null)
+            {
+                return new FrameAnimationPlaybackError(
+                    FrameAnimationPlaybackErrorCode.PlayableNotFound,
+                    "Timeline Clip 没有绑定 FrameClip。");
+            }
+
+            if (value.DefaultEndBehavior == FrameClipEndBehavior.Loop)
+            {
+                if (timelineClip == value && session != null)
+                {
+                    return FrameAnimationPlaybackError.None;
+                }
+
+                var duration = GetEffectiveClipDurationSeconds(value);
+                return SampleTimeline(value, Math.Max(0d, duration - 0.000001d));
+            }
+
+            var sampleError = SampleTimeline(value, GetEffectiveClipDurationSeconds(value));
+            if (sampleError.Code == FrameAnimationPlaybackErrorCode.None)
+            {
+                ApplyEndBehavior(value.DefaultEndBehavior);
+            }
+            return sampleError;
+        }
+
+        internal void RestoreTimelineBaseline()
+        {
+            if (!timelineControlled || target == null || !target.IsValid) return;
+            target.Sprite = timelineBaselineSprite;
+            target.Enabled = timelineBaselineEnabled;
+            session = null;
+            timelineClip = null;
+            state = FrameAnimationPlaybackState.Stopped;
+        }
+
+        internal void ReleaseTimelineControl(FrameClip terminalClip)
+        {
+            if (!timelineControlled) return;
+
+            if (terminalClip != null)
+            {
+                ApplyTimelineEndBehavior(terminalClip);
+            }
+            else
+            {
+                RestoreTimelineBaseline();
+            }
+
+            timelineControlled = false;
+            timelineClip = null;
+            session = null;
+            state = FrameAnimationPlaybackState.Stopped;
+        }
+
+        private static double GetEffectiveClipDurationSeconds(FrameClip value)
+        {
+            if (value == null || value.TotalDurationMs <= 0 || value.Speed <= 0f)
+            {
+                return 0d;
+            }
+            return value.TotalDurationMs / 1000d / value.Speed;
+        }
+
+        private void Evaluate(double deltaTimeSeconds)
+        {
+            if (state != FrameAnimationPlaybackState.Playing || session == null) return;
+            if (target == null || !target.IsValid)
+            {
+                FailActive(FrameAnimationPlaybackErrorCode.TargetMissing, "播放期间显示目标失效。");
+                return;
+            }
+            if (session.CurrentClip == null)
+            {
+                FailActive(FrameAnimationPlaybackErrorCode.InvalidPlayableData, "播放期间 Clip 数据失效。");
+                return;
+            }
+            if (!FrameAnimationValueUtility.IsValidSpeed(speed))
+            {
+                FailActive(FrameAnimationPlaybackErrorCode.InvalidSpeed, "播放期间 Player speed 变为无效值。");
+                return;
+            }
+
+            var evaluation = session.Evaluate(deltaTimeSeconds, speed, ApplySprite);
+            if (evaluation.IsFailed) FailActive(evaluation.Error.Code, evaluation.Error.Message);
+            else if (evaluation.IsCompleted) CompleteNaturally(evaluation.EndBehavior);
+        }
+
+        private FrameAnimationPlaybackHandle PlayInternal(FrameClip value, FrameAnimationPlayOptions options)
+        {
+            ReleaseTimelineControl(null);
+            var handle = new FrameAnimationPlaybackHandle(Interlocked.Increment(ref nextRequestId));
+            if (!TryPrepare(value, options, handle, out var plan, out var resolvedTarget)) return handle;
+
+            if (activeHandle != null && !activeHandle.IsCompleted)
+            {
+                CompleteHandle(activeHandle, CurrentClipId, FrameAnimationCompletionReason.Replaced,
+                    FrameAnimationPlaybackError.None);
+            }
+
+            session = new FrameAnimationPlaybackSession(plan);
+            activeHandle = handle;
+            state = FrameAnimationPlaybackState.Playing;
+            target = resolvedTarget;
+            target.Enabled = true;
+            session.Start(ApplySprite);
+            return handle;
+        }
+
+        private bool TryPrepare(
+            FrameClip value,
+            FrameAnimationPlayOptions options,
+            FrameAnimationPlaybackHandle handle,
+            out ResolvedPlaybackPlan plan,
+            out IFrameAnimationTarget resolvedTarget)
+        {
+            plan = null;
+            resolvedTarget = null;
+            var playableId = value != null ? value.Id : string.Empty;
+            if (!isActiveAndEnabled)
+            {
+                CompleteFailed(handle, playableId, FrameAnimationPlaybackErrorCode.PlayerNotReady,
+                    "FrameClipPlayer 未启用或 GameObject 未激活。");
+                return false;
+            }
+            if (value == null)
+            {
+                CompleteFailed(handle, playableId, FrameAnimationPlaybackErrorCode.PlayableNotFound,
+                    "FrameClipPlayer 没有可播放的 FrameClip。");
+                return false;
+            }
+            if (!FrameAnimationValueUtility.IsValidSpeed(speed))
+            {
+                CompleteFailed(handle, playableId, FrameAnimationPlaybackErrorCode.InvalidSpeed,
+                    "FrameClipPlayer speed 无效。");
+                return false;
+            }
+            if (!TryCreateTarget(out resolvedTarget, out var targetError))
+            {
+                CompleteFailed(handle, playableId, targetError.Code, targetError.Message);
+                return false;
+            }
+            if (!FrameAnimationResolver.TryResolveClip(value, options, out plan, out var resolveError))
+            {
+                CompleteFailed(handle, playableId, resolveError.Code, resolveError.Message);
+                return false;
+            }
+            return true;
+        }
+
+        private bool TryCreateTarget(out IFrameAnimationTarget resolvedTarget, out FrameAnimationPlaybackError error)
+        {
+            if (GetComponent<FrameAnimationPlayer>() != null)
+            {
+                resolvedTarget = null;
+                error = new FrameAnimationPlaybackError(FrameAnimationPlaybackErrorCode.TargetConflict,
+                    "同一 GameObject 不能同时包含 FrameAnimationPlayer 和 FrameClipPlayer。");
+                return false;
+            }
+            var spriteRenderer = GetComponent<SpriteRenderer>();
+            var image = GetComponent<Image>();
+            if (spriteRenderer != null && image != null)
+            {
+                resolvedTarget = null;
+                error = new FrameAnimationPlaybackError(FrameAnimationPlaybackErrorCode.TargetConflict,
+                    "FrameClipPlayer 所在对象不能同时包含 SpriteRenderer 和 Image。");
+                return false;
+            }
+            if (spriteRenderer == null && image == null)
+            {
+                resolvedTarget = null;
+                error = new FrameAnimationPlaybackError(FrameAnimationPlaybackErrorCode.TargetMissing,
+                    "FrameClipPlayer 所在对象缺少 SpriteRenderer 或 Image。");
+                return false;
+            }
+            resolvedTarget = spriteRenderer != null
+                ? new SpriteRendererFrameAnimationTarget(spriteRenderer)
+                : new ImageFrameAnimationTarget(image);
+            error = FrameAnimationPlaybackError.None;
+            return true;
+        }
+
+        private static FrameAnimationPlaybackHandle CompleteFailed(
+            FrameAnimationPlaybackHandle handle,
+            string playableId,
+            FrameAnimationPlaybackErrorCode code,
+            string message)
+        {
+            CompleteHandle(handle, playableId, FrameAnimationCompletionReason.Failed,
+                new FrameAnimationPlaybackError(code, message));
+            return handle;
+        }
+
+        private void CompleteNaturally(FrameClipEndBehavior endBehavior)
+        {
+            var handle = activeHandle;
+            var playableId = CurrentClipId;
+            ApplyEndBehavior(endBehavior);
+            session = null;
+            activeHandle = null;
+            state = FrameAnimationPlaybackState.Stopped;
+            CompleteHandle(handle, playableId, FrameAnimationCompletionReason.Completed,
+                FrameAnimationPlaybackError.None);
+        }
+
+        private void FailActive(FrameAnimationPlaybackErrorCode code, string message)
+        {
+            var handle = activeHandle;
+            var playableId = CurrentClipId;
+            session = null;
+            activeHandle = null;
+            state = FrameAnimationPlaybackState.Stopped;
+            CompleteHandle(handle, playableId, FrameAnimationCompletionReason.Failed,
+                new FrameAnimationPlaybackError(code, message));
+        }
+
+        private void TerminateActive(FrameAnimationCompletionReason reason, FrameAnimationPlaybackError error)
+        {
+            if (activeHandle == null || activeHandle.IsCompleted)
+            {
+                session = null;
+                activeHandle = null;
+                state = FrameAnimationPlaybackState.Stopped;
+                return;
+            }
+            var handle = activeHandle;
+            var playableId = CurrentClipId;
+            session = null;
+            activeHandle = null;
+            state = FrameAnimationPlaybackState.Stopped;
+            CompleteHandle(handle, playableId, reason, error);
+        }
+
+        private static void CompleteHandle(
+            FrameAnimationPlaybackHandle handle,
+            string playableId,
+            FrameAnimationCompletionReason reason,
+            FrameAnimationPlaybackError error)
+        {
+            handle?.TryComplete(new FrameAnimationPlaybackResult(handle.RequestId, playableId, reason, error));
+        }
+
+        private void ApplySprite(Sprite sprite)
+        {
+            if (target != null && target.IsValid) target.Sprite = sprite;
+        }
+
+        private bool ShouldWaitForFirstPass(FrameAnimationPlaybackHandle playbackHandle)
+        {
+            return !playbackHandle.IsCompleted && activeHandle == playbackHandle && session != null &&
+                   !session.HasCompletedFirstTerminalLoopCycle;
+        }
+
+        private sealed class FirstPassYieldInstruction : CustomYieldInstruction
+        {
+            private readonly FrameClipPlayer player;
+            private readonly FrameAnimationPlaybackHandle playbackHandle;
+
+            public FirstPassYieldInstruction(FrameClipPlayer player, FrameAnimationPlaybackHandle playbackHandle)
+            {
+                this.player = player;
+                this.playbackHandle = playbackHandle;
+            }
+
+            public override bool keepWaiting =>
+                player != null && player.ShouldWaitForFirstPass(playbackHandle);
+        }
+
+        private void ApplyEndBehavior(FrameClipEndBehavior endBehavior)
+        {
+            switch (endBehavior)
+            {
+                case FrameClipEndBehavior.Clear:
+                    if (target != null && target.IsValid)
+                    {
+                        target.Enabled = true;
+                        target.Sprite = null;
+                    }
+                    break;
+                case FrameClipEndBehavior.HideTarget:
+                    if (target != null && target.IsValid) target.Enabled = false;
+                    break;
+            }
+        }
+
+        private void ApplyStopMode(FrameAnimationStopMode mode)
+        {
+            switch (mode)
+            {
+                case FrameAnimationStopMode.Clear:
+                    target.Enabled = true;
+                    target.Sprite = null;
+                    break;
+                case FrameAnimationStopMode.HideTarget:
+                    target.Enabled = false;
+                    break;
+            }
+        }
+    }
+}
diff --git a/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs.meta b/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs.meta
new file mode 100644
index 000000000..a270d6f1b
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Runtime/FrameClipPlayer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 192967735fd44d642bee1a6c5ba29717
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline.meta b/Assets/Scripts/FrameAnimation/Timeline.meta
new file mode 100644
index 000000000..3841aa293
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 66e7d3aa7a5d4bf3838316bbebed8117
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef b/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef
new file mode 100644
index 000000000..1561cc323
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef
@@ -0,0 +1,18 @@
+{
+  "name": "AibisDream.FrameAnimation.Timeline",
+  "rootNamespace": "AibisDream.FrameAnimation.Timeline",
+  "references": [
+    "AibisDream.FrameAnimation.Runtime",
+    "Unity.Timeline",
+    "UnityEngine.UI"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef.meta b/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef.meta
new file mode 100644
index 000000000..b3e6a0349
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/AibisDream.FrameAnimation.Timeline.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2a8d75ec8acb4b18ae787ed85e8401b8
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs b/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs
new file mode 100644
index 000000000..881d4074b
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs
@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Tests.EditMode")]
+[assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Tests.PlayMode")]
+[assembly: InternalsVisibleTo("AibisDream.FrameAnimation.Timeline.Editor")]
diff --git a/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs.meta b/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs.meta
new file mode 100644
index 000000000..de5dcffb6
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/AssemblyInfo.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: df7035ef1c2d40218ccf85f294e34735
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/Editor.meta b/Assets/Scripts/FrameAnimation/Timeline/Editor.meta
new file mode 100644
index 000000000..94df01371
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b32641aa64c6449994fe91525598e451
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef b/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef
new file mode 100644
index 000000000..d24c0ce88
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef
@@ -0,0 +1,21 @@
+{
+  "name": "AibisDream.FrameAnimation.Timeline.Editor",
+  "rootNamespace": "AibisDream.FrameAnimation.Timeline.Editor",
+  "references": [
+    "AibisDream.FrameAnimation.Runtime",
+    "AibisDream.FrameAnimation.Timeline",
+    "Unity.Timeline",
+    "Unity.Timeline.Editor"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}
diff --git a/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef.meta b/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef.meta
new file mode 100644
index 000000000..7b5694a77
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/Editor/AibisDream.FrameAnimation.Timeline.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7dcd49d5096747bda63e1b94c699b67b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs b/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs
new file mode 100644
index 000000000..431d7a0f7
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs
@@ -0,0 +1,51 @@
+using UnityEditor.Timeline;
+using UnityEngine.Timeline;
+
+namespace AibisDream.FrameAnimation.Timeline.Editor
+{
+    [CustomTimelineEditor(typeof(FrameAnimationTimelineClip))]
+    internal sealed class FrameAnimationTimelineClipEditor : ClipEditor
+    {
+        public override void OnCreate(TimelineClip clip, TrackAsset track, TimelineClip clonedFrom)
+        {
+            base.OnCreate(clip, track, clonedFrom);
+            SynchronizeSource(clip);
+        }
+
+        public override void OnClipChanged(TimelineClip clip)
+        {
+            base.OnClipChanged(clip);
+            SynchronizeSource(clip);
+        }
+
+        public override ClipDrawOptions GetClipOptions(TimelineClip clip)
+        {
+            var options = base.GetClipOptions(clip);
+            if (clip?.asset is not FrameAnimationTimelineClip asset)
+            {
+                return options;
+            }
+
+            if (asset.FrameClip == null)
+            {
+                options.errorText = "未指定 FrameClip";
+            }
+            return options;
+        }
+
+        private static void SynchronizeSource(TimelineClip clip)
+        {
+            if (clip?.asset is not FrameAnimationTimelineClip asset ||
+                !asset.TrySynchronizeSourceDuration(out var duration))
+            {
+                return;
+            }
+
+            clip.duration = duration;
+            clip.displayName = asset.FrameClip != null &&
+                               !string.IsNullOrEmpty(asset.FrameClip.DisplayName)
+                ? asset.FrameClip.DisplayName
+                : "Frame Animation Clip";
+        }
+    }
+}
diff --git a/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs.meta b/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs.meta
new file mode 100644
index 000000000..bc85d1d6f
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/Editor/FrameAnimationTimelineClipEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9f814325d9449478d6688741c38204f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs
new file mode 100644
index 000000000..d2682d85c
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs
@@ -0,0 +1,76 @@
+using System;
+using System.ComponentModel;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace AibisDream.FrameAnimation.Timeline
+{
+    [Serializable]
+    [DisplayName("Frame Animation Clip")]
+    public sealed class FrameAnimationTimelineClip : PlayableAsset, ITimelineClipAsset
+    {
+        private const double FallbackDurationSeconds = 1d;
+
+        [SerializeField, Tooltip("要由 Timeline 播放的独立 FrameClip 资产。")]
+        private FrameClip frameClip;
+        [SerializeField, HideInInspector] private FrameClip synchronizedDurationSource;
+        [SerializeField, HideInInspector] private bool hasSynchronizedDuration;
+
+        public FrameClip FrameClip => frameClip;
+
+        public override double duration => GetEffectiveDuration(frameClip);
+
+        public ClipCaps clipCaps
+        {
+            get
+            {
+                var caps = ClipCaps.ClipIn | ClipCaps.SpeedMultiplier;
+                if (frameClip != null && frameClip.DefaultEndBehavior == FrameClipEndBehavior.Loop)
+                {
+                    caps |= ClipCaps.Looping;
+                }
+                return caps;
+            }
+        }
+
+        public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
+        {
+            var playable = ScriptPlayable<FrameAnimationTimelineBehaviour>.Create(graph);
+            playable.GetBehaviour().FrameClip = frameClip;
+            return playable;
+        }
+
+        internal void SetFrameClipForTests(FrameClip value)
+        {
+            frameClip = value;
+        }
+
+        internal bool TrySynchronizeSourceDuration(out double sourceDuration)
+        {
+            sourceDuration = duration;
+            if (hasSynchronizedDuration && synchronizedDurationSource == frameClip)
+            {
+                return false;
+            }
+
+            synchronizedDurationSource = frameClip;
+            hasSynchronizedDuration = true;
+            return true;
+        }
+
+        internal static double GetEffectiveDuration(FrameClip value)
+        {
+            if (value == null || value.TotalDurationMs <= 0 || value.Speed <= 0f)
+            {
+                return FallbackDurationSeconds;
+            }
+            return value.TotalDurationMs / 1000d / value.Speed;
+        }
+    }
+
+    internal sealed class FrameAnimationTimelineBehaviour : PlayableBehaviour
+    {
+        internal FrameClip FrameClip { get; set; }
+    }
+}
diff --git a/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs.meta b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs.meta
new file mode 100644
index 000000000..c76eec70f
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTimelineClip.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c908631f9d7446ac86914dce3f1927af
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs
new file mode 100644
index 000000000..b874ae874
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+using UnityEngine.UI;
+
+namespace AibisDream.FrameAnimation.Timeline
+{
+    [DisplayName("Frame Animation Track")]
+    [TrackColor(0.35f, 0.72f, 0.95f)]
+    [TrackBindingType(typeof(FrameClipPlayer))]
+    [TrackClipType(typeof(FrameAnimationTimelineClip))]
+    public sealed class FrameAnimationTrack : TrackAsset
+    {
+        public override Playable CreateTrackMixer(PlayableGraph graph, GameObject go, int inputCount)
+        {
+            var playable = ScriptPlayable<FrameAnimationTrackMixerBehaviour>.Create(graph, inputCount);
+            playable.GetBehaviour().SetClips(
+                GetClips()
+                    .Select((clip, index) => new FrameAnimationTimelineClipInfo(clip, index))
+                    .ToArray());
+            return playable;
+        }
+
+        public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
+        {
+            var player = director != null ? director.GetGenericBinding(this) as FrameClipPlayer : null;
+            if (player != null)
+            {
+                var spriteRenderer = player.GetComponent<SpriteRenderer>();
+                if (spriteRenderer != null)
+                {
+                    driver.AddFromName<SpriteRenderer>(player.gameObject, "m_Sprite");
+                    driver.AddFromName<SpriteRenderer>(player.gameObject, "m_Enabled");
+                }
+
+                var image = player.GetComponent<Image>();
+                if (image != null)
+                {
+                    driver.AddFromName<Image>(player.gameObject, "m_Sprite");
+                    driver.AddFromName<Image>(player.gameObject, "m_Enabled");
+                }
+            }
+            base.GatherProperties(director, driver);
+        }
+    }
+
+    internal readonly struct FrameAnimationTimelineClipInfo
+    {
+        internal TimelineClip TimelineClip { get; }
+        internal FrameAnimationTimelineClip Asset { get; }
+        internal double Start { get; }
+        internal double End { get; }
+        internal int Order { get; }
+
+        internal FrameAnimationTimelineClipInfo(TimelineClip timelineClip, int order)
+        {
+            TimelineClip = timelineClip;
+            Asset = timelineClip?.asset as FrameAnimationTimelineClip;
+            Start = timelineClip?.start ?? 0d;
+            End = timelineClip?.end ?? 0d;
+            Order = order;
+        }
+    }
+
+    internal sealed class FrameAnimationTrackMixerBehaviour : PlayableBehaviour
+    {
+        private const double TimeEpsilon = 0.0000001d;
+        private IReadOnlyList<FrameAnimationTimelineClipInfo> clips =
+            Array.Empty<FrameAnimationTimelineClipInfo>();
+        private FrameClipPlayer currentPlayer;
+        private FrameClip terminalClip;
+        private string lastErrorKey = string.Empty;
+
+        internal void SetClips(IReadOnlyList<FrameAnimationTimelineClipInfo> value)
+        {
+            clips = value ?? Array.Empty<FrameAnimationTimelineClipInfo>();
+        }
+
+        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
+        {
+            var player = playerData as FrameClipPlayer;
+            if (player == null)
+            {
+                ReleaseCurrentPlayer();
+                return;
+            }
+
+            if (currentPlayer != player)
+            {
+                ReleaseCurrentPlayer();
+                currentPlayer = player;
+                ReportError(currentPlayer.BeginTimelineControl(), currentPlayer);
+            }
+
+            var timelineTime = playable.GetTime();
+            var activeIndex = FindActiveClipIndex(playable, timelineTime);
+            if (activeIndex >= 0)
+            {
+                var clipInfo = clips[activeIndex];
+                terminalClip = clipInfo.Asset?.FrameClip;
+                var localTime = playable.GetInput(activeIndex).GetTime();
+                localTime = NormalizeLoopTime(terminalClip, localTime);
+                ReportError(currentPlayer.SampleTimeline(terminalClip, localTime), currentPlayer);
+                return;
+            }
+
+            var previous = FindPreviousClip(timelineTime);
+            if (previous.HasValue)
+            {
+                terminalClip = previous.Value.Asset?.FrameClip;
+                ReportError(currentPlayer.ApplyTimelineEndBehavior(terminalClip), currentPlayer);
+            }
+            else
+            {
+                terminalClip = null;
+                currentPlayer.RestoreTimelineBaseline();
+                lastErrorKey = string.Empty;
+            }
+        }
+
+        public override void OnGraphStop(Playable playable)
+        {
+            ReleaseCurrentPlayer();
+        }
+
+        public override void OnPlayableDestroy(Playable playable)
+        {
+            ReleaseCurrentPlayer();
+        }
+
+        private int FindActiveClipIndex(Playable playable, double timelineTime)
+        {
+            var selected = -1;
+            var selectedStart = double.NegativeInfinity;
+            var count = Math.Min(playable.GetInputCount(), clips.Count);
+            for (var index = 0; index < count; index++)
+            {
+                var clip = clips[index];
+                var isInside = timelineTime + TimeEpsilon >= clip.Start &&
+                               timelineTime < clip.End - TimeEpsilon;
+                if (!isInside || playable.GetInputWeight(index) <= 0f)
+                {
+                    continue;
+                }
+
+                if (clip.Start > selectedStart ||
+                    (Math.Abs(clip.Start - selectedStart) <= TimeEpsilon && index > selected))
+                {
+                    selected = index;
+                    selectedStart = clip.Start;
+                }
+            }
+            return selected;
+        }
+
+        private FrameAnimationTimelineClipInfo? FindPreviousClip(double timelineTime)
+        {
+            FrameAnimationTimelineClipInfo? selected = null;
+            foreach (var clip in clips)
+            {
+                if (clip.End > timelineTime + TimeEpsilon)
+                {
+                    continue;
+                }
+
+                if (!selected.HasValue || clip.End > selected.Value.End ||
+                    (Math.Abs(clip.End - selected.Value.End) <= TimeEpsilon &&
+                     clip.Order > selected.Value.Order))
+                {
+                    selected = clip;
+                }
+            }
+            return selected;
+        }
+
+        private static double NormalizeLoopTime(FrameClip clip, double localTime)
+        {
+            if (clip == null || clip.DefaultEndBehavior != FrameClipEndBehavior.Loop)
+            {
+                return Math.Max(0d, localTime);
+            }
+
+            var duration = FrameAnimationTimelineClip.GetEffectiveDuration(clip);
+            if (duration <= 0d)
+            {
+                return 0d;
+            }
+            return Math.Max(0d, localTime) % duration;
+        }
+
+        private void ReleaseCurrentPlayer()
+        {
+            if (currentPlayer != null)
+            {
+                currentPlayer.ReleaseTimelineControl(terminalClip);
+            }
+            currentPlayer = null;
+            terminalClip = null;
+            lastErrorKey = string.Empty;
+        }
+
+        private void ReportError(FrameAnimationPlaybackError error, UnityEngine.Object context)
+        {
+            if (error.Code == FrameAnimationPlaybackErrorCode.None)
+            {
+                lastErrorKey = string.Empty;
+                return;
+            }
+
+            var key = $"{error.Code}:{error.Message}";
+            if (lastErrorKey == key)
+            {
+                return;
+            }
+            lastErrorKey = key;
+            Debug.LogError($"Frame Animation Timeline 播放失败：{error}", context);
+        }
+    }
+}
diff --git a/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs.meta b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs.meta
new file mode 100644
index 000000000..a5566f3cf
--- /dev/null
+++ b/Assets/Scripts/FrameAnimation/Timeline/FrameAnimationTrack.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6d1afb0ade1f46879f33b8173a66abbf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/FrameAnimation/EditMode/AibisDream.FrameAnimation.Tests.EditMode.asmdef b/Assets/Tests/FrameAnimation/EditMode/AibisDream.FrameAnimation.Tests.EditMode.asmdef
index 2eeb859d8..8edc44f53 100644
--- a/Assets/Tests/FrameAnimation/EditMode/AibisDream.FrameAnimation.Tests.EditMode.asmdef
+++ b/Assets/Tests/FrameAnimation/EditMode/AibisDream.FrameAnimation.Tests.EditMode.asmdef
@@ -3,7 +3,10 @@
   "rootNamespace": "AibisDream.FrameAnimation.Tests.EditMode",
   "references": [
     "AibisDream.FrameAnimation.Runtime",
-    "AibisDream.FrameAnimation.Editor"
+    "AibisDream.FrameAnimation.Editor",
+    "AibisDream.FrameAnimation.Timeline",
+    "Unity.Timeline",
+    "UnityEngine.UI"
   ],
   "includePlatforms": [
     "Editor"
diff --git a/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs b/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs
new file mode 100644
index 000000000..6eef95866
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs
@@ -0,0 +1,307 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using AibisDream.FrameAnimation.Timeline;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.TestTools;
+using UnityEngine.Timeline;
+using UnityEngine.UI;
+
+namespace AibisDream.FrameAnimation.Tests.EditMode
+{
+    public sealed class FrameAnimationTimelineTests
+    {
+        private readonly List<UnityEngine.Object> createdObjects = new List<UnityEngine.Object>();
+
+        [TearDown]
+        public void TearDown()
+        {
+            for (var index = createdObjects.Count - 1; index >= 0; index--)
+            {
+                if (createdObjects[index] != null)
+                {
+                    UnityEngine.Object.DestroyImmediate(createdObjects[index]);
+                }
+            }
+            createdObjects.Clear();
+        }
+
+        [Test]
+        public void TimelineClip_ReportsDurationAndSupportedCapabilities()
+        {
+            var holdClip = CreateClip("Hold", FrameClipEndBehavior.HoldLastFrame, 2f, null, null);
+            var loopClip = CreateClip("Loop", FrameClipEndBehavior.Loop, 1f, null, null);
+            var asset = Track(ScriptableObject.CreateInstance<FrameAnimationTimelineClip>());
+
+            asset.SetFrameClipForTests(holdClip);
+            Assert.That(asset.duration, Is.EqualTo(0.1d).Within(0.000001d));
+            Assert.That(asset.TrySynchronizeSourceDuration(out var synchronizedDuration), Is.True);
+            Assert.That(synchronizedDuration, Is.EqualTo(0.1d).Within(0.000001d));
+            Assert.That(asset.TrySynchronizeSourceDuration(out _), Is.False);
+            Assert.That(asset.clipCaps.HasFlag(ClipCaps.ClipIn), Is.True);
+            Assert.That(asset.clipCaps.HasFlag(ClipCaps.SpeedMultiplier), Is.True);
+            Assert.That(asset.clipCaps.HasFlag(ClipCaps.Blending), Is.False);
+            Assert.That(asset.clipCaps.HasFlag(ClipCaps.Looping), Is.False);
+
+            asset.SetFrameClipForTests(loopClip);
+            Assert.That(asset.TrySynchronizeSourceDuration(out _), Is.True);
+            Assert.That(asset.clipCaps.HasFlag(ClipCaps.Looping), Is.True);
+
+            asset.SetFrameClipForTests(null);
+            Assert.That(asset.duration, Is.EqualTo(1d));
+        }
+
+        [Test]
+        public void Track_ScrubsBothDirectionsAndHonorsClipInAndSpeedMultiplier()
+        {
+            var first = CreateSprite(Color.red);
+            var second = CreateSprite(Color.blue);
+            var clip = CreateClip("Scrub", FrameClipEndBehavior.HoldLastFrame, 1f, first, second);
+            var playerObject = Track(new GameObject("Timeline Sprite Player"));
+            var renderer = playerObject.AddComponent<SpriteRenderer>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, clip, 0d, 0.2d);
+            setup.Clip.clipIn = 0.05d;
+            setup.Clip.timeScale = 2d;
+
+            Evaluate(setup.Director, 0.03d);
+            Assert.That(renderer.sprite, Is.SameAs(second));
+
+            Evaluate(setup.Director, 0d);
+            Assert.That(renderer.sprite, Is.SameAs(first));
+
+            Evaluate(setup.Director, 0.03d);
+            Assert.That(renderer.sprite, Is.SameAs(second));
+        }
+
+        [Test]
+        public void Track_GapUsesPreviousTerminalStateAndOverlapPrefersLaterClip()
+        {
+            var baseline = CreateSprite(Color.white);
+            var firstSprite = CreateSprite(Color.red);
+            var secondSprite = CreateSprite(Color.blue);
+            var hold = CreateClip("Hold", FrameClipEndBehavior.HoldLastFrame, 1f, firstSprite);
+            var later = CreateClip("Later", FrameClipEndBehavior.HoldLastFrame, 1f, secondSprite);
+            var playerObject = Track(new GameObject("Timeline Overlap Player"));
+            var renderer = playerObject.AddComponent<SpriteRenderer>();
+            renderer.sprite = baseline;
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, hold, 0.1d, 0.3d);
+            AddClip(setup.Track, later, 0.2d, 0.1d);
+
+            Evaluate(setup.Director, 0.25d);
+            Assert.That(renderer.sprite, Is.SameAs(secondSprite));
+
+            Evaluate(setup.Director, 0.35d);
+            Assert.That(renderer.sprite, Is.SameAs(firstSprite));
+
+            Evaluate(setup.Director, 0.45d);
+            Assert.That(renderer.sprite, Is.SameAs(firstSprite));
+
+            Evaluate(setup.Director, -0.01d);
+            Assert.That(renderer.sprite, Is.SameAs(baseline));
+        }
+
+        [Test]
+        public void Track_AppliesClearAndHideTerminalStates()
+        {
+            var sprite = CreateSprite(Color.green);
+            var clear = CreateClip("Clear", FrameClipEndBehavior.Clear, 1f, sprite);
+            var hide = CreateClip("Hide", FrameClipEndBehavior.HideTarget, 1f, sprite);
+            var playerObject = Track(new GameObject("Timeline End States"));
+            var renderer = playerObject.AddComponent<SpriteRenderer>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, clear, 0d, 0.1d);
+            AddClip(setup.Track, hide, 0.2d, 0.1d);
+
+            Evaluate(setup.Director, 0.15d);
+            Assert.That(renderer.enabled, Is.True);
+            Assert.That(renderer.sprite, Is.Null);
+
+            Evaluate(setup.Director, 0.35d);
+            Assert.That(renderer.enabled, Is.False);
+        }
+
+        [Test]
+        public void Track_SamplesImageAndZeroSpeedClipStaysOnFirstFrame()
+        {
+            var first = CreateSprite(Color.yellow);
+            var second = CreateSprite(Color.black);
+            var clip = CreateClip("Zero", FrameClipEndBehavior.HoldLastFrame, 0f, first, second);
+            var playerObject = Track(new GameObject(
+                "Timeline Image Player",
+                typeof(RectTransform),
+                typeof(CanvasRenderer)));
+            var image = playerObject.AddComponent<Image>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, clip, 0d, 1d);
+
+            Evaluate(setup.Director, 0.75d);
+
+            Assert.That(image.sprite, Is.SameAs(first));
+            Assert.That(setup.Asset.duration, Is.EqualTo(1d));
+        }
+
+        [Test]
+        public void Track_InvalidClipLogsStructuredErrorWithoutThrowing()
+        {
+            var invalid = CreateClip("Empty", FrameClipEndBehavior.HoldLastFrame, 1f);
+            var playerObject = Track(new GameObject("Timeline Invalid Clip"));
+            playerObject.AddComponent<SpriteRenderer>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, invalid, 0d, 1d);
+            LogAssert.Expect(
+                LogType.Error,
+                new Regex("Frame Animation Timeline 播放失败.*InvalidPlayableData"));
+
+            Assert.DoesNotThrow(() => Evaluate(setup.Director, 0.25d));
+        }
+
+        [Test]
+        public void Track_GathersSpriteAndEnabledPropertiesForPreview()
+        {
+            var clip = CreateClip(
+                "Preview",
+                FrameClipEndBehavior.HoldLastFrame,
+                1f,
+                CreateSprite(Color.white));
+            var spriteObject = Track(new GameObject("Timeline Sprite Preview"));
+            spriteObject.AddComponent<SpriteRenderer>();
+            var spritePlayer = spriteObject.AddComponent<FrameClipPlayer>();
+            var spriteSetup = CreateTimeline(spritePlayer, clip, 0d, 0.1d);
+            var spriteCollector = new RecordingPropertyCollector();
+
+            spriteSetup.Track.GatherProperties(spriteSetup.Director, spriteCollector);
+
+            Assert.That(spriteCollector.Properties, Does.Contain("SpriteRenderer:m_Sprite"));
+            Assert.That(spriteCollector.Properties, Does.Contain("SpriteRenderer:m_Enabled"));
+
+            var imageObject = Track(new GameObject(
+                "Timeline Image Preview",
+                typeof(RectTransform),
+                typeof(CanvasRenderer)));
+            imageObject.AddComponent<Image>();
+            var imagePlayer = imageObject.AddComponent<FrameClipPlayer>();
+            var imageSetup = CreateTimeline(imagePlayer, clip, 0d, 0.1d);
+            var imageCollector = new RecordingPropertyCollector();
+
+            imageSetup.Track.GatherProperties(imageSetup.Director, imageCollector);
+
+            Assert.That(imageCollector.Properties, Does.Contain("Image:m_Sprite"));
+            Assert.That(imageCollector.Properties, Does.Contain("Image:m_Enabled"));
+        }
+
+        private TimelineSetup CreateTimeline(
+            FrameClipPlayer player,
+            FrameClip clip,
+            double start,
+            double duration)
+        {
+            var timeline = Track(ScriptableObject.CreateInstance<TimelineAsset>());
+            var track = Track(timeline.CreateTrack<FrameAnimationTrack>());
+            var timelineClip = AddClip(track, clip, start, duration);
+            var directorObject = Track(new GameObject("Frame Animation Director"));
+            var director = directorObject.AddComponent<PlayableDirector>();
+            director.playableAsset = timeline;
+            director.SetGenericBinding(track, player);
+            return new TimelineSetup(
+                director,
+                track,
+                timelineClip,
+                (FrameAnimationTimelineClip)timelineClip.asset);
+        }
+
+        private TimelineClip AddClip(
+            FrameAnimationTrack track,
+            FrameClip clip,
+            double start,
+            double duration)
+        {
+            var timelineClip = track.CreateClip<FrameAnimationTimelineClip>();
+            var asset = Track((FrameAnimationTimelineClip)timelineClip.asset);
+            asset.SetFrameClipForTests(clip);
+            timelineClip.start = start;
+            timelineClip.duration = duration;
+            return timelineClip;
+        }
+
+        private static void Evaluate(PlayableDirector director, double time)
+        {
+            director.time = Math.Max(0d, time);
+            director.Evaluate();
+        }
+
+        private FrameClip CreateClip(
+            string id,
+            FrameClipEndBehavior endBehavior,
+            float speed,
+            params Sprite[] sprites)
+        {
+            var clip = Track(ScriptableObject.CreateInstance<FrameClip>());
+            var frames = new List<FrameAnimationFrame>();
+            for (var index = 0; index < sprites.Length; index++)
+            {
+                frames.Add(new FrameAnimationFrame(sprites[index], 100, $"frame_{index}", index));
+            }
+            clip.Configure(id, id, frames, speed, endBehavior);
+            return clip;
+        }
+
+        private Sprite CreateSprite(Color color)
+        {
+            var texture = Track(new Texture2D(2, 2));
+            texture.SetPixels(new[] { color, color, color, color });
+            texture.Apply();
+            return Track(Sprite.Create(texture, new Rect(0, 0, 2, 2), Vector2.one * 0.5f));
+        }
+
+        private T Track<T>(T value) where T : UnityEngine.Object
+        {
+            createdObjects.Add(value);
+            return value;
+        }
+
+        private readonly struct TimelineSetup
+        {
+            internal PlayableDirector Director { get; }
+            internal FrameAnimationTrack Track { get; }
+            internal TimelineClip Clip { get; }
+            internal FrameAnimationTimelineClip Asset { get; }
+
+            internal TimelineSetup(
+                PlayableDirector director,
+                FrameAnimationTrack track,
+                TimelineClip clip,
+                FrameAnimationTimelineClip asset)
+            {
+                Director = director;
+                Track = track;
+                Clip = clip;
+                Asset = asset;
+            }
+        }
+
+        private sealed class RecordingPropertyCollector : IPropertyCollector
+        {
+            internal List<string> Properties { get; } = new List<string>();
+
+            public void PushActiveGameObject(GameObject gameObject) { }
+            public void PopActiveGameObject() { }
+            public void AddFromClip(AnimationClip clip) { }
+            public void AddFromClips(IEnumerable<AnimationClip> clips) { }
+            public void AddFromName<T>(string name) where T : Component =>
+                Properties.Add($"{typeof(T).Name}:{name}");
+            public void AddFromName(string name) { }
+            public void AddFromClip(GameObject obj, AnimationClip clip) { }
+            public void AddFromClips(GameObject obj, IEnumerable<AnimationClip> clips) { }
+            public void AddFromName<T>(GameObject obj, string name) where T : Component =>
+                Properties.Add($"{typeof(T).Name}:{name}");
+            public void AddFromName(GameObject obj, string name) { }
+            public void AddFromName(Component component, string name) { }
+            public void AddFromComponent(GameObject obj, Component component) { }
+            public void AddObjectProperties(UnityEngine.Object obj, AnimationClip clip) { }
+        }
+    }
+}
diff --git a/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs.meta b/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs.meta
new file mode 100644
index 000000000..783ac0025
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/EditMode/FrameAnimationTimelineTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0886b53af79f4406ba432ad67cd822be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs b/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs
new file mode 100644
index 000000000..49471d296
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs
@@ -0,0 +1,196 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using AibisDream.FrameAnimation.Editor;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+
+namespace AibisDream.FrameAnimation.Tests.EditMode
+{
+    public sealed class FrameClipStandaloneImportTests
+    {
+        private const string Root = "Assets/Tests/FrameAnimation/GeneratedStandaloneClipTests";
+        private const string TexturePath = Root + "/Atlas.png";
+        private const string JsonPath = Root + "/Atlas.json";
+        private const string ClipPath = Root + "/Standalone.asset";
+
+        [SetUp]
+        public void SetUp()
+        {
+            AssetDatabase.DeleteAsset(Root);
+            EnsureFolder(Root);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            AssetDatabase.DeleteAsset(Root);
+            AssetDatabase.Refresh();
+        }
+
+        [Test]
+        public void Preview_UsesOnlyFirstTagAndRespectsDirection()
+        {
+            var clip = CreateSourceClip(string.Empty, JsonWithTags("reverse"));
+
+            var preview = FrameClipImportService.Preview(clip);
+
+            Assert.That(preview.HasErrors, Is.False, JoinIssues(preview));
+            Assert.That(preview.SourceTagName, Is.EqualTo("First"));
+            CollectionAssert.AreEqual(new[] { 1, 0 }, preview.SourceIndices);
+            Assert.That(preview.SpriteDiffs.Count(diff => diff.Kind == FrameAnimationSpriteChangeKind.Added),
+                Is.EqualTo(2));
+        }
+
+        [Test]
+        public void Preview_WithoutTagsUsesAllFrames()
+        {
+            var clip = CreateSourceClip("Existing", JsonWithoutTags());
+
+            var preview = FrameClipImportService.Preview(clip);
+
+            Assert.That(preview.HasErrors, Is.False, JoinIssues(preview));
+            Assert.That(preview.SourceTagName, Is.Empty);
+            CollectionAssert.AreEqual(new[] { 0, 1 }, preview.SourceIndices);
+        }
+
+        [Test]
+        public void Apply_InitializesEmptyIdAndRefreshPreservesExistingId()
+        {
+            var clip = CreateSourceClip(string.Empty, JsonWithTags("forward"));
+            var first = FrameClipImportService.Preview(clip);
+            Assert.That(FrameClipImportService.Apply(first, true, out var error), Is.True, error);
+
+            Assert.That(clip.Id, Is.EqualTo("First"));
+            Assert.That(clip.DisplayName, Is.EqualTo("First"));
+            Assert.That(clip.FrameCount, Is.EqualTo(2));
+            Assert.That(clip.StandaloneImportSource.LastImportedTagName, Is.EqualTo("First"));
+
+            var serialized = new SerializedObject(clip);
+            serialized.FindProperty("id").stringValue = "CustomId";
+            serialized.ApplyModifiedPropertiesWithoutUndo();
+            WriteJson(JsonWithTags("reverse"));
+            var second = FrameClipImportService.Preview(clip);
+            Assert.That(FrameClipImportService.Apply(second, true, out error), Is.True, error);
+            Assert.That(clip.Id, Is.EqualTo("CustomId"));
+            CollectionAssert.AreEqual(new[] { 1, 0 }, clip.Frames.Select(frame => frame.SourceIndex));
+        }
+
+        [Test]
+        public void Detach_PreservesFramesAndAllowsGraphReference()
+        {
+            var clip = CreateSourceClip("External", JsonWithoutTags());
+            var preview = FrameClipImportService.Preview(clip);
+            Assert.That(FrameClipImportService.Apply(preview, true, out var error), Is.True, error);
+            var frames = clip.Frames.ToArray();
+
+            var graph = ScriptableObject.CreateInstance<FrameAnimationGraph>();
+            graph.Configure("Graph", "Graph", Array.Empty<FrameClip>(), Array.Empty<AnimationNode>(),
+                Array.Empty<AnimationEdge>(), Array.Empty<AnimationFlow>(), clip.Id);
+            AssetDatabase.CreateAsset(graph, Root + "/Graph.asset");
+            Assert.That(FrameAnimationAssetOperations.AddExistingManualClip(graph, clip, out error), Is.True, error);
+            Assert.That(FrameAnimationGraphValidator.Validate(graph).HasErrors, Is.False);
+
+            FrameClipImportService.DetachSource(clip);
+
+            Assert.That(clip.HasStandaloneImportSource, Is.False);
+            CollectionAssert.AreEqual(frames, clip.Frames);
+        }
+
+        [Test]
+        public void Preview_RejectsSecondWritableStandaloneOwnerForSameTexture()
+        {
+            CreateTexture();
+            WriteJson(JsonWithoutTags());
+            var first = CreateLinkedClipAt(ClipPath, "FirstOwner");
+            var second = CreateLinkedClipAt(Root + "/Second.asset", "SecondOwner");
+
+            var preview = FrameClipImportService.Preview(second);
+
+            Assert.That(first.StandaloneImportSource.Texture, Is.SameAs(second.StandaloneImportSource.Texture));
+            Assert.That(preview.HasErrors, Is.True);
+            Assert.That(preview.Issues.Any(issue =>
+                issue.Code == FrameAnimationImportIssueCode.TextureOwnershipConflict), Is.True);
+        }
+
+        private static FrameClip CreateSourceClip(string id, string json)
+        {
+            CreateTexture();
+            WriteJson(json);
+            return CreateLinkedClipAt(ClipPath, id);
+        }
+
+        private static FrameClip CreateLinkedClipAt(string path, string id)
+        {
+            var clip = ScriptableObject.CreateInstance<FrameClip>();
+            clip.Configure(id, string.Empty, Array.Empty<FrameAnimationFrame>());
+            AssetDatabase.CreateAsset(clip, path);
+            Assert.That(FrameClipImportService.EnableSource(clip, out var error), Is.True, error);
+            var serialized = new SerializedObject(clip);
+            var source = serialized.FindProperty("standaloneImportSource");
+            source.FindPropertyRelative("texture").objectReferenceValue =
+                AssetDatabase.LoadAssetAtPath<Texture2D>(TexturePath);
+            source.FindPropertyRelative("asepriteJson").objectReferenceValue =
+                AssetDatabase.LoadAssetAtPath<TextAsset>(JsonPath);
+            source.FindPropertyRelative("manageSpriteSlicing").boolValue = true;
+            serialized.ApplyModifiedPropertiesWithoutUndo();
+            AssetDatabase.SaveAssets();
+            return clip;
+        }
+
+        private static void CreateTexture()
+        {
+            var texture = new Texture2D(4, 2, TextureFormat.RGBA32, false);
+            texture.SetPixels(Enumerable.Range(0, 8).Select(index => index < 4 ? Color.red : Color.green).ToArray());
+            texture.Apply();
+            File.WriteAllBytes(TexturePath, texture.EncodeToPNG());
+            UnityEngine.Object.DestroyImmediate(texture);
+            AssetDatabase.ImportAsset(TexturePath, ImportAssetOptions.ForceSynchronousImport);
+        }
+
+        private static void WriteJson(string json)
+        {
+            File.WriteAllText(JsonPath, json, new UTF8Encoding(false));
+            AssetDatabase.ImportAsset(JsonPath, ImportAssetOptions.ForceSynchronousImport);
+        }
+
+        private static string JsonWithTags(string direction)
+        {
+            return Json("[{\"name\":\"First\",\"from\":0,\"to\":1,\"direction\":\"" + direction +
+                        "\"},{\"name\":\"Ignored\",\"from\":1,\"to\":1,\"direction\":\"invalid\"}]");
+        }
+
+        private static string JsonWithoutTags()
+        {
+            return Json("[]");
+        }
+
+        private static string Json(string tags)
+        {
+            return "{" +
+                   "\"frames\":{" +
+                   "\"FrameA\":{\"frame\":{\"x\":0,\"y\":0,\"w\":2,\"h\":2},\"rotated\":false,\"trimmed\":false,\"duration\":100,\"spriteSourceSize\":{\"x\":0,\"y\":0,\"w\":2,\"h\":2},\"sourceSize\":{\"w\":2,\"h\":2}}," +
+                   "\"FrameB\":{\"frame\":{\"x\":2,\"y\":0,\"w\":2,\"h\":2},\"rotated\":false,\"trimmed\":false,\"duration\":200,\"spriteSourceSize\":{\"x\":0,\"y\":0,\"w\":2,\"h\":2},\"sourceSize\":{\"w\":2,\"h\":2}}}," +
+                   "\"meta\":{\"image\":\"Atlas.png\",\"size\":{\"w\":4,\"h\":2},\"frameTags\":" + tags + "}}";
+        }
+
+        private static string JoinIssues(FrameClipImportPreview preview)
+        {
+            return string.Join("\n", preview.Issues.Select(issue => issue.Message));
+        }
+
+        private static void EnsureFolder(string path)
+        {
+            var segments = path.Split('/');
+            var current = segments[0];
+            for (var index = 1; index < segments.Length; index++)
+            {
+                var next = current + "/" + segments[index];
+                if (!AssetDatabase.IsValidFolder(next)) AssetDatabase.CreateFolder(current, segments[index]);
+                current = next;
+            }
+        }
+    }
+}
diff --git a/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs.meta b/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs.meta
new file mode 100644
index 000000000..92c3877f7
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/EditMode/FrameClipStandaloneImportTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fd9f1e89abcc595428c137e42258e008
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Tests/FrameAnimation/PlayMode/AibisDream.FrameAnimation.Tests.PlayMode.asmdef b/Assets/Tests/FrameAnimation/PlayMode/AibisDream.FrameAnimation.Tests.PlayMode.asmdef
index a53ed3add..071f569ca 100644
--- a/Assets/Tests/FrameAnimation/PlayMode/AibisDream.FrameAnimation.Tests.PlayMode.asmdef
+++ b/Assets/Tests/FrameAnimation/PlayMode/AibisDream.FrameAnimation.Tests.PlayMode.asmdef
@@ -2,7 +2,10 @@
   "name": "AibisDream.FrameAnimation.Tests.PlayMode",
   "rootNamespace": "AibisDream.FrameAnimation.Tests.PlayMode",
   "references": [
-    "AibisDream.FrameAnimation.Runtime"
+    "AibisDream.FrameAnimation.Runtime",
+    "AibisDream.FrameAnimation.Timeline",
+    "Unity.Timeline",
+    "UnityEngine.UI"
   ],
   "includePlatforms": [],
   "excludePlatforms": [],
diff --git a/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationPlayerTests.cs b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationPlayerTests.cs
index ec366733b..36bd32530 100644
--- a/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationPlayerTests.cs
+++ b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationPlayerTests.cs
@@ -47,6 +47,103 @@ namespace AibisDream.FrameAnimation.Tests.PlayMode
             Assert.That(renderer.enabled, Is.True);
         }
 
+        [Test]
+        public void FrameClipPlayer_PlaysDefaultClipWithoutGraph()
+        {
+            var first = CreateSprite(Color.magenta);
+            var second = CreateSprite(Color.cyan);
+            var clip = CreateClip("Standalone", FrameClipEndBehavior.HoldLastFrame, first, second);
+            var gameObject = Track(new GameObject("Standalone Clip Player"));
+            var renderer = gameObject.AddComponent<SpriteRenderer>();
+            var player = gameObject.AddComponent<FrameClipPlayer>();
+            player.ConfigureForAuthoring(clip, false, 1f);
+
+            var handle = player.Play();
+
+            Assert.That(renderer.sprite, Is.SameAs(first));
+            Assert.That(player.Clip, Is.SameAs(clip));
+            Assert.That(player.CurrentClip, Is.SameAs(clip));
+            player.EvaluateForTests(0.2d);
+            Assert.That(handle.Result.Reason, Is.EqualTo(FrameAnimationCompletionReason.Completed));
+            Assert.That(renderer.sprite, Is.SameAs(second));
+        }
+
+        [Test]
+        public void FrameClipPlayer_TemporaryClipDoesNotReplaceDefaultAndFailedPlayKeepsActive()
+        {
+            var defaultClip = CreateClip("Default", FrameClipEndBehavior.Loop, CreateSprite(Color.red));
+            var temporary = CreateClip("Temporary", FrameClipEndBehavior.Loop, CreateSprite(Color.blue));
+            var invalid = Track(ScriptableObject.CreateInstance<FrameClip>());
+            var gameObject = Track(new GameObject("Temporary Clip Player"));
+            gameObject.AddComponent<SpriteRenderer>();
+            var player = gameObject.AddComponent<FrameClipPlayer>();
+            player.ConfigureForAuthoring(defaultClip, false, 1f);
+
+            var active = player.Play(temporary);
+            var failed = player.Play(invalid);
+
+            Assert.That(failed.Result.Reason, Is.EqualTo(FrameAnimationCompletionReason.Failed));
+            Assert.That(active.IsCompleted, Is.False);
+            Assert.That(player.Clip, Is.SameAs(defaultClip));
+            Assert.That(player.CurrentClip, Is.SameAs(temporary));
+        }
+
+        [Test]
+        public void FrameClipPlayer_RestoreTerminalStateAppliesLastFrame()
+        {
+            var first = CreateSprite(Color.red);
+            var last = CreateSprite(Color.green);
+            var clip = CreateClip("RestoreStandalone", FrameClipEndBehavior.HoldLastFrame, first, last);
+            var gameObject = Track(new GameObject("Restore Standalone"));
+            var renderer = gameObject.AddComponent<SpriteRenderer>();
+            var player = gameObject.AddComponent<FrameClipPlayer>();
+            player.ConfigureForAuthoring(clip, false, 1f);
+
+            var handle = player.RestoreTerminalState();
+
+            Assert.That(handle.Result.Reason, Is.EqualTo(FrameAnimationCompletionReason.Completed));
+            Assert.That(renderer.sprite, Is.SameAs(last));
+        }
+
+        [Test]
+        public void FrameClipPlayer_ImageLoopWaitsForFirstPassAndKeepsPlaying()
+        {
+            var first = CreateSprite(Color.yellow);
+            var second = CreateSprite(Color.black);
+            var clip = CreateClip("StandaloneLoop", FrameClipEndBehavior.Loop, first, second);
+            var gameObject = Track(new GameObject("Standalone Image", typeof(RectTransform), typeof(CanvasRenderer)));
+            var image = gameObject.AddComponent<Image>();
+            var player = gameObject.AddComponent<FrameClipPlayer>();
+            player.ConfigureForAuthoring(clip, false, 1f);
+
+            var handle = player.Play();
+            var wait = player.WaitForFirstPass(handle);
+            player.EvaluateForTests(0.2d);
+
+            Assert.That(wait.keepWaiting, Is.False);
+            Assert.That(handle.IsCompleted, Is.False);
+            Assert.That(player.State, Is.EqualTo(FrameAnimationPlaybackState.Playing));
+            Assert.That(image.sprite, Is.SameAs(first));
+        }
+
+        [Test]
+        public void GraphAndClipPlayersOnSameObjectReturnConflict()
+        {
+            var clip = CreateClip("ConflictClip", FrameClipEndBehavior.Loop, CreateSprite(Color.white));
+            var graph = CreateDirectGraph(clip);
+            var gameObject = Track(new GameObject("Player Conflict"));
+            gameObject.AddComponent<SpriteRenderer>();
+            var graphPlayer = gameObject.AddComponent<FrameAnimationPlayer>();
+            graphPlayer.ConfigureForAuthoring(graph, false, 1f);
+            var clipPlayer = gameObject.AddComponent<FrameClipPlayer>();
+            clipPlayer.ConfigureForAuthoring(clip, false, 1f);
+
+            Assert.That(graphPlayer.Play().Result.Error.Code,
+                Is.EqualTo(FrameAnimationPlaybackErrorCode.TargetConflict));
+            Assert.That(clipPlayer.Play().Result.Error.Code,
+                Is.EqualTo(FrameAnimationPlaybackErrorCode.TargetConflict));
+        }
+
         [Test]
         public void Image_PlayerSupportsHideAndNextPlayReEnablesTarget()
         {
diff --git a/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs
new file mode 100644
index 000000000..45d5edb30
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs
@@ -0,0 +1,144 @@
+using System.Collections;
+using System.Collections.Generic;
+using AibisDream.FrameAnimation.Timeline;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.TestTools;
+using UnityEngine.Timeline;
+
+namespace AibisDream.FrameAnimation.Tests.PlayMode
+{
+    public sealed class FrameAnimationTimelinePlayModeTests
+    {
+        private readonly List<UnityEngine.Object> createdObjects = new List<UnityEngine.Object>();
+
+        [TearDown]
+        public void TearDown()
+        {
+            for (var index = createdObjects.Count - 1; index >= 0; index--)
+            {
+                if (createdObjects[index] != null)
+                {
+                    UnityEngine.Object.DestroyImmediate(createdObjects[index]);
+                }
+            }
+            createdObjects.Clear();
+        }
+
+        [UnityTest]
+        public IEnumerator Director_TakesControlStopsAtTerminalAndPlayerCanPlayAgain()
+        {
+            var first = CreateSprite(Color.red);
+            var second = CreateSprite(Color.blue);
+            var clip = CreateClip("Timeline", FrameClipEndBehavior.HoldLastFrame, first, second);
+            var playerObject = Track(new GameObject("Timeline Runtime Player"));
+            var renderer = playerObject.AddComponent<SpriteRenderer>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            player.ConfigureForAuthoring(clip, false, 1f);
+            var ordinaryHandle = player.Play();
+            var setup = CreateTimeline(player, clip);
+
+            setup.Director.Play();
+            setup.Director.time = 0.15d;
+            setup.Director.Evaluate();
+            yield return null;
+
+            Assert.That(ordinaryHandle.IsCompleted, Is.True);
+            Assert.That(ordinaryHandle.Result.Reason, Is.EqualTo(FrameAnimationCompletionReason.Replaced));
+            Assert.That(renderer.sprite, Is.SameAs(second));
+
+            setup.Director.Stop();
+            Assert.That(renderer.sprite, Is.SameAs(second));
+            var nextHandle = player.Play();
+            Assert.That(nextHandle.IsCompleted, Is.False);
+            Assert.That(renderer.sprite, Is.SameAs(first));
+        }
+
+        [UnityTest]
+        public IEnumerator Director_CanPauseSeekBackwardAndReplayLoop()
+        {
+            var first = CreateSprite(Color.green);
+            var second = CreateSprite(Color.yellow);
+            var clip = CreateClip("Loop", FrameClipEndBehavior.Loop, first, second);
+            var playerObject = Track(new GameObject("Timeline Runtime Loop"));
+            var renderer = playerObject.AddComponent<SpriteRenderer>();
+            var player = playerObject.AddComponent<FrameClipPlayer>();
+            var setup = CreateTimeline(player, clip);
+            setup.Clip.duration = 0.6d;
+
+            setup.Director.Play();
+            setup.Director.time = 0.15d;
+            setup.Director.Evaluate();
+            setup.Director.Pause();
+            Assert.That(renderer.sprite, Is.SameAs(second));
+
+            setup.Director.time = 0.01d;
+            setup.Director.Evaluate();
+            Assert.That(renderer.sprite, Is.SameAs(first));
+
+            setup.Director.Play();
+            setup.Director.time = 0.25d;
+            setup.Director.Evaluate();
+            yield return null;
+
+            Assert.That(renderer.sprite, Is.SameAs(first));
+            setup.Director.Stop();
+            Assert.That(renderer.sprite, Is.Not.Null);
+        }
+
+        private TimelineSetup CreateTimeline(FrameClipPlayer player, FrameClip clip)
+        {
+            var timeline = Track(ScriptableObject.CreateInstance<TimelineAsset>());
+            var track = Track(timeline.CreateTrack<FrameAnimationTrack>());
+            var timelineClip = track.CreateClip<FrameAnimationTimelineClip>();
+            var asset = Track((FrameAnimationTimelineClip)timelineClip.asset);
+            asset.SetFrameClipForTests(clip);
+            timelineClip.start = 0d;
+            timelineClip.duration = asset.duration;
+            var directorObject = Track(new GameObject("Frame Animation Runtime Director"));
+            var director = directorObject.AddComponent<PlayableDirector>();
+            director.playableAsset = timeline;
+            director.SetGenericBinding(track, player);
+            return new TimelineSetup(director, timelineClip);
+        }
+
+        private FrameClip CreateClip(string id, FrameClipEndBehavior endBehavior, params Sprite[] sprites)
+        {
+            var clip = Track(ScriptableObject.CreateInstance<FrameClip>());
+            var frames = new List<FrameAnimationFrame>();
+            for (var index = 0; index < sprites.Length; index++)
+            {
+                frames.Add(new FrameAnimationFrame(sprites[index], 100, $"frame_{index}", index));
+            }
+            clip.Configure(id, id, frames, 1f, endBehavior);
+            return clip;
+        }
+
+        private Sprite CreateSprite(Color color)
+        {
+            var texture = Track(new Texture2D(2, 2));
+            texture.SetPixels(new[] { color, color, color, color });
+            texture.Apply();
+            return Track(Sprite.Create(texture, new Rect(0, 0, 2, 2), Vector2.one * 0.5f));
+        }
+
+        private T Track<T>(T value) where T : UnityEngine.Object
+        {
+            createdObjects.Add(value);
+            return value;
+        }
+
+        private readonly struct TimelineSetup
+        {
+            internal PlayableDirector Director { get; }
+            internal TimelineClip Clip { get; }
+
+            internal TimelineSetup(PlayableDirector director, TimelineClip clip)
+            {
+                Director = director;
+                Clip = clip;
+            }
+        }
+    }
+}
diff --git a/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs.meta b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs.meta
new file mode 100644
index 000000000..884ec6a59
--- /dev/null
+++ b/Assets/Tests/FrameAnimation/PlayMode/FrameAnimationTimelinePlayModeTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 610722ceae2b4e41995b13da073bc5a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Docs/FrameAnimationTimeline使用说明.md b/Docs/FrameAnimationTimeline使用说明.md
new file mode 100644
index 000000000..6d00e7dc8
--- /dev/null
+++ b/Docs/FrameAnimationTimeline使用说明.md
@@ -0,0 +1,25 @@
+# FrameAnimation Timeline 使用说明
+
+## 创建与绑定
+
+1. 为带有 `SpriteRenderer` 或 UI `Image` 的对象添加 `FrameClipPlayer`。
+2. 在 Timeline 中创建 `Frame Animation Track`。
+3. 将场景中的 `FrameClipPlayer` 绑定到轨道。
+4. 在轨道上创建 `Frame Animation Clip`，并在 Inspector 中指定独立的 `FrameClip.asset`。
+
+Timeline Clip 的初始时长来自 `FrameClip` 的帧总时长和 Speed。Clip 支持裁剪、Clip In、Timeline Speed Multiplier，以及在编辑模式下拖动时间轴预览。
+
+## 循环与终态
+
+- `Loop`：延长 Timeline Clip 后在 Clip 范围内循环；离开 Clip 后保持最后采样帧。
+- `HoldLastFrame`：Clip 结束或 Director 停止后保持最后一帧。
+- `Clear`：Clip 结束后清空 Sprite，并保持显示组件启用。
+- `HideTarget`：Clip 结束后禁用 `SpriteRenderer` 或 `Image`。
+
+同一轨道不提供 Sprite 混合。Clip 重叠时，开始时间更晚的 Clip 优先。关闭 Timeline 编辑态预览后，Unity 会恢复预览前的 Sprite 与显示状态。
+
+## 第一版边界
+
+- Timeline Clip 只引用独立 `FrameClip`，不播放 `FrameAnimationGraph` 或 `AnimationFlow`。
+- 不支持多条轨道同时控制同一个 `FrameClipPlayer`。
+- 不支持 Sprite 淡入淡出或权重插值。
diff --git a/Docs/FrameAnimationTimeline使用说明.md.meta b/Docs/FrameAnimationTimeline使用说明.md.meta
new file mode 100644
index 000000000..0db2dca42
--- /dev/null
+++ b/Docs/FrameAnimationTimeline使用说明.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fd1f782f09e542d984a303f64ff7ebdb
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Docs/独立FrameClip播放器与编辑器验收.md b/Docs/独立FrameClip播放器与编辑器验收.md
new file mode 100644
index 000000000..5118d299a
--- /dev/null
+++ b/Docs/独立FrameClip播放器与编辑器验收.md
@@ -0,0 +1,26 @@
+# 独立 FrameClip 播放器与编辑器验收
+
+## 独立播放器
+
+1. 创建带 `SpriteRenderer` 或 `Image` 的对象并添加 `FrameClipPlayer`。
+2. 绑定一个有效的外部 `FrameClip`，启用 `Play On Enable` 后进入 Play Mode。
+3. 确认首帧立即显示，速度、Loop、HoldLastFrame、Clear、HideTarget 与 Graph Player 一致。
+4. 在代码中调用 `Play(otherClip)`，确认临时 Clip 播放但 Inspector 默认 Clip 不变。
+5. 同对象同时添加 `FrameAnimationPlayer`，确认 Inspector 报错且播放返回 `TargetConflict`。
+
+## 独立 Clip 编辑器
+
+1. 双击外部 `FrameClip.asset`，确认打开 `Frame Clip Editor`；Graph sub-asset 仍打开 Graph Editor。
+2. 手工编辑 ID、Display Name、Speed、Default End 和帧列表，检查预览、拖动时间和逐帧按钮。
+3. 为外部 Clip 启用 `Texture + JSON Source`，指定 Texture、Aseprite JSON、Pivot，并按需启用切图管理。
+4. 点击 `Preview Import` 检查差异，再点击 `Refresh`；若需要修改 TextureImporter，应先出现确认框。
+5. 多 Tag JSON 只应采用数组中第一个 Tag；无 Tag JSON 应采用全部 frames。
+6. 来源型 Clip 的帧列表必须只读；点击 `Detach Source` 后保留当前帧并恢复手工编辑。
+7. 将来源型外部 Clip 加入 Graph，确认可以创建节点和播放，但刷新入口仍位于独立 Clip 编辑器。
+
+## 安全检查
+
+- 同一 Texture 只能有一个启用了切图管理的 Graph ImportSource 或独立 Clip 来源。
+- 空 ID 在首次刷新时由首 Tag 名初始化；无 Tag 时使用资产文件名。
+- 已有 ID 和 Display Name 在后续刷新时不自动改变。
+- 被多个 Graph 共享的外部 Clip 不能在独立编辑器中重命名 ID。