@aura3d/editor-runtime 1.4.0 → 1.4.1

package/src/TimelineRuntimeBridge.ts

@@ -1,280 +0,0 @@
-import { TimelineModel } from "./TimelineModel";
-import type {
-  TimelineActiveClipSnapshot,
-  TimelineClipBlendMode,
-  TimelineSignalEventSnapshot,
-  TimelineSnapshot
-} from "./TimelineModel";
-
-export interface TimelineRuntimeBindingConfig {
-  readonly trackId?: string;
-  readonly trackName?: string;
-  readonly targetId: string;
-  readonly assetId?: string;
-  readonly clipNameMap?: Record<string, string>;
-}
-
-export interface TimelineRuntimeAnimationApplication {
-  readonly targetId: string;
-  readonly trackId: string;
-  readonly trackName: string;
-  readonly clipId: string;
-  readonly clipName: string;
-  readonly assetId?: string;
-  readonly localTime: number;
-  readonly assetTime: number;
-  readonly normalizedTime: number;
-  readonly blendWeight: number;
-  readonly blendMode: TimelineClipBlendMode;
-  readonly playback: TimelineSnapshot["playback"];
-  readonly properties: Record<string, string | number | boolean>;
-}
-
-export interface TimelineRuntimeSignalDispatch {
-  readonly targetId?: string;
-  readonly trackId: string;
-  readonly trackName: string;
-  readonly clipId: string;
-  readonly clipName: string;
-  readonly event: string;
-  readonly time: number;
-  readonly localTime: number;
-  readonly properties: Record<string, string | number | boolean>;
-}
-
-export interface TimelineRuntimeTarget {
-  readonly id: string;
-  applyTimelineAnimation?(application: TimelineRuntimeAnimationApplication): void;
-  applyTimelineSignal?(dispatch: TimelineRuntimeSignalDispatch): void;
-  snapshot?(): unknown;
-}
-
-export interface TimelineRuntimeBridgeConfig {
-  readonly timeline: TimelineModel;
-  readonly targets: readonly TimelineRuntimeTarget[];
-  readonly bindings?: readonly TimelineRuntimeBindingConfig[];
-  readonly strictBindings?: boolean;
-  readonly dispatchSignals?: boolean;
-}
-
-export interface TimelineRuntimeTargetSnapshot {
-  readonly id: string;
-  readonly appliedAnimationCount: number;
-  readonly dispatchedSignalCount: number;
-  readonly snapshot?: unknown;
-}
-
-export interface TimelineRuntimeBridgeSnapshot {
-  readonly kind: "aura-editor-timeline-runtime-bridge";
-  readonly timeline: TimelineSnapshot;
-  readonly appliedAnimationCount: number;
-  readonly dispatchedSignalCount: number;
-  readonly warnings: readonly string[];
-  readonly targets: readonly TimelineRuntimeTargetSnapshot[];
-  readonly lastApplications: readonly TimelineRuntimeAnimationApplication[];
-  readonly lastSignals: readonly TimelineRuntimeSignalDispatch[];
-  readonly evidence: {
-    readonly timelineToRuntimeBridge: true;
-    readonly deterministicApplyAt: true;
-    readonly animationClipBinding: boolean;
-    readonly signalDispatch: boolean;
-    readonly runtimeTargetSnapshots: boolean;
-  };
-}
-
-interface TargetCounters {
-  appliedAnimationCount: number;
-  dispatchedSignalCount: number;
-}
-
-export class TimelineRuntimeBridge {
-  private readonly timeline: TimelineModel;
-  private readonly targets = new Map<string, TimelineRuntimeTarget>();
-  private readonly counters = new Map<string, TargetCounters>();
-  private readonly bindings: readonly TimelineRuntimeBindingConfig[];
-  private readonly strictBindings: boolean;
-  private readonly dispatchSignals: boolean;
-  private readonly seenSignalKeys = new Set<string>();
-  private lastTimelineTime = 0;
-  private lastSnapshot: TimelineRuntimeBridgeSnapshot;
-
-  constructor(config: TimelineRuntimeBridgeConfig) {
-    this.timeline = config.timeline;
-    this.bindings = config.bindings ?? [];
-    this.strictBindings = config.strictBindings ?? false;
-    this.dispatchSignals = config.dispatchSignals ?? true;
-    for (const target of config.targets) {
-      const id = target.id.trim();
-      if (!id) throw new Error("Timeline runtime target id is required.");
-      if (this.targets.has(id)) throw new Error(`Duplicate timeline runtime target id: ${id}`);
-      this.targets.set(id, target);
-      this.counters.set(id, { appliedAnimationCount: 0, dispatchedSignalCount: 0 });
-    }
-    this.lastSnapshot = this.createBridgeSnapshot(this.timeline.snapshot(), [], [], []);
-  }
-
-  step(deltaSeconds: number): TimelineRuntimeBridgeSnapshot {
-    this.timeline.tick(deltaSeconds);
-    return this.applyCurrent();
-  }
-
-  applyAt(time: number, options: { readonly replaySignals?: boolean } = {}): TimelineRuntimeBridgeSnapshot {
-    this.timeline.seek(time);
-    if (options.replaySignals) this.resetSignalCursor();
-    return this.applyCurrent();
-  }
-
-  applyCurrent(): TimelineRuntimeBridgeSnapshot {
-    const timelineSnapshot = this.timeline.snapshot();
-    if (timelineSnapshot.time < this.lastTimelineTime) {
-      this.resetSignalCursor();
-    }
-    this.lastTimelineTime = timelineSnapshot.time;
-
-    const warnings: string[] = [];
-    const applications = this.applyAnimations(timelineSnapshot, warnings);
-    const signals = this.dispatchSignals ? this.applySignals(timelineSnapshot, warnings) : [];
-    this.lastSnapshot = this.createBridgeSnapshot(timelineSnapshot, applications, signals, warnings);
-    return this.lastSnapshot;
-  }
-
-  resetSignalCursor(): void {
-    this.seenSignalKeys.clear();
-  }
-
-  snapshot(): TimelineRuntimeBridgeSnapshot {
-    return this.lastSnapshot;
-  }
-
-  private applyAnimations(snapshot: TimelineSnapshot, warnings: string[]): TimelineRuntimeAnimationApplication[] {
-    const applications: TimelineRuntimeAnimationApplication[] = [];
-    for (const clip of snapshot.activeClips) {
-      if (clip.trackType !== "animation") continue;
-      const binding = this.resolveBinding(clip);
-      const targetId = clip.runtimeTargetId ?? binding?.targetId;
-      if (!targetId) {
-        this.warnOrThrow(`No runtime target binding for animation track ${clip.trackId}.`, warnings);
-        continue;
-      }
-      const target = this.targets.get(targetId);
-      if (!target) {
-        this.warnOrThrow(`Runtime target is not registered for timeline binding: ${targetId}`, warnings);
-        continue;
-      }
-      const clipName = binding?.clipNameMap?.[clip.assetClipName ?? clip.clipName] ?? binding?.clipNameMap?.[clip.clipName] ?? clip.assetClipName ?? clip.clipName;
-      const application: TimelineRuntimeAnimationApplication = {
-        targetId,
-        trackId: clip.trackId,
-        trackName: clip.trackName,
-        clipId: clip.clipId,
-        clipName,
-        assetId: clip.assetId ?? binding?.assetId,
-        localTime: clip.localTime,
-        assetTime: clip.assetTime,
-        normalizedTime: clip.normalizedTime,
-        blendWeight: clip.blendWeight,
-        blendMode: clip.blendMode,
-        playback: snapshot.playback,
-        properties: { ...clip.properties }
-      };
-      target.applyTimelineAnimation?.(application);
-      this.counters.get(targetId)!.appliedAnimationCount += 1;
-      applications.push(application);
-    }
-    return applications;
-  }
-
-  private applySignals(snapshot: TimelineSnapshot, warnings: string[]): TimelineRuntimeSignalDispatch[] {
-    const signals: TimelineRuntimeSignalDispatch[] = [];
-    for (const event of snapshot.signalEventDetails) {
-      const key = `${event.trackId}:${event.clipId}:${event.event}`;
-      if (this.seenSignalKeys.has(key)) continue;
-      this.seenSignalKeys.add(key);
-      const targetId = this.resolveSignalTargetId(event);
-      const dispatch: TimelineRuntimeSignalDispatch = {
-        targetId,
-        trackId: event.trackId,
-        trackName: event.trackName,
-        clipId: event.clipId,
-        clipName: event.clipName,
-        event: event.event,
-        time: event.time,
-        localTime: event.localTime,
-        properties: { ...event.properties }
-      };
-      if (targetId) {
-        const target = this.targets.get(targetId);
-        if (!target) {
-          this.warnOrThrow(`Runtime target is not registered for timeline signal: ${targetId}`, warnings);
-          signals.push(dispatch);
-          continue;
-        }
-        target.applyTimelineSignal?.(dispatch);
-        this.counters.get(targetId)!.dispatchedSignalCount += 1;
-      }
-      signals.push(dispatch);
-    }
-    return signals;
-  }
-
-  private resolveBinding(clip: TimelineActiveClipSnapshot): TimelineRuntimeBindingConfig | undefined {
-    return this.bindings.find((binding) => {
-      if (binding.trackId && binding.trackId === clip.trackId) return true;
-      if (binding.trackName && binding.trackName === clip.trackName) return true;
-      return false;
-    });
-  }
-
-  private resolveSignalTargetId(event: TimelineSignalEventSnapshot): string | undefined {
-    if (typeof event.properties.runtimeNodeId === "string" && event.properties.runtimeNodeId.trim().length > 0) return event.properties.runtimeNodeId;
-    if (typeof event.properties.targetId === "string" && event.properties.targetId.trim().length > 0) return event.properties.targetId;
-    const binding = this.bindings.find((candidate) => {
-      if (candidate.trackId && candidate.trackId === event.trackId) return true;
-      if (candidate.trackName && candidate.trackName === event.trackName) return true;
-      return false;
-    });
-    return binding?.targetId;
-  }
-
-  private createBridgeSnapshot(
-    timeline: TimelineSnapshot,
-    applications: readonly TimelineRuntimeAnimationApplication[],
-    signals: readonly TimelineRuntimeSignalDispatch[],
-    warnings: readonly string[]
-  ): TimelineRuntimeBridgeSnapshot {
-    return {
-      kind: "aura-editor-timeline-runtime-bridge",
-      timeline,
-      appliedAnimationCount: [...this.counters.values()].reduce((total, counter) => total + counter.appliedAnimationCount, 0),
-      dispatchedSignalCount: [...this.counters.values()].reduce((total, counter) => total + counter.dispatchedSignalCount, 0),
-      warnings,
-      targets: [...this.targets.values()].map((target) => {
-        const counter = this.counters.get(target.id)!;
-        return {
-          id: target.id,
-          appliedAnimationCount: counter.appliedAnimationCount,
-          dispatchedSignalCount: counter.dispatchedSignalCount,
-          snapshot: target.snapshot?.()
-        };
-      }),
-      lastApplications: applications,
-      lastSignals: signals,
-      evidence: {
-        timelineToRuntimeBridge: true,
-        deterministicApplyAt: true,
-        animationClipBinding: applications.length > 0,
-        signalDispatch: signals.length > 0,
-        runtimeTargetSnapshots: [...this.targets.values()].some((target) => typeof target.snapshot === "function")
-      }
-    };
-  }
-
-  private warnOrThrow(message: string, warnings: string[]): void {
-    if (this.strictBindings) throw new Error(message);
-    warnings.push(message);
-  }
-}
-
-export function createTimelineRuntimeBridge(config: TimelineRuntimeBridgeConfig): TimelineRuntimeBridge {
-  return new TimelineRuntimeBridge(config);
-}

