@uniformdev/cli 20.79.1 → 20.79.2-alpha.19.sha-0b10e12c18

package/dist/{chunk-QGXYDPOL.mjs → chunk-OTHXZ5BE.mjs}

@@ -409,23 +409,41 @@ function readFileToObject(filename) {
   const file = readFileSync(filename, "utf8");
   return load(file, { filename, json: true });
 }
+var ENTITY_ID_CHUNK_SIZE = 100;
+function* chunkEntityIds(ids, chunkSize = ENTITY_ID_CHUNK_SIZE) {
+  if (!ids) {
+    yield void 0;
+    return;
+  }
+  for (let index = 0; index < ids.length; index += chunkSize) {
+    yield ids.slice(index, index + chunkSize);
+  }
+}
 async function* paginateAsync(fetchPage, options) {
   const pageSize = options.pageSize ?? 100;
   if (pageSize < 1) {
     throw new Error(`pageSize must be at least 1, got ${pageSize}`);
   }
+  const { maxItems } = options;
   let offset = 0;
+  let yielded = 0;
+  let limit = pageSize;
   let pageData = [];
   do {
+    limit = maxItems === void 0 ? pageSize : Math.min(pageSize, maxItems - yielded);
+    if (limit < 1) {
+      return;
+    }
     if (options.verbose) {
-      console.log(`Fetching ${options.entityName ?? "items"} batch: offset=${offset}, pageSize=${pageSize}`);
+      console.log(`Fetching ${options.entityName ?? "items"} batch: offset=${offset}, pageSize=${limit}`);
     }
-    pageData = await fetchPage(offset, pageSize);
+    pageData = await fetchPage(offset, limit);
     for (const item of pageData) {
       yield item;
     }
-    offset += pageSize;
-  } while (pageData.length === pageSize);
+    yielded += pageData.length;
+    offset += limit;
+  } while (pageData.length === limit);
 }
 var entityBatchSizeDefaults = {
   composition: 100,
@@ -461,6 +479,21 @@ function getEntityBatchSize(entityType, config) {
   }
   return entityBatchSizeDefaults[entityType];
 }
