@linker-design-plus/timeline-track 2.0.24 → 2.1.1

package/README.md

@@ -2,24 +2,7 @@
 
 基于 TypeScript、Konva 和 Vue demo 的时间线编辑组件库，对外以 `TimelineManager` 为统一入口，提供多轨片段编辑、拖拽/拉伸/分割、撤销重做、选中态同步、封面渲染和预览挂载能力。时间轴主体仍由 Konva 驱动，播放指针使用独立的 SVG/DOM 覆盖层渲染。
 
-## 当前状态
-
-- 主线重构已经完成，仓库已从“双轨实现 + 大量兼容层”收敛到单一轨道组件 `Track`
-- `TimelineManager` 仍然是 façade，但内部已经拆分为 `stores`、`commands`、`controllers`、`tracks`、`presentation`
-- 当前发布包实际内置的预览实现是 `DomPreviewBackend`
-- `previewBackend` 配置仍然保留，但当前实现会统一解析到 `dom`，不要把 `canvas` / `auto` 视为已交付能力
-- 仓库内保留了较完整的回归测试，适合继续做功能收敛和架构瘦身
-
-## 审计结论
-
-本轮已完成一次针对仓库现状的维护梳理，并同步修正了以下残留：
-
-- 修复了 3 处测试残留，使 `pnpm test` 与 `pnpm exec tsc -p tsconfig.json --noEmit` 恢复通过
-- 清理了 `pixi` 预览类型和 demo 入口中的过期选项
-- 把 README 与重构路线文档改为“当前真实状态”，不再把未交付的 canvas 预览写成已完成能力
-- 把 `build` 脚本改为直接调用本地 `tsc`，避免 `npm run build:types` 带来的环境告警
-
-更细的维护记录见 [docs/maintenance-audit.md](./docs/maintenance-audit.md)。
+当前版本已经收敛到单一 `Track` 实现。预览侧真实交付的 backend 只有 `DomPreviewBackend`；`previewBackend` 配置仍保留兼容输入，但运行时会统一解析到 `dom`。
 
 ## 安装
 
@@ -66,35 +49,17 @@ timeline.on('history_change', (_event, data) => {
 });
 ```
 
-### 预览资源缓存
-
-预览资源缓存默认关闭。开启后，可被前端 `fetch` 读取且不超过 100MB 的 `http:` / `https:` 音视频文件会被缓存到浏览器存储中，用于后续预览播放。默认策略为 30 天 TTL、10GB 应用级容量上限、优先 OPFS，并在 OPFS 不可用时降级到 IndexedDB Blob。缓存失败会自动回退原始媒体 URL。
-
-```ts
-const timeline = new TimelineManager({
-  container,
-  previewBackend: 'dom',
-  resourceCache: {
-    enabled: true,
-    resolveMode: 'prefer-fast-start'
-  }
-});
-```
-
-第一版不会缓存 HLS manifest / 分片，也不会缓存超过 100MB 的媒体文件。
-
 ## 核心能力
 
-- 多轨时间线编辑，支持视频轨和音频轨
+- 多轨时间线编辑，支持视频轨、音频轨和文本片段
 - 片段拖拽、拉伸、分割、跨轨移动和重叠避让
-- 单一选中态与批量拖拽
+- 多选、框选与批量拖拽
 - 播放头、缩放、滚动和时间同步
 - 撤销 / 重做 / 历史变更通知
-- 缩略图提供器与异步封面加载
-- 预览容器挂载、预览比例同步和当前激活片段解析
-- 草稿导入导出、音视频分离/恢复等编辑工作流
+- 预览挂载、比例同步和当前激活片段解析
+- 草稿导入导出、音视频分离 / 恢复等编辑工作流
 
-## 主要 API
+## API 概览
 
 常用方法：
 
@@ -104,30 +69,30 @@ const timeline = new TimelineManager({
 - `setSpeed(speed)` / `getSpeed()`
 - `addClip(config)` / `addClips(configs)`
 - `updateClip(clipId, updates)` / `removeClip(clipId)`
-- `selectClip(clipId)` / `clearSelection()` / `getSelectedClip()`
+- `selectClip(clipId)` / `setSelection(ids)` / `clearSelection()`
 - `splitCurrentClip()` / `removeClipGaps()`
-- `getRenderedHeight()`
 - `undo()` / `redo()` / `clearHistory()`
 - `attachPreview(containerOrConfig)` / `detachPreview()`
-- `exportTimeline()` / `loadDraft(data)`
+- `exportTimeline()` / `importTimeline(data)`
 
-快捷键配置：
+配音配置面板：
 
-- `keyboardShortcuts: false` 可彻底关闭快捷键
-- `keyboardShortcuts.bindings` 可按动作覆盖默认键位
-- 时间轴挂载后默认在当前页面生效
+- `attachClipConfig(container, options)` 返回 `TimelineClipConfigController`
+- 内建 `generateVoiceBatch` 流程会自动展示 / 关闭“配音生成中”全屏 loading
+- 外部自定义配音流程也可以手动调用 `controller.showVoiceGenerationLoading()` 和 `controller.hideVoiceGenerationLoading()`
 
-默认快捷键：
+```ts
+const controller = timeline.attachClipConfig(clipConfigContainer, {
+  voiceCatalog
+});
 