package/src/TimelineTrackTypes.ts

@@ -1,89 +0,0 @@
-import type { TimelineTrackConfig } from "./TimelineModel";
-
-export type TimelineEditorTrackKind =
-  | "shot"
-  | "animation"
-  | "audio"
-  | "viseme"
-  | "camera"
-  | "dialogue"
-  | "sfx"
-  | "caption"
-  | "selection"
-  | "signal"
-  | "generic";
-
-export interface TimelineTrackTypeDefinition {
-  readonly kind: TimelineEditorTrackKind;
-  readonly timelineType: TimelineTrackConfig["type"];
-  readonly label: string;
-  readonly laneHeight: number;
-  readonly color: string;
-  readonly acceptsClips: boolean;
-  readonly acceptsKeyframes: boolean;
-  readonly waveform: boolean;
-  readonly lockedByDefault?: boolean;
-}
-
-export const TIMELINE_TRACK_TYPES: readonly TimelineTrackTypeDefinition[] = [
-  { kind: "shot", timelineType: "generic", label: "Shots", laneHeight: 36, color: "#2563eb", acceptsClips: true, acceptsKeyframes: false, waveform: false },
-  { kind: "animation", timelineType: "animation", label: "Animation", laneHeight: 44, color: "#16a34a", acceptsClips: true, acceptsKeyframes: true, waveform: false },
-  { kind: "audio", timelineType: "audio", label: "Audio", laneHeight: 48, color: "#db2777", acceptsClips: true, acceptsKeyframes: false, waveform: true },
-  { kind: "viseme", timelineType: "generic", label: "Visemes", laneHeight: 34, color: "#ea580c", acceptsClips: true, acceptsKeyframes: true, waveform: true },
-  { kind: "camera", timelineType: "camera", label: "Camera", laneHeight: 40, color: "#7c3aed", acceptsClips: true, acceptsKeyframes: true, waveform: false },
-  { kind: "dialogue", timelineType: "audio", label: "Dialogue", laneHeight: 42, color: "#0891b2", acceptsClips: true, acceptsKeyframes: false, waveform: true },
-  { kind: "sfx", timelineType: "audio", label: "SFX", laneHeight: 36, color: "#c2410c", acceptsClips: true, acceptsKeyframes: false, waveform: true },
-  { kind: "caption", timelineType: "generic", label: "Captions", laneHeight: 32, color: "#475569", acceptsClips: true, acceptsKeyframes: false, waveform: false },
-  { kind: "selection", timelineType: "selection", label: "Selection", laneHeight: 32, color: "#64748b", acceptsClips: false, acceptsKeyframes: false, waveform: false },
-  { kind: "signal", timelineType: "signal", label: "Signals", laneHeight: 32, color: "#ca8a04", acceptsClips: true, acceptsKeyframes: false, waveform: false },
-  { kind: "generic", timelineType: "generic", label: "Generic", laneHeight: 32, color: "#334155", acceptsClips: true, acceptsKeyframes: false, waveform: false }
-];
-
-export function timelineTrackTypeDefinition(kind: TimelineEditorTrackKind): TimelineTrackTypeDefinition {
-  const definition = TIMELINE_TRACK_TYPES.find((candidate) => candidate.kind === kind);
-  if (!definition) {
-    throw new Error(`Unknown timeline editor track kind: ${kind}`);
-  }
-  return definition;
-}
-
-export function timelineTrackKindFromConfig(track: Pick<TimelineTrackConfig, "type" | "properties">): TimelineEditorTrackKind {
-  const storedKind = track.properties?.auraTrackKind;
-  if (typeof storedKind === "string" && TIMELINE_TRACK_TYPES.some((definition) => definition.kind === storedKind)) {
-    return storedKind as TimelineEditorTrackKind;
-  }
-  if (track.type === "animation" || track.type === "audio" || track.type === "camera" || track.type === "selection" || track.type === "signal") {
-    return track.type;
-  }
-  return "generic";
-}
-
-export interface CreateTimelineTrackConfigOptions {
-  readonly id?: string;
-  readonly muted?: boolean;
-  readonly locked?: boolean;
-  readonly weight?: number;
-  readonly properties?: TimelineTrackConfig["properties"];
-}
-
-export function createTimelineTrackConfig(
-  kind: TimelineEditorTrackKind,
-  name = timelineTrackTypeDefinition(kind).label,
-  options: CreateTimelineTrackConfigOptions = {}
-): TimelineTrackConfig {
-  const definition = timelineTrackTypeDefinition(kind);
-  return {
-    id: options.id,
-    name,
-    type: definition.timelineType,
-    muted: options.muted,
-    locked: options.locked ?? definition.lockedByDefault,
-    weight: options.weight,
-    properties: {
-      ...(options.properties ?? {}),
-      auraTrackKind: kind,
-      laneHeight: definition.laneHeight,
-      color: definition.color
-    }
-  };
-}

