premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/move-clip-to-track.jsx

@@ -0,0 +1,220 @@
+// Command: move-clip-to-track → ppb_moveClipToTrack
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveTimelineClip,
+// resolveQeClip, serializeTrackItem, timeValueToSeconds, ...) are
+// already defined there.
+//
+// Moves a clip to a different track of the SAME media type. REWRITTEN
+// 2026-07-17 after the probe session (see BUILD_FINDINGS.md
+// corrections): the working signature on this build — found in the
+// antipaster/Adobe-Premiere-Pro-MCP repo — is the 4-arg
+//   qeClip.moveToTrack(videoTrackOffset, audioTrackOffset,
+//                      timeShiftTicksString, bool)
+// with RELATIVE track offsets (target − source) and the time shift as a
+// ticks string ("0" = keep the clip's time position). Live-verified: it
+// is a TRUE move — per-clip effects/keyframes survive (tested with a
+// Gaussian Blur) and the start time is preserved. This replaces the old
+// LOSSY remove()+overwrite() re-add workaround entirely.
+//
+// The video-clip form (offset in arg1) is live-verified; for audio
+// clips the offset is assumed to belong in arg2 by symmetry — if the
+// arg2 attempt produces no observable change, arg1 is tried as a
+// fallback, with every attempt recorded.
+//
+// MUTATION RULE: verified by re-finding the clip on the TARGET track by
+// name/media path near its original start time, plus per-track clip
+// counts — never by trusting moveToTrack()'s return value.
+
+function ppbMoveClipToTrack_trackCounts(trackCollection) {
+  var counts = [];
+  for (var t = 0; t < trackCollection.numTracks; t++) {
+    counts.push(trackCollection[t].clips.numItems);
+  }
+  return counts;
+}
+
+function ppbMoveClipToTrack_findByNameNear(trackCollection, trackIndex, name, mediaPath, nearSeconds) {
+  if (trackIndex >= trackCollection.numTracks) {
+    return null;
+  }
+  var track = trackCollection[trackIndex];
+  var numClips = track.clips.numItems;
+  var best = null;
+  var bestDelta = null;
+  for (var i = 0; i < numClips; i++) {
+    var c = track.clips[i];
+    var cName = null;
+    var cPath = null;
+    try { cName = c.name; } catch (e) { cName = null; }
+    try { cPath = c.projectItem.getMediaPath(); } catch (e2) { cPath = null; }
+    if (cName === name || (mediaPath !== null && cPath === mediaPath)) {
+      var startSeconds = null;
+      try { startSeconds = timeValueToSeconds(c.start); } catch (e3) { startSeconds = null; }
+      var delta = (startSeconds !== null && nearSeconds !== null) ? Math.abs(startSeconds - nearSeconds) : 0;
+      if (best === null || delta < bestDelta) {
+        best = { clip: c, index: i };
+        bestDelta = delta;
+      }
+    }
+  }
+  return best;
+}
+
+function ppb_moveClipToTrack(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 (typeof args.clipIndex !== "number" || args.clipIndex < 0 || Math.floor(args.clipIndex) !== args.clipIndex) {
+      return JSON.stringify({ ok: false, error: "clipIndex must be a non-negative integer" });
+    }
+    if (typeof args.targetTrackIndex !== "number" || args.targetTrackIndex < 0 || Math.floor(args.targetTrackIndex) !== args.targetTrackIndex) {
+      return JSON.stringify({ ok: false, error: "targetTrackIndex must be a non-negative integer" });
+    }
+    if (args.targetTrackIndex === args.trackIndex) {
+      return JSON.stringify({ ok: false, error: "targetTrackIndex is the same as trackIndex — nothing to move" });
+    }
+
+    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;
+    if (args.targetTrackIndex >= trackCollection.numTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "targetTrackIndex " + args.targetTrackIndex + " is out of range — sequence has " + trackCollection.numTracks + " " + args.trackType + " track(s)"
+      });
+    }
+
+    var resolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    if (resolved.error) {
+      return JSON.stringify({ ok: false, error: resolved.error });
+    }
+    var before = serializeTrackItem(resolved.clip, args.trackIndex, args.clipIndex);
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project) {
+      return JSON.stringify({ ok: false, error: "QE DOM not available after enableQE()" });
+    }
+
+    var qeSeq;
+    try {
+      qeSeq = qe.project.getActiveSequence();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() failed: " + e.toString() });
+    }
+    var qeResolved = resolveQeClip(qeSeq, args.trackType, args.trackIndex, args.clipIndex);
+    if (qeResolved.error) {
+      return JSON.stringify({ ok: false, error: qeResolved.error });
+    }
+    var qeClip = qeResolved.qeClip;
+    if (typeof qeClip.moveToTrack !== "function") {
+      return JSON.stringify({ ok: false, error: "qeClip.moveToTrack is not a function on this build" });
+    }
+
+    var offset = args.targetTrackIndex - args.trackIndex;
+
+    // Arg order: (videoTrackOffset, audioTrackOffset, timeShiftTicks,
+    // bool). The video slot is live-verified; the audio slot is assumed
+    // by symmetry with an arg1 fallback.
+    var forms = [];
+    if (args.trackType === "video") {
+      forms.push({ label: "moveToTrack(offset, 0, '0', false)", a: [offset, 0, "0", false] });
+    } else {
+      forms.push({ label: "moveToTrack(0, offset, '0', false)", a: [0, offset, "0", false] });
+      forms.push({ label: "moveToTrack(offset, 0, '0', false) [audio fallback]", a: [offset, 0, "0", false] });
+    }
+
+    var attempts = [];
+    var moved = false;
+    var formUsed = null;
+    for (var f = 0; f < forms.length && !moved; f++) {
+      var countsBefore = ppbMoveClipToTrack_trackCounts(trackCollection);
+      var att = { form: forms[f].label };
+      try {
+        qeClip.moveToTrack.apply(qeClip, forms[f].a);
+        att.threw = false;
+      } catch (e2) {
+        att.threw = true;
+        att.error = e2.toString();
+      }
+      var countsAfter = ppbMoveClipToTrack_trackCounts(trackCollection);
+      att.effective = false;
+      for (var t = 0; t < countsAfter.length; t++) {
+        if (countsAfter[t] !== countsBefore[t]) { att.effective = true; }
+      }
+      attempts.push(att);
+      if (att.effective) {
+        moved = true;
+        formUsed = forms[f].label;
+      }
+    }
+
+    if (!moved) {
+      return JSON.stringify({
+        ok: false,
+        error: "moveToTrack() produced no observable track change with any argument form tried — the clip was left in place",
+        attempts: attempts,
+        before: before
+      });
+    }
+
+    var found = ppbMoveClipToTrack_findByNameNear(trackCollection, args.targetTrackIndex, before.name, before.mediaPath, before.startSeconds);
+    var after = found ? serializeTrackItem(found.clip, args.targetTrackIndex, found.index) : null;
+
+    var startDelta = (after && after.startSeconds !== null && before.startSeconds !== null)
+      ? (after.startSeconds - before.startSeconds)
+      : null;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        sourceTrackIndex: args.trackIndex,
+        sourceClipIndex: args.clipIndex,
+        targetTrackIndex: args.targetTrackIndex,
+        formUsed: formUsed,
+        attempts: attempts,
+        before: before,
+        after: after,
+        placedOnTarget: after !== null,
+        startSecondsDelta: startDelta,
+        positionPreserved: startDelta !== null && Math.abs(startDelta) < 0.5,
+        note: "TRUE move via qeClip.moveToTrack() — per-clip effects/keyframes survive (live-verified 2026-07-17), unlike the previous remove+overwrite workaround"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/move-clip.jsx