-- 播放 / 暂停：`Space`
-- 删除片段：`Delete` / `Backspace`
-- 复制片段：`Mod+C`
-- 剪切片段：`Mod+X`
-- 粘贴片段：`Mod+V`
-- 分离 / 还原音频：`Mod+Alt+A`
-- 分割片段：`Mod+B`
-- 撤销：`Mod+Z`
-- 还原：`Mod+Shift+Z`，Windows 另支持 `Ctrl+Y`
+controller.showVoiceGenerationLoading();
+try {
+  await customGenerateVoice();
+} finally {
+  controller.hideVoiceGenerationLoading();
+}
+```
 
 常用事件：
 
@@ -137,83 +102,30 @@ const timeline = new TimelineManager({
 - `clip_added`
 - `clip_removed`
 - `clip_updated`
-- `clip_selected`
 - `selected_clip_change`
 - `history_change`
 - `track_duration_change`
 - `buffering_state_change`
 - `source_loading_change`
 
-## 关键类型
-
-```ts
-interface ClipConfig {
-  id?: string;
-  type?: 'video' | 'audio';
-  externalId?: string;
-  src: string;
-  name: string;
-  isMuted?: boolean;
-  startTime?: number;
-  duration: number;
-  startTimeAtSource?: number;
-  endTimeAtSource?: number;
-  sourceDuration?: number;
-  thumbnails?: string[];
-  style?: Record<string, any>;
-  visualTransform?: {
-    x: number;
-    y: number;
-    scale: number;
-  };
-  trackId?: string;
-  volume?: number;
-}
-```
-
-## 预览实现说明
+## 兼容与边界
 
-- 当前代码路径实际只会创建 `DomPreviewBackend`
-- `previewBackend` 字段被保留，目的是不给后续预览实现扩展制造额外 breaking change
-- 如果你在业务接入层看到 `canvas` / `auto` 配置，请把它当作保留参数，而不是当前版本的有效能力
+- 当前代码路径只会创建 `DomPreviewBackend`
+- `canvas` / `auto` 仍可作为兼容输入传入，但不应视为已交付能力
+- 挂载预览且当前时间命中视频片段时，时间轴会消费预览视频的真实媒体时钟
+- 空白段、纯音频、文本或未挂载预览时，播放仍回退到 `TimelineManager` 的 wall-clock 推进
 
-## 架构概览
+## 预览资源缓存
 
-```mermaid
-flowchart TB
-  API["Public API\nsrc/index.ts"] --> FACADE["TimelineManager\nsrc/core/facade/timelineManager.ts"]
-  FACADE --> STORES["Stores\nTimeline / Selection / Playback / Viewport"]
-  FACADE --> COMMANDS["Commands\nTimelineCommands"]
-  FACADE --> CONTROLLERS["Controllers\nworkflow / selection / duration / playback / events"]
-  FACADE --> TRACKS["Tracks\nTrackManager / Bridge / Collection"]
-  FACADE --> PRESENTATION["Presentation\nTimelinePresentationAdapter"]
-  FACADE --> PREVIEW["Preview\nDomPreviewBackend"]
-  FACADE --> COMPONENTS["Presentation Views\nTimeline / Track / Clip / Panels / ManagedPlayhead"]
-```
+预览资源缓存默认关闭。开启后，前端可直接 `fetch` 的音视频资源会被缓存到浏览器存储中，用于后续预览复用；缓存失败时会自动回退原始媒体 URL。完整边界和配置说明见 [docs/resource-cache.md](./docs/resource-cache.md)。
 
-当前最值得关注的热点：
-
-- `src/core/facade/timelineManager.ts` 仍然超过 4k 行，是后续最重要的瘦身目标
-- `src/components/track/Track.tsx` 内部还保留一层 `legacy` 交互镜像，用于兼容旧拖拽状态
-- `src/utils/rendering/KonvaUtils.ts` 仍偏大，适合继续拆分为更小的渲染工具模块
-- `demo/App.vue` 既承担演示又承担诊断面板职责，维护成本偏高
-
-## 目录结构
-
-```text
-src/
-  components/   时间轴视图、SVG/DOM 覆盖层与交互 helper
-  core/         stores / commands / controllers / facade / models
-  utils/        渲染、时间和日志工具
-  styles/       样式入口
-  index.ts      对外导出
-docs/
-  interaction-model.md
-  maintenance-audit.md
-  refactor-roadmap.md
-demo/
-  App.vue
-  main.ts
+```ts
+const timeline = new TimelineManager({
+  container,
+  resourceCache: {
+    enabled: true
+  }
+});
 ```
 
 ## 开发