package/src/TimelineUI.ts

@@ -1,153 +0,0 @@
-import { TimelineEditorController, type TimelineEditorSnapshot } from "./TimelineEditorController";
-
-export interface TimelineUIOptions {
-  readonly document?: Document;
-  readonly className?: string;
-  readonly onRender?: (snapshot: TimelineEditorSnapshot) => void;
-}
-
-export interface TimelineUIRenderResult {
-  readonly root: HTMLElement;
-  readonly snapshot: TimelineEditorSnapshot;
-  dispose(): void;
-  render(): TimelineUIRenderResult;
-}
-
-export class TimelineUI {
-  private readonly documentRef: Document;
-  private readonly listeners: (() => void)[] = [];
-
-  constructor(
-    private readonly controller: TimelineEditorController,
-    private readonly container: HTMLElement,
-    private readonly options: TimelineUIOptions = {}
-  ) {
-    this.documentRef = options.document ?? container.ownerDocument;
-  }
-
-  render(): TimelineUIRenderResult {
-    this.dispose();
-    const snapshot = this.controller.snapshot();
-    this.container.replaceChildren();
-    this.container.className = this.options.className ?? "aura-timeline";
-    this.container.tabIndex = this.container.tabIndex >= 0 ? this.container.tabIndex : 0;
-
-    const toolbar = this.el("div", "aura-timeline__toolbar");
-    toolbar.append(
-      this.button("Play", () => {
-        this.controller.togglePlayback();
-        this.render();
-      }),
-      this.button("Start", () => {
-        this.controller.scrubTo(0);
-        this.render();
-      }),
-      this.button("End", () => {
-        this.controller.scrubTo(this.controller.timeline.duration);
-        this.render();
-      })
-    );
-
-    const ruler = this.el("div", "aura-timeline__ruler");
-    const durationPixels = Math.max(1, this.controller.timeline.duration * snapshot.zoomPixelsPerSecond);
-    ruler.style.width = `${durationPixels}px`;
-    ruler.append(this.marker("playhead", this.controller.timeline.currentTime));
-    for (let second = 0; second <= Math.ceil(this.controller.timeline.duration); second += 1) {
-      const tick = this.marker("tick", second);
-      tick.textContent = `${second}s`;
-      ruler.append(tick);
-    }
-
-    const tracks = this.el("div", "aura-timeline__tracks");
-    for (const track of this.controller.timeline.tracks) {
-      const trackSnapshot = snapshot.tracks.find((candidate) => candidate.id === track.id);
-      const lane = this.el("div", "aura-timeline__track");
-      lane.dataset.trackId = track.id;
-      lane.dataset.trackKind = trackSnapshot?.kind ?? "generic";
-      lane.dataset.waveform = String(trackSnapshot?.kind === "dialogue" || trackSnapshot?.kind === "audio" || trackSnapshot?.kind === "sfx" || trackSnapshot?.kind === "viseme");
-      lane.style.minHeight = `${trackSnapshot?.laneHeight ?? 32}px`;
-      const label = this.el("div", "aura-timeline__track-label");
-      label.textContent = track.name;
-      const clips = this.el("div", "aura-timeline__clips");
-      clips.style.width = `${durationPixels}px`;
-      for (const clip of track.clips) {
-        const clipEl = this.el("button", "aura-timeline__clip") as HTMLButtonElement;
-        clipEl.type = "button";
-        clipEl.dataset.clipId = clip.id;
-        clipEl.textContent = clip.name;
-        clipEl.style.left = `${clip.startTime * snapshot.zoomPixelsPerSecond}px`;
-        clipEl.style.width = `${Math.max(8, clip.duration * snapshot.zoomPixelsPerSecond)}px`;
-        clipEl.style.background = trackSnapshot?.color ?? "#334155";
-        if (snapshot.selectedIds.includes(clip.id)) clipEl.dataset.selected = "true";
-        const click = (event: MouseEvent): void => {
-          if (trackSnapshot?.kind === "shot") {
-            this.controller.jumpToShot(clip.id);
-          }
-          this.controller.selectClip(clip.id, event.shiftKey);
-          this.render();
-        };
-        clipEl.addEventListener("click", click);
-        this.listeners.push(() => clipEl.removeEventListener("click", click));
-        clips.append(clipEl);
-      }
-      lane.append(label, clips);
-      tracks.append(lane);
-    }
-
-    const minimap = this.el("div", "aura-timeline__minimap");
-    minimap.style.setProperty("--aura-timeline-duration-px", `${durationPixels}px`);
-    minimap.textContent = `${snapshot.timeline.clipCount} clips`;
-
-    const keydown = (event: KeyboardEvent): void => {
-      if (this.controller.handleKeyboardShortcut(event.key)) {
-        event.preventDefault();
-        this.render();
-      }
-    };
-    this.container.addEventListener("keydown", keydown);
-    this.listeners.push(() => this.container.removeEventListener("keydown", keydown));
-
-    this.container.append(toolbar, ruler, tracks, minimap);
-    this.options.onRender?.(snapshot);
-    return {
-      root: this.container,
-      snapshot,
-      dispose: () => this.dispose(),
-      render: () => this.render()
-    };
-  }
-
-  dispose(): void {
-    for (const dispose of this.listeners.splice(0)) dispose();
-  }
-
-  private button(label: string, onClick: () => void): HTMLButtonElement {
-    const button = this.el("button", "aura-timeline__button") as HTMLButtonElement;
-    button.type = "button";
-    button.textContent = label;
-    button.addEventListener("click", onClick);
-    this.listeners.push(() => button.removeEventListener("click", onClick));
-    return button;
-  }
-
-  private marker(kind: string, time: number): HTMLElement {
-    const marker = this.el("div", `aura-timeline__${kind}`);
-    marker.style.left = `${time * this.controller.zoomPixelsPerSecond}px`;
-    marker.dataset.time = String(time);
-    return marker;
-  }
-
-  private el(tagName: string, className: string): HTMLElement {
-    const element = this.documentRef.createElement(tagName);
-    element.className = className;
-    return element;
-  }
-}
-
-export function renderTimelineUI(
-  controller: TimelineEditorController,
-  container: HTMLElement,
-  options: TimelineUIOptions = {}
-): TimelineUIRenderResult {
-  return new TimelineUI(controller, container, options).render();
-}