@@ -0,0 +1,97 @@
+// Command: move-clip → ppb_moveClip
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeTrackItem, tryTimeForms, ...) are already
+// defined there.
+//
+// Moves a clip to a new ABSOLUTE start time on the SAME track via
+// clip.start assignment (PREMIERE_API_NOTES.md: "assign clip.start =
+// newStartTicksString ... neither standard-DOM path changes track" —
+// this command does not attempt a cross-track move, matching that
+// documented limitation). Key-argument form is disputed across builds
+// (ticks string vs Time object vs raw seconds), so tryTimeForms() tries
+// each in turn.
+//
+// MUTATION RULE: verified via a clip.start read-back after the
+// assignment, compared against the requested startSeconds with a
+// tolerance (frame-quantization is expected).
+
+function ppb_moveClip(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" || typeof args.clipIndex !== "number") {
+      return JSON.stringify({ ok: false, error: "trackIndex and clipIndex are required" });
+    }
+    if (typeof args.startSeconds !== "number") {
+      return JSON.stringify({ ok: false, error: "startSeconds is required" });
+    }
+
+    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 resolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    if (resolved.error) {
+      return JSON.stringify({ ok: false, error: resolved.error });
+    }
+    var clip = resolved.clip;
+
+    var before = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+
+    var attemptResult = tryTimeForms(args.startSeconds, function (timeArg) {
+      clip.start = timeArg;
+    });
+
+    if (!attemptResult.success) {
+      return JSON.stringify({
+        ok: false,
+        error: "could not set clip.start with any known argument form (ticksString, Time object, seconds) — see attempts",
+        attempts: attemptResult.attempts,
+        previousValue: before
+      });
+    }
+
+    var after = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+    var verified = after.startSeconds !== null && Math.abs(after.startSeconds - args.startSeconds) <= 0.05;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        requestedStartSeconds: args.startSeconds,
+        previousValue: before,
+        newValue: after,
+        verified: verified,
+        formUsed: attemptResult.formUsed,
+        attempts: attemptResult.attempts
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/move-items-to-bin.jsx

