@uniformdev/transformer 1.1.35 → 1.1.37

package/dist/index.d.ts

@@ -148,6 +148,8 @@ interface ConvertCompositionsToEntriesOptions extends GlobalOptions {
     compositionTypes: string;
     componentsToReferences?: string;
     componentsToBlocks?: string;
+    slotsToReferences?: string;
+    slotsToBlocks?: string;
 }
 interface RemoveParameterOptions extends GlobalOptions {
     componentType: string;
@@ -307,7 +309,10 @@ declare class CompositionService {
 }
 
 declare class Logger {
+    private verbose;
+    constructor(verbose?: boolean);
     info(message: string): void;
+    debug(message: string): void;
     success(message: string): void;
     error(message: string): void;
     warn(message: string): void;
@@ -458,6 +463,8 @@ interface ConvertCompositionsToEntriesInternalOptions {
     compositionTypes: string[];
     componentsToReferences: string[];
     componentsToBlocks: string[];
+    slotsToReferences: string[];
+    slotsToBlocks: string[];
     whatIf: boolean;
     strict: boolean;
 }
@@ -518,6 +525,7 @@ declare class CompositionConverterService {
     generateEntryFromFlattenedInstance(inst: FlattenedInstance): EntryDefinition;
     findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private walkSlots;
+    findInstancesInSlot(slots: Record<string, ComponentInstance[]>, slotName: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private transformContentReferences;
     buildEntryIdMap(entriesDirFull: string): Promise<Map<string, string>>;
     buildSourceItemMap(entriesDirFull: string): Promise<Map<string, string>>;
@@ -525,6 +533,7 @@ declare class CompositionConverterService {
     private matchesType;
     private compareTypes;
     private expandWildcardTypes;
+    private expandWildcardSlots;
     private collectMatchingTypes;
     private truncate;
     private truncateName;

package/dist/index.js

@@ -597,11 +597,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);
@@ -618,7 +622,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`);
     }
@@ -635,6 +645,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);
@@ -649,6 +661,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`);
@@ -684,6 +697,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;
@@ -713,6 +727,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) {
@@ -732,6 +747,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;
@@ -754,6 +846,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) {
@@ -771,6 +864,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)) {
@@ -784,6 +878,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);
@@ -794,7 +889,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();
@@ -813,6 +944,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)) {
@@ -833,6 +965,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(
@@ -869,6 +1030,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) {
@@ -893,6 +1055,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);
           }
@@ -919,6 +1118,7 @@ var CompositionConverterService = class {
             },
             localizable: false
           });
+          this.logger.debug(`Field "${refType}" (contentReference) added to content type "${contentType.id}"`);
         }
       }
     }
@@ -941,6 +1141,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}"`);
         }
       }
     }
@@ -965,6 +1202,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);
       }
@@ -977,6 +1215,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);
       }
@@ -1108,6 +1347,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 = {};
@@ -1210,6 +1472,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;
@@ -1342,6 +1632,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})`);
@@ -1352,6 +1643,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 = [];
@@ -1372,6 +1664,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`);
         }
       }
     }
@@ -1410,7 +1704,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(
@@ -1435,6 +1732,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}`);
@@ -1454,7 +1752,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`);
           }
         }
       }
@@ -1467,6 +1768,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) {
@@ -1477,6 +1779,7 @@ var PropertyPropagatorService = class {
         findOptions
       );
       if (instances.length === 0) {
+        this.logger.debug(`Skipping "${filePath}": no instances of ${targetComponentType} found`);
         continue;
       }
       const valuesToPropagate = {};
@@ -1486,6 +1789,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;
@@ -1497,9 +1801,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}`);
@@ -1522,7 +1828,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(
@@ -1561,6 +1870,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}`);
         }
       }
     }
@@ -2934,9 +3245,16 @@ var FieldRemoverService = 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}`);
   }