@uniformdev/cli 20.74.6-alpha.6 → 20.74.7-alpha.14.sha-79426f9415

package/dist/index.mjs

@@ -3,13 +3,11 @@ import {
   CLI_USER_AGENT,
   __require,
   applyDefaultSyncConfiguration,
-  chunkEntityIds,
   emitWithFormat,
   exitOnCliError,
   getDirectoryOrFilename,
   getEntityBatchSize,
   getEntityOption,
-  getPublishScope,
   isPaginatedSyncEntity,
   isPathAPackageFile,
   maskApiKey,
@@ -25,7 +23,7 @@ import {
   withFormatOptions,
   withProjectOptions,
   withTeamOptions
-} from "./chunk-RXRK6OF5.mjs";
+} from "./chunk-4FPNEXON.mjs";
 
 // src/index.ts
 import * as dotenv from "dotenv";
@@ -288,6 +286,11 @@ var ENVIRONMENT_HOSTS = {
     api: "https://eu.uniform.app",
     global: "https://eu.uniform.global",
     ai: "https://ai.eu.uniform.global"
+  },
+  eu2: {
+    api: "https://eu2.uniform.app",
+    global: "https://eu2.uniform.global",
+    ai: "https://ai.eu2.uniform.global"
   }
 };
 async function selectEnvironment(explicitParams) {
@@ -307,6 +310,10 @@ async function selectEnvironment(explicitParams) {
         {
           name: "EU (eu.uniform.app)",
           value: "eu"
+        },
+        {
+          name: "EU2 (eu2.uniform.app)",
+          value: "eu2"
         }
       ],
       default: "usa"
@@ -872,7 +879,6 @@ async function syncEngine({
           await target.writeObject(finalSourceObject, targetObject2);
           status.changesApplied++;
         }
-        syncEngineEvents.emit("objectWritten", { id: ids[0], action: "update" });
       } catch (e) {
         if (onError) {
           onError(e, sourceObject2);
@@ -908,7 +914,6 @@ async function syncEngine({
             await target.writeObject(finalSourceObject);
             status.changesApplied++;
           }
-          syncEngineEvents.emit("objectWritten", { id, action: "create" });
         } catch (e) {
           if (onError) {
             onError(e, sourceObject2);
@@ -2745,9 +2750,32 @@ var writeResponseBodyToFile = async (response, filePath) => {
     throw error;
   }
 };
+var getFileMetadata = async ({
+  fileClient,
+  fileId,
+  fileUrl
+}) => {
+  if (fileId) {
+    const fileById = await fileClient.get({ id: fileId }).catch(() => null);
+    if (fileById) {
+      return fileById;
+    }
+  }
+  return fileClient.get({ url: fileUrl }).catch(() => null);
+};
+var logDownloadFailure = ({
+  fileUrl,
+  filePath,
+  status
+}) => {
+  console.warn(
+    `Failed to download file ${fileUrl} (HTTP status: ${status}; expected local path: ${filePath})`
+  );
+};
 var downloadFile = async ({
   fileClient,
   fileUrl,
+  fileId,
   directory
 }) => {
   const writeDirectory = getFilesDirectory(directory);
@@ -2756,14 +2784,10 @@ var downloadFile = async ({
   const filePath = join10(filesDirectory, fileName);
   const fileAlreadyExists = await fsj2.existsAsync(filePath);
   if (fileAlreadyExists) {
-    return { url: fileUrl };
-  }
-  const file = await fileClient.get({ url: fileUrl }).catch(() => null);
-  if (!file) {
-    console.warn(`Skipping file ${fileUrl} as it does not exist in the project anymore`);
-    return null;
+    return { id: fileId, url: fileUrl };
   }
-  if (file.sourceId) {
+  const file = await getFileMetadata({ fileClient, fileId, fileUrl });
+  if (file?.sourceId) {
     const sourceId = file.sourceId;
     try {
       const downloadedFilePaths = await getDownloadedFilePathCache(filesDirectory);
@@ -2774,17 +2798,36 @@ var downloadFile = async ({
     }
   }
   const fetchUrl = `${fileUrl}?format=original`;
-  const response = await fetch(fetchUrl);
+  const preserveWarningOnlyFailure = !file;
+  let response;
+  try {
+    response = await fetch(fetchUrl);
+  } catch (error) {
+    logDownloadFailure({ fileUrl, filePath, status: "unavailable" });
+    if (preserveWarningOnlyFailure) {
+      return null;
+    }
+    throw error;
+  }
   if (!response.ok) {
+    logDownloadFailure({ fileUrl, filePath, status: response.status });
     return null;
   }
-  await writeResponseBodyToFile(response, filePath);
+  try {
+    await writeResponseBodyToFile(response, filePath);
+  } catch (error) {
+    logDownloadFailure({ fileUrl, filePath, status: response.status });
+    if (preserveWarningOnlyFailure) {
+      return null;
+    }
+    throw error;
+  }
   const downloadedFilePathCache = downloadedFilePathCacheByDirectory.get(filesDirectory);
   if (downloadedFilePathCache) {
     const downloadedFilePaths = await downloadedFilePathCache;
     downloadedFilePaths.add(fileName);
   }
-  return { id: file.id, url: fileUrl };
+  return { id: file?.id ?? fileId, url: fileUrl };
 };
 
 // src/files/uploadFile.ts
@@ -2799,11 +2842,24 @@ import PQueue2 from "p-queue";
 import { join as join11 } from "path";
 var uploadQueueByKey = /* @__PURE__ */ new Map();
 var fileUploadQueue = new PQueue2({ concurrency: 10 });
+var IMAGE_SIZE_SAFE_MEDIA_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/apng",
+  "image/jpeg",
+  "image/jpg",
+  "image/jfif",
+  "image/pjpeg",
+  "image/pjp",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml"
+]);
 var uploadFile = async ({
   fileClient,
   fileUrl,
   directory,
-  fileId
+  fileId,
+  warnIfLocalCopyMissing = true
 }) => {
   const key = `${fileId}-${fileUrl}`;
   if (uploadQueueByKey.has(key)) {
@@ -2826,9 +2882,11 @@ var uploadFile = async ({
       const expectedFilePath = join11(writeDirectory, FILES_DIRECTORY_NAME, localFileName);
       const fileInspect = await fsj3.inspectAsync(expectedFilePath);
       if (fileInspect?.type !== "file") {
-        console.warn(
-          `Skipping file ${fileUrl} as we couldn't find a local copy (looked at ${expectedFilePath})`
-        );
+        if (warnIfLocalCopyMissing) {
+          console.warn(
+            `Skipping file ${fileUrl} as we couldn't find a local copy (looked at ${expectedFilePath})`
+          );
+        }
         return null;
       }
       const fileName = getFileNameFromUrl(fileUrl);
@@ -2860,7 +2918,7 @@ var uploadFile = async ({
         uploadBody = createReadStream(expectedFilePath);
       }
       const { width, height } = await (async () => {
-        if (!mimeType.startsWith("image/")) {
+        if (!IMAGE_SIZE_SAFE_MEDIA_TYPES.has(mimeType)) {
           return {
             width: void 0,
             height: void 0
@@ -2989,27 +3047,37 @@ var downloadFileForAsset = async ({
   directory,
   fileClient
 }) => {
-  if (asset.asset.fields?.file?.value === void 0 || asset.asset.fields.url?.value === void 0) {
+  const fields = asset.asset.fields;
+  if (!fields) {
     return null;
   }
-  const fileId = asset.asset.fields?.file?.value;
-  const fileUrl = asset.asset.fields.url?.value;
-  if (fileId === "" || fileUrl === "") {
+  const fileId = fields.file?.value;
+  if (!fileId) {
     return null;
   }
-  return downloadFile({ fileUrl, directory, fileClient });
+  const fileUrl = fields.url?.value;
+  if (!fileUrl) {
+    return null;
+  }
+  return downloadFile({ fileUrl, fileId, directory, fileClient });
 };
 var uploadFileForAsset = async ({
   asset,
   directory,
   fileClient
 }) => {
-  if (asset.asset.fields?.file?.value === void 0 || asset.asset.fields.url?.value === void 0) {
+  const fileId = asset.asset.fields?.file?.value;
+  const fileUrl = asset.asset.fields?.url?.value;
+  if (fileId === void 0 || !fileUrl) {
     return null;
   }
-  const fileUrl = asset.asset.fields.url.value;
-  const fileId = asset.asset.fields.file.value;
-  return uploadFile({ fileUrl, directory, fileClient, fileId });
+  return uploadFile({
+    fileUrl,
+    directory,
+    fileClient,
+    fileId,
+    warnIfLocalCopyMissing: false
+  });
 };
 var removeUrlsFromAssetParameters = (entity) => {
   const treeWalker = ({ node }) => {
@@ -3311,6 +3379,25 @@ function writeCanvasPackage(filename, packageContents) {
 
 // src/commands/canvas/commands/asset/pull.ts
 var ASSET_PULL_ACTION_CONCURRENCY = 10;
+var prepareAssetForPull = async ({
+  sourceObject,
+  directory,
+  fileClient
+}) => {
+  delete sourceObject.object.asset._author;
+  if (!sourceObject.object.asset.fields?.file) {
+    return sourceObject;
+  }
+  const downloadedFile = await downloadFileForAsset({
+    asset: sourceObject.object,
+    directory,
+    fileClient
+  });
+  if (downloadedFile?.id) {
+    sourceObject.object.asset.fields.file.value = downloadedFile.id;
+  }
+  return sourceObject;
+};
 var AssetPullModule = {
   command: "pull <directory>",
   describe: "Pulls all assets to local files in a directory",
@@ -3417,27 +3504,70 @@ var AssetPullModule = {
         return sourceObject;
       },
       compareContents: compareAssetsWithoutUrls,
-      onBeforeWriteObject: async (sourceObject) => {
-        delete sourceObject.object.asset._author;
-        if (!sourceObject.object.asset.fields?.file) {
-          return sourceObject;
-        }
-        const downloadedFile = await downloadFileForAsset({
-          asset: sourceObject.object,
-          directory,
-          fileClient
-        });
-        if (downloadedFile?.id) {
-          sourceObject.object.asset.fields.file.value = downloadedFile.id;
-        }
-        return sourceObject;
-      }
+      onBeforeWriteObject: (sourceObject) => prepareAssetForPull({
+        sourceObject,
+        directory,
+        fileClient
+      })
     });
   }
 };
 
 // src/commands/canvas/commands/asset/push.ts
+import { join as join13 } from "path";
 var ASSET_PUSH_ACTION_CONCURRENCY = 10;
+var getExpectedFilePath = (directory, fileUrl) => {
+  if (!fileUrl) {
+    return "Unavailable because the asset has no file URL";
+  }
+  try {
+    return join13(getFilesDirectory(directory), FILES_DIRECTORY_NAME, urlToFileName(fileUrl));
+  } catch {
+    return "Unavailable because the asset file URL is invalid";
+  }
+};
+var prepareAssetForPush = async ({
+  sourceObject,
+  directory,
+  fileClient,
+  targetProjectId
+}) => {
+  const fields = sourceObject.object.asset.fields;
+  const fileId = fields?.file?.value;
+  if (!fields || !fileId) {
+    return sourceObject;
+  }
+  const uploadedFile = await uploadFileForAsset({
+    asset: sourceObject.object,
+    directory,
+    fileClient
+  });
+  if (!uploadedFile) {
+    const assetId = sourceObject.object.asset._id;
+    const fileUrl = fields.url?.value;
+    const expectedFilePath = getExpectedFilePath(directory, fileUrl);
+    throw new Error(
+      [
+        `Unable to push asset "${sourceObject.displayName ?? assetId}" (${assetId}) because its file could not be uploaded.`,
+        `Source project ID: ${sourceObject.object.projectId ?? "Unavailable"}`,
+        `Target project ID: ${targetProjectId}`,
+        `File ID: ${fileId}`,
+        `File URL: ${fileUrl || "Missing"}`,
+        `Expected local path: ${expectedFilePath}`,
+        `Remove the asset with the ID ${assetId} before pushing again.`
+      ].join("\n")
+    );
+  }
+  fields.file = {
+    type: "file",
+    value: uploadedFile.id
+  };
+  fields.url = {
+    type: "text",
+    value: uploadedFile.url
+  };
+  return sourceObject;
+};
 var AssetPushModule = {
   command: "push <directory>",
   describe: "Pushes all assets from files in a directory to Uniform",
@@ -3523,27 +3653,12 @@ var AssetPushModule = {
         return sourceObject;
       },
       compareContents: compareAssetsWithoutUrls,
-      onBeforeWriteObject: async (sourceObject) => {
-        const uploadedFile = await uploadFileForAsset({
-          asset: sourceObject.object,
-          directory,
-          fileClient
-        });
-        if (uploadedFile !== null) {
-          if (sourceObject.object.asset.fields === void 0) {
-            sourceObject.object.asset.fields = {};
-          }
-          sourceObject.object.asset.fields.file = {
-            type: "file",
-            value: uploadedFile.id
-          };
-          sourceObject.object.asset.fields.url = {
-            type: "text",
-            value: uploadedFile.url
-          };
-        }
-        return sourceObject;
-      }
+      onBeforeWriteObject: (sourceObject) => prepareAssetForPush({
+        sourceObject,
+        directory,
+        fileClient,
+        targetProjectId: projectId
+      })
     });
   }
 };
@@ -4644,28 +4759,16 @@ var selectIdentifier3 = (response) => {
   }
   return baseId;
 };
+function parseCompositionSerializedId(providerId) {
+  const [compositionId, editionId] = providerId.split(" (");
+  return { compositionId, editionId: editionId?.slice(0, -1) };
+}
 var selectDisplayName3 = (component) => {
   const name = component.composition._name ?? component.composition._slug ?? component.composition._id;
   const edition = component.editionId ? component.editionName ?? component.editionId : void 0;
   return `${name} (pid: ${component.composition._id}${edition ? `, edition: ${edition}` : ""})`;
 };
 
-// src/commands/canvas/util/serializedIds.ts
-function parseSerializedId(serializedId) {
-  const [id, editionId] = serializedId.split(" (");
-  return { id, editionId: editionId?.slice(0, -1) };
-}
-function splitSerializedIds(ids) {
-  return ids.split(",").map((id) => id.trim()).filter(Boolean);
-}
-function toRawEntityIds(serializedIds) {
-  return Array.from(new Set(serializedIds.map(toRawEntityId)));
-}
-function toRawEntityId(serializedId) {
-  const { id, editionId } = parseSerializedId(serializedId);
-  return editionId ?? id;
-}
-
 // src/commands/canvas/componentInstanceEngineDataSource.ts
 function createComponentInstanceEngineDataSource({
   client,
@@ -4675,47 +4778,36 @@ function createComponentInstanceEngineDataSource({
   patternType,
   verbose,
   batchSize,
-  editions = "all",
   ...clientOptions
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    const pageSize = batchSize ?? 100;
-    for (const compositionIDsChunk of chunkEntityIds(clientOptions.compositionIDs)) {
-      const componentInstances = paginateAsync(
-        async (offset, limit2) => {
-          const parameters = {
-            ...clientOptions,
-            compositionIDs: compositionIDsChunk,
-            limit: limit2,
-            offset,
-            pattern: onlyCompositions ? false : onlyPatterns ? true : void 0,
-            state: stateId,
-            patternType,
-            editions
-          };
-          if (verbose) {
-            console.log(`\u{1F41B} pull compositions: `, parameters);
-          }
-          return (await client.list(parameters)).compositions;
-        },
-        {
-          pageSize,
-          verbose,
-          entityName: "compositions",
-          // a raw id resolves to exactly one row, so the chunk bounds the result
-          maxItems: editions === "raw" ? compositionIDsChunk?.length : void 0
-        }
-      );
-      for await (const compositionListItem of componentInstances) {
-        const result = {
-          id: selectIdentifier3(compositionListItem),
-          displayName: selectDisplayName3(compositionListItem),
-          providerId: selectIdentifier3(compositionListItem),
-          object: prepCompositionForDisk(compositionListItem)
+    const componentInstances = paginateAsync(
+      async (offset, limit2) => {
+        const parameters = {
+          ...clientOptions,
+          limit: limit2,
+          offset,
+          pattern: onlyCompositions ? false : onlyPatterns ? true : void 0,
+          state: stateId,
+          patternType,
+          editions: "all"
         };
-        yield result;
-      }
+        if (verbose) {
+          console.log(`\u{1F41B} pull compositions: `, parameters);
+        }
+        return (await client.list(parameters)).compositions;
+      },
+      { pageSize: batchSize ?? 100, verbose, entityName: "compositions" }
+    );
+    for await (const compositionListItem of componentInstances) {
+      const result = {
+        id: selectIdentifier3(compositionListItem),
+        displayName: selectDisplayName3(compositionListItem),
+        providerId: selectIdentifier3(compositionListItem),
+        object: prepCompositionForDisk(compositionListItem)
+      };
+      yield result;
     }
   }
   return {
@@ -4723,10 +4815,9 @@ function createComponentInstanceEngineDataSource({
     objects: getObjects(),
     deleteObject: async (providerId) => {
       if (verbose) {
-        console.log(`\u{1F41B} delete composition: (id: ${providerId})`);
+        console.log(`\u{1F41B} delete composition: (id: ${parseCompositionSerializedId(providerId)})`);
       }
-      const { id: compositionId, editionId } = parseSerializedId(providerId);
-      await client.remove({ compositionId, editionId });
+      await client.remove(parseCompositionSerializedId(providerId));
     },
     writeObject: async (object4) => {
       if (verbose) {
@@ -4791,23 +4882,29 @@ var CompositionPublishModule = {
       console.error(`Specify --all or composition ID(s) to publish.`);
       process.exit(1);
     }
-    const compositionIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const compositionIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getCompositionManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const createDataSource = (state) => createComponentInstanceEngineDataSource({
+    const source = createComponentInstanceEngineDataSource({
       client,
-      state,
-      compositionIDs,
-      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
-      editions: compositionIDs ? "raw" : "all",
+      state: "preview",
+      compositionIDs: compositionIDsArray,
+      onlyCompositions,
+      onlyPatterns,
+      patternType,
+      verbose,
+      batchSize: resolvedBatchSize
+    });
+    const target = createComponentInstanceEngineDataSource({
+      client,
+      state: "published",
+      compositionIDs: compositionIDsArray,
       onlyCompositions,
       onlyPatterns,
       patternType,
       verbose,
       batchSize: resolvedBatchSize
     });
-    const source = createDataSource("preview");
-    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -5364,7 +5461,7 @@ var CompositionUnpublishModule = {
       console.error(`Specify --all or composition ID(s) to unpublish.`);
       process.exit(1);
     }
-    const compositionIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const compositionIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getCompositionManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -5372,8 +5469,6 @@ var CompositionUnpublishModule = {
       client,
       state: "published",
       compositionIDs: compositionIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: compositionIDsArray ? "raw" : "all",
       onlyCompositions,
       onlyPatterns,
       patternType,
@@ -5384,8 +5479,6 @@ var CompositionUnpublishModule = {
       client,
       state: "preview",
       compositionIDs: compositionIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: compositionIDsArray ? "raw" : "all",
       onlyCompositions,
       onlyPatterns,
       patternType,
@@ -5412,9 +5505,8 @@ var CompositionUnpublishModule = {
         console.log(`Composition ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
-        const { id: compositionId } = parseSerializedId(id);
         actions.push(
-          client.unpublish({ compositionId, editionId: toRawEntityId(id) }).catch((err) => {
+          client.unpublish(parseCompositionSerializedId(id)).catch((err) => {
             const isNotFound = err instanceof ApiClientError && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -6695,6 +6787,10 @@ var selectEntryIdentifier = (e) => {
   }
   return baseId;
 };
+function parseEntrySerializedId(providerId) {
+  const [entryId, editionId] = providerId.split(" (");
+  return { entryId, editionId: editionId?.slice(0, -1) };
+}
 var selectEntryDisplayName = (e) => {
   const name = e.entry._name ?? "Untitled";
   const edition = e.editionId ? e.editionName ?? e.editionId : void 0;
@@ -6709,56 +6805,45 @@ function createEntryEngineDataSource({
   onlyPatterns,
   entryIDs,
   batchSize,
-  verbose,
-  editions = "all"
+  verbose
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    const pageSize = batchSize ?? 100;
-    for (const entryIDsChunk of chunkEntityIds(entryIDs)) {
-      const entries = paginateAsync(
-        async (offset, limit2) => {
-          try {
-            return (await client.list({
-              offset,
-              limit: limit2,
-              entryIDs: entryIDsChunk,
-              pattern: onlyEntries ? false : onlyPatterns ? true : void 0,
-              state: stateId,
-              editions
-            })).entries;
-          } catch (error) {
-            if (error instanceof ApiClientError2 && error.errorMessage?.startsWith("Entry not found")) {
-              return [];
-            }
-            throw error;
+    const entries = paginateAsync(
+      async (offset, limit2) => {
+        try {
+          return (await client.list({
+            offset,
+            limit: limit2,
+            entryIDs,
+            pattern: onlyEntries ? false : onlyPatterns ? true : void 0,
+            state: stateId,
+            editions: "all"
+          })).entries;
+        } catch (error) {
+          if (error instanceof ApiClientError2 && error.errorMessage === "Entry not found or not published") {
+            return [];
           }
-        },
-        {
-          pageSize,
-          verbose,
-          entityName: "entries",
-          // a raw id resolves to exactly one row, so the chunk bounds the result
-          maxItems: editions === "raw" ? entryIDsChunk?.length : void 0
+          throw error;
         }
-      );
-      for await (const e of entries) {
-        const result = {
-          id: selectEntryIdentifier(e),
-          displayName: selectEntryDisplayName(e),
-          providerId: selectEntryIdentifier(e),
-          object: prepCompositionForDisk(e)
-        };
-        yield result;
-      }
+      },
+      { pageSize: batchSize ?? 100, verbose, entityName: "entries" }
+    );
+    for await (const e of entries) {
+      const result = {
+        id: selectEntryIdentifier(e),
+        displayName: selectEntryDisplayName(e),
+        providerId: selectEntryIdentifier(e),
+        object: prepCompositionForDisk(e)
+      };
+      yield result;
     }
   }
   return {
     name: "Uniform API",
     objects: getObjects(),
     deleteObject: async (providerId) => {
-      const { id: entryId, editionId } = parseSerializedId(providerId);
-      await client.remove({ entryId, editionId });
+      await client.remove(parseEntrySerializedId(providerId));
     },
     writeObject: async ({ object: object4 }) => {
       await client.save({ ...convertEntryToPutEntry(object4), state: stateId });
@@ -6808,21 +6893,23 @@ var EntryPublishModule = {
       console.error(`Specify --all or entry ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const createDataSource = (state) => createEntryEngineDataSource({
+    const source = createEntryEngineDataSource({
       client,
-      state,
-      entryIDs,
-      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
-      editions: entryIDs ? "raw" : "all",
+      state: "preview",
+      entryIDs: entryIDsArray,
+      onlyEntries: true,
+      batchSize: resolvedBatchSize
+    });
+    const target = createEntryEngineDataSource({
+      client,
+      state: "published",
+      entryIDs: entryIDsArray,
       onlyEntries: true,
-      verbose,
       batchSize: resolvedBatchSize
     });
-    const source = createDataSource("preview");
-    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -7168,7 +7255,7 @@ var EntryUnpublishModule = {
       console.error(`Specify --all or entry ID(s) to unpublish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -7176,8 +7263,6 @@ var EntryUnpublishModule = {
       client,
       state: "published",
       entryIDs: entryIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: entryIDsArray ? "raw" : "all",
       onlyEntries: true,
       batchSize: resolvedBatchSize
     });
@@ -7185,8 +7270,6 @@ var EntryUnpublishModule = {
       client,
       state: "preview",
       entryIDs: entryIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: entryIDsArray ? "raw" : "all",
       onlyEntries: true,
       batchSize: resolvedBatchSize
     });
@@ -7210,9 +7293,8 @@ var EntryUnpublishModule = {
         console.log(`Entry ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
-        const { id: entryId } = parseSerializedId(id);
         actions.push(
-          client.unpublish({ entryId, editionId: toRawEntityId(id) }).catch((err) => {
+          client.unpublish(parseEntrySerializedId(id)).catch((err) => {
             const isNotFound = err instanceof ApiClientError3 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -7405,21 +7487,23 @@ var EntryPatternPublishModule = {
       console.error(`Specify --all or entry pattern ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const createDataSource = (state) => createEntryEngineDataSource({
+    const source = createEntryEngineDataSource({
       client,
-      state,
-      entryIDs,
-      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
-      editions: entryIDs ? "raw" : "all",
+      state: "preview",
+      entryIDs: entryIDsArray,
+      onlyPatterns: true,
+      batchSize: resolvedBatchSize
+    });
+    const target = createEntryEngineDataSource({
+      client,
+      state: "published",
+      entryIDs: entryIDsArray,
       onlyPatterns: true,
-      verbose,
       batchSize: resolvedBatchSize
     });
-    const source = createDataSource("preview");
-    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -7739,7 +7823,7 @@ var EntryPatternUnpublishModule = {
       console.error(`Specify --all or entry pattern ID(s) to unpublish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
+    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -7747,8 +7831,6 @@ var EntryPatternUnpublishModule = {
       client,
       state: "published",
       entryIDs: entryIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: entryIDsArray ? "raw" : "all",
       onlyPatterns: true,
       batchSize: resolvedBatchSize
     });
@@ -7756,8 +7838,6 @@ var EntryPatternUnpublishModule = {
       client,
       state: "preview",
       entryIDs: entryIDsArray,
-      // matched exactly as publish matches them, so the two stay inverses
-      editions: entryIDsArray ? "raw" : "all",
       onlyPatterns: true,
       batchSize: resolvedBatchSize
     });
@@ -7781,9 +7861,8 @@ var EntryPatternUnpublishModule = {
         console.log(`Entry pattern ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
-        const { id: entryId } = parseSerializedId(id);
         actions.push(
-          client.unpublish({ entryId, editionId: toRawEntityId(id) }).catch((err) => {
+          client.unpublish(parseEntrySerializedId(id)).catch((err) => {
             const isNotFound = err instanceof ApiClientError4 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -12109,7 +12188,7 @@ var PolicyDocumentsPullModule = {
 // src/commands/policy-documents/commands/push.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import { extname as extname3, join as join13 } from "path";
+import { extname as extname3, join as join14 } from "path";
 async function readLocalPolicyDocuments(directory, format, verbose) {
   const files = await readdir2(directory);
   const policyDocuments = {};
@@ -12119,7 +12198,7 @@ async function readLocalPolicyDocuments(directory, format, verbose) {
     if (ext !== `.${format}` && ext !== ".yaml" && ext !== ".yml" && ext !== ".json") {
       continue;
     }
-    const filePath = join13(directory, filename);
+    const filePath = join14(directory, filename);
     try {
       let roleId = filename.replace(ext, "");
       const fileContent = readFileToObject(filePath);
@@ -13556,7 +13635,7 @@ var WebhookPullModule = {
 // src/commands/sync/commands/util.ts
 import ora2 from "ora";
 async function spinPromise(action, options) {
-  const { failText } = options;
+  const { successText, failText } = typeof options === "object" ? options : { successText: void 0, failText: void 0 };
   const spinner = ora2(options).start();
   const consoleReplay = [];
   const revertLog = patchConsole({
@@ -13594,7 +13673,6 @@ async function spinPromise(action, options) {
   process.on("SIGINT", executeReplayOnSigint);
   try {
     const result = await action;
-    const successText = typeof options.successText === "function" ? options.successText(result) : options.successText;
     const finalStatusText = spinner.text.startsWith(options.text) && spinner.text.length > options.text.length ? spinner.text.slice(options.text.length).trim() : `\u2699\uFE0F compared: ${numPad(0)} changes: 0`;
     const padding = " ".repeat(Math.max(4, 40 - successText.length));
     spinner.succeed(successText + padding + finalStatusText);
@@ -13876,115 +13954,160 @@ var SyncPushModule = {
         "No entities were configured to be pushed. Please make sure you have configuration file and at least one entity type is enabled."
       );
     }
-    const publishScopes = /* @__PURE__ */ new Map();
-    for (const { entityType } of publishableEntities) {
+    for (const [entityType, module] of enabledEntities) {
       try {
-        publishScopes.set(entityType, getPublishScope(entityType, config2));
-      } catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
+        await spinPromise(
+          module.handler({
+            ...otherParams,
+            state: 0,
+            format: getFormat2(entityType, config2),
+            onlyCompositions: entityType === "composition" ? true : void 0,
+            onlyPatterns: ["pattern", "componentPattern", "compositionPattern"].includes(entityType) ? true : void 0,
+            patternType: entityType === "compositionPattern" ? "composition" : entityType === "componentPattern" ? "component" : void 0,
+            mode: getPushMode(entityType, config2),
+            directory: getPushFilename(entityType, config2),
+            allowEmptySource: config2.allowEmptySource,
+            ...isPaginatedSyncEntity(entityType) ? { resolvedBatchSize: getEntityBatchSize(entityType, config2) } : {}
+          }),
+          {
+            text: `${entityType}...`,
+            successText: entityType,
+            failText(error) {
+              return `${entityType}
+
+ ${error.stack ?? error.message}`;
+            }
+          }
+        );
+      } catch {
         process.exit(1);
       }
     }
-    const pushedIds = /* @__PURE__ */ new Map();
-    for (const [entityType, module] of enabledEntities) {
-      const written = [];
-      const recordWrite = ({ id }) => written.push(id);
-      syncEngineEvents.on("objectWritten", recordWrite);
-      pushedIds.set(entityType, written);
-      await runStep({
-        text: `${entityType}...`,
-        successText: entityType,
-        failLabel: entityType,
-        run: () => module.handler({
-          ...otherParams,
-          state: 0,
-          format: getFormat2(entityType, config2),
-          ...getEntityDiscriminators(entityType),
-          mode: getPushMode(entityType, config2),
-          directory: getPushFilename(entityType, config2),
-          allowEmptySource: config2.allowEmptySource,
-          ...isPaginatedSyncEntity(entityType) ? { resolvedBatchSize: getEntityBatchSize(entityType, config2) } : {}
-        })
-      });
-      syncEngineEvents.off("objectWritten", recordWrite);
-    }
-    for (const { entityType, module, label } of publishableEntities) {
-      const entityConfig = config2.entitiesConfig?.[entityType];
-      const scope = publishScopes.get(entityType);
-      if (entityConfig?.disabled === true || entityConfig?.push?.disabled === true || !scope) {
-        continue;
+    if (config2.entitiesConfig?.componentPattern && config2.entitiesConfig?.componentPattern?.push?.disabled !== true && config2.entitiesConfig?.componentPattern?.publish) {
+      try {
+        await spinPromise(
+          ComponentPatternPublishModule.handler({
+            ...otherParams,
+            serialization: config2,
+            patternType: "component",
+            onlyPatterns: true,
+            all: true,
+            directory: getPushFilename("componentPattern", config2),
+            resolvedBatchSize: getEntityBatchSize("componentPattern", config2)
+          }),
+          {
+            text: "publishing component patterns...",
+            successText: "published component patterns",
+            failText(error) {
+              return `publishing component patterns
+
+ ${error.stack ?? error.message}`;
+            }
+          }
+        );
+      } catch {
+        process.exit(1);
       }
-      const directory = getPushFilename(entityType, config2);
-      await runStep({
-        text: `publishing ${label}...`,
-        // a push that changed nothing is not an error, but it must not read as "published" either
-        successText: (outcome) => outcome.skippedReason ? `skipped ${label}: ${outcome.skippedReason}` : `published ${label}`,
-        failLabel: `publishing ${label}`,
-        run: async () => {
-          if (otherParams.whatIf) {
-            return { skippedReason: "what-if run did not write preview" };
+    }
+    if (config2.entitiesConfig?.compositionPattern && config2.entitiesConfig?.compositionPattern?.push?.disabled !== true && config2.entitiesConfig?.compositionPattern?.publish) {
+      try {
+        await spinPromise(
+          CompositionPatternPublishModule.handler({
+            ...otherParams,
+            serialization: config2,
+            all: true,
+            onlyPatterns: true,
+            patternType: "composition",
+            directory: getPushFilename("compositionPattern", config2),
+            resolvedBatchSize: getEntityBatchSize("compositionPattern", config2)
+          }),
+          {
+            text: "publishing composition patterns...",
+            successText: "published composition patterns",
+            failText(error) {
+              return `publishing composition patterns
+
+ ${error.stack ?? error.message}`;
+            }
           }
-          let ids;
-          if (scope === "pushed") {
-            const written = pushedIds.get(entityType) ?? [];
-            if (written.length === 0) {
-              return { skippedReason: "nothing was pushed" };
+        );
+      } catch {
+        process.exit(1);
+      }
+    }
+    if (config2.entitiesConfig?.composition && config2.entitiesConfig?.composition?.push?.disabled !== true && config2.entitiesConfig?.composition?.publish) {
+      try {
+        await spinPromise(
+          CompositionPublishModule.handler({
+            ...otherParams,
+            serialization: config2,
+            all: true,
+            onlyCompositions: true,
+            directory: getPushFilename("composition", config2),
+            resolvedBatchSize: getEntityBatchSize("composition", config2)
+          }),
+          {
+            text: "publishing compositions...",
+            successText: "published compositions",
+            failText(error) {
+              return `publishing compositions
+
+ ${error.stack ?? error.message}`;
             }
-            ids = written.join(",");
           }
-          await module.handler({
+        );
+      } catch {
+        process.exit(1);
+      }
+    }
+    if (config2.entitiesConfig?.entry && config2.entitiesConfig?.entry?.push?.disabled !== true && config2.entitiesConfig?.entry?.publish) {
+      try {
+        await spinPromise(
+          EntryPublishModule.handler({
             ...otherParams,
             serialization: config2,
-            all: scope === "all",
-            ids,
-            ...getEntityDiscriminators(entityType),
-            directory,
-            resolvedBatchSize: getEntityBatchSize(entityType, config2)
-          });
-          return {};
-        }
-      });
+            all: true,
+            directory: getPushFilename("entry", config2),
+            resolvedBatchSize: getEntityBatchSize("entry", config2)
+          }),
+          {
+            text: "publishing entries...",
+            successText: "published entries",
+            failText(error) {
+              return `publishing entries
+
+ ${error.stack ?? error.message}`;
+            }
+          }
+        );
+      } catch {
+        process.exit(1);
+      }
     }
-  }
-};
-var publishableEntities = [
-  {
-    entityType: "componentPattern",
-    module: ComponentPatternPublishModule,
-    label: "component patterns"
-  },
-  {
-    entityType: "compositionPattern",
-    module: CompositionPatternPublishModule,
-    label: "composition patterns"
-  },
-  { entityType: "composition", module: CompositionPublishModule, label: "compositions" },
-  { entityType: "entry", module: EntryPublishModule, label: "entries" },
-  { entityType: "entryPattern", module: EntryPatternPublishModule, label: "entry patterns" }
-];
-var getEntityDiscriminators = (entityType) => ({
-  onlyCompositions: entityType === "composition" ? true : void 0,
-  onlyPatterns: ["pattern", "componentPattern", "compositionPattern"].includes(entityType) ? true : void 0,
-  patternType: entityType === "compositionPattern" ? "composition" : entityType === "componentPattern" ? "component" : void 0
-});
-var runStep = async ({
-  text,
-  successText,
-  failLabel,
-  run
-}) => {
-  try {
-    await spinPromise(run(), {
-      text,
-      successText,
-      failText(error) {
-        return `${failLabel}
+    if (config2.entitiesConfig?.entryPattern && config2.entitiesConfig?.entryPattern?.push?.disabled !== true && config2.entitiesConfig?.entryPattern?.publish) {
+      try {
+        await spinPromise(
+          EntryPatternPublishModule.handler({
+            ...otherParams,
+            serialization: config2,
+            all: true,
+            directory: getPushFilename("entryPattern", config2),
+            resolvedBatchSize: getEntityBatchSize("entryPattern", config2)
+          }),
+          {
+            text: "publishing entry patterns...",
+            successText: "published entry patterns",
+            failText(error) {
+              return `publishing entry patterns
 
  ${error.stack ?? error.message}`;
+            }
+          }
+        );
+      } catch {
+        process.exit(1);
       }
-    });
-  } catch {
-    process.exit(1);
+    }
   }
 };
 var getPushMode = (entityType, config2) => {
@@ -14083,14 +14206,14 @@ import { existsSync as existsSync9, promises as fs8 } from "fs";
 import { get as getHttp } from "http";
 import { get as getHttps } from "https";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import registryUrl from "registry-url";
 import { URL as URL2 } from "url";
 var compareVersions = (a, b) => a.localeCompare(b, "en-US", { numeric: true });
 var encode = (value) => encodeURIComponent(value).replace(/^%40/, "@");
 var getFile = async (details, distTag) => {
   const rootDir = tmpdir2();
-  const subDir = join14(rootDir, "update-check");
+  const subDir = join15(rootDir, "update-check");
   if (!existsSync9(subDir)) {
     await fs8.mkdir(subDir);
   }
@@ -14098,7 +14221,7 @@ var getFile = async (details, distTag) => {
   if (details.scope) {
     name = `${details.scope}-${name}`;
   }
-  return join14(subDir, name);
+  return join15(subDir, name);
 };
 var evaluateCache = async (file, time, interval) => {
   if (existsSync9(file)) {
@@ -14253,7 +14376,7 @@ var checkForUpdateMiddleware = async ({ verbose }) => {
 
 // src/middleware/checkLocalDepsVersionsMiddleware.ts
 import { magenta, red as red8 } from "colorette";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var uniformStrictVersions = [
   "@uniformdev/canvas",
   "@uniformdev/canvas-next",
@@ -14275,7 +14398,7 @@ var checkLocalDepsVersions = async (args) => {
   try {
     let isOutside = false;
     let warning = `${magenta("Warning:")} Installed Uniform packages should be the same version`;
-    const localPackages = await tryReadJSON(join15(process.cwd(), "package.json"));
+    const localPackages = await tryReadJSON(join16(process.cwd(), "package.json"));
     if (!localPackages) return;
     let firstVersion;
     const allDependencies = {