@uniformdev/transformer 1.1.16 → 1.1.17

package/dist/index.js

@@ -513,624 +513,869 @@ 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/core/services/slot-renamer.service.ts
-var SlotRenamerService = class {
-  constructor(fileSystem, componentService, logger) {
-    this.fileSystem = fileSystem;
-    this.componentService = componentService;
-    this.logger = logger;
-  }
-  compareIds(id1, id2, strict) {
-    if (strict) {
-      return id1 === id2;
+    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++;
     }
-    return id1.toLowerCase() === id2.toLowerCase();
+    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 };
   }
-  async rename(options) {
-    const {
-      rootDir,
-      componentsDir,
-      compositionsDir,
-      compositionPatternsDir,
-      componentPatternsDir,
-      componentType,
-      slotId,
-      newSlotId,
-      newSlotName,
-      whatIf,
-      strict
-    } = options;
-    const findOptions = { strict };
-    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
-    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
-    if (this.compareIds(slotId, newSlotId, strict)) {
-      throw new TransformError("New slot ID is the same as the current slot ID");
+  // --- Content Type Generation ---
+  generateContentType(component) {
+    const fields = [];
+    if (component.parameters) {
+      for (const param of component.parameters) {
+        fields.push(this.parameterToField(param));
+      }
     }
-    this.logger.info(`Loading component: ${componentType}`);
-    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
-    if (!component.slots || component.slots.length === 0) {
-      throw new SlotNotFoundError(slotId, componentType);
+    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;
     }
-    const slotIndex = component.slots.findIndex(
-      (s) => this.compareIds(s.id, slotId, strict)
-    );
-    if (slotIndex === -1) {
-      throw new SlotNotFoundError(slotId, componentType);
+    if (param.localizable !== void 0) {
+      field.localizable = param.localizable;
     }
-    const existingNewSlot = component.slots.find(
-      (s) => this.compareIds(s.id, newSlotId, strict)
-    );
-    if (existingNewSlot) {
-      throw new SlotAlreadyExistsError(newSlotId, componentType);
+    if (param.typeConfig !== void 0) {
+      field.typeConfig = param.typeConfig;
     }
-    this.logger.action(
-      whatIf,
-      "UPDATE",
-      `Slot "${slotId}" \u2192 "${newSlotId}" in component/${this.fileSystem.getBasename(componentFilePath)}`
-    );
-    component.slots[slotIndex].id = newSlotId;
-    if (newSlotName !== void 0) {
-      component.slots[slotIndex].name = newSlotName;
+    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;
+      }
     }
-    if (!whatIf) {
-      await this.componentService.saveComponent(componentFilePath, component);
+    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 compositionsResult = await this.renameSlotInDirectory(
-      fullCompositionsDir,
-      componentType,
-      slotId,
-      newSlotId,
-      whatIf,
-      strict,
-      "composition"
-    );
-    const compositionPatternsResult = await this.renameSlotInDirectory(
-      fullCompositionPatternsDir,
-      componentType,
-      slotId,
-      newSlotId,
-      whatIf,
-      strict,
-      "compositionPattern"
-    );
-    const componentPatternsResult = await this.renameSlotInDirectory(
-      fullComponentPatternsDir,
-      componentType,
-      slotId,
-      newSlotId,
-      whatIf,
-      strict,
-      "componentPattern"
-    );
-    const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
-    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
-    this.logger.info("");
-    this.logger.info(
-      `Summary: 1 component definition, ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`
-    );
+    const entryId = computeGuidHash(`entry${comp._id}`);
+    const entryName = this.truncateName(comp._name ?? comp._id, 60);
     return {
-      componentDefinitionUpdated: true,
-      compositionsModified: compositionsResult.filesModified,
-      compositionPatternsModified: compositionPatternsResult.filesModified,
-      componentPatternsModified: componentPatternsResult.filesModified,
-      instancesRenamed: totalInstances
+      entry: {
+        _id: entryId,
+        _name: entryName,
+        type: comp.type,
+        fields: { ...comp.parameters ?? {} },
+        ...extraRootProps
+      },
+      ...extraWrapperProps
     };
   }
-  async renameSlotInDirectory(directory, componentType, oldSlotId, newSlotId, whatIf, strict, label) {
-    let files;
-    try {
-      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
-    } catch {
-      return { filesModified: 0, instancesRenamed: 0 };
-    }
-    if (files.length === 0) {
-      return { filesModified: 0, instancesRenamed: 0 };
-    }
-    let filesModified = 0;
-    let instancesRenamed = 0;
-    for (const filePath of files) {
-      let composition;
-      try {
-        composition = await this.fileSystem.readFile(filePath);
-      } catch {
-        continue;
-      }
-      if (!composition?.composition) {
-        continue;
+  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 ?? {} }
       }
-      const count = this.renameSlotInTree(
-        composition.composition,
-        componentType,
-        oldSlotId,
-        newSlotId,
-        strict
-      );
-      if (count > 0) {
-        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
-        this.logger.action(
-          whatIf,
-          "UPDATE",
-          `${label}/${relativePath} (${count} instance(s) of ${componentType})`
-        );
-        if (!whatIf) {
-          await this.fileSystem.writeFile(filePath, composition);
+    };
+  }
+  // --- 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;
+        }
+        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
+          );
         }
-        filesModified++;
-        instancesRenamed += count;
       }
     }
-    return { filesModified, instancesRenamed };
   }
-  renameSlotInTree(node, componentType, oldSlotId, newSlotId, strict) {
-    let count = 0;
-    if (this.compareIds(node.type, componentType, strict) && node.slots) {
-      const result = this.renameSlotKey(node.slots, oldSlotId, newSlotId, strict);
-      if (result.renamed) {
-        node.slots = result.slots;
-        count++;
+  // --- 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 (node.slots) {
-      for (const slotInstances of Object.values(node.slots)) {
-        if (!Array.isArray(slotInstances)) continue;
-        for (const instance of slotInstances) {
-          count += this.renameSlotInTree(instance, componentType, oldSlotId, newSlotId, strict);
-        }
-      }
+    if (Object.keys(dataResources).length > 0) {
+      entry.entry._dataResources = {
+        ...entry.entry._dataResources ?? {},
+        ...dataResources
+      };
     }
-    return count;
   }
-  renameSlotKey(slots, oldSlotId, newSlotId, strict) {
-    const matchingKey = Object.keys(slots).find(
-      (key) => this.compareIds(key, oldSlotId, strict)
-    );
-    if (!matchingKey) {
-      return { renamed: false, slots };
-    }
-    const newSlots = {};
-    for (const key of Object.keys(slots)) {
-      if (key === matchingKey) {
-        newSlots[newSlotId] = slots[key];
-      } else {
-        newSlots[key] = slots[key];
+  // --- 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 { renamed: true, slots: newSlots };
+    return sourceItemMap;
   }
-};
-
-// src/core/services/component-renamer.service.ts
-var ComponentRenamerService = class {
-  constructor(fileSystem, componentService, logger) {
-    this.fileSystem = fileSystem;
-    this.componentService = componentService;
-    this.logger = logger;
+  findExistingEntryBySourceItem(inst, sourceItemMap) {
+    const sourceItemParam = inst.instance.parameters?.sourceItem;
+    if (sourceItemParam?.value == null) {
+      return void 0;
+    }
+    return sourceItemMap.get(String(sourceItemParam.value));
   }
-  compareIds(id1, id2, strict) {
+  // --- Utilities ---
+  compareTypes(type1, type2, strict) {
     if (strict) {
-      return id1 === id2;
+      return type1 === type2;
     }
-    return id1.toLowerCase() === id2.toLowerCase();
+    return type1.toLowerCase() === type2.toLowerCase();
   }
-  async rename(options) {
-    const {
-      rootDir,
-      componentsDir,
-      compositionsDir,
-      compositionPatternsDir,
-      componentPatternsDir,
-      componentType,
-      newComponentType,
-      newComponentName,
-      whatIf,
-      strict
-    } = options;
-    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
-    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
-    const findOptions = { strict };
-    if (this.compareIds(componentType, newComponentType, strict)) {
-      throw new TransformError("New component type is the same as the current component type");
-    }
-    this.logger.info(`Loading component: ${componentType}`);
-    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
-    let targetExists = false;
-    try {
-      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
-      targetExists = true;
-    } catch (error) {
-      if (!(error instanceof ComponentNotFoundError)) {
-        throw error;
-      }
-    }
-    if (targetExists) {
-      throw new ComponentAlreadyExistsError(newComponentType, fullComponentsDir);
-    }
-    this.logger.action(
-      whatIf,
-      "UPDATE",
-      `Component ID "${componentType}" \u2192 "${newComponentType}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+  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
     );
-    component.id = newComponentType;
-    if (newComponentName !== void 0) {
-      component.name = newComponentName;
+    if (!existingGroup) {
+      this.logger.action(whatIf, "CREATE", `Group "${targetGroup}" on ${targetComponentType}`);
+      modifiedComponent = this.componentService.ensureGroupExists(
+        modifiedComponent,
+        groupId,
+        targetGroup,
+        findOptions
+      );
+      componentModified = true;
     }
-    if (!whatIf) {
-      await this.componentService.saveComponent(componentFilePath, component);
+    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;
+          }
+        }
+      }
     }
-    const ext = this.fileSystem.getExtension(componentFilePath);
-    const dir = this.fileSystem.getDirname(componentFilePath);
-    const newFilePath = this.fileSystem.joinPath(dir, `${newComponentType}${ext}`);
-    let fileRenamed = false;
-    if (componentFilePath !== newFilePath) {
-      this.logger.action(
-        whatIf,
-        "RENAME",
-        `component/${this.fileSystem.getBasename(componentFilePath)} \u2192 component/${this.fileSystem.getBasename(newFilePath)}`
+    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 (!whatIf) {
-        await this.fileSystem.renameFile(componentFilePath, newFilePath);
+      if (!exists) {
+        normalized.push(entry);
       }
-      fileRenamed = true;
     }
-    const allowedComponentsUpdated = await this.updateAllowedComponents(
-      fullComponentsDir,
+    return normalized;
+  }
+};
+
+// src/core/services/slot-renamer.service.ts
+var SlotRenamerService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async rename(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
       componentType,
-      newComponentType,
-      componentFilePath,
+      slotId,
+      newSlotId,
+      newSlotName,
       whatIf,
       strict
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    if (this.compareIds(slotId, newSlotId, strict)) {
+      throw new TransformError("New slot ID is the same as the current slot ID");
+    }
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    if (!component.slots || component.slots.length === 0) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const slotIndex = component.slots.findIndex(
+      (s) => this.compareIds(s.id, slotId, strict)
     );
-    const compositionsResult = await this.renameTypeInDirectory(
+    if (slotIndex === -1) {
+      throw new SlotNotFoundError(slotId, componentType);
+    }
+    const existingNewSlot = component.slots.find(
+      (s) => this.compareIds(s.id, newSlotId, strict)
+    );
+    if (existingNewSlot) {
+      throw new SlotAlreadyExistsError(newSlotId, componentType);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Slot "${slotId}" \u2192 "${newSlotId}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.slots[slotIndex].id = newSlotId;
+    if (newSlotName !== void 0) {
+      component.slots[slotIndex].name = newSlotName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const compositionsResult = await this.renameSlotInDirectory(
       fullCompositionsDir,
       componentType,
-      newComponentType,
+      slotId,
+      newSlotId,
       whatIf,
       strict,
       "composition"
     );
-    const compositionPatternsResult = await this.renameTypeInDirectory(
+    const compositionPatternsResult = await this.renameSlotInDirectory(
       fullCompositionPatternsDir,
       componentType,
-      newComponentType,
+      slotId,
+      newSlotId,
       whatIf,
       strict,
       "compositionPattern"
     );
-    const componentPatternsResult = await this.renameTypeInDirectory(
+    const componentPatternsResult = await this.renameSlotInDirectory(
       fullComponentPatternsDir,
       componentType,
-      newComponentType,
+      slotId,
+      newSlotId,
       whatIf,
       strict,
       "componentPattern"
     );
-    const totalCompositionFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
     const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
     this.logger.info("");
     this.logger.info(
-      `Summary: 1 component renamed, ${allowedComponentsUpdated} component(s) with allowedComponents updated, ${totalCompositionFiles} composition file(s) (${totalInstances} instance(s)) updated.`
+      `Summary: 1 component definition, ${totalFiles} file(s) (${totalInstances} instance(s)) updated.`
     );
     return {
-      componentRenamed: true,
-      fileRenamed,
-      allowedComponentsUpdated,
+      componentDefinitionUpdated: true,
       compositionsModified: compositionsResult.filesModified,
       compositionPatternsModified: compositionPatternsResult.filesModified,
       componentPatternsModified: componentPatternsResult.filesModified,
       instancesRenamed: totalInstances
     };
   }
-  async updateAllowedComponents(componentsDir, oldType, newType, sourceFilePath, whatIf, strict) {
-    let files;
-    try {
-      files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
-    } catch {
-      return 0;
-    }
-    let updatedCount = 0;
-    for (const filePath of files) {
-      if (filePath === sourceFilePath) continue;
-      let comp;
-      try {
-        comp = await this.fileSystem.readFile(filePath);
-      } catch {
-        continue;
-      }
-      if (!comp.slots || comp.slots.length === 0) continue;
-      let fileModified = false;
-      for (const slot of comp.slots) {
-        if (!slot.allowedComponents) continue;
-        for (let i = 0; i < slot.allowedComponents.length; i++) {
-          if (this.compareIds(slot.allowedComponents[i], oldType, strict)) {
-            slot.allowedComponents[i] = newType;
-            fileModified = true;
-          }
-        }
-      }
-      if (fileModified) {
-        this.logger.action(
-          whatIf,
-          "UPDATE",
-          `allowedComponents in component/${this.fileSystem.getBasename(filePath)}: ${oldType} \u2192 ${newType}`
-        );
-        if (!whatIf) {
-          await this.fileSystem.writeFile(filePath, comp);
-        }
-        updatedCount++;
-      }
-    }
-    return updatedCount;
-  }
-  async renameTypeInDirectory(directory, oldType, newType, whatIf, strict, label) {
+  async renameSlotInDirectory(directory, componentType, oldSlotId, newSlotId, whatIf, strict, label) {
     let files;
     try {
       files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
@@ -1149,14 +1394,22 @@ var ComponentRenamerService = class {
       } catch {
         continue;
       }
-      if (!composition?.composition) continue;
-      const count = this.renameTypeInTree(composition.composition, oldType, newType, strict);
+      if (!composition?.composition) {
+        continue;
+      }
+      const count = this.renameSlotInTree(
+        composition.composition,
+        componentType,
+        oldSlotId,
+        newSlotId,
+        strict
+      );
       if (count > 0) {
         const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
         this.logger.action(
           whatIf,
           "UPDATE",
-          `${label}/${relativePath} (${count} instance(s))`
+          `${label}/${relativePath} (${count} instance(s) of ${componentType})`
         );
         if (!whatIf) {
           await this.fileSystem.writeFile(filePath, composition);
@@ -1167,949 +1420,725 @@ var ComponentRenamerService = class {
     }
     return { filesModified, instancesRenamed };
   }
-  renameTypeInTree(node, oldType, newType, strict) {
+  renameSlotInTree(node, componentType, oldSlotId, newSlotId, strict) {
     let count = 0;
-    if (this.compareIds(node.type, oldType, strict)) {
-      node.type = newType;
-      count++;
+    if (this.compareIds(node.type, componentType, strict) && node.slots) {
+      const result = this.renameSlotKey(node.slots, oldSlotId, newSlotId, strict);
+      if (result.renamed) {
+        node.slots = result.slots;
+        count++;
+      }
     }
     if (node.slots) {
       for (const slotInstances of Object.values(node.slots)) {
         if (!Array.isArray(slotInstances)) continue;
         for (const instance of slotInstances) {
-          count += this.renameTypeInTree(instance, oldType, newType, strict);
+          count += this.renameSlotInTree(instance, componentType, oldSlotId, newSlotId, strict);
         }
       }
     }
     return count;
   }
+  renameSlotKey(slots, oldSlotId, newSlotId, strict) {
+    const matchingKey = Object.keys(slots).find(
+      (key) => this.compareIds(key, oldSlotId, strict)
+    );
+    if (!matchingKey) {
+      return { renamed: false, slots };
+    }
+    const newSlots = {};
+    for (const key of Object.keys(slots)) {
+      if (key === matchingKey) {
+        newSlots[newSlotId] = slots[key];
+      } else {
+        newSlots[key] = slots[key];
+      }
+    }
+    return { renamed: true, slots: newSlots };
+  }
 };
 
-// src/core/services/component-adder.service.ts
-import { randomUUID } from "crypto";
-var ComponentAdderService = class {
+// src/core/services/component-renamer.service.ts
+var ComponentRenamerService = class {
   constructor(fileSystem, componentService, logger) {
     this.fileSystem = fileSystem;
     this.componentService = componentService;
     this.logger = logger;
   }
   compareIds(id1, id2, strict) {
-    if (strict) {
-      return id1 === id2;
-    }
-    return id1.toLowerCase() === id2.toLowerCase();
-  }
-  parseParentComponentTypes(parentComponentType) {
-    return parentComponentType.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
-  }
-  matchesAnyParentType(instanceType, parentTypes, strict) {
-    return parentTypes.some((pt) => this.compareIds(instanceType, pt, strict));
-  }
-  parseParameters(parameterString) {
-    const result = {};
-    if (!parameterString) return result;
-    const pairs = parameterString.split("|");
-    for (const pair of pairs) {
-      const [key, ...valueParts] = pair.split(":");
-      if (key && valueParts.length > 0) {
-        result[key.trim()] = valueParts.join(":").trim();
-      }
-    }
-    return result;
-  }
-  generateId(baseName) {
-    return `${baseName}-${randomUUID().slice(0, 8)}`;
-  }
-  regenerateInstanceIds(instance) {
-    if (instance._id) {
-      instance._id = instance._pattern ? randomUUID() : this.generateId(instance.type);
-    }
-    if (instance.slots) {
-      for (const slotInstances of Object.values(instance.slots)) {
-        if (Array.isArray(slotInstances)) {
-          for (const nestedInstance of slotInstances) {
-            this.regenerateInstanceIds(nestedInstance);
-          }
-        }
-      }
-    }
-  }
-  createComponentInstance(componentType, parameters) {
-    const instance = {
-      type: componentType,
-      _id: this.generateId(componentType)
-    };
-    if (Object.keys(parameters).length > 0) {
-      instance.parameters = {};
-      for (const [key, value] of Object.entries(parameters)) {
-        instance.parameters[key] = {
-          type: "text",
-          value
-        };
-      }
-    }
-    return instance;
-  }
-  addComponentToSlot(slots, slotId, instance) {
-    if (!slots[slotId]) {
-      slots[slotId] = [];
+    if (strict) {
+      return id1 === id2;
     }
-    slots[slotId].push(instance);
+    return id1.toLowerCase() === id2.toLowerCase();
   }
-  async addComponent(options) {
+  async rename(options) {
     const {
       rootDir,
       componentsDir,
       compositionsDir,
       compositionPatternsDir,
       componentPatternsDir,
-      parentComponentType,
-      slot,
+      componentType,
       newComponentType,
-      parameters: paramString,
+      newComponentName,
       whatIf,
       strict
     } = options;
-    if (!newComponentType) {
-      throw new TransformError("newComponentType is required for add-component");
-    }
     const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
     const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
     const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
     const findOptions = { strict };
-    const parentTypes = this.parseParentComponentTypes(parentComponentType);
-    if (parentTypes.length === 0) {
-      throw new TransformError("parentComponentType cannot be empty");
+    if (this.compareIds(componentType, newComponentType, strict)) {
+      throw new TransformError("New component type is the same as the current component type");
     }
-    this.logger.info(`Validating new component: ${newComponentType}`);
+    this.logger.info(`Loading component: ${componentType}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentType, findOptions);
+    let targetExists = false;
     try {
       await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
+      targetExists = true;
     } catch (error) {
-      if (error instanceof ComponentNotFoundError) {
-        throw new TransformError(
-          `Component type "${newComponentType}" not found in ${fullComponentsDir}`
-        );
+      if (!(error instanceof ComponentNotFoundError)) {
+        throw error;
       }
-      throw error;
     }
-    let allowedComponentsUpdated = false;
-    for (const parentType of parentTypes) {
-      this.logger.info(`Loading parent component: ${parentType}`);
-      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
-      if (!parentComponent.slots) {
-        parentComponent.slots = [];
-      }
-      let slotDef = parentComponent.slots.find(
-        (s) => this.compareIds(s.id, slot, strict)
-      );
-      if (!slotDef) {
-        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
-        slotDef = { id: slot, name: slot, allowedComponents: [] };
-        parentComponent.slots.push(slotDef);
-      }
-      const slotIndex = parentComponent.slots?.findIndex(
-        (s) => this.compareIds(s.id, slotDef.id, strict)
+    if (targetExists) {
+      throw new ComponentAlreadyExistsError(newComponentType, fullComponentsDir);
+    }
+    this.logger.action(
+      whatIf,
+      "UPDATE",
+      `Component ID "${componentType}" \u2192 "${newComponentType}" in component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    component.id = newComponentType;
+    if (newComponentName !== void 0) {
+      component.name = newComponentName;
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, component);
+    }
+    const ext = this.fileSystem.getExtension(componentFilePath);
+    const dir = this.fileSystem.getDirname(componentFilePath);
+    const newFilePath = this.fileSystem.joinPath(dir, `${newComponentType}${ext}`);
+    let fileRenamed = false;
+    if (componentFilePath !== newFilePath) {
+      this.logger.action(
+        whatIf,
+        "RENAME",
+        `component/${this.fileSystem.getBasename(componentFilePath)} \u2192 component/${this.fileSystem.getBasename(newFilePath)}`
       );
-      if (slotIndex !== void 0 && slotIndex >= 0) {
-        const actualSlot = parentComponent.slots[slotIndex];
-        if (!actualSlot.allowedComponents) {
-          actualSlot.allowedComponents = [];
-        }
-        const isAlreadyAllowed = actualSlot.allowedComponents.some(
-          (c) => this.compareIds(c, newComponentType, strict)
-        );
-        if (!isAlreadyAllowed) {
-          this.logger.action(
-            whatIf,
-            "UPDATE",
-            `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentType}"`
-          );
-          actualSlot.allowedComponents.push(newComponentType);
-          if (!whatIf) {
-            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
-          }
-          allowedComponentsUpdated = true;
-        }
+      if (!whatIf) {
+        await this.fileSystem.renameFile(componentFilePath, newFilePath);
       }
+      fileRenamed = true;
     }
-    const parsedParams = this.parseParameters(paramString);
-    const newInstance = this.createComponentInstance(newComponentType, parsedParams);
-    const compositionsResult = await this.addComponentToDirectory(
+    const allowedComponentsUpdated = await this.updateAllowedComponents(
+      fullComponentsDir,
+      componentType,
+      newComponentType,
+      componentFilePath,
+      whatIf,
+      strict
+    );
+    const compositionsResult = await this.renameTypeInDirectory(
       fullCompositionsDir,
-      parentTypes,
-      slot,
-      newInstance,
+      componentType,
+      newComponentType,
       whatIf,
       strict,
       "composition"
     );
-    const compositionPatternsResult = await this.addComponentToDirectory(
+    const compositionPatternsResult = await this.renameTypeInDirectory(
       fullCompositionPatternsDir,
-      parentTypes,
-      slot,
-      newInstance,
+      componentType,
+      newComponentType,
       whatIf,
       strict,
       "compositionPattern"
     );
-    const componentPatternsResult = await this.addComponentToDirectory(
+    const componentPatternsResult = await this.renameTypeInDirectory(
       fullComponentPatternsDir,
-      parentTypes,
-      slot,
-      newInstance,
+      componentType,
+      newComponentType,
       whatIf,
       strict,
       "componentPattern"
     );
+    const totalCompositionFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
+    const totalInstances = compositionsResult.instancesRenamed + compositionPatternsResult.instancesRenamed + componentPatternsResult.instancesRenamed;
     this.logger.info("");
     this.logger.info(
-      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+      `Summary: 1 component renamed, ${allowedComponentsUpdated} component(s) with allowedComponents updated, ${totalCompositionFiles} composition file(s) (${totalInstances} instance(s)) updated.`
     );
     return {
+      componentRenamed: true,
+      fileRenamed,
       allowedComponentsUpdated,
-      compositionsModified: compositionsResult,
-      compositionPatternsModified: compositionPatternsResult,
-      componentPatternsModified: componentPatternsResult,
-      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+      compositionsModified: compositionsResult.filesModified,
+      compositionPatternsModified: compositionPatternsResult.filesModified,
+      componentPatternsModified: componentPatternsResult.filesModified,
+      instancesRenamed: totalInstances
     };
   }
-  async addComponentPattern(options) {
-    const {
-      rootDir,
-      componentsDir,
-      compositionsDir,
-      compositionPatternsDir,
-      componentPatternsDir,
-      parentComponentType,
-      slot,
-      componentPatternId,
-      whatIf,
-      strict
-    } = options;
-    if (!componentPatternId) {
-      throw new TransformError("componentPatternId is required for add-component-pattern");
-    }
-    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
-    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
-    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
-    const findOptions = { strict };
-    const parentTypes = this.parseParentComponentTypes(parentComponentType);
-    if (parentTypes.length === 0) {
-      throw new TransformError("parentComponentType cannot be empty");
-    }
-    this.logger.info(`Loading component pattern: ${componentPatternId}`);
-    const pattern = await this.loadComponentPattern(
-      fullComponentPatternsDir,
-      componentPatternId,
-      strict
-    );
-    const patternDefinition = pattern.definition;
-    if (!patternDefinition || !patternDefinition.type) {
-      throw new TransformError(
-        `Component pattern "${componentPatternId}" has no valid definition or missing type`
-      );
+  async updateAllowedComponents(componentsDir, oldType, newType, sourceFilePath, whatIf, strict) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(componentsDir, "*.{json,yaml,yml}");
+    } catch {
+      return 0;
     }
-    const componentTypeInPattern = patternDefinition.type;
-    let allowedComponentsUpdated = false;
-    for (const parentType of parentTypes) {
-      this.logger.info(`Loading parent component: ${parentType}`);
-      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
-      if (!parentComponent.slots) {
-        parentComponent.slots = [];
+    let updatedCount = 0;
+    for (const filePath of files) {
+      if (filePath === sourceFilePath) continue;
+      let comp;
+      try {
+        comp = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
       }
-      let slotDef = parentComponent.slots.find(
-        (s) => this.compareIds(s.id, slot, strict)
-      );
-      if (!slotDef) {
-        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
-        slotDef = { id: slot, name: slot, allowedComponents: [] };
-        parentComponent.slots.push(slotDef);
+      if (!comp.slots || comp.slots.length === 0) continue;
+      let fileModified = false;
+      for (const slot of comp.slots) {
+        if (!slot.allowedComponents) continue;
+        for (let i = 0; i < slot.allowedComponents.length; i++) {
+          if (this.compareIds(slot.allowedComponents[i], oldType, strict)) {
+            slot.allowedComponents[i] = newType;
+            fileModified = true;
+          }
+        }
       }
-      const slotIndex = parentComponent.slots?.findIndex(
-        (s) => this.compareIds(s.id, slotDef.id, strict)
-      );
-      if (slotIndex !== void 0 && slotIndex >= 0) {
-        const actualSlot = parentComponent.slots[slotIndex];
-        if (!actualSlot.allowedComponents) {
-          actualSlot.allowedComponents = [];
+      if (fileModified) {
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `allowedComponents in component/${this.fileSystem.getBasename(filePath)}: ${oldType} \u2192 ${newType}`
+        );
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, comp);
         }
-        const isAlreadyAllowed = actualSlot.allowedComponents.some(
-          (c) => this.compareIds(c, componentTypeInPattern, strict)
+        updatedCount++;
+      }
+    }
+    return updatedCount;
+  }
+  async renameTypeInDirectory(directory, oldType, newType, whatIf, strict, label) {
+    let files;
+    try {
+      files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    } catch {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    if (files.length === 0) {
+      return { filesModified: 0, instancesRenamed: 0 };
+    }
+    let filesModified = 0;
+    let instancesRenamed = 0;
+    for (const filePath of files) {
+      let composition;
+      try {
+        composition = await this.fileSystem.readFile(filePath);
+      } catch {
+        continue;
+      }
+      if (!composition?.composition) continue;
+      const count = this.renameTypeInTree(composition.composition, oldType, newType, strict);
+      if (count > 0) {
+        const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
+        this.logger.action(
+          whatIf,
+          "UPDATE",
+          `${label}/${relativePath} (${count} instance(s))`
         );
-        if (!isAlreadyAllowed) {
-          this.logger.action(
-            whatIf,
-            "UPDATE",
-            `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentType}"`
-          );
-          actualSlot.allowedComponents.push(componentTypeInPattern);
-          if (!whatIf) {
-            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
-          }
-          allowedComponentsUpdated = true;
+        if (!whatIf) {
+          await this.fileSystem.writeFile(filePath, composition);
         }
+        filesModified++;
+        instancesRenamed += count;
       }
     }
-    const newInstance = {
-      type: componentTypeInPattern,
-      _pattern: pattern.componentPatternId,
-      _id: randomUUID()
-    };
-    const compositionsResult = await this.addComponentToDirectory(
-      fullCompositionsDir,
-      parentTypes,
-      slot,
-      newInstance,
-      whatIf,
-      strict,
-      "composition"
-    );
-    const compositionPatternsResult = await this.addComponentToDirectory(
-      fullCompositionPatternsDir,
-      parentTypes,
-      slot,
-      newInstance,
-      whatIf,
-      strict,
-      "compositionPattern"
-    );
-    const componentPatternsResult = await this.addComponentToDirectory(
-      fullComponentPatternsDir,
-      parentTypes,
-      slot,
-      newInstance,
-      whatIf,
-      strict,
-      "componentPattern"
-    );
-    this.logger.info("");
-    this.logger.info(
-      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
-    );
-    return {
-      allowedComponentsUpdated,
-      compositionsModified: compositionsResult,
-      compositionPatternsModified: compositionPatternsResult,
-      componentPatternsModified: componentPatternsResult,
-      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
-    };
+    return { filesModified, instancesRenamed };
   }
-  async loadComponentPattern(componentPatternsDir, patternId, strict) {
-    const jsonPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.json`);
-    const yamlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yaml`);
-    const ymlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yml`);
-    let raw;
-    if (await this.fileSystem.fileExists(jsonPath)) {
-      raw = await this.fileSystem.readFile(jsonPath);
-    } else if (await this.fileSystem.fileExists(yamlPath)) {
-      raw = await this.fileSystem.readFile(yamlPath);
-    } else if (await this.fileSystem.fileExists(ymlPath)) {
-      raw = await this.fileSystem.readFile(ymlPath);
+  renameTypeInTree(node, oldType, newType, strict) {
+    let count = 0;
+    if (this.compareIds(node.type, oldType, strict)) {
+      node.type = newType;
+      count++;
     }
-    if (!raw && !strict) {
-      const files = await this.fileSystem.findFiles(componentPatternsDir, "*.{json,yaml,yml}");
-      for (const filePath of files) {
-        const basename2 = this.fileSystem.getBasename(filePath);
-        const nameWithoutExt = basename2.replace(/\.(json|yaml|yml)$/i, "");
-        if (nameWithoutExt.toLowerCase() === patternId.toLowerCase()) {
-          raw = await this.fileSystem.readFile(filePath);
-          break;
+    if (node.slots) {
+      for (const slotInstances of Object.values(node.slots)) {
+        if (!Array.isArray(slotInstances)) continue;
+        for (const instance of slotInstances) {
+          count += this.renameTypeInTree(instance, oldType, newType, strict);
         }
       }
     }
-    if (!raw) {
-      throw new TransformError(`Component pattern "${patternId}" not found in ${componentPatternsDir}`);
-    }
-    return this.normalizeComponentPattern(raw, patternId);
+    return count;
   }
-  normalizeComponentPattern(raw, patternId) {
-    if (raw.definition && typeof raw.definition === "object" && raw.definition.type) {
-      return raw;
+};
+
+// src/core/services/component-adder.service.ts
+import { randomUUID } from "crypto";
+var ComponentAdderService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
     }
-    if (raw.composition && typeof raw.composition === "object" && raw.composition.type) {
-      const composition = raw.composition;
-      return {
-        componentPatternId: patternId,
-        definition: composition
-      };
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  parseParentComponentTypes(parentComponentType) {
+    return parentComponentType.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  matchesAnyParentType(instanceType, parentTypes, strict) {
+    return parentTypes.some((pt) => this.compareIds(instanceType, pt, strict));
+  }
+  parseParameters(parameterString) {
+    const result = {};
+    if (!parameterString) return result;
+    const pairs = parameterString.split("|");
+    for (const pair of pairs) {
+      const [key, ...valueParts] = pair.split(":");
+      if (key && valueParts.length > 0) {
+        result[key.trim()] = valueParts.join(":").trim();
+      }
     }
-    return raw;
+    return result;
   }
-  async addComponentToDirectory(directory, parentTypes, slot, newInstance, whatIf, strict, dirType) {
-    const exists = await this.fileSystem.fileExists(directory);
-    if (!exists) {
-      this.logger.detail(`${dirType} directory does not exist, skipping`);
-      return 0;
+  generateId(baseName) {
+    return `${baseName}-${randomUUID().slice(0, 8)}`;
+  }
+  regenerateInstanceIds(instance) {
+    if (instance._id) {
+      instance._id = instance._pattern ? randomUUID() : this.generateId(instance.type);
     }
-    const files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
-    let filesModified = 0;
-    for (const filePath of files) {
-      try {
-        const content = await this.fileSystem.readFile(filePath);
-        let composition = null;
-        let isComponentPattern = false;
-        if (dirType === "componentPattern" && content && typeof content === "object" && "definition" in content) {
-          isComponentPattern = true;
-          const pattern = content;
-          if (pattern.definition && pattern.definition.slots) {
-            composition = {
-              composition: {
-                _id: "pattern-root",
-                type: pattern.definition.type,
-                slots: pattern.definition.slots
-              }
-            };
-          }
-        } else {
-          composition = content;
-        }
-        if (!composition?.composition) {
-          continue;
-        }
-        const rootInstance = composition.composition;
-        let modified = false;
-        if (this.matchesAnyParentType(rootInstance.type, parentTypes, strict)) {
-          if (!rootInstance.slots) {
-            rootInstance.slots = {};
-          }
-          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
-          this.regenerateInstanceIds(instanceCopy);
-          this.addComponentToSlot(rootInstance.slots, slot, instanceCopy);
-          modified = true;
-        }
-        if (rootInstance.slots) {
-          const nestedModified = this.addComponentToNestedSlots(
-            rootInstance.slots,
-            parentTypes,
-            slot,
-            newInstance,
-            strict
-          );
-          if (nestedModified) {
-            modified = true;
-          }
-        }
-        if (modified) {
-          this.logger.action(
-            whatIf,
-            "UPDATE",
-            `Adding "${newInstance.type}" to slot "${slot}" in ${dirType}/${this.fileSystem.getBasename(filePath)}`
-          );
-          if (!whatIf) {
-            if (isComponentPattern && content && typeof content === "object" && "definition" in content) {
-              const pattern = content;
-              if (rootInstance.slots) {
-                pattern.definition.slots = rootInstance.slots;
-              }
-            }
-            await this.fileSystem.writeFile(filePath, content);
+    if (instance.slots) {
+      for (const slotInstances of Object.values(instance.slots)) {
+        if (Array.isArray(slotInstances)) {
+          for (const nestedInstance of slotInstances) {
+            this.regenerateInstanceIds(nestedInstance);
           }
-          filesModified++;
-        }
-      } catch (error) {
-        if (error instanceof Error && !error.message.includes("skipping")) {
-          this.logger.detail(`Skipping ${filePath}: ${error.message}`);
         }
       }
     }
-    return filesModified;
   }
-  addComponentToNestedSlots(slots, parentTypes, slot, newInstance, strict) {
-    let modified = false;
-    for (const slotInstances of Object.values(slots)) {
-      if (!Array.isArray(slotInstances)) continue;
-      for (const instance of slotInstances) {
-        if (this.matchesAnyParentType(instance.type, parentTypes, strict)) {
-          if (!instance.slots) {
-            instance.slots = {};
-          }
-          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
-          this.regenerateInstanceIds(instanceCopy);
-          this.addComponentToSlot(instance.slots, slot, instanceCopy);
-          modified = true;
-        }
-        if (instance.slots) {
-          const nestedModified = this.addComponentToNestedSlots(
-            instance.slots,
-            parentTypes,
-            slot,
-            newInstance,
-            strict
-          );
-          if (nestedModified) {
-            modified = true;
-          }
-        }
+  createComponentInstance(componentType, parameters) {
+    const instance = {
+      type: componentType,
+      _id: this.generateId(componentType)
+    };
+    if (Object.keys(parameters).length > 0) {
+      instance.parameters = {};
+      for (const [key, value] of Object.entries(parameters)) {
+        instance.parameters[key] = {
+          type: "text",
+          value
+        };
       }
     }
-    return modified;
+    return instance;
   }
-};
-
-// 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;
+  addComponentToSlot(slots, slotId, instance) {
+    if (!slots[slotId]) {
+      slots[slotId] = [];
+    }
+    slots[slotId].push(instance);
   }
-  async convert(options) {
+  async addComponent(options) {
     const {
       rootDir,
-      compositionsDir,
       componentsDir,
-      contentTypesDir,
-      entriesDir,
-      compositionTypes,
-      flattenComponentIds,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      newComponentType,
+      parameters: paramString,
       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 };
+    if (!newComponentType) {
+      throw new TransformError("newComponentType is required for add-component");
     }
-    this.logger.info(`Found ${compositionResults.length} composition(s)`);
-    const rootComponentTypes = /* @__PURE__ */ new Set();
-    for (const { composition } of compositionResults) {
-      rootComponentTypes.add(composition.composition.type);
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    const findOptions = { strict };
+    const parentTypes = this.parseParentComponentTypes(parentComponentType);
+    if (parentTypes.length === 0) {
+      throw new TransformError("parentComponentType cannot be empty");
     }
-    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);
+    this.logger.info(`Validating new component: ${newComponentType}`);
+    try {
+      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
+    } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        throw new TransformError(
+          `Component type "${newComponentType}" not found in ${fullComponentsDir}`
+        );
+      }
+      throw error;
     }
-    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)
+    let allowedComponentsUpdated = false;
+    for (const parentType of parentTypes) {
+      this.logger.info(`Loading parent component: ${parentType}`);
+      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
+      if (!parentComponent.slots) {
+        parentComponent.slots = [];
+      }
+      let slotDef = parentComponent.slots.find(
+        (s) => this.compareIds(s.id, slot, strict)
       );
-      if (isRootType) {
-        continue;
+      if (!slotDef) {
+        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
+        slotDef = { id: slot, name: slot, allowedComponents: [] };
+        parentComponent.slots.push(slotDef);
       }
-      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;
+      const slotIndex = parentComponent.slots?.findIndex(
+        (s) => this.compareIds(s.id, slotDef.id, strict)
+      );
+      if (slotIndex !== void 0 && slotIndex >= 0) {
+        const actualSlot = parentComponent.slots[slotIndex];
+        if (!actualSlot.allowedComponents) {
+          actualSlot.allowedComponents = [];
         }
-        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
+        const isAlreadyAllowed = actualSlot.allowedComponents.some(
+          (c) => this.compareIds(c, newComponentType, strict)
+        );
+        if (!isAlreadyAllowed) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentType}"`
           );
-          if (instances.length > 0) {
-            flattenedByType.set(flattenType, instances);
-            if (missingFlattenTypes.includes(flattenType)) {
-              foundMissingFlattenTypes.add(flattenType);
-            }
+          actualSlot.allowedComponents.push(newComponentType);
+          if (!whatIf) {
+            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
           }
+          allowedComponentsUpdated = true;
         }
       }
-      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 parsedParams = this.parseParameters(paramString);
+    const newInstance = this.createComponentInstance(newComponentType, parsedParams);
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+    );
+    return {
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
+    };
+  }
+  async addComponentPattern(options) {
+    const {
+      rootDir,
+      componentsDir,
+      compositionsDir,
+      compositionPatternsDir,
+      componentPatternsDir,
+      parentComponentType,
+      slot,
+      componentPatternId,
+      whatIf,
+      strict
+    } = options;
+    if (!componentPatternId) {
+      throw new TransformError("componentPatternId is required for add-component-pattern");
+    }
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
+    const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
+    const findOptions = { strict };
+    const parentTypes = this.parseParentComponentTypes(parentComponentType);
+    if (parentTypes.length === 0) {
+      throw new TransformError("parentComponentType cannot be empty");
+    }
+    this.logger.info(`Loading component pattern: ${componentPatternId}`);
+    const pattern = await this.loadComponentPattern(
+      fullComponentPatternsDir,
+      componentPatternId,
+      strict
+    );
+    const patternDefinition = pattern.definition;
+    if (!patternDefinition || !patternDefinition.type) {
+      throw new TransformError(
+        `Component pattern "${componentPatternId}" has no valid definition or missing type`
+      );
+    }
+    const componentTypeInPattern = patternDefinition.type;
+    let allowedComponentsUpdated = false;
+    for (const parentType of parentTypes) {
+      this.logger.info(`Loading parent component: ${parentType}`);
+      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
+      if (!parentComponent.slots) {
+        parentComponent.slots = [];
       }
-      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)}")`
+      let slotDef = parentComponent.slots.find(
+        (s) => this.compareIds(s.id, slot, strict)
       );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(entryFilePath, entry);
+      if (!slotDef) {
+        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
+        slotDef = { id: slot, name: slot, allowedComponents: [] };
+        parentComponent.slots.push(slotDef);
       }
-      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`
-          );
+      const slotIndex = parentComponent.slots?.findIndex(
+        (s) => this.compareIds(s.id, slotDef.id, strict)
+      );
+      if (slotIndex !== void 0 && slotIndex >= 0) {
+        const actualSlot = parentComponent.slots[slotIndex];
+        if (!actualSlot.allowedComponents) {
+          actualSlot.allowedComponents = [];
+        }
+        const isAlreadyAllowed = actualSlot.allowedComponents.some(
+          (c) => this.compareIds(c, componentTypeInPattern, strict)
+        );
+        if (!isAlreadyAllowed) {
           this.logger.action(
             whatIf,
-            "WRITE",
-            `${entriesDir}/${inst.determinisiticId}.json (${flattenType} from "${this.truncate(compositionName, 50)}")`
+            "UPDATE",
+            `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentType}"`
           );
+          actualSlot.allowedComponents.push(componentTypeInPattern);
           if (!whatIf) {
-            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
-          }
-          entriesFromFlattened++;
-        }
-      }
-    }
-    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;
+            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
           }
-          contentType.fields.push({
-            id: flattenType,
-            name: flattenType,
-            type: "contentReference",
-            typeConfig: {
-              isMulti: true,
-              allowedContentTypes: [flattenType]
-            },
-            localizable: false
-          });
+          allowedComponentsUpdated = true;
         }
       }
     }
-    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);
-      }
-      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);
-      }
-      contentTypesWritten++;
-    }
-    const neverFoundMissingTypes = missingFlattenTypes.filter(
-      (type) => !foundMissingFlattenTypes.has(type)
+    const newInstance = {
+      type: componentTypeInPattern,
+      _pattern: pattern.componentPatternId,
+      _id: randomUUID()
+    };
+    const compositionsResult = await this.addComponentToDirectory(
+      fullCompositionsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "composition"
+    );
+    const compositionPatternsResult = await this.addComponentToDirectory(
+      fullCompositionPatternsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "compositionPattern"
+    );
+    const componentPatternsResult = await this.addComponentToDirectory(
+      fullComponentPatternsDir,
+      parentTypes,
+      slot,
+      newInstance,
+      whatIf,
+      strict,
+      "componentPattern"
+    );
+    this.logger.info("");
+    this.logger.info(
+      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
     );
-    if (neverFoundMissingTypes.length > 0) {
-      this.logger.warn(
-        `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
-      );
-    }
-    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));
-      }
-    }
     return {
-      id: component.id,
-      name: component.name,
-      fields
-    };
-  }
-  parameterToField(param) {
-    const field = {
-      id: param.id,
-      name: param.name,
-      type: param.type
+      allowedComponentsUpdated,
+      compositionsModified: compositionsResult,
+      compositionPatternsModified: compositionPatternsResult,
+      componentPatternsModified: componentPatternsResult,
+      instancesAdded: compositionsResult + compositionPatternsResult + componentPatternsResult
     };
-    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 wrapperKeys = /* @__PURE__ */ new Set(["composition"]);
-    const extraWrapperProps = {};
-    for (const [key, value] of Object.entries(composition)) {
-      if (!wrapperKeys.has(key) && value != null) {
-        extraWrapperProps[key] = value;
-      }
+  async loadComponentPattern(componentPatternsDir, patternId, strict) {
+    const jsonPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.json`);
+    const yamlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(componentPatternsDir, `${patternId}.yml`);
+    let raw;
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      raw = await this.fileSystem.readFile(jsonPath);
+    } else if (await this.fileSystem.fileExists(yamlPath)) {
+      raw = await this.fileSystem.readFile(yamlPath);
+    } else if (await this.fileSystem.fileExists(ymlPath)) {
+      raw = await this.fileSystem.readFile(ymlPath);
     }
-    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 ?? {} }
+    if (!raw && !strict) {
+      const files = await this.fileSystem.findFiles(componentPatternsDir, "*.{json,yaml,yml}");
+      for (const filePath of files) {
+        const basename2 = this.fileSystem.getBasename(filePath);
+        const nameWithoutExt = basename2.replace(/\.(json|yaml|yml)$/i, "");
+        if (nameWithoutExt.toLowerCase() === patternId.toLowerCase()) {
+          raw = await this.fileSystem.readFile(filePath);
+          break;
+        }
       }
-    };
+    }
+    if (!raw) {
+      throw new TransformError(`Component pattern "${patternId}" not found in ${componentPatternsDir}`);
+    }
+    return this.normalizeComponentPattern(raw, patternId);
   }
