@agilewallaby/c4-model 2.7.0 → 2.8.0

package/src/index.cjs

@@ -44,9 +44,11 @@ __export(index_exports, {
   View: () => View,
   Views: () => Views,
   buildModel: () => buildModel,
-  buildModelWithCatalog: () => buildModelWithCatalog,
+  exportWorkspaceJson: () => exportWorkspaceJson,
+  exportWorkspaceJsonFromDsl: () => exportWorkspaceJsonFromDsl,
   generateDiagrams: () => generateDiagrams,
-  mergeArchetypeWithOverride: () => mergeArchetypeWithOverride
+  mergeArchetypeWithOverride: () => mergeArchetypeWithOverride,
+  validateModel: () => validateModel
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -221,9 +223,9 @@ var Element = class {
   getRelationshipsInHierarchy() {
     return this._relationships.concat(this.getChildElements().flatMap((element) => element.getRelationshipsInHierarchy()));
   }
-  getChildElementNames(path2) {
+  getChildElementNames(path4) {
     const result = Array.from(this.getChildElements()).flatMap((reference) => {
-      const currentPath = `${path2 ? path2 : "" + this.name}.${reference.name}`;
+      const currentPath = `${path4 ? path4 : "" + this.name}.${reference.name}`;
       return [currentPath, ...reference.getChildElementNames(currentPath)];
     });
     return result;
@@ -279,21 +281,46 @@ var Component = class extends TechnicalElement {
 };
 
 // libs/c4-model/src/container.ts
-var ContainerGroup = class extends Group {
-  constructor(name, container) {
+var ContainerGroup = class _ContainerGroup extends Group {
+  constructor(name, container, pathSegments = []) {
     super(name);
     this.name = name;
     this.container = container;
+    this.pathSegments = pathSegments;
   }
   _components = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   component(name, archetypeOrDef, override) {
     const component = this.container.component(name, archetypeOrDef, override);
     this._components.set(name, component);
     return component;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _ContainerGroup(groupName, this.container, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getComponents() {
     return Array.from(this._components.values());
   }
+  getAllComponents() {
+    return [
+      ...this._components.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllComponents())
+    ];
+  }
 };
 var Container = class extends TechnicalElement {
   constructor(name, definition, archetype, overrideDefinition) {
@@ -330,7 +357,7 @@ var Container = class extends TechnicalElement {
     return Array.from(this._groups.values());
   }
   getComponentsNotInGroups() {
-    const componentsInGroups = this.getGroups().flatMap((group) => group.getComponents());
+    const componentsInGroups = this.getGroups().flatMap((group) => group.getAllComponents());
     return Array.from(this._components.values()).filter((component) => !componentsInGroups.includes(component));
   }
   getChildElements() {
@@ -339,21 +366,46 @@ var Container = class extends TechnicalElement {
 };
 
 // libs/c4-model/src/softwareSystem.ts
-var SoftwareSystemGroup = class extends Group {
-  constructor(name, softwareSystem) {
+var SoftwareSystemGroup = class _SoftwareSystemGroup extends Group {
+  constructor(name, softwareSystem, pathSegments = []) {
     super(name);
     this.name = name;
     this.softwareSystem = softwareSystem;
+    this.pathSegments = pathSegments;
   }
   _containers = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   container(name, archetypeOrDef, override) {
     const container = this.softwareSystem.container(name, archetypeOrDef, override);
     this._containers.set(name, container);
     return container;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _SoftwareSystemGroup(groupName, this.softwareSystem, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getContainers() {
     return Array.from(this._containers.values());
   }
+  getAllContainers() {
+    return [
+      ...this._containers.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllContainers())
+    ];
+  }
 };
 var SoftwareSystem = class extends Element {
   constructor(name, definition, archetype, overrideDefinition) {
@@ -393,7 +445,7 @@ var SoftwareSystem = class extends Element {
     return Array.from(this._containers.values());
   }
   getContainersNotInGroups() {
-    const containersInGroups = Array.from(this._groups.values()).flatMap((group) => group.getContainers());
+    const containersInGroups = Array.from(this._groups.values()).flatMap((group) => group.getAllContainers());
     return Array.from(this._containers.values()).filter((container) => !containersInGroups.includes(container));
   }
 };
@@ -410,14 +462,22 @@ var Person = class extends Element {
 };
 
 // libs/c4-model/src/model.ts
-var ModelGroup = class extends Group {
-  constructor(name, model) {
+var ModelGroup = class _ModelGroup extends Group {
+  constructor(name, model, pathSegments = []) {
     super(name);
     this.name = name;
     this.model = model;
+    this.pathSegments = pathSegments;
   }
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   softwareSystem(name, archetypeOrDef, override) {
     const softwareSystem = this.model.softwareSystem(name, archetypeOrDef, override);
     this.softwareSystems.set(name, softwareSystem);
@@ -428,12 +488,35 @@ var ModelGroup = class extends Group {
     this.people.set(name, person);
     return person;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _ModelGroup(groupName, this.model, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getSoftwareSystems() {
     return Array.from(this.softwareSystems.values());
   }
   getPeople() {
     return Array.from(this.people.values());
   }
+  getAllSoftwareSystems() {
+    return [
+      ...this.softwareSystems.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllSoftwareSystems())
+    ];
+  }
+  getAllPeople() {
+    return [
+      ...this.people.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllPeople())
+    ];
+  }
 };
 var Model = class {
   constructor(name) {
@@ -458,7 +541,6 @@ var Model = class {
     this.softwareSystems.set(name, system);
     return system;
   }
-  // TODO:Should be a Group<SoftwareSystem | Person> if that is added back in
   group(groupName) {
     let group = this.groups.get(groupName);
     if (!group) {
@@ -493,11 +575,11 @@ var Model = class {
     return Array.from(this.softwareSystems.values());
   }
   getPeopleNotInGroups() {
-    const peopleInGroups = Array.from(this.groups.values()).flatMap((group) => group.getPeople());
+    const peopleInGroups = Array.from(this.groups.values()).flatMap((group) => group.getAllPeople());
     return Array.from(this.people.values()).filter((person) => !peopleInGroups.includes(person));
   }
   getSoftwareSystemsNotInGroups() {
-    const systemsInGroups = Array.from(this.groups.values()).flatMap((group) => group.getSoftwareSystems());
+    const systemsInGroups = Array.from(this.groups.values()).flatMap((group) => group.getAllSoftwareSystems());
     return Array.from(this.softwareSystems.values()).filter((system) => !systemsInGroups.includes(system));
   }
   getGroups() {
@@ -517,6 +599,9 @@ var View = class {
   description;
   title;
   _scopes = [];
+  _autoLayout;
+  _isDefault = false;
+  _properties = /* @__PURE__ */ new Map();
   includeAll() {
     this._scopes.push("include *");
   }
@@ -535,15 +620,37 @@ var View = class {
   excludeExpression(expression) {
     this._scopes.push(`exclude ${expression}`);
   }
+  autoLayout(direction, rankSeparation, nodeSeparation) {
+    this._autoLayout = { direction, rankSeparation, nodeSeparation };
+  }
+  setDefault() {
+    this._isDefault = true;
+  }
+  addProperty(name, value) {
+    this._properties.set(name, value);
+  }
   get scopes() {
     return this._scopes;
   }
+  get autoLayoutConfig() {
+    return this._autoLayout;
+  }
+  get isDefault() {
+    return this._isDefault;
+  }
+  get properties() {
+    return this._properties;
+  }
 };
 var Views = class {
   _systemLandscapeViews = /* @__PURE__ */ new Map();
   _systemContextViews = /* @__PURE__ */ new Map();
   _containerViews = /* @__PURE__ */ new Map();
   _componentViews = /* @__PURE__ */ new Map();
+  _elementStyles = [];
+  _relationshipStyles = [];
+  _themes = [];
+  _properties = /* @__PURE__ */ new Map();
   addSystemLandscapeView(key, definition) {
     const view = new View(key, { subject: void 0, description: definition.description, title: definition.title });
     this._systemLandscapeViews.set(key, view);
@@ -564,6 +671,18 @@ var Views = class {
     this._componentViews.set(key, view);
     return view;
   }
+  addElementStyle(tag, definition) {
+    this._elementStyles.push({ tag, definition });
+  }
+  addRelationshipStyle(tag, definition) {
+    this._relationshipStyles.push({ tag, definition });
+  }
+  addTheme(url) {
+    this._themes.push(url);
+  }
+  addProperty(name, value) {
+    this._properties.set(name, value);
+  }
   get systemLandscapeViews() {
     return Array.from(this._systemLandscapeViews.values());
   }
@@ -576,6 +695,18 @@ var Views = class {
   get componentViews() {
     return Array.from(this._componentViews.values());
   }
+  get elementStyles() {
+    return this._elementStyles;
+  }
+  get relationshipStyles() {
+    return this._relationshipStyles;
+  }
+  get themes() {
+    return this._themes;
+  }
+  get properties() {
+    return this._properties;
+  }
 };
 
 // libs/c4-model/src/structurizrDslWriter.ts
@@ -710,11 +841,17 @@ var StructurizrDSLWriter = class {
   }
   writeContainerGroup(group, level) {
     let containerGroupDsl = "";
-    containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getComponents().forEach((component) => {
-      containerGroupDsl += this.writeComponent(component, level + 1);
+    const hasDirect = group.getComponents().length > 0;
+    if (hasDirect) {
+      containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getComponents().forEach((component) => {
+        containerGroupDsl += this.writeComponent(component, level + 1);
+      });
+      containerGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      containerGroupDsl += this.writeContainerGroup(nested, level);
     });
-    containerGroupDsl += this.writeLine(`}`, level);
     return containerGroupDsl;
   }
   writeContainer(container, level) {
@@ -734,11 +871,17 @@ var StructurizrDSLWriter = class {
   }
   writeSoftwareSystemGroup(group, level) {
     let softwareSystemGroupDsl = "";
-    softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getContainers().forEach((container) => {
-      softwareSystemGroupDsl += this.writeContainer(container, level + 1);
+    const hasDirect = group.getContainers().length > 0;
+    if (hasDirect) {
+      softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getContainers().forEach((container) => {
+        softwareSystemGroupDsl += this.writeContainer(container, level + 1);
+      });
+      softwareSystemGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      softwareSystemGroupDsl += this.writeSoftwareSystemGroup(nested, level);
     });
-    softwareSystemGroupDsl += this.writeLine(`}`, level);
     return softwareSystemGroupDsl;
   }
   writeSoftwareSystem(softwareSystem, level) {
@@ -790,21 +933,51 @@ var StructurizrDSLWriter = class {
     });
     return relationshipsDsl;
   }
+  hasNestedModelGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedModelGroups(g.getGroups()));
+  }
+  hasNestedSoftwareSystemGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedSoftwareSystemGroups(g.getGroups()));
+  }
+  hasNestedContainerGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedContainerGroups(g.getGroups()));
+  }
+  hasNestedGroups() {
+    if (this.hasNestedModelGroups(this.model.getGroups())) return true;
+    for (const ss of this.model.getSoftwareSystems()) {
+      if (this.hasNestedSoftwareSystemGroups(ss.getGroups())) return true;
+      for (const c of ss.getGroups().flatMap((g) => g.getAllContainers())) {
+        if (this.hasNestedContainerGroups(c.getGroups())) return true;
+      }
+    }
+    return false;
+  }
   writeModelGroup(group, level) {
     let modelGroupDsl = "";
-    modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getPeople().forEach((person) => {
-      modelGroupDsl += this.writeElement("person", person, level + 1);
-    });
-    group.getSoftwareSystems().forEach((softwareSystem) => {
-      modelGroupDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+    const hasDirect = group.getPeople().length > 0 || group.getSoftwareSystems().length > 0;
+    if (hasDirect) {
+      modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getPeople().forEach((person) => {
+        modelGroupDsl += this.writeElement("person", person, level + 1);
+      });
+      group.getSoftwareSystems().forEach((softwareSystem) => {
+        modelGroupDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+      });
+      modelGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      modelGroupDsl += this.writeModelGroup(nested, level);
     });
-    modelGroupDsl += this.writeLine(`}`, level);
     return modelGroupDsl;
   }
   writeModel(model, level) {
     let modelDsl = "";
     modelDsl += this.writeLine(`model {`, level);
+    if (this.hasNestedGroups()) {
+      modelDsl += this.writeLine(`properties {`, level + 1);
+      modelDsl += this.writeLine(`"structurizr.groupSeparator" "/"`, level + 2);
+      modelDsl += this.writeLine(`}`, level + 1);
+    }
     modelDsl += this.writeArchetypes(level + 1);
     modelDsl += this.writeLine("// Elements", level + 1);
     model.getPeopleNotInGroups().forEach((person) => {
@@ -827,12 +1000,66 @@ var StructurizrDSLWriter = class {
     if (view.title) {
       viewDsl += this.writeLine(`title "${view.title}"`, level + 1);
     }
+    if (view.isDefault) {
+      viewDsl += this.writeLine("default", level + 1);
+    }
     view.scopes.forEach((scope) => {
       viewDsl += this.writeLine(`${scope}`, level + 1);
     });
+    if (view.autoLayoutConfig) {
+      const { direction, rankSeparation, nodeSeparation } = view.autoLayoutConfig;
+      let line = "autoLayout";
+      if (direction) line += ` ${direction}`;
+      if (rankSeparation !== void 0) line += ` ${rankSeparation}`;
+      if (nodeSeparation !== void 0) line += ` ${nodeSeparation}`;
+      viewDsl += this.writeLine(line, level + 1);
+    }
+    if (view.properties.size > 0) {
+      viewDsl += this.writeLine("properties {", level + 1);
+      for (const [name, value] of view.properties) {
+        viewDsl += this.writeLine(`"${name}" "${value}"`, level + 2);
+      }
+      viewDsl += this.writeLine("}", level + 1);
+    }
     viewDsl += this.writeLine(`}`, level);
     return viewDsl;
   }
+  writeStyles(views, level) {
+    const { elementStyles, relationshipStyles } = views;
+    if (elementStyles.length === 0 && relationshipStyles.length === 0) return "";
+    let dsl = this.writeLine("styles {", level);
+    for (const { tag, definition: d } of elementStyles) {
+      dsl += this.writeLine(`element "${tag}" {`, level + 1);
+      if (d.shape) dsl += this.writeLine(`shape ${d.shape}`, level + 2);
+      if (d.icon) dsl += this.writeLine(`icon "${d.icon}"`, level + 2);
+      if (d.width) dsl += this.writeLine(`width ${d.width}`, level + 2);
+      if (d.height) dsl += this.writeLine(`height ${d.height}`, level + 2);
+      if (d.background) dsl += this.writeLine(`background "${d.background}"`, level + 2);
+      if (d.color) dsl += this.writeLine(`color "${d.color}"`, level + 2);
+      if (d.stroke) dsl += this.writeLine(`stroke "${d.stroke}"`, level + 2);
+      if (d.strokeWidth) dsl += this.writeLine(`strokeWidth ${d.strokeWidth}`, level + 2);
+      if (d.fontSize) dsl += this.writeLine(`fontSize ${d.fontSize}`, level + 2);
+      if (d.border) dsl += this.writeLine(`border ${d.border}`, level + 2);
+      if (d.opacity !== void 0) dsl += this.writeLine(`opacity ${d.opacity}`, level + 2);
+      if (d.metadata !== void 0) dsl += this.writeLine(`metadata ${d.metadata}`, level + 2);
+      if (d.description !== void 0) dsl += this.writeLine(`description ${d.description}`, level + 2);
+      dsl += this.writeLine("}", level + 1);
+    }
+    for (const { tag, definition: d } of relationshipStyles) {
+      dsl += this.writeLine(`relationship "${tag}" {`, level + 1);
+      if (d.thickness) dsl += this.writeLine(`thickness ${d.thickness}`, level + 2);
+      if (d.color) dsl += this.writeLine(`color "${d.color}"`, level + 2);
+      if (d.style) dsl += this.writeLine(`style ${d.style}`, level + 2);
+      if (d.routing) dsl += this.writeLine(`routing ${d.routing}`, level + 2);
+      if (d.fontSize) dsl += this.writeLine(`fontSize ${d.fontSize}`, level + 2);
+      if (d.width) dsl += this.writeLine(`width ${d.width}`, level + 2);
+      if (d.position !== void 0) dsl += this.writeLine(`position ${d.position}`, level + 2);
+      if (d.opacity !== void 0) dsl += this.writeLine(`opacity ${d.opacity}`, level + 2);
+      dsl += this.writeLine("}", level + 1);
+    }
+    dsl += this.writeLine("}", level);
+    return dsl;
+  }
   writeViews(views, level) {
     let viewDsl = "";
     viewDsl += this.writeLine(`views {`, level);
@@ -852,6 +1079,19 @@ var StructurizrDSLWriter = class {
     views.componentViews.forEach((view) => {
       viewDsl += this.writeView(view, "component", level + 1);
     });
+    viewDsl += this.writeStyles(views, level + 1);
+    if (views.themes.length === 1) {
+      viewDsl += this.writeLine(`theme ${views.themes[0]}`, level + 1);
+    } else if (views.themes.length > 1) {
+      viewDsl += this.writeLine(`themes ${views.themes.join(" ")}`, level + 1);
+    }
+    if (views.properties.size > 0) {
+      viewDsl += this.writeLine("properties {", level + 1);
+      for (const [name, value] of views.properties) {
+        viewDsl += this.writeLine(`"${name}" "${value}"`, level + 2);
+      }
+      viewDsl += this.writeLine("}", level + 1);
+    }
     viewDsl += this.writeLine(`}`, level);
     return viewDsl;
   }
@@ -877,8 +1117,8 @@ var import_path = require("path");
 var import_url = require("url");
 var import_meta = {};
 var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
-async function buildModelWithCatalog(options = {}) {
-  const { modelName = "model", modules: explicitModules, archetypes = {} } = options;
+async function buildModel(options = {}) {
+  const { modelName = "model", modules: explicitModules, archetypes = {}, addViews } = options;
   const model = new Model(modelName);
   let c4Modules;
   if (explicitModules) {
@@ -902,14 +1142,16 @@ async function buildModelWithCatalog(options = {}) {
     rootCatalog[instance.key] = local;
     registrations.push({ instance, key: instance.key, local });
   }
+  const dependenciesFor = (key) => Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
   for (const { instance, key, local } of registrations) {
-    const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
-    instance.buildRelationships(local, dependencies, archetypes);
+    instance.addRelationships(local, dependenciesFor(key), archetypes);
   }
-  return { model, catalog: rootCatalog };
-}
-async function buildModel(options = {}) {
-  return (await buildModelWithCatalog(options)).model;
+  const views = new Views();
+  addViews?.(views, rootCatalog);
+  for (const { instance, key, local } of registrations) {
+    instance.addViews?.(views, local, dependenciesFor(key));
+  }
+  return { model, catalog: rootCatalog, views };
 }
 
 // libs/c4-model/src/generateDiagrams.ts
@@ -918,9 +1160,8 @@ var os = __toESM(require("os"), 1);
 var path = __toESM(require("path"), 1);
 var import_testcontainers = require("testcontainers");
 async function generateDiagrams(options) {
-  const { views: viewsFactory, outputDir, ...buildOptions } = options;
-  const { model, catalog } = await buildModelWithCatalog(buildOptions);
-  const views = viewsFactory(catalog);
+  const { outputDir, ...buildOptions } = options;
+  const { model, views } = await buildModel(buildOptions);
   const dsl = new StructurizrDSLWriter(model, views).write();
   const tmpDir = await fs.promises.mkdtemp(path.join(fs.realpathSync(os.tmpdir()), "c4-diagrams-"));
   await fs.promises.writeFile(path.join(tmpDir, "workspace.dsl"), dsl, "utf8");
@@ -941,6 +1182,60 @@ async function generateDiagrams(options) {
   }
   return generatedFiles;
 }
+
+// libs/c4-model/src/validateModel.ts
+var fs2 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_testcontainers2 = require("testcontainers");
+async function validateModel(model, views) {
+  const dsl = new StructurizrDSLWriter(model, views).write();
+  const tmpDir = await fs2.promises.mkdtemp(path2.join(fs2.realpathSync(os2.tmpdir()), "c4-validate-"));
+  try {
+    await fs2.promises.writeFile(path2.join(tmpDir, "workspace.dsl"), dsl, "utf8");
+    const logs = [];
+    try {
+      await new import_testcontainers2.GenericContainer("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["validate", "-workspace", "/workspace/workspace.dsl"]).withWaitStrategy(import_testcontainers2.Wait.forOneShotStartup()).withLogConsumer((stream) => stream.on("data", (chunk) => logs.push(chunk.toString()))).start();
+    } catch {
+      throw new Error(`Structurizr validation failed:
+${logs.join("")}`);
+    }
+  } finally {
+    await fs2.promises.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// libs/c4-model/src/exportWorkspaceJson.ts
+var fs3 = __toESM(require("fs"), 1);
+var os3 = __toESM(require("os"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_testcontainers3 = require("testcontainers");
+async function exportWorkspaceJsonFromDsl(dsl) {
+  const tmpDir = await fs3.promises.mkdtemp(path3.join(fs3.realpathSync(os3.tmpdir()), "c4-export-"));
+  try {
+    await fs3.promises.writeFile(path3.join(tmpDir, "workspace.dsl"), dsl, "utf8");
+    const logs = [];
+    try {
+      await new import_testcontainers3.GenericContainer("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["export", "-w", "/workspace/workspace.dsl", "-f", "json", "-o", "/workspace"]).withWaitStrategy(import_testcontainers3.Wait.forOneShotStartup()).withLogConsumer((stream) => stream.on("data", (chunk) => logs.push(chunk.toString()))).start();
+    } catch {
+      throw new Error(`Structurizr JSON export failed:
+${logs.join("")}`);
+    }
+    const files = await fs3.promises.readdir(tmpDir);
+    const jsonFile = files.find((f) => f.endsWith(".json"));
+    if (!jsonFile) {
+      throw new Error(`Structurizr JSON export produced no .json file. Files: ${files.join(", ")}`);
+    }
+    const jsonContent = await fs3.promises.readFile(path3.join(tmpDir, jsonFile), "utf8");
+    return JSON.parse(jsonContent);
+  } finally {
+    await fs3.promises.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function exportWorkspaceJson(model, views) {
+  const dsl = new StructurizrDSLWriter(model, views).write();
+  return exportWorkspaceJsonFromDsl(dsl);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Component,
@@ -957,7 +1252,9 @@ async function generateDiagrams(options) {
   View,
   Views,
   buildModel,
-  buildModelWithCatalog,
+  exportWorkspaceJson,
+  exportWorkspaceJsonFromDsl,
   generateDiagrams,
-  mergeArchetypeWithOverride
+  mergeArchetypeWithOverride,
+  validateModel
 });