premiere-cli 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,111 @@
+// Command: trim-clip → ppb_trimClip
+// 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.
+//
+// Trims a clip's in and/or out point — SOURCE-MEDIA-RELATIVE seconds, per
+// leancoderkavy's premiere-pro-mcp trim_clip tool and
+// PREMIERE_API_NOTES.md ("assign clip.inPoint/outPoint (Time or ticks
+// string)"). At least one of inPointSeconds/outPointSeconds is required.
+//
+// MUTATION RULE: each requested field is verified via its own read-back
+// after assignment, compared against the request with a tolerance
+// (frame-quantization is expected). A failure on one field does not
+// block attempting the other.
+
+function ppb_trimClip(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" });
+    }
+    var hasIn = typeof args.inPointSeconds === "number";
+    var hasOut = typeof args.outPointSeconds === "number";
+    if (!hasIn && !hasOut) {
+      return JSON.stringify({ ok: false, error: "at least one of inPointSeconds/outPointSeconds 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 changes = {};
+
+    if (hasIn) {
+      var inAttempt = tryTimeForms(args.inPointSeconds, function (timeArg) {
+        clip.inPoint = timeArg;
+      });
+      var inNewValue = null;
+      try { inNewValue = timeValueToSeconds(clip.inPoint); } catch (e2) { inNewValue = null; }
+      changes.inPoint = {
+        requestedValue: args.inPointSeconds,
+        previousValue: before.inPointSeconds,
+        newValue: inNewValue,
+        verified: inAttempt.success && inNewValue !== null && Math.abs(inNewValue - args.inPointSeconds) <= 0.05,
+        attempts: inAttempt.attempts
+      };
+    }
+
+    if (hasOut) {
+      var outAttempt = tryTimeForms(args.outPointSeconds, function (timeArg) {
+        clip.outPoint = timeArg;
+      });
+      var outNewValue = null;
+      try { outNewValue = timeValueToSeconds(clip.outPoint); } catch (e3) { outNewValue = null; }
+      changes.outPoint = {
+        requestedValue: args.outPointSeconds,
+        previousValue: before.outPointSeconds,
+        newValue: outNewValue,
+        verified: outAttempt.success && outNewValue !== null && Math.abs(outNewValue - args.outPointSeconds) <= 0.05,
+        attempts: outAttempt.attempts
+      };
+    }
+
+    var after = serializeTrackItem(clip, args.trackIndex, args.clipIndex);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        previousValue: before,
+        newValue: after,
+        changes: changes
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/undo.jsx

@@ -0,0 +1,114 @@
+// Command: undo → ppb_undo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled, ...)
+// are already defined there.
+//
+// REWRITTEN 2026-07-17 after the probe session (see BUILD_FINDINGS.md
+// corrections): qe.project.undo() WORKS on this build for operations
+// that enter the undo stack — the earlier "silent no-op" finding was an
+// artifact of testing with marker-add/track-rename, which NEVER enter
+// the stack. qe.project.undoStackIndex() (an int-returning function on
+// this build) is the verification primitive: a real undo decrements it.
+//
+// CAUTION for callers: if YOUR last operation didn't enter the undo
+// stack (markers, track renames, ...), undo() pops whatever IS on top —
+// possibly the user's own last edit. This command therefore refuses to
+// keep looping once the stack index stops moving, and reports the index
+// trajectory so the caller can tell exactly how many stack entries were
+// popped.
+
+function ppb_undo(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var count = typeof args.count === "number" ? args.count : 1;
+    if (isNaN(count) || Math.floor(count) !== count || count < 1) {
+      return JSON.stringify({ ok: false, error: "count must be a positive integer" });
+    }
+    var requestedCount = count;
+    if (count > 50) {
+      count = 50;
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    try {
+      ensureQEEnabled();
+    } catch (e2) {
+      return JSON.stringify({ ok: false, error: "app.enableQE() failed: " + e2.toString() });
+    }
+    if (typeof qe === "undefined" || !qe.project || typeof qe.project.undo !== "function") {
+      return JSON.stringify({ ok: false, error: "qe.project.undo is not available on this Premiere build" });
+    }
+
+    function readStackIndex() {
+      try {
+        if (typeof qe.project.undoStackIndex === "function") {
+          return qe.project.undoStackIndex();
+        }
+      } catch (e) {
+        // fall through
+      }
+      return null;
+    }
+
+    var indexBefore = readStackIndex();
+    var undoneCount = 0;
+    var stopError = null;
+    var stackExhausted = false;
+
+    for (var i = 0; i < count; i++) {
+      var idxPre = readStackIndex();
+      try {
+        qe.project.undo();
+      } catch (e3) {
+        stopError = e3.toString();
+        break;
+      }
+      var idxPost = readStackIndex();
+      if (idxPre !== null && idxPost !== null) {
+        if (idxPost < idxPre) {
+          undoneCount++;
+        } else {
+          // the call no-opped — the stack is exhausted (or this op class
+          // isn't undoable); looping further would be pointless
+          stackExhausted = true;
+          break;
+        }
+      } else {
+        // no index available to verify against — count the non-throwing
+        // call, but flag the weaker evidence in the result note
+        undoneCount++;
+      }
+    }
+
+    var indexAfter = readStackIndex();
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        requestedCount: requestedCount,
+        cappedCount: count,
+        undoneCount: undoneCount,
+        stoppedEarly: undoneCount < count,
+        stackExhausted: stackExhausted,
+        stopError: stopError,
+        method: "qe.project.undo",
+        undoStackIndexBefore: indexBefore,
+        undoStackIndexAfter: indexAfter,
+        note: indexBefore !== null
+          ? "verified via qe.project.undoStackIndex() — each counted undo decremented the stack index. CAUTION: some operations (markers, track renames) never enter the undo stack; undoing after one of those pops the NEXT stack entry instead."
+          : "undoStackIndex() unavailable — undoneCount only reports non-throwing undo calls"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/unlink-selection.jsx

@@ -0,0 +1,106 @@
+// Command: unlink-selection → ppb_unlinkSelection
+// 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.
+//
+// Unlinks the currently-selected video and audio clips in a sequence.
+// Ported from leancoderkavy's premiere-pro-mcp `unlink_selection` tool
+// (advanced.ts: `seq.unlinkSelection()`) — the standard-DOM counterpart
+// of link-selection.jsx; see that file's header for the full context on
+// why this is standard DOM (not QE, which has no link/unlink at all) and
+// why there's no verified "is linked" state to check. Same before/after
+// selection reporting as link-selection.
+
+function ppbUnlinkSelection_collect(seq) {
+  var sel = null;
+  try {
+    sel = seq.getSelection();
+  } catch (e) {
+    sel = null;
+  }
+  var selCount = 0;
+  if (sel) {
+    if (typeof sel.numItems === "number") {
+      selCount = sel.numItems;
+    } else if (typeof sel.length === "number") {
+      selCount = sel.length;
+    }
+  }
+  var items = [];
+  var cap = selCount > 20 ? 20 : selCount;
+  for (var i = 0; i < cap; i++) {
+    var item = sel[i];
+    var entry = { name: null, mediaType: null, startSeconds: null, endSeconds: null, nodeId: null };
+    try { entry.name = item.name; } catch (e) { entry.name = null; }
+    try { entry.mediaType = item.mediaType; } catch (e) { entry.mediaType = null; }
+    try { entry.startSeconds = timeValueToSeconds(item.start); } catch (e) { entry.startSeconds = null; }
+    try { entry.endSeconds = timeValueToSeconds(item.end); } catch (e) { entry.endSeconds = null; }
+    try { entry.nodeId = item.nodeId; } catch (e) { entry.nodeId = null; }
+    items.push(entry);
+  }
+  var out = { selectedCount: selCount, selectedClips: items };
+  if (selCount > 20) {
+    out.truncated = true;
+  }
+  return out;
+}
+
+function ppb_unlinkSelection(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" });
+      }
+    }
+
+    if (typeof seq.unlinkSelection !== "function") {
+      return JSON.stringify({ ok: false, error: "seq.unlinkSelection is not available on this Premiere build" });
+    }
+
+    var before = ppbUnlinkSelection_collect(seq);
+    if (before.selectedCount === 0) {
+      return JSON.stringify({
+        ok: false,
+        error: "nothing is selected in sequence \"" + seq.name + "\" — select the linked clip(s) to unlink first (e.g. via set-clip-selection)"
+      });
+    }
+
+    try {
+      seq.unlinkSelection();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "seq.unlinkSelection() failed: " + e.toString() });
+    }
+
+    var after = ppbUnlinkSelection_collect(seq);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        before: before,
+        after: after,
+        note: "there is no confirmed 'is linked' read-back API (PREMIERE_API_NOTES.md) — before/after selection is reported as the only available signal; the call not throwing is the closest thing to success confirmation here."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/unnest-sequence.jsx

@@ -0,0 +1,207 @@
+// Command: unnest-sequence → ppb_unnestSequence
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's sequence.ts
+// unnest_sequence — a real (non-stub) implementation, so this is a full
+// port rather than a skip. Replaces a nested-sequence clip on the
+// timeline with copies of the nested sequence's own clips, addressed by
+// the outer clip's nodeId (not trackType/trackIndex/clipIndex, since the
+// nested clip could be on either track type and the reference itself
+// only ever addresses it by nodeId).
+//
+// Algorithm (matches the reference): find the timeline clip by nodeId,
+// confirm its projectItem resolves to another open sequence (nodeId/name
+// matched against app.project.sequences — the "is this a nested sequence
+// clip" test), remove the nested-sequence clip, then re-insert each of
+// the nested sequence's own clips at an offset position (outer clip's own
+// start + the nested clip's own start) on the corresponding track.
+//
+// Semi-destructive/structural: removes the nested-sequence clip outright
+// before re-inserting its contents — if insertion partway fails, the
+// timeline is left in a partially-unnested state (documented in the
+// result, not silently swallowed). Undo is non-functional on this build.
+//
+// Verification: reports the outer clip removal AND, per re-inserted
+// clip, whether seq.insertClip() was reached without throwing — plus a
+// final total-clip-count comparison across the whole sequence (never
+// trusting insertClip()'s own return value).
+function ppb_findTimelineClipByNodeId(seq, nodeId) {
+  function scan(tracks, trackType) {
+    for (var t = 0; t < tracks.numTracks; t++) {
+      for (var c = 0; c < tracks[t].clips.numItems; c++) {
+        var clip = tracks[t].clips[c];
+        var id = null;
+        try { id = clip.nodeId; } catch (e) { id = null; }
+        if (id === nodeId) {
+          return { clip: clip, trackType: trackType, trackIndex: t, clipIndex: c };
+        }
+      }
+    }
+    return null;
+  }
+  return scan(seq.videoTracks, "video") || scan(seq.audioTracks, "audio");
+}
+
+function ppb_countAllClipsUnnestSequence(seq) {
+  var total = 0;
+  try {
+    for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+      total += seq.videoTracks[v].clips.numItems;
+    }
+  } catch (e) {
+    // best-effort
+  }
+  try {
+    for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+      total += seq.audioTracks[a].clips.numItems;
+    }
+  } catch (e) {
+    // best-effort
+  }
+  return total;
+}
+
+function ppb_unnestSequence(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.nodeId || typeof args.nodeId !== "string") {
+      return JSON.stringify({ ok: false, error: "nodeId is required (node ID of the nested-sequence clip on the timeline)" });
+    }
+
+    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 found = ppb_findTimelineClipByNodeId(seq, args.nodeId);
+    if (!found) {
+      return JSON.stringify({ ok: false, error: "no clip with nodeId \"" + args.nodeId + "\" found on sequence \"" + seq.name + "\"" });
+    }
+    var clip = found.clip;
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var projectItem = null;
+    try { projectItem = clip.projectItem; } catch (e) { projectItem = null; }
+    if (!projectItem) {
+      return JSON.stringify({ ok: false, error: "clip \"" + clipName + "\" has no projectItem — cannot resolve it to a nested sequence" });
+    }
+
+    var nestedSeq = null;
+    for (var i = 0; i < app.project.sequences.numSequences; i++) {
+      var s = app.project.sequences[i];
+      var sName = null;
+      try { sName = s.name; } catch (e) { sName = null; }
+      var sId = null;
+      try { sId = s.sequenceID; } catch (e) { sId = null; }
+      var itName = null;
+      try { itName = projectItem.name; } catch (e) { itName = null; }
+      var itNodeId = null;
+      try { itNodeId = projectItem.nodeId; } catch (e) { itNodeId = null; }
+      if (sName === itName || sId === itNodeId) {
+        nestedSeq = s;
+        break;
+      }
+    }
+    if (!nestedSeq) {
+      return JSON.stringify({ ok: false, error: "clip \"" + clipName + "\" is not a nested sequence (its projectItem doesn't match any open sequence)" });
+    }
+
+    var startTicks = null;
+    try { startTicks = clip.start.ticks; } catch (e) { startTicks = null; }
+    if (startTicks === null) {
+      return JSON.stringify({ ok: false, error: "could not read the nested clip's own start time" });
+    }
+    var trackIndex = found.trackIndex;
+    var trackType = found.trackType;
+
+    var countBefore = ppb_countAllClipsUnnestSequence(seq);
+
+    var removeError = null;
+    try {
+      clip.remove(false, false);
+    } catch (e) {
+      removeError = e.toString();
+    }
+    if (removeError !== null) {
+      return JSON.stringify({ ok: false, error: "failed to remove the nested-sequence clip: " + removeError });
+    }
+
+    var addedClips = [];
+    var insertErrors = [];
+    var tracks = trackType === "video" ? nestedSeq.videoTracks : nestedSeq.audioTracks;
+    for (var t = 0; t < tracks.numTracks; t++) {
+      var track = tracks[t];
+      for (var c = 0; c < track.clips.numItems; c++) {
+        var nestedClip = track.clips[c];
+        var nestedProjectItem = null;
+        try { nestedProjectItem = nestedClip.projectItem; } catch (e) { nestedProjectItem = null; }
+        if (!nestedProjectItem) {
+          continue;
+        }
+        var nestedName = null;
+        try { nestedName = nestedClip.name; } catch (e) { nestedName = null; }
+
+        var insertTime = null;
+        try {
+          insertTime = (parseFloat(startTicks) + parseFloat(nestedClip.start.ticks)).toString();
+        } catch (e) {
+          insertErrors.push({ clip: nestedName, error: "could not compute insert time: " + e.toString() });
+          continue;
+        }
+        var targetTrack = trackIndex + t;
+
+        try {
+          if (trackType === "video") {
+            seq.insertClip(nestedProjectItem, insertTime, targetTrack, targetTrack);
+          } else {
+            seq.insertClip(nestedProjectItem, insertTime, 0, targetTrack);
+          }
+          addedClips.push(nestedName);
+        } catch (e2) {
+          insertErrors.push({ clip: nestedName, error: e2.toString() });
+        }
+      }
+    }
+
+    var countAfter = ppb_countAllClipsUnnestSequence(seq);
+
+    return JSON.stringify({
+      ok: insertErrors.length === 0,
+      result: {
+        sequenceName: seq.name,
+        unnestedClipName: clipName,
+        nestedSequenceName: nestedSeq.name,
+        trackType: trackType,
+        trackIndex: trackIndex,
+        addedClips: addedClips,
+        addedCount: addedClips.length,
+        insertErrors: insertErrors,
+        countBefore: countBefore,
+        countAfter: countAfter
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/update-marker.jsx

@@ -0,0 +1,120 @@
+// Command: update-marker → ppb_updateMarker
+// 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.
+//
+// Ported from leancoderkavy's premiere-pro-mcp update_marker tool, but
+// re-addressed: the reference identifies the target marker by matching
+// its start time within a tolerance window; this panel instead identifies
+// it by .guid (the same stable identity list-markers/get-clip-markers
+// already expose), which is unambiguous and avoids float-time matching
+// entirely. Only name/comments/type/colorIndex/endSeconds/durationSeconds
+// are mutable here — marker.start itself is not attempted (no confirmed
+// write API for it; see PREMIERE_API_NOTES.md's markers section).
+//
+// MUTATION RULE: after applying changes, the marker is re-found by the
+// same guid via a fresh getFirstMarker()/getNextMarker() walk and
+// re-serialized from that live object — never returned from the
+// reference held before mutating.
+
+function ppbUpdateMarker_serializeOne(m) {
+  var entry = { name: null, comments: null, type: null, 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.type = m.type; } catch (e) { entry.type = 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; }
+  return entry;
+}
+
+function ppbUpdateMarker_findByGuid(seq, guid) {
+  var m = seq.markers.getFirstMarker();
+  var iterations = 0;
+  while (m !== null && typeof m !== "undefined" && iterations < 10000) {
+    var thisGuid = null;
+    try { thisGuid = m.guid; } catch (e) { thisGuid = null; }
+    if (thisGuid === guid) {
+      return m;
+    }
+    m = seq.markers.getNextMarker(m);
+    iterations++;
+  }
+  return null;
+}
+
+function ppb_updateMarker(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.guid !== "string" || args.guid.length === 0) {
+      return JSON.stringify({ ok: false, error: "guid 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 marker = ppbUpdateMarker_findByGuid(seq, args.guid);
+    if (!marker) {
+      return JSON.stringify({ ok: false, error: "no marker found with guid \"" + args.guid + "\" on this sequence" });
+    }
+
+    var applied = {};
+    if (typeof args.name === "string") {
+      try { marker.name = args.name; applied.name = true; } catch (e) { applied.name = false; }
+    }
+    if (typeof args.comments === "string") {
+      try { marker.comments = args.comments; applied.comments = true; } catch (e) { applied.comments = false; }
+    }
+    if (typeof args.type === "string") {
+      try { marker.type = args.type; applied.type = true; } catch (e) { applied.type = false; }
+    }
+    if (typeof args.colorIndex === "number") {
+      try { marker.setColorByIndex(args.colorIndex); applied.colorIndex = true; } catch (e) { applied.colorIndex = false; }
+    }
+    if (typeof args.durationSeconds === "number") {
+      try {
+        var startSeconds = timeValueToSeconds(marker.start);
+        marker.end = startSeconds + args.durationSeconds;
+        applied.durationSeconds = true;
+      } catch (e) { applied.durationSeconds = false; }
+    } else if (typeof args.endSeconds === "number") {
+      try { marker.end = args.endSeconds; applied.endSeconds = true; } catch (e) { applied.endSeconds = false; }
+    }
+
+    var reFound = ppbUpdateMarker_findByGuid(seq, args.guid);
+    if (!reFound) {
+      return JSON.stringify({ ok: false, error: "marker vanished after update (re-find by guid failed)", applied: applied });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        applied: applied,
+        marker: ppbUpdateMarker_serializeOne(reFound)
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}