premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/get-full-project-overview.jsx

@@ -0,0 +1,193 @@
+// Command: get-full-project-overview → ppb_getFullProjectOverview
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// ensureQEEnabled, findSequenceByName, ...) are already defined there.
+//
+// Builds a nested bin tree of the whole project plus a mediaTypeCounts
+// classification of every non-bin item by its mediaPath extension. Helper
+// names are prefixed ppbFullOverview_ to avoid colliding with same-purpose
+// helpers in other lazily-loaded command files evaluated into this same
+// global context.
+
+var PPB_FULL_OVERVIEW_VIDEO_EXTENSIONS = ["mp4", "mov", "mxf", "avi", "m4v", "mts"];
+var PPB_FULL_OVERVIEW_AUDIO_EXTENSIONS = ["wav", "mp3", "aac", "m4a", "aiff"];
+var PPB_FULL_OVERVIEW_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "tif", "tiff", "psd", "svg", "gif"];
+
+function ppbFullOverview_extOf(mediaPath) {
+  if (!mediaPath || typeof mediaPath !== "string") {
+    return null;
+  }
+  var dot = mediaPath.lastIndexOf(".");
+  if (dot === -1 || dot === mediaPath.length - 1) {
+    return null;
+  }
+  return mediaPath.substring(dot + 1).toLowerCase();
+}
+
+function ppbFullOverview_inList(ext, list) {
+  if (ext === null) {
+    return false;
+  }
+  for (var i = 0; i < list.length; i++) {
+    if (list[i] === ext) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function ppbFullOverview_isBin(item) {
+  try {
+    return typeof ProjectItemType !== "undefined" && item.type === ProjectItemType.BIN;
+  } catch (e) {
+    return false;
+  }
+}
+
+function ppbFullOverview_typeToString(item) {
+  try {
+    if (typeof ProjectItemType !== "undefined") {
+      if (item.type === ProjectItemType.CLIP) {
+        return "CLIP";
+      }
+      if (item.type === ProjectItemType.FILE) {
+        return "FILE";
+      }
+      if (item.type === ProjectItemType.ROOT) {
+        return "ROOT";
+      }
+    }
+  } catch (e) {
+    // fall through to raw number below
+  }
+  return String(item.type);
+}
+
+// Classifies one non-bin item into counts. A sequence item always counts
+// as "sequence" regardless of any extension on its mediaPath. An offline
+// item ADDITIONALLY increments "offline", on top of its type bucket.
+function ppbFullOverview_classify(item, counts) {
+  var isSequence = false;
+  try {
+    isSequence = item.isSequence();
+  } catch (e) {
+    isSequence = false;
+  }
+
+  var isOffline = false;
+  try {
+    isOffline = item.isOffline();
+  } catch (e) {
+    isOffline = false;
+  }
+
+  var mediaPath = null;
+  try {
+    mediaPath = item.getMediaPath();
+  } catch (e) {
+    mediaPath = null;
+  }
+
+  if (isSequence) {
+    counts.sequence++;
+  } else {
+    var ext = ppbFullOverview_extOf(mediaPath);
+    if (ppbFullOverview_inList(ext, PPB_FULL_OVERVIEW_VIDEO_EXTENSIONS)) {
+      counts.video++;
+    } else if (ppbFullOverview_inList(ext, PPB_FULL_OVERVIEW_AUDIO_EXTENSIONS)) {
+      counts.audio++;
+    } else if (ppbFullOverview_inList(ext, PPB_FULL_OVERVIEW_IMAGE_EXTENSIONS)) {
+      counts.image++;
+    } else {
+      counts.other++;
+    }
+  }
+
+  if (isOffline) {
+    counts.offline++;
+  }
+}
+
+// Capped at depth 32 to defend against pathological/circular bin
+// structures rather than looping forever.
+function ppbFullOverview_buildBinTree(item, counts, depth) {
+  var node = { name: item.name, bins: [], items: [] };
+
+  if (depth > 32 || !item.children) {
+    return node;
+  }
+
+  for (var i = 0; i < item.children.numItems; i++) {
+    var child = item.children[i];
+
+    if (ppbFullOverview_isBin(child)) {
+      node.bins.push(ppbFullOverview_buildBinTree(child, counts, depth + 1));
+    } else {
+      var mediaPath = null;
+      try {
+        mediaPath = child.getMediaPath();
+      } catch (e) {
+        mediaPath = null;
+      }
+
+      node.items.push({
+        name: child.name,
+        type: ppbFullOverview_typeToString(child),
+        mediaPath: mediaPath
+      });
+      ppbFullOverview_classify(child, counts);
+    }
+  }
+
+  return node;
+}
+
+function ppb_getFullProjectOverview(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var proj = app.project;
+    var sequences = [];
+
+    for (var j = 0; j < proj.sequences.numSequences; j++) {
+      var seq = proj.sequences[j];
+      var frameRate = null;
+      var durationSeconds = null;
+
+      try {
+        frameRate = TICKS_PER_SECOND / Number(seq.timebase);
+      } catch (e) {
+        frameRate = null;
+      }
+
+      try {
+        durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+      } catch (e) {
+        durationSeconds = null;
+      }
+
+      sequences.push({
+        name: seq.name,
+        sequenceID: seq.sequenceID,
+        frameRate: frameRate,
+        durationSeconds: durationSeconds
+      });
+    }
+
+    var counts = { video: 0, audio: 0, image: 0, sequence: 0, other: 0, offline: 0 };
+    var binTree = ppbFullOverview_buildBinTree(proj.rootItem, counts, 1);
+
+    var result = {
+      project: { name: proj.name, path: proj.path },
+      binTree: binTree,
+      sequences: sequences,
+      mediaTypeCounts: counts
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-full-sequence-info.jsx

@@ -0,0 +1,184 @@
+// Command: get-full-sequence-info → ppb_getFullSequenceInfo
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// findSequenceByName, serializeTrackItem, ...) are already defined there.
+//
+// Standard-DOM read only (seq.videoTracks[i].clips[j]) — no QE DOM needed,
+// no need to activate the sequence tab. This is a self-contained command
+// file (each command file loads independently, so it cannot rely on
+// helpers defined only in another command file) — its own clip/track
+// serialization is defined locally, layering `components` on top of the
+// shared serializeTrackItem() fields.
+
+// Per PREMIERE_API_NOTES.md's component model: clip.components[0]=Motion,
+// [1]=Opacity, [2+]=applied effects.
+function ppb_serializeComponentsForFullSequenceInfo(clip) {
+  var components = [];
+  try {
+    for (var i = 0; i < clip.components.numItems; i++) {
+      var comp = clip.components[i];
+      var entry = { displayName: null, matchName: null, enabled: null, numProperties: null };
+      try { entry.displayName = comp.displayName; } catch (e) { entry.displayName = null; }
+      try { entry.matchName = comp.matchName; } catch (e) { entry.matchName = null; }
+      try { entry.enabled = comp.enabled; } catch (e) { entry.enabled = null; }
+      try { entry.numProperties = comp.properties.numItems; } catch (e) { entry.numProperties = null; }
+      components.push(entry);
+    }
+  } catch (e) {
+    // leave components as whatever was collected so far
+  }
+  return components;
+}
+
+function ppb_serializeClipForFullSequenceInfo(clip, trackIndex, clipIndex) {
+  var out = serializeTrackItem(clip, trackIndex, clipIndex);
+  out.components = ppb_serializeComponentsForFullSequenceInfo(clip);
+  return out;
+}
+
+function ppb_serializeTrackForFullSequenceInfo(track, trackIndex) {
+  var out = {
+    index: trackIndex,
+    name: null,
+    isMuted: null,
+    isLocked: null,
+    clipCount: null,
+    clips: []
+  };
+
+  try { out.name = track.name; } catch (e) { out.name = null; }
+  try { out.isMuted = track.isMuted(); } catch (e) { out.isMuted = null; }
+  try { out.isLocked = track.isLocked(); } catch (e) { out.isLocked = null; }
+
+  try {
+    out.clipCount = track.clips.numItems;
+    for (var c = 0; c < track.clips.numItems; c++) {
+      out.clips.push(ppb_serializeClipForFullSequenceInfo(track.clips[c], trackIndex, c));
+    }
+  } catch (e) {
+    // leave clipCount/clips as-is
+  }
+
+  return out;
+}
+
+// Markers have no reliable indexing (PREMIERE_API_NOTES.md) — iterate via
+// getFirstMarker()/getNextMarker(m), capped to guard against a pathological
+// linked-list (e.g. a cycle from a corrupt project).
+function ppb_serializeSequenceMarkers(seq) {
+  var markers = [];
+  try {
+    var m = seq.markers.getFirstMarker();
+    var iterations = 0;
+    while (m !== null && typeof m !== "undefined" && iterations < 10000) {
+      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; }
+      markers.push(entry);
+
+      m = seq.markers.getNextMarker(m);
+      iterations++;
+    }
+  } catch (e) {
+    // leave markers as whatever was collected so far
+  }
+  return markers;
+}
+
+function ppb_getFullSequenceInfo(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var seq = null;
+    if (args.sequenceName && typeof args.sequenceName === "string") {
+      seq = findSequenceByName(args.sequenceName);
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no sequence named \"" + args.sequenceName + "\" is open" });
+      }
+    } else {
+      seq = app.project.activeSequence;
+      if (!seq) {
+        return JSON.stringify({ ok: false, error: "no active sequence, and no sequenceName given" });
+      }
+    }
+
+    var frameRate = null;
+    try {
+      frameRate = getSequenceFps(seq);
+    } catch (e) {
+      frameRate = null;
+    }
+
+    var durationSeconds = null;
+    try {
+      durationSeconds = (Number(seq.end) - Number(seq.zeroPoint)) / TICKS_PER_SECOND;
+    } catch (e) {
+      durationSeconds = null;
+    }
+
+    var width = null;
+    var height = null;
+    try {
+      var settings = seq.getSettings();
+      width = settings.videoFrameWidth;
+      height = settings.videoFrameHeight;
+    } catch (e) {
+      // best-effort only
+    }
+
+    var videoTracks = [];
+    try {
+      for (var v = 0; v < seq.videoTracks.numTracks; v++) {
+        videoTracks.push(ppb_serializeTrackForFullSequenceInfo(seq.videoTracks[v], v));
+      }
+    } catch (e) {
+      // leave videoTracks as whatever was collected so far
+    }
+
+    var audioTracks = [];
+    try {
+      for (var a = 0; a < seq.audioTracks.numTracks; a++) {
+        audioTracks.push(ppb_serializeTrackForFullSequenceInfo(seq.audioTracks[a], a));
+      }
+    } catch (e) {
+      // leave audioTracks as whatever was collected so far
+    }
+
+    var markerCount = null;
+    try {
+      markerCount = seq.markers.numMarkers;
+    } catch (e) {
+      markerCount = null;
+    }
+
+    var result = {
+      name: seq.name,
+      sequenceID: seq.sequenceID,
+      frameRate: frameRate,
+      durationSeconds: durationSeconds,
+      width: width,
+      height: height,
+      videoTracks: videoTracks,
+      audioTracks: audioTracks,
+      markers: ppb_serializeSequenceMarkers(seq),
+      markerCount: markerCount
+    };
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-graphics-white-luminance.jsx

@@ -0,0 +1,31 @@
+// Command: get-graphics-white-luminance → ppb_getGraphicsWhiteLuminance
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// READ-only. Ported from leancoderkavy/premiere-pro-mcp's project.ts
+// get_graphics_white_luminance: app.project.getGraphicsWhiteLuminance() —
+// the HDR graphics-white-luminance setting (in nits), not documented
+// elsewhere in PREMIERE_API_NOTES.md. Pairs with
+// set-graphics-white-luminance.jsx.
+
+function ppb_getGraphicsWhiteLuminance(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+    if (typeof app.project.getGraphicsWhiteLuminance !== "function") {
+      return JSON.stringify({ ok: false, error: "getGraphicsWhiteLuminance is not available on this Premiere build" });
+    }
+
+    var value = null;
+    try {
+      value = app.project.getGraphicsWhiteLuminance();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "getGraphicsWhiteLuminance() failed: " + e.toString() });
+    }
+
+    return JSON.stringify({ ok: true, result: { graphicsWhiteLuminance: value } });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-insertion-bin.jsx

