@kenkaiiii/gg-editor 0.1.0

package/dist/core/hosts/premiere/bridge-source.js

@@ -0,0 +1,326 @@
+/**
+ * ExtendScript runtime for the Premiere bridge.
+ *
+ * Design: per-call self-contained JSX file. Each invocation generates a
+ * complete script that:
+ *   1. Defines small helpers (frame conversion, file writer)
+ *   2. Reads command + params hard-coded into the file
+ *   3. Writes result JSON to a known output path
+ *   4. Always wraps work in try/catch so a Premiere-side exception still
+ *      yields a parseable result file
+ *
+ * We keep JSX minimal — agent-facing logic lives in the TS adapter; JSX is
+ * only the thin glue that walks app.project.* and writes JSON.
+ *
+ * Modern Premiere (2018+) ships with full ECMAScript 5 JSON support. We
+ * don't polyfill; older versions get a clear error.
+ */
+const PREAMBLE = String.raw `
+function _writeJson(path, obj) {
+  var f = new File(path);
+  f.encoding = "UTF-8";
+  f.open("w");
+  f.write(JSON.stringify(obj));
+  f.close();
+}
+
+function _seq() {
+  if (!app.project) throw new Error("No project open in Premiere.");
+  var s = app.project.activeSequence;
+  if (!s) throw new Error("No active sequence in Premiere.");
+  return s;
+}
+
+function _fps(seq) {
+  // videoFrameRate is a Time; .seconds = frame duration in seconds.
+  var fd = seq.getSettings().videoFrameRate.seconds;
+  return fd > 0 ? 1 / fd : 30;
+}
+
+function _frames(time, seq) {
+  // seq.timebase: ticks per frame (TickValue). time.ticks: ticks since 0.
+  var tb = parseInt(seq.timebase, 10);
+  if (!tb || isNaN(tb)) tb = 1;
+  return Math.round(parseInt(time.ticks, 10) / tb);
+}
+
+function _markerColor(name) {
+  // Premiere marker colorIndex: 0..7 maps to Green, Red, Purple, Orange,
+  // Yellow, White, Blue, Cyan (varies by version; this is the common map).
+  var m = { green:0, red:1, purple:2, orange:3, yellow:4, white:5, blue:6, cyan:7 };
+  var k = (name || "blue").toLowerCase();
+  return m[k] !== undefined ? m[k] : 6;
+}
+
+function _findClipBin(name) {
+  // Walk root bin recursively for a ProjectItem matching imported file name.
+  var stack = [app.project.rootItem];
+  while (stack.length) {
+    var item = stack.pop();
+    for (var i = 0; i < item.children.numItems; i++) {
+      var child = item.children[i];
+      if (child.name === name) return child;
+      if (child.type === 2 /* BIN */) stack.push(child);
+    }
+  }
+  return null;
+}
+`;
+// ── Per-method bodies ───────────────────────────────────────
+const METHODS = {
+    ping: String.raw `
+    return { product: "Premiere Pro", version: app.version || "?" };
+  `,
+    get_timeline: String.raw `
+    var seq = _seq();
+    var fps = _fps(seq);
+    var clips = [];
+    function collect(tracks, kind) {
+      for (var ti = 0; ti < tracks.numTracks; ti++) {
+        var tr = tracks[ti];
+        for (var ci = 0; ci < tr.clips.numItems; ci++) {
+          var c = tr.clips[ci];
+          try {
+            clips.push({
+              id: String(c.nodeId || c.name + ":" + ci),
+              track: ti + 1,
+              trackKind: kind,
+              startFrame: _frames(c.start, seq),
+              endFrame: _frames(c.end, seq),
+              name: c.name
+            });
+          } catch (e) { /* skip uninspectable */ }
+        }
+      }
+    }
+    collect(seq.videoTracks, "video");
+    collect(seq.audioTracks, "audio");
+
+    var markers = [];
+    var mc = seq.markers;
+    var m = mc.getFirstMarker();
+    while (m) {
+      markers.push({
+        frame: _frames(m.start, seq),
+        note: (m.comments || m.name || ""),
+        color: m.colorIndex,
+        durationFrames: _frames(m.end, seq) - _frames(m.start, seq)
+      });
+      m = mc.getNextMarker(m);
+    }
+
+    var dur = (seq.end ? _frames({ ticks: seq.end }, seq) : 0);
+    return {
+      name: seq.name,
+      frameRate: fps,
+      durationFrames: dur,
+      clips: clips,
+      markers: markers
+    };
+  `,
+    add_marker: String.raw `
+    var seq = _seq();
+    var fps = _fps(seq);
+    var m = seq.markers.createMarker(P.frame / fps);
+    m.name = (P.note || "").substring(0, 60);
+    m.comments = P.note || "";
+    if (P.durationFrames && P.durationFrames > 1) {
+      m.end = m.start + (P.durationFrames / fps);
+    }
+    try { m.setColorByIndex(_markerColor(P.color)); } catch (e) {}
+    return null;
+  `,
+    append_clip: String.raw `
+    var seq = _seq();
+    var ok = app.project.importFiles([P.mediaPath], true, app.project.rootItem, false);
+    if (!ok) throw new Error("importFiles returned false for " + P.mediaPath);
+    // Find the imported item by basename.
+    var base = P.mediaPath.replace(/\\/g, "/").split("/").pop();
+    var pi = _findClipBin(base);
+    if (!pi) throw new Error("Imported item not found in project bin: " + base);
+    var track = seq.videoTracks[(P.track || 1) - 1];
+    if (!track) throw new Error("Track " + P.track + " does not exist on active sequence.");
+    // Insert at sequence end.
+    var endSec = seq.end ? (parseInt(seq.end, 10) / 254016000000) : 0;
+    track.insertClip(pi, endSec);
+    // Find the inserted clip — it's the last one on the track.
+    var inserted = track.clips[track.clips.numItems - 1];
+    return {
+      id: String(inserted.nodeId || inserted.name),
+      track: P.track || 1,
+      trackKind: "video",
+      startFrame: _frames(inserted.start, seq),
+      endFrame: _frames(inserted.end, seq),
+      name: inserted.name
+    };
+  `,
+    import_timeline: String.raw `
+    // Premiere's importFiles handles FCPXML/EDL — they create new sequences.
+    var ok = app.project.importFiles([P.filePath], true, app.project.rootItem, false);
+    if (!ok) throw new Error("importFiles returned false for " + P.filePath);
+    return null;
+  `,
+    get_markers: String.raw `
+    var seq = _seq();
+    var markers = [];
+    var mc = seq.markers;
+    var m = mc.getFirstMarker();
+    while (m) {
+      markers.push({
+        frame: _frames(m.start, seq),
+        note: (m.comments || m.name || ""),
+        color: m.colorIndex,
+        durationFrames: _frames(m.end, seq) - _frames(m.start, seq)
+      });
+      m = mc.getNextMarker(m);
+    }
+    return markers;
+  `,
+    create_timeline: String.raw `
+    if (!app.project) throw new Error("No project open in Premiere.");
+    var name = String(P.name || "GG Sequence");
+    var preset = P.presetPath || "";
+    var newSeq = null;
+    if (preset) {
+      try { newSeq = app.project.createNewSequence(name, preset); } catch (e) { newSeq = null; }
+    }
+    if (!newSeq) {
+      // Fallback: clone the active sequence so we get a usable preset.
+      var src = app.project.activeSequence;
+      if (!src) {
+        throw new Error("create_timeline needs either a sqpreset path (P.presetPath) or an active sequence to clone.");
+      }
+      try {
+        newSeq = src.clone();
+        if (newSeq && newSeq.name !== undefined) newSeq.name = name;
+      } catch (e2) {
+        throw new Error("create_timeline fallback failed: " + (e2 && e2.message ? e2.message : e2));
+      }
+    }
+    return { name: newSeq.name || name };
+  `,
+    import_to_media_pool: String.raw `
+    if (!app.project) throw new Error("No project open in Premiere.");
+    var paths = P.paths || [];
+    if (!paths.length) throw new Error("import_to_media_pool: paths array is empty.");
+    var parent = app.project.rootItem;
+    if (P.bin) {
+      var existing = null;
+      for (var i = 0; i < parent.children.numItems; i++) {
+        var child = parent.children[i];
+        if (child.name === P.bin && child.type === 2 /* BIN */) { existing = child; break; }
+      }
+      parent = existing || parent.createBin(P.bin);
+    }
+    var ok = app.project.importFiles(paths, true, parent, false);
+    if (!ok) throw new Error("importFiles returned false.");
+    return { imported: paths.length };
+  `,
+    clone_timeline: String.raw `
+    var src = _seq();
+    var newName = String(P.newName || (src.name + " copy"));
+    var cloned = null;
+    try { cloned = src.clone(); } catch (e) { cloned = null; }
+    if (!cloned) throw new Error("sequence clone failed (older Premiere versions don't expose Sequence.clone)");
+    if (cloned.name !== undefined) {
+      try { cloned.name = newName; } catch (e2) {}
+    }
+    return { name: cloned.name || newName };
+  `,
+    save_project: String.raw `
+    if (!app.project) throw new Error("No project open in Premiere.");
+    if (typeof app.project.save !== "function") throw new Error("app.project.save is not callable in this Premiere version");
+    app.project.save();
+    return null;
+  `,
+    insert_clip_on_track: String.raw `
+    var seq = _seq();
+    var fps = _fps(seq);
+    // Import media first.
+    var ok = app.project.importFiles([P.mediaPath], true, app.project.rootItem, false);
+    if (!ok) throw new Error("importFiles returned false for " + P.mediaPath);
+    var base = P.mediaPath.replace(/\\/g, "/").split("/").pop();
+    var pi = _findClipBin(base);
+    if (!pi) throw new Error("imported item not found: " + base);
+    var trackIdx = (P.track || 2) - 1;
+    var track = seq.videoTracks[trackIdx];
+    if (!track) throw new Error("track " + P.track + " does not exist on active sequence.");
+    var recordSec = P.recordFrame / fps;
+    track.insertClip(pi, recordSec);
+    var inserted = null;
+    for (var i = 0; i < track.clips.numItems; i++) {
+      var c = track.clips[i];
+      if (Math.abs(_frames(c.start, seq) - P.recordFrame) < 2) { inserted = c; break; }
+    }
+    if (!inserted) inserted = track.clips[track.clips.numItems - 1];
+    return {
+      id: String(inserted.nodeId || inserted.name),
+      track: P.track || 2,
+      trackKind: "video",
+      startFrame: _frames(inserted.start, seq),
+      endFrame: _frames(inserted.end, seq),
+      name: inserted.name
+    };
+  `,
+    replace_clip: String.raw `
+    var seq = _seq();
+    var target = null;
+    function scan(tracks) {
+      for (var ti = 0; ti < tracks.numTracks; ti++) {
+        var tr = tracks[ti];
+        for (var ci = 0; ci < tr.clips.numItems; ci++) {
+          var c = tr.clips[ci];
+          var iid = String(c.nodeId || c.name + ":" + ci);
+          if (iid === P.clipId) { target = c; return; }
+        }
+      }
+    }
+    scan(seq.videoTracks);
+    if (!target) scan(seq.audioTracks);
+    if (!target) throw new Error("clip not found on active sequence: " + P.clipId);
+    // Import the new media if not already in the project.
+    var ok = app.project.importFiles([P.mediaPath], true, app.project.rootItem, false);
+    if (!ok) throw new Error("importFiles returned false for " + P.mediaPath);
+    var base = P.mediaPath.replace(/\\/g, "/").split("/").pop();
+    var pi = _findClipBin(base);
+    if (!pi) throw new Error("imported item not found: " + base);
+    // Premiere's TrackItem exposes changeMediaPath in some versions.
+    if (typeof target.changeMediaPath === "function") {
+      target.changeMediaPath(P.mediaPath);
+      return { clipId: P.clipId, mediaPath: P.mediaPath };
+    }
+    throw new Error("replace_clip not supported by this Premiere version. fix: rebuild via FCPXML with the new media reference.");
+  `,
+    import_subtitles: String.raw `
+    if (!app.project) throw new Error("No project open in Premiere.");
+    var ok = app.project.importFiles([P.srtPath], true, app.project.rootItem, false);
+    if (!ok) throw new Error("importFiles returned false for " + P.srtPath);
+    return { imported: true, attached: false, note: "SRT imported to project; drag onto a captions track on the active sequence." };
+  `,
+};
+/**
+ * Generate a self-contained JSX script for one method invocation.
+ * @param method   Method name (must match METHODS)
+ * @param params   JSON-encoded params (will be JSON.parsed in JSX as `P`)
+ * @param outPath  Absolute path where the result JSON is written
+ */
+export function buildJsxScript(method, params, outPath) {
+    const body = METHODS[method];
+    if (!body)
+        throw new Error(`unknown premiere method: ${method}`);
+    // Escape outPath for safe JSX string literal.
+    const safeOut = outPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const safeParams = JSON.stringify(params).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `${PREAMBLE}
+var P = JSON.parse("${safeParams}");
+var __out = "${safeOut}";
+try {
+  var __result = (function () { ${body} })();
+  _writeJson(__out, { ok: true, result: __result === undefined ? null : __result });
+} catch (__e) {
+  _writeJson(__out, { ok: false, error: (__e && __e.message) ? __e.message : String(__e) });
+}
+`;
+}
+export const PREMIERE_METHODS = Object.keys(METHODS);
+//# sourceMappingURL=bridge-source.js.map