+function getPublishScope(entityType, config) {
+  const publish = config.entitiesConfig?.[entityType]?.publish;
+  if (!publish) {
+    return void 0;
+  }
+  if (publish === true || publish === "all") {
+    return "all";
+  }
+  if (publish === "pushed") {
+    return "pushed";
+  }
+  throw new Error(
+    `Invalid publish option '${publish}' for ${entityType}. Expected true, false, 'all', or 'pushed'.`
+  );
+}
 function resolveEntityBatchSize({
   entityType,
   cliBatchSize,
@@ -572,9 +605,11 @@ export {
   isPathAPackageFile,
   emitWithFormat,
   readFileToObject,
+  chunkEntityIds,
   paginateAsync,
   isPaginatedSyncEntity,
   getEntityBatchSize,
+  getPublishScope,
   withBatchSizeOptions,
   applyDefaultSyncConfiguration,
   getEntityOption,

package/dist/defaultConfig.d.mts

@@ -1,4 +1,4 @@
-import { C as CLIConfiguration, E as EntityTypes } from './index-DeoTNXj-.mjs';
+import { C as CLIConfiguration, E as EntityTypes } from './index-FdhH3tn0.mjs';
 
 type UniformConfigAllOptions = {
     /**

package/dist/defaultConfig.mjs

@@ -1,4 +1,4 @@
-import "./chunk-QGXYDPOL.mjs";
+import "./chunk-OTHXZ5BE.mjs";
 
 // src/sync/allSerializableEntitiesConfig.ts
 var allSerializableEntitiesConfig = {
@@ -11,11 +11,11 @@ var allSerializableEntitiesConfig = {
   projectMapDefinition: {},
   projectMapNode: {},
   contentType: {},
-  composition: { publish: true },
-  entry: { publish: true },
-  entryPattern: { publish: true },
-  componentPattern: { publish: true },
-  compositionPattern: { publish: true },
+  composition: { publish: "all" },
+  entry: { publish: "all" },
+  entryPattern: { publish: "all" },
+  componentPattern: { publish: "all" },
+  compositionPattern: { publish: "all" },
   asset: {},
   workflow: {},
   webhook: {},

package/dist/{index-DeoTNXj-.d.mts → index-FdhH3tn0.d.mts}

@@ -13,8 +13,21 @@ type EntityConfiguration = {
     disabled?: true;
 };
 type EntityWithStateConfiguration = EntityConfiguration & Partial<StateArgs>;
+/**
+ * What a push should publish once it has written its entities to preview.
+ *
+ * - `all`: publish every entity of this type in the project that has unpublished changes, whether or
+ *   not it came from the push source. This is what `publish: true` has always done.
+ * - `pushed`: publish only the entities this run actually created or updated. This is narrower than
+ *   "everything in the push source": an entity whose preview copy already matches the source is not
+ *   written, so it is not published either. A run that changes nothing therefore publishes nothing,
+ *   which also means a failed publish is not retried by re-running an unchanged push. Use `all` when
+ *   the publish set needs to converge on its own.
+ */
+type PublishScope = 'all' | 'pushed';
 type PublishableEntitiesConfiguration = EntityWithStateConfiguration & {
-    publish?: boolean;
+    /** `true` is an alias for `'all'`, kept for backwards compatibility. */
+    publish?: boolean | PublishScope;
     batchSize?: number;
 };
 type SerializationEntitiesConfiguration = Record<EntityTypes, {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { C as CLIConfiguration } from './index-DeoTNXj-.mjs';
+export { C as CLIConfiguration } from './index-FdhH3tn0.mjs';

package/dist/index.mjs

@@ -3,11 +3,13 @@ import {
   CLI_USER_AGENT,
   __require,
   applyDefaultSyncConfiguration,
+  chunkEntityIds,
   emitWithFormat,
   exitOnCliError,
   getDirectoryOrFilename,
   getEntityBatchSize,
   getEntityOption,
+  getPublishScope,
   isPaginatedSyncEntity,
   isPathAPackageFile,
   maskApiKey,
@@ -23,7 +25,7 @@ import {
   withFormatOptions,
   withProjectOptions,
   withTeamOptions
-} from "./chunk-QGXYDPOL.mjs";
+} from "./chunk-OTHXZ5BE.mjs";
 
 // src/index.ts
 import * as dotenv from "dotenv";
@@ -818,10 +820,12 @@ async function syncEngine({
   onBeforeCompareObjects,
   onBeforeWriteObject,
   onError,
-  actionConcurrency
+  actionConcurrency,
+  selectWriteWave
   //verbose = false,
 }) {
   const status = new ReactiveStatusUpdate((status2) => syncEngineEvents.emit("statusUpdate", status2));
+  const selectWave = (sourceObject) => selectWriteWave?.(sourceObject) ?? 0;
   const targetItems = /* @__PURE__ */ new Map();
   const deleteTracker = /* @__PURE__ */ new Set();
   const processDelete = async (object4) => {
@@ -879,6 +883,7 @@ 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);
@@ -902,7 +907,10 @@ async function syncEngine({
       if (!compareResult) {
         if (mode === "createOrUpdate" || mode === "mirror") {
           status.changeCount++;
-          actions.push(() => processUpdate(sourceObject, targetObject));
+          actions.push({
+            wave: selectWave(sourceObject),
+            run: () => processUpdate(sourceObject, targetObject)
+          });
         }
       }
       processedIds.forEach((i) => targetItems.delete(i));
@@ -914,6 +922,7 @@ async function syncEngine({
             await target.writeObject(finalSourceObject);
             status.changesApplied++;
           }
+          syncEngineEvents.emit("objectWritten", { id, action: "create" });
         } catch (e) {
           if (onError) {
             onError(e, sourceObject2);
@@ -938,7 +947,10 @@ async function syncEngine({
           const compareResult = compareContents(sourceObject, matchedTargetObject);
           if (!compareResult) {
             status.changeCount++;
-            actions.push(() => processUpdate(sourceObject, matchedTargetObject));
+            actions.push({
+              wave: selectWave(sourceObject),
+              run: () => processUpdate(sourceObject, matchedTargetObject)
+            });
           }
           (Array.isArray(matchedTargetObject.id) ? matchedTargetObject.id : [matchedTargetObject.id]).forEach(
             (i) => targetItems.delete(i)
@@ -958,15 +970,21 @@ async function syncEngine({
         if (targetObject) {
           deletes.push(() => processDelete(targetObject));
         }
-        actions.push(async () => {
-          for (const deleteFn of deletes) {
-            await deleteFn();
+        actions.push({
+          wave: selectWave(sourceObject),
+          run: async () => {
+            for (const deleteFn of deletes) {
+              await deleteFn();
+            }
+            await processUpsert(sourceObject, ids[0]);
           }
-          await processUpsert(sourceObject, ids[0]);
         });
       } else {
         status.changeCount++;
-        actions.push(() => processUpsert(sourceObject, ids[0]));
+        actions.push({
+          wave: selectWave(sourceObject),
+          run: () => processUpsert(sourceObject, ids[0])
+        });
       }
     }
   }
@@ -985,9 +1003,27 @@ async function syncEngine({
     });
     await runSyncActions(deletes, actionConcurrency);
   }
-  await runSyncActions(actions, actionConcurrency);
+  await runSyncWriteWaves(actions, actionConcurrency);
   await Promise.all([source.onSyncComplete?.(false), target.onSyncComplete?.(true)]);
 }
+var runSyncWriteWaves = async (actions, actionConcurrency) => {
+  if (actions.length === 0) {
+    return;
+  }
+  const waves = /* @__PURE__ */ new Map();
+  for (const { wave, run } of actions) {
+    const waveActions = waves.get(wave);
+    if (waveActions) {
+      waveActions.push(run);
+    } else {
+      waves.set(wave, [run]);
+    }
+  }
+  const orderedWaves = Array.from(waves.entries()).sort(([first], [second]) => first - second);
+  for (const [, waveActions] of orderedWaves) {
+    await runSyncActions(waveActions, actionConcurrency);
+  }
+};
 var runSyncActions = async (actions, actionConcurrency) => {
   if (actions.length === 0) {
     return;
@@ -2692,6 +2728,7 @@ var deleteDownloadedFileByUrl = async (url, options) => {
 };
 
 // src/files/files.ts
+import { selectWritableAssetFields } from "@uniformdev/assets";
 import {
   ASSETS_SOURCE_UNIFORM,
   getPropertiesValue as getPropertiesValue2,
@@ -3148,17 +3185,15 @@ var compareCompositionsOrEntriesWithoutAssetUrlsForPublishing = (source, target)
   }
   return compareCompositionsOrEntriesWithoutAssetUrls(source, target);
 };
-var removeUrlFromAsset = (asset) => {
-  if (asset.asset.fields?.url?.value) {
-    asset.asset.fields.url.value = "";
-  }
-  return asset;
-};
+var selectComparableAsset = ({ asset }) => ({
+  _id: asset._id,
+  _name: asset._name,
+  _dataResources: asset._dataResources,
+  labels: asset.labels,
+  fields: selectWritableAssetFields(asset.fields)
+});
 var compareAssetsWithoutUrls = (source, target) => {
-  return serializedDequal(
-    removeUrlFromAsset(structuredClone(source.object)),
-    removeUrlFromAsset(structuredClone(target.object))
-  );
+  return serializedDequal(selectComparableAsset(source.object), selectComparableAsset(target.object));
 };
 var downloadFilesForCompositionOrEntry = async ({
   entity,
@@ -4759,16 +4794,28 @@ 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,
@@ -4778,36 +4825,47 @@ function createComponentInstanceEngineDataSource({
   patternType,
   verbose,
   batchSize,
+  editions = "all",
   ...clientOptions
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    const componentInstances = paginateAsync(
-      async (offset, limit2) => {
-        const parameters = {
-          ...clientOptions,
-          limit: limit2,
-          offset,
-          pattern: onlyCompositions ? false : onlyPatterns ? true : void 0,
-          state: stateId,
-          patternType,
-          editions: "all"
-        };
-        if (verbose) {
-          console.log(`\u{1F41B} pull compositions: `, parameters);
+    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
         }
-        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;
+      );
+      for await (const compositionListItem of componentInstances) {
+        const result = {
+          id: selectIdentifier3(compositionListItem),
+          displayName: selectDisplayName3(compositionListItem),
+          providerId: selectIdentifier3(compositionListItem),
+          object: prepCompositionForDisk(compositionListItem)
+        };
+        yield result;
+      }
     }
   }
   return {
@@ -4815,9 +4873,10 @@ function createComponentInstanceEngineDataSource({
     objects: getObjects(),
     deleteObject: async (providerId) => {
       if (verbose) {
-        console.log(`\u{1F41B} delete composition: (id: ${parseCompositionSerializedId(providerId)})`);
+        console.log(`\u{1F41B} delete composition: (id: ${providerId})`);
       }
-      await client.remove(parseCompositionSerializedId(providerId));
+      const { id: compositionId, editionId } = parseSerializedId(providerId);
+      await client.remove({ compositionId, editionId });
     },
     writeObject: async (object4) => {
       if (verbose) {
@@ -4882,29 +4941,23 @@ var CompositionPublishModule = {
       console.error(`Specify --all or composition ID(s) to publish.`);
       process.exit(1);
     }
-    const compositionIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const compositionIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getCompositionManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const source = createComponentInstanceEngineDataSource({
+    const createDataSource = (state) => createComponentInstanceEngineDataSource({
       client,
-      state: "preview",
-      compositionIDs: compositionIDsArray,
-      onlyCompositions,
-      onlyPatterns,
-      patternType,
-      verbose,
-      batchSize: resolvedBatchSize
-    });
-    const target = createComponentInstanceEngineDataSource({
-      client,
-      state: "published",
-      compositionIDs: compositionIDsArray,
+      state,
+      compositionIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: compositionIDs ? "raw" : "all",
       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,
@@ -5461,7 +5514,7 @@ var CompositionUnpublishModule = {
       console.error(`Specify --all or composition ID(s) to unpublish.`);
       process.exit(1);
     }
-    const compositionIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const compositionIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getCompositionManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -5469,6 +5522,8 @@ 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,
@@ -5479,6 +5534,8 @@ 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,
@@ -5505,8 +5562,9 @@ var CompositionUnpublishModule = {
         console.log(`Composition ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
+        const { id: compositionId } = parseSerializedId(id);
         actions.push(
-          client.unpublish(parseCompositionSerializedId(id)).catch((err) => {
+          client.unpublish({ compositionId, editionId: toRawEntityId(id) }).catch((err) => {
             const isNotFound = err instanceof ApiClientError && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -6787,10 +6845,6 @@ 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;
@@ -6805,45 +6859,56 @@ function createEntryEngineDataSource({
   onlyPatterns,
   entryIDs,
   batchSize,
-  verbose
+  verbose,
+  editions = "all"
 }) {
   const stateId = convertStateOption(state);
   async function* getObjects() {
-    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 [];
+    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;
           }
-          throw error;
+        },
+        {
+          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
         }
-      },
-      { 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;
+      );
+      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) => {
-      await client.remove(parseEntrySerializedId(providerId));
+      const { id: entryId, editionId } = parseSerializedId(providerId);
+      await client.remove({ entryId, editionId });
     },
     writeObject: async ({ object: object4 }) => {
       await client.save({ ...convertEntryToPutEntry(object4), state: stateId });
@@ -6893,23 +6958,21 @@ var EntryPublishModule = {
       console.error(`Specify --all or entry ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const source = createEntryEngineDataSource({
+    const createDataSource = (state) => createEntryEngineDataSource({
       client,
-      state: "preview",
-      entryIDs: entryIDsArray,
-      onlyEntries: true,
-      batchSize: resolvedBatchSize
-    });
-    const target = createEntryEngineDataSource({
-      client,
-      state: "published",
-      entryIDs: entryIDsArray,
+      state,
+      entryIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: entryIDs ? "raw" : "all",
       onlyEntries: true,
+      verbose,
       batchSize: resolvedBatchSize
     });
+    const source = createDataSource("preview");
+    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -7255,7 +7318,7 @@ var EntryUnpublishModule = {
       console.error(`Specify --all or entry ID(s) to unpublish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -7263,6 +7326,8 @@ 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
     });
@@ -7270,6 +7335,8 @@ 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
     });
@@ -7293,8 +7360,9 @@ var EntryUnpublishModule = {
         console.log(`Entry ${id} did not have a draft (removing published)`);
       }
       if (!whatIf) {
+        const { id: entryId } = parseSerializedId(id);
         actions.push(
-          client.unpublish(parseEntrySerializedId(id)).catch((err) => {
+          client.unpublish({ entryId, editionId: toRawEntityId(id) }).catch((err) => {
             const isNotFound = err instanceof ApiClientError3 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -7487,23 +7555,21 @@ var EntryPatternPublishModule = {
       console.error(`Specify --all or entry pattern ID(s) to publish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDs = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
-    const source = createEntryEngineDataSource({
-      client,
-      state: "preview",
-      entryIDs: entryIDsArray,
-      onlyPatterns: true,
-      batchSize: resolvedBatchSize
-    });
-    const target = createEntryEngineDataSource({
+    const createDataSource = (state) => createEntryEngineDataSource({
       client,
-      state: "published",
-      entryIDs: entryIDsArray,
+      state,
+      entryIDs,
+      // ids name exact entities or editions; resolving editions would publish siblings nobody asked for
+      editions: entryIDs ? "raw" : "all",
       onlyPatterns: true,
+      verbose,
       batchSize: resolvedBatchSize
     });
+    const source = createDataSource("preview");
+    const target = createDataSource("published");
     const fileClient = getFileClient({ apiKey, apiHost, fetch: fetch2, projectId });
     await syncEngine({
       source,
@@ -7823,7 +7889,7 @@ var EntryPatternUnpublishModule = {
       console.error(`Specify --all or entry pattern ID(s) to unpublish.`);
       process.exit(1);
     }
-    const entryIDsArray = ids ? ids.split(",").map((id) => id.trim()) : void 0;
+    const entryIDsArray = ids ? toRawEntityIds(splitSerializedIds(ids)) : void 0;
     const targetItems = /* @__PURE__ */ new Map();
     const fetch2 = nodeFetchProxy(proxy, verbose);
     const client = getEntryManagementClient({ apiKey, apiHost, fetch: fetch2, projectId });
@@ -7831,6 +7897,8 @@ 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
     });
@@ -7838,6 +7906,8 @@ 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
     });
@@ -7861,8 +7931,9 @@ 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(parseEntrySerializedId(id)).catch((err) => {
+          client.unpublish({ entryId, editionId: toRawEntityId(id) }).catch((err) => {
             const isNotFound = err instanceof ApiClientError4 && err.statusCode === 404;
             if (isNotFound) {
               console.warn(
@@ -12722,6 +12793,7 @@ var selectIdentifier15 = (source, projectId) => [
   projectId + source.projectMapId + source.id,
   projectId + source.projectMapId + source.path
 ];
+var selectNodeDepth = (source) => source.path.split("/").filter((segment) => segment.length > 0).length;
 var selectFilename = (source) => cleanFileName(`${source.pathSegment}_${source.id}`);
 var selectDisplayName15 = (source) => `${source.name} (pid: ${source.id})`;
 function alignProjectMapNodeWithTargetIdentifier(sourceObject, targetObject) {
@@ -12928,7 +13000,7 @@ var ProjectMapNodePushModule = {
       source = await createArraySyncEngineDataSource({
         name: `Package file ${directory}`,
         objects: packageContents.projectMapNodes.sort((a, b) => {
-          return a.path.length - b.path.length;
+          return selectNodeDepth(a) - selectNodeDepth(b);
         }) ?? [],
         selectIdentifier: expandedSelectIdentifier,
         selectDisplayName: selectDisplayName15
@@ -12954,6 +13026,9 @@ var ProjectMapNodePushModule = {
         whatIf,
         allowEmptySource,
         log: createSyncEngineConsoleLogger({ diffMode }),
+        // Writes land parent-first: every node at one depth is written before any deeper node
+        // starts, so a moved subtree's descendants are recomputed from the parent's new path.
+        selectWriteWave: (sourceObject) => selectNodeDepth(sourceObject.object),
         onBeforeCompareObjects: async (sourceObject, targetObject) => {
           return alignProjectMapNodeWithTargetIdentifier(sourceObject, targetObject);
         },
@@ -13633,7 +13708,7 @@ var WebhookPullModule = {
 // src/commands/sync/commands/util.ts
 import ora2 from "ora";
 async function spinPromise(action, options) {
-  const { successText, failText } = typeof options === "object" ? options : { successText: void 0, failText: void 0 };
+  const { failText } = options;
   const spinner = ora2(options).start();
   const consoleReplay = [];
   const revertLog = patchConsole({
@@ -13671,6 +13746,7 @@ 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);
@@ -13952,160 +14028,115 @@ var SyncPushModule = {
         "No entities were configured to be pushed. Please make sure you have configuration file and at least one entity type is enabled."
       );
     }
-    for (const [entityType, module] of enabledEntities) {
+    const publishScopes = /* @__PURE__ */ new Map();
+    for (const { entityType } of publishableEntities) {
       try {
-        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 {
+        publishScopes.set(entityType, getPublishScope(entityType, config2));
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
         process.exit(1);
       }
     }
-    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 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);
     }
-    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}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
+    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?.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}`;
-            }
+      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" };
           }
-        );
-      } 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: true,
-            directory: getPushFilename("entry", config2),
-            resolvedBatchSize: getEntityBatchSize("entry", config2)
-          }),
-          {
-            text: "publishing entries...",
-            successText: "published entries",
-            failText(error) {
-              return `publishing entries
-
- ${error.stack ?? error.message}`;
+          let ids;
+          if (scope === "pushed") {
+            const written = pushedIds.get(entityType) ?? [];
+            if (written.length === 0) {
+              return { skippedReason: "nothing was pushed" };
             }
+            ids = written.join(",");
           }
-        );
-      } catch {
-        process.exit(1);
-      }
-    }
-    if (config2.entitiesConfig?.entryPattern && config2.entitiesConfig?.entryPattern?.push?.disabled !== true && config2.entitiesConfig?.entryPattern?.publish) {
-      try {
-        await spinPromise(
-          EntryPatternPublishModule.handler({
+          await module.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
+            all: scope === "all",
+            ids,
+            ...getEntityDiscriminators(entityType),
+            directory,
+            resolvedBatchSize: getEntityBatchSize(entityType, config2)
+          });
+          return {};
+        }
+      });
+    }
+  }
+};
+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}
 
  ${error.stack ?? error.message}`;
-            }
-          }
-        );
-      } catch {
-        process.exit(1);
       }
-    }
+    });
+  } catch {
+    process.exit(1);
   }
 };
 var getPushMode = (entityType, config2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/cli",
-  "version": "20.79.1",
+  "version": "20.79.2-alpha.19.sha-0b10e12c18",
   "description": "Uniform command line interface tool",
   "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./cli.js",
@@ -27,14 +27,14 @@
   "dependencies": {
     "@inquirer/prompts": "^8.5.2",
     "@thi.ng/mime": "^2.2.23",
-    "@uniformdev/assets": "20.79.1",
-    "@uniformdev/automations-sdk": "20.79.1",
-    "@uniformdev/canvas": "20.79.1",
-    "@uniformdev/context": "20.79.1",
-    "@uniformdev/files": "20.79.1",
-    "@uniformdev/project-map": "20.79.1",
-    "@uniformdev/redirect": "20.79.1",
-    "@uniformdev/richtext": "20.79.1",
+    "@uniformdev/assets": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/automations-sdk": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/canvas": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/context": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/files": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/project-map": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/redirect": "20.79.2-alpha.19.sha-0b10e12c18",
+    "@uniformdev/richtext": "20.79.2-alpha.19.sha-0b10e12c18",
     "call-bind": "^1.0.2",
     "colorette": "2.0.20",
     "cosmiconfig": "9.0.2",
@@ -78,5 +78,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a9709918bf00f79101fcc46bda36105626931933"
+  "gitHead": "0b10e12c18b63e24d30690e6d596f723c22f38df"
 }