@@ -0,0 +1,35 @@
+// Command: get-insertion-bin → ppb_getInsertionBin
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (TICKS_PER_SECOND,
+// ensureQEEnabled, findSequenceByName, ...) are already defined there.
+//
+// Thin read of app.project.getInsertionBin() — the bin currently focused
+// in the Project panel, i.e. where a new import would land.
+
+function ppb_getInsertionBin(argsJson) {
+  try {
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var bin = null;
+    try {
+      bin = app.project.getInsertionBin();
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "getInsertionBin failed: " + e.toString() });
+    }
+
+    if (!bin) {
+      return JSON.stringify({ ok: false, error: "no insertion bin found" });
+    }
+
+    var result = { name: null, nodeId: null, treePath: null };
+    try { result.name = bin.name; } catch (e) { result.name = null; }
+    try { result.nodeId = bin.nodeId; } catch (e) { result.nodeId = null; }
+    try { result.treePath = bin.treePath; } catch (e) { result.treePath = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-item-metadata.jsx

@@ -0,0 +1,94 @@
+// Command: get-item-metadata → ppb_getItemMetadata
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Project-item addressing: at least one of nodeId/name is required.
+// nodeId is matched exactly; name is matched exactly against item.name
+// (first match wins, depth-first). This helper is duplicated in each of
+// the get-item-metadata / get-color-label / get-footage-interpretation /
+// get-xmp-metadata / get-color-space command files (prefixed
+// ppbFindItem<Command>_) since each command file loads independently and
+// cannot rely on helpers defined only in another command file.
+
+function ppbFindItemGetItemMetadata_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 = ppbFindItemGetItemMetadata_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemGetItemMetadata_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemGetItemMetadata_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppb_getItemMetadata(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 = ppbFindItemGetItemMetadata_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 result = { name: null, nodeId: null, mediaPath: null, projectMetadata: null };
+    try { result.name = item.name; } catch (e) { result.name = null; }
+    try { result.nodeId = item.nodeId; } catch (e) { result.nodeId = null; }
+    try { result.mediaPath = item.getMediaPath(); } catch (e) { result.mediaPath = null; }
+    try { result.projectMetadata = item.getProjectMetadata(); } catch (e) { result.projectMetadata = null; }
+
+    return JSON.stringify({ ok: true, result: result });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/get-keyframes.jsx

@@ -0,0 +1,158 @@
+// Command: get-keyframes → ppb_getKeyframes
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// findClipComponent, findComponentProperty, timeValueToSeconds,
+// keyTimeToSeconds, getSequenceFps, ...) are already defined there.
+//
+// Standard-DOM only — no QE needed. Ported from leancoderkavy's
+// premiere-pro-mcp `get_keyframes` tool (keyframes.ts), addressed here by
+// trackType/trackIndex/clipIndex + componentName/propertyName. READ-only.
+//
+// Per PREMIERE_API_NOTES.md, prop.getKeys() key times are DISPUTED across
+// Premiere builds/repos (Time objects vs. raw ticks vs. raw seconds) —
+// keyTimeToSeconds() normalizes defensively (see its own comment for the
+// heuristic). Each key is reported as BOTH sequenceSeconds (raw Premiere
+// time) AND clipRelativeSeconds (offset by the clip's own start, matching
+// how add-audio-keyframes/add-keyframe accept clip-relative input).
+function ppb_getKeyframes(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.componentName !== "string" || !args.componentName) {
+      return JSON.stringify({ ok: false, error: "componentName is required" });
+    }
+    if (typeof args.propertyName !== "string" || !args.propertyName) {
+      return JSON.stringify({ ok: false, error: "propertyName 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 trackCollection = args.trackType === "video" ? seq.videoTracks : seq.audioTracks;
+    var numTracks = trackCollection.numTracks;
+    if (args.trackIndex >= numTracks) {
+      return JSON.stringify({
+        ok: false,
+        error: "trackIndex " + args.trackIndex + " is out of range — sequence has " + numTracks + " " + args.trackType + " track(s)"
+      });
+    }
+
+    var track = trackCollection[args.trackIndex];
+    var numClips = track.clips.numItems;
+    if (args.clipIndex >= numClips) {
+      return JSON.stringify({
+        ok: false,
+        error: "clipIndex " + args.clipIndex + " is out of range — track " + args.trackIndex + " has " + numClips + " clip(s)"
+      });
+    }
+
+    var clip = track.clips[args.clipIndex];
+    var clipName = null;
+    try { clipName = clip.name; } catch (e) { clipName = null; }
+
+    var clipStartSeconds = 0;
+    try { clipStartSeconds = timeValueToSeconds(clip.start) || 0; } catch (e) { clipStartSeconds = 0; }
+
+    var comp = findClipComponent(clip, [args.componentName], [args.componentName]);
+    if (!comp) {
+      return JSON.stringify({
+        ok: false,
+        error: "component \"" + args.componentName + "\" not found on clip (matched against matchName and displayName)"
+      });
+    }
+    var compDisplayName = null;
+    try { compDisplayName = comp.displayName; } catch (e) { compDisplayName = null; }
+
+    var prop = findComponentProperty(comp, [args.propertyName]);
+    if (!prop) {
+      return JSON.stringify({
+        ok: false,
+        error: "property \"" + args.propertyName + "\" not found on component \"" + compDisplayName + "\""
+      });
+    }
+
+    var isTimeVarying = false;
+    try { isTimeVarying = prop.isTimeVarying(); } catch (e) { isTimeVarying = false; }
+
+    if (!isTimeVarying) {
+      return JSON.stringify({
+        ok: true,
+        result: {
+          sequenceName: seq.name,
+          trackType: args.trackType,
+          trackIndex: args.trackIndex,
+          clipIndex: args.clipIndex,
+          clipName: clipName,
+          componentName: compDisplayName,
+          propertyName: args.propertyName,
+          isTimeVarying: false,
+          keyCount: 0,
+          keys: []
+        }
+      });
+    }
+
+    var rawKeys = null;
+    try { rawKeys = prop.getKeys(); } catch (e) { rawKeys = null; }
+
+    var keys = [];
+    if (rawKeys) {
+      for (var i = 0; i < rawKeys.length; i++) {
+        var rawKey = rawKeys[i];
+        var entry = { sequenceSeconds: null, clipRelativeSeconds: null, value: null };
+        try { entry.sequenceSeconds = keyTimeToSeconds(rawKey); } catch (e1) { entry.sequenceSeconds = null; }
+        if (entry.sequenceSeconds !== null) {
+          entry.clipRelativeSeconds = entry.sequenceSeconds - clipStartSeconds;
+        }
+        try { entry.value = prop.getValueAtKey(rawKey); } catch (e2) { entry.value = null; }
+        keys.push(entry);
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        sequenceName: seq.name,
+        trackType: args.trackType,
+        trackIndex: args.trackIndex,
+        clipIndex: args.clipIndex,
+        clipName: clipName,
+        componentName: compDisplayName,
+        propertyName: args.propertyName,
+        isTimeVarying: true,
+        keyCount: keys.length,
+        keys: keys
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}