package/dist/core/hosts/premiere/bridge-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-source.js","sourceRoot":"","sources":["../../../../src/core/hosts/premiere/bridge-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD1B,CAAC;AAEF,+DAA+D;AAE/D,MAAM,OAAO,GAA2B;IACtC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAA;;GAEf;IAED,YAAY,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CvB;IAED,UAAU,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;GAWrB;IAED,WAAW,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBtB;IAED,eAAe,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;GAK1B;IAED,WAAW,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;GAetB;IAED,eAAe,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;GAsB1B;IAED,oBAAoB,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;GAgB/B;IAED,cAAc,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;GAUzB;IAED,YAAY,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;GAKvB;IAED,oBAAoB,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4B/B;IAED,YAAY,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BvB;IAED,gBAAgB,EAAE,MAAM,CAAC,GAAG,CAAA;;;;;GAK3B;CACF,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAc,EACd,MAA+B,EAC/B,OAAe;IAEf,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,MAAM,EAAE,CAAC,CAAC;IACjE,8CAA8C;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtF,OAAO,GAAG,QAAQ;sBACE,UAAU;eACjB,OAAO;;kCAEY,IAAI;;;;;CAKrC,CAAC;AACF,CAAC;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC"}

package/dist/core/hosts/premiere/bridge-source.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bridge-source.test.d.ts.map

