@uniformdev/transformer 1.1.16 → 1.1.17

package/dist/cli/index.js

@@ -523,301 +523,793 @@ var CompositionService = class {
   }
 };
 
-// src/core/services/property-propagator.service.ts
-var PropertyPropagatorService = class {
+// src/core/services/composition-converter.service.ts
+import * as crypto from "crypto";
+var CompositionConverterService = class {
   constructor(fileSystem, componentService, compositionService, logger) {
     this.fileSystem = fileSystem;
     this.componentService = componentService;
     this.compositionService = compositionService;
     this.logger = logger;
   }
-  async propagate(options) {
+  async convert(options) {
     const {
       rootDir,
-      componentsDir,
       compositionsDir,
-      compositionType,
-      property,
-      targetComponentType,
-      targetGroup,
+      componentsDir,
+      contentTypesDir,
+      entriesDir,
+      compositionTypes,
+      flattenComponentIds,
       whatIf,
-      strict,
-      deleteSourceParameter
+      strict
     } = options;
-    const findOptions = { strict };
-    const compositionTypes = this.parsePipeSeparatedValues(compositionType, strict);
-    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const sourceComponents = [];
-    for (const sourceType of compositionTypes) {
-      this.logger.info(`Loading component: ${sourceType}`);
-      const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
-      sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    let contentTypesWritten = 0;
+    let entriesFromCompositions = 0;
+    let entriesFromFlattened = 0;
+    let entriesReused = 0;
+    this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
+    if (flattenComponentIds.length > 0) {
+      this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
     }
-    this.logger.info(`Loading component: ${targetComponentType}`);
-    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
-    const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
-    const resolvedParams = [];
-    const resolvedNames = [];
-    for (const { sourceType, sourceComponent } of sourceComponents) {
-      const { parameters: sourceParams, notFound } = this.componentService.resolveProperties(
-        sourceComponent,
-        propertyNames,
-        findOptions
+    const sourceItemMap = flattenComponentIds.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`);
+    }
+    const compositionResults = await this.compositionService.findCompositionsByTypes(
+      compositionsDirFull,
+      compositionTypes,
+      { strict }
+    );
+    if (compositionResults.length === 0) {
+      this.logger.warn("No compositions found matching the specified types");
+      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0, entriesReused: 0 };
+    }
+    this.logger.info(`Found ${compositionResults.length} composition(s)`);
+    const rootComponentTypes = /* @__PURE__ */ new Set();
+    for (const { composition } of compositionResults) {
+      rootComponentTypes.add(composition.composition.type);
+    }
+    const contentTypeMap = /* @__PURE__ */ new Map();
+    for (const rootType of rootComponentTypes) {
+      const { component } = await this.componentService.loadComponent(
+        componentsDirFull,
+        rootType,
+        { strict }
       );
-      if (notFound.length > 0) {
-        this.logger.warn(`Property "${notFound.join(", ")}" not found on component "${sourceType}"`);
+      const contentType = this.generateContentType(component);
+      contentTypeMap.set(rootType, contentType);
+    }
+    const flattenContentTypeMap = /* @__PURE__ */ new Map();
+    const missingFlattenTypes = [];
+    const foundMissingFlattenTypes = /* @__PURE__ */ new Set();
+    for (const flattenType of flattenComponentIds) {
+      const isRootType = [...rootComponentTypes].some(
+        (rt) => this.compareTypes(rt, flattenType, strict)
+      );
+      if (isRootType) {
         continue;
       }
-      for (const param of sourceParams) {
-        const exists = resolvedParams.some(
-          (existing) => strict ? existing.id === param.id : existing.id.toLowerCase() === param.id.toLowerCase()
+      try {
+        const { component } = await this.componentService.loadComponent(
+          componentsDirFull,
+          flattenType,
+          { strict }
         );
-        if (!exists) {
-          resolvedParams.push(param);
-          resolvedNames.push(param.id);
+        const contentType = this.generateContentType(component);
+        flattenContentTypeMap.set(flattenType, contentType);
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.info(`Flatten component type not found: ${flattenType}`);
+          missingFlattenTypes.push(flattenType);
+          continue;
         }
+        throw error;
       }
     }
-    const groupSources = [];
-    for (const { sourceType, sourceComponent } of sourceComponents) {
-      for (const name of propertyNames) {
-        const param = this.componentService.findParameter(sourceComponent, name, findOptions);
-        if (param && this.componentService.isGroupParameter(param)) {
-          const groupSource = `${sourceType}.${name}`;
-          if (!groupSources.includes(groupSource)) {
-            groupSources.push(groupSource);
+    for (const { composition } of compositionResults) {
+      const comp = composition.composition;
+      const compositionId = comp._id;
+      const compositionName = comp._name ?? compositionId;
+      const compositionType = comp.type;
+      const entry = this.generateEntryFromComposition(composition);
+      const flattenedByType = /* @__PURE__ */ new Map();
+      if (flattenComponentIds.length > 0 && comp.slots) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, compositionType, strict)) {
+            this.logger.warn(
+              `Skipping flatten of "${flattenType}" \u2014 same as root component type`
+            );
+            continue;
           }
-        }
-      }
-    }
-    if (groupSources.length > 0) {
-      this.logger.info(
-        `Resolved properties: ${resolvedNames.join(", ")} (from ${groupSources.join(", ")})`
-      );
-    } else {
-      this.logger.info(`Resolved properties: ${resolvedNames.join(", ")}`);
-    }
-    let modifiedComponent = { ...targetComponent };
-    let componentModified = false;
-    const groupId = this.componentService.generateGroupId(targetGroup);
-    const existingGroup = this.componentService.findParameter(
-      modifiedComponent,
-      groupId,
-      findOptions
-    );
-    if (!existingGroup) {
-      this.logger.action(whatIf, "CREATE", `Group "${targetGroup}" on ${targetComponentType}`);
-      modifiedComponent = this.componentService.ensureGroupExists(
-        modifiedComponent,
-        groupId,
-        targetGroup,
-        findOptions
-      );
-      componentModified = true;
-    }
-    for (const param of resolvedParams) {
-      const existingParam = this.componentService.findParameter(
-        modifiedComponent,
-        param.id,
-        findOptions
-      );
-      if (!existingParam) {
-        this.logger.action(
-          whatIf,
-          "COPY",
-          `Parameter "${param.id}" \u2192 ${targetComponentType}.${targetGroup}`
-        );
-        modifiedComponent = this.componentService.addParameterToComponent(
-          modifiedComponent,
-          param,
-          findOptions
-        );
-        modifiedComponent = this.componentService.addParameterToGroup(
-          modifiedComponent,
-          groupId,
-          param.id,
-          findOptions
-        );
-        componentModified = true;
-      } else {
-        this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
-        const group = this.componentService.findParameter(
-          modifiedComponent,
-          groupId,
-          findOptions
-        );
-        if (group && this.componentService.isGroupParameter(group)) {
-          const isInGroup = group.typeConfig?.childrenParams?.some(
-            (id) => strict ? id === param.id : id.toLowerCase() === param.id.toLowerCase()
+          const instances = this.findFlattenTargets(
+            comp.slots,
+            flattenType,
+            compositionId,
+            compositionName,
+            strict
           );
-          if (!isInGroup) {
-            modifiedComponent = this.componentService.addParameterToGroup(
-              modifiedComponent,
-              groupId,
-              param.id,
-              findOptions
-            );
-            componentModified = true;
+          if (instances.length > 0) {
+            flattenedByType.set(flattenType, instances);
+            if (missingFlattenTypes.includes(flattenType)) {
+              foundMissingFlattenTypes.add(flattenType);
+            }
           }
         }
       }
-    }
-    if (componentModified && !whatIf) {
-      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
-    }
-    const compositions = await this.compositionService.findCompositionsByTypes(
-      fullCompositionsDir,
-      compositionTypes,
-      findOptions
-    );
-    let modifiedCompositions = 0;
-    let propagatedInstances = 0;
-    for (const { composition, filePath } of compositions) {
-      const rootOverrides = this.compositionService.getRootOverrides(composition);
-      const instances = this.compositionService.findComponentInstances(
-        composition,
-        targetComponentType,
-        findOptions
-      );
-      if (instances.length === 0) {
-        continue;
-      }
-      const valuesToPropagate = {};
-      for (const param of resolvedParams) {
-        if (rootOverrides[param.id]) {
-          valuesToPropagate[param.id] = rootOverrides[param.id];
+      const resolvedRefIds = /* @__PURE__ */ new Map();
+      for (const [flattenType, instances] of flattenedByType) {
+        const refIds = [];
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          refIds.push(existingId ?? inst.determinisiticId);
         }
+        resolvedRefIds.set(flattenType, refIds);
       }
-      if (Object.keys(valuesToPropagate).length === 0) {
-        continue;
+      for (const [flattenType] of flattenedByType) {
+        entry.entry.fields[flattenType] = {
+          type: "contentReference",
+          value: resolvedRefIds.get(flattenType)
+        };
       }
-      let compositionModified = false;
-      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
-      const instanceUpdates = [];
-      for (const { instance, instanceId } of instances) {
-        const instanceName = instance._id ?? instanceId;
-        this.compositionService.setInstanceParameters(instance, valuesToPropagate);
-        compositionModified = true;
-        propagatedInstances++;
-        instanceUpdates.push(
-          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
-        );
+      if (flattenComponentIds.length > 0) {
+        this.transformContentReferences(entry);
       }
-      if (compositionModified) {
-        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
-        for (const update of instanceUpdates) {
-          this.logger.detail(`\u2192 ${update}`);
-        }
-        if (!whatIf) {
-          await this.compositionService.saveComposition(filePath, composition);
-        }
-        modifiedCompositions++;
+      const entryId = entry.entry._id;
+      const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${entryId}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${entriesDir}/${entryId}.json (${compositionType}, "${this.truncate(compositionName, 50)}")`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(entryFilePath, entry);
       }
-    }
-    let modifiedSourceComponents = 0;
-    if (deleteSourceParameter) {
-      for (const { sourceType, sourceFilePath, sourceComponent } of sourceComponents) {
-        let modifiedSource = { ...sourceComponent };
-        let sourceComponentModified = false;
-        for (const param of resolvedParams) {
-          const exists = this.componentService.findParameter(modifiedSource, param.id, findOptions);
-          if (exists) {
-            this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
-            modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
-            sourceComponentModified = true;
+      entriesFromCompositions++;
+      for (const [flattenType, instances] of flattenedByType) {
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          if (existingId) {
+            this.logger.info(
+              `Reusing existing entry ${existingId} for ${flattenType} (sourceItem match)`
+            );
+            entriesReused++;
+            continue;
           }
-        }
-        const beforeGroupCount = modifiedSource.parameters?.filter(
-          (p) => this.componentService.isGroupParameter(p)
-        ).length ?? 0;
-        modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
-        const afterGroupCount = modifiedSource.parameters?.filter(
-          (p) => this.componentService.isGroupParameter(p)
-        ).length ?? 0;
-        if (afterGroupCount < beforeGroupCount) {
-          const removedCount = beforeGroupCount - afterGroupCount;
+          const flatEntry = this.generateEntryFromFlattenedInstance(inst);
+          const flatEntryPath = this.fileSystem.joinPath(
+            entriesDirFull,
+            `${inst.determinisiticId}.json`
+          );
           this.logger.action(
             whatIf,
-            "DELETE",
-            `${removedCount} empty group(s) from ${sourceType}`
+            "WRITE",
+            `${entriesDir}/${inst.determinisiticId}.json (${flattenType} from "${this.truncate(compositionName, 50)}")`
           );
-          sourceComponentModified = true;
-        }
-        if (sourceComponentModified) {
-          modifiedSourceComponents++;
-        }
-        if (sourceComponentModified && !whatIf) {
-          await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+          if (!whatIf) {
+            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
+          }
+          entriesFromFlattened++;
         }
       }
-      for (const { composition, filePath } of compositions) {
-        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
-        const deleted = this.compositionService.deleteRootOverrides(
-          composition,
-          resolvedNames,
-          findOptions
-        );
-        if (deleted) {
-          this.logger.action(whatIf, "DELETE", `Root overrides from composition/${relativePath}`);
-          this.logger.detail(`\u2192 Removed: ${resolvedNames.join(", ")}`);
-          if (!whatIf) {
-            await this.compositionService.saveComposition(filePath, composition);
+    }
+    if (flattenComponentIds.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, contentType.id, strict)) {
+            continue;
           }
+          if (missingFlattenTypes.includes(flattenType) && !foundMissingFlattenTypes.has(flattenType)) {
+            continue;
+          }
+          contentType.fields.push({
+            id: flattenType,
+            name: flattenType,
+            type: "contentReference",
+            typeConfig: {
+              isMulti: true,
+              allowedContentTypes: [flattenType]
+            },
+            localizable: false
+          });
         }
       }
     }
-    return {
-      modifiedComponents: (componentModified ? 1 : 0) + modifiedSourceComponents,
-      modifiedCompositions,
-      propagatedInstances
-    };
-  }
-  parsePipeSeparatedValues(value, strict) {
-    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-    const normalized = [];
-    for (const entry of entries) {
-      const exists = normalized.some(
-        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+    for (const [typeName, contentType] of contentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
+      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
+      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
       );
-      if (!exists) {
-        normalized.push(entry);
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
       }
+      contentTypesWritten++;
     }
-    return normalized;
-  }
-};
-
-// src/cli/logger.ts
-import chalk from "chalk";
-var Logger = class {
-  info(message) {
-    console.log(`${chalk.blue("[INFO]")} ${message}`);
+    for (const [typeName, contentType] of flattenContentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
+      }
+      contentTypesWritten++;
+    }
+    const neverFoundMissingTypes = missingFlattenTypes.filter(
+      (type) => !foundMissingFlattenTypes.has(type)
+    );
+    if (neverFoundMissingTypes.length > 0) {
+      this.logger.warn(
+        `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
+      );
+    }
+    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened, entriesReused };
   }
-  success(message) {
-    console.log(`${chalk.green("[DONE]")} ${message}`);
+  // --- Content Type Generation ---
+  generateContentType(component) {
+    const fields = [];
+    if (component.parameters) {
+      for (const param of component.parameters) {
+        fields.push(this.parameterToField(param));
+      }
+    }
+    return {
+      id: component.id,
+      name: component.name,
+      fields
+    };
   }
-  error(message) {
-    console.log(`${chalk.red("[ERROR]")} ${message}`);
+  parameterToField(param) {
+    const field = {
+      id: param.id,
+      name: param.name,
+      type: param.type
+    };
+    if (param.helpText !== void 0) {
+      field.helpText = param.helpText;
+    }
+    if (param.localizable !== void 0) {
+      field.localizable = param.localizable;
+    }
+    if (param.typeConfig !== void 0) {
+      field.typeConfig = param.typeConfig;
+    }
+    return field;
   }
-  warn(message) {
-    console.log(`${chalk.yellow("[WARN]")} ${message}`);
+  // --- Entry Generation ---
+  generateEntryFromComposition(composition) {
+    const comp = composition.composition;
+    const compositionSpecificKeys = /* @__PURE__ */ new Set(["_id", "_name", "type", "parameters", "slots", "_overrides"]);
+    const extraRootProps = {};
+    for (const [key, value] of Object.entries(comp)) {
+      if (!compositionSpecificKeys.has(key) && value != null) {
+        extraRootProps[key] = value;
+      }
+    }
+    const wrapperKeys = /* @__PURE__ */ new Set(["composition"]);
+    const extraWrapperProps = {};
+    for (const [key, value] of Object.entries(composition)) {
+      if (!wrapperKeys.has(key) && value != null) {
+        extraWrapperProps[key] = value;
+      }
+    }
+    const entryId = computeGuidHash(`entry${comp._id}`);
+    const entryName = this.truncateName(comp._name ?? comp._id, 60);
+    return {
+      entry: {
+        _id: entryId,
+        _name: entryName,
+        type: comp.type,
+        fields: { ...comp.parameters ?? {} },
+        ...extraRootProps
+      },
+      ...extraWrapperProps
+    };
   }
-  action(whatIf, actionType, message) {
-    const prefix = whatIf ? chalk.yellow("[WOULD]") : chalk.green(`[${actionType}]`);
-    console.log(`${prefix} ${message}`);
+  generateEntryFromFlattenedInstance(inst) {
+    const entryName = this.truncateName(
+      `${inst.componentType} (from ${inst.compositionName})`,
+      60
+    );
+    return {
+      entry: {
+        _id: inst.determinisiticId,
+        _name: entryName,
+        type: inst.componentType,
+        fields: { ...inst.instance.parameters ?? {} }
+      }
+    };
   }
-  detail(message) {
-    console.log(`  ${chalk.gray(message)}`);
+  // --- Flatten Tree Walking ---
+  findFlattenTargets(slots, targetType, compositionId, compositionName, strict) {
+    const results = [];
+    this.walkSlots(slots, targetType, compositionId, compositionName, "", results, strict);
+    return results;
   }
-};
-
-// src/cli/commands/propagate-root-component-property.ts
-function createPropagateRootComponentPropertyCommand() {
-  const command = new Command("propagate-root-component-property");
-  command.description(
-    "Copies property definitions from a composition type's root component to a target component type, then propagates the actual values across all matching compositions."
-  ).option(
+  walkSlots(slots, targetType, compositionId, compositionName, pathPrefix, results, strict) {
+    for (const [slotName, instances] of Object.entries(slots)) {
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        if (instance._pattern) {
+          continue;
+        }
+        const currentPath = pathPrefix ? `${pathPrefix}-${slotName}-[${i}]-${instance.type}` : `${slotName}-[${i}]-${instance.type}`;
+        if (this.compareTypes(instance.type, targetType, strict)) {
+          const fullPath = `${compositionId}-${currentPath}`;
+          const deterministicId = computeGuidHash(fullPath);
+          results.push({
+            instance,
+            path: fullPath,
+            determinisiticId: deterministicId,
+            componentType: instance.type,
+            compositionId,
+            compositionName
+          });
+        }
+        if (instance.slots) {
+          this.walkSlots(
+            instance.slots,
+            targetType,
+            compositionId,
+            compositionName,
+            currentPath,
+            results,
+            strict
+          );
+        }
+      }
+    }
+  }
+  // --- Content Reference Transformation ---
+  transformContentReferences(entry) {
+    const dataResources = {};
+    for (const [fieldName, field] of Object.entries(entry.entry.fields)) {
+      if (field.type === "contentReference" && Array.isArray(field.value)) {
+        const entryIds = field.value;
+        const resourceKey = `ref-${entry.entry._id}-${fieldName}`;
+        field.value = `\${#jptr:/${resourceKey}/entries}`;
+        dataResources[resourceKey] = {
+          type: "uniformContentInternalReference",
+          variables: {
+            locale: "${locale}",
+            entryIds: entryIds.join(",")
+          }
+        };
+      }
+    }
+    if (Object.keys(dataResources).length > 0) {
+      entry.entry._dataResources = {
+        ...entry.entry._dataResources ?? {},
+        ...dataResources
+      };
+    }
+  }
+  // --- Source Item Matching ---
+  async buildSourceItemMap(entriesDirFull) {
+    const sourceItemMap = /* @__PURE__ */ new Map();
+    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "*.json");
+    for (const filePath of entryFiles) {
+      try {
+        const entryData = await this.fileSystem.readFile(filePath);
+        const sourceItemField = entryData?.entry?.fields?.sourceItem;
+        if (sourceItemField?.value != null) {
+          sourceItemMap.set(String(sourceItemField.value), entryData.entry._id);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return sourceItemMap;
+  }
+  findExistingEntryBySourceItem(inst, sourceItemMap) {
+    const sourceItemParam = inst.instance.parameters?.sourceItem;
+    if (sourceItemParam?.value == null) {
+      return void 0;
+    }
+    return sourceItemMap.get(String(sourceItemParam.value));
+  }
+  // --- Utilities ---
+  compareTypes(type1, type2, strict) {
+    if (strict) {
+      return type1 === type2;
+    }
+    return type1.toLowerCase() === type2.toLowerCase();
+  }
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength - 3) + "...";
+  }
+  truncateName(name, maxLength) {
+    if (name.length <= maxLength) return name;
+    return name.substring(0, maxLength);
+  }
+};
+function computeGuidHash(guidOrSeed) {
+  let uuidStr;
+  if (isValidUuid(guidOrSeed)) {
+    uuidStr = formatAsBracedUuid(guidOrSeed);
+  } else {
+    const hash = crypto.createHash("md5").update(guidOrSeed, "utf-8").digest();
+    const hex = [
+      // First 4 bytes: little-endian in .NET Guid
+      hash[3].toString(16).padStart(2, "0"),
+      hash[2].toString(16).padStart(2, "0"),
+      hash[1].toString(16).padStart(2, "0"),
+      hash[0].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 4-5: little-endian
+      hash[5].toString(16).padStart(2, "0"),
+      hash[4].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 6-7: little-endian
+      hash[7].toString(16).padStart(2, "0"),
+      hash[6].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 8-9: big-endian
+      hash[8].toString(16).padStart(2, "0"),
+      hash[9].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 10-15: big-endian
+      hash[10].toString(16).padStart(2, "0"),
+      hash[11].toString(16).padStart(2, "0"),
+      hash[12].toString(16).padStart(2, "0"),
+      hash[13].toString(16).padStart(2, "0"),
+      hash[14].toString(16).padStart(2, "0"),
+      hash[15].toString(16).padStart(2, "0")
+    ].join("");
+    uuidStr = `{${hex}}`.toUpperCase();
+  }
+  const chars = uuidStr.split("");
+  chars[15] = "4";
+  const arr20 = ["8", "9", "A", "B"];
+  const hexVal = parseInt(chars[20], 16);
+  chars[20] = arr20[hexVal % 4];
+  return chars.join("").slice(1, -1).toLowerCase();
+}
+function isValidUuid(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+function formatAsBracedUuid(uuid) {
+  const clean = uuid.replace(/[{}]/g, "").toUpperCase();
+  return `{${clean}}`;
+}
+
+// src/core/services/id-regenerator.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function regenerateIds(value, basePath) {
+  return walkAndRegenerate(value, basePath);
+}
+function walkAndRegenerate(value, currentPath) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => walkAndRegenerate(item, `${currentPath}[${index}]`));
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+      const childPath = `${currentPath}.${key}`;
+      if (key === "_id" && typeof val === "string" && UUID_PATTERN.test(val)) {
+        result[key] = computeGuidHash(val + childPath);
+      } else {
+        result[key] = walkAndRegenerate(val, childPath);
+      }
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/core/services/property-propagator.service.ts
+var PropertyPropagatorService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async propagate(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionType,
+      property,
+      targetComponentType,
+      targetGroup,
+      whatIf,
+      strict,
+      deleteSourceParameter
+    } = options;
+    const findOptions = { strict };
+    const compositionTypes = this.parsePipeSeparatedValues(compositionType, strict);
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const sourceComponents = [];
+    for (const sourceType of compositionTypes) {
+      this.logger.info(`Loading component: ${sourceType}`);
+      const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
+      sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+    }
+    this.logger.info(`Loading component: ${targetComponentType}`);
+    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
+    const resolvedParams = [];
+    const resolvedNames = [];
+    for (const { sourceType, sourceComponent } of sourceComponents) {
+      const { parameters: sourceParams, notFound } = this.componentService.resolveProperties(
+        sourceComponent,
+        propertyNames,
+        findOptions
+      );
+      if (notFound.length > 0) {
+        this.logger.warn(`Property "${notFound.join(", ")}" not found on component "${sourceType}"`);
+        continue;
+      }
+      for (const param of sourceParams) {
+        const exists = resolvedParams.some(
+          (existing) => strict ? existing.id === param.id : existing.id.toLowerCase() === param.id.toLowerCase()
+        );
+        if (!exists) {
+          resolvedParams.push(param);
+          resolvedNames.push(param.id);
+        }
+      }
+    }
+    const groupSources = [];
+    for (const { sourceType, sourceComponent } of sourceComponents) {
+      for (const name of propertyNames) {
+        const param = this.componentService.findParameter(sourceComponent, name, findOptions);
+        if (param && this.componentService.isGroupParameter(param)) {
+          const groupSource = `${sourceType}.${name}`;
+          if (!groupSources.includes(groupSource)) {
+            groupSources.push(groupSource);
+          }
+        }
+      }
+    }
+    if (groupSources.length > 0) {
+      this.logger.info(
+        `Resolved properties: ${resolvedNames.join(", ")} (from ${groupSources.join(", ")})`
+      );
+    } else {
+      this.logger.info(`Resolved properties: ${resolvedNames.join(", ")}`);
+    }
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    const groupId = this.componentService.generateGroupId(targetGroup);
+    const existingGroup = this.componentService.findParameter(
+      modifiedComponent,
+      groupId,
+      findOptions
+    );
+    if (!existingGroup) {
+      this.logger.action(whatIf, "CREATE", `Group "${targetGroup}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.ensureGroupExists(
+        modifiedComponent,
+        groupId,
+        targetGroup,
+        findOptions
+      );
+      componentModified = true;
+    }
+    for (const param of resolvedParams) {
+      const existingParam = this.componentService.findParameter(
+        modifiedComponent,
+        param.id,
+        findOptions
+      );
+      if (!existingParam) {
+        this.logger.action(
+          whatIf,
+          "COPY",
+          `Parameter "${param.id}" \u2192 ${targetComponentType}.${targetGroup}`
+        );
+        modifiedComponent = this.componentService.addParameterToComponent(
+          modifiedComponent,
+          param,
+          findOptions
+        );
+        modifiedComponent = this.componentService.addParameterToGroup(
+          modifiedComponent,
+          groupId,
+          param.id,
+          findOptions
+        );
+        componentModified = true;
+      } else {
+        this.logger.info(`Parameter "${param.id}" already exists on ${targetComponentType}`);
+        const group = this.componentService.findParameter(
+          modifiedComponent,
+          groupId,
+          findOptions
+        );
+        if (group && this.componentService.isGroupParameter(group)) {
+          const isInGroup = group.typeConfig?.childrenParams?.some(
+            (id) => strict ? id === param.id : id.toLowerCase() === param.id.toLowerCase()
+          );
+          if (!isInGroup) {
+            modifiedComponent = this.componentService.addParameterToGroup(
+              modifiedComponent,
+              groupId,
+              param.id,
+              findOptions
+            );
+            componentModified = true;
+          }
+        }
+      }
+    }
+    if (componentModified && !whatIf) {
+      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
+    }
+    const compositions = await this.compositionService.findCompositionsByTypes(
+      fullCompositionsDir,
+      compositionTypes,
+      findOptions
+    );
+    let modifiedCompositions = 0;
+    let propagatedInstances = 0;
+    for (const { composition, filePath } of compositions) {
+      const rootOverrides = this.compositionService.getRootOverrides(composition);
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
+      );
+      if (instances.length === 0) {
+        continue;
+      }
+      const valuesToPropagate = {};
+      for (const param of resolvedParams) {
+        if (rootOverrides[param.id]) {
+          valuesToPropagate[param.id] = rootOverrides[param.id];
+        }
+      }
+      if (Object.keys(valuesToPropagate).length === 0) {
+        continue;
+      }
+      let compositionModified = false;
+      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+      const instanceUpdates = [];
+      for (const { instance, instanceId } of instances) {
+        const instanceName = instance._id ?? instanceId;
+        const clonedValues = regenerateIds(valuesToPropagate, instanceName);
+        this.compositionService.setInstanceParameters(instance, clonedValues);
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${Object.keys(valuesToPropagate).join(", ")}`
+        );
+      }
+      if (compositionModified) {
+        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
+        for (const update of instanceUpdates) {
+          this.logger.detail(`\u2192 ${update}`);
+        }
+        if (!whatIf) {
+          await this.compositionService.saveComposition(filePath, composition);
+        }
+        modifiedCompositions++;
+      }
+    }
+    let modifiedSourceComponents = 0;
+    if (deleteSourceParameter) {
+      for (const { sourceType, sourceFilePath, sourceComponent } of sourceComponents) {
+        let modifiedSource = { ...sourceComponent };
+        let sourceComponentModified = false;
+        for (const param of resolvedParams) {
+          const exists = this.componentService.findParameter(modifiedSource, param.id, findOptions);
+          if (exists) {
+            this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
+            modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+            sourceComponentModified = true;
+          }
+        }
+        const beforeGroupCount = modifiedSource.parameters?.filter(
+          (p) => this.componentService.isGroupParameter(p)
+        ).length ?? 0;
+        modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
+        const afterGroupCount = modifiedSource.parameters?.filter(
+          (p) => this.componentService.isGroupParameter(p)
+        ).length ?? 0;
+        if (afterGroupCount < beforeGroupCount) {
+          const removedCount = beforeGroupCount - afterGroupCount;
+          this.logger.action(
+            whatIf,
+            "DELETE",
+            `${removedCount} empty group(s) from ${sourceType}`
+          );
+          sourceComponentModified = true;
+        }
+        if (sourceComponentModified) {
+          modifiedSourceComponents++;
+        }
+        if (sourceComponentModified && !whatIf) {
+          await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+        }
+      }
+      for (const { composition, filePath } of compositions) {
+        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+        const deleted = this.compositionService.deleteRootOverrides(
+          composition,
+          resolvedNames,
+          findOptions
+        );
+        if (deleted) {
+          this.logger.action(whatIf, "DELETE", `Root overrides from composition/${relativePath}`);
+          this.logger.detail(`\u2192 Removed: ${resolvedNames.join(", ")}`);
+          if (!whatIf) {
+            await this.compositionService.saveComposition(filePath, composition);
+          }
+        }
+      }
+    }
+    return {
+      modifiedComponents: (componentModified ? 1 : 0) + modifiedSourceComponents,
+      modifiedCompositions,
+      propagatedInstances
+    };
+  }
+  parsePipeSeparatedValues(value, strict) {
+    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    const normalized = [];
+    for (const entry of entries) {
+      const exists = normalized.some(
+        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+      );
+      if (!exists) {
+        normalized.push(entry);
+      }
+    }
+    return normalized;
+  }
+};
+
+// src/cli/logger.ts
+import chalk from "chalk";
+var Logger = class {
+  info(message) {
+    console.log(`${chalk.blue("[INFO]")} ${message}`);
+  }
+  success(message) {
+    console.log(`${chalk.green("[DONE]")} ${message}`);
+  }
+  error(message) {
+    console.log(`${chalk.red("[ERROR]")} ${message}`);
+  }
+  warn(message) {
+    console.log(`${chalk.yellow("[WARN]")} ${message}`);
+  }
+  action(whatIf, actionType, message) {
+    const prefix = whatIf ? chalk.yellow("[WOULD]") : chalk.green(`[${actionType}]`);
+    console.log(`${prefix} ${message}`);
+  }
+  detail(message) {
+    console.log(`  ${chalk.gray(message)}`);
+  }
+};
+
+// src/cli/commands/propagate-root-component-property.ts
+function createPropagateRootComponentPropertyCommand() {
+  const command = new Command("propagate-root-component-property");
+  command.description(
+    "Copies property definitions from a composition type's root component to a target component type, then propagates the actual values across all matching compositions."
+  ).option(
     "--compositionType <type>",
     "The composition type(s) to process. Supports pipe-separated lists (e.g., HomePage|LandingPage)"
   ).option("--property <properties>", "Pipe-separated list of properties and/or groups to copy").option(
@@ -3159,74 +3651,17 @@ var ComponentAdderService = class {
     }
     return modified;
   }
-};
-
-// src/cli/commands/add-component.ts
-function createAddComponentCommand() {
-  const command = new Command7("add-component");
-  command.description("Adds a component instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component will be added").option("--newComponentType <type>", "The component type to add").option("--parameters <params>", "Pipe-separated parameter assignments (key1:value1|key2:value2)").hook("preAction", (thisCommand) => {
-    const opts = thisCommand.opts();
-    const requiredOptions = [
-      { name: "parentComponentType", flag: "--parentComponentType" },
-      { name: "slot", flag: "--slot" },
-      { name: "newComponentType", flag: "--newComponentType" }
-    ];
-    const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
-    if (missing.length > 0) {
-      console.error(`error: missing required options: ${missing.join(", ")}`);
-      process.exit(1);
-    }
-  }).action(async (opts, cmd) => {
-    const globalOpts = cmd.optsWithGlobals();
-    const options = {
-      ...globalOpts,
-      parentComponentType: opts.parentComponentType,
-      slot: opts.slot,
-      newComponentType: opts.newComponentType,
-      parameters: opts.parameters
-    };
-    const logger = new Logger();
-    const fileSystem = new FileSystemService();
-    const componentService = new ComponentService(fileSystem);
-    const adder = new ComponentAdderService(fileSystem, componentService, logger);
-    try {
-      const result = await adder.addComponent({
-        rootDir: options.rootDir,
-        componentsDir: options.componentsDir,
-        compositionsDir: options.compositionsDir,
-        compositionPatternsDir: options.compositionPatternsDir,
-        componentPatternsDir: options.componentPatternsDir,
-        parentComponentType: options.parentComponentType,
-        slot: options.slot,
-        newComponentType: options.newComponentType,
-        parameters: options.parameters,
-        whatIf: options.whatIf ?? false,
-        strict: options.strict ?? false
-      });
-      logger.success(
-        `Added component: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
-      );
-    } catch (error) {
-      if (error instanceof TransformError) {
-        logger.error(error.message);
-        process.exit(1);
-      }
-      throw error;
-    }
-  });
-  return command;
-}
+};
 
-// src/cli/commands/add-component-pattern.ts
-import { Command as Command8 } from "commander";
-function createAddComponentPatternCommand() {
-  const command = new Command8("add-component-pattern");
-  command.description("Adds a component pattern instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component pattern will be added").option("--componentPatternId <id>", "The component pattern ID to add").hook("preAction", (thisCommand) => {
+// src/cli/commands/add-component.ts
+function createAddComponentCommand() {
+  const command = new Command7("add-component");
+  command.description("Adds a component instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component will be added").option("--newComponentType <type>", "The component type to add").option("--parameters <params>", "Pipe-separated parameter assignments (key1:value1|key2:value2)").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
       { name: "parentComponentType", flag: "--parentComponentType" },
       { name: "slot", flag: "--slot" },
-      { name: "componentPatternId", flag: "--componentPatternId" }
+      { name: "newComponentType", flag: "--newComponentType" }
     ];
     const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
     if (missing.length > 0) {
@@ -3239,288 +3674,51 @@ function createAddComponentPatternCommand() {
       ...globalOpts,
       parentComponentType: opts.parentComponentType,
       slot: opts.slot,
-      componentPatternId: opts.componentPatternId
+      newComponentType: opts.newComponentType,
+      parameters: opts.parameters
     };
     const logger = new Logger();
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
     const adder = new ComponentAdderService(fileSystem, componentService, logger);
     try {
-      const result = await adder.addComponentPattern({
+      const result = await adder.addComponent({
         rootDir: options.rootDir,
-        componentsDir: options.componentsDir,
-        compositionsDir: options.compositionsDir,
-        compositionPatternsDir: options.compositionPatternsDir,
-        componentPatternsDir: options.componentPatternsDir,
-        parentComponentType: options.parentComponentType,
-        slot: options.slot,
-        componentPatternId: options.componentPatternId,
-        whatIf: options.whatIf ?? false,
-        strict: options.strict ?? false
-      });
-      logger.success(
-        `Added component pattern: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
-      );
-    } catch (error) {
-      if (error instanceof TransformError) {
-        logger.error(error.message);
-        process.exit(1);
-      }
-      throw error;
-    }
-  });
-  return command;
-}
-
-// src/cli/commands/propagate-root-component-slot.ts
-import { Command as Command9 } from "commander";
-
-// src/core/services/slot-propagator.service.ts
-var SlotPropagatorService = class {
-  constructor(fileSystem, componentService, compositionService, logger) {
-    this.fileSystem = fileSystem;
-    this.componentService = componentService;
-    this.compositionService = compositionService;
-    this.logger = logger;
-  }
-  async propagate(options) {
-    const {
-      rootDir,
-      componentsDir,
-      compositionsDir,
-      compositionType,
-      slot,
-      targetComponentType,
-      targetSlot,
-      whatIf,
-      strict,
-      deleteSourceSlot
-    } = options;
-    const findOptions = { strict };
-    const compositionTypes = this.parsePipeSeparatedValues(compositionType, strict);
-    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const sourceComponents = [];
-    for (const sourceType of compositionTypes) {
-      this.logger.info(`Loading component: ${sourceType}`);
-      const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
-      sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
-    }
-    this.logger.info(`Loading component: ${targetComponentType}`);
-    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
-    const slotNames = slot.split("|").map((s) => s.trim()).filter((s) => s.length > 0);
-    const resolvedSlots = [];
-    const resolvedSlotIds = [];
-    for (const { sourceType, sourceComponent } of sourceComponents) {
-      const notFound = [];
-      for (const slotName of slotNames) {
-        const slotDef = this.componentService.findSlot(sourceComponent, slotName, findOptions);
-        if (!slotDef) {
-          notFound.push(slotName);
-          continue;
-        }
-        const exists = resolvedSlots.some(
-          (existing) => strict ? existing.id === slotDef.id : existing.id.toLowerCase() === slotDef.id.toLowerCase()
-        );
-        if (!exists) {
-          resolvedSlots.push(slotDef);
-          resolvedSlotIds.push(slotDef.id);
-        }
-      }
-      if (notFound.length > 0) {
-        throw new PropertyNotFoundError(`Slot "${notFound.join(", ")}"`, sourceType);
-      }
-    }
-    this.logger.info(`Resolved slots: ${resolvedSlotIds.join(", ")}`);
-    let modifiedComponent = { ...targetComponent };
-    let componentModified = false;
-    const existingSlot = this.componentService.findSlot(modifiedComponent, targetSlot, findOptions);
-    if (!existingSlot) {
-      const mergedAllowedComponents = this.mergeAllowedComponents(resolvedSlots);
-      this.logger.action(whatIf, "CREATE", `Slot "${targetSlot}" on ${targetComponentType}`);
-      modifiedComponent = this.componentService.addSlot(modifiedComponent, {
-        id: targetSlot,
-        name: targetSlot,
-        allowedComponents: mergedAllowedComponents
-      });
-      componentModified = true;
-    } else {
-      const mergedAllowedComponents = this.mergeAllowedComponents([existingSlot, ...resolvedSlots]);
-      const existingAllowed = existingSlot.allowedComponents ?? [];
-      if (mergedAllowedComponents.length > existingAllowed.length) {
-        this.logger.action(
-          whatIf,
-          "UPDATE",
-          `Slot "${targetSlot}" allowedComponents on ${targetComponentType}`
-        );
-        modifiedComponent = this.componentService.updateSlotAllowedComponents(
-          modifiedComponent,
-          targetSlot,
-          mergedAllowedComponents,
-          findOptions
-        );
-        componentModified = true;
-      } else {
-        this.logger.info(`Slot "${targetSlot}" already exists on ${targetComponentType}`);
-      }
-    }
-    if (componentModified && !whatIf) {
-      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
-    }
-    const compositions = await this.compositionService.findCompositionsByTypes(
-      fullCompositionsDir,
-      compositionTypes,
-      findOptions
-    );
-    let modifiedCompositions = 0;
-    let propagatedInstances = 0;
-    for (const { composition, filePath } of compositions) {
-      const rootSlots = composition.composition.slots ?? {};
-      const instances = this.compositionService.findComponentInstances(
-        composition,
-        targetComponentType,
-        findOptions
-      );
-      if (instances.length === 0) {
-        continue;
-      }
-      const componentsToPropagate = [];
-      for (const slotDef of resolvedSlots) {
-        const slotContent = rootSlots[slotDef.id] ?? [];
-        componentsToPropagate.push(...slotContent);
-      }
-      if (componentsToPropagate.length === 0) {
-        continue;
-      }
-      let compositionModified = false;
-      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
-      const instanceUpdates = [];
-      for (const { instance, instanceId } of instances) {
-        const instanceName = instance._id ?? instanceId;
-        const clonedComponents = this.deepCloneComponents(componentsToPropagate);
-        this.addComponentsToInstanceSlot(instance, targetSlot, clonedComponents);
-        compositionModified = true;
-        propagatedInstances++;
-        instanceUpdates.push(
-          `${targetComponentType} "${instanceName}": ${componentsToPropagate.length} component(s) \u2192 ${targetSlot}`
-        );
-      }
-      if (compositionModified) {
-        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
-        for (const update of instanceUpdates) {
-          this.logger.detail(`\u2192 ${update}`);
-        }
-        if (!whatIf) {
-          await this.compositionService.saveComposition(filePath, composition);
-        }
-        modifiedCompositions++;
-      }
-    }
-    let modifiedSourceComponents = 0;
-    if (deleteSourceSlot) {
-      for (const { sourceType, sourceFilePath, sourceComponent } of sourceComponents) {
-        let modifiedSource = { ...sourceComponent };
-        let sourceComponentModified = false;
-        for (const slotDef of resolvedSlots) {
-          const slotToDelete = this.componentService.findSlot(modifiedSource, slotDef.id, findOptions);
-          if (!slotToDelete) {
-            continue;
-          }
-          this.logger.action(whatIf, "DELETE", `Slot "${slotDef.id}" from ${sourceType}`);
-          modifiedSource = this.componentService.removeSlot(modifiedSource, slotDef.id, findOptions);
-          sourceComponentModified = true;
-        }
-        if (sourceComponentModified) {
-          modifiedSourceComponents++;
-        }
-        if (sourceComponentModified && !whatIf) {
-          await this.componentService.saveComponent(sourceFilePath, modifiedSource);
-        }
-      }
-      for (const { composition, filePath } of compositions) {
-        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
-        let cleared = false;
-        for (const slotDef of resolvedSlots) {
-          if (composition.composition.slots?.[slotDef.id]?.length) {
-            composition.composition.slots[slotDef.id] = [];
-            cleared = true;
-          }
-        }
-        if (cleared) {
-          this.logger.action(whatIf, "CLEAR", `Root slots in composition/${relativePath}`);
-          this.logger.detail(`\u2192 Cleared: ${resolvedSlotIds.join(", ")}`);
-          if (!whatIf) {
-            await this.compositionService.saveComposition(filePath, composition);
-          }
-        }
-      }
-    }
-    return {
-      modifiedComponents: (componentModified ? 1 : 0) + modifiedSourceComponents,
-      modifiedCompositions,
-      propagatedInstances
-    };
-  }
-  mergeAllowedComponents(slots) {
-    const allowed = /* @__PURE__ */ new Set();
-    for (const slot of slots) {
-      for (const comp of slot.allowedComponents ?? []) {
-        allowed.add(comp);
-      }
-    }
-    return Array.from(allowed).sort();
-  }
-  deepCloneComponents(components) {
-    return JSON.parse(JSON.stringify(components));
-  }
-  addComponentsToInstanceSlot(instance, slotName, components) {
-    if (!instance.slots) {
-      instance.slots = {};
-    }
-    if (!instance.slots[slotName]) {
-      instance.slots[slotName] = [];
-    }
-    instance.slots[slotName].push(...components);
-  }
-  parsePipeSeparatedValues(value, strict) {
-    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-    const normalized = [];
-    for (const entry of entries) {
-      const exists = normalized.some(
-        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        parentComponentType: options.parentComponentType,
+        slot: options.slot,
+        newComponentType: options.newComponentType,
+        parameters: options.parameters,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `Added component: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
-      if (!exists) {
-        normalized.push(entry);
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
       }
+      throw error;
     }
-    return normalized;
-  }
-};
+  });
+  return command;
+}
 
-// src/cli/commands/propagate-root-component-slot.ts
-function createPropagateRootComponentSlotCommand() {
-  const command = new Command9("propagate-root-component-slot");
-  command.description(
-    "Copies slot definitions from a composition type's root component to a target component type, then moves all component instances from that slot across all matching compositions."
-  ).option(
-    "--compositionType <type>",
-    "The composition type(s) to process. Supports pipe-separated lists (e.g., HomePage|LandingPage)"
-  ).option("--slot <slots>", "Pipe-separated list of slot names to copy from the source component").option(
-    "--targetComponentType <type>",
-    "The component type that will receive the copied slots"
-  ).option(
-    "--targetSlot <slot>",
-    "The slot name on the target component where the contents will be placed"
-  ).option(
-    "--deleteSourceSlot",
-    "Delete the original slots from the source component after propagation"
-  ).hook("preAction", (thisCommand) => {
+// src/cli/commands/add-component-pattern.ts
+import { Command as Command8 } from "commander";
+function createAddComponentPatternCommand() {
+  const command = new Command8("add-component-pattern");
+  command.description("Adds a component pattern instance to existing component slots across all compositions.").option("--parentComponentType <type>", "The component type that owns the slot").option("--slot <slotId>", "The slot ID where the component pattern will be added").option("--componentPatternId <id>", "The component pattern ID to add").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
-      { name: "compositionType", flag: "--compositionType" },
+      { name: "parentComponentType", flag: "--parentComponentType" },
       { name: "slot", flag: "--slot" },
-      { name: "targetComponentType", flag: "--targetComponentType" },
-      { name: "targetSlot", flag: "--targetSlot" }
+      { name: "componentPatternId", flag: "--componentPatternId" }
     ];
     const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
     if (missing.length > 0) {
@@ -3531,37 +3729,29 @@ function createPropagateRootComponentSlotCommand() {
     const globalOpts = cmd.optsWithGlobals();
     const options = {
       ...globalOpts,
-      compositionType: opts.compositionType,
+      parentComponentType: opts.parentComponentType,
       slot: opts.slot,
-      targetComponentType: opts.targetComponentType,
-      targetSlot: opts.targetSlot,
-      deleteSourceSlot: opts.deleteSourceSlot
+      componentPatternId: opts.componentPatternId
     };
     const logger = new Logger();
     const fileSystem = new FileSystemService();
     const componentService = new ComponentService(fileSystem);
-    const compositionService = new CompositionService(fileSystem);
-    const propagator = new SlotPropagatorService(
-      fileSystem,
-      componentService,
-      compositionService,
-      logger
-    );
+    const adder = new ComponentAdderService(fileSystem, componentService, logger);
     try {
-      const result = await propagator.propagate({
+      const result = await adder.addComponentPattern({
         rootDir: options.rootDir,
         componentsDir: options.componentsDir,
         compositionsDir: options.compositionsDir,
-        compositionType: options.compositionType,
+        compositionPatternsDir: options.compositionPatternsDir,
+        componentPatternsDir: options.componentPatternsDir,
+        parentComponentType: options.parentComponentType,
         slot: options.slot,
-        targetComponentType: options.targetComponentType,
-        targetSlot: options.targetSlot,
+        componentPatternId: options.componentPatternId,
         whatIf: options.whatIf ?? false,
-        strict: options.strict ?? false,
-        deleteSourceSlot: options.deleteSourceSlot ?? false
+        strict: options.strict ?? false
       });
       logger.success(
-        `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s)`
+        `Added component pattern: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
     } catch (error) {
       if (error instanceof TransformError) {
@@ -3574,473 +3764,310 @@ function createPropagateRootComponentSlotCommand() {
   return command;
 }
 
-// src/cli/commands/convert-compositions-to-entries.ts
-import { Command as Command10 } from "commander";
+// src/cli/commands/propagate-root-component-slot.ts
+import { Command as Command9 } from "commander";
 
-// src/core/services/composition-converter.service.ts
-import * as crypto from "crypto";
-var CompositionConverterService = class {
+// src/core/services/slot-propagator.service.ts
+var SlotPropagatorService = class {
   constructor(fileSystem, componentService, compositionService, logger) {
     this.fileSystem = fileSystem;
     this.componentService = componentService;
     this.compositionService = compositionService;
     this.logger = logger;
   }
-  async convert(options) {
+  async propagate(options) {
     const {
       rootDir,
-      compositionsDir,
       componentsDir,
-      contentTypesDir,
-      entriesDir,
-      compositionTypes,
-      flattenComponentIds,
-      whatIf,
-      strict
-    } = options;
-    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
-    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
-    let contentTypesWritten = 0;
-    let entriesFromCompositions = 0;
-    let entriesFromFlattened = 0;
-    let entriesReused = 0;
-    this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
-    if (flattenComponentIds.length > 0) {
-      this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
-    }
-    const sourceItemMap = flattenComponentIds.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`);
-    }
-    const compositionResults = await this.compositionService.findCompositionsByTypes(
-      compositionsDirFull,
-      compositionTypes,
-      { strict }
-    );
-    if (compositionResults.length === 0) {
-      this.logger.warn("No compositions found matching the specified types");
-      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0, entriesReused: 0 };
-    }
-    this.logger.info(`Found ${compositionResults.length} composition(s)`);
-    const rootComponentTypes = /* @__PURE__ */ new Set();
-    for (const { composition } of compositionResults) {
-      rootComponentTypes.add(composition.composition.type);
-    }
-    const contentTypeMap = /* @__PURE__ */ new Map();
-    for (const rootType of rootComponentTypes) {
-      const { component } = await this.componentService.loadComponent(
-        componentsDirFull,
-        rootType,
-        { strict }
-      );
-      const contentType = this.generateContentType(component);
-      contentTypeMap.set(rootType, contentType);
-    }
-    const flattenContentTypeMap = /* @__PURE__ */ new Map();
-    const missingFlattenTypes = [];
-    const foundMissingFlattenTypes = /* @__PURE__ */ new Set();
-    for (const flattenType of flattenComponentIds) {
-      const isRootType = [...rootComponentTypes].some(
-        (rt) => this.compareTypes(rt, flattenType, strict)
-      );
-      if (isRootType) {
-        continue;
-      }
-      try {
-        const { component } = await this.componentService.loadComponent(
-          componentsDirFull,
-          flattenType,
-          { strict }
-        );
-        const contentType = this.generateContentType(component);
-        flattenContentTypeMap.set(flattenType, contentType);
-      } catch (error) {
-        if (error instanceof ComponentNotFoundError) {
-          this.logger.info(`Flatten component type not found: ${flattenType}`);
-          missingFlattenTypes.push(flattenType);
-          continue;
-        }
-        throw error;
-      }
-    }
-    for (const { composition } of compositionResults) {
-      const comp = composition.composition;
-      const compositionId = comp._id;
-      const compositionName = comp._name ?? compositionId;
-      const compositionType = comp.type;
-      const entry = this.generateEntryFromComposition(composition);
-      const flattenedByType = /* @__PURE__ */ new Map();
-      if (flattenComponentIds.length > 0 && comp.slots) {
-        for (const flattenType of flattenComponentIds) {
-          if (this.compareTypes(flattenType, compositionType, strict)) {
-            this.logger.warn(
-              `Skipping flatten of "${flattenType}" \u2014 same as root component type`
-            );
-            continue;
-          }
-          const instances = this.findFlattenTargets(
-            comp.slots,
-            flattenType,
-            compositionId,
-            compositionName,
-            strict
-          );
-          if (instances.length > 0) {
-            flattenedByType.set(flattenType, instances);
-            if (missingFlattenTypes.includes(flattenType)) {
-              foundMissingFlattenTypes.add(flattenType);
-            }
-          }
-        }
-      }
-      const resolvedRefIds = /* @__PURE__ */ new Map();
-      for (const [flattenType, instances] of flattenedByType) {
-        const refIds = [];
-        for (const inst of instances) {
-          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
-          refIds.push(existingId ?? inst.determinisiticId);
-        }
-        resolvedRefIds.set(flattenType, refIds);
-      }
-      for (const [flattenType] of flattenedByType) {
-        entry.entry.fields[flattenType] = {
-          type: "contentReference",
-          value: resolvedRefIds.get(flattenType)
-        };
-      }
-      if (flattenComponentIds.length > 0) {
-        this.transformContentReferences(entry);
-      }
-      const entryId = entry.entry._id;
-      const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${entryId}.json`);
-      this.logger.action(
-        whatIf,
-        "WRITE",
-        `${entriesDir}/${entryId}.json (${compositionType}, "${this.truncate(compositionName, 50)}")`
-      );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(entryFilePath, entry);
-      }
-      entriesFromCompositions++;
-      for (const [flattenType, instances] of flattenedByType) {
-        for (const inst of instances) {
-          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
-          if (existingId) {
-            this.logger.info(
-              `Reusing existing entry ${existingId} for ${flattenType} (sourceItem match)`
-            );
-            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 (${flattenType} from "${this.truncate(compositionName, 50)}")`
-          );
-          if (!whatIf) {
-            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
-          }
-          entriesFromFlattened++;
-        }
-      }
+      compositionsDir,
+      compositionType,
+      slot,
+      targetComponentType,
+      targetSlot,
+      whatIf,
+      strict,
+      deleteSourceSlot
+    } = options;
+    const findOptions = { strict };
+    const compositionTypes = this.parsePipeSeparatedValues(compositionType, strict);
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const sourceComponents = [];
+    for (const sourceType of compositionTypes) {
+      this.logger.info(`Loading component: ${sourceType}`);
+      const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
+      sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
     }
-    if (flattenComponentIds.length > 0) {
-      for (const contentType of contentTypeMap.values()) {
-        for (const flattenType of flattenComponentIds) {
-          if (this.compareTypes(flattenType, contentType.id, strict)) {
-            continue;
-          }
-          if (missingFlattenTypes.includes(flattenType) && !foundMissingFlattenTypes.has(flattenType)) {
-            continue;
-          }
-          contentType.fields.push({
-            id: flattenType,
-            name: flattenType,
-            type: "contentReference",
-            typeConfig: {
-              isMulti: true,
-              allowedContentTypes: [flattenType]
-            },
-            localizable: false
-          });
+    this.logger.info(`Loading component: ${targetComponentType}`);
+    const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
+    const slotNames = slot.split("|").map((s) => s.trim()).filter((s) => s.length > 0);
+    const resolvedSlots = [];
+    const resolvedSlotIds = [];
+    for (const { sourceType, sourceComponent } of sourceComponents) {
+      const notFound = [];
+      for (const slotName of slotNames) {
+        const slotDef = this.componentService.findSlot(sourceComponent, slotName, findOptions);
+        if (!slotDef) {
+          notFound.push(slotName);
+          continue;
+        }
+        const exists = resolvedSlots.some(
+          (existing) => strict ? existing.id === slotDef.id : existing.id.toLowerCase() === slotDef.id.toLowerCase()
+        );
+        if (!exists) {
+          resolvedSlots.push(slotDef);
+          resolvedSlotIds.push(slotDef.id);
         }
       }
-    }
-    for (const [typeName, contentType] of contentTypeMap) {
-      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
-      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
-      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
-      this.logger.action(
-        whatIf,
-        "WRITE",
-        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
-      );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
+      if (notFound.length > 0) {
+        throw new PropertyNotFoundError(`Slot "${notFound.join(", ")}"`, sourceType);
       }
-      contentTypesWritten++;
     }
-    for (const [typeName, contentType] of flattenContentTypeMap) {
-      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      this.logger.action(
-        whatIf,
-        "WRITE",
-        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
-      );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
+    this.logger.info(`Resolved slots: ${resolvedSlotIds.join(", ")}`);
+    let modifiedComponent = { ...targetComponent };
+    let componentModified = false;
+    const existingSlot = this.componentService.findSlot(modifiedComponent, targetSlot, findOptions);
+    if (!existingSlot) {
+      const mergedAllowedComponents = this.mergeAllowedComponents(resolvedSlots);
+      this.logger.action(whatIf, "CREATE", `Slot "${targetSlot}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.addSlot(modifiedComponent, {
+        id: targetSlot,
+        name: targetSlot,
+        allowedComponents: mergedAllowedComponents
+      });
+      componentModified = true;
+    } else {
+      const mergedAllowedComponents = this.mergeAllowedComponents([existingSlot, ...resolvedSlots]);
+      const existingAllowed = existingSlot.allowedComponents ?? [];
+      if (mergedAllowedComponents.length > existingAllowed.length) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `Slot "${targetSlot}" allowedComponents on ${targetComponentType}`
+        );
+        modifiedComponent = this.componentService.updateSlotAllowedComponents(
+          modifiedComponent,
+          targetSlot,
+          mergedAllowedComponents,
+          findOptions
+        );
+        componentModified = true;
+      } else {
+        this.logger.info(`Slot "${targetSlot}" already exists on ${targetComponentType}`);
       }
-      contentTypesWritten++;
     }
-    const neverFoundMissingTypes = missingFlattenTypes.filter(
-      (type) => !foundMissingFlattenTypes.has(type)
+    if (componentModified && !whatIf) {
+      await this.componentService.saveComponent(targetFilePath, modifiedComponent);
+    }
+    const compositions = await this.compositionService.findCompositionsByTypes(
+      fullCompositionsDir,
+      compositionTypes,
+      findOptions
     );
-    if (neverFoundMissingTypes.length > 0) {
-      this.logger.warn(
-        `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
+    let modifiedCompositions = 0;
+    let propagatedInstances = 0;
+    for (const { composition, filePath } of compositions) {
+      const rootSlots = composition.composition.slots ?? {};
+      const instances = this.compositionService.findComponentInstances(
+        composition,
+        targetComponentType,
+        findOptions
       );
-    }
-    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened, entriesReused };
-  }
-  // --- Content Type Generation ---
-  generateContentType(component) {
-    const fields = [];
-    if (component.parameters) {
-      for (const param of component.parameters) {
-        fields.push(this.parameterToField(param));
+      if (instances.length === 0) {
+        continue;
       }
-    }
-    return {
-      id: component.id,
-      name: component.name,
-      fields
-    };
-  }
-  parameterToField(param) {
-    const field = {
-      id: param.id,
-      name: param.name,
-      type: param.type
-    };
-    if (param.helpText !== void 0) {
-      field.helpText = param.helpText;
-    }
-    if (param.localizable !== void 0) {
-      field.localizable = param.localizable;
-    }
-    if (param.typeConfig !== void 0) {
-      field.typeConfig = param.typeConfig;
-    }
-    return field;
-  }
-  // --- Entry Generation ---
-  generateEntryFromComposition(composition) {
-    const comp = composition.composition;
-    const compositionSpecificKeys = /* @__PURE__ */ new Set(["_id", "_name", "type", "parameters", "slots", "_overrides"]);
-    const extraRootProps = {};
-    for (const [key, value] of Object.entries(comp)) {
-      if (!compositionSpecificKeys.has(key) && value != null) {
-        extraRootProps[key] = value;
+      const componentsToPropagate = [];
+      for (const slotDef of resolvedSlots) {
+        const slotContent = rootSlots[slotDef.id] ?? [];
+        componentsToPropagate.push(...slotContent);
       }
-    }
-    const wrapperKeys = /* @__PURE__ */ new Set(["composition"]);
-    const extraWrapperProps = {};
-    for (const [key, value] of Object.entries(composition)) {
-      if (!wrapperKeys.has(key) && value != null) {
-        extraWrapperProps[key] = value;
+      if (componentsToPropagate.length === 0) {
+        continue;
       }
-    }
-    const entryId = computeGuidHash(`entry${comp._id}`);
-    const entryName = this.truncateName(comp._name ?? comp._id, 60);
-    return {
-      entry: {
-        _id: entryId,
-        _name: entryName,
-        type: comp.type,
-        fields: { ...comp.parameters ?? {} },
-        ...extraRootProps
-      },
-      ...extraWrapperProps
-    };
-  }
-  generateEntryFromFlattenedInstance(inst) {
-    const entryName = this.truncateName(
-      `${inst.componentType} (from ${inst.compositionName})`,
-      60
-    );
-    return {
-      entry: {
-        _id: inst.determinisiticId,
-        _name: entryName,
-        type: inst.componentType,
-        fields: { ...inst.instance.parameters ?? {} }
+      let compositionModified = false;
+      const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+      const instanceUpdates = [];
+      for (const { instance, instanceId } of instances) {
+        const instanceName = instance._id ?? instanceId;
+        const clonedComponents = regenerateIds(componentsToPropagate, `${instanceName}.${targetSlot}`);
+        this.addComponentsToInstanceSlot(instance, targetSlot, clonedComponents);
+        compositionModified = true;
+        propagatedInstances++;
+        instanceUpdates.push(
+          `${targetComponentType} "${instanceName}": ${componentsToPropagate.length} component(s) \u2192 ${targetSlot}`
+        );
       }
-    };
-  }
-  // --- Flatten Tree Walking ---
-  findFlattenTargets(slots, targetType, compositionId, compositionName, strict) {
-    const results = [];
-    this.walkSlots(slots, targetType, compositionId, compositionName, "", results, strict);
-    return results;
-  }
-  walkSlots(slots, targetType, compositionId, compositionName, pathPrefix, results, strict) {
-    for (const [slotName, instances] of Object.entries(slots)) {
-      if (!Array.isArray(instances)) continue;
-      for (let i = 0; i < instances.length; i++) {
-        const instance = instances[i];
-        if (instance._pattern) {
-          continue;
+      if (compositionModified) {
+        this.logger.action(whatIf, "UPDATE", `composition/${relativePath}`);
+        for (const update of instanceUpdates) {
+          this.logger.detail(`\u2192 ${update}`);
+        }
+        if (!whatIf) {
+          await this.compositionService.saveComposition(filePath, composition);
+        }
+        modifiedCompositions++;
+      }
+    }
+    let modifiedSourceComponents = 0;
+    if (deleteSourceSlot) {
+      for (const { sourceType, sourceFilePath, sourceComponent } of sourceComponents) {
+        let modifiedSource = { ...sourceComponent };
+        let sourceComponentModified = false;
+        for (const slotDef of resolvedSlots) {
+          const slotToDelete = this.componentService.findSlot(modifiedSource, slotDef.id, findOptions);
+          if (!slotToDelete) {
+            continue;
+          }
+          this.logger.action(whatIf, "DELETE", `Slot "${slotDef.id}" from ${sourceType}`);
+          modifiedSource = this.componentService.removeSlot(modifiedSource, slotDef.id, findOptions);
+          sourceComponentModified = true;
         }
-        const currentPath = pathPrefix ? `${pathPrefix}-${slotName}-[${i}]-${instance.type}` : `${slotName}-[${i}]-${instance.type}`;
-        if (this.compareTypes(instance.type, targetType, strict)) {
-          const fullPath = `${compositionId}-${currentPath}`;
-          const deterministicId = computeGuidHash(fullPath);
-          results.push({
-            instance,
-            path: fullPath,
-            determinisiticId: deterministicId,
-            componentType: instance.type,
-            compositionId,
-            compositionName
-          });
+        if (sourceComponentModified) {
+          modifiedSourceComponents++;
         }
-        if (instance.slots) {
-          this.walkSlots(
-            instance.slots,
-            targetType,
-            compositionId,
-            compositionName,
-            currentPath,
-            results,
-            strict
-          );
+        if (sourceComponentModified && !whatIf) {
+          await this.componentService.saveComponent(sourceFilePath, modifiedSource);
         }
       }
-    }
-  }
-  // --- Content Reference Transformation ---
-  transformContentReferences(entry) {
-    const dataResources = {};
-    for (const [fieldName, field] of Object.entries(entry.entry.fields)) {
-      if (field.type === "contentReference" && Array.isArray(field.value)) {
-        const entryIds = field.value;
-        const resourceKey = `ref-${entry.entry._id}-${fieldName}`;
-        field.value = `\${#jptr:/${resourceKey}/entries}`;
-        dataResources[resourceKey] = {
-          type: "uniformContentInternalReference",
-          variables: {
-            locale: "${locale}",
-            entryIds: entryIds.join(",")
+      for (const { composition, filePath } of compositions) {
+        const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
+        let cleared = false;
+        for (const slotDef of resolvedSlots) {
+          if (composition.composition.slots?.[slotDef.id]?.length) {
+            composition.composition.slots[slotDef.id] = [];
+            cleared = true;
           }
-        };
+        }
+        if (cleared) {
+          this.logger.action(whatIf, "CLEAR", `Root slots in composition/${relativePath}`);
+          this.logger.detail(`\u2192 Cleared: ${resolvedSlotIds.join(", ")}`);
+          if (!whatIf) {
+            await this.compositionService.saveComposition(filePath, composition);
+          }
+        }
       }
     }
-    if (Object.keys(dataResources).length > 0) {
-      entry.entry._dataResources = {
-        ...entry.entry._dataResources ?? {},
-        ...dataResources
-      };
-    }
+    return {
+      modifiedComponents: (componentModified ? 1 : 0) + modifiedSourceComponents,
+      modifiedCompositions,
+      propagatedInstances
+    };
   }
-  // --- Source Item Matching ---
-  async buildSourceItemMap(entriesDirFull) {
-    const sourceItemMap = /* @__PURE__ */ new Map();
-    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "*.json");
-    for (const filePath of entryFiles) {
-      try {
-        const entryData = await this.fileSystem.readFile(filePath);
-        const sourceItemField = entryData?.entry?.fields?.sourceItem;
-        if (sourceItemField?.value != null) {
-          sourceItemMap.set(String(sourceItemField.value), entryData.entry._id);
-        }
-      } catch {
-        continue;
+  mergeAllowedComponents(slots) {
+    const allowed = /* @__PURE__ */ new Set();
+    for (const slot of slots) {
+      for (const comp of slot.allowedComponents ?? []) {
+        allowed.add(comp);
       }
     }
-    return sourceItemMap;
+    return Array.from(allowed).sort();
   }
-  findExistingEntryBySourceItem(inst, sourceItemMap) {
-    const sourceItemParam = inst.instance.parameters?.sourceItem;
-    if (sourceItemParam?.value == null) {
-      return void 0;
-    }
-    return sourceItemMap.get(String(sourceItemParam.value));
+  deepCloneComponents(components) {
+    return JSON.parse(JSON.stringify(components));
   }
-  // --- Utilities ---
-  compareTypes(type1, type2, strict) {
-    if (strict) {
-      return type1 === type2;
+  addComponentsToInstanceSlot(instance, slotName, components) {
+    if (!instance.slots) {
+      instance.slots = {};
     }
-    return type1.toLowerCase() === type2.toLowerCase();
-  }
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) return str;
-    return str.substring(0, maxLength - 3) + "...";
+    if (!instance.slots[slotName]) {
+      instance.slots[slotName] = [];
+    }
+    instance.slots[slotName].push(...components);
   }
-  truncateName(name, maxLength) {
-    if (name.length <= maxLength) return name;
-    return name.substring(0, maxLength);
+  parsePipeSeparatedValues(value, strict) {
+    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    const normalized = [];
+    for (const entry of entries) {
+      const exists = normalized.some(
+        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+      );
+      if (!exists) {
+        normalized.push(entry);
+      }
+    }
+    return normalized;
   }
 };
-function computeGuidHash(guidOrSeed) {
-  let uuidStr;
-  if (isValidUuid(guidOrSeed)) {
-    uuidStr = formatAsBracedUuid(guidOrSeed);
-  } else {
-    const hash = crypto.createHash("md5").update(guidOrSeed, "utf-8").digest();
-    const hex = [
-      // First 4 bytes: little-endian in .NET Guid
-      hash[3].toString(16).padStart(2, "0"),
-      hash[2].toString(16).padStart(2, "0"),
-      hash[1].toString(16).padStart(2, "0"),
-      hash[0].toString(16).padStart(2, "0"),
-      "-",
-      // Bytes 4-5: little-endian
-      hash[5].toString(16).padStart(2, "0"),
-      hash[4].toString(16).padStart(2, "0"),
-      "-",
-      // Bytes 6-7: little-endian
-      hash[7].toString(16).padStart(2, "0"),
-      hash[6].toString(16).padStart(2, "0"),
-      "-",
-      // Bytes 8-9: big-endian
-      hash[8].toString(16).padStart(2, "0"),
-      hash[9].toString(16).padStart(2, "0"),
-      "-",
-      // Bytes 10-15: big-endian
-      hash[10].toString(16).padStart(2, "0"),
-      hash[11].toString(16).padStart(2, "0"),
-      hash[12].toString(16).padStart(2, "0"),
-      hash[13].toString(16).padStart(2, "0"),
-      hash[14].toString(16).padStart(2, "0"),
-      hash[15].toString(16).padStart(2, "0")
-    ].join("");
-    uuidStr = `{${hex}}`.toUpperCase();
-  }
-  const chars = uuidStr.split("");
-  chars[15] = "4";
-  const arr20 = ["8", "9", "A", "B"];
-  const hexVal = parseInt(chars[20], 16);
-  chars[20] = arr20[hexVal % 4];
-  return chars.join("").slice(1, -1).toLowerCase();
-}
-function isValidUuid(str) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
-}
-function formatAsBracedUuid(uuid) {
-  const clean = uuid.replace(/[{}]/g, "").toUpperCase();
-  return `{${clean}}`;
+
+// src/cli/commands/propagate-root-component-slot.ts
+function createPropagateRootComponentSlotCommand() {
+  const command = new Command9("propagate-root-component-slot");
+  command.description(
+    "Copies slot definitions from a composition type's root component to a target component type, then moves all component instances from that slot across all matching compositions."
+  ).option(
+    "--compositionType <type>",
+    "The composition type(s) to process. Supports pipe-separated lists (e.g., HomePage|LandingPage)"
+  ).option("--slot <slots>", "Pipe-separated list of slot names to copy from the source component").option(
+    "--targetComponentType <type>",
+    "The component type that will receive the copied slots"
+  ).option(
+    "--targetSlot <slot>",
+    "The slot name on the target component where the contents will be placed"
+  ).option(
+    "--deleteSourceSlot",
+    "Delete the original slots from the source component after propagation"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionType", flag: "--compositionType" },
+      { name: "slot", flag: "--slot" },
+      { name: "targetComponentType", flag: "--targetComponentType" },
+      { name: "targetSlot", flag: "--targetSlot" }
+    ];
+    const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
+    if (missing.length > 0) {
+      console.error(`error: missing required options: ${missing.join(", ")}`);
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      compositionType: opts.compositionType,
+      slot: opts.slot,
+      targetComponentType: opts.targetComponentType,
+      targetSlot: opts.targetSlot,
+      deleteSourceSlot: opts.deleteSourceSlot
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const propagator = new SlotPropagatorService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const result = await propagator.propagate({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        compositionsDir: options.compositionsDir,
+        compositionType: options.compositionType,
+        slot: options.slot,
+        targetComponentType: options.targetComponentType,
+        targetSlot: options.targetSlot,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false,
+        deleteSourceSlot: options.deleteSourceSlot ?? false
+      });
+      logger.success(
+        `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s)`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
 }
 
 // src/cli/commands/convert-compositions-to-entries.ts
+import { Command as Command10 } from "commander";
 function createConvertCompositionsToEntriesCommand() {
   const command = new Command10("convert-compositions-to-entries");
   command.description(
@@ -4649,7 +4676,7 @@ function createRemoveFieldCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.16",
+  version: "1.1.17",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {