premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/slide-edit.jsx

@@ -0,0 +1,162 @@
+// Command: slide-edit → ppb_slideEdit
+// 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, TICKS_PER_SECOND, ...) are already
+// defined there.
+//
+// Slides the addressed clip earlier/later on the timeline WITHOUT
+// changing its own duration or source in/out points — the adjacent
+// clips' out/in points absorb the shift instead. Ported from
+// leancoderkavy's premiere-pro-mcp `slide_edit` tool (advanced.ts:
+// `qeClip.slide(offsetTicksString)`), whose signature is UNCONFIRMED on
+// this build (`slide` is on our own reflect list per QE_DOM_NOTES.md /
+// PREMIERE_API_NOTES.md, but never live-called) — every plausible
+// argument form is tried in turn (ticks string, then a raw seconds
+// number, then a Time object), recording an `attempts` array, and
+// success is judged by an actual before/after shift in the clip's own
+// start time matching the requested offset, never by whether the call
+// merely avoided throwing. Positive offsetSeconds slides later, negative
+// slides earlier.
+
+function ppbSlideEdit_offsetForms(offsetSeconds) {
+  var ticksString = String(Math.round(offsetSeconds * TICKS_PER_SECOND));
+  var timeObj = null;
+  try {
+    timeObj = new Time();
+    timeObj.seconds = offsetSeconds;
+  } catch (e) {
+    timeObj = null;
+  }
+  var forms = [
+    { label: "ticksString", value: ticksString },
+    { label: "seconds", value: offsetSeconds }
+  ];
+  if (timeObj !== null) {
+    forms.push({ label: "TimeObject", value: timeObj });
+  }
+  return forms;
+}
+
+function ppb_slideEdit(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.offsetSeconds !== "number" || isNaN(args.offsetSeconds) || args.offsetSeconds === 0) {
+      return JSON.stringify({ ok: false, error: "offsetSeconds must be a non-zero number" });
+    }
+
+    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 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.slide !== "function") {
+      return JSON.stringify({ ok: false, error: "qeClip.slide is not available on this Premiere build" });
+    }
+
+    var attempts = [];
+    var forms = ppbSlideEdit_offsetForms(args.offsetSeconds);
+    var succeeded = false;
+    var formUsed = null;
+    for (var i = 0; i < forms.length && !succeeded; i++) {
+      try {
+        qeClip.slide(forms[i].value);
+        attempts.push({ form: forms[i].label, success: true });
+        succeeded = true;
+        formUsed = forms[i].label;
+      } catch (e) {
+        attempts.push({ form: forms[i].label, success: false, error: e.toString() });
+      }
+    }
+
+    if (!succeeded) {
+      return JSON.stringify({
+        ok: false,
+        error: "qeClip.slide() failed with every argument form tried",
+        attempts: attempts
+      });
+    }
+
+    var afterResolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    var after = afterResolved.clip ? serializeTrackItem(afterResolved.clip, args.trackIndex, args.clipIndex) : null;
+
+    var startDelta = (after && before && after.startSeconds !== null && before.startSeconds !== null)
+      ? (after.startSeconds - before.startSeconds)
+      : null;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        requestedOffsetSeconds: args.offsetSeconds,
+        formUsed: formUsed,
+        attempts: attempts,
+        before: before,
+        after: after,
+        startSecondsDelta: startDelta,
+        verified: startDelta !== null && Math.abs(startDelta - args.offsetSeconds) < 0.5,
+        note: "verified compares the clip's own start-time shift against the requested offset within half a second — slide's exact neighbor-absorption semantics are unconfirmed on this build (see PREMIERE_API_NOTES.md)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/slip-edit.jsx

