@agilewallaby/c4-model 2.1.0 → 2.3.0

package/src/index.d.ts

@@ -1,3 +1,4 @@
+export * from './archetype';
 export * from './model';
 export * from './person';
 export * from './softwareSystem';
@@ -5,4 +6,5 @@ export * from './container';
 export * from './component';
 export * from './views';
 export * from './structurizrDslWriter';
+export * from './buildModel';
 export * from './generateDiagrams';

package/src/index.js

@@ -1,24 +1,162 @@
-// libs/c4-model/src/model.ts
-import { glob } from "glob";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+// libs/c4-model/src/archetype.ts
+var ElementArchetype = class {
+  constructor(name, elementKind, definition, parent) {
+    this.name = name;
+    this.elementKind = elementKind;
+    this.parent = parent;
+    this.ownDescription = definition?.description;
+    this.ownTechnology = definition?.technology;
+    this.ownTags = definition?.tags ?? [];
+    this.description = this.ownDescription ?? parent?.description;
+    this.technology = this.ownTechnology ?? parent?.technology;
+    this.tags = [...parent?.tags ?? [], ...this.ownTags];
+  }
+  ownDescription;
+  ownTechnology;
+  ownTags;
+  description;
+  technology;
+  tags;
+};
+var RelationshipArchetype = class {
+  constructor(name, definition, parent) {
+    this.name = name;
+    this.parent = parent;
+    this.ownDescription = definition?.description;
+    this.ownTechnology = definition?.technology;
+    this.ownTags = definition?.tags ?? [];
+    this.description = this.ownDescription ?? parent?.description;
+    this.technology = this.ownTechnology ?? parent?.technology;
+    this.tags = [...parent?.tags ?? [], ...this.ownTags];
+  }
+  ownDescription;
+  ownTechnology;
+  ownTags;
+  description;
+  technology;
+  tags;
+};
+function mergeArchetypeWithOverride(archetype, override) {
+  return {
+    description: override?.description ?? archetype.description,
+    technology: override?.technology ?? archetype.technology,
+    tags: [...archetype.tags, ...override?.tags ?? []]
+  };
+}
+
+// node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function camelCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  const transform = options?.mergeAmbiguousCharacters ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map((word, index) => {
+    if (index === 0)
+      return lower(word);
+    return transform(word, index);
+  }).join(options?.delimiter ?? "") + suffix;
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
 
 // libs/c4-model/src/core.ts
