@uniformdev/transformer 1.1.35 → 1.1.37

package/dist/cli/index.js

@@ -607,11 +607,15 @@ var CompositionConverterService = class {
       compositionTypes,
       componentsToReferences: rawComponentsToReferences,
       componentsToBlocks: rawComponentsToBlocks,
+      slotsToReferences: rawSlotsToReferences,
+      slotsToBlocks: rawSlotsToBlocks,
       whatIf,
       strict
     } = options;
     const initialComponentsToReferences = [...new Set(rawComponentsToReferences)];
     const initialComponentsToBlocks = [...new Set(rawComponentsToBlocks)];
+    const initialSlotsToReferences = [...new Set(rawSlotsToReferences)];
+    const initialSlotsToBlocks = [...new Set(rawSlotsToBlocks)];
     const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
     const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
@@ -628,7 +632,13 @@ var CompositionConverterService = class {
     if (initialComponentsToBlocks.length > 0) {
       this.logger.info(`Components to blocks: ${initialComponentsToBlocks.join(", ")}`);
     }
-    const sourceItemMap = initialComponentsToReferences.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
+    if (initialSlotsToReferences.length > 0) {
+      this.logger.info(`Slots to references: ${initialSlotsToReferences.join(", ")}`);
+    }
+    if (initialSlotsToBlocks.length > 0) {
+      this.logger.info(`Slots to blocks: ${initialSlotsToBlocks.join(", ")}`);
+    }
+    const sourceItemMap = initialComponentsToReferences.length > 0 || initialSlotsToReferences.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
     if (sourceItemMap.size > 0) {
       this.logger.info(`Found ${sourceItemMap.size} existing entry(ies) with sourceItem values`);
     }
@@ -645,6 +655,8 @@ var CompositionConverterService = class {
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
     const componentsToReferences = this.expandWildcardTypes(compositionResults, initialComponentsToReferences, strict);
     const componentsToBlocks = this.expandWildcardTypes(compositionResults, initialComponentsToBlocks, strict);
+    const slotsToReferences = this.expandWildcardSlots(compositionResults, initialSlotsToReferences, strict);
+    const slotsToBlocks = this.expandWildcardSlots(compositionResults, initialSlotsToBlocks, strict);
     const rootComponentTypes = /* @__PURE__ */ new Set();
     for (const { composition } of compositionResults) {
       rootComponentTypes.add(composition.composition.type);
@@ -659,6 +671,7 @@ var CompositionConverterService = class {
         );
         const contentType = this.generateContentType(component);
         contentTypeMap.set(rootType, contentType);
+        this.logger.debug(`Generated content type "${rootType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${rootType} \u2014 skipping content type generation`);
@@ -694,6 +707,7 @@ var CompositionConverterService = class {
         if (isRefType) {
           const contentType = this.generateContentType(component);
           targetContentTypeMap.set(targetType, contentType);
+          this.logger.debug(`Generated reference content type "${targetType}" with ${contentType.fields.length} field(s): ${contentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (isBlockType) {
           let blockId = targetType;
@@ -723,6 +737,7 @@ var CompositionConverterService = class {
           blockContentType.id = blockId;
           blockContentType.name = needsRename ? `${blockContentType.name} Block` : blockContentType.name;
           targetContentTypeMap.set(blockId, blockContentType);
+          this.logger.debug(`Generated block content type "${blockId}" with ${blockContentType.fields.length} field(s): ${blockContentType.fields.map((f) => f.id).join(", ")}`);
         }
         if (!isBlockType) {
           if (!isRefType) {
@@ -742,6 +757,83 @@ var CompositionConverterService = class {
         throw error;
       }
     }
+    const slotToRefTypes = /* @__PURE__ */ new Map();
+    const slotToBlockTypes = /* @__PURE__ */ new Map();
+    for (const slotName of slotsToReferences) slotToRefTypes.set(slotName, /* @__PURE__ */ new Set());
+    for (const slotName of slotsToBlocks) slotToBlockTypes.set(slotName, /* @__PURE__ */ new Set());
+    for (const { composition: discoverComp } of compositionResults) {
+      const dc = discoverComp.composition;
+      if (!dc.slots) continue;
+      const dcName = dc._name ?? dc._id;
+      for (const slotName of slotsToReferences) {
+        const instances = this.findInstancesInSlot(dc.slots, slotName, dc._id, dcName, strict);
+        for (const inst of instances) {
+          if (!this.compareTypes(inst.componentType, dc.type, strict)) {
+            slotToRefTypes.get(slotName).add(inst.componentType);
+          }
+        }
+      }
+      for (const slotName of slotsToBlocks) {
+        const instances = this.findInstancesInSlot(dc.slots, slotName, dc._id, dcName, strict);
+        for (const inst of instances) {
+          if (!this.compareTypes(inst.componentType, dc.type, strict)) {
+            slotToBlockTypes.get(slotName).add(inst.componentType);
+          }
+        }
+      }
+    }
+    const allSlotRefTypes = /* @__PURE__ */ new Set();
+    for (const types of slotToRefTypes.values()) for (const t of types) allSlotRefTypes.add(t);
+    const allSlotBlockTypes = /* @__PURE__ */ new Set();
+    for (const types of slotToBlockTypes.values()) for (const t of types) allSlotBlockTypes.add(t);
+    const allSlotTargetTypes = /* @__PURE__ */ new Set([...allSlotRefTypes, ...allSlotBlockTypes]);
+    for (const targetType of allSlotTargetTypes) {
+      if (targetContentTypeMap.has(targetType) || missingTargetTypes.includes(targetType)) continue;
+      const isRootType = [...rootComponentTypes].some((rt) => this.compareTypes(rt, targetType, strict));
+      if (isRootType) continue;
+      const isSlotBlockType = allSlotBlockTypes.has(targetType);
+      const isSlotRefType = allSlotRefTypes.has(targetType);
+      try {
+        const { component } = await this.componentService.loadComponent(componentsDirFull, targetType, { strict });
+        if (isSlotRefType) {
+          const contentType = this.generateContentType(component);
+          targetContentTypeMap.set(targetType, contentType);
+          this.logger.debug(`Generated slot reference content type "${targetType}" with ${contentType.fields.length} field(s)`);
+        }
+        if (isSlotBlockType && !blockTypeIdMap.has(targetType)) {
+          let blockId = targetType;
+          let needsRename = isSlotRefType;
+          if (!needsRename) {
+            const existingPath = this.fileSystem.joinPath(contentTypesDirFull, `${targetType}.json`);
+            if (await this.fileSystem.fileExists(existingPath)) {
+              try {
+                const existing = await this.fileSystem.readFile(existingPath);
+                if (existing?.type !== "block") needsRename = true;
+              } catch {
+              }
+            }
+          }
+          if (needsRename) {
+            blockId = `${targetType}Block`;
+            this.logger.info(`Content type "${targetType}" already exists as non-block, using "${blockId}" for block`);
+          }
+          blockTypeIdMap.set(targetType, blockId);
+          const blockContentType = this.generateContentType(component);
+          blockContentType.type = "block";
+          blockContentType.id = blockId;
+          blockContentType.name = needsRename ? `${blockContentType.name} Block` : blockContentType.name;
+          targetContentTypeMap.set(blockId, blockContentType);
+          this.logger.debug(`Generated slot block content type "${blockId}" with ${blockContentType.fields.length} field(s)`);
+        }
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.info(`Component type not found: ${targetType}`);
+          if (isSlotBlockType && !blockTypeIdMap.has(targetType)) blockTypeIdMap.set(targetType, targetType);
+          continue;
+        }
+        throw error;
+      }
+    }
     for (const { composition } of compositionResults) {
       const comp = composition.composition;
       const compositionId = comp._id;
@@ -764,6 +856,7 @@ var CompositionConverterService = class {
         }
       } else {
         entry = this.generateEntryFromComposition(composition);
+        this.logger.debug(`Generated entry "${entry.entry._id}" from composition "${compositionName}" (${compositionType}) with fields: ${Object.keys(entry.entry.fields).join(", ") || "(none)"}`);
       }
       const refsByType = /* @__PURE__ */ new Map();
       if (componentsToReferences.length > 0 && comp.slots) {
@@ -781,6 +874,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of reference type "${refType}"`);
           if (instances.length > 0) {
             refsByType.set(refType, instances);
             if (missingTargetTypes.includes(refType)) {
@@ -794,6 +888,7 @@ var CompositionConverterService = class {
         const refIds = [];
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          this.logger.debug(`Reference instance "${inst.determinisiticId}" (${refType}): ${existingId ? `reusing existing entry "${existingId}"` : `assigned new ID "${inst.determinisiticId}"`}`);
           refIds.push(existingId ?? inst.determinisiticId);
         }
         resolvedRefIds.set(refType, refIds);
@@ -804,7 +899,43 @@ var CompositionConverterService = class {
           value: resolvedRefIds.get(refType)
         };
       }
-      if (componentsToReferences.length > 0) {
+      const refsBySlot = /* @__PURE__ */ new Map();
+      if (slotsToReferences.length > 0 && comp.slots) {
+        for (const slotName of slotsToReferences) {
+          const instances = this.findInstancesInSlot(
+            comp.slots,
+            slotName,
+            compositionId,
+            compositionName,
+            strict
+          );
+          const filtered = instances.filter((inst) => {
+            if (this.compareTypes(inst.componentType, compositionType, strict)) {
+              this.logger.warn(`Skipping reference of "${inst.componentType}" in slot "${slotName}" \u2014 same as root component type`);
+              return false;
+            }
+            return true;
+          });
+          this.logger.debug(`Composition "${compositionName}": found ${filtered.length} instance(s) in reference slot "${slotName}"`);
+          if (filtered.length > 0) refsBySlot.set(slotName, filtered);
+        }
+      }
+      const resolvedSlotRefIds = /* @__PURE__ */ new Map();
+      for (const [slotName, instances] of refsBySlot) {
+        const refIds = [];
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          refIds.push(existingId ?? inst.determinisiticId);
+        }
+        resolvedSlotRefIds.set(slotName, refIds);
+      }
+      for (const [slotName] of refsBySlot) {
+        entry.entry.fields[slotName] = {
+          type: "contentReference",
+          value: resolvedSlotRefIds.get(slotName)
+        };
+      }
+      if (componentsToReferences.length > 0 || slotsToReferences.length > 0) {
         this.transformContentReferences(entry);
       }
       const blocksByType = /* @__PURE__ */ new Map();
@@ -823,6 +954,7 @@ var CompositionConverterService = class {
             compositionName,
             strict
           );
+          this.logger.debug(`Composition "${compositionName}": found ${instances.length} instance(s) of block type "${blockType}"`);
           if (instances.length > 0) {
             blocksByType.set(blockType, instances);
             if (missingTargetTypes.includes(blockType)) {
@@ -843,6 +975,35 @@ var CompositionConverterService = class {
         };
         blocksEmbedded += instances.length;
       }
+      const blocksBySlot = /* @__PURE__ */ new Map();
+      if (slotsToBlocks.length > 0 && comp.slots) {
+        for (const slotName of slotsToBlocks) {
+          const instances = this.findInstancesInSlot(
+            comp.slots,
+            slotName,
+            compositionId,
+            compositionName,
+            strict
+          );
+          const filtered = instances.filter((inst) => {
+            if (this.compareTypes(inst.componentType, compositionType, strict)) {
+              this.logger.warn(`Skipping block of "${inst.componentType}" in slot "${slotName}" \u2014 same as root component type`);
+              return false;
+            }
+            return true;
+          });
+          this.logger.debug(`Composition "${compositionName}": found ${filtered.length} instance(s) in block slot "${slotName}"`);
+          if (filtered.length > 0) blocksBySlot.set(slotName, filtered);
+        }
+      }
+      for (const [slotName, instances] of blocksBySlot) {
+        const blockValues = instances.map((inst) => ({
+          type: blockTypeIdMap.get(inst.componentType) ?? inst.componentType,
+          fields: { ...inst.instance.parameters ?? {} }
+        }));
+        entry.entry.fields[slotName] = { type: "$block", value: blockValues };
+        blocksEmbedded += instances.length;
+      }
       const entryId = entry.entry._id;
       if (isExistingEntry) {
         this.logger.action(
@@ -879,6 +1040,7 @@ var CompositionConverterService = class {
               "UPDATE",
               `${entriesDir}/${existingId}.json (${refType}, merged fields from "${this.truncate(compositionName, 50)}")`
             );
+            this.logger.debug(`Merging fields [${Object.keys(inst.instance.parameters ?? {}).join(", ") || "(none)"}] into existing reference entry "${existingId}"`);
             if (!whatIf) {
               const existingEntry = await this.fileSystem.readFile(existingEntryPath2);
               if (existingEntry?.entry) {
@@ -903,6 +1065,43 @@ var CompositionConverterService = class {
             "WRITE",
             `${entriesDir}/${inst.determinisiticId}.json (${refType} from "${this.truncate(compositionName, 50)}")`
           );
+          this.logger.debug(`Writing reference entry "${inst.determinisiticId}" (${refType}) with fields: ${Object.keys(flatEntry.entry.fields).join(", ") || "(none)"}`);
+          if (!whatIf) {
+            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
+          }
+          entriesFromReferences++;
+        }
+      }
+      for (const [, instances] of refsBySlot) {
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          if (existingId) {
+            const existingSlotEntryPath = this.fileSystem.joinPath(entriesDirFull, `${existingId}.json`);
+            this.logger.action(
+              whatIf,
+              "UPDATE",
+              `${entriesDir}/${existingId}.json (${inst.componentType}, merged fields from "${this.truncate(compositionName, 50)}")`
+            );
+            if (!whatIf) {
+              const existingEntry = await this.fileSystem.readFile(existingSlotEntryPath);
+              if (existingEntry?.entry) {
+                existingEntry.entry.fields = {
+                  ...existingEntry.entry.fields,
+                  ...inst.instance.parameters ?? {}
+                };
+                await this.fileSystem.writeFile(existingSlotEntryPath, existingEntry);
+              }
+            }
+            entriesReused++;
+            continue;
+          }
+          const flatEntry = this.generateEntryFromFlattenedInstance(inst);
+          const flatEntryPath = this.fileSystem.joinPath(entriesDirFull, `${inst.determinisiticId}.json`);
+          this.logger.action(
+            whatIf,
+            "WRITE",
+            `${entriesDir}/${inst.determinisiticId}.json (${inst.componentType} from "${this.truncate(compositionName, 50)}")`
+          );
           if (!whatIf) {
             await this.fileSystem.writeFile(flatEntryPath, flatEntry);
           }
@@ -929,6 +1128,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${refType}" (contentReference) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -951,6 +1151,43 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${resolvedBlockId}" ($block) added to content type "${contentType.id}"`);
+        }
+      }
+    }
+    if (slotsToReferences.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const slotName of slotsToReferences) {
+          const typesInSlot = slotToRefTypes.get(slotName) ?? /* @__PURE__ */ new Set();
+          const allowedTypes = [...typesInSlot].filter(
+            (t) => !this.compareTypes(t, contentType.id, strict)
+          );
+          if (allowedTypes.length === 0) continue;
+          contentType.fields.push({
+            id: slotName,
+            name: slotName,
+            type: "contentReference",
+            typeConfig: { isMulti: true, allowedTypes },
+            localizable: false
+          });
+          this.logger.debug(`Field "${slotName}" (contentReference, allowedTypes: ${allowedTypes.join(", ")}) added to content type "${contentType.id}"`);
+        }
+      }
+    }
+    if (slotsToBlocks.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const slotName of slotsToBlocks) {
+          const typesInSlot = slotToBlockTypes.get(slotName) ?? /* @__PURE__ */ new Set();
+          const resolvedBlockIds = [...typesInSlot].filter((t) => !this.compareTypes(t, contentType.id, strict)).map((t) => blockTypeIdMap.get(t) ?? t);
+          if (resolvedBlockIds.length === 0) continue;
+          contentType.fields.push({
+            id: slotName,
+            name: slotName,
+            type: "$block",
+            typeConfig: { allowedTypes: resolvedBlockIds },
+            localizable: false
+          });
+          this.logger.debug(`Field "${slotName}" ($block, allowedTypes: ${resolvedBlockIds.join(", ")}) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -975,6 +1212,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${baseFieldCount} fields${extrasInfo})`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -987,6 +1225,7 @@ var CompositionConverterService = class {
         "WRITE",
         `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
       );
+      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
@@ -1118,6 +1357,29 @@ var CompositionConverterService = class {
       }
     }
   }
+  // --- Slot-Based Instance Finding ---
+  findInstancesInSlot(slots, slotName, compositionId, compositionName, strict) {
+    const results = [];
+    for (const [name, instances] of Object.entries(slots)) {
+      const matches = strict ? name === slotName : name.toLowerCase() === slotName.toLowerCase();
+      if (!matches) continue;
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        if (instance._pattern) continue;
+        const path2 = `${compositionId}-${name}-[${i}]-${instance.type}`;
+        results.push({
+          instance,
+          path: path2,
+          determinisiticId: computeGuidHash(path2),
+          componentType: instance.type,
+          compositionId,
+          compositionName
+        });
+      }
+    }
+    return results;
+  }
   // --- Content Reference Transformation ---
   transformContentReferences(entry) {
     const dataResources = {};
@@ -1220,6 +1482,34 @@ var CompositionConverterService = class {
     }
     return [...new Set(expanded)];
   }
+  expandWildcardSlots(compositionResults, patterns, strict) {
+    const expanded = [];
+    for (const pattern of patterns) {
+      if (!pattern.includes("*")) {
+        expanded.push(pattern);
+        continue;
+      }
+      const matched = /* @__PURE__ */ new Set();
+      for (const { composition } of compositionResults) {
+        if (composition.composition.slots) {
+          for (const slotName of Object.keys(composition.composition.slots)) {
+            if (this.matchesType(slotName, pattern, strict)) {
+              matched.add(slotName);
+            }
+          }
+        }
+      }
+      if (matched.size === 0) {
+        this.logger.warn(`Wildcard pattern "${pattern}" did not match any slot names`);
+      } else {
+        this.logger.info(`Wildcard "${pattern}" expanded to: ${[...matched].join(", ")}`);
+      }
+      for (const name of matched) {
+        expanded.push(name);
+      }
+    }
+    return [...new Set(expanded)];
+  }
   collectMatchingTypes(slots, pattern, strict, matched) {
     for (const instances of Object.values(slots)) {
       if (!Array.isArray(instances)) continue;
@@ -1352,6 +1642,7 @@ var PropertyPropagatorService = class {
       try {
         const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
         sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+        this.logger.debug(`Loaded source component "${sourceType}" from ${sourceFilePath}`);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
           this.logger.warn(`Component not found: ${sourceType} (searched: ${fullComponentsDir})`);
@@ -1362,6 +1653,7 @@ var PropertyPropagatorService = class {
     }
     this.logger.info(`Loading component: ${targetComponentType}`);
     const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    this.logger.debug(`Loaded target component "${targetComponentType}" from ${targetFilePath}`);
     const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
     const resolvedParams = [];
     const resolvedNames = [];
@@ -1382,6 +1674,8 @@ var PropertyPropagatorService = class {
         if (!exists) {
           resolvedParams.push(param);
           resolvedNames.push(param.id);
+        } else {
+          this.logger.debug(`Parameter "${param.id}" already collected from another source \u2014 skipping duplicate`);
         }
       }
     }
@@ -1420,7 +1714,10 @@ var PropertyPropagatorService = class {
         targetGroup,
         findOptions
       );
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) created on component ${targetComponentType}`);
       componentModified = true;
+    } else {
+      this.logger.debug(`Group "${targetGroup}" (id: ${groupId}) already exists on ${targetComponentType}`);
     }
     for (const param of resolvedParams) {
       const existingParam = this.componentService.findParameter(
@@ -1445,6 +1742,7 @@ var PropertyPropagatorService = class {
           param.id,
           findOptions
         );
+        this.logger.debug(`Parameter "${param.id}" (type: ${param.type}) added to component ${targetComponentType} in group "${targetGroup}"`);
         componentModified = true;
       } else {
         this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
@@ -1464,7 +1762,10 @@ var PropertyPropagatorService = class {
               param.id,
               findOptions
             );
+            this.logger.debug(`Parameter "${param.id}" added to group "${targetGroup}" on ${targetComponentType} (was missing from group)`);
             componentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" already in group "${targetGroup}" on ${targetComponentType} \u2014 no change`);
           }
         }
       }
@@ -1477,6 +1778,7 @@ var PropertyPropagatorService = class {
       compositionTypes,
       findOptions
     );
+    this.logger.debug(`Found ${compositions.length} composition(s) matching types [${compositionTypes.join(", ")}]`);
     let modifiedCompositions = 0;
     let propagatedInstances = 0;
     for (const { composition, filePath } of compositions) {
@@ -1487,6 +1789,7 @@ var PropertyPropagatorService = class {
         findOptions
       );
       if (instances.length === 0) {
+        this.logger.debug(`Skipping "${filePath}": no instances of ${targetComponentType} found`);
         continue;
       }
       const valuesToPropagate = {};
@@ -1496,6 +1799,7 @@ var PropertyPropagatorService = class {
         }
       }
       if (Object.keys(valuesToPropagate).length === 0) {
+        this.logger.debug(`Skipping "${filePath}": ${instances.length} instance(s) of ${targetComponentType} found but none of [${resolvedNames.join(", ")}] present in root overrides`);
         continue;
       }
       let compositionModified = false;
@@ -1507,9 +1811,11 @@ var PropertyPropagatorService = class {
         this.compositionService.setInstanceParameters(instance, clonedValues);
         compositionModified = true;
         propagatedInstances++;
+        const updatedParamNames = Object.keys(valuesToPropagate).join(", ");
         instanceUpdates.push(
-          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+          `${targetComponentType} "${instanceName}": ${updatedParamNames}`
         );
+        this.logger.debug(`Component ${targetComponentType} "${instanceName}": parameters ${updatedParamNames} updated`);
       }
       if (compositionModified) {
         this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
@@ -1532,7 +1838,10 @@ var PropertyPropagatorService = class {
           if (exists) {
             this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
             modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+            this.logger.debug(`Parameter "${param.id}" removed from component ${sourceType}`);
             sourceComponentModified = true;
+          } else {
+            this.logger.debug(`Parameter "${param.id}" not found on source component "${sourceType}" \u2014 nothing to delete`);
           }
         }
         const beforeGroupCount = modifiedSource.parameters?.filter(
@@ -1571,6 +1880,8 @@ var PropertyPropagatorService = class {
           if (!whatIf) {
             await this.compositionService.saveComposition(filePath, composition);
           }
+        } else {
+          this.logger.debug(`No root overrides matching [${resolvedNames.join(", ")}] in composition/${relativePath}`);
         }
       }
     }
@@ -1598,9 +1909,16 @@ var PropertyPropagatorService = class {
 // src/cli/logger.ts
 import chalk from "chalk";
 var Logger = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
   info(message) {
     console.log(`${chalk.blue("[INFO]")} ${message}`);
   }
+  debug(message) {
+    if (!this.verbose) return;
+    console.log(`${chalk.magenta("[DEBUG]")} ${message}`);
+  }
   success(message) {
     console.log(`${chalk.green("[DONE]")} ${message}`);
   }
@@ -1636,7 +1954,7 @@ function createPropagateRootComponentPropertyCommand() {
   ).option(
     "--deleteSourceParameter",
     "Delete the original parameters from the source component after propagation"
-  ).hook("preAction", (thisCommand) => {
+  ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "compositionType", flag: "--compositionType" },
@@ -1659,7 +1977,7 @@ function createPropagateRootComponentPropertyCommand() {
       targetGroup: opts.targetGroup,
       deleteSourceParameter: opts.deleteSourceParameter
     };
-    const logger = new Logger();
+    const logger = new Logger(opts.verbose ?? false);
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const compositionService = new CompositionService(fileSystem);
@@ -4447,7 +4765,13 @@ function createConvertCompositionsToEntriesCommand() {
   ).option(
     "--componentsToBlocks <types>",
     "Pipe-separated list of component types to convert into inline blocks (e.g., DetailHero|ArticleDetail)"
-  ).hook("preAction", (thisCommand) => {
+  ).option(
+    "--slotsToReferences <slots>",
+    "Pipe-separated list of slot names whose instances should be converted into separate referenced entries (e.g., main|sidebar)"
+  ).option(
+    "--slotsToBlocks <slots>",
+    "Pipe-separated list of slot names whose instances should be converted into inline blocks (e.g., main|sidebar)"
+  ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "compositionTypes", flag: "--compositionTypes" }
@@ -4463,9 +4787,11 @@ function createConvertCompositionsToEntriesCommand() {
       ...globalOpts,
       compositionTypes: opts.compositionTypes,
       componentsToReferences: opts.componentsToReferences,
-      componentsToBlocks: opts.componentsToBlocks
+      componentsToBlocks: opts.componentsToBlocks,
+      slotsToReferences: opts.slotsToReferences,
+      slotsToBlocks: opts.slotsToBlocks
     };
-    const logger = new Logger();
+    const logger = new Logger(opts.verbose ?? false);
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const compositionService = new CompositionService(fileSystem);
@@ -4480,6 +4806,8 @@ function createConvertCompositionsToEntriesCommand() {
       const parsePipeSeparated = (value) => value ? [...new Set(value.split("|").map((t) => t.trim()).filter((t) => t.length > 0))] : [];
       const componentsToReferences = parsePipeSeparated(options.componentsToReferences);
       const componentsToBlocks = parsePipeSeparated(options.componentsToBlocks);
+      const slotsToReferences = parsePipeSeparated(options.slotsToReferences);
+      const slotsToBlocks = parsePipeSeparated(options.slotsToBlocks);
       const result = await converter.convert({
         rootDir: options.rootDir,
         compositionsDir: options.compositionsDir,
@@ -4489,6 +4817,8 @@ function createConvertCompositionsToEntriesCommand() {
         compositionTypes,
         componentsToReferences,
         componentsToBlocks,
+        slotsToReferences,
+        slotsToBlocks,
         whatIf: options.whatIf ?? false,
         strict: options.strict ?? false
       });
@@ -6033,7 +6363,7 @@ function createRemoveOrphanEntriesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.35",
+  version: "1.1.37",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {