@dr2rai/raid-canvas 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+RaidCanvas
+© Rainer Burkhardt. All rights reserved.

package/dist/RaiBridge.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file RaiBridge.ts
+ * @description Bidirectional synchronization bridge between the SVG `aim-*` ontological
+ * contract and AntV X6 Graph models.
+ *
+ * Capabilities:
+ * - Hydrate: Ingests an SVG containing `aim-*` semantic attributes and inflates an interactive
+ *   AntV X6 graph with orthogonal ports and Manhattan-routed edges.
+ * - Serialize: Extracts updated coordinates, node dimensions, and user-dragged bend points from
+ *   the X6 graph, serializing them back into the SVG document while preserving semantic fidelity.
+ */
+import { Graph } from '@antv/x6';
+import { type RaidMetamodel, type SvgBendPoint, type HydrationOptions, type SerializationOptions } from './types.js';
+export declare class RaiBridge {
+    /**
+     * Hydrates an AntV X6 graph from an SVG source string or DOM Element.
+     *
+     * @param svgSource Raw SVG markup string or SVGSVGElement DOM node.
+     * @param graph The AntV X6 Graph instance to populate.
+     * @param options Hydration options.
+     * @returns The extracted RaidMetamodel representation.
+     */
+    hydrateFromSvg(svgSource: string | Element, graph: Graph, options?: HydrationOptions): RaidMetamodel;
+    /**
+     * Serializes current X6 graph layout (positions, bounds, bend points) back into an SVG document.
+     *
+     * @param graph The AntV X6 Graph instance.
+     * @param baseSvg Optional base SVG string to update in-place.
+     * @param options Serialization options.
+     * @returns The updated SVG markup string adhering to the aim-* contract.
+     */
+    serializeToSvg(graph: Graph, baseSvg?: string, options?: SerializationOptions): string;
+    /**
+     * Extracts a pure RaidMetamodel from an active AntV X6 Graph.
+     */
+    metamodelFromGraph(graph: Graph): RaidMetamodel;
+    /**
+     * Parses semicolon-separated bend points: "100,50; 200,50; 200,150"
+     */
+    parseBendPoints(bendsStr: string): SvgBendPoint[];
+    /**
+     * Formats bend points into the canonical aim-bends format: "x1,y1; x2,y2"
+     */
+    formatBendPoints(points: readonly SvgBendPoint[]): string;
+    private resolveSvgElement;
+    private extractMetamodel;
+    private extractBounds;
+    private updateExistingSvg;
+    private generateFreshSvg;
+    private normalizeKind;
+    private normalizeEdgeKind;
+    private kindFromShape;
+}
+//# sourceMappingURL=RaiBridge.d.ts.map

package/dist/RaiBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RaiBridge.d.ts","sourceRoot":"","sources":["../src/RaiBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAGpB,qBAAa,SAAS;IACpB;;;;;;;OAOG;IACI,cAAc,CACnB,SAAS,EAAE,MAAM,GAAG,OAAO,EAC3B,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gBAAqB,GAC7B,aAAa,CAuBf;IAED;;;;;;;OAOG;IACI,cAAc,CACnB,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAQR;IAED;;OAEG;IACI,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,aAAa,CAuErD;IAED;;OAEG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAevD;IAED;;OAEG;IACI,gBAAgB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAE/D;IAMD,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,gBAAgB;IA8ExB,OAAO,CAAC,aAAa;IA8CrB,OAAO,CAAC,iBAAiB;IA0CzB,OAAO,CAAC,gBAAgB;IA8ExB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,aAAa;CAQtB"}

package/dist/RaiBridge.js