-import { camelCase } from "change-case";
 var Element = class {
-  constructor(name, defaultTags = [], definition) {
+  constructor(name, defaultTags = [], definition, archetype, overrideDefinition) {
     this.name = name;
     this.description = definition?.description;
     this.tags = (definition?.tags ?? []).concat(["Element"]).concat(defaultTags);
+    this.archetype = archetype;
+    this.overrideDefinition = overrideDefinition;
   }
   description;
   tags;
+  archetype;
+  overrideDefinition;
   _relationships = [];
   get canonicalName() {
     return camelCase(this.name);
   }
-  uses(otherElement, definition) {
-    const relationship = new Relationship(this, otherElement, definition);
+  uses(otherElement, archetypeOrDef, override) {
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof RelationshipArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const relationship = new Relationship(this, otherElement, definition, archetype, override);
     this._relationships.push(relationship);
   }
   get relationships() {
@@ -37,22 +175,26 @@ var Element = class {
 };
 var TechnicalElement = class extends Element {
   technology;
-  constructor(name, defaultTags = [], definition) {
-    super(name, defaultTags, definition);
+  constructor(name, defaultTags = [], definition, archetype, overrideDefinition) {
+    super(name, defaultTags, definition, archetype, overrideDefinition);
     this.technology = definition?.technology;
   }
 };
 var Relationship = class {
-  constructor(source, destination, definition) {
+  constructor(source, destination, definition, archetype, overrideDefinition) {
     this.source = source;
     this.destination = destination;
     this.description = definition?.description;
     this.technology = definition?.technology;
     this.tags = (definition?.tags ?? []).concat(["Relationship"]);
+    this.archetype = archetype;
+    this.overrideDefinition = overrideDefinition;
   }
   description;
   tags;
   technology;
+  archetype;
+  overrideDefinition;
 };
 var Group = class {
   constructor(name) {
@@ -64,8 +206,8 @@ var Group = class {
 
 // libs/c4-model/src/component.ts
 var Component = class extends TechnicalElement {
-  constructor(name, definition) {
-    super(name, ["Component"], definition);
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Component"], definition, archetype, overrideDefinition);
     this.name = name;
   }
   getChildElements() {
@@ -81,8 +223,8 @@ var ContainerGroup = class extends Group {
     this.container = container;
   }
   _components = /* @__PURE__ */ new Map();
-  defineComponent(name, definition) {
-    const component = this.container.defineComponent(name, definition);
+  defineComponent(name, archetypeOrDef, override) {
+    const component = this.container.defineComponent(name, archetypeOrDef, override);
     this._components.set(name, component);
     return component;
   }
@@ -91,17 +233,25 @@ var ContainerGroup = class extends Group {
   }
 };
 var Container = class extends TechnicalElement {
-  constructor(name, definition) {
-    super(name, ["Container"], definition);
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Container"], definition, archetype, overrideDefinition);
     this.name = name;
   }
   _components = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineComponent(name, definition) {
+  defineComponent(name, archetypeOrDef, override) {
     if (this._components.has(name)) {
       throw Error(`A Component named '${name}' is defined elsewhere in this Container. A Component can be defined only once.`);
     }
-    const component = new Component(name, definition);
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const component = new Component(name, definition, archetype, override);
     this._components.set(name, component);
     return component;
   }
@@ -133,8 +283,8 @@ var SoftwareSystemGroup = class extends Group {
     this.softwareSystem = softwareSystem;
   }
   _containers = /* @__PURE__ */ new Map();
-  defineContainer(name, definition) {
-    const container = this.softwareSystem.defineContainer(name, definition);
+  defineContainer(name, archetypeOrDef, override) {
+    const container = this.softwareSystem.defineContainer(name, archetypeOrDef, override);
     this._containers.set(name, container);
     return container;
   }
@@ -143,17 +293,25 @@ var SoftwareSystemGroup = class extends Group {
   }
 };
 var SoftwareSystem = class extends Element {
-  constructor(name, definition) {
-    super(name, ["Software System"], definition);
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Software System"], definition, archetype, overrideDefinition);
     this.name = name;
   }
   _containers = /* @__PURE__ */ new Map();
   _groups = /* @__PURE__ */ new Map();
-  defineContainer(name, definition) {
+  defineContainer(name, archetypeOrDef, override) {
     if (this._containers.has(name)) {
       throw Error(`A Container named '${name}' is defined elsewhere in this SoftwareSystem. A Container can be defined only once.`);
     }
-    const container = new Container(name, definition);
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const container = new Container(name, definition, archetype, override);
     this._containers.set(name, container);
     return container;
   }
@@ -179,8 +337,8 @@ var SoftwareSystem = class extends Element {
 
 // libs/c4-model/src/person.ts
 var Person = class extends Element {
-  constructor(name, definition) {
-    super(name, ["Person"], definition);
+  constructor(name, definition, archetype, overrideDefinition) {
+    super(name, ["Person"], definition, archetype, overrideDefinition);
     this.name = name;
   }
   getChildElements() {
@@ -189,7 +347,6 @@ var Person = class extends Element {
 };
 
 // libs/c4-model/src/model.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
 var ModelGroup = class extends Group {
   constructor(name, model) {
     super(name);
@@ -198,13 +355,13 @@ var ModelGroup = class extends Group {
   }
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, definition) {
-    const softwareSystem = this.model.defineSoftwareSystem(name, definition);
+  defineSoftwareSystem(name, archetypeOrDef, override) {
+    const softwareSystem = this.model.defineSoftwareSystem(name, archetypeOrDef, override);
     this.softwareSystems.set(name, softwareSystem);
     return softwareSystem;
   }
-  definePerson(name, definition) {
-    const person = this.model.definePerson(name, definition);
+  definePerson(name, archetypeOrDef, override) {
+    const person = this.model.definePerson(name, archetypeOrDef, override);
     this.people.set(name, person);
     return person;
   }
@@ -222,11 +379,19 @@ var Model = class {
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
   groups = /* @__PURE__ */ new Map();
-  defineSoftwareSystem(name, definition) {
+  defineSoftwareSystem(name, archetypeOrDef, override) {
     if (this.softwareSystems.has(name)) {
       throw Error(`A SoftwareSystem named '${name}' is defined elsewhere in this Model. A SoftwareSystem can be defined only once.`);
     }
-    const system = new SoftwareSystem(name, definition);
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const system = new SoftwareSystem(name, definition, archetype, override);
     this.softwareSystems.set(name, system);
     return system;
   }
@@ -239,11 +404,19 @@ var Model = class {
     }
     return group;
   }
-  definePerson(name, definition) {
+  definePerson(name, archetypeOrDef, override) {
     if (this.people.has(name)) {
       throw Error(`A Person named '${name}' is defined elsewhere in this Model. A Person can be defined only once.`);
     }
-    const person = new Person(name, definition);
+    let definition;
+    let archetype;
+    if (archetypeOrDef instanceof ElementArchetype) {
+      archetype = archetypeOrDef;
+      definition = mergeArchetypeWithOverride(archetypeOrDef, override);
+    } else {
+      definition = archetypeOrDef;
+    }
+    const person = new Person(name, definition, archetype, override);
     this.people.set(name, person);
     return person;
   }
@@ -267,37 +440,6 @@ var Model = class {
     return Array.from(this.groups.values());
   }
 };
-async function buildModelWithCatalog(options = {}) {
-  const { modelName = "model", globPath = "c4.dsl.ts", searchRoot = __dirname } = options;
-  const model = new Model(modelName);
-  const result = await glob(`**/${globPath}`, { cwd: searchRoot });
-  if (result.length === 0) {
-    throw new Error(`No ${globPath} files found`);
-  }
-  const modules = await Promise.all(result.map((file) => import(join(searchRoot, file))));
-  const registrations = [];
-  const rootCatalog = {};
-  for (const module of modules) {
-    if (!module.c4Module) {
-      continue;
-    }
-    const instance = module.c4Module;
-    const local = instance.registerDefinitions(model);
-    rootCatalog[instance.key] = local;
-    registrations.push({ instance, key: instance.key, local });
-  }
-  if (registrations.length === 0) {
-    throw new Error(`No c4Module exports found in any ${globPath} files`);
-  }
-  for (const { instance, key, local } of registrations) {
-    const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
-    instance.buildRelationships(local, dependencies);
-  }
-  return { model, catalog: rootCatalog };
-}
-async function buildModel(options = {}) {
-  return (await buildModelWithCatalog(options)).model;
-}
 
 // libs/c4-model/src/views.ts
 var View = class {
@@ -379,13 +521,115 @@ var StructurizrDSLWriter = class {
     this.model = model;
     this.views = views;
   }
+  collectArchetypes() {
+    const elementSet = /* @__PURE__ */ new Set();
+    const relationshipSet = /* @__PURE__ */ new Set();
+    const collectFromElement = (element) => {
+      if (element.archetype) {
+        let arch = element.archetype;
+        while (arch) {
+          elementSet.add(arch);
+          arch = arch.parent;
+        }
+      }
+      element.relationships.forEach((rel) => {
+        if (rel.archetype) {
+          let arch = rel.archetype;
+          while (arch) {
+            relationshipSet.add(arch);
+            arch = arch.parent;
+          }
+        }
+      });
+      element.getChildElements().forEach(collectFromElement);
+    };
+    const allElements = [...this.model.getPeople(), ...this.model.getSoftwareSystems()];
+    allElements.forEach(collectFromElement);
+    const sortArchetypes = (set) => {
+      const sorted = [];
+      const visited = /* @__PURE__ */ new Set();
+      const visit = (arch) => {
+        if (visited.has(arch)) return;
+        if (arch.parent && set.has(arch.parent)) visit(arch.parent);
+        visited.add(arch);
+        sorted.push(arch);
+      };
+      set.forEach(visit);
+      return sorted;
+    };
+    return {
+      elementArchetypes: sortArchetypes(elementSet),
+      relationshipArchetypes: sortArchetypes(relationshipSet)
+    };
+  }
+  writeArchetypes(level) {
+    const { elementArchetypes, relationshipArchetypes } = this.collectArchetypes();
+    if (elementArchetypes.length === 0 && relationshipArchetypes.length === 0) return "";
+    let dsl = this.writeLine(`archetypes {`, level);
+    for (const arch of elementArchetypes) {
+      const baseType = arch.parent ? arch.parent.name : arch.elementKind;
+      let inner = "";
+      if (arch.ownDescription) {
+        inner += this.writeLine(`description "${arch.ownDescription}"`, level + 2);
+      }
+      if (arch.ownTechnology) {
+        inner += this.writeLine(`technology "${arch.ownTechnology}"`, level + 2);
+      }
+      if (arch.ownTags.length > 0) {
+        inner += this.writeLine(`tags ${arch.ownTags.map((t) => `"${t}"`).join(" ")}`, level + 2);
+      }
+      if (inner) {
+        dsl += this.writeLine(`${arch.name} = ${baseType} {`, level + 1);
+        dsl += inner;
+        dsl += this.writeLine(`}`, level + 1);
+      } else {
+        dsl += this.writeLine(`${arch.name} = ${baseType} {}`, level + 1);
+      }
+    }
+    for (const arch of relationshipArchetypes) {
+      const arrow = arch.parent ? `--${arch.parent.name}->` : `->`;
+      let inner = "";
+      if (arch.ownDescription) {
+        inner += this.writeLine(`description "${arch.ownDescription}"`, level + 2);
+      }
+      if (arch.ownTechnology) {
+        inner += this.writeLine(`technology "${arch.ownTechnology}"`, level + 2);
+      }
+      if (arch.ownTags.length > 0) {
+        inner += this.writeLine(`tags ${arch.ownTags.map((t) => `"${t}"`).join(" ")}`, level + 2);
+      }
+      if (inner) {
+        dsl += this.writeLine(`${arch.name} = ${arrow} {`, level + 1);
+        dsl += inner;
+        dsl += this.writeLine(`}`, level + 1);
+      } else {
+        dsl += this.writeLine(`${arch.name} = ${arrow} {}`, level + 1);
+      }
+    }
+    dsl += this.writeLine(`}`, level);
+    return dsl;
+  }
   writeElement(elementType, element, level, closeElement = true) {
     let elementDsl = "";
-    elementDsl += this.writeLine(`${element.canonicalName} = ${elementType} "${element.name}" {`, level);
-    if (element.description) {
-      elementDsl += this.writeLine(`description "${element.description}"`, level + 1);
+    const type = element.archetype ? element.archetype.name : elementType;
+    elementDsl += this.writeLine(`${element.canonicalName} = ${type} "${element.name}" {`, level);
+    if (element.archetype) {
+      const ovr = element.overrideDefinition;
+      if (ovr?.description) {
+        elementDsl += this.writeLine(`description "${ovr.description}"`, level + 1);
+      }
+      if (ovr?.tags && ovr.tags.length > 0) {
+        elementDsl += this.writeLine(`tags ${ovr.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      }
+      if (ovr && "technology" in ovr && ovr.technology) {
+        elementDsl += this.writeLine(`technology "${ovr.technology}"`, level + 1);
+      }
+    } else {
+      if (element.description) {
+        elementDsl += this.writeLine(`description "${element.description}"`, level + 1);
+      }
+      elementDsl += this.writeLine(`tags ${element.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
     }
-    elementDsl += this.writeLine(`tags ${element.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
     if (closeElement) {
       elementDsl += this.writeLine(`}`, level);
     }
@@ -394,7 +638,9 @@ var StructurizrDSLWriter = class {
   writeComponent(component, level) {
     let componentDsl = "";
     componentDsl += this.writeElement("component", component, level, false);
-    componentDsl += this.writeLine(`technology "${component.technology}"`, level + 1);
+    if (!component.archetype && component.technology) {
+      componentDsl += this.writeLine(`technology "${component.technology}"`, level + 1);
+    }
     componentDsl += this.writeLine(`}`, level);
     return componentDsl;
   }
@@ -410,7 +656,9 @@ var StructurizrDSLWriter = class {
   writeContainer(container, level) {
     let containerDsl = "";
     containerDsl += this.writeElement("container", container, level, false);
-    containerDsl += this.writeLine(`technology "${container.technology}"`, level + 1);
+    if (!container.archetype && container.technology) {
+      containerDsl += this.writeLine(`technology "${container.technology}"`, level + 1);
+    }
     container.getComponentsNotInGroups().forEach((component) => {
       containerDsl += this.writeComponent(component, level + 1);
     });
@@ -441,17 +689,39 @@ var StructurizrDSLWriter = class {
     softwareSystemDsl += this.writeLine(`}`, level);
     return softwareSystemDsl;
   }
+  writeRelationship(relationship, level) {
+    let dsl = "";
+    if (relationship.archetype) {
+      const arrow = `--${relationship.archetype.name}->`;
+      const ovr = relationship.overrideDefinition;
+      const desc = ovr?.description ?? relationship.description ?? "uses";
+      dsl += this.writeLine(
+        `${relationship.source.canonicalName} ${arrow} ${relationship.destination.canonicalName} "${desc}" {`,
+        level
+      );
+      if (ovr?.technology) {
+        dsl += this.writeLine(`technology "${ovr.technology}"`, level + 1);
+      }
+      if (ovr?.tags && ovr.tags.length > 0) {
+        dsl += this.writeLine(`tags ${ovr.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      }
+      dsl += this.writeLine(`}`, level);
+    } else {
+      const tech = relationship.technology ? ` "${relationship.technology}"` : "";
+      dsl += this.writeLine(
+        `${relationship.source.canonicalName} -> ${relationship.destination.canonicalName} "${relationship.description ?? "uses"}"${tech} {`,
+        level
+      );
+      dsl += this.writeLine(`tags ${relationship.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
+      dsl += this.writeLine(`}`, level);
+    }
+    return dsl;
+  }
   writeRelationships(elements, level) {
     let relationshipsDsl = "";
     elements.forEach((element) => {
       element.getRelationshipsInHierarchy().forEach((relationship) => {
-        const tech = relationship.technology ? ` "${relationship.technology}"` : "";
-        relationshipsDsl += this.writeLine(
-          `${relationship.source.canonicalName} -> ${relationship.destination.canonicalName} "${relationship.description ?? "uses"}"${tech} {`,
-          level
-        );
-        relationshipsDsl += this.writeLine(`tags ${relationship.tags.map((tag) => `"${tag}"`).join(" ")}`, level + 1);
-        relationshipsDsl += this.writeLine(`}`, level);
+        relationshipsDsl += this.writeRelationship(relationship, level);
       });
     });
     return relationshipsDsl;
@@ -471,6 +741,7 @@ var StructurizrDSLWriter = class {
   writeModel(model, level) {
     let modelDsl = "";
     modelDsl += this.writeLine(`model {`, level);
+    modelDsl += this.writeArchetypes(level + 1);
     modelDsl += this.writeLine("// Elements", level + 1);
     model.getPeopleNotInGroups().forEach((person) => {
       modelDsl += this.writeElement("person", person, level + 1);
@@ -487,10 +758,7 @@ var StructurizrDSLWriter = class {
     return modelDsl;
   }
   writeView(view, viewType, level) {
-    let viewDsl = this.writeLine(
-      `${viewType}${view.subject ? ' "' + view.subject.canonicalName + '"' : ""} "${view.key}" {`,
-      level
-    );
+    let viewDsl = this.writeLine(`${viewType}${view.subject ? ' "' + view.subject.canonicalName + '"' : ""} "${view.key}" {`, level);
     viewDsl += this.writeLine(`description "${view.description}"`, level + 1);
     if (view.title) {
       viewDsl += this.writeLine(`title "${view.title}"`, level + 1);
@@ -540,6 +808,46 @@ var StructurizrDSLWriter = class {
   }
 };
 
+// libs/c4-model/src/buildModel.ts
+import { glob } from "glob";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+async function buildModelWithCatalog(options = {}) {
+  const { modelName = "model", modules: explicitModules } = options;
+  const model = new Model(modelName);
+  let c4Modules;
+  if (explicitModules) {
+    c4Modules = [...explicitModules];
+  } else {
+    const { globPath = "c4.dsl.ts", searchRoot = _dirname } = options;
+    const result = await glob(`**/${globPath}`, { cwd: searchRoot });
+    if (result.length === 0) {
+      throw new Error(`No ${globPath} files found`);
+    }
+    const imported = await Promise.all(result.map((file) => import(join(searchRoot, file))));
+    c4Modules = imported.filter((m) => m.c4Module).map((m) => m.c4Module);
+  }
+  if (c4Modules.length === 0) {
+    throw new Error("No c4Module instances found");
+  }
+  const registrations = [];
+  const rootCatalog = {};
+  for (const instance of c4Modules) {
+    const local = instance.registerDefinitions(model);
+    rootCatalog[instance.key] = local;
+    registrations.push({ instance, key: instance.key, local });
+  }
+  for (const { instance, key, local } of registrations) {
+    const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
+    instance.buildRelationships(local, dependencies);
+  }
+  return { model, catalog: rootCatalog };
+}
+async function buildModel(options = {}) {
+  return (await buildModelWithCatalog(options)).model;
+}
+
 // libs/c4-model/src/generateDiagrams.ts
 import * as fs from "fs";
 import * as os from "os";
@@ -573,9 +881,11 @@ export {
   Component,
   Container,
   ContainerGroup,
+  ElementArchetype,
   Model,
   ModelGroup,
   Person,
+  RelationshipArchetype,
   SoftwareSystem,
   SoftwareSystemGroup,
   StructurizrDSLWriter,
@@ -583,5 +893,6 @@ export {
   Views,
   buildModel,
   buildModelWithCatalog,
-  generateDiagrams
+  generateDiagrams,
+  mergeArchetypeWithOverride
 };