package/src/TranslateGizmo.ts

@@ -1,39 +0,0 @@
-import { Gizmo, type GizmoDrag } from "./Gizmo";
-import { TransformCommand, type TransformLike } from "./commands/TransformCommand";
-
-export class TranslateGizmo extends Gizmo {
-  async drag(input: GizmoDrag): Promise<void> {
-    if (!this.target) return;
-    const current = readTransform(this.target);
-    const next = clone(current);
-    const delta = this.snapPositionDelta(input.delta);
-    if (input.axis === "x" || input.axis === "xy" || input.axis === "xz") next.position.x += delta;
-    if (input.axis === "y" || input.axis === "xy" || input.axis === "yz") next.position.y += delta;
-    if (input.axis === "z" || input.axis === "xz" || input.axis === "yz") next.position.z += delta;
-    if (input.axis === "uniform") {
-      next.position.x += delta;
-      next.position.y += delta;
-      next.position.z += delta;
-    }
-    await this.history.execute(new TransformCommand(this.target, next));
-  }
-}
-
-function readTransform(target: NonNullable<TranslateGizmo["target"]>): TransformLike {
-  if ("transform" in target) {
-    return {
-      position: { x: target.transform.position[0], y: target.transform.position[1], z: target.transform.position[2] },
-      rotation: { x: target.transform.rotation[0], y: target.transform.rotation[1], z: target.transform.rotation[2], w: target.transform.rotation[3] },
-      scale: { x: target.transform.scale[0], y: target.transform.scale[1], z: target.transform.scale[2] }
-    };
-  }
-  return clone(target);
-}
-
-function clone(transform: TransformLike): TransformLike {
-  return {
-    position: { ...transform.position },
-    rotation: transform.rotation ? { ...transform.rotation } : undefined,
-    scale: transform.scale ? { ...transform.scale } : undefined
-  };
-}

