premiere-cli 0.2.0__py3-none-any.whl

premiere_cli/panel/host/commands/create-caption-track.jsx

@@ -0,0 +1,159 @@
+// Command: create-caption-track → ppb_createCaptionTrack
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Ported from leancoderkavy's premiere-pro-mcp captions.ts
+// create_caption_track. Creates a caption/subtitle track from an already-
+// imported caption project item (e.g. an .srt file) via
+// seq.createCaptionTrack(item, startSeconds, formatConstant) — the 3-arg
+// signature PREMIERE_API_NOTES.md documents ("3rd arg is an INTEGER
+// CONSTANT, NOT a string — 'Illegal Parameter type' otherwise"). Note
+// this deliberately does NOT resolve to the same call add-text-overlay
+// makes (that file's 1-arg createCaptionTrack(formatNum) — see its header
+// comment for the arity conflict this reveals between reference repos).
+//
+// format is resolved via Sequence.CAPTION_FORMAT_* named constants with a
+// typeof guard first (per PREMIERE_API_NOTES.md's constant list:
+// SUBTITLE/608/708/TELETEXT/OPEN_EBU/OP42/OP47); if the named constant
+// isn't present on this build, a known integer fallback (text.ts's own
+// numeric map) is used ONLY for subtitle/608/708/teletext — ebu/op42/op47
+// have no confirmed integer fallback anywhere in the reference repos, so
+// those fail honestly if the named constant is unavailable.
+//
+// No caption READ API exists (PREMIERE_API_NOTES.md) — this command
+// cannot verify the caption track's actual contents afterward, only that
+// the call itself returned truthy.
+function ppbFindItemCreateCaptionTrack_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 = ppbFindItemCreateCaptionTrack_walk(item.children[i], args, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbFindItemCreateCaptionTrack_resolve(args) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbFindItemCreateCaptionTrack_walk(root.children[i], args, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+var PPB_CAPTION_FORMAT_CONSTANT_NAMES = {
+  "subtitle": "CAPTION_FORMAT_SUBTITLE",
+  "608": "CAPTION_FORMAT_608",
+  "708": "CAPTION_FORMAT_708",
+  "teletext": "CAPTION_FORMAT_TELETEXT",
+  "ebu": "CAPTION_FORMAT_OPEN_EBU",
+  "op42": "CAPTION_FORMAT_OP42",
+  "op47": "CAPTION_FORMAT_OP47"
+};
+
+var PPB_CAPTION_FORMAT_INT_FALLBACKS = { "subtitle": 3, "608": 1, "708": 2, "teletext": 4 };
+
+function ppb_createCaptionTrack(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 to identify the caption project item (e.g. an imported .srt)" });
+    }
+    if (typeof args.startSeconds !== "number") {
+      return JSON.stringify({ ok: false, error: "startSeconds is required" });
+    }
+
+    var format = (typeof args.format === "string" && PPB_CAPTION_FORMAT_CONSTANT_NAMES.hasOwnProperty(args.format)) ? args.format : "subtitle";
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+    var seq = app.project.activeSequence;
+    if (!seq) {
+      return JSON.stringify({ ok: false, error: "no active sequence" });
+    }
+
+    var item = ppbFindItemCreateCaptionTrack_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 constantName = PPB_CAPTION_FORMAT_CONSTANT_NAMES[format];
+    var formatValue = null;
+    var usedFallbackInt = false;
+    try {
+      if (typeof Sequence !== "undefined" && typeof Sequence[constantName] !== "undefined") {
+        formatValue = Sequence[constantName];
+      }
+    } catch (e2) {
+      formatValue = null;
+    }
+    if (formatValue === null) {
+      if (PPB_CAPTION_FORMAT_INT_FALLBACKS.hasOwnProperty(format)) {
+        formatValue = PPB_CAPTION_FORMAT_INT_FALLBACKS[format];
+        usedFallbackInt = true;
+      } else {
+        return JSON.stringify({ ok: false, error: "Sequence." + constantName + " is not available on this build, and format \"" + format + "\" has no known integer fallback" });
+      }
+    }
+
+    var createResult = null;
+    try {
+      createResult = seq.createCaptionTrack(item, args.startSeconds, formatValue);
+    } catch (e3) {
+      return JSON.stringify({ ok: false, error: "seq.createCaptionTrack() failed: " + e3.toString() });
+    }
+    if (!createResult) {
+      return JSON.stringify({ ok: false, error: "seq.createCaptionTrack() returned a falsy result" });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        created: true,
+        item: { name: (function () { try { return item.name; } catch (e) { return null; } })(), nodeId: (function () { try { return item.nodeId; } catch (e) { return null; } })() },
+        startSeconds: args.startSeconds,
+        format: format,
+        formatValue: formatValue,
+        usedFallbackInt: usedFallbackInt,
+        note: "no caption READ API exists on this build — this only confirms the create call returned truthy, not the track's actual rendered contents."
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/create-sequence-from-clips.jsx

@@ -0,0 +1,170 @@
+// Command: create-sequence-from-clips → ppb_createSequenceFromClips
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (findSequenceByName,
+// ...) are already defined there. Helper names are prefixed
+// ppbCreateSeqFromClips_ to avoid colliding with same-purpose helpers in
+// other lazily-loaded command files evaluated into this same global
+// context (e.g. add-to-timeline.jsx's own project-item walker).
+//
+// Ported from leancoderkavy/premiere-pro-mcp's advanced.ts
+// create_sequence_from_clips tool:
+// `app.project.createNewSequenceFromClips(name, itemsArray[, targetBin])`
+// per PREMIERE_API_NOTES.md's Sequences table ("auto-detects settings from
+// first clip"). nodeIds resolve to project items via the same recursive
+// bin walk used elsewhere in this panel (list-project-items.jsx,
+// add-to-timeline.jsx); targetBinPath (if given) is resolved the same
+// '/'-separated way as create-sequence's --bin, but is NEVER auto-created
+// here (same convention as get-bin-contents.jsx) — pass an existing bin
+// path only.
+function ppbCreateSeqFromClips_findItem(item, nodeId, 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;
+  try { matched = item.nodeId === nodeId; } catch (e) { matched = false; }
+  if (matched) {
+    return item;
+  }
+  if (isBin && item.children) {
+    for (var i = 0; i < item.children.numItems; i++) {
+      var found = ppbCreateSeqFromClips_findItem(item.children[i], nodeId, depth + 1);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+}
+
+function ppbCreateSeqFromClips_resolveItem(nodeId) {
+  var root = app.project.rootItem;
+  for (var i = 0; i < root.children.numItems; i++) {
+    var found = ppbCreateSeqFromClips_findItem(root.children[i], nodeId, 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function ppbCreateSeqFromClips_resolveBin(binPath) {
+  var segments = binPath.split("/").filter(function (s) { return s.length > 0; });
+  var currentBin = app.project.rootItem;
+  for (var i = 0; i < segments.length; i++) {
+    var segment = segments[i];
+    var found = null;
+    for (var j = 0; j < currentBin.children.numItems; j++) {
+      var child = currentBin.children[j];
+      if (child.name === segment && child.type === ProjectItemType.BIN) {
+        found = child;
+        break;
+      }
+    }
+    if (!found) {
+      return null;
+    }
+    currentBin = found;
+  }
+  return currentBin;
+}
+
+function ppb_createSequenceFromClips(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" });
+    }
+    if (!args.name || typeof args.name !== "string") {
+      return JSON.stringify({ ok: false, error: "name is required" });
+    }
+
+    var nodeIds = args.nodeIds;
+    if (!nodeIds || !(nodeIds instanceof Array) || nodeIds.length === 0) {
+      return JSON.stringify({ ok: false, error: "nodeIds must be a non-empty array" });
+    }
+
+    var items = [];
+    var notFound = [];
+    for (var i = 0; i < nodeIds.length; i++) {
+      var item = ppbCreateSeqFromClips_resolveItem(nodeIds[i]);
+      if (item) {
+        items.push(item);
+      } else {
+        notFound.push(nodeIds[i]);
+      }
+    }
+    if (notFound.length > 0) {
+      return JSON.stringify({ ok: false, error: "could not find project item(s) for nodeId(s): " + notFound.join(", ") });
+    }
+
+    var targetBin = null;
+    if (args.targetBinPath && typeof args.targetBinPath === "string") {
+      targetBin = ppbCreateSeqFromClips_resolveBin(args.targetBinPath);
+      if (!targetBin) {
+        return JSON.stringify({ ok: false, error: "targetBinPath \"" + args.targetBinPath + "\" does not exist (not auto-created)" });
+      }
+    }
+
+    var numSequencesBefore = app.project.sequences.numSequences;
+
+    var callError = null;
+    try {
+      if (targetBin) {
+        app.project.createNewSequenceFromClips(args.name, items, targetBin);
+      } else {
+        app.project.createNewSequenceFromClips(args.name, items);
+      }
+    } catch (e) {
+      callError = e.toString();
+    }
+
+    var numSequencesAfter = app.project.sequences.numSequences;
+
+    if (callError !== null || numSequencesAfter <= numSequencesBefore) {
+      return JSON.stringify({
+        ok: false,
+        error: callError !== null
+          ? ("createNewSequenceFromClips() failed: " + callError)
+          : "createNewSequenceFromClips() did not throw, but the project's sequence count did not increase",
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    var newSeq = findSequenceByName(args.name);
+    if (!newSeq) {
+      return JSON.stringify({
+        ok: false,
+        error: "sequence count increased but no sequence named \"" + args.name + "\" was found afterward",
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        name: newSeq.name,
+        sequenceID: newSeq.sequenceID,
+        clipCount: items.length,
+        targetBinPath: args.targetBinPath || null,
+        numSequencesBefore: numSequencesBefore,
+        numSequencesAfter: numSequencesAfter
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/create-sequence-from-preset.jsx

@@ -0,0 +1,90 @@
+// Command: create-sequence-from-preset → ppb_createSequenceFromPreset
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled,
+// findSequenceByName, getSequenceFps, ...) are already defined there.
+//
+// Sibling of create-sequence.jsx, which bundles its own fixed 4K/25fps
+// .sqpreset — this command is the caller-supplied-preset counterpart per
+// leancoderkavy's advanced.ts create_sequence_from_preset tool
+// (app.project.createNewSequenceFromPreset did not exist on our build per
+// PREMIERE_API_NOTES.md — the QE path `qe.project.newSequence(name,
+// presetPath)` create-sequence.jsx already proved out is reused here with
+// an arbitrary presetPath instead of the bundled one).
+//
+// Unlike create-sequence, there is no --bin argument — the new sequence
+// lands wherever qe.project.newSequence() puts it (bin placement was not
+// part of the reference tool's own scope either). Duplicate-name checking
+// is at the project root only, since there's no bin scope to check within.
+function ppb_createSequenceFromPreset(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.name || typeof args.name !== "string") {
+      return JSON.stringify({ ok: false, error: "name is required" });
+    }
+    if (!args.presetPath || typeof args.presetPath !== "string") {
+      return JSON.stringify({ ok: false, error: "presetPath is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    for (var k = 0; k < app.project.rootItem.children.numItems; k++) {
+      var existing = app.project.rootItem.children[k];
+      if (existing.name === args.name && existing.type === ProjectItemType.SEQUENCE) {
+        return JSON.stringify({ ok: false, error: "sequence \"" + args.name + "\" already exists at the project root" });
+      }
+    }
+
+    var presetFile = new File(args.presetPath);
+    if (!presetFile.exists) {
+      return JSON.stringify({ ok: false, error: "preset file not found: " + presetFile.fsName });
+    }
+
+    try {
+      ensureQEEnabled();
+      qe.project.newSequence(args.name, presetFile.fsName);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.newSequence failed: " + e.toString() });
+    }
+
+    var newSequence = findSequenceByName(args.name);
+    if (!newSequence) {
+      return JSON.stringify({ ok: false, error: "sequence creation failed: no sequence found after qe.project.newSequence" });
+    }
+
+    var width = null;
+    var height = null;
+    var fps = null;
+    try {
+      var settings = newSequence.getSettings();
+      width = settings.videoFrameWidth;
+      height = settings.videoFrameHeight;
+      fps = getSequenceFps(newSequence);
+    } catch (e) {
+      width = null;
+      height = null;
+      fps = null;
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        name: newSequence.name,
+        sequenceID: newSequence.sequenceID,
+        presetPath: presetFile.fsName,
+        width: width,
+        height: height,
+        fps: fps
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

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

@@ -0,0 +1,166 @@
+// Command: create-sequence → ppb_createSequence
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context — shared helpers (ensureQEEnabled, ...)
+// are already defined there.
+//
+// Sequence creation without the interactive "New Sequence" dialog uses the
+// undocumented QE (Quality Engineering) DOM, not the standard app.project
+// DOM: app.project.createNewSequence() pops the dialog regardless of its
+// placeholderID argument, and app.project.importSequencePreset() does not
+// exist at all on this Premiere Pro version. qe.project.newSequence(name,
+// presetPath) creates the sequence directly from a .sqpreset file with no
+// dialog, but returns a QE-DOM object with a different API surface — the
+// standard Sequence object (needed for moveBin/getSettings/setSettings) is
+// re-fetched from app.project.sequences by name afterward.
+
+// The bundled preset is 4K/25fps; requests matching those values skip the
+// getSettings()/setSettings() override step entirely (the preset already
+// has the right settings, including Rec.709 color space).
+var DEFAULT_FPS = 25;
+var DEFAULT_WIDTH = 3840;
+var DEFAULT_HEIGHT = 2160;
+
+function ppb_createSequence(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.name || typeof args.name !== "string") {
+      return JSON.stringify({ ok: false, error: "name is required" });
+    }
+    if (typeof args.bin !== "string") {
+      return JSON.stringify({ ok: false, error: "bin is required" });
+    }
+    if (typeof args.fps !== "number" || args.fps <= 0) {
+      return JSON.stringify({ ok: false, error: "fps must be a positive number" });
+    }
+    if (typeof args.width !== "number" || args.width <= 0 || Math.floor(args.width) !== args.width) {
+      return JSON.stringify({ ok: false, error: "width must be a positive integer" });
+    }
+    if (typeof args.height !== "number" || args.height <= 0 || Math.floor(args.height) !== args.height) {
+      return JSON.stringify({ ok: false, error: "height must be a positive integer" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    // Walk (and create, if missing) the bin path.
+    var binSegments = args.bin.split("/").filter(function (s) { return s.length > 0; });
+    var currentBin = app.project.rootItem;
+
+    for (var i = 0; i < binSegments.length; i++) {
+      var segment = binSegments[i];
+      var found = null;
+
+      for (var j = 0; j < currentBin.children.numItems; j++) {
+        var child = currentBin.children[j];
+        if (child.name === segment && child.type === ProjectItemType.BIN) {
+          found = child;
+          break;
+        }
+      }
+
+      if (!found) {
+        found = currentBin.createBin(segment);
+      }
+
+      currentBin = found;
+    }
+
+    // Duplicate check — before any mutation past bin creation.
+    for (var k = 0; k < currentBin.children.numItems; k++) {
+      var existing = currentBin.children[k];
+      if (existing.name === args.name && existing.type === ProjectItemType.SEQUENCE) {
+        return JSON.stringify({
+          ok: false,
+          error: "sequence \"" + args.name + "\" already exists in bin \"" + args.bin + "\""
+        });
+      }
+    }
+
+    if (typeof args.pluginDir !== "string" || args.pluginDir.length === 0) {
+      return JSON.stringify({ ok: false, error: "pluginDir was not provided by the panel" });
+    }
+
+    var presetFile = new File(args.pluginDir + "/host/presets/default-4k-25fps.sqpreset");
+    if (!presetFile.exists) {
+      return JSON.stringify({ ok: false, error: "sequence preset file not found: " + presetFile.fsName });
+    }
+
+    try {
+      ensureQEEnabled();
+      qe.project.newSequence(args.name, presetFile.fsName);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "qe.project.newSequence failed: " + e.toString() });
+    }
+
+    // qe.project.newSequence returns a QE-DOM object, not a standard
+    // Sequence — re-fetch the real one by name to use normal DOM methods.
+    var newSequence = null;
+    for (var s = 0; s < app.project.sequences.numSequences; s++) {
+      if (app.project.sequences[s].name === args.name) {
+        newSequence = app.project.sequences[s];
+        break;
+      }
+    }
+
+    if (!newSequence) {
+      return JSON.stringify({ ok: false, error: "sequence creation failed: no sequence found after qe.project.newSequence" });
+    }
+
+    var settingsApplied = [];
+    var settingsFailed = {};
+
+    try {
+      newSequence.projectItem.moveBin(currentBin);
+    } catch (e) {
+      settingsFailed.bin = e.toString();
+    }
+
+    var matchesDefaults = (args.fps === DEFAULT_FPS && args.width === DEFAULT_WIDTH && args.height === DEFAULT_HEIGHT);
+
+    if (matchesDefaults) {
+      // The bundled preset already is 4K/25fps — nothing further to apply.
+      settingsApplied.push("fps");
+      settingsApplied.push("resolution");
+    } else {
+      try {
+        var fpsSettings = newSequence.getSettings();
+        fpsSettings.videoFrameRate = TICKS_PER_SECOND / args.fps;
+        newSequence.setSettings(fpsSettings);
+        settingsApplied.push("fps");
+      } catch (e) {
+        settingsFailed.fps = e.toString();
+      }
+
+      try {
+        var resSettings = newSequence.getSettings();
+        resSettings.videoFrameWidth = args.width;
+        resSettings.videoFrameHeight = args.height;
+        newSequence.setSettings(resSettings);
+        settingsApplied.push("resolution");
+      } catch (e) {
+        settingsFailed.resolution = e.toString();
+      }
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: {
+        name: newSequence.name,
+        bin: args.bin,
+        sequenceID: newSequence.sequenceID,
+        settingsApplied: settingsApplied,
+        settingsFailed: settingsFailed,
+        colorSpace: "rec709 (from bundled sequence preset)"
+      }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}

premiere_cli/panel/host/commands/create-smart-bin.jsx

@@ -0,0 +1,80 @@
+// Command: create-smart-bin → ppb_createSmartBin
+// Loaded lazily by ppb_dispatch (host/index.jsx) on first use, into the
+// same global ExtendScript context.
+//
+// Ported from leancoderkavy/premiere-pro-mcp's project.ts create_smart_bin.
+// Calls rootItem.createSmartBin(name, query) — per PREMIERE_API_NOTES.md.
+// Verified by a root-bin children-count increase and locating the newly-
+// appeared bin by name (never trusting the call's own return value, same
+// distrust pattern as add-adjustment-layer.jsx's item creation step).
+// query syntax is Premiere's own search-bin query language — not
+// validated here, any failure surfaces as either a thrown exception or a
+// silent no-op (count doesn't increase).
+
+function ppb_createSmartBin(argsJson) {
+  try {
+    var args;
+    try {
+      args = JSON.parse(argsJson);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "invalid args JSON: " + e.toString() });
+    }
+
+    if (!args.name || typeof args.name !== "string") {
+      return JSON.stringify({ ok: false, error: "name is required" });
+    }
+    if (!args.query || typeof args.query !== "string") {
+      return JSON.stringify({ ok: false, error: "query is required" });
+    }
+
+    if (!app.project) {
+      return JSON.stringify({ ok: false, error: "no project open" });
+    }
+
+    var root = app.project.rootItem;
+    if (typeof root.createSmartBin !== "function") {
+      return JSON.stringify({ ok: false, error: "createSmartBin is not available on this Premiere build" });
+    }
+
+    var countBefore = root.children.numItems;
+
+    try {
+      root.createSmartBin(args.name, args.query);
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: "createSmartBin() failed: " + e.toString() });
+    }
+
+    var freshChildren = app.project.rootItem.children;
+    var countAfter = freshChildren.numItems;
+    var created = countAfter > countBefore;
+
+    var newBin = null;
+    if (created) {
+      for (var i = freshChildren.numItems - 1; i >= 0; i--) {
+        var it = freshChildren[i];
+        var itName = null;
+        try { itName = it.name; } catch (e) { itName = null; }
+        if (itName === args.name) {
+          newBin = it;
+          break;
+        }
+      }
+    }
+
+    if (!created || !newBin) {
+      return JSON.stringify({
+        ok: false,
+        error: "createSmartBin() did not throw, but no new bin named \"" + args.name + "\" was found afterward",
+        countBefore: countBefore,
+        countAfter: countAfter
+      });
+    }
+
+    return JSON.stringify({
+      ok: true,
+      result: { created: true, name: args.name, query: args.query, nodeId: newBin.nodeId }
+    });
+  } catch (e) {
+    return JSON.stringify({ ok: false, error: e.toString() });
+  }
+}