package/dist/core/hosts/premiere/bridge-source.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-source.test.d.ts","sourceRoot":"","sources":["../../../../src/core/hosts/premiere/bridge-source.test.ts"],"names":[],"mappings":""}

package/dist/core/hosts/premiere/bridge-source.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { buildJsxScript, PREMIERE_METHODS } from "./bridge-source.js";
+describe("buildJsxScript", () => {
+    it("produces a non-empty script for every supported method", () => {
+        for (const m of PREMIERE_METHODS) {
+            const jsx = buildJsxScript(m, {}, "/tmp/out.json");
+            expect(jsx.length).toBeGreaterThan(0);
+            expect(jsx).toContain("_writeJson");
+            expect(jsx).toContain("/tmp/out.json");
+        }
+    });
+    it("throws on unknown method", () => {
+        expect(() => buildJsxScript("not_a_method", {}, "/tmp/out.json")).toThrow(/unknown premiere method/);
+    });
+    it("escapes quotes in output path", () => {
+        const jsx = buildJsxScript("ping", {}, '/tmp/with "quote".json');
+        // Should appear escaped, not raw.
+        expect(jsx).not.toContain('"/tmp/with "quote".json"');
+        expect(jsx).toContain('with \\"quote\\"');
+    });
+    it("encodes params as a JSON-parseable string in JSX", () => {
+        const jsx = buildJsxScript("add_marker", { frame: 30, note: 'hi "there"' }, "/tmp/o.json");
+        // The script should contain a JSON.parse(...) call with our params.
+        expect(jsx).toContain("JSON.parse(");
+        expect(jsx).toContain("frame");
+        // Quotes inside the JSON-string must be doubly escaped.
+        expect(jsx).toContain('\\"frame\\":30');
+    });
+    it("wraps every method body in try/catch that emits ok:false on throw", () => {
+        const jsx = buildJsxScript("ping", {}, "/tmp/o.json");
+        expect(jsx).toContain("try {");
+        expect(jsx).toContain("ok: false");
+        expect(jsx).toContain("ok: true");
+    });
+});
+//# sourceMappingURL=bridge-source.test.js.map

