tinacms 3.8.4 → 3.9.0

package/dist/index.js

@@ -58,10 +58,10 @@ import { useSensors, useSensor, PointerSensor, KeyboardSensor, DndContext, close
 import { sortableKeyboardCoordinates, useSortable, SortableContext, verticalListSortingStrategy, defaultAnimateLayoutChanges } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { FaSpinner, FaCircle, FaFolder, FaFile, FaLock, FaUnlock } from "react-icons/fa";
+import { AiFillWarning, AiOutlineLoading } from "react-icons/ai";
 import { buildSchema, print, getIntrospectionQuery, buildClientSchema, parse as parse$3 } from "graphql";
 import { diff as diff$1 } from "@graphql-inspector/core";
 import { processDocumentForIndexing, queryToSearchIndexQuery, optionsToSearchIndexOptions, parseSearchIndexResponse } from "@tinacms/search/index-client";
-import { AiFillWarning, AiOutlineLoading } from "react-icons/ai";
 import { HexColorPicker } from "react-colorful";
 import { MdKeyboardArrowDown, MdOutlineClear, MdArrowForward, MdAccessTime, MdOutlineDataSaverOff, MdCheckCircle, MdWifiOff, MdOutlineSettings, MdOutlinePhotoLibrary, MdVpnKey, MdImage, MdOutlineCloud, MdWarning, MdInfo, MdError, MdSyncProblem, MdOutlinePerson, MdOutlineHelpOutline } from "react-icons/md";
 import * as dropzone from "react-dropzone";
@@ -9306,12 +9306,23 @@ const PullRequestCell = ({
   }
   return null;
 };
-const tableHeadingStyle = "px-3 py-3 text-left text-xs font-bold text-gray-700 tracking-wider sticky top-0 bg-gray-100 z-20 border-b-2 border-gray-200 ";
 function formatBranchName(str) {
-  const pattern = /[^/\w-]+/g;
-  const formattedStr = str.replace(pattern, "-");
-  return formattedStr.toLowerCase();
+  let result = "";
+  let replacingInvalidChars = false;
+  for (const char of str.toLowerCase()) {
+    const code = char.charCodeAt(0);
+    const isValid = char === "/" || char === "-" || char === "_" || code >= 48 && code <= 57 || code >= 97 && code <= 122;
+    if (isValid) {
+      result += char;
+      replacingInvalidChars = false;
+    } else if (!replacingInvalidChars) {
+      result += "-";
+      replacingInvalidChars = true;
+    }
+  }
+  return result;
 }
+const tableHeadingStyle = "px-3 py-3 text-left text-xs font-bold text-gray-700 tracking-wider sticky top-0 bg-gray-100 z-20 border-b-2 border-gray-200 ";
 const BranchSwitcher = (props) => {
   const cms = useCMS$1();
   const usingEditorialWorkflow = cms.api.tina.usingEditorialWorkflow;
@@ -10014,9 +10025,28 @@ class EventBus {
   }
   dispatch(event) {
     if (!this.listeners)
-      return;
+      return false;
     const listenerSnapshot = Array.from(this.listeners.values());
-    listenerSnapshot.forEach((listener) => listener.handleEvent(event));
+    return listenerSnapshot.reduce(
+      (handled, listener) => listener.handleEvent(event) || handled,
+      false
+    );
+  }
+  /**
+   * Whether any listener *explicitly* targets `eventType`. The catch-all `'*'`
+   * pattern does not count — callers use this to detect a purpose-built
+   * subscriber (e.g. a mounted UI overlay) without being misled by ambient
+   * `'*'` listeners such as the alerts bridge, which would otherwise make
+   * {@link dispatch} report every event as "handled".
+   */
+  hasExplicitListenerFor(eventType) {
+    if (!this.listeners)
+      return false;
+    for (const listener of this.listeners) {
+      if (listener.isExplicitListenerFor(eventType))
+        return true;
+    }
+    return false;
   }
 }
 class Listener {
@@ -10031,6 +10061,16 @@ class Listener {
     }
     return false;
   }
+  /**
+   * Whether this listener explicitly targets `eventType`. Unlike
+   * {@link watchesEvent}, the catch-all `'*'` pattern does NOT match, so this
+   * reflects a purpose-built subscription rather than an ambient one.
+   */
+  isExplicitListenerFor(eventType) {
+    if (this.eventPattern === "*")
+      return false;
+    return this.watchesEvent({ type: eventType });
+  }
   watchesEvent(currentEvent) {
     if (this.eventPattern === "*")
       return true;
@@ -10047,6 +10087,63 @@ class Listener {
     return !ignoresEvent;
   }
 }
+const EDITORIAL_WORKFLOW_STATUS = {
+  QUEUED: "queued",
+  PROCESSING: "processing",
+  SETTING_UP: "setting_up",
+  CREATING_BRANCH: "creating_branch",
+  INDEXING: "indexing",
+  CONTENT_GENERATION: "content_generation",
+  CREATING_PR: "creating_pr",
+  COMPLETE: "complete",
+  ERROR: "error",
+  TIMEOUT: "timeout"
+};
+const EDITORIAL_WORKFLOW_ERROR = {
+  BRANCH_EXISTS: "BRANCH_EXISTS",
+  BRANCH_HIERARCHY_CONFLICT: "BRANCH_HIERARCHY_CONFLICT",
+  VALIDATION_FAILED: "VALIDATION_FAILED"
+};
+const getEditorialWorkflowPrTitle = (branchName) => `${branchName.replace("tina/", "").replaceAll("-", " ")} (PR from TinaCMS)`;
+const TARGET_BRANCH_EXISTS_ERROR = "A branch with this name already exists";
+const checkBranchExists = async (tinaApi, branchName, debugLabel, branchType, fallback, signal) => {
+  try {
+    console.debug(
+      `[tina:branch-guard] ${debugLabel}: checking ${branchType} branch:`,
+      branchName
+    );
+    const exists = await tinaApi.branchExists(branchName, { signal });
+    console.debug(
+      `[tina:branch-guard] ${debugLabel}: ${branchType} branch exists?`,
+      exists
+    );
+    return exists;
+  } catch (err) {
+    if (signal == null ? void 0 : signal.aborted)
+      return fallback;
+    console.error(
+      `[tina:branch-guard] ${debugLabel}: branchExists threw, failing open:`,
+      err
+    );
+    return fallback;
+  }
+};
+const checkBaseBranchExists = async (tinaApi, baseBranch, debugLabel, signal) => checkBranchExists(tinaApi, baseBranch, debugLabel, "base", true, signal);
+const checkTargetBranchExists = async (tinaApi, targetBranch, debugLabel, signal) => checkBranchExists(tinaApi, targetBranch, debugLabel, "target", false, signal);
+const MEDIA_WORKFLOW_STEP = {
+  BRANCH: 1,
+  CONTENT: 2,
+  PR: 3,
+  COMPLETE: 4
+};
+const MEDIA_WORKFLOW_STATUS_TO_STEP = {
+  [EDITORIAL_WORKFLOW_STATUS.SETTING_UP]: MEDIA_WORKFLOW_STEP.BRANCH,
+  [EDITORIAL_WORKFLOW_STATUS.CREATING_BRANCH]: MEDIA_WORKFLOW_STEP.BRANCH,
+  [EDITORIAL_WORKFLOW_STATUS.INDEXING]: MEDIA_WORKFLOW_STEP.CONTENT,
+  [EDITORIAL_WORKFLOW_STATUS.CONTENT_GENERATION]: MEDIA_WORKFLOW_STEP.CONTENT,
+  [EDITORIAL_WORKFLOW_STATUS.CREATING_PR]: MEDIA_WORKFLOW_STEP.PR,
+  [EDITORIAL_WORKFLOW_STATUS.COMPLETE]: MEDIA_WORKFLOW_STEP.COMPLETE
+};
 const s3ErrorRegex = /<Error>.*<Code>(.+)<\/Code>.*<Message>(.+)<\/Message>.*/;
 class DummyMediaStore {
   constructor() {
@@ -10084,6 +10181,9 @@ class TinaMediaStore {
     __publicField(this, "url");
     __publicField(this, "staticMedia");
     __publicField(this, "isStatic");
+    // Route assets-api calls through the created branch until indexing makes it safe to switch React branch state.
+    __publicField(this, "workflowBranchOverride");
+    __publicField(this, "mediaWorkflowInProgress", false);
     __publicField(this, "accept", DEFAULT_MEDIA_UPLOAD_TYPES);
     // allow up to 100MB uploads
     __publicField(this, "maxSize", 100 * 1024 * 1024);
@@ -10123,8 +10223,8 @@ class TinaMediaStore {
     return await this.api.authProvider.isAuthenticated();
   }
   /**
-   * Returns the current branch as a single-encoded query-param value, or
-   * an empty string when no branch is set.
+   * Returns the workflow branch override or current branch as a single-encoded
+   * query-param value, or an empty string when no branch is set.
    *
    * `this.api.branch` is already URL-encoded by `Client.setBranch()`, so we
    * decode then re-encode here to defend against double-encoding when this
@@ -10137,6 +10237,9 @@ class TinaMediaStore {
    * assets-api (which would route the call to a non-existent staging path).
    */
   encodedBranchParam() {
+    if (this.workflowBranchOverride) {
+      return encodeURIComponent(this.workflowBranchOverride);
+    }
     if (!this.api.branch)
       return "";
     const decoded = decodeURIComponent(this.api.branch);
@@ -10144,67 +10247,297 @@ class TinaMediaStore {
       return "";
     return encodeURIComponent(decoded);
   }
-  async persist_cloud(media) {
-    if (!await this.isAuthenticated()) {
-      return [];
+  shortStableHash(input) {
+    let hash = 2166136261;
+    for (let index = 0; index < input.length; index++) {
+      hash ^= input.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
     }
+    return (hash >>> 0).toString(36);
+  }
+  trimEdges(value, char) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value[start] === char) {
+      start++;
+    }
+    while (end > start && value[end - 1] === char) {
+      end--;
+    }
+    return value.slice(start, end);
+  }
+  branchSlugForMediaPath(directory, filename) {
+    const trimmedDirectory = this.trimEdges(directory ?? "", "/");
+    const rawPath = [trimmedDirectory, filename].filter(Boolean).join("/");
+    const flattened = rawPath.replaceAll("/", "-");
+    const slug = this.trimEdges(formatBranchName(flattened), "-");
+    if (!slug)
+      return `asset-${this.shortStableHash(rawPath || "root")}`;
+    return rawPath !== rawPath.toLowerCase() ? `${slug}-${this.shortStableHash(rawPath)}` : slug;
+  }
+  /** Joins a directory and filename into a normalized `dir/file` repo path. */
+  joinMediaPath(directory, filename) {
+    const dir = this.trimEdges(directory ?? "", "/");
+    return dir && dir !== "/" ? `${dir}/${filename ?? ""}` : filename ?? "";
+  }
+  branchQueryParam() {
     const encodedBranch = this.encodedBranchParam();
-    const branchQuery = encodedBranch ? `?branch=${encodedBranch}` : "";
-    for (const item of media) {
-      let directory = item.directory;
-      if (directory == null ? void 0 : directory.endsWith("/")) {
-        directory = directory.substr(0, directory.length - 1);
-      }
-      const safeName = sanitizeFilename(item.file.name);
-      const path = `${directory && directory !== "/" ? `${directory}/${safeName}` : safeName}`;
-      const res = await this.api.authProvider.fetchWithToken(
-        `${this.url}/upload_url/${path}${branchQuery}`,
-        { method: "GET" }
+    return encodedBranch ? `?branch=${encodedBranch}` : "";
+  }
+  requestMediaBranchChoice(branchName, baseBranch, opType, repoPath) {
+    if (!this.cms.events.hasExplicitListenerFor("media:workflow:confirm-branch")) {
+      throw new Error(
+        "Cannot start a media editorial workflow: no branch prompt is mounted. Ensure <MediaWorkflowOverlay /> is rendered (TinaCloudProvider mounts it automatically)."
       );
-      if (res.status === 412) {
-        const { message = "Unexpected error generating upload url" } = await res.json();
-        throw new Error(message);
-      }
-      const { signedUrl, requestId } = await res.json();
-      if (!signedUrl) {
-        throw new Error("Unexpected error generating upload url");
-      }
-      const uploadRes = await this.fetchFunction(signedUrl, {
-        method: "PUT",
-        body: item.file,
-        headers: {
-          "Content-Type": item.file.type || "application/octet-stream",
-          "Content-Length": String(item.file.size)
+    }
+    return new Promise((resolve) => {
+      this.cms.events.dispatch({
+        type: "media:workflow:confirm-branch",
+        branchName,
+        baseBranch,
+        onConfirm: async (selectedBranchName) => {
+          const context = await this.prepareMediaBranch(
+            selectedBranchName,
+            baseBranch,
+            opType,
+            repoPath
+          );
+          resolve({
+            kind: "workflow",
+            context
+          });
+        },
+        onCancel: () => resolve({ kind: "cancelled" }),
+        onSaveToProtectedBranch: () => resolve({ kind: "direct" })
+      });
+    });
+  }
+  async prepareMediaBranch(branchName, baseBranch, opType, repoPath) {
+    if (this.mediaWorkflowInProgress) {
+      throw new Error("A media workflow is already in progress.");
+    }
+    this.mediaWorkflowInProgress = true;
+    try {
+      this.cms.events.dispatch({
+        type: "media:workflow:start",
+        branchName,
+        baseBranch
+      });
+      const workflow = await this.api.startMediaEditorialWorkflow({
+        branchName,
+        baseBranch,
+        prTitle: getEditorialWorkflowPrTitle(branchName),
+        operation: opType,
+        repoPath
+      });
+      const branchContext = {
+        branchName: workflow.branchName || branchName,
+        baseBranch,
+        requestId: workflow.requestId
+      };
+      this.workflowBranchOverride = branchContext.branchName;
+      return branchContext;
+    } catch (err) {
+      this.resetWorkflowState();
+      throw err;
+    }
+  }
+  resetWorkflowState() {
+    this.workflowBranchOverride = void 0;
+    this.mediaWorkflowInProgress = false;
+  }
+  async finalizeMediaWorkflow(branchContext, onCatalogued) {
+    try {
+      const result = await this.api.waitForEditorialWorkflowStatus(
+        branchContext.requestId,
+        (status) => {
+          const step = MEDIA_WORKFLOW_STATUS_TO_STEP[status.status];
+          if (step) {
+            this.cms.events.dispatch({
+              type: "media:workflow:step",
+              step
+            });
+          }
         }
+      );
+      if (onCatalogued)
+        await onCatalogued();
+      this.resetWorkflowState();
+      this.cms.events.dispatch({
+        type: "media:workflow:complete",
+        branchName: result.branchName || branchContext.branchName
       });
-      if (!uploadRes.ok) {
-        const xmlRes = await uploadRes.text();
-        const matches = s3ErrorRegex.exec(xmlRes);
-        console.error(xmlRes);
-        if (!matches) {
-          throw new Error("Unexpected error uploading media asset");
+      if (result.warning) {
+        this.cms.alerts.warn(result.warning, 0);
+      }
+      this.cms.alerts.success(
+        `Branch created successfully - Pull Request at ${(result == null ? void 0 : result.pullRequestUrl) || ""}`,
+        0
+      );
+      this.cms.events.dispatch({ type: "media:workflow:finish" });
+    } catch (err) {
+      this.resetWorkflowState();
+      this.dispatchMediaWorkflowError(err);
+    }
+  }
+  dispatchMediaWorkflowError(err) {
+    this.cms.events.dispatch({
+      type: "media:workflow:error",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  }
+  async runMediaOpWithWorkflow(decision, op) {
+    if (decision.kind !== "workflow")
+      return op();
+    try {
+      const result = await op();
+      await this.finalizeMediaWorkflow(decision.context);
+      return result;
+    } catch (err) {
+      this.resetWorkflowState();
+      this.cms.events.dispatch({ type: "media:workflow:finish" });
+      throw err;
+    }
+  }
+  async prepareProtectedMediaBranch(opType, directory, filename) {
+    if (!this.api.usingProtectedBranch())
+      return { kind: "direct" };
+    const baseBranch = decodeURIComponent(this.api.branch || "");
+    const mediaSlug = this.branchSlugForMediaPath(directory, filename);
+    const branchName = `media-${opType}-${mediaSlug}`;
+    const repoFilename = opType === "upload" && filename ? sanitizeFilename(filename) : filename;
+    const repoPath = this.joinMediaPath(directory, repoFilename);
+    return this.requestMediaBranchChoice(
+      branchName,
+      baseBranch,
+      opType,
+      repoPath
+    );
+  }
+  async waitForRequestStatus(requestId, timeoutMessage) {
+    const startTime = Date.now();
+    while (true) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const { error: error2, message } = await this.api.getRequestStatus(requestId);
+      if (error2 !== void 0) {
+        if (error2) {
+          throw new Error(message);
         } else {
-          throw new Error(`Upload error: '${matches[2]}'`);
+          return;
         }
       }
-      const updateStartTime = Date.now();
-      while (true) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        const { error: error2, message } = await this.api.getRequestStatus(requestId);
-        if (error2 !== void 0) {
-          if (error2) {
-            throw new Error(message);
-          } else {
-            break;
-          }
-        }
-        if (Date.now() - updateStartTime > 3e4) {
-          throw new Error("Time out waiting for upload to complete");
-        }
+      if (Date.now() - startTime > 3e4) {
+        throw new Error(timeoutMessage);
       }
     }
+  }
+  async persist_cloud(media) {
+    if (media.length === 0) {
+      return [];
+    }
+    if (!await this.isAuthenticated()) {
+      return [];
+    }
+    const firstItem = media[0];
+    const decision = await this.prepareProtectedMediaBranch(
+      "upload",
+      firstItem.directory,
+      firstItem.file.name
+    );
+    if (decision.kind === "cancelled")
+      return [];
+    if (decision.kind === "workflow") {
+      return this.persistCloudViaWorkflow(media, decision.context);
+    }
+    const branchQuery = this.branchQueryParam();
+    for (const item of media) {
+      await this.uploadCloudMediaItem(item, branchQuery, {
+        waitForStatus: true
+      });
+    }
     return this.fetchUploadedEntries(media);
   }
+  /**
+   * Uploads assets through the editorial workflow. The asset is staged, the
+   * server-side workflow catalogues it in the new branch's media index, and
+   * only then do we list it — while the branch override still routes list
+   * calls to the workflow branch, so the freshly uploaded item is returned to
+   * the caller (and added to the media manager) without needing a manual
+   * refresh.
+   */
+  async persistCloudViaWorkflow(media, branchContext) {
+    try {
+      const branchQuery = this.branchQueryParam();
+      for (const item of media) {
+        await this.uploadCloudMediaItem(item, branchQuery, {
+          waitForStatus: false
+        });
+      }
+      let entries = [];
+      await this.finalizeMediaWorkflow(branchContext, async () => {
+        entries = await this.fetchUploadedEntries(media);
+      });
+      return entries;
+    } catch (err) {
+      this.resetWorkflowState();
+      this.cms.events.dispatch({ type: "media:workflow:finish" });
+      throw err;
+    }
+  }
+  async uploadCloudMediaItem(item, branchQuery, { waitForStatus = true } = {}) {
+    const path = this.joinMediaPath(
+      item.directory,
+      sanitizeFilename(item.file.name)
+    );
+    const res = await this.api.authProvider.fetchWithToken(
+      `${this.url}/upload_url/${path}${branchQuery}`,
+      { method: "GET" }
+    );
+    if (res.status === 412) {
+      const { message = "Unexpected error generating upload url" } = await res.json();
+      throw new Error(message);
+    }
+    const { signedUrl, requestId } = await res.json();
+    if (!signedUrl) {
+      throw new Error("Unexpected error generating upload url");
+    }
+    const uploadRes = await this.fetchFunction(signedUrl, {
+      method: "PUT",
+      body: item.file,
+      headers: {
+        "Content-Type": item.file.type || "application/octet-stream",
+        "Content-Length": String(item.file.size)
+      }
+    });
+    if (!uploadRes.ok) {
+      const xmlRes = await uploadRes.text();
+      const matches = s3ErrorRegex.exec(xmlRes);
+      console.error(xmlRes);
+      if (!matches) {
+        throw new Error("Unexpected error uploading media asset");
+      } else {
+        throw new Error(`Upload error: '${matches[2]}'`);
+      }
+    }
+    if (waitForStatus) {
+      await this.waitForRequestStatus(
+        requestId,
+        "Time out waiting for upload to complete"
+      );
+    }
+  }
+  groupMediaByDirectory(media) {
+    const byDirectory = /* @__PURE__ */ new Map();
+    for (const item of media) {
+      let dir = item.directory || "";
+      while (dir.endsWith("/"))
+        dir = dir.slice(0, -1);
+      const bucket = byDirectory.get(dir) ?? [];
+      bucket.push(item);
+      byDirectory.set(dir, bucket);
+    }
+    return byDirectory;
+  }
   /**
    * Resolves the just-uploaded items to canonical `Media` entries by hitting
    * the assets-api `list` endpoint, which is the source of truth for the
@@ -10218,15 +10551,7 @@ class TinaMediaStore {
    * throwing — the upload itself already succeeded.
    */
   async fetchUploadedEntries(media) {
-    const byDirectory = /* @__PURE__ */ new Map();
-    for (const item of media) {
-      let dir = item.directory || "";
-      while (dir.endsWith("/"))
-        dir = dir.slice(0, -1);
-      const bucket = byDirectory.get(dir) ?? [];
-      bucket.push(item);
-      byDirectory.set(dir, bucket);
-    }
+    const byDirectory = this.groupMediaByDirectory(media);
     const thumbnailSizes = [
       { w: 75, h: 75 },
       { w: 400, h: 400 },
@@ -10422,37 +10747,33 @@ class TinaMediaStore {
     };
   }
   async delete(media) {
-    const path = `${media.directory ? `${media.directory}/${media.filename}` : media.filename}`;
+    const path = this.joinMediaPath(media.directory, media.filename);
     if (!this.isLocal) {
       if (await this.isAuthenticated()) {
-        const encodedBranch = this.encodedBranchParam();
-        const branchQuery = encodedBranch ? `?branch=${encodedBranch}` : "";
-        const res = await this.api.authProvider.fetchWithToken(
-          `${this.url}/${path}${branchQuery}`,
-          {
-            method: "DELETE"
-          }
+        const decision = await this.prepareProtectedMediaBranch(
+          "delete",
+          media.directory,
+          media.filename
         );
-        if (res.status == 200) {
+        if (decision.kind === "cancelled")
+          return;
+        await this.runMediaOpWithWorkflow(decision, async () => {
+          const branchQuery = this.branchQueryParam();
+          const res = await this.api.authProvider.fetchWithToken(
+            `${this.url}/${path}${branchQuery}`,
+            { method: "DELETE" }
+          );
+          if (res.status !== 200) {
+            throw new Error("Unexpected error deleting media asset");
+          }
           const { requestId } = await res.json();
-          const deleteStartTime = Date.now();
-          while (true) {
-            await new Promise((resolve) => setTimeout(resolve, 1e3));
-            const { error: error2, message } = await this.api.getRequestStatus(requestId);
-            if (error2 !== void 0) {
-              if (error2) {
-                throw new Error(message);
-              } else {
-                break;
-              }
-            }
-            if (Date.now() - deleteStartTime > 3e4) {
-              throw new Error("Time out waiting for delete to complete");
-            }
+          if (decision.kind !== "workflow") {
+            await this.waitForRequestStatus(
+              requestId,
+              "Time out waiting for delete to complete"
+            );
           }
-        } else {
-          throw new Error("Unexpected error deleting media asset");
-        }
+        });
       } else {
         throw E_UNAUTHORIZED;
       }
@@ -12865,7 +13186,7 @@ const NavProvider = ({
 const name = "tinacms";
 const type = "module";
 const typings = "dist/index.d.ts";
-const version$1 = "3.8.4";
+const version$1 = "3.9.0";
 const main = "dist/index.js";
 const module = "./dist/index.js";
 const exports = {
@@ -15454,23 +15775,6 @@ const BranchPreviewButton = (props) => {
     /* @__PURE__ */ React.createElement(BiLinkExternal, { className: "h-5 w-auto" })
   );
 };
-const EDITORIAL_WORKFLOW_STATUS = {
-  QUEUED: "queued",
-  PROCESSING: "processing",
-  SETTING_UP: "setting_up",
-  CREATING_BRANCH: "creating_branch",
-  INDEXING: "indexing",
-  CONTENT_GENERATION: "content_generation",
-  CREATING_PR: "creating_pr",
-  COMPLETE: "complete",
-  ERROR: "error",
-  TIMEOUT: "timeout"
-};
-const EDITORIAL_WORKFLOW_ERROR = {
-  BRANCH_EXISTS: "BRANCH_EXISTS",
-  BRANCH_HIERARCHY_CONFLICT: "BRANCH_HIERARCHY_CONFLICT",
-  VALIDATION_FAILED: "VALIDATION_FAILED"
-};
 const CREATE_DOCUMENT_GQL = `#graphql
 mutation($collection: String!, $relativePath: String!, $params: DocumentMutation!) {
   createDocument(
@@ -15828,6 +16132,18 @@ const pathRelativeToCollection = (collectionPath, fullPath) => {
     `Path ${fullPath} not within collection path ${collectionPath}`
   );
 };
+const getEditorialWorkflowMutation = (crudType) => {
+  if (crudType === "create") {
+    return CREATE_DOCUMENT_GQL;
+  }
+  if (crudType === "delete") {
+    return DELETE_DOCUMENT_GQL;
+  }
+  if (crudType !== "view") {
+    return UPDATE_DOCUMENT_GQL;
+  }
+  return "";
+};
 const WORKFLOW_STEPS = [
   { id: 1, name: "Creating branch", description: "Setting up workspace" },
   { id: 2, name: "Updating branch", description: "Syncing content to branch" },
@@ -15838,6 +16154,33 @@ const formatTime = (seconds) => {
   const secs = seconds % 60;
   return `${mins}:${secs.toString().padStart(2, "0")}`;
 };
+const getEditorialWorkflowErrorMessage = (e) => {
+  let errMessage = "Branch operation failed. Talking to GitHub was unsuccessful, please try again. If the problem persists please contact support at https://tina.io/support 🦙";
+  const err = e;
+  if (err.errorCode) {
+    switch (err.errorCode) {
+      case EDITORIAL_WORKFLOW_ERROR.BRANCH_EXISTS:
+        errMessage = "A branch with this name already exists";
+        break;
+      case EDITORIAL_WORKFLOW_ERROR.BRANCH_HIERARCHY_CONFLICT:
+        errMessage = err.message || "Branch name conflicts with an existing branch";
+        break;
+      case EDITORIAL_WORKFLOW_ERROR.VALIDATION_FAILED:
+        errMessage = err.message || "Invalid branch name";
+        break;
+      default:
+        errMessage = err.message || errMessage;
+        break;
+    }
+  } else if (err.message) {
+    if (err.message.toLowerCase().includes("already exists")) {
+      errMessage = "A branch with this name already exists";
+    } else if (err.message.toLowerCase().includes("conflict")) {
+      errMessage = err.message;
+    }
+  }
+  return errMessage;
+};
 function useEditorialWorkflow() {
   const cms = useCMS$1();
   const tinaApi = cms.api.tina;
@@ -15871,20 +16214,30 @@ function useEditorialWorkflow() {
     path,
     values,
     crudType,
-    tinaForm
+    tinaForm,
+    signal
   }) => {
     var _a;
     try {
+      if (signal == null ? void 0 : signal.aborted)
+        return false;
+      const targetBranchExists = await checkTargetBranchExists(
+        tinaApi,
+        branchName,
+        "executeEditorialWorkflow",
+        signal
+      );
+      if (signal == null ? void 0 : signal.aborted)
+        return false;
+      if (targetBranchExists) {
+        setErrorMessage(TARGET_BRANCH_EXISTS_ERROR);
+        setIsExecuting(false);
+        setCurrentStep(0);
+        return false;
+      }
       setIsExecuting(true);
       setCurrentStep(1);
-      let graphql2 = "";
-      if (crudType === "create") {
-        graphql2 = CREATE_DOCUMENT_GQL;
-      } else if (crudType === "delete") {
-        graphql2 = DELETE_DOCUMENT_GQL;
-      } else if (crudType !== "view") {
-        graphql2 = UPDATE_DOCUMENT_GQL;
-      }
+      const graphql2 = getEditorialWorkflowMutation(crudType);
       const collection = tinaApi.schema.getCollectionByFullPath(path);
       let submittedValues = values;
       if ((_a = collection == null ? void 0 : collection.ui) == null ? void 0 : _a.beforeSubmit) {
@@ -15905,7 +16258,7 @@ function useEditorialWorkflow() {
       const result = await tinaApi.executeEditorialWorkflow({
         branchName,
         baseBranch,
-        prTitle: `${branchName.replace("tina/", "").replace("-", " ")} (PR from TinaCMS)`,
+        prTitle: getEditorialWorkflowPrTitle(branchName),
         graphQLContentOp: {
           query: graphql2,
           variables: {
@@ -15954,30 +16307,7 @@ function useEditorialWorkflow() {
       return true;
     } catch (e) {
       console.error(e);
-      let errMessage = "Branch operation failed. Talking to GitHub was unsuccessful, please try again. If the problem persists please contact support at https://tina.io/support 🦙";
-      const err = e;
-      if (err.errorCode) {
-        switch (err.errorCode) {
-          case EDITORIAL_WORKFLOW_ERROR.BRANCH_EXISTS:
-            errMessage = "A branch with this name already exists";
-            break;
-          case EDITORIAL_WORKFLOW_ERROR.BRANCH_HIERARCHY_CONFLICT:
-            errMessage = err.message || "Branch name conflicts with an existing branch";
-            break;
-          case EDITORIAL_WORKFLOW_ERROR.VALIDATION_FAILED:
-            errMessage = err.message || "Invalid branch name";
-            break;
-          default:
-            errMessage = err.message || errMessage;
-            break;
-        }
-      } else if (err.message) {
-        if (err.message.toLowerCase().includes("already exists")) {
-          errMessage = "A branch with this name already exists";
-        } else if (err.message.toLowerCase().includes("conflict")) {
-          errMessage = err.message;
-        }
-      }
+      const errMessage = getEditorialWorkflowErrorMessage(e);
       setErrorMessage(errMessage);
       setIsExecuting(false);
       setCurrentStep(0);
@@ -16065,6 +16395,18 @@ const WorkflowProgressIndicator = ({
     "Learn more about Editorial Workflow"
   ));
 };
+const EditorialWorkflowProgressModal = ({
+  title,
+  currentStep,
+  elapsedTime
+}) => /* @__PURE__ */ React.createElement(Modal, { className: "flex" }, /* @__PURE__ */ React.createElement(PopupModal, { className: "w-auto" }, /* @__PURE__ */ React.createElement(ModalHeader, null, title), /* @__PURE__ */ React.createElement(ModalBody, { padded: true }, /* @__PURE__ */ React.createElement(
+  WorkflowProgressIndicator,
+  {
+    currentStep,
+    isExecuting: true,
+    elapsedTime
+  }
+))));
 const formatDefaultBranchName = (filePath, crudType) => {
   let result = filePath;
   const contentPrefix = "content/";
@@ -16096,6 +16438,7 @@ const CreateBranchModal = ({
     formatDefaultBranchName(path, crudType)
   );
   const [isBranchGuardChecking, setIsBranchGuardChecking] = React.useState(false);
+  const branchGuardAbortRef = React.useRef(null);
   const {
     isExecuting,
     errorMessage,
@@ -16104,27 +16447,35 @@ const CreateBranchModal = ({
     executeWorkflow,
     reset
   } = useEditorialWorkflow();
+  const abortBranchGuard = React.useCallback(() => {
+    var _a;
+    (_a = branchGuardAbortRef.current) == null ? void 0 : _a.abort();
+    branchGuardAbortRef.current = null;
+    setIsBranchGuardChecking(false);
+  }, []);
+  React.useEffect(() => {
+    return () => {
+      var _a;
+      (_a = branchGuardAbortRef.current) == null ? void 0 : _a.abort();
+    };
+  }, []);
   const executeEditorialWorkflow = async () => {
+    abortBranchGuard();
+    const abortController = new AbortController();
+    branchGuardAbortRef.current = abortController;
     setIsBranchGuardChecking(true);
     const baseBranch = decodeURIComponent(tinaApi.branch);
-    let baseBranchExists = true;
-    try {
-      console.debug(
-        "[tina:branch-guard] executeEditorialWorkflow: checking base branch:",
-        baseBranch
-      );
-      baseBranchExists = await tinaApi.branchExists(baseBranch);
-    } catch (err) {
-      console.error(
-        "[tina:branch-guard] executeEditorialWorkflow: branchExists threw, failing open:",
-        err
-      );
-    }
-    console.debug(
-      "[tina:branch-guard] executeEditorialWorkflow: base branch exists?",
-      baseBranchExists
+    const targetBranch = `tina/${newBranchName}`;
+    const baseBranchExists = await checkBaseBranchExists(
+      tinaApi,
+      baseBranch,
+      "executeEditorialWorkflow",
+      abortController.signal
     );
+    if (abortController.signal.aborted)
+      return;
     if (!baseBranchExists) {
+      abortBranchGuard();
       console.debug(
         "[tina:branch-guard] executeEditorialWorkflow: base branch deleted — handing off"
       );
@@ -16133,52 +16484,84 @@ const CreateBranchModal = ({
     }
     setIsBranchGuardChecking(false);
     const success = await executeWorkflow({
-      branchName: `tina/${newBranchName}`,
+      branchName: targetBranch,
       baseBranch,
       path,
       values,
       crudType,
-      tinaForm
+      tinaForm,
+      signal: abortController.signal
     });
+    if (branchGuardAbortRef.current === abortController) {
+      branchGuardAbortRef.current = null;
+    }
     if (success) {
       close2();
     }
   };
-  const renderStateContent = () => {
-    if (isExecuting) {
-      return /* @__PURE__ */ React.createElement(
-        WorkflowProgressIndicator,
-        {
-          currentStep,
-          isExecuting,
-          elapsedTime
-        }
-      );
-    } else {
-      return /* @__PURE__ */ React.createElement("div", { className: "max-w-sm" }, errorMessage && /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-1 text-red-700 py-2 px-3 mb-4 bg-red-50 border border-red-200 rounded" }, /* @__PURE__ */ React.createElement(BiError, { className: "w-5 h-auto text-red-400 flex-shrink-0" }), /* @__PURE__ */ React.createElement("span", { className: "text-sm" }, /* @__PURE__ */ React.createElement("b", null, "Error:"), " ", errorMessage)), /* @__PURE__ */ React.createElement("p", { className: "text-lg text-gray-700 font-bold mb-2" }, "First, let's create a copy"), /* @__PURE__ */ React.createElement("p", { className: "text-sm text-gray-700 mb-4 max-w-sm" }, "To make changes, you need to create a copy then get it approved and merged for it to go live.", /* @__PURE__ */ React.createElement("br", null), /* @__PURE__ */ React.createElement("br", null), /* @__PURE__ */ React.createElement("span", { className: "text-gray-500" }, "Learn more about "), /* @__PURE__ */ React.createElement(
-        "a",
-        {
-          className: "underline text-tina-orange-dark font-medium",
-          href: "https://tina.io/docs/r/editorial-workflow",
-          target: "_blank"
-        },
-        "Editorial Workflow"
-      ), "."), /* @__PURE__ */ React.createElement(
-        PrefixedTextField,
-        {
-          name: "new-branch-name",
-          label: "Branch Name",
-          placeholder: "e.g. {{PAGE-NAME}}-updates",
-          value: newBranchName,
-          onChange: (e) => {
-            reset();
-            setNewBranchName(e.target.value);
-          }
-        }
-      ));
+  if (isExecuting) {
+    return /* @__PURE__ */ React.createElement(
+      EditorialWorkflowProgressModal,
+      {
+        title: "Save changes to new branch",
+        currentStep,
+        elapsedTime
+      }
+    );
+  }
+  return /* @__PURE__ */ React.createElement(
+    CreateBranchPromptModal,
+    {
+      branchName: newBranchName,
+      close: () => {
+        abortBranchGuard();
+        close2();
+      },
+      errorMessage,
+      disabled: newBranchName === "" || isBranchGuardChecking,
+      onBranchNameChange: (value) => {
+        abortBranchGuard();
+        reset();
+        setNewBranchName(value);
+      },
+      onCreateBranch: executeEditorialWorkflow,
+      onSaveToProtectedBranch: () => {
+        abortBranchGuard();
+        close2();
+        safeSubmit();
+      }
     }
-  };
-  return /* @__PURE__ */ React.createElement(Modal, { className: "flex" }, /* @__PURE__ */ React.createElement(PopupModal, { className: "w-auto" }, /* @__PURE__ */ React.createElement(ModalHeader, { close: isExecuting ? void 0 : close2 }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center justify-between w-full" }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center" }, "Save changes to new branch"))), /* @__PURE__ */ React.createElement(ModalBody, { padded: true }, renderStateContent()), !isExecuting && /* @__PURE__ */ React.createElement(ModalActions, { align: "end" }, /* @__PURE__ */ React.createElement(
+  );
+};
+const CreateBranchPromptModal = ({
+  branchName,
+  close: close2,
+  disabled,
+  errorMessage,
+  onBranchNameChange,
+  onCreateBranch,
+  onSaveToProtectedBranch
+}) => {
+  return /* @__PURE__ */ React.createElement(Modal, { className: "flex" }, /* @__PURE__ */ React.createElement(PopupModal, { className: "w-auto" }, /* @__PURE__ */ React.createElement(ModalHeader, { close: close2 }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center justify-between w-full" }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center" }, "Save changes to new branch"))), /* @__PURE__ */ React.createElement(ModalBody, { padded: true }, /* @__PURE__ */ React.createElement("div", { className: "max-w-sm" }, errorMessage && /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-1 text-red-700 py-2 px-3 mb-4 bg-red-50 border border-red-200 rounded" }, /* @__PURE__ */ React.createElement(BiError, { className: "w-5 h-auto text-red-400 flex-shrink-0" }), /* @__PURE__ */ React.createElement("span", { className: "text-sm" }, /* @__PURE__ */ React.createElement("b", null, "Error:"), " ", errorMessage)), /* @__PURE__ */ React.createElement("p", { className: "text-lg text-gray-700 font-bold mb-2" }, "First, let's create a copy"), /* @__PURE__ */ React.createElement("p", { className: "text-sm text-gray-700 mb-4 max-w-sm" }, "To make changes, you need to create a copy then get it approved and merged for it to go live.", /* @__PURE__ */ React.createElement("br", null), /* @__PURE__ */ React.createElement("br", null), /* @__PURE__ */ React.createElement("span", { className: "text-gray-500" }, "Learn more about "), /* @__PURE__ */ React.createElement(
+    "a",
+    {
+      className: "underline text-tina-orange-dark font-medium",
+      href: "https://tina.io/docs/r/editorial-workflow",
+      target: "_blank"
+    },
+    "Editorial Workflow"
+  ), "."), /* @__PURE__ */ React.createElement(
+    PrefixedTextField,
+    {
+      name: "new-branch-name",
+      label: "Branch Name",
+      placeholder: "e.g. {{PAGE-NAME}}-updates",
+      value: branchName,
+      onChange: (e) => {
+        onBranchNameChange(e.target.value);
+      }
+    }
+  ))), /* @__PURE__ */ React.createElement(ModalActions, { align: "end" }, /* @__PURE__ */ React.createElement(
     Button$2,
     {
       variant: "secondary",
@@ -16192,26 +16575,17 @@ const CreateBranchModal = ({
       variant: "primary",
       align: "start",
       className: "w-full sm:w-auto",
-      disabled: newBranchName === "" || isBranchGuardChecking,
-      onMainAction: executeEditorialWorkflow,
+      disabled,
+      onMainAction: onCreateBranch,
       items: [
         {
           label: "Save to Protected Branch",
-          onClick: () => {
-            close2();
-            safeSubmit();
-          },
+          onClick: onSaveToProtectedBranch,
           icon: /* @__PURE__ */ React.createElement(TriangleAlert, { className: "w-4 h-4" })
         }
       ]
     },
-    /* @__PURE__ */ React.createElement(
-      GitBranchIcon,
-      {
-        className: "w-4 h-4 mr-1",
-        style: { fill: "none" }
-      }
-    ),
+    /* @__PURE__ */ React.createElement(GitBranchIcon, { className: "w-4 h-4 mr-1", style: { fill: "none" } }),
     "Save to a new branch"
   ))));
 };
@@ -69994,6 +70368,191 @@ function useLocalStorage(key, initialValue) {
   };
   return [storedValue, setValue];
 }
+const MediaWorkflowOverlay = () => {
+  const cms = useCMS$1();
+  const { setCurrentBranch } = useBranchData();
+  const [state, setState] = React.useState({ phase: "idle" });
+  const preflightAbortRef = React.useRef(null);
+  const abortPreflight = React.useCallback(() => {
+    var _a;
+    (_a = preflightAbortRef.current) == null ? void 0 : _a.abort();
+    preflightAbortRef.current = null;
+  }, []);
+  React.useEffect(() => {
+    const offConfirm = cms.events.subscribe(
+      "media:workflow:confirm-branch",
+      (event) => {
+        abortPreflight();
+        setState({
+          phase: "confirming",
+          branchName: event.branchName,
+          baseBranch: event.baseBranch,
+          onConfirm: event.onConfirm,
+          onCancel: event.onCancel,
+          onSaveToProtectedBranch: event.onSaveToProtectedBranch
+        });
+      }
+    );
+    const offStart = cms.events.subscribe("media:workflow:start", () => {
+      setState({ phase: "executing", step: 1, elapsed: 0 });
+    });
+    const offStep = cms.events.subscribe(
+      "media:workflow:step",
+      (event) => {
+        setState(
+          (prev) => prev.phase === "executing" ? { ...prev, step: event.step } : { phase: "executing", step: event.step, elapsed: 0 }
+        );
+      }
+    );
+    const offComplete = cms.events.subscribe("media:workflow:complete", (event) => {
+      setCurrentBranch(event.branchName);
+    });
+    const offError = cms.events.subscribe(
+      "media:workflow:error",
+      (event) => {
+        setState({ phase: "error", message: event.message });
+      }
+    );
+    const offFinish = cms.events.subscribe("media:workflow:finish", () => {
+      setState({ phase: "idle" });
+    });
+    return () => {
+      offConfirm();
+      offStart();
+      offStep();
+      offComplete();
+      offError();
+      offFinish();
+      abortPreflight();
+    };
+  }, [abortPreflight, cms, setCurrentBranch]);
+  React.useEffect(() => {
+    if (state.phase !== "executing")
+      return;
+    const interval = setInterval(() => {
+      setState(
+        (prev) => prev.phase === "executing" ? { ...prev, elapsed: prev.elapsed + 1 } : prev
+      );
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [state.phase]);
+  const handleCreateBranch = async () => {
+    if (state.phase !== "confirming")
+      return;
+    const confirmState = state;
+    const branchName = confirmState.branchName;
+    const targetBranch = `tina/${branchName}`;
+    abortPreflight();
+    const abortController = new AbortController();
+    preflightAbortRef.current = abortController;
+    setState({
+      ...confirmState,
+      isChecking: true,
+      errorMessage: ""
+    });
+    const baseBranchExists = await checkBaseBranchExists(
+      cms.api.tina,
+      confirmState.baseBranch,
+      "media workflow",
+      abortController.signal
+    );
+    if (abortController.signal.aborted)
+      return;
+    if (!baseBranchExists) {
+      if (preflightAbortRef.current === abortController) {
+        preflightAbortRef.current = null;
+      }
+      setState({
+        ...confirmState,
+        branchName,
+        isChecking: false,
+        errorMessage: `The branch ${confirmState.baseBranch} no longer exists. It may have been merged or deleted. Your changes cannot be pushed to it.`
+      });
+      return;
+    }
+    const targetBranchExists = await checkTargetBranchExists(
+      cms.api.tina,
+      targetBranch,
+      "media workflow",
+      abortController.signal
+    );
+    if (abortController.signal.aborted)
+      return;
+    if (targetBranchExists) {
+      if (preflightAbortRef.current === abortController) {
+        preflightAbortRef.current = null;
+      }
+      setState({
+        ...confirmState,
+        branchName,
+        isChecking: false,
+        errorMessage: TARGET_BRANCH_EXISTS_ERROR
+      });
+      return;
+    }
+    try {
+      if (preflightAbortRef.current === abortController) {
+        preflightAbortRef.current = null;
+      }
+      setState({ phase: "executing", step: 1, elapsed: 0 });
+      await confirmState.onConfirm(targetBranch);
+    } catch (e) {
+      console.error(e);
+      setState({
+        ...confirmState,
+        branchName,
+        isChecking: false,
+        errorMessage: getEditorialWorkflowErrorMessage(e)
+      });
+    }
+  };
+  if (state.phase === "idle")
+    return null;
+  if (state.phase === "confirming") {
+    return /* @__PURE__ */ React.createElement(
+      CreateBranchPromptModal,
+      {
+        branchName: state.branchName,
+        close: () => {
+          abortPreflight();
+          state.onCancel();
+          setState({ phase: "idle" });
+        },
+        disabled: state.branchName === "" || state.isChecking,
+        errorMessage: state.errorMessage,
+        onBranchNameChange: (branchName) => {
+          abortPreflight();
+          setState(
+            (prev) => prev.phase === "confirming" ? {
+              ...prev,
+              branchName,
+              errorMessage: void 0,
+              isChecking: false
+            } : prev
+          );
+        },
+        onCreateBranch: handleCreateBranch,
+        onSaveToProtectedBranch: () => {
+          abortPreflight();
+          state.onSaveToProtectedBranch();
+          setState({ phase: "idle" });
+        }
+      }
+    );
+  }
+  if (state.phase === "executing") {
+    return /* @__PURE__ */ React.createElement(
+      EditorialWorkflowProgressModal,
+      {
+        title: "Save changes to new branch",
+        currentStep: state.step,
+        elapsedTime: state.elapsed
+      }
+    );
+  }
+  const dismissError = () => setState({ phase: "idle" });
+  return /* @__PURE__ */ React.createElement(Modal, { className: "flex" }, /* @__PURE__ */ React.createElement(PopupModal, { className: "w-auto" }, /* @__PURE__ */ React.createElement(ModalHeader, { close: dismissError }, "Branch creation failed"), /* @__PURE__ */ React.createElement(ModalBody, { padded: true }, /* @__PURE__ */ React.createElement("div", { className: "flex items-center gap-1 text-red-700 py-2 px-3 bg-red-50 border border-red-200 rounded max-w-sm" }, /* @__PURE__ */ React.createElement(BiError, { className: "w-5 h-auto text-red-400 flex-shrink-0" }), /* @__PURE__ */ React.createElement("span", { className: "text-sm" }, /* @__PURE__ */ React.createElement("b", null, "Error:"), " ", state.message)))));
+};
 function asyncPoll(fn, pollInterval = 5 * 1e3, pollTimeout = 30 * 1e3) {
   const endTime = (/* @__PURE__ */ new Date()).getTime() + pollTimeout;
   let stop = false;
@@ -70553,7 +71112,7 @@ mutation addPendingDocumentMutation(
         }
       });
       if (!res.ok) {
-        let errorMessage = `There was an error creating a new branch. ${res.statusText}`;
+        let errorMessage = `There was an error creating a pull request. ${res.statusText}`;
         if (res.status === 422) {
           errorMessage = `Please make sure you have made changes on ${branch} before creating a pull request.`;
         }
@@ -70562,7 +71121,7 @@ mutation addPendingDocumentMutation(
       const values = await res.json();
       return values;
     } catch (error2) {
-      console.error("There was an error creating a new branch.", error2);
+      console.error("There was an error creating a pull request.", error2);
       throw error2;
     }
   }
@@ -70659,7 +71218,8 @@ mutation addPendingDocumentMutation(
     try {
       const url = `${this.contentApiBase}/github/${this.clientId}/list_branches`;
       const res = await this.authProvider.fetchWithToken(url, {
-        method: "GET"
+        method: "GET",
+        signal: args == null ? void 0 : args.signal
       });
       const branches = await res.json();
       const parsedBranches = await ListBranchResponse.parseAsync(branches);
@@ -70685,10 +71245,13 @@ mutation addPendingDocumentMutation(
     var _a;
     return this.usingEditorialWorkflow && ((_a = this.protectedBranches) == null ? void 0 : _a.includes(decodeURIComponent(this.branch)));
   }
-  async branchExists(branchName) {
+  async branchExists(branchName, args) {
     if (this.isLocalMode)
       return true;
-    const branches = await this.listBranches({ includeIndexStatus: false });
+    const branches = await this.listBranches({
+      includeIndexStatus: false,
+      signal: args == null ? void 0 : args.signal
+    });
     return branches.some((b) => b.name === branchName);
   }
   async createBranch({ baseBranch, branchName }) {
@@ -70732,6 +71295,89 @@ mutation addPendingDocumentMutation(
       throw error2;
     }
   }
+  async pollEditorialWorkflowStatus(requestId, onStatusUpdate) {
+    const pollInterval = 5e3;
+    const maxAttempts = 180;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      attempts++;
+      try {
+        const statusUrl = `${this.contentApiBase}/editorial-workflow/${this.clientId}/status/${requestId}`;
+        const statusResponse = await this.authProvider.fetchWithToken(statusUrl);
+        const statusResponseBody = await statusResponse.json();
+        onStatusUpdate == null ? void 0 : onStatusUpdate({
+          status: statusResponseBody.status,
+          message: statusResponseBody.message || `Status: ${statusResponseBody.status}`
+        });
+        if (statusResponseBody.status === EDITORIAL_WORKFLOW_STATUS.ERROR || statusResponse.status === 500) {
+          if (statusResponseBody.pullRequestUrl) {
+            return {
+              branchName: statusResponseBody.branchName,
+              pullRequestUrl: statusResponseBody.pullRequestUrl,
+              warning: statusResponseBody.message
+            };
+          }
+          const error2 = new Error(
+            statusResponseBody.message || "Editorial workflow failed"
+          );
+          error2.errorCode = statusResponseBody.errorCode || "WORKFLOW_FAILED";
+          throw error2;
+        }
+        if (statusResponse.status === 200) {
+          return {
+            branchName: statusResponseBody.branchName,
+            pullRequestUrl: statusResponseBody.pullRequestUrl
+          };
+        }
+        if (statusResponse.status !== 202) {
+          const error2 = new Error(
+            statusResponseBody.message || `Failed to check workflow status: ${statusResponse.statusText}`
+          );
+          error2.errorCode = "WORKFLOW_STATUS_FAILED";
+          throw error2;
+        }
+      } catch (error2) {
+        if (error2.errorCode) {
+          throw error2;
+        }
+        console.warn(
+          `Editorial workflow status poll failed (attempt ${attempts}/${maxAttempts}), retrying...`,
+          error2
+        );
+      }
+    }
+    const timeoutMinutes = Math.round(maxAttempts * pollInterval / 6e4);
+    throw new Error(
+      `Editorial workflow timed out after ${timeoutMinutes} minutes. It may still be completing in the background — please wait before retrying.`
+    );
+  }
+  toEditorialWorkflowError(responseBody, fallbackMessage) {
+    const error2 = new Error(
+      (responseBody == null ? void 0 : responseBody.message) || fallbackMessage
+    );
+    if (responseBody == null ? void 0 : responseBody.errorCode) {
+      error2.errorCode = responseBody.errorCode;
+    }
+    if (responseBody == null ? void 0 : responseBody.conflictingBranch) {
+      error2.conflictingBranch = responseBody.conflictingBranch;
+    }
+    return error2;
+  }
+  async postEditorialWorkflow(url, body, errorFallback) {
+    const res = await this.authProvider.fetchWithToken(url, {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    const responseBody = await res.json();
+    if (!res.ok) {
+      throw this.toEditorialWorkflowError(responseBody, errorFallback);
+    }
+    return responseBody;
+  }
   /**
    * Initiate and poll for the results of an editorial workflow operation
    *
@@ -70741,32 +71387,16 @@ mutation addPendingDocumentMutation(
   async executeEditorialWorkflow(options) {
     const url = `${this.contentApiBase}/editorial-workflow/${this.clientId}`;
     try {
-      const res = await this.authProvider.fetchWithToken(url, {
-        method: "POST",
-        body: JSON.stringify({
+      const responseBody = await this.postEditorialWorkflow(
+        url,
+        {
           branchName: options.branchName,
           baseBranch: options.baseBranch,
           prTitle: options.prTitle,
           graphQLContentOp: options.graphQLContentOp
-        }),
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      const responseBody = await res.json();
-      if (!res.ok) {
-        console.error("There was an error starting editorial workflow.");
-        const error2 = new Error(
-          (responseBody == null ? void 0 : responseBody.message) || "Failed to start editorial workflow"
-        );
-        if (responseBody == null ? void 0 : responseBody.errorCode) {
-          error2.errorCode = responseBody.errorCode;
-        }
-        if (responseBody == null ? void 0 : responseBody.conflictingBranch) {
-          error2.conflictingBranch = responseBody.conflictingBranch;
-        }
-        throw error2;
-      }
+        },
+        "Failed to start editorial workflow"
+      );
       const requestId = responseBody.requestId;
       if (!requestId) {
         return responseBody;
@@ -70777,60 +71407,10 @@ mutation addPendingDocumentMutation(
           message: "Workflow queued, starting..."
         });
       }
-      const maxAttempts = 60;
-      const pollInterval = 5e3;
-      let attempts = 0;
-      while (attempts < maxAttempts) {
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-        attempts++;
-        try {
-          const statusUrl = `${this.contentApiBase}/editorial-workflow/${this.clientId}/status/${requestId}`;
-          const statusResponse = await this.authProvider.fetchWithToken(statusUrl);
-          const statusResponseBody = await statusResponse.json();
-          if (options.onStatusUpdate) {
-            options.onStatusUpdate({
-              status: statusResponseBody.status,
-              message: statusResponseBody.message || `Status: ${statusResponseBody.status}`
-            });
-          }
-          if (statusResponseBody.status === EDITORIAL_WORKFLOW_STATUS.ERROR || statusResponse.status === 500) {
-            if (statusResponseBody.pullRequestUrl) {
-              return {
-                branchName: statusResponseBody.branchName,
-                pullRequestUrl: statusResponseBody.pullRequestUrl,
-                warning: statusResponseBody.message
-              };
-            }
-            const error2 = new Error(
-              statusResponseBody.message || "Editorial workflow failed"
-            );
-            error2.errorCode = statusResponseBody.errorCode || "WORKFLOW_FAILED";
-            throw error2;
-          }
-          if (statusResponse.status === 200) {
-            return {
-              branchName: statusResponseBody.branchName,
-              pullRequestUrl: statusResponseBody.pullRequestUrl
-            };
-          }
-          if (statusResponse.status !== 202) {
-            const error2 = new Error(
-              statusResponseBody.message || `Failed to check workflow status: ${statusResponse.statusText}`
-            );
-            error2.errorCode = "WORKFLOW_STATUS_FAILED";
-            throw error2;
-          }
-        } catch (error2) {
-          if (error2.errorCode) {
-            throw error2;
-          }
-          console.warn(
-            `Editorial workflow status poll failed (attempt ${attempts}/${maxAttempts}), retrying...`,
-            error2
-          );
-        }
-      }
-      throw new Error("Editorial workflow timed out after 5 minutes");
+      return await this.pollEditorialWorkflowStatus(
+        requestId,
+        options.onStatusUpdate
+      );
     } catch (error2) {
       console.error(
         "There was an error with editorial workflow operation.",
@@ -70839,6 +71419,17 @@ mutation addPendingDocumentMutation(
       throw error2;
     }
   }
+  async startMediaEditorialWorkflow(options) {
+    const url = `${this.contentApiBase}/editorial-workflow/${this.clientId}/media`;
+    return await this.postEditorialWorkflow(
+      url,
+      options,
+      "Failed to start media editorial workflow"
+    );
+  }
+  async waitForEditorialWorkflowStatus(requestId, onStatusUpdate) {
+    return await this.pollEditorialWorkflowStatus(requestId, onStatusUpdate);
+  }
 }
 const DEFAULT_LOCAL_TINA_GQL_SERVER_URL = "http://localhost:4001/graphql";
 class LocalClient extends Client {
@@ -71392,7 +71983,7 @@ const TinaCloudProvider = (props) => {
   }, []);
   React__default.useEffect(() => {
     const setupEditorialWorkflow = () => {
-      client.getProject().then((project) => {
+      client.getProject().then(async (project) => {
         var _a2;
         if ((_a2 = project == null ? void 0 : project.features) == null ? void 0 : _a2.includes("editorial-workflow")) {
           cms.flags.set("branch-switcher", true);
@@ -71422,7 +72013,7 @@ const TinaCloudProvider = (props) => {
         setCurrentBranch(b);
       }
     },
-    /* @__PURE__ */ React__default.createElement(TinaProvider, { cms }, /* @__PURE__ */ React__default.createElement(AuthWallInner, { ...props, cms }))
+    /* @__PURE__ */ React__default.createElement(TinaProvider, { cms }, /* @__PURE__ */ React__default.createElement(MediaWorkflowOverlay, null), /* @__PURE__ */ React__default.createElement(AuthWallInner, { ...props, cms }))
   ));
 };
 const TinaCloudAuthWall = TinaCloudProvider;
@@ -74457,6 +75048,7 @@ export {
   ColorPicker,
   CreateBranchModal,
   CreateBranchModel,
+  CreateBranchPromptModal,
   CursorPaginator,
   DEFAULT_LOCAL_TINA_GQL_SERVER_URL,
   DEFAULT_MEDIA_UPLOAD_TYPES,
@@ -74535,6 +75127,7 @@ export {
   MediaIcon,
   MediaListError,
   MediaManager$1 as MediaManager,
+  MediaWorkflowOverlay,
   Message,
   Modal,
   ModalActions,