@@ -0,0 +1,167 @@
+// Command: slip-edit → ppb_slipEdit
+// 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, TICKS_PER_SECOND, ...) are already
+// defined there.
+//
+// Slips the addressed clip's source in/out points forward/backward
+// WITHOUT moving it on the timeline (its start/end stay fixed; which
+// portion of the source media it shows changes). Ported from
+// leancoderkavy's premiere-pro-mcp `slip_edit` tool (advanced.ts:
+// `qeClip.slip(offsetTicksString)`), whose signature is UNCONFIRMED on
+// this build (`slip` is on our own reflect list per QE_DOM_NOTES.md /
+// PREMIERE_API_NOTES.md, but never live-called) — every plausible
+// argument form is tried in turn (ticks string, then a raw seconds
+// number, then a Time object), recording an `attempts` array, and
+// success is judged by an actual before/after shift in the clip's own
+// inPoint matching the requested offset, never by whether the call
+// merely avoided throwing. Positive offsetSeconds slips forward in the
+// source, negative slips backward.
+
+function ppbSlipEdit_offsetForms(offsetSeconds) {
+  var ticksString = String(Math.round(offsetSeconds * TICKS_PER_SECOND));
+  var timeObj = null;
+  try {
+    timeObj = new Time();
+    timeObj.seconds = offsetSeconds;
+  } catch (e) {
+    timeObj = null;
+  }
+  var forms = [
+    { label: "ticksString", value: ticksString },
+    { label: "seconds", value: offsetSeconds }
+  ];
+  if (timeObj !== null) {
+    forms.push({ label: "TimeObject", value: timeObj });
+  }
+  return forms;
+}
+
+function ppb_slipEdit(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.offsetSeconds !== "number" || isNaN(args.offsetSeconds) || args.offsetSeconds === 0) {
+      return JSON.stringify({ ok: false, error: "offsetSeconds must be a non-zero number" });
+    }
+
+    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 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.slip !== "function") {
+      return JSON.stringify({ ok: false, error: "qeClip.slip is not available on this Premiere build" });
+    }
+
+    var attempts = [];
+    var forms = ppbSlipEdit_offsetForms(args.offsetSeconds);
+    var succeeded = false;
+    var formUsed = null;
+    for (var i = 0; i < forms.length && !succeeded; i++) {
+      try {
+        qeClip.slip(forms[i].value);
+        attempts.push({ form: forms[i].label, success: true });
+        succeeded = true;
+        formUsed = forms[i].label;
+      } catch (e) {
+        attempts.push({ form: forms[i].label, success: false, error: e.toString() });
+      }
+    }
+
+    if (!succeeded) {
+      return JSON.stringify({
+        ok: false,
+        error: "qeClip.slip() failed with every argument form tried",
+        attempts: attempts
+      });
+    }
+
+    var afterResolved = resolveTimelineClip(seq, args.trackType, args.trackIndex, args.clipIndex);
+    var after = afterResolved.clip ? serializeTrackItem(afterResolved.clip, args.trackIndex, args.clipIndex) : null;
+
+    var inPointDelta = (after && before && after.inPointSeconds !== null && before.inPointSeconds !== null)
+      ? (after.inPointSeconds - before.inPointSeconds)
+      : null;
+    var startDelta = (after && before && after.startSeconds !== null && before.startSeconds !== null)
+      ? (after.startSeconds - before.startSeconds)
+      : null;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        requestedOffsetSeconds: args.offsetSeconds,
+        formUsed: formUsed,
+        attempts: attempts,
+        before: before,
+        after: after,
+        inPointSecondsDelta: inPointDelta,
+        startSecondsDelta: startDelta,
+        verified: inPointDelta !== null && Math.abs(inPointDelta - args.offsetSeconds) < 0.5 &&
+          (startDelta === null || Math.abs(startDelta) < 0.5),
+        note: "verified checks that inPoint shifted by roughly the requested offset while start stayed roughly fixed — slip's exact semantics are unconfirmed on this build (see PREMIERE_API_NOTES.md)."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

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

