premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/get-sequence-markers-by-type.jsx

@@ -0,0 +1,89 @@
+// Command: get-sequence-markers-by-type → ppb_getSequenceMarkersByType
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, timeValueToSeconds, ...) are already defined there.
+//
+// Same marker iteration pattern as get-full-sequence-info.jsx and
+// list-markers.jsx (getFirstMarker/getNextMarker, capped at 10000),
+// filtering to markers whose type matches the requested type.
+
+var PPB_MARKER_TYPES = ["Comment", "Chapter", "Segmentation", "WebLink", "FlashCuePoint"];
+
+function ppbMarkersByType_isValidType(type) {
+  for (var i = 0; i < PPB_MARKER_TYPES.length; i++) {
+    if (PPB_MARKER_TYPES[i] === type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function ppbMarkersByType_serialize(seq, type) {
+  var markers = [];
+  var m = seq.markers.getFirstMarker();
+  var iterations = 0;
+  while (m !== null && typeof m !== "undefined" && iterations < 10000) {
+    var markerType = null;
+    try { markerType = m.type; } catch (e) { markerType = null; }
+
+    if (markerType === type) {
+      var entry = { name: null, comments: null, type: markerType, startSeconds: null, endSeconds: null, guid: null };
+      try { entry.name = m.name; } catch (e) { entry.name = null; }
+      try { entry.comments = m.comments; } catch (e) { entry.comments = null; }
+      try { entry.startSeconds = timeValueToSeconds(m.start); } catch (e) { entry.startSeconds = null; }
+      try { entry.endSeconds = timeValueToSeconds(m.end); } catch (e) { entry.endSeconds = null; }
+      try { entry.guid = m.guid; } catch (e) { entry.guid = null; }
+      markers.push(entry);
+    }
+
+    m = seq.markers.getNextMarker(m);
+    iterations++;
+  }
+  return markers;
+}
+
+function ppb_getSequenceMarkersByType(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (typeof args.type !== "string" || !ppbMarkersByType_isValidType(args.type)) {
+      return JSON.stringify({ ok: false, error: "type must be one of: " + PPB_MARKER_TYPES.join(", ") });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var markers = [];
+    try {
+      markers = ppbMarkersByType_serialize(seq, args.type);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "failed to read markers: " + e.toString() });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: { sequenceName: seq.name, type: args.type, markers: markers, count: markers.length }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-source-monitor-info.jsx

@@ -0,0 +1,34 @@
+// Command: get-source-monitor-info → ppb_getSourceMonitorInfo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use.
+//
+// Standard-DOM read only — no QE DOM needed. Ported from leancoderkavy's
+// premiere-pro-mcp `get_source_monitor_info` tool (source-monitor.ts). No
+// clip loaded in the Source Monitor is a valid, truthful "loaded: false"
+// result, not an error — same convention as get-premiere-state.
+
+function ppb_getSourceMonitorInfo() {
+  try {
+    var item = null;
+    try {
+      item = app.sourceMonitor.getProjectItem();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.sourceMonitor.getProjectItem() failed: " + e.toString() });
+    }
+
+    if (!item) {
+      return JSON.stringify({ ok: true, result: { loaded: false } });
+    }
+
+    var result = { loaded: true, nodeId: null, name: null, mediaPath: null, inPointSeconds: null, outPointSeconds: null };
+
+    try { result.nodeId = item.nodeId; } catch (e) { result.nodeId = null; }
+    try { result.name = item.name; } catch (e) { result.name = null; }
+    try { result.mediaPath = item.getMediaPath(); } catch (e) { result.mediaPath = null; }
+    try { result.inPointSeconds = timeValueToSeconds(item.getInPoint()); } catch (e) { result.inPointSeconds = null; }
+    try { result.outPointSeconds = timeValueToSeconds(item.getOutPoint()); } catch (e) { result.outPointSeconds = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-source-monitor-position.jsx

@@ -0,0 +1,30 @@
+// Command: get-source-monitor-position → ppb_getSourceMonitorPosition
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// timeValueToSeconds, ...) are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's playback.ts
+// get_source_monitor_position. Standard DOM (app.sourceMonitor.getPosition())
+// — no sequence involved. Fails if no clip is currently open in the
+// Source Monitor.
+function ppb_getSourceMonitorPosition(argsJson) {
+  try {
+    var pos = null;
+    try {
+      pos = app.sourceMonitor.getPosition();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read source monitor position: " + e.toString() });
+    }
+
+    if (pos === null || typeof pos === "undefined") {
+      return JSON.stringify({ ok: false, error: "no clip open in Source Monitor" });
+    }
+
+    var seconds = null;
+    try { seconds = timeValueToSeconds(pos); } catch (e) { seconds = null; }
+
+    return JSON.stringify({ ok: true, result: { seconds: seconds } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-target-tracks.jsx

@@ -0,0 +1,76 @@
+// Command: get-target-tracks → ppb_getTargetTracks
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Standard-DOM read only — no QE DOM needed, no need to activate the
+// sequence tab. Ported from leancoderkavy's premiere-pro-mcp
+// `get_target_tracks` tool (track-targeting.ts), which only reads the
+// active sequence; here `sequenceName` may target any open sequence.
+
+function ppb_getTargetTracks(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var video = [];
+    try {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        var vTrack = seq.videoTracks[v];
+        try {
+          if (vTrack.isTargeted()) {
+            video.push({ index: v, name: vTrack.name });
+          }
+        } catch (e) {
+          // skip tracks whose isTargeted() throws
+        }
+      }
+    } catch (e) {
+      // leave video as whatever was collected so far
+    }
+
+    var audio = [];
+    try {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        var aTrack = seq.audioTracks[a];
+        try {
+          if (aTrack.isTargeted()) {
+            audio.push({ index: a, name: aTrack.name });
+          }
+        } catch (e) {
+          // skip tracks whose isTargeted() throws
+        }
+      }
+    } catch (e) {
+      // leave audio as whatever was collected so far
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: { sequenceName: seq.name, video: video, audio: audio }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-timeline-gaps.jsx

@@ -0,0 +1,124 @@
+// Command: get-timeline-gaps → ppb_getTimelineGaps
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, timeValueToSeconds, ...) are already defined there.
+//
+// Standard-DOM read only, no QE DOM needed. Assumes each track's clips
+// collection is already ordered by start time (Premiere returns it that
+// way) — walks each track once, tracking the end of the previous clip and
+// reporting any gap larger than minGapSeconds before the next one.
+
+var PPB_TIMELINE_GAPS_DEFAULT_MIN_SECONDS = 0.04;
+
+function ppbTimelineGaps_findGaps(tracks, trackType, minGapSeconds, gaps) {
+  for (var t = 0; t < tracks.numTracks; t++) {
+    var track = tracks[t];
+    var numClips = 0;
+    try {
+      numClips = track.clips.numItems;
+    } catch (e) {
+      numClips = 0;
+    }
+    if (numClips === 0) {
+      continue;
+    }
+
+    var trackName = null;
+    try { trackName = track.name; } catch (e) { trackName = null; }
+
+    var prevEnd = 0;
+    var prevClipName = null;
+    for (var c = 0; c < numClips; c++) {
+      var clip = track.clips[c];
+
+      var startSeconds = null;
+      var endSeconds = null;
+      var clipName = null;
+      try { startSeconds = timeValueToSeconds(clip.start); } catch (e) { startSeconds = null; }
+      try { endSeconds = timeValueToSeconds(clip.end); } catch (e) { endSeconds = null; }
+      try { clipName = clip.name; } catch (e) { clipName = null; }
+
+      if (startSeconds !== null) {
+        var gapSeconds = startSeconds - prevEnd;
+        if (gapSeconds > minGapSeconds) {
+          gaps.push({
+            trackType: trackType,
+            trackIndex: t,
+            trackName: trackName,
+            gapStartSeconds: prevEnd,
+            gapEndSeconds: startSeconds,
+            gapDurationSeconds: gapSeconds,
+            beforeClip: prevClipName,
+            afterClip: clipName
+          });
+        }
+      }
+
+      if (endSeconds !== null) {
+        prevEnd = endSeconds;
+      }
+      prevClipName = clipName;
+    }
+  }
+}
+
+function ppb_getTimelineGaps(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var trackType = args.trackType;
+    if (trackType !== "video" && trackType !== "audio" && trackType !== "both" && typeof trackType !== "undefined" && trackType !== null) {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\", \"audio\", or \"both\"" });
+    }
+    if (!trackType) {
+      trackType = "both";
+    }
+
+    var minGapSeconds = PPB_TIMELINE_GAPS_DEFAULT_MIN_SECONDS;
+    if (typeof args.minGapSeconds === "number" && args.minGapSeconds >= 0) {
+      minGapSeconds = args.minGapSeconds;
+    }
+
+    var gaps = [];
+    if (trackType !== "audio") {
+      ppbTimelineGaps_findGaps(seq.videoTracks, "video", minGapSeconds, gaps);
+    }
+    if (trackType !== "video") {
+      ppbTimelineGaps_findGaps(seq.audioTracks, "audio", minGapSeconds, gaps);
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        gapCount: gaps.length,
+        minGapSeconds: minGapSeconds,
+        gaps: gaps
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-timeline-summary.jsx

@@ -0,0 +1,154 @@
+// Command: get-timeline-summary → ppb_getTimelineSummary
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, serializeTrackItem, ...) are already defined there.
+//
+// Standard-DOM read only (seq.videoTracks[i].clips[j]) — no QE DOM needed,
+// no need to activate the sequence tab. Compact, human-oriented overview —
+// no per-clip data, just per-track roll-ups.
+
+// video clips have Motion+Opacity built in (2 baseline components);
+// audio clips have their own built-in component(s) (Volume etc, baseline 1).
+var GET_TIMELINE_SUMMARY_VIDEO_BASELINE_COMPONENTS = 2;
+var GET_TIMELINE_SUMMARY_AUDIO_BASELINE_COMPONENTS = 1;
+
+function ppb_summarizeTrackForTimelineSummary(track, trackIndex, durationSeconds, baselineComponents) {
+  var out = { index: trackIndex, name: null, clipCount: 0, coveragePercent: 0 };
+  var totalClips = 0;
+  var clipsWithEffects = 0;
+  var coveredSeconds = 0;
+
+  try { out.name = track.name; } catch (e) { out.name = null; }
+
+  try {
+    var numClips = track.clips.numItems;
+    out.clipCount = numClips;
+    totalClips = numClips;
+
+    for (var c = 0; c < numClips; c++) {
+      var clip = track.clips[c];
+
+      try {
+        var clipDuration = timeValueToSeconds(clip.duration);
+        if (clipDuration !== null) {
+          coveredSeconds += clipDuration;
+        }
+      } catch (e) {
+        // skip unreadable clip duration
+      }
+
+      try {
+        if (clip.components.numItems > baselineComponents) {
+          clipsWithEffects++;
+        }
+      } catch (e) {
+        // skip unreadable clip components
+      }
+    }
+  } catch (e) {
+    // leave clipCount/totals as whatever was collected so far
+  }
+
+  if (durationSeconds && durationSeconds > 0) {
+    out.coveragePercent = Math.round((coveredSeconds / durationSeconds) * 1000) / 10;
+  } else {
+    out.coveragePercent = 0;
+  }
+
+  return { track: out, totalClips: totalClips, clipsWithEffects: clipsWithEffects };
+}
+
+function ppb_getTimelineSummary(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var frameRate = null;
+    try {
+      frameRate = getSequenceFps(seq);
+    } catch (e) {
+      frameRate = null;
+    }
+
+    var durationSeconds = null;
+    try {
+      durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+    } catch (e) {
+      durationSeconds = null;
+    }
+
+    var totalClips = 0;
+    var clipsWithEffects = 0;
+
+    var videoTracks = [];
+    try {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        var vSummary = ppb_summarizeTrackForTimelineSummary(
+          seq.videoTracks[v], v, durationSeconds, GET_TIMELINE_SUMMARY_VIDEO_BASELINE_COMPONENTS
+        );
+        videoTracks.push(vSummary.track);
+        totalClips += vSummary.totalClips;
+        clipsWithEffects += vSummary.clipsWithEffects;
+      }
+    } catch (e) {
+      // leave videoTracks as whatever was collected so far
+    }
+
+    var audioTracks = [];
+    try {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        var aSummary = ppb_summarizeTrackForTimelineSummary(
+          seq.audioTracks[a], a, durationSeconds, GET_TIMELINE_SUMMARY_AUDIO_BASELINE_COMPONENTS
+        );
+        audioTracks.push(aSummary.track);
+        totalClips += aSummary.totalClips;
+        clipsWithEffects += aSummary.clipsWithEffects;
+      }
+    } catch (e) {
+      // leave audioTracks as whatever was collected so far
+    }
+
+    var markerCount = null;
+    try {
+      markerCount = seq.markers.numMarkers;
+    } catch (e) {
+      markerCount = null;
+    }
+
+    var result = {
+      sequenceName: seq.name,
+      frameRate: frameRate,
+      durationSeconds: durationSeconds,
+      videoTracks: videoTracks,
+      audioTracks: audioTracks,
+      totalClips: totalClips,
+      clipsWithEffects: clipsWithEffects,
+      markerCount: markerCount
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-total-clip-count.jsx

@@ -0,0 +1,67 @@
+// Command: get-total-clip-count → ppb_getTotalClipCount
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Standard-DOM read only — no QE DOM needed, no need to activate the
+// sequence tab. Ported from leancoderkavy's premiere-pro-mcp
+// `get_total_clip_count` tool (utility.ts), which only reads the active
+// sequence; here `sequenceName` may target any open sequence.
+
+function ppb_getTotalClipCount(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var videoClips = 0;
+    try {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        videoClips += seq.videoTracks[v].clips.numItems;
+      }
+    } catch (e) {
+      // leave videoClips as whatever was collected so far
+    }
+
+    var audioClips = 0;
+    try {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        audioClips += seq.audioTracks[a].clips.numItems;
+      }
+    } catch (e) {
+      // leave audioClips as whatever was collected so far
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        videoClips: videoClips,
+        audioClips: audioClips,
+        total: videoClips + audioClips
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-track-info.jsx

@@ -0,0 +1,117 @@
+// Command: get-track-info → ppb_getTrackInfo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// timeValueToSeconds, ...) are already defined there.
+//
+// Standard-DOM read only — no QE DOM needed, no need to activate the
+// sequence tab. Ported from leancoderkavy's premiere-pro-mcp
+// `get_track_info` tool (track-targeting.ts).
+
+function ppb_getTrackInfo(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (args.trackType !== "video" && args.trackType !== "audio") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" or \"audio\"" });
+    }
+    if (typeof args.trackIndex !== "number" || args.trackIndex < 0 || Math.floor(args.trackIndex) !== args.trackIndex) {
+      return JSON.stringify({ ok: false, error: "trackIndex must be a non-negative integer" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var trackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var numTracks = trackCollection.numTracks;
+    if (args.trackIndex >= numTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "trackIndex " + args.trackIndex + " is out of range — sequence has " + numTracks + " " + args.trackType + " track(s)"
+      });
+    }
+
+    var track = trackCollection[args.trackIndex];
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: args.trackType,
+      trackIndex: args.trackIndex,
+      name: null,
+      clipCount: 0,
+      isMuted: null,
+      isLocked: null,
+      isTargeted: null,
+      clips: [],
+      transitions: []
+    };
+
+    try { result.name = track.name; } catch (e) { result.name = null; }
+    try { result.isMuted = track.isMuted(); } catch (e) { result.isMuted = null; }
+    try { result.isLocked = track.isLocked(); } catch (e) { result.isLocked = null; }
+    try { result.isTargeted = track.isTargeted(); } catch (e) { result.isTargeted = null; }
+
+    try {
+      var numClips = track.clips.numItems;
+      result.clipCount = numClips;
+      for (var c = 0; c < numClips; c++) {
+        var clip = track.clips[c];
+        var ci = {
+          clipIndex: c,
+          nodeId: null,
+          name: null,
+          startSeconds: null,
+          endSeconds: null,
+          durationSeconds: null,
+          disabled: null,
+          speed: null
+        };
+        try { ci.nodeId = clip.nodeId; } catch (e) { ci.nodeId = null; }
+        try { ci.name = clip.name; } catch (e) { ci.name = null; }
+        try { ci.startSeconds = timeValueToSeconds(clip.start); } catch (e) { ci.startSeconds = null; }
+        try { ci.endSeconds = timeValueToSeconds(clip.end); } catch (e) { ci.endSeconds = null; }
+        try { ci.durationSeconds = timeValueToSeconds(clip.duration); } catch (e) { ci.durationSeconds = null; }
+        try { ci.disabled = clip.disabled; } catch (e) { ci.disabled = null; }
+        try { ci.speed = clip.getSpeed(); } catch (e) { ci.speed = null; }
+        result.clips.push(ci);
+      }
+    } catch (e) {
+      // leave clips as whatever was collected so far
+    }
+
+    try {
+      var numTransitions = track.transitions.numItems;
+      for (var t = 0; t < numTransitions; t++) {
+        var transition = track.transitions[t];
+        var ti = { transitionIndex: t, startSeconds: null, endSeconds: null };
+        try { ti.startSeconds = timeValueToSeconds(transition.start); } catch (e) { ti.startSeconds = null; }
+        try { ti.endSeconds = timeValueToSeconds(transition.end); } catch (e) { ti.endSeconds = null; }
+        result.transitions.push(ti);
+      }
+    } catch (e) {
+      // transitions collection unavailable on this track/build — leave empty
+    }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}