package/dist/core/hosts/premiere/bridge-source.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-source.test.js","sourceRoot":"","sources":["../../../../src/core/hosts/premiere/bridge-source.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtE,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,KAAK,MAAM,CAAC,IAAI,gBAAgB,EAAE,CAAC;YACjC,MAAM,GAAG,GAAG,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,eAAe,CAAC,CAAC;YACnD,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;YACtC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YACpC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QACzC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0BAA0B,EAAE,GAAG,EAAE;QAClC,MAAM,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,cAAc,EAAE,EAAE,EAAE,eAAe,CAAC,CAAC,CAAC,OAAO,CACvE,yBAAyB,CAC1B,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACvC,MAAM,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,wBAAwB,CAAC,CAAC;QACjE,kCAAkC;QAClC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,0BAA0B,CAAC,CAAC;QACtD,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,MAAM,GAAG,GAAG,cAAc,CAAC,YAAY,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,aAAa,CAAC,CAAC;QAC3F,oEAAoE;QACpE,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QACrC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC/B,wDAAwD;QACxD,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,MAAM,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,EAAE,EAAE,aAAa,CAAC,CAAC;QACtD,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QACnC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/core/hosts/premiere/bridge.d.ts

@@ -0,0 +1,38 @@
+export type BridgeError = Error;
+/**
+ * Active panel runtime, surfaced for capability + diagnostic messages.
+ *   - 'http-uxp'        Modern UXP panel (Premiere 25.6+).
+ *   - 'http-cep'        Legacy CEP panel — supported by Adobe through Sept 2026.
+ *   - 'osascript-cep'   ExtendScript via osascript (no panel installed). macOS-only.
+ */
+export type PremiereTransportKind = "http-uxp" | "http-cep" | "osascript-cep";
+export declare class PremiereBridge {
+    private transport?;
+    private transportProbe?;
+    /**
+     * Cheap pre-flight reachability check. Async because it probes the panel.
+     * Safe to call from capabilities() — also surfaces the panel runtime kind so
+     * the adapter can include it in HostCapabilities without needing to issue a
+     * full RPC first.
+     */
+    static checkReachable(): Promise<{
+        ok: true;
+        transport: PremiereTransportKind;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    /**
+     * What flavour of bridge is currently in use. Returns undefined before the
+     * first call (transport hasn't been resolved yet).
+     */
+    getTransportKind(): PremiereTransportKind | undefined;
+    private getTransport;
+    call<T = unknown>(method: string, params?: Record<string, unknown>, opts?: {
+        signal?: AbortSignal;
+    }): Promise<T>;
+    private callViaOsascript;
+    private runOsascript;
+    shutdown(): void;
+}
+//# sourceMappingURL=bridge.d.ts.map

package/dist/core/hosts/premiere/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../../src/core/hosts/premiere/bridge.ts"],"names":[],"mappings":"AAkCA,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC;AAEhC;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,UAAU,GAAG,eAAe,CAAC;AAc9E,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAC,CAAY;IAC9B,OAAO,CAAC,cAAc,CAAC,CAAqB;IAE5C;;;;;OAKG;WACU,cAAc,IAAI,OAAO,CACpC;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,qBAAqB,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAC/E;IAwCD;;;OAGG;IACH,gBAAgB,IAAI,qBAAqB,GAAG,SAAS;YASvC,YAAY;IAuDpB,IAAI,CAAC,CAAC,GAAG,OAAO,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACpC,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GAClC,OAAO,CAAC,CAAC,CAAC;YAWC,gBAAgB;IAuC9B,OAAO,CAAC,YAAY;IAiCpB,QAAQ,IAAI,IAAI;CAMjB"}

package/dist/core/hosts/premiere/bridge.js

@@ -0,0 +1,238 @@
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { tmpdir, platform } from "node:os";
+import { join } from "node:path";
+import { buildJsxScript } from "./bridge-source.js";
+import { PremiereHttpBridge } from "./http-bridge.js";
+import { PremiereWsBridge } from "./ws-bridge.js";
+/**
+ * Premiere bridge. Three transports, selected lazily on first use:
+ *
+ *   1. **HTTP** — talks to the gg-editor-premiere-panel CEP extension running
+ *      inside Premiere. The CEP panel is the HTTP server; ggeditor is the
+ *      client. Required on Windows when the user is on the legacy CEP path.
+ *      Per-call latency: ~10-30ms.
+ *
+ *   2. **WebSocket** — talks to the gg-editor-premiere-panel UXP plugin.
+ *      UXP plugins **cannot listen on TCP ports**, so the roles are flipped:
+ *      ggeditor hosts a localhost WS server, the plugin connects out.
+ *      The plugin's hello frame is what we treat as 'health' here.
+ *
+ *   3. **osascript** — macOS only fallback. Spawns AppleScript that asks
+ *      Premiere to evalFile a per-call JSX. Per-call latency ~200-500ms.
+ *      Used when neither panel is installed/running.
+ *
+ * Probe order:
+ *   - Try HTTP first (cheapest — pure fetch, no listening sockets).
+ *   - Otherwise spin up the WS listener and wait briefly for the UXP plugin.
+ *   - Otherwise on macOS, fall back to osascript.
+ *   - Otherwise on Windows, surface a clear install instruction.
+ */
+let nextId = 1;
+/**
+ * How long we wait for the UXP plugin to dial back into our WS listener
+ * before giving up and trying the next transport. Kept short so users
+ * without a plugin don't pay this cost on every CLI launch.
+ */
+const WS_HELLO_TIMEOUT_MS = 1500;
+export class PremiereBridge {
+    transport;
+    transportProbe;
+    /**
+     * Cheap pre-flight reachability check. Async because it probes the panel.
+     * Safe to call from capabilities() — also surfaces the panel runtime kind so
+     * the adapter can include it in HostCapabilities without needing to issue a
+     * full RPC first.
+     */
+    static async checkReachable() {
+        // 1. Try HTTP (existing CEP panel) first — cheapest probe.
+        const http = new PremiereHttpBridge();
+        const health = await http.health();
+        if (health?.ok) {
+            const transport = health.kind === "uxp" ? "http-uxp" : "http-cep";
+            return { ok: true, transport };
+        }
+        // 2. Try WS (UXP plugin). Spin up a temporary listener and see if the
+        //    plugin dials in. We tear it down regardless — the real bridge in
+        //    `getTransport()` will start its own listener if WS turns out to be
+        //    the chosen transport.
+        const probe = new PremiereWsBridge();
+        try {
+            await probe.start();
+            const ws = await probe.health(WS_HELLO_TIMEOUT_MS);
+            if (ws?.ok)
+                return { ok: true, transport: "http-uxp" };
+        }
+        catch {
+            // Couldn't bind — fall through to osascript / install message.
+        }
+        finally {
+            probe.shutdown();
+        }
+        if (platform() === "darwin")
+            return { ok: true, transport: "osascript-cep" };
+        if (platform() === "win32") {
+            return {
+                ok: false,
+                reason: "Premiere panel not reachable on http://127.0.0.1:7437. " +
+                    "Install the UXP panel (Premiere 25.6+, recommended): " +
+                    "`npx @kenkaiiii/gg-editor-premiere-panel install --uxp`. " +
+                    "Or the legacy CEP panel (works through Sept 2026): " +
+                    "`npx @kenkaiiii/gg-editor-premiere-panel install --cep`. " +
+                    "Then restart Premiere and open Window → Extensions → GG Editor.",
+            };
+        }
+        return { ok: false, reason: `Premiere is not supported on platform '${platform()}'.` };
+    }
+    /**
+     * What flavour of bridge is currently in use. Returns undefined before the
+     * first call (transport hasn't been resolved yet).
+     */
+    getTransportKind() {
+        if (!this.transport)
+            return undefined;
+        if (this.transport.kind === "http") {
+            return this.transport.panelKind === "uxp" ? "http-uxp" : "http-cep";
+        }
+        if (this.transport.kind === "ws")
+            return "http-uxp";
+        return "osascript-cep";
+    }
+    async getTransport() {
+        if (this.transport)
+            return this.transport;
+        if (this.transportProbe)
+            return this.transportProbe;
+        this.transportProbe = (async () => {
+            // 1. HTTP — pre-existing CEP panel.
+            const http = new PremiereHttpBridge();
+            const health = await http.health();
+            if (health?.ok) {
+                const t = {
+                    kind: "http",
+                    panelKind: health.kind ?? "cep",
+                    bridge: http,
+                };
+                this.transport = t;
+                return t;
+            }
+            // 2. WS — UXP plugin connects to us. Hold the listener open: it stays
+            //    bound for the rest of the session so the plugin can reconnect
+            //    after a Premiere restart without us missing it.
+            const ws = new PremiereWsBridge();
+            try {
+                await ws.start();
+                const hello = await ws.health(WS_HELLO_TIMEOUT_MS);
+                if (hello?.ok) {
+                    const t = { kind: "ws", panelKind: "uxp", bridge: ws };
+                    this.transport = t;
+                    return t;
+                }
+                ws.shutdown();
+            }
+            catch {
+                ws.shutdown();
+            }
+            // 3. osascript — macOS only.
+            if (platform() === "darwin") {
+                const t = {
+                    kind: "osascript",
+                    workDir: mkdtempSync(join(tmpdir(), "gg-editor-premiere-")),
+                };
+                this.transport = t;
+                return t;
+            }
+            throw new Error("Premiere panel not reachable and osascript not available. " +
+                "On Windows: install @kenkaiiii/gg-editor-premiere-panel " +
+                "(use --uxp for Premiere 25.6+, --cep for older versions). " +
+                "On macOS: ensure Premiere Pro is running.");
+        })();
+        return this.transportProbe;
+    }
+    async call(method, params = {}, opts = {}) {
+        const t = await this.getTransport();
+        if (t.kind === "http") {
+            return t.bridge.call(method, params, opts);
+        }
+        if (t.kind === "ws") {
+            return t.bridge.call(method, params, opts);
+        }
+        return this.callViaOsascript(method, params, t.workDir, opts.signal);
+    }
+    async callViaOsascript(method, params, workDir, signal) {
+        if (signal?.aborted) {
+            throw Object.assign(new Error("call aborted before send"), { name: "AbortError" });
+        }
+        const id = String(nextId++);
+        const scriptPath = join(workDir, `cmd-${id}.jsx`);
+        const outPath = join(workDir, `out-${id}.json`);
+        const jsx = buildJsxScript(method, params, outPath);
+        writeFileSync(scriptPath, jsx, "utf8");
+        try {
+            await this.runOsascript(scriptPath, signal);
+            const raw = readFileSync(outPath, "utf8");
+            const msg = JSON.parse(raw);
+            if (!msg.ok) {
+                const err = new Error(msg.error ?? "premiere bridge error");
+                throw err;
+            }
+            return msg.result;
+        }
+        finally {
+            try {
+                unlinkSync(scriptPath);
+            }
+            catch {
+                /* */
+            }
+            try {
+                unlinkSync(outPath);
+            }
+            catch {
+                /* */
+            }
+        }
+    }
+    runOsascript(scriptPath, signal) {
+        return new Promise((resolve, reject) => {
+            const jsxPath = scriptPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            const apple = [
+                'tell application "Adobe Premiere Pro"',
+                `  do script "$.evalFile(\\"${jsxPath}\\")"`,
+                "end tell",
+            ].join("\n");
+            const child = spawn("osascript", ["-e", apple], {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stderr = "";
+            child.stderr.on("data", (d) => (stderr += d.toString()));
+            const onAbort = () => {
+                child.kill("SIGTERM");
+                reject(Object.assign(new Error("osascript aborted"), { name: "AbortError" }));
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            child.on("error", (e) => {
+                signal?.removeEventListener("abort", onAbort);
+                reject(e);
+            });
+            child.on("close", (code) => {
+                signal?.removeEventListener("abort", onAbort);
+                if (signal?.aborted)
+                    return; // already rejected
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`osascript exited ${code}${stderr ? ": " + stderr.slice(-300) : ""}`));
+            });
+        });
+    }
+    shutdown() {
+        if (this.transport?.kind === "http")
+            this.transport.bridge.shutdown();
+        if (this.transport?.kind === "ws")
+            this.transport.bridge.shutdown();
+        this.transport = undefined;
+        this.transportProbe = undefined;
+    }
+}
+//# sourceMappingURL=bridge.js.map