premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/batch-set-clips-enabled.jsx

@@ -0,0 +1,145 @@
+// Command: batch-set-clips-enabled → ppb_batchSetClipsEnabled
+// 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 mutation. Ported from leancoderkavy's premiere-pro-mcp
+// `batch_enable_disable` tool (track-targeting.ts), which supports
+// target: "selected"|"track"|"all" — collapsed here to two filters
+// (`nameContains`, `trackType`) since this bridge otherwise always exposes
+// filters rather than a target enum (matching batch-rename-clips'
+// convention); omit both to affect every clip in the sequence, matching
+// the reference's "all" target. There is no `target: "selected"`
+// equivalent — use select-clips-by-name / set-clip-selection first, then
+// filter batch-set-clips-enabled by the same `nameContains` if that
+// combination is needed. Same `clip.disabled`/`setDisabled()` dual-probe
+// as set-clip-enabled, capped at 200 clips per call, with a per-track
+// read-back verification summary rather than trusting the mutation calls.
+var BATCH_SET_CLIPS_ENABLED_MAX = 200;
+
+function ppb_batchSetClipsEnabledOnTrack(track, trackType, trackIndex, nameContainsLower, enabled, budget, results) {
+  var affected = 0;
+  var verifiedCount = 0;
+  var numClips = track.clips.numItems;
+  var requestedDisabled = !enabled;
+
+  for (var c = 0; c < numClips; c++) {
+    if (budget.remaining <= 0) {
+      budget.cappedAtLimit = true;
+      break;
+    }
+
+    var clip = track.clips[c];
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    if (nameContainsLower !== null) {
+      var haystack = clipName === null ? "" : String(clipName).toLowerCase();
+      if (haystack.indexOf(nameContainsLower) === -1) {
+        continue;
+      }
+    }
+
+    var entry = { trackType: trackType, trackIndex: trackIndex, clipIndex: c, clipName: clipName, verified: false };
+
+    try {
+      clip.disabled = requestedDisabled;
+    } catch (e1) {
+      try {
+        clip.setDisabled(requestedDisabled);
+      } catch (e2) {
+        entry.error = e1.toString() + " / " + e2.toString();
+      }
+    }
+
+    var newDisabled = null;
+    try { newDisabled = clip.disabled; } catch (e) { newDisabled = null; }
+    entry.verified = newDisabled === requestedDisabled;
+
+    if (entry.verified) {
+      verifiedCount++;
+    }
+    affected++;
+    budget.remaining--;
+    results.push(entry);
+  }
+
+  return { affected: affected, verifiedCount: verifiedCount };
+}
+
+function ppb_batchSetClipsEnabled(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.enabled !== "boolean") {
+      return JSON.stringify({ ok: false, error: "enabled must be a boolean" });
+    }
+    var trackTypeFilter = args.trackType || "both";
+    if (trackTypeFilter !== "video" && trackTypeFilter !== "audio" && trackTypeFilter !== "both") {
+      return JSON.stringify({ ok: false, error: "trackType must be \"video\", \"audio\", or \"both\"" });
+    }
+    var nameContainsLower = null;
+    if (typeof args.nameContains === "string" && args.nameContains.length > 0) {
+      nameContainsLower = args.nameContains.toLowerCase();
+    }
+
+    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 results = [];
+    var budget = { remaining: BATCH_SET_CLIPS_ENABLED_MAX, cappedAtLimit: false };
+    var totalAffected = 0;
+    var totalVerified = 0;
+
+    if (trackTypeFilter === "video" || trackTypeFilter === "both") {
+      for (var vt = 0; vt < seq.videoTracks.numTracks; vt++) {
+        var vRes = ppb_batchSetClipsEnabledOnTrack(seq.videoTracks[vt], "video", vt, nameContainsLower, args.enabled, budget, results);
+        totalAffected += vRes.affected;
+        totalVerified += vRes.verifiedCount;
+        if (budget.cappedAtLimit) { break; }
+      }
+    }
+    if (!budget.cappedAtLimit && (trackTypeFilter === "audio" || trackTypeFilter === "both")) {
+      for (var at = 0; at < seq.audioTracks.numTracks; at++) {
+        var aRes = ppb_batchSetClipsEnabledOnTrack(seq.audioTracks[at], "audio", at, nameContainsLower, args.enabled, budget, results);
+        totalAffected += aRes.affected;
+        totalVerified += aRes.verifiedCount;
+        if (budget.cappedAtLimit) { break; }
+      }
+    }
+
+    var result = {
+      sequenceName: seq.name,
+      trackType: trackTypeFilter,
+      nameContains: args.nameContains || null,
+      requestedEnabled: args.enabled,
+      affected: totalAffected,
+      verifiedCount: totalVerified,
+      cappedAtLimit: budget.cappedAtLimit,
+      results: results
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/clear-item-in-out.jsx

@@ -0,0 +1,117 @@
+// Command: clear-item-in-out → ppb_clearItemInOut
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's track-targeting.ts
+// clear_item_in_out — clears in and/or out points on a PROJECT item via
+// item.clearInPoint()/clearOutPoint(), resetting it to its full source
+// duration. Both default to true (clear both) unless explicitly set false.
+//
+// Project-item addressing/lookup duplicated per command file, same
+// convention as get-item-metadata.jsx / set-item-in-out.jsx.
+
+function ppbFindItemClearItemInOut_walk(item, args, depth) {
+  if (depth > 32) {
+    return null;
+  }
+  var isBin = false;
+  try {
+    isBin = typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    isBin = false;
+  }
+  var matched = false;
+  if (args.nodeId !== null) {
+    try { matched = item.nodeId === args.nodeId; } catch (e) { matched = false; }
+  } else if (args.name !== null) {
+    try { matched = item.name === args.name; } catch (e) { matched = false; }
+  }
+  if (matched) {
+    return item;
+  }
+  if (isBin && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbFindItemClearItemInOut_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemClearItemInOut_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemClearItemInOut_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppb_clearItemInOut(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    var hasNodeId = typeof args.nodeId === "string" && args.nodeId.length > 0;
+    var hasName = typeof args.name === "string" && args.name.length > 0;
+    if (!hasNodeId && !hasName) {
+      return JSON.stringify({ ok: false, error: "either nodeId or name is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var item = ppbFindItemClearItemInOut_resolve({
+      nodeId: hasNodeId ? args.nodeId : null,
+      name: hasNodeId ? null : args.name
+    });
+    if (!item) {
+      return JSON.stringify({ ok: false, error: "no project item found matching the given nodeId/name" });
+    }
+
+    var clearIn = args.clearIn !== false;
+    var clearOut = args.clearOut !== false;
+
+    var inClearError = null;
+    var outClearError = null;
+
+    if (clearIn) {
+      try {
+        item.clearInPoint();
+      } catch (e) {
+        inClearError = e.toString();
+      }
+    }
+    if (clearOut) {
+      try {
+        item.clearOutPoint();
+      } catch (e) {
+        outClearError = e.toString();
+      }
+    }
+
+    return JSON.stringify({
+      ok: (clearIn ? inClearError === null : true) && (clearOut ? outClearError === null : true),
+      result: {
+        name: item.name,
+        nodeId: item.nodeId,
+        clearedIn: clearIn && inClearError === null,
+        clearedOut: clearOut && outClearError === null,
+        inClearError: inClearError,
+        outClearError: outClearError,
+        note: "no getInPoint/getOutPoint-style getter is confirmed available on this build (see set-item-in-out.jsx) — this only confirms the clear call(s) did not throw"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/clear-sequence-in-out.jsx

@@ -0,0 +1,100 @@
+// Command: clear-sequence-in-out → ppb_clearSequenceInOut
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// trySetSequenceRange, timeValueToSeconds, ...) are already defined there.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's track-targeting.ts
+// clear_sequence_in_out. The reference implementation sets in=zeroPoint,
+// out=seq.end — but per get-sequence-in-out.jsx's live finding, an actually
+// UNSET in/out point reads back as Premiere's internal -400000 sentinel,
+// not a real in/out range spanning the whole sequence. This command sets
+// that literal -400000 sentinel value via the shared trySetSequenceRange()
+// helper (its first attempt is the raw "seconds" form — i.e.
+// seq.setInPoint(-400000) — which is exactly the value get-sequence-in-out
+// reads back for "no point set", live-confirmed working on this build) so
+// a subsequent get-sequence-in-out reports {inSeconds: null, outSeconds: null}.
+var CLEAR_SEQUENCE_IN_OUT_SENTINEL = -400000;
+
+// Duplicated from get-sequence-in-out.jsx's ppb_pointValueToSeconds (each
+// command file loads independently and cannot rely on another command
+// file's helpers) — treats Premiere's -400000-ish sentinel as "unset".
+function ppbSentinelPointToSeconds(value) {
+  if (value === null || typeof value === "undefined") {
+    return null;
+  }
+  if (typeof value === "object") {
+    return timeValueToSeconds(value);
+  }
+  var seconds = Number(value);
+  if (isNaN(seconds)) {
+    return null;
+  }
+  if (seconds <= -399999) {
+    return null;
+  }
+  return seconds;
+}
+
+function ppb_clearSequenceInOut(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 previousIn = null;
+    var previousOut = null;
+    try { previousIn = ppbSentinelPointToSeconds(seq.getInPoint()); } catch (e) { previousIn = null; }
+    try { previousOut = ppbSentinelPointToSeconds(seq.getOutPoint()); } catch (e) { previousOut = null; }
+
+    var rangeResult = trySetSequenceRange(seq, CLEAR_SEQUENCE_IN_OUT_SENTINEL, CLEAR_SEQUENCE_IN_OUT_SENTINEL);
+    if (!rangeResult.ok) {
+      return JSON.stringify({
+        ok: false,
+        error: "could not clear sequence in/out points with any known argument form",
+        attempts: rangeResult.attempts,
+        previousInSeconds: previousIn,
+        previousOutSeconds: previousOut
+      });
+    }
+
+    var newIn = null;
+    var newOut = null;
+    try { newIn = ppbSentinelPointToSeconds(seq.getInPoint()); } catch (e) { newIn = null; }
+    try { newOut = ppbSentinelPointToSeconds(seq.getOutPoint()); } catch (e) { newOut = null; }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        previousInSeconds: previousIn,
+        previousOutSeconds: previousOut,
+        inSeconds: newIn,
+        outSeconds: newOut,
+        verified: newIn === null && newOut === null,
+        attempts: rangeResult.attempts
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/close-all-source-clips.jsx

@@ -0,0 +1,32 @@
+// Command: close-all-source-clips → ppb_closeAllSourceClips
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use.
+//
+// Ported from leancoderkavy's premiere-pro-mcp source-monitor.ts
+// close_all_source_clips. Closes every clip currently open across the
+// Source Monitor's tabs via app.sourceMonitor.closeAllClips().
+//
+// MUTATION RULE: verified the same way as close-source-monitor — a null
+// getProjectItem() read-back afterward confirms nothing is left loaded.
+function ppb_closeAllSourceClips() {
+  try {
+    try {
+      app.sourceMonitor.closeAllClips();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.sourceMonitor.closeAllClips() failed: " + e.toString() });
+    }
+
+    var stillLoaded = null;
+    try {
+      stillLoaded = app.sourceMonitor.getProjectItem();
+    } catch (e2) {
+      stillLoaded = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: { closed: true, verified: !stillLoaded }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

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

@@ -0,0 +1,80 @@
+// Command: close-sequence → ppb_closeSequence
+// 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 advanced.ts close_sequence
+// tool: `seq.close()` per PREMIERE_API_NOTES.md's Sequences table.
+//
+// UI-TAB SEMANTICS PROBE: seq.close() is expected to close the sequence's
+// TAB in the Timeline panel, not delete the sequence from the project —
+// there is a separate app.project.deleteSequence(seq) for that. This
+// command probes exactly that distinction rather than assuming it: after
+// calling close(), it re-scans app.project.sequences (a collection
+// distinct from open timeline tabs) for the closed sequence's own
+// sequenceID and reports stillInProjectSequences accordingly.
+function ppb_closeSequence(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;
+    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 closedName = seq.name;
+    var closedSequenceID = null;
+    try { closedSequenceID = seq.sequenceID; } catch (e) { closedSequenceID = null; }
+
+    var numSequencesBefore = app.project.sequences.numSequences;
+
+    try {
+      seq.close();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "seq.close() failed: " + e.toString() });
+    }
+
+    var numSequencesAfter = app.project.sequences.numSequences;
+    var stillInProjectSequences = false;
+    for (var i = 0; i < app.project.sequences.numSequences; i++) {
+      var candidateId = null;
+      try { candidateId = app.project.sequences[i].sequenceID; } catch (e2) { candidateId = null; }
+      if (candidateId !== null && candidateId === closedSequenceID) {
+        stillInProjectSequences = true;
+        break;
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: closedName,
+        sequenceID: closedSequenceID,
+        closed: true,
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter,
+        stillInProjectSequences: stillInProjectSequences,
+        note: "seq.close() closes the sequence's UI TAB in the Timeline panel — this is NOT the same as deleting the sequence from the project (that is app.project.deleteSequence(seq), not exposed by this command). stillInProjectSequences reports whether app.project.sequences — a collection distinct from open timeline tabs — still lists the closed sequence afterward, the only available probe of this UI-tab-vs-project-item distinction."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/close-source-monitor.jsx

@@ -0,0 +1,32 @@
+// Command: close-source-monitor → ppb_closeSourceMonitor
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use.
+//
+// Ported from leancoderkavy's premiere-pro-mcp source-monitor.ts
+// close_source_monitor. Closes whichever single clip is open in the
+// Source Monitor via app.sourceMonitor.closeClip().
+//
+// MUTATION RULE: verified by reading app.sourceMonitor.getProjectItem()
+// back afterward — a null result confirms the monitor is now empty.
+function ppb_closeSourceMonitor() {
+  try {
+    try {
+      app.sourceMonitor.closeClip();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "app.sourceMonitor.closeClip() failed: " + e.toString() });
+    }
+
+    var stillLoaded = null;
+    try {
+      stillLoaded = app.sourceMonitor.getProjectItem();
+    } catch (e2) {
+      stillLoaded = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: { closed: true, verified: !stillLoaded }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/color-correct.jsx

@@ -0,0 +1,164 @@
+// Command: color-correct → ppb_colorCorrect
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// resolveTimelineClip, serializeClipComponents,
+// ensureLumetriColorComponent, valuesApproximatelyEqual, ...) are already
+// defined there.
+//
+// Ensures Lumetri Color is applied (via ensureLumetriColorComponent, adding
+// it through the standard QE dance if missing), then sets any of
+// exposure/contrast/saturation/temperature/tint by displayName. Per
+// PREMIERE_API_NOTES.md, Lumetri repeats display names across its
+// sub-sections (Basic Correction, Creative, HSL Secondary, ...) and not
+// every match is writable — for each requested control, every matching
+// property is tried in order until one setValue() doesn't throw ("first
+// writable match wins"); previous/new values are read from that exact
+// property index, not re-scanned from the top (which could otherwise grab
+// an unrelated same-named property). 0 is a legitimate value for every one
+// of these controls (e.g. full desaturate) — never falsy-checked.
+function ppb_colorCorrect(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\" — Lumetri Color 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" });
+    }
+
+    var CONTROLS = [
+      { key: "exposure", label: "Exposure" },
+      { key: "contrast", label: "Contrast" },
+      { key: "saturation", label: "Saturation" },
+      { key: "temperature", label: "Temperature" },
+      { key: "tint", label: "Tint" }
+    ];
+    var requested = [];
+    for (var c = 0; c < CONTROLS.length; c++) {
+      if (typeof args[CONTROLS[c].key] === "number") {
+        requested.push(CONTROLS[c]);
+      }
+    }
+    if (requested.length === 0) {
+      return JSON.stringify({ ok: false, error: "at least one of exposure, contrast, saturation, temperature, tint 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 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);
+
+    var lumetri = ensureLumetriColorComponent(seq, "video", args.trackIndex, args.clipIndex, clip);
+    if (lumetri.error) {
+      return JSON.stringify({ ok: false, error: lumetri.error });
+    }
+    var lumetriComp = lumetri.component;
+
+    var changes = {};
+    var numProps;
+    try {
+      numProps = lumetriComp.properties.numItems;
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "could not read Lumetri Color's properties: " + e.toString() });
+    }
+
+    for (var r = 0; r < requested.length; r++) {
+      var key = requested[r].key;
+      var label = requested[r].label;
+      var value = args[key];
+
+      var previousValue = null;
+      var havePrevious = false;
+      var applied = false;
+      var appliedIndex = -1;
+      var errorMsg = null;
+
+      for (var p = 0; p < numProps; p++) {
+        var prop = lumetriComp.properties[p];
+        var dn = null;
+        try { dn = prop.displayName; } catch (e2) { dn = null; }
+        if (dn !== label) {
+          continue;
+        }
+        if (!havePrevious) {
+          try { previousValue = prop.getValue(); } catch (e3) { previousValue = null; }
+          havePrevious = true;
+        }
+        if (!applied) {
+          try {
+            prop.setValue(value, true);
+            applied = true;
+            appliedIndex = p;
+          } catch (e4) {
+            errorMsg = e4.toString();
+          }
+        }
+      }
+
+      var newValue = null;
+      if (applied) {
+        try { newValue = lumetriComp.properties[appliedIndex].getValue(); } catch (e5) { newValue = null; }
+      }
+
+      changes[key] = {
+        displayName: label,
+        previousValue: previousValue,
+        requestedValue: value,
+        newValue: newValue,
+        applied: applied,
+        verified: applied && valuesApproximatelyEqual(newValue, value),
+        error: applied ? null : (errorMsg || "no writable property named \"" + label + "\" found on Lumetri Color")
+      };
+    }
+
+    var newComponents = serializeClipComponents(clip);
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: "video",
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        lumetriApplied: lumetri.applied,
+        changes: changes,
+        previousComponents: previousComponents,
+        newComponents: newComponents
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}