-  // --- Flatten Tree Walking ---
-  findFlattenTargets(slots, targetType, compositionId, compositionName, strict) {
-    const results = [];
-    this.walkSlots(slots, targetType, compositionId, compositionName, "", results, strict);
-    return results;
+  normalizeComponentPattern(raw, patternId) {
+    if (raw.definition && typeof raw.definition === "object" && raw.definition.type) {
+      return raw;
+    }
+    if (raw.composition && typeof raw.composition === "object" && raw.composition.type) {
+      const composition = raw.composition;
+      return {
+        componentPatternId: patternId,
+        definition: composition
+      };
+    }
+    return raw;
   }
-  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) {
+  async addComponentToDirectory(directory, parentTypes, slot, newInstance, whatIf, strict, dirType) {
+    const exists = await this.fileSystem.fileExists(directory);
+    if (!exists) {
+      this.logger.detail(`${dirType} directory does not exist, skipping`);
+      return 0;
+    }
+    const files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
+    let filesModified = 0;
+    for (const filePath of files) {
+      try {
+        const content = await this.fileSystem.readFile(filePath);
+        let composition = null;
+        let isComponentPattern = false;
+        if (dirType === "componentPattern" && content && typeof content === "object" && "definition" in content) {
+          isComponentPattern = true;
+          const pattern = content;
+          if (pattern.definition && pattern.definition.slots) {
+            composition = {
+              composition: {
+                _id: "pattern-root",
+                type: pattern.definition.type,
+                slots: pattern.definition.slots
+              }
+            };
+          }
+        } else {
+          composition = content;
+        }
+        if (!composition?.composition) {
           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
-          });
+        const rootInstance = composition.composition;
+        let modified = false;
+        if (this.matchesAnyParentType(rootInstance.type, parentTypes, strict)) {
+          if (!rootInstance.slots) {
+            rootInstance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(rootInstance.slots, slot, instanceCopy);
+          modified = true;
         }
-        if (instance.slots) {
-          this.walkSlots(
-            instance.slots,
-            targetType,
-            compositionId,
-            compositionName,
-            currentPath,
-            results,
+        if (rootInstance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            rootInstance.slots,
+            parentTypes,
+            slot,
+            newInstance,
             strict
           );
+          if (nestedModified) {
+            modified = true;
+          }
         }
-      }
-    }
-  }
-  // --- 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 (modified) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${newInstance.type}" to slot "${slot}" in ${dirType}/${this.fileSystem.getBasename(filePath)}`
+          );
+          if (!whatIf) {
+            if (isComponentPattern && content && typeof content === "object" && "definition" in content) {
+              const pattern = content;
+              if (rootInstance.slots) {
+                pattern.definition.slots = rootInstance.slots;
+              }
+            }
+            await this.fileSystem.writeFile(filePath, content);
           }
-        };
+          filesModified++;
+        }
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("skipping")) {
+          this.logger.detail(`Skipping ${filePath}: ${error.message}`);
+        }
       }
     }