@@ -226,9 +138,11 @@ pnpm test
 pnpm exec tsc -p tsconfig.json --noEmit
 ```
 
-## 相关文档
+## 文档
 
+- [docs/README.md](./docs/README.md): 文档入口
+- [docs/architecture-overview.md](./docs/architecture-overview.md): 当前架构、模块边界、运行链路
+- [docs/implementation-notes.md](./docs/implementation-notes.md): selection、preview、resource cache、draft 的实现笔记
+- [docs/resource-cache.md](./docs/resource-cache.md): 预览资源缓存的能力边界与配置
 - [docs/interaction-model.md](./docs/interaction-model.md): 指针交互分层和拖拽约束
-- [docs/refactor-roadmap.md](./docs/refactor-roadmap.md): 主线重构归档与后续收敛方向
-- [docs/maintenance-audit.md](./docs/maintenance-audit.md): 本轮仓库审计、验证结果和依赖建议
-- [docs/review-remediation-plan.md](./docs/review-remediation-plan.md): 基于审查结论的修复计划与阶段性落地建议
+- [docs/preview-playback-recovery-flow.md](./docs/preview-playback-recovery-flow.md): 预览媒体时钟驱动播放、buffering 阻塞与恢复续播流程

package/dist/components/panel/ClipConfigPanel.d.ts

@@ -105,6 +105,8 @@ export declare class ClipConfigPanel {
     setClip(clip: Clip | null): void;
     setSelectionState(selectionState: ClipConfigPanelSelectionState): void;
     setPreferredTab(tab: 'voice' | null): void;
+    showVoiceGenerationLoading(): void;
+    hideVoiceGenerationLoading(): void;
     setVoiceGenerationBusy(isBusy: boolean): void;
     destroy(): void;
     private render;

package/dist/components/panel/ClipConfigPanelRenderer.d.ts

@@ -114,4 +114,6 @@ export declare class ClipConfigPanelRenderer extends LitDomRenderer<ClipConfigPa
     private getTransform;
     private calculatePresetPosition;
     private resizeSvg;
+    private static colorRafId;
+    private static createColorInputHandler;
 }

package/dist/core/controllers/index.d.ts

@@ -13,4 +13,5 @@ export { TimelinePreviewStateController, type TimelinePendingPreviewState } from
 export { TimelineKeyboardShortcutsController, type TimelineKeyboardShortcutsControllerCallbacks } from './timelineKeyboardShortcutsController';
 export * from './timelineSelectionController';
 export * from './timelineTrackMutationController';
+export { TimelineClipConfigController } from './timelineClipConfigController';
 export { TimelineTrackInfoPanelController } from './timelineTrackInfoPanelController';

package/dist/core/controllers/previewBackend.d.ts

@@ -15,8 +15,6 @@ export interface TimelinePreviewSyncPayload {
     syncRequestId?: number;
 }
 export interface TimelinePreviewBackendCallbacks {
-    onBufferingStateChange?: (isBuffering: boolean) => void;
-    onSourceLoadingChange?: (pending: number) => void;
     onSyncProcessed?: (syncRequestId?: number) => void;
     onRuntimeStateChange?: (state: PreviewRuntimeState) => void;
     onAspectRatioChange?: (aspectRatio: PreviewAspectRatio) => void;
@@ -29,15 +27,31 @@ export interface TimelinePreviewBackendCallbacks {
     /** 预览层文字交互（点击字幕或文字变换控件）时若时间线处于播放中，用于请求暂停 */
     onPauseIfPlaying?: () => void;
 }
+export type PreviewLoadingStatus = 'idle' | 'loading' | 'ready' | 'failed';
+export type PreviewLoadingReason = 'syncing' | 'resolving-source' | 'seeking' | 'media-pending' | 'failed' | null;
+export interface PreviewLoadingState {
+    status: PreviewLoadingStatus;
+    isLoading: boolean;
+    reason: PreviewLoadingReason;
+}
 export interface PreviewPendingState {
-    mode: 'seek' | 'scrub';
+    mode: 'seek' | 'scrub' | 'playback';
     targetTime: TimeMs;
-    loadingPending: number;
-    isBuffering: boolean;
+    loading: PreviewLoadingState;
     errorMessage: string | null;
 }
 export type PreviewRuntimePhase = 'idle' | 'awaiting-sync' | 'awaiting-media' | 'ready' | 'failed';
 export type PreviewSlotPhase = 'idle' | 'binding' | 'primed' | 'active' | 'recovering' | 'failed';
+export type PreviewClockStatus = 'unavailable' | 'priming' | 'running' | 'blocked' | 'failed';
+export type PreviewClockBlockedReason = 'no-video-clock' | 'syncing' | 'resolving-source' | 'seeking' | 'media-pending' | 'media-paused' | 'media-stalled' | 'failed' | null;
+export interface PreviewClockState {
+    status: PreviewClockStatus;
+    timelineTime: TimeMs | null;
+    mediaTime: TimeMs | null;
+    clipId: string | null;
+    trackId: string | null;
+    reason: PreviewClockBlockedReason;
+}
 export interface PreviewSlotDiagnostic {
     trackId: string;
     role: 'current' | 'preload';
@@ -52,8 +66,8 @@ export interface PreviewSlotDiagnostic {
 export interface PreviewRuntimeState {
     syncRequestId?: number;
     phase: PreviewRuntimePhase;
-    loadingCount: number;
-    isBuffering: boolean;
+    loading: PreviewLoadingState;
+    clock?: PreviewClockState;
     errorMessage: string | null;
     slots: PreviewSlotDiagnostic[];
 }

package/dist/core/controllers/previewPendingOverlayRenderer.d.ts

@@ -3,16 +3,15 @@ import type { DomRenderer } from '../renderers/domRenderer';
 export interface PreviewPendingOverlayViewModel {
     pendingState: PreviewPendingState | null;
     runtimeState: PreviewRuntimeState;
-    isBuffering: boolean;
 }
 export declare class PreviewPendingOverlayRenderer implements DomRenderer<PreviewPendingOverlayViewModel> {
     private container;
     private statusElement;
-    private detailElement;
     private actionElement;
     private readonly onRetry;
     constructor(onRetry: () => void);
     mount(container: HTMLElement): void;
     update(viewModel: PreviewPendingOverlayViewModel): void;
+    private resolveLoadingStatusText;
     destroy(): void;
 }

package/dist/core/controllers/previewRecoveryExecution.d.ts

@@ -0,0 +1,25 @@
+import type { ActiveClipPlaybackInfo } from '../models/types';
+import { type PreviewSlotRecoveryReason } from './previewSlotPolicy';
+export interface PreviewRecoveryAttemptInput {
+    entry: ActiveClipPlaybackInfo;
+    desiredSource: string;
+    reason: PreviewSlotRecoveryReason;
+    previousRecoveryKey: string | null;
+    previousRetryCount: number;
+    maxImmediateRecoveryRetries: number;
+    recoveryTimeBucketMs: number;
+    isBackgroundPreload: boolean;
+}
+export type PreviewRecoveryAttemptResult = {
+    status: 'continue';
+    recoveryKey: string;
+    retryCount: number;
+} | {
+    status: 'park';
+    message: string;
+    parkReason: 'retries-exhausted';
+} | {
+    status: 'fail';
+    message: string;
+};
+export declare function resolveRecoveryAttempt(input: PreviewRecoveryAttemptInput): PreviewRecoveryAttemptResult;

package/dist/core/controllers/previewSlotCoordinator.d.ts

@@ -0,0 +1,18 @@
+import type { ActiveClipPlaybackInfo, PlayState } from '../models/types';
+import type { PreviewSlotTarget } from './previewTrackPlanner';
+export interface PreviewSlotLike {
+    role: 'current' | 'preload';
+    trackId: string;
+    entry: ActiveClipPlaybackInfo | null;
+    requestedPlayState: PlayState;
+}
+export interface TrackSlotPairLike<TSlot extends PreviewSlotLike = PreviewSlotLike> {
+    current: TSlot;
+    preload: TSlot;
+}
+export declare function slotHasEntry(slot: PreviewSlotLike, clipId?: string | null): boolean;
+export declare function shouldSwapTrackSlotsForPlan(slots: TrackSlotPairLike, currentEntry: ActiveClipPlaybackInfo | null): boolean;
+export declare function swapTrackSlotPair<TSlot extends PreviewSlotLike>(slots: TrackSlotPairLike<TSlot>): TrackSlotPairLike<TSlot>;
+export declare function buildSlotKey(slot: Pick<PreviewSlotLike, 'trackId' | 'role'>): string;
+export declare function buildDeferredPreloadTarget(slot: PreviewSlotLike, syncRequestId?: number): PreviewSlotTarget | null;
+export declare function resolveSlotFromKey<TSlot extends PreviewSlotLike>(trackSlots: Map<string, TrackSlotPairLike<TSlot>>, slotKey: string): TSlot | null;

package/dist/core/controllers/previewSlotLifecycle.d.ts

@@ -0,0 +1,41 @@
+import type { PlayState } from '../models/types';
+import type { PreviewSlotPhase } from './previewBackend';
+export interface PreviewSlotRecoveryStateLike {
+    isActive: boolean;
+    phase: PreviewSlotPhase;
+    errorMessage: string | null;
+    retryCount: number;
+    recoveryKey: string | null;
+    forceRecover: boolean;
+    isLoading: boolean;
+    isResolvingSource: boolean;
+    isBuffering: boolean;
+    isSeeking: boolean;
+    consecutiveStalledCount: number;
+    expectedEmptiedEvents: number;
+    recoverableEventCount: number;
+    loadStartedSinceRecover: boolean;
+}
+export interface PreviewTrackedCurrentVideoSlotStatus {
+    failed: boolean;
+    resolving: boolean;
+    seeking: boolean;
+    mediaUnready: boolean;
+    ready: boolean;
+}
+export declare function resetSlotRecoveryTrackingState(slot: PreviewSlotRecoveryStateLike, forceRecover?: boolean): void;
+export declare function clearSlotState(slot: PreviewSlotRecoveryStateLike): void;
+export declare function parkPreloadSlotState(slot: PreviewSlotRecoveryStateLike): void;
+export declare function settleResolvedSourceWithoutRecoveryState(slot: Pick<PreviewSlotRecoveryStateLike, 'isActive' | 'phase' | 'isResolvingSource' | 'isLoading' | 'isBuffering' | 'errorMessage'>): void;
+export declare function finalizeAppliedSlotPhase(slot: Pick<PreviewSlotRecoveryStateLike, 'isActive' | 'isLoading' | 'isSeeking' | 'phase'>): void;
+export declare function beginDeferredPreloadState(slot: Pick<PreviewSlotRecoveryStateLike, 'phase' | 'forceRecover' | 'isLoading' | 'isResolvingSource' | 'isSeeking' | 'isBuffering' | 'errorMessage'>, hasAssignedSource: boolean): void;
+export declare function reconcileTrackedCurrentVideoSlotState(slot: PreviewSlotRecoveryStateLike, input: {
+    hasDesiredSource: boolean;
+    sourceMatched: boolean;
+    withinSeekThreshold: boolean;
+    readyState: number;
+    haveCurrentDataState: number;
+}): PreviewTrackedCurrentVideoSlotStatus;
+export declare function failSlotState(slot: Pick<PreviewSlotRecoveryStateLike, 'phase' | 'isLoading' | 'isResolvingSource' | 'isSeeking' | 'isBuffering' | 'errorMessage' | 'forceRecover' | 'expectedEmptiedEvents'>, errorMessage: string): void;
+export declare function beginPreloadPrimingState(slot: Pick<PreviewSlotRecoveryStateLike, 'isActive' | 'isBuffering' | 'isSeeking'>): void;
+export declare function beginSlotRecoveryState(slot: PreviewSlotRecoveryStateLike, playState: PlayState): void;

package/dist/core/controllers/previewSlotPolicy.d.ts

@@ -0,0 +1,59 @@
+import type { ActiveClipPlaybackInfo, PlayState } from '../models/types';
+import type { PreviewSlotPhase } from './previewBackend';
+export type PreviewSlotRecoveryReason = 'reconcile' | 'stalled' | 'abort' | 'emptied' | 'error';
+export interface ResolvedSlotSourceLike {
+    stableSourceUrl: string;
+    url: string;
+    objectUrl: string | null;
+}
+export interface ReusableBoundSlotSourceInput {
+    currentSourceKey: string;
+    nextSourceKey: string;
+    desiredSource: string | null;
+    stableSourceUrl: string | null;
+    objectUrl: string | null;
+}
+export interface PreviewSlotRecoveryNeedInput {
+    desiredSource: string;
+    configuredSource: string | null;
+    assignedSource: string | null;
+    forceRecover: boolean;
+    isActive: boolean;
+    isLoading: boolean;
+    isSeeking: boolean;
+    isBuffering: boolean;
+    phase: PreviewSlotPhase;
+    networkState: number | null;
+    readyState: number | null;
+    networkEmptyState: number;
+    haveCurrentDataState: number;
+}
+export interface PreviewSlotRecoveryNeedResult {
+    needsRecovery: boolean;
+    recoveryReason: string | null;
+    actualSource: string | null;
+    configuredSource: string | null;
+    shouldWarn: boolean;
+}
+export declare function buildRecoveryKey(entry: ActiveClipPlaybackInfo, desiredSource: string, reason: PreviewSlotRecoveryReason, recoveryTimeBucketMs: number): string;
+export declare function getReusableBoundSlotSource(input: ReusableBoundSlotSourceInput): ResolvedSlotSourceLike | null;
+export declare function doesSlotSourceMatchDesired(configuredSource: string | null, assignedSource: string | null, desiredSource: string | null): boolean;
+export declare function evaluateSlotRecoveryNeed(input: PreviewSlotRecoveryNeedInput): PreviewSlotRecoveryNeedResult;
+export declare function getSlotSeekThresholdSeconds(role: 'current' | 'preload', playbackRate: number): number;
+export declare function shouldHardResetRecoveredSource(previousActualSource: string | null, reason: PreviewSlotRecoveryReason, retryCount: number): boolean;
+export declare function buildCurrentSlotTarget(input: {
+    role: 'current' | 'preload';
+    entry: ActiveClipPlaybackInfo;
+    requestedPlayState: PlayState;
+    isActive: boolean;
+    playbackRate: number;
+    syncRequestId?: number;
+}): {
+    role: 'current' | 'preload';
+    entry: ActiveClipPlaybackInfo;
+    playState: PlayState;
+    speed: number;
+    visible: boolean;
+    zIndex: number;
+    syncRequestId?: number;
+};

package/dist/core/controllers/previewTrackPlanner.d.ts

@@ -0,0 +1,24 @@
+import type { ActiveClipPlaybackInfo, TrackType } from '../models/types';
+import type { TimelinePreviewSyncPayload } from './previewBackend';
+export interface PreviewSlotTarget {
+    role: 'current' | 'preload';
+    entry: ActiveClipPlaybackInfo | null;
+    playState: TimelinePreviewSyncPayload['playState'];
+    speed: number;
+    visible: boolean;
+    zIndex: number;
+    syncRequestId?: number;
+}
+export interface PreviewTrackPlan {
+    trackId: string;
+    kind: TrackType;
+    order: number;
+    current: PreviewSlotTarget;
+    preload: PreviewSlotTarget;
+}
+export interface ExistingPreviewTrack {
+    trackId: string;
+    kind: TrackType;
+    order: number;
+}
+export declare function projectPreviewPlan(payload: TimelinePreviewSyncPayload, existingTracks: ExistingPreviewTrack[]): PreviewTrackPlan[];

package/dist/core/controllers/timelineClipConfigController.d.ts

@@ -18,6 +18,8 @@ export declare class TimelineClipConfigController {
     updateFromExternal(): void;
     destroy(): void;
     setPreferredTab(tab: 'voice' | null): void;
+    showVoiceGenerationLoading(): void;
+    hideVoiceGenerationLoading(): void;
     setVoiceGenerationBusy(isBusy: boolean): void;
     private buildSelectionState;
     private resolveUpdateTargets;

package/dist/core/controllers/timelinePreviewSession.d.ts

@@ -4,8 +4,6 @@ import type { ResourceCacheManager } from '../resources/resourceCache';
 import type { PreviewPendingState, PreviewRuntimeState } from './previewBackend';
 import { type DiagnosticEmitInput, type DiagnosticsCenter } from '../../utils/diagnostics';
 interface TimelinePreviewSessionCallbacks {
-    onBufferingStateChange?: (isBuffering: boolean) => void;
-    onSourceLoadingChange?: (pending: number) => void;
     onSyncProcessed?: (syncRequestId?: number) => void;
     onRuntimeStateChange?: (state: PreviewRuntimeState) => void;
     onAspectRatioChange?: (aspectRatio: PreviewAspectRatio) => void;
@@ -54,9 +52,9 @@ export declare class TimelinePreviewSession {
     private readonly textPreviewEntries;
     private audioContext;
     private masterGainNode;
-    private loadingCount;
-    private isBuffering;
-    private bufferingVisibleTimeoutId;
+    private loadingProbeTimeoutId;
+    private clockProbeTimeoutId;
+    private playbackGroupSuspended;
     private lastRuntimeSignature;
     private lastRuntimeState;
     private lastSettledSyncRequestId;
@@ -81,13 +79,13 @@ export declare class TimelinePreviewSession {
     private aspectRatioProbe;
     private aspectRatioProbeSrc;
     private aspectRatioProbeResolveToken;
-    private isAspectRatioProbeLoading;
     private pendingState;
     private activeSyncRequestId;
     private isSyncProjecting;
     private readonly deferredPreloadSlotKeys;
     private deferredPreloadFlushScheduled;
     private lastSyncedPlayState;
+    private pendingClockAlignmentTargetTime;
     constructor(callbacks?: TimelinePreviewSessionCallbacks, dependencies?: TimelinePreviewSessionDependencies);
     private requestPauseIfPlaying;
     private emitDiagnostic;
@@ -117,11 +115,13 @@ export declare class TimelinePreviewSession {
     private resolvePlayableSlotSource;
     private emitRuntimeSourceDiagnostic;
     private getReusableResolvedSlotSource;
+    private getReusableBoundSlotSource;
     private slotNeedsRecovery;
     private recoverSlot;
     private finishSlotRecovery;
     private getSlotKey;
     private isActiveCurrentSlot;
+    private isTrackedActiveCurrentVideoSlot;
     private hasBlockingActiveCurrentSlot;
     private shouldDeferPreloadTarget;
     private shouldDeferPreloadRecovery;
@@ -143,6 +143,9 @@ export declare class TimelinePreviewSession {
     private failSlot;
     private configureAudioRouting;
     private syncCurrentSlot;
+    private resetSlotPlaybackProgressProbe;
+    private updateSlotPlaybackProgressState;
+    private maybeResumeRequestedPlayback;
     private preparePreloadSlot;
     private setSlotVisible;
     private getAudioContext;
@@ -156,9 +159,29 @@ export declare class TimelinePreviewSession {
     private tryResolveAutoAspectRatioFromSlot;
     private handleResolvedAutoAspectRatio;
     private refreshRuntimeState;
-    private syncVisibleBufferingState;
-    private clearBufferingVisibleTimeout;
+    private buildPreviewClockState;
+    private buildPreviewClockStateFromSlot;
+    private resolveClockBlockedReason;
+    private getPreviewClockSourceSlot;
+    private buildPreviewClockSourceCandidate;
+    private comparePreviewClockSourceCandidates;
+    private isPreviewClockCandidateAlignedToTarget;
+    private getPreviewClockTargetAlignmentThresholdMs;
+    private isPreviewClockSlotAlignedToPendingTarget;
+    private updatePendingClockAlignmentTarget;
+    private syncActivePlaybackGroupSuspension;
+    private getSlotMediaTimeMs;
+    private getSlotTimelineTime;
     private refreshPendingOverlay;
+    private buildPreviewLoadingState;
+    private evaluateTrackedCurrentVideoSlot;
+    private doesSlotSourceMatchDesired;
+    private getSlotSeekThresholdSeconds;
+    private finalizeSourceResolutionResult;
+    private syncLoadingProbe;
+    private syncClockProbe;
+    private clearLoadingProbe;
+    private clearClockProbe;
     private handlePreviewTransformChange;
     private refreshVisualLayout;
     private syncTextPreviewEntries;

package/dist/core/controllers/timelinePreviewStateController.d.ts

@@ -1,5 +1,5 @@
 import type { TimeMs } from '../models/types';
-import type { PreviewPendingState, PreviewRuntimeState } from './previewBackend';
+import type { PreviewLoadingState, PreviewPendingState, PreviewRuntimeState } from './previewBackend';
 export interface TimelinePendingPreviewState {
     mode: 'seek' | 'scrub';
     targetTime: TimeMs;
@@ -13,36 +13,26 @@ export interface TimelinePendingPreviewState {
 }
 interface TimelinePreviewStateControllerCallbacks {
     applyPendingState: (state: PreviewPendingState | null) => void;
-    emitBufferingStateChange: (isBuffering: boolean) => void;
-    emitSourceLoadingStateChange: () => void;
+    emitLoadingStateChange: (state: PreviewLoadingState) => void;
     resumePlayback: () => void;
     requestPreviewSync: () => void;
 }
 interface TimelinePreviewStateControllerOptions {
     callbacks: TimelinePreviewStateControllerCallbacks;
-    pendingTimeoutMs?: number;
     failedOverlayDelayMs?: number;
 }
 export declare class TimelinePreviewStateController {
     private readonly callbacks;
-    private readonly pendingTimeoutMs;
     private readonly failedOverlayDelayMs;
-    private _previewSourceLoadingCount;
-    private _previewBuffering;
-    private _previewAwaitingMedia;
+    private _previewLoadingState;
     private _pendingPreviewState;
     private _nextPendingPreviewSyncRequestId;
     constructor(options: TimelinePreviewStateControllerOptions);
-    get previewSourceLoadingCount(): number;
-    set previewSourceLoadingCount(value: number);
-    get previewBuffering(): boolean;
-    set previewBuffering(value: boolean);
+    get previewLoadingState(): PreviewLoadingState;
     get pendingPreviewState(): TimelinePendingPreviewState | null;
     set pendingPreviewState(value: TimelinePendingPreviewState | null);
     get nextPendingPreviewSyncRequestId(): number;
     set nextPendingPreviewSyncRequestId(value: number);
-    handleBufferingStateChange(isBuffering: boolean): void;
-    handleSourceLoadingChange(pending: number): void;
     handleRuntimeStateChange(state: PreviewRuntimeState): void;
     markSyncProcessed(syncRequestId?: number): void;
     beginPendingPreview(time: TimeMs, mode: 'seek' | 'scrub', resumePlayOnReady: boolean): void;
@@ -51,7 +41,8 @@ export declare class TimelinePreviewStateController {
     retryPendingPreview(): void;
     clearPendingPreviewState(): void;
     resetPreviewRuntimeState(): void;
-    private ensurePendingPreviewTimeout;
+    private resolvePendingLoadingState;
+    private buildPlaybackLoadingOverlayState;
     private clearPendingPreviewTimeout;
     private scheduleFailedOverlay;
     private clearFailedOverlayTimeout;