@@ -0,0 +1,144 @@
+
+// seconds -> "HH:MM:SS:FF" — the razor argument form PROVEN working on
+// this build (remove-track-intervals live-validated it); the ticksString
+// form silently no-ops (live-tested 2026-07-17).
+function ppbSplitClip_secondsToQeTimecode(seconds, fps) {
+  var totalFrames = Math.round(seconds * fps);
+  var ff = totalFrames % Math.round(fps);
+  var totalSeconds = Math.floor(totalFrames / Math.round(fps));
+  var ss = totalSeconds % 60;
+  var totalMinutes = Math.floor(totalSeconds / 60);
+  var mm = totalMinutes % 60;
+  var hh = Math.floor(totalMinutes / 60);
+  function pad2(n) { return (n < 10 ? "0" : "") + n; }
+  return pad2(hh) + ":" + pad2(mm) + ":" + pad2(ss) + ":" + pad2(ff);
+}
+// Command: split-clip → ppb_splitClip
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, secondsToTicksString, ...) are
+// already defined there.
+//
+// Splits (razors) whichever clip covers a given SEQUENCE-TIME position on
+// one track, via the QE DOM's qeTrack.razor(ticksString) —
+// PREMIERE_API_NOTES.md: "Split/razor: QE only ... Standard-DOM
+// 'fallback' (truncating clip.end) is destructive — don't." Addressed by
+// trackType/trackIndex only (not clipIndex) since a razor cut targets a
+// TIME, not a specific clip index — matches leancoderkavy's
+// premiere-pro-mcp split_clip tool. Activates the resolved sequence
+// first (QE DOM only ever operates on the active sequence tab), same
+// pattern as remove-track-intervals/get-qe-clip-info.
+//
+// MUTATION RULE: verified via the STANDARD-DOM track's clips.numItems
+// increasing by exactly one (never razor()'s own return value).
+
+function ppb_splitClip(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") {
+      return JSON.stringify({ ok: false, error: "trackIndex is required" });
+    }
+    if (typeof args.seconds !== "number") {
+      return JSON.stringify({ ok: false, error: "seconds 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 stdTrackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var numStdTracks;
+    try { numStdTracks = stdTrackCollection.numTracks; } catch (e2) { numStdTracks = 0; }
+    if (args.trackIndex >= numStdTracks) {
+      return JSON.stringify({ ok: false, error: "trackIndex " + args.trackIndex + " is out of range — sequence has " + numStdTracks + " " + args.trackType + " track(s)" });
+    }
+    var stdTrack = stdTrackCollection[args.trackIndex];
+    var clipCountBefore = null;
+    try { clipCountBefore = stdTrack.clips.numItems; } catch (e3) { clipCountBefore = null; }
+
+    try {
+      ensureQEEnabled();
+      activateSequenceForQE(seq);
+    } catch (e4) {
+      return JSON.stringify({ ok: false, error: "app.enableQE()/sequence activation failed: " + e4.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 (e5) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() failed: " + e5.toString() });
+    }
+    if (!qeSeq) {
+      return JSON.stringify({ ok: false, error: "qe.project.getActiveSequence() returned nothing after activating the sequence" });
+    }
+
+    var qeTrack;
+    try {
+      qeTrack = args.trackType === "video" ? qeSeq.getVideoTrackAt(args.trackIndex) : qeSeq.getAudioTrackAt(args.trackIndex);
+    } catch (e6) {
+      return JSON.stringify({ ok: false, error: "QE track lookup failed: " + e6.toString() });
+    }
+    if (!qeTrack) {
+      return JSON.stringify({ ok: false, error: "QE track not found at index " + args.trackIndex });
+    }
+
+    var ticksString = secondsToTicksString(args.seconds);
+    try {
+      var fps2 = getSequenceFps(seq);
+      var qeTimecode2 = ppbSplitClip_secondsToQeTimecode(args.seconds, fps2);
+      try {
+        qeTrack.razor(qeTimecode2);
+      } catch (eTc) {
+        qeTrack.razor(ticksString);
+      }
+    } catch (e7) {
+      return JSON.stringify({ ok: false, error: "qeTrack.razor() failed: " + e7.toString() });
+    }
+
+    var clipCountAfter = null;
+    try { clipCountAfter = stdTrack.clips.numItems; } catch (e8) { clipCountAfter = null; }
+
+    var verified = clipCountBefore !== null && clipCountAfter !== null && clipCountAfter === clipCountBefore + 1;
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        seconds: args.seconds,
+        clipCountBefore: clipCountBefore,
+        clipCountAfter: clipCountAfter,
+        verified: verified
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

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

@@ -0,0 +1,139 @@
+// Command: stabilize-clip → ppb_stabilizeClip
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ensureQEEnabled, activateSequenceForQE, resolveTimelineClip,
+// resolveQeClip, serializeClipComponents, findQeVideoEffectByName,
+// findClipComponent, setComponentProperty, ...) are already defined there.
+//
+// Applies Warp Stabilizer via the standard QE dance (getVideoEffectByName +
+// addVideoEffect), verified by clip.components.numItems increasing by 1,
+// then optionally sets "Smoothness" (number) and/or "Method" (string enum —
+// "Subspace Warp"/"Position"/"Position, Scale, Rotation" per the reference
+// tool) via the shared setComponentProperty helper. Warp Stabilizer analysis
+// itself runs asynchronously inside Premiere after being applied — this
+// command does not wait for or report analysis completion.
+function ppb_stabilizeClip(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") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\" — Warp Stabilizer is a video effect" });
+    }
+    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 (args.smoothness !== undefined && typeof args.smoothness !== "number") {
+      return JSON.stringify({ ok: false, error: "smoothness must be a number if given" });
+    }
+    if (args.method !== undefined && typeof args.method !== "string") {
+      return JSON.stringify({ ok: false, error: "method must be a string if given" });
+    }
+
+    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 resolvedClip = resolveTimelineClip(seq, "video", args.trackIndex, args.clipIndex);
+    if (resolvedClip.error) {
+      return JSON.stringify({ ok: false, error: resolvedClip.error });
+    }
+    var clip = resolvedClip.clip;
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var previousComponents = serializeClipComponents(clip);
+
+    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, "video", args.trackIndex, args.clipIndex);
+    if (qeResolved.error) {
+      return JSON.stringify({ ok: false, error: qeResolved.error });
+    }
+
+    var fx = findQeVideoEffectByName("Warp Stabilizer");
+    if (!fx) {
+      return JSON.stringify({ ok: false, error: "Warp Stabilizer effect not found in this Premiere install's QE effect catalog" });
+    }
+
+    try {
+      qeResolved.qeClip.addVideoEffect(fx);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qeClip.addVideoEffect(Warp Stabilizer) failed: " + e.toString() });
+    }
+
+    var newComponents = serializeClipComponents(clip);
+    var componentVerified = newComponents.length === previousComponents.length + 1;
+
+    var changes = {};
+    if (componentVerified) {
+      var warpComp = findClipComponent(clip, null, ["Warp Stabilizer"]);
+      if (warpComp) {
+        if (typeof args.smoothness === "number") {
+          var smoothResult = setComponentProperty(warpComp, ["Smoothness"], args.smoothness);
+          changes.smoothness = smoothResult.found ? smoothResult : { found: false };
+        }
+        if (typeof args.method === "string") {
+          var methodResult = setComponentProperty(warpComp, ["Method"], args.method);
+          changes.method = methodResult.found ? methodResult : { found: false };
+        }
+      } else if (typeof args.smoothness === "number" || typeof args.method === "string") {
+        changes.error = "Warp Stabilizer was applied but could not be re-found on the standard-DOM clip to set properties";
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: "video",
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        verified: componentVerified,
+        changes: changes,
+        previousComponentCount: previousComponents.length,
+        newComponentCount: newComponents.length,
+        previousComponents: previousComponents,
+        newComponents: newComponents
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/stop-playback.jsx

@@ -0,0 +1,23 @@
+// Command: stop-playback → ppb_stopPlayback
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled, ...)
+// are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's playback.ts stop_playback.
+// QE DOM only (qe.stopPlayback()) — inherently active-sequence-only, same
+// as play-timeline: no sequenceName override.
+function ppb_stopPlayback(argsJson) {
+  try {
+    ensureQEEnabled();
+
+    try {
+      qe.stopPlayback();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not stop playback: " + e.toString() });
+    }
+
+    return JSON.stringify({ ok: true, result: { stopped: true } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}