package/src/VisualReviewDashboard.ts

@@ -1,87 +0,0 @@
-import type {
-  EpisodeReviewManualVisemeEdit,
-  EpisodeReviewNote,
-  EpisodeReviewPanelSnapshot,
-  EpisodeReviewRejectedFrame,
-  EpisodeReviewWaveformLane
-} from "./EpisodeReviewPanel";
-
-export interface VisualReviewDashboardPackage {
-  readonly packageId: string;
-  readonly status: EpisodeReviewPanelSnapshot["status"];
-  readonly failedFrameCount: number;
-  readonly noteCount: number;
-  readonly waveformLaneCount: number;
-  readonly manualVisemeEditCount: number;
-  readonly approvalBlocked: boolean;
-}
-
-export interface VisualReviewDashboardSnapshot {
-  readonly kind: "visual-review-dashboard";
-  readonly packageCount: number;
-  readonly packages: readonly VisualReviewDashboardPackage[];
-  readonly failedFrames: readonly (EpisodeReviewRejectedFrame & { readonly packageId: string })[];
-  readonly reviewerNotes: readonly (EpisodeReviewNote & { readonly packageId: string })[];
-  readonly waveformLanes: readonly (EpisodeReviewWaveformLane & { readonly packageId: string })[];
-  readonly manualVisemeEdits: readonly (EpisodeReviewManualVisemeEdit & { readonly packageId: string })[];
-  readonly approvalBlockedPackageIds: readonly string[];
-  readonly evidence: {
-    readonly listsFailedFrames: boolean;
-    readonly listsReviewerNotes: boolean;
-    readonly waveformReview: boolean;
-    readonly manualVisemeEdits: boolean;
-    readonly approvalBlocking: boolean;
-  };
-}
-
-export class VisualReviewDashboard {
-  private reviews: readonly EpisodeReviewPanelSnapshot[];
-
-  constructor(reviews: readonly EpisodeReviewPanelSnapshot[]) {
-    this.reviews = reviews.map((review) => ({ ...review }));
-  }
-
-  setReviews(reviews: readonly EpisodeReviewPanelSnapshot[]): VisualReviewDashboardSnapshot {
-    this.reviews = reviews.map((review) => ({ ...review }));
-    return this.snapshot();
-  }
-
-  snapshot(): VisualReviewDashboardSnapshot {
-    const packages = this.reviews.map((review) => ({
-      packageId: review.packageId,
-      status: review.status,
-      failedFrameCount: review.rejectedFrameCount,
-      noteCount: review.noteCount,
-      waveformLaneCount: review.waveformLaneCount,
-      manualVisemeEditCount: review.manualVisemeEditCount,
-      approvalBlocked: review.rejectedFrameCount > 0
-    }));
-    const failedFrames = this.reviews.flatMap((review) => review.rejectedFrames.map((frame) => ({ ...frame, packageId: review.packageId })));
-    const reviewerNotes = this.reviews.flatMap((review) => review.notes.map((note) => ({ ...note, packageId: review.packageId })));
-    const waveformLanes = this.reviews.flatMap((review) => (review.waveformLanes ?? []).map((lane) => ({ ...lane, packageId: review.packageId })));
-    const manualVisemeEdits = this.reviews.flatMap((review) => (review.manualVisemeEdits ?? []).map((edit) => ({ ...edit, packageId: review.packageId })));
-    const approvalBlockedPackageIds = packages.filter((item) => item.approvalBlocked).map((item) => item.packageId);
-
-    return {
-      kind: "visual-review-dashboard",
-      packageCount: packages.length,
-      packages,
-      failedFrames,
-      reviewerNotes,
-      waveformLanes,
-      manualVisemeEdits,
-      approvalBlockedPackageIds,
-      evidence: {
-        listsFailedFrames: failedFrames.length > 0,
-        listsReviewerNotes: reviewerNotes.length > 0,
-        waveformReview: waveformLanes.length > 0,
-        manualVisemeEdits: manualVisemeEdits.length > 0,
-        approvalBlocking: approvalBlockedPackageIds.length > 0
-      }
-    };
-  }
-}
-
-export function createVisualReviewDashboard(reviews: readonly EpisodeReviewPanelSnapshot[]): VisualReviewDashboard {
-  return new VisualReviewDashboard(reviews);
-}

package/src/commands/CreateNodeCommand.ts

@@ -1,23 +0,0 @@
-import type { Command } from "../Command";
-
-export interface NodeContainer<TNode> {
-  add(node: TNode): void;
-  remove(node: TNode): void;
-}
-
-export class CreateNodeCommand<TNode> implements Command {
-  readonly name = "Create Node";
-
-  constructor(
-    private readonly container: NodeContainer<TNode>,
-    private readonly node: TNode
-  ) {}
-
-  execute(): void {
-    this.container.add(this.node);
-  }
-
-  undo(): void {
-    this.container.remove(this.node);
-  }
-}