@@ -0,0 +1,408 @@
+/**
+ * @file RaiBridge.ts
+ * @description Bidirectional synchronization bridge between the SVG `aim-*` ontological
+ * contract and AntV X6 Graph models.
+ *
+ * Capabilities:
+ * - Hydrate: Ingests an SVG containing `aim-*` semantic attributes and inflates an interactive
+ *   AntV X6 graph with orthogonal ports and Manhattan-routed edges.
+ * - Serialize: Extracts updated coordinates, node dimensions, and user-dragged bend points from
+ *   the X6 graph, serializing them back into the SVG document while preserving semantic fidelity.
+ */
+import { AimSvgContract, } from './types.js';
+import { createAimNode, createAimEdge, configureAimGraph, CascaisPalette } from './X6Shapes.js';
+export class RaiBridge {
+    /**
+     * Hydrates an AntV X6 graph from an SVG source string or DOM Element.
+     *
+     * @param svgSource Raw SVG markup string or SVGSVGElement DOM node.
+     * @param graph The AntV X6 Graph instance to populate.
+     * @param options Hydration options.
+     * @returns The extracted RaidMetamodel representation.
+     */
+    hydrateFromSvg(svgSource, graph, options = {}) {
+        configureAimGraph(graph);
+        if (options.clearGraph !== false) {
+            graph.clearCells();
+        }
+        const doc = this.resolveSvgElement(svgSource);
+        const metamodel = this.extractMetamodel(doc, options);
+        // 1. Add all nodes to graph
+        for (const nodeData of metamodel.nodes) {
+            const nodeMeta = createAimNode(nodeData);
+            graph.addNode(nodeMeta);
+        }
+        // 2. Add all edges to graph
+        for (const edgeData of metamodel.edges) {
+            const edgeMeta = createAimEdge(edgeData);
+            graph.addEdge(edgeMeta);
+        }
+        return metamodel;
+    }
+    /**
+     * Serializes current X6 graph layout (positions, bounds, bend points) back into an SVG document.
+     *
+     * @param graph The AntV X6 Graph instance.
+     * @param baseSvg Optional base SVG string to update in-place.
+     * @param options Serialization options.
+     * @returns The updated SVG markup string adhering to the aim-* contract.
+     */
+    serializeToSvg(graph, baseSvg, options = {}) {
+        const metamodel = this.metamodelFromGraph(graph);
+        if (baseSvg) {
+            return this.updateExistingSvg(baseSvg, metamodel, options);
+        }
+        return this.generateFreshSvg(metamodel, options);
+    }
+    /**
+     * Extracts a pure RaidMetamodel from an active AntV X6 Graph.
+     */
+    metamodelFromGraph(graph) {
+        const nodes = [];
+        const edges = [];
+        // Extract nodes
+        const x6Nodes = graph.getNodes();
+        for (const node of x6Nodes) {
+            const pos = node.getPosition();
+            const size = node.getSize();
+            const customData = (node.getData() ?? {});
+            const id = node.id;
+            const kind = (customData.kind ?? this.kindFromShape(node.shape));
+            const displayName = customData.displayName ?? node.getAttrByPath('label/text') ?? id;
+            const nodeData = {
+                id,
+                kind,
+                displayName,
+                ...(customData.stereotype !== undefined ? { stereotype: customData.stereotype } : {}),
+                ...(customData.namespace !== undefined ? { namespace: customData.namespace } : {}),
+                ...(customData.attributes !== undefined ? { attributes: customData.attributes } : {}),
+                ...(customData.methods !== undefined ? { methods: customData.methods } : {}),
+                bounds: {
+                    x: pos.x,
+                    y: pos.y,
+                    width: size.width,
+                    height: size.height,
+                },
+                ...(customData.properties !== undefined ? { properties: customData.properties } : {}),
+            };
+            nodes.push(nodeData);
+        }
+        // Extract edges
+        const x6Edges = graph.getEdges();
+        for (const edge of x6Edges) {
+            const source = edge.getSourceCell();
+            const target = edge.getTargetCell();
+            if (!source || !target)
+                continue;
+            const vertices = edge.getVertices();
+            const bendPoints = vertices.map((v) => ({ x: v.x, y: v.y }));
+            const customData = (edge.getData() ?? {});
+            const sourcePort = edge.getSourcePortId();
+            const targetPort = edge.getTargetPortId();
+            const label = edge.getLabels()?.[0]?.attrs?.['text']?.['text'] ?? customData.label;
+            const edgeData = {
+                id: edge.id,
+                kind: customData.kind ?? 'association',
+                sourceId: source.id,
+                targetId: target.id,
+                ...(sourcePort !== undefined ? { sourcePort } : {}),
+                ...(targetPort !== undefined ? { targetPort } : {}),
+                ...(label !== undefined ? { label } : {}),
+                ...(customData.stereotype !== undefined ? { stereotype: customData.stereotype } : {}),
+                bendPoints,
+            };
+            edges.push(edgeData);
+        }
+        return {
+            diagramId: 'RaidDiagram',
+            archetype: 'InteractiveCanvas',
+            nodes,
+            edges,
+        };
+    }
+    /**
+     * Parses semicolon-separated bend points: "100,50; 200,50; 200,150"
+     */
+    parseBendPoints(bendsStr) {
+        if (!bendsStr || bendsStr.trim().length === 0) {
+            return [];
+        }
+        return bendsStr
+            .split(';')
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0)
+            .map((part) => {
+            const [xStr, yStr] = part.split(',');
+            const x = parseFloat(xStr?.trim() ?? '0');
+            const y = parseFloat(yStr?.trim() ?? '0');
+            return { x: Number.isNaN(x) ? 0 : x, y: Number.isNaN(y) ? 0 : y };
+        });
+    }
+    /**
+     * Formats bend points into the canonical aim-bends format: "x1,y1; x2,y2"
+     */
+    formatBendPoints(points) {
+        return points.map((p) => `${Math.round(p.x)},${Math.round(p.y)}`).join('; ');
+    }
+    // --------------------------------------------------------------------------
+    // Private Helper Implementation
+    // --------------------------------------------------------------------------
+    resolveSvgElement(source) {
+        if (typeof source !== 'string') {
+            return source;
+        }
+        if (typeof DOMParser !== 'undefined') {
+            const parser = new DOMParser();
+            const parsed = parser.parseFromString(source, 'image/svg+xml');
+            const root = parsed.documentElement;
+            if (root.tagName.toLowerCase() === 'parsererror') {
+                throw new Error('Failed to parse SVG: XML Parser Error');
+            }
+            return root;
+        }
+        throw new Error('DOMParser unavailable in current execution environment');
+    }
+    extractMetamodel(svgRoot, options) {
+        const nodes = [];
+        const edges = [];
+        // 1. Locate all node elements
+        const nodeElements = Array.from(svgRoot.querySelectorAll(AimSvgContract.SELECTOR_NODE));
+        for (const el of nodeElements) {
+            const id = el.getAttribute(AimSvgContract.ATTR_ID) ??
+                el.getAttribute('data-node') ??
+                el.getAttribute('data-element-id') ??
+                el.getAttribute('id');
+            if (!id)
+                continue;
+            const rawKind = el.getAttribute(AimSvgContract.ATTR_KIND) ?? 'act';
+            const kind = this.normalizeKind(rawKind);
+            const displayName = el.getAttribute(AimSvgContract.ATTR_DISPLAY_NAME) ??
+                el.querySelector('text')?.textContent?.trim() ??
+                id;
+            const stereotype = el.getAttribute(AimSvgContract.ATTR_STEREOTYPE) ?? undefined;
+            const bounds = this.extractBounds(el, options.defaultNodeSize);
+            nodes.push({
+                id,
+                kind,
+                displayName,
+                ...(stereotype !== undefined ? { stereotype } : {}),
+                bounds,
+            });
+        }
+        // 2. Locate all edge elements
+        const edgeElements = Array.from(svgRoot.querySelectorAll(AimSvgContract.SELECTOR_EDGE));
+        for (const el of edgeElements) {
+            const id = el.getAttribute(AimSvgContract.ATTR_ID) ?? el.getAttribute('id') ?? `edge-${edges.length + 1}`;
+            const sourceId = el.getAttribute(AimSvgContract.ATTR_SOURCE);
+            const targetId = el.getAttribute(AimSvgContract.ATTR_TARGET);
+            if (!sourceId || !targetId)
+                continue;
+            const rawEdgeKind = el.getAttribute(AimSvgContract.ATTR_EDGE_KIND) ?? 'association';
+            const kind = this.normalizeEdgeKind(rawEdgeKind);
+            const bendsAttr = el.getAttribute(AimSvgContract.ATTR_BENDS) ?? '';
+            const bendPoints = this.parseBendPoints(bendsAttr);
+            const sourcePort = el.getAttribute(AimSvgContract.ATTR_SOURCE_PORT) ?? undefined;
+            const targetPort = el.getAttribute(AimSvgContract.ATTR_TARGET_PORT) ?? undefined;
+            edges.push({
+                id,
+                kind,
+                sourceId,
+                targetId,
+                ...(sourcePort !== undefined ? { sourcePort } : {}),
+                ...(targetPort !== undefined ? { targetPort } : {}),
+                bendPoints,
+            });
+        }
+        return {
+            diagramId: svgRoot.getAttribute('id') ?? 'ImportedDiagram',
+            archetype: svgRoot.getAttribute('aim-archetype') ?? 'AOAIMDiagram',
+            nodes,
+            edges,
+        };
+    }
+    extractBounds(el, defaultSize = { width: 140, height: 60 }) {
+        let x = 0;
+        let y = 0;
+        let width = defaultSize.width;
+        let height = defaultSize.height;
+        // Check transform matrix or translate
+        const transform = el.getAttribute('transform');
+        if (transform) {
+            const match = /translate\(\s*([-\d.]+)[,\s]+([-\d.]+)\s*\)/.exec(transform);
+            if (match && match[1] && match[2]) {
+                x = parseFloat(match[1]);
+                y = parseFloat(match[2]);
+            }
+        }
+        // Check direct geometry attributes (rect, ellipse, circle)
+        const rect = el.querySelector('rect') ?? (el.tagName.toLowerCase() === 'rect' ? el : null);
+        if (rect) {
+            if (!transform && rect.getAttribute('x'))
+                x = parseFloat(rect.getAttribute('x'));
+            if (!transform && rect.getAttribute('y'))
+                y = parseFloat(rect.getAttribute('y'));
+            if (rect.getAttribute('width'))
+                width = parseFloat(rect.getAttribute('width'));
+            if (rect.getAttribute('height'))
+                height = parseFloat(rect.getAttribute('height'));
+        }
+        const ellipse = el.querySelector('ellipse') ?? (el.tagName.toLowerCase() === 'ellipse' ? el : null);
+        if (ellipse) {
+            const rx = parseFloat(ellipse.getAttribute('rx') ?? `${width / 2}`);
+            const ry = parseFloat(ellipse.getAttribute('ry') ?? `${height / 2}`);
+            width = rx * 2;
+            height = ry * 2;
+            if (!transform) {
+                const cx = parseFloat(ellipse.getAttribute('cx') ?? '0');
+                const cy = parseFloat(ellipse.getAttribute('cy') ?? '0');
+                x = cx - rx;
+                y = cy - ry;
+            }
+        }
+        return { x, y, width, height };
+    }
+    updateExistingSvg(baseSvg, model, _options) {
+        if (typeof DOMParser === 'undefined' || typeof XMLSerializer === 'undefined') {
+            return this.generateFreshSvg(model, _options);
+        }
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(baseSvg, 'image/svg+xml');
+        // Update node positions and transforms
+        for (const node of model.nodes) {
+            const el = doc.querySelector(`[${AimSvgContract.ATTR_ID}="${node.id}"], [id="${node.id}"]`);
+            if (el) {
+                el.setAttribute('transform', `translate(${node.bounds.x}, ${node.bounds.y})`);
+                el.setAttribute(AimSvgContract.ATTR_NODE, 'true');
+                el.setAttribute(AimSvgContract.ATTR_KIND, node.kind);
+                const rect = el.querySelector('rect');
+                if (rect) {
+                    rect.setAttribute('width', `${node.bounds.width}`);
+                    rect.setAttribute('height', `${node.bounds.height}`);
+                }
+            }
+        }
+        // Update edge bend points and aim-bends attributes
+        for (const edge of model.edges) {
+            const el = doc.querySelector(`[${AimSvgContract.ATTR_ID}="${edge.id}"], [id="${edge.id}"]`);
+            if (el) {
+                const bendsString = this.formatBendPoints(edge.bendPoints);
+                el.setAttribute(AimSvgContract.ATTR_BENDS, bendsString);
+                el.setAttribute(AimSvgContract.ATTR_EDGE, 'true');
+                el.setAttribute(AimSvgContract.ATTR_EDGE_KIND, edge.kind);
+            }
+        }
+        return new XMLSerializer().serializeToString(doc);
+    }
+    generateFreshSvg(model, options) {
+        const width = Math.max(800, ...model.nodes.map((n) => n.bounds.x + n.bounds.width + 100));
+        const height = Math.max(600, ...model.nodes.map((n) => n.bounds.y + n.bounds.height + 100));
+        let svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" id="${model.diagramId}" aim-archetype="${model.archetype}">\n`;
+        // Definitions & Markers
+        svg += `  <defs>\n`;
+        svg += `    <marker id="arrow-classic" viewBox="0 0 10 10" refX="10" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse">\n`;
+        svg += `      <path d="M 0 0 L 10 5 L 0 10 z" fill="${CascaisPalette.WarmGraphite}" />\n`;
+        svg += `    </marker>\n`;
+        svg += `    <marker id="arrow-hollow" viewBox="0 0 12 12" refX="12" refY="6" markerWidth="9" markerHeight="9" orient="auto-start-reverse">\n`;
+        svg += `      <polygon points="0 0, 12 6, 0 12" fill="${CascaisPalette.ChalkWhite}" stroke="${CascaisPalette.WarmGraphite}" stroke-width="1.5" />\n`;
+        svg += `    </marker>\n`;
+        if (options.embedStyles !== false) {
+            svg += `    <style>\n`;
+            svg += `      .aim-node { cursor: pointer; transition: filter 0.15s ease; }\n`;
+            svg += `      .aim-node:hover { filter: drop-shadow(0 4px 6px rgba(0,0,0,0.1)); }\n`;
+            svg += `      .aim-edge { fill: none; stroke: ${CascaisPalette.WarmGraphite}; stroke-width: 1.5; }\n`;
+            svg += `      text { font-family: Inter, system-ui, sans-serif; }\n`;
+            svg += `    </style>\n`;
+        }
+        svg += `  </defs>\n\n`;
+        // Render Edges
+        svg += `  <!-- Edges -->\n`;
+        svg += `  <g class="aim-edges-layer">\n`;
+        for (const edge of model.edges) {
+            const bendsFormatted = this.formatBendPoints(edge.bendPoints);
+            const strokeDash = edge.kind === 'dependency' ? ' stroke-dasharray="5,5"' : '';
+            const markerEnd = edge.kind === 'generalization' ? ' marker-end="url(#arrow-hollow)"' : ' marker-end="url(#arrow-classic)"';
+            // Path data construction
+            let pathD = '';
+            if (edge.bendPoints.length > 0) {
+                const first = edge.bendPoints[0];
+                pathD = `M ${first.x} ${first.y} ` + edge.bendPoints.slice(1).map((p) => `L ${p.x} ${p.y}`).join(' ');
+            }
+            svg += `    <g ${AimSvgContract.ATTR_EDGE}="true" ${AimSvgContract.ATTR_ID}="${edge.id}" ${AimSvgContract.ATTR_EDGE_KIND}="${edge.kind}" ${AimSvgContract.ATTR_SOURCE}="${edge.sourceId}" ${AimSvgContract.ATTR_TARGET}="${edge.targetId}" ${AimSvgContract.ATTR_BENDS}="${bendsFormatted}">\n`;
+            if (pathD) {
+                svg += `      <path d="${pathD}" class="aim-edge"${strokeDash}${markerEnd} />\n`;
+            }
+            if (edge.label) {
+                const midPoint = edge.bendPoints[Math.floor(edge.bendPoints.length / 2)] ?? { x: 50, y: 50 };
+                svg += `      <text x="${midPoint.x}" y="${midPoint.y - 8}" font-size="11" fill="${CascaisPalette.TextSecondary}" text-anchor="middle">${edge.label}</text>\n`;
+            }
+            svg += `    </g>\n`;
+        }
+        svg += `  </g>\n\n`;
+        // Render Nodes
+        svg += `  <!-- Nodes -->\n`;
+        svg += `  <g class="aim-nodes-layer">\n`;
+        for (const node of model.nodes) {
+            svg += `    <g ${AimSvgContract.ATTR_NODE}="true" ${AimSvgContract.ATTR_ID}="${node.id}" ${AimSvgContract.ATTR_KIND}="${node.kind}" ${AimSvgContract.ATTR_DISPLAY_NAME}="${node.displayName}" transform="translate(${node.bounds.x}, ${node.bounds.y})">\n`;
+            if (node.kind === 'uc') {
+                const rx = node.bounds.width / 2;
+                const ry = node.bounds.height / 2;
+                svg += `      <ellipse cx="${rx}" cy="${ry}" rx="${rx}" ry="${ry}" fill="${CascaisPalette.ChalkWhite}" stroke="${CascaisPalette.NetGold}" stroke-width="2" />\n`;
+                svg += `      <text x="${rx}" y="${ry}" font-size="13" font-weight="bold" fill="${CascaisPalette.TextPrimary}" text-anchor="middle" dominant-baseline="central">${node.displayName}</text>\n`;
+            }
+            else if (node.kind === 'act') {
+                svg += `      <rect width="${node.bounds.width}" height="${node.bounds.height}" rx="12" ry="12" fill="${CascaisPalette.CanvasCream}" stroke="${CascaisPalette.HeraldicGreen}" stroke-width="2" />\n`;
+                svg += `      <text x="${node.bounds.width / 2}" y="${node.bounds.height / 2}" font-size="13" font-weight="600" fill="${CascaisPalette.TextPrimary}" text-anchor="middle" dominant-baseline="central">${node.displayName}</text>\n`;
+            }
+            else {
+                svg += `      <rect width="${node.bounds.width}" height="${node.bounds.height}" fill="${CascaisPalette.ChalkWhite}" stroke="${CascaisPalette.WarmGraphite}" stroke-width="1.5" />\n`;
+                svg += `      <text x="${node.bounds.width / 2}" y="${node.bounds.height / 2}" font-size="12" fill="${CascaisPalette.TextPrimary}" text-anchor="middle" dominant-baseline="central">${node.displayName}</text>\n`;
+            }
+            svg += `    </g>\n`;
+        }
+        svg += `  </g>\n`;
+        svg += `</svg>\n`;
+        return svg;
+    }
+    normalizeKind(kind) {
+        const lower = kind.toLowerCase();
+        if (lower === 'uc' || lower === 'usecase')
+            return 'uc';
+        if (lower === 'act' || lower === 'activity')
+            return 'act';
+        if (lower === 'cls' || lower === 'class')
+            return 'cls';
+        if (lower === 'obj' || lower === 'object')
+            return 'obj';
+        if (lower === 'per' || lower === 'person' || lower === 'actor')
+            return 'per';
+        return 'act';
+    }
+    normalizeEdgeKind(kind) {
+        const lower = kind.toLowerCase();
+        if (lower.includes('depend'))
+            return 'dependency';
+        if (lower.includes('general') || lower.includes('inher'))
+            return 'generalization';
+        if (lower.includes('realiz'))
+            return 'realization';
+        if (lower.includes('aggreg'))
+            return 'aggregation';
+        if (lower.includes('compos'))
+            return 'composition';
+        return 'association';
+    }
+    kindFromShape(shape) {
+        if (shape.includes('uc'))
+            return 'uc';
+        if (shape.includes('act'))
+            return 'act';
+        if (shape.includes('cls'))
+            return 'cls';
+        if (shape.includes('obj'))
+            return 'obj';
+        if (shape.includes('per'))
+            return 'per';
+        return 'act';
+    }
+}
+//# sourceMappingURL=RaiBridge.js.map