@@ -0,0 +1,194 @@
+// Command: move-items-to-bin → ppb_moveItemsToBin
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND, ...)
+// are already defined there.
+//
+// MERGES the reference project's two near-duplicate media.ts/track-
+// targeting.ts tools — move_item_to_bin (single item) and
+// move_items_to_bin (array) — into one command: pass either nodeIds (a
+// JSON array string) OR a single nodeId/name, plus targetBinPath. Item
+// resolution uses children-presence recursion (NOT an isBin() gate) per
+// get-project-item-info.jsx's live-debugged finding that the ROOT item's
+// type is ROOT, not BIN — an isBin() gate would never descend past the
+// root. targetBinPath is a '/'-separated bin path (same convention as
+// create-sequence's bin arg) resolved but never auto-created here — call
+// create-bin first if it might not exist. Each move verified by re-reading
+// the item's own treePath afterward and confirming it now starts with the
+// target bin's treePath.
+
+function ppbMoveItemsToBin_findByNodeId(item, nodeId, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.nodeId === nodeId) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbMoveItemsToBin_findByNodeId(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbMoveItemsToBin_findByName(item, name, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  try {
+    if (item.name === name) {
+      return item;
+    }
+  } catch (e) {
+    // fall through
+  }
+  if (item.children && item.children.numItems > 0) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbMoveItemsToBin_findByName(item.children[i], name, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbMoveItemsToBin_resolveBinPath(binPath) {
+  var segments = binPath.split("/").filter(function (s) { return s.length > 0; });
+  if (segments.length === 0) {
+    return { error: "targetBinPath must contain at least one non-empty segment" };
+  }
+  var current = app.project.rootItem;
+  for (var i = 0; i < segments.length; i++) {
+    var found = null;
+    for (var j = 0; j < current.children.numItems; j++) {
+      var child = current.children[j];
+      if (child.name === segments[i] && typeof ProjectItemType !== "undefined" && child.type === ProjectItemType.BIN) {
+        found = child;
+        break;
+      }
+    }
+    if (!found) {
+      return { error: "bin path segment \"" + segments[i] + "\" not found in \"" + binPath + "\" (target bin must already exist — call create-bin first)" };
+    }
+    current = found;
+  }
+  return { bin: current };
+}
+
+function ppb_moveItemsToBin(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var identifiers = [];
+    if (typeof args.nodeIds === "string" && args.nodeIds.length > 0) {
+      var parsed;
+      try {
+        parsed = JSON.parse(args.nodeIds);
+      } catch (e) {
+        return JSON.stringify({ ok: false, error: "nodeIds must be a JSON array string: " + e.toString() });
+      }
+      if (!(parsed instanceof Array)) {
+        return JSON.stringify({ ok: false, error: "nodeIds must parse to a JSON array" });
+      }
+      for (var i = 0; i < parsed.length; i++) {
+        identifiers.push({ nodeId: parsed[i], name: null });
+      }
+    } else if (typeof args.nodeId === "string" && args.nodeId.length > 0) {
+      identifiers.push({ nodeId: args.nodeId, name: null });
+    } else if (typeof args.name === "string" && args.name.length > 0) {
+      identifiers.push({ nodeId: null, name: args.name });
+    }
+
+    if (identifiers.length === 0) {
+      return JSON.stringify({ ok: false, error: "one of nodeIds (JSON array), nodeId, or name is required" });
+    }
+
+    if (!args.targetBinPath || typeof args.targetBinPath !== "string") {
+      return JSON.stringify({ ok: false, error: "targetBinPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var binResolved = ppbMoveItemsToBin_resolveBinPath(args.targetBinPath);
+    if (binResolved.error) {
+      return JSON.stringify({ ok: false, error: binResolved.error });
+    }
+    var targetBin = binResolved.bin;
+    var targetTreePath = null;
+    try { targetTreePath = targetBin.treePath; } catch (e) { targetTreePath = null; }
+
+    var results = [];
+    var movedCount = 0;
+
+    for (var k = 0; k < identifiers.length; k++) {
+      var ident = identifiers[k];
+      var item = ident.nodeId
+        ? ppbMoveItemsToBin_findByNodeId(app.project.rootItem, ident.nodeId, 0)
+        : ppbMoveItemsToBin_findByName(app.project.rootItem, ident.name, 0);
+
+      if (!item) {
+        results.push({
+          nodeId: ident.nodeId,
+          name: ident.name,
+          moved: false,
+          error: "no project item found matching the given nodeId/name"
+        });
+        continue;
+      }
+
+      var itemName = null;
+      try { itemName = item.name; } catch (e) { itemName = null; }
+      var itemNodeId = null;
+      try { itemNodeId = item.nodeId; } catch (e) { itemNodeId = null; }
+
+      try {
+        item.moveBin(targetBin);
+      } catch (e) {
+        results.push({ nodeId: itemNodeId, name: itemName, moved: false, error: "moveBin() failed: " + e.toString() });
+        continue;
+      }
+
+      var newTreePath = null;
+      try { newTreePath = item.treePath; } catch (e) { newTreePath = null; }
+      var verified = targetTreePath !== null && newTreePath !== null && newTreePath.indexOf(targetTreePath) === 0;
+
+      results.push({
+        nodeId: itemNodeId,
+        name: itemName,
+        moved: true,
+        newTreePath: newTreePath,
+        verified: verified
+      });
+      if (verified) {
+        movedCount++;
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        targetBinPath: args.targetBinPath,
+        requestedCount: identifiers.length,
+        movedCount: movedCount,
+        results: results
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/move-playhead-to-edit.jsx

@@ -0,0 +1,174 @@
+// Command: move-playhead-to-edit → ppb_movePlayheadToEdit
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, ...) are already defined there.
+//
+// Ported from leancoderkavy's premiere-pro-mcp move_playhead_to_edit tool
+// (utility.ts), combining its edit-point-search logic (same one backing
+// get-next-edit-point.jsx: collect every clip start/end tick across all
+// video/audio tracks, sort, dedupe, pick the nearest one before/after the
+// playhead) with move-playhead.jsx's proven seek pattern for the actual
+// move (ticksString first, Time-object fallback, recording each attempt).
+// Standard DOM only, no QE needed.
+//
+// MUTATION RULE: verified by reading back seq.getPlayerPosition() after
+// the seek and reporting it alongside the edit point that was targeted —
+// never trusting the seek call's own (lack of a) return value.
+
+function ppbMovePlayheadToEdit_collectPoints(seq) {
+  var points = [];
+
+  function collect(tracks) {
+    for (var t = 0; t < tracks.numTracks; t++) {
+      for (var c = 0; c < tracks[t].clips.numItems; c++) {
+        var clip = tracks[t].clips[c];
+        try { points.push(parseFloat(clip.start.ticks)); } catch (e) { /* skip */ }
+        try { points.push(parseFloat(clip.end.ticks)); } catch (e) { /* skip */ }
+      }
+    }
+  }
+
+  collect(seq.videoTracks);
+  collect(seq.audioTracks);
+
+  points.sort(function (a, b) { return a - b; });
+
+  var unique = [];
+  for (var i = 0; i < points.length; i++) {
+    if (unique.length === 0 || points[i] !== unique[unique.length - 1]) {
+      unique.push(points[i]);
+    }
+  }
+  return unique;
+}
+
+function ppb_movePlayheadToEdit(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var direction = args.direction === "previous" ? "previous" : "next";
+    if (args.direction !== undefined && args.direction !== null && args.direction !== "next" && args.direction !== "previous") {
+      return JSON.stringify({ ok: false, error: "direction must be \"next\" or \"previous\"" });
+    }
+
+    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" });
+      }
+    }
+
+    if (app.project.activeSequence !== seq) {
+      app.project.activeSequence = seq;
+    }
+
+    var posTicks = null;
+    try {
+      posTicks = parseFloat(seq.getPlayerPosition().ticks);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read the current playhead position: " + e.toString() });
+    }
+
+    var editPoints = ppbMovePlayheadToEdit_collectPoints(seq);
+
+    var found = null;
+    if (direction === "next") {
+      for (var i = 0; i < editPoints.length; i++) {
+        if (editPoints[i] > posTicks + 1) {
+          found = editPoints[i];
+          break;
+        }
+      }
+    } else {
+      for (var j = editPoints.length - 1; j >= 0; j--) {
+        if (editPoints[j] < posTicks - 1) {
+          found = editPoints[j];
+          break;
+        }
+      }
+    }
+
+    if (found === null) {
+      return JSON.stringify({ ok: false, error: "no " + direction + " edit point found from the current playhead position" });
+    }
+
+    var targetSeconds = found / TICKS_PER_SECOND;
+    var ticksString = String(Math.round(found));
+    var timeObj = null;
+    try {
+      timeObj = new Time();
+      timeObj.seconds = targetSeconds;
+    } catch (e) {
+      timeObj = null;
+    }
+
+    var positionAttempts = [];
+    var positionSet = false;
+    try {
+      seq.setPlayerPosition(ticksString);
+      positionAttempts.push({ form: "ticksString", success: true });
+      positionSet = true;
+    } catch (e) {
+      positionAttempts.push({ form: "ticksString", success: false, error: e.toString() });
+    }
+    if (!positionSet && timeObj !== null) {
+      try {
+        seq.setPlayerPosition(timeObj);
+        positionAttempts.push({ form: "TimeObject", success: true });
+        positionSet = true;
+      } catch (e) {
+        positionAttempts.push({ form: "TimeObject", success: false, error: e.toString() });
+      }
+    }
+
+    if (!positionSet) {
+      return JSON.stringify({
+        ok: false,
+        error: "could not move the playhead to the found edit point with any known argument form (ticks string, Time object)",
+        attempts: positionAttempts
+      });
+    }
+
+    var playheadSeconds = null;
+    try {
+      var currentPosition = seq.getPlayerPosition();
+      if (currentPosition !== null && typeof currentPosition !== "undefined") {
+        if (typeof currentPosition.seconds === "number") {
+          playheadSeconds = currentPosition.seconds;
+        } else {
+          playheadSeconds = Number(currentPosition.ticks) / TICKS_PER_SECOND;
+        }
+      }
+    } catch (e) {
+      playheadSeconds = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        direction: direction,
+        editPointSeconds: targetSeconds,
+        playheadSeconds: playheadSeconds,
+        attempts: positionAttempts
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}