-    if (Object.keys(dataResources).length > 0) {
-      entry.entry._dataResources = {
-        ...entry.entry._dataResources ?? {},
-        ...dataResources
-      };
-    }
+    return filesModified;
   }
-  // --- 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);
+  addComponentToNestedSlots(slots, parentTypes, slot, newInstance, strict) {
+    let modified = false;
+    for (const slotInstances of Object.values(slots)) {
+      if (!Array.isArray(slotInstances)) continue;
+      for (const instance of slotInstances) {
+        if (this.matchesAnyParentType(instance.type, parentTypes, strict)) {
+          if (!instance.slots) {
+            instance.slots = {};
+          }
+          const instanceCopy = JSON.parse(JSON.stringify(newInstance));
+          this.regenerateInstanceIds(instanceCopy);
+          this.addComponentToSlot(instance.slots, slot, instanceCopy);
+          modified = true;
+        }
+        if (instance.slots) {
+          const nestedModified = this.addComponentToNestedSlots(
+            instance.slots,
+            parentTypes,
+            slot,
+            newInstance,
+            strict
+          );
+          if (nestedModified) {
+            modified = true;
+          }
         }
-      } 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);
+    return modified;
   }
 };
-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/parameter-remover.service.ts
 var ParameterRemoverService = class {
@@ -2583,6 +2612,7 @@ export {
   SlotNotFoundError,
   SlotRenamerService,
   TransformError,
-  computeGuidHash
+  computeGuidHash,
+  regenerateIds
 };
 //# sourceMappingURL=index.js.map