@cda/adapter-xma 0.1.0

package/README.md

@@ -0,0 +1,192 @@
+# @cda/adapter-xma
+
+An XMA output adapter for the [Continuous-Driven Architecture (CDA)](https://github.com/Continuous-DrivenArchitecture) ecosystem.
+
+`@cda/adapter-xma` converts the typed `ArchiModel` produced by
+[`@cda/archi-semantic-core`](https://github.com/Continuous-DrivenArchitecture/archi-semantic-core)
+into an XMA document, preserving both **semantics** (elements, relationships,
+names, documentation) and **presentation intent** (views, node geometry,
+default visual styling, graphical relationships, bendpoints, Notes, Groups).
+
+```
+.archimate
+    │
+    ▼
+@cda/archi-semantic-core   (parseArchiModel)
+    │
+    ▼
+ArchiModel
+    │
+    ▼
+@cda/adapter-xma           (serializeXma)
+    │
+    ▼
+.xma
+```
+
+This package is a **pure output-format adapter**. It does not re-parse
+`.archimate` XML, does not duplicate `archi-semantic-core`'s parsing logic,
+and does not use the ArchiMate Open Exchange format as an intermediate
+representation (doing so would lose native presentation fidelity). It
+consumes `archi-semantic-core`'s public `ArchiModel` contract only.
+
+The runtime is dependency-light and avoids Node-only APIs (`fs`, `path`,
+`process`), so it can run in a browser — e.g. a future client-side CDA
+converter.
+
+## Installation
+
+```
+npm install @cda/archi-semantic-core @cda/adapter-xma
+```
+
+## Usage
+
+```ts
+import { parseArchiModel } from '@cda/archi-semantic-core';
+import { serializeXma } from '@cda/adapter-xma';
+
+const model = parseArchiModel(archimateXml);
+
+const xma = serializeXma(model, {
+  language: 'en',
+});
+```
+
+`serializeXma` is **strict by default**: if the model contains a construct
+that would cause semantic or presentation loss (an unmapped element type, an
+unconfirmed relationship, more than one view, incomplete geometry, ...) it
+throws `XmaSerializationError` carrying a structured diagnostic for every
+problem found, rather than silently dropping content or fabricating an
+approximate result.
+
+To preview what is and isn't supported without throwing:
+
+```ts
+import { inspectXmaSupport } from '@cda/adapter-xma';
+
+const diagnostics = inspectXmaSupport(model);
+for (const d of diagnostics) {
+  console.log(`[${d.severity}] ${d.code}: ${d.message}`);
+}
+```
+
+### Options
+
+```ts
+interface XmaSerializeOptions {
+  /** Applied to every xml:lang and the default MM_Language. Default: 'en'. Never inferred from element names. */
+  language?: string;
+  /** The root MM_ModelPackage's display name. Default: a neutral placeholder — no machine/user identity is ever fabricated. */
+  packageName?: string;
+  /** The model's display name. Default: `model.metadata.name`. */
+  modelName?: string;
+}
+```
+
+## Support matrix
+
+This is **initial, evidence-backed XMA serialization support** — not a
+complete, universal XMA converter. Everything below was confirmed against
+two reference `.archimate`/`.xma` fixture pairs (see
+[`tests/fixtures/README.md`](tests/fixtures/README.md)); nothing here is
+extrapolated beyond that evidence.
+
+### Supported
+
+- All 60 confirmed ArchiMate element type mappings (Strategy, Business,
+  Application, Technology, Physical, Motivation, Implementation & Migration,
+  Composite), with confirmed scheme/collection placement and default icon
+  decoration presence.
+- Element and view names, and documentation (as RTF profile values).
+- A single ArchiMate view per model: node geometry (exact ×3 scale),
+  default per-category fill colors, line color, opacity, and font.
+- Notes and Groups (as `ArchiMate:ViewGraphic`), including Group
+  documentation.
+- Three confirmed semantic relationship mappings and their graphical
+  representation:
+  - `AssignmentRelationship` `BusinessActor` → `BusinessProcess`
+  - `ServingRelationship` `ApplicationService` → `BusinessProcess` (XMA
+    calls this `...Use`, not `...Serving`)
+  - `FlowRelationship` `BusinessProcess` → `BusinessProcess`
+- Manually routed connection bendpoints (source/target-relative offsets,
+  cross-checked against each other).
+- A configurable output language, applied consistently — never inferred
+  from element names.
+- Direct, lossless mapping of explicit Archi `fillColor`/`lineColor`
+  (hex → RGB) and `fontName` overrides, where the source field maps onto
+  the exact same structural XMA slot.
+
+### Not yet guaranteed
+
+- Relationship type/source/target combinations beyond the three confirmed
+  above (reported as a diagnostic, not silently dropped or guessed).
+- More than one view per model (reported as a diagnostic).
+- Nested diagram objects, `DiagramModelReference` ("insert view as
+  reference"), and purely visual (non-semantic) connections.
+- Junctions, profiles/specializations, and arbitrary model properties.
+- Explicit font size, bold/italic, line width, font color, or connector
+  line color overrides (reported as diagnostics; the confirmed defaults are
+  used instead).
+- Manual connector anchor metadata (`mm_fromx`/`mm_fromy`/`mm_tox`/`mm_toy`)
+  — only one fixture exhibited these attributes, not enough evidence to
+  derive a general formula or confirm they're required for import. They are
+  deliberately omitted rather than guessed; see
+  `src/serializer/graphical-writer.ts`.
+
+## Architecture
+
+```
+src/
+  index.ts                    public API
+
+  serializer/                 XmlElement tree construction
+    serialize-xma.ts            orchestrator: plan -> diagnostics/throw -> render
+    document-writer.ts          MM_Document skeleton, scheme/folder nesting
+    semantic-writer.ts          per-scheme element collections
+    relationship-writer.ts      semantic relationship elements
+    view-writer.ts              AllView: ViewGraphics + RefObjects, validation
+    graphical-writer.ts         Canvas / MM_Node / MM_DirectedRel
+    profile-values.ts           MM_ProfileValues (nm/doc) builder
+    rtf.ts                      dependency-free RTF escaping
+
+  mapping/                    immutable mapping DATA (never switch statements)
+    element-mapping.ts           60 confirmed Archi type -> XMA type/scheme/collection
+    relationship-mapping.ts      3 confirmed (type, source, target) -> XMA relationship
+    scheme-mapping.ts            scheme container / folder-nesting metadata
+    visual-mapping.ts            default fill/line colors, font, opacity
+
+  geometry/
+    geometry.ts                  the ×3 scale rule
+    bendpoints.ts                bendpoint offset -> absolute point resolution
+
+  infrastructure/
+    id-allocator.ts              deterministic numeric XMA id allocation
+    xml-writer.ts                typed XmlElement tree -> deterministic XML string
+
+  diagnostics/
+    diagnostics.ts               XmaDiagnostic, DiagnosticCollector
+    errors.ts                    XmaSerializationError
+```
+
+Every generated XMA id is a deterministic, strictly-increasing integer
+driven by traversal order over the (order-preserving) `ArchiModel` — never
+`Math.random()`, `Date.now()`, or a UUID. Archi's own string ids are never
+reused as XMA ids.
+
+Output is fully deterministic: the same `ArchiModel` and options always
+produce byte-identical XML (no timestamps, host names, or environment
+values are ever embedded).
+
+## Development
+
+```
+npm install
+npm run typecheck
+npm run build
+npm test
+```
+
+## License
+
+MIT

package/dist/diagnostics/diagnostics.d.ts

@@ -0,0 +1,20 @@
+export type XmaDiagnosticSeverity = 'error' | 'warning';
+export interface XmaDiagnostic {
+    /** Stable machine-readable code, e.g. "unsupported-element-type". */
+    code: string;
+    severity: XmaDiagnosticSeverity;
+    message: string;
+    /** Id of the offending source entity (Archi element/relationship/view/diagram id), when applicable. */
+    entityId?: string;
+    /** Kind of the offending source entity, e.g. "ArchiElement", "ArchiRelationship". */
+    entityType?: string;
+}
+/** Accumulates diagnostics during a single serialization pass. */
+export declare class DiagnosticCollector {
+    private readonly items;
+    error(diagnostic: Omit<XmaDiagnostic, 'severity'>): void;
+    warning(diagnostic: Omit<XmaDiagnostic, 'severity'>): void;
+    get all(): XmaDiagnostic[];
+    get hasErrors(): boolean;
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics/diagnostics.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,SAAS,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,qBAAqB,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,kEAAkE;AAClE,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAE7C,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,GAAG,IAAI;IAIxD,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,GAAG,IAAI;IAI1D,IAAI,GAAG,IAAI,aAAa,EAAE,CAEzB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}

package/dist/diagnostics/diagnostics.js

@@ -0,0 +1,19 @@
+/** Accumulates diagnostics during a single serialization pass. */
+export class DiagnosticCollector {
+    constructor() {
+        this.items = [];
+    }
+    error(diagnostic) {
+        this.items.push({ ...diagnostic, severity: 'error' });
+    }
+    warning(diagnostic) {
+        this.items.push({ ...diagnostic, severity: 'warning' });
+    }
+    get all() {
+        return [...this.items];
+    }
+    get hasErrors() {
+        return this.items.some((d) => d.severity === 'error');
+    }
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../../src/diagnostics/diagnostics.ts"],"names":[],"mappings":"AAaA,kEAAkE;AAClE,MAAM,OAAO,mBAAmB;IAAhC;QACmB,UAAK,GAAoB,EAAE,CAAC;IAiB/C,CAAC;IAfC,KAAK,CAAC,UAA2C;QAC/C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,OAAO,CAAC,UAA2C;QACjD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,GAAG;QACL,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC;IACxD,CAAC;CACF"}

package/dist/diagnostics/errors.d.ts

@@ -0,0 +1,13 @@
+import type { XmaDiagnostic } from './diagnostics.js';
+/**
+ * Thrown by `serializeXma` whenever serializing would silently lose
+ * semantics or presentation intent. Carries the full structured diagnostic
+ * list (not just the first failure) so callers can report everything wrong
+ * in one pass — see `inspectXmaSupport` to obtain the same list without
+ * throwing.
+ */
+export declare class XmaSerializationError extends Error {
+    readonly diagnostics: XmaDiagnostic[];
+    constructor(diagnostics: XmaDiagnostic[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/diagnostics/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/diagnostics/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,WAAW,EAAE,aAAa,EAAE,CAAC;gBAE1B,WAAW,EAAE,aAAa,EAAE;CAYzC"}

package/dist/diagnostics/errors.js

@@ -0,0 +1,20 @@
+/**
+ * Thrown by `serializeXma` whenever serializing would silently lose
+ * semantics or presentation intent. Carries the full structured diagnostic
+ * list (not just the first failure) so callers can report everything wrong
+ * in one pass — see `inspectXmaSupport` to obtain the same list without
+ * throwing.
+ */
+export class XmaSerializationError extends Error {
+    constructor(diagnostics) {
+        const errorCount = diagnostics.filter((d) => d.severity === 'error').length;
+        super(`XMA serialization failed: ${errorCount} unsupported construct(s) would cause semantic or presentation loss. ` +
+            diagnostics
+                .filter((d) => d.severity === 'error')
+                .map((d) => `[${d.code}] ${d.message}`)
+                .join('; '));
+        this.name = 'XmaSerializationError';
+        this.diagnostics = diagnostics;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/diagnostics/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/diagnostics/errors.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAG9C,YAAY,WAA4B;QACtC,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,MAAM,CAAC;QAC5E,KAAK,CACH,6BAA6B,UAAU,uEAAuE;YAC5G,WAAW;iBACR,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC;iBACrC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;iBACtC,IAAI,CAAC,IAAI,CAAC,CAChB,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;CACF"}

package/dist/geometry/bendpoints.d.ts

@@ -0,0 +1,33 @@
+import type { Point, Rect } from './geometry.js';
+export type BendpointAgreement = 'both' | 'source-only' | 'target-only';
+export interface BendpointResolution {
+    /** Resolved absolute point, in Archi (pre-scale) coordinate space. */
+    point: Point;
+    agreement: BendpointAgreement;
+    /** Present only when both source- and target-relative forms were available but disagreed materially. */
+    mismatch?: {
+        fromSource: Point;
+        fromTarget: Point;
+    };
+}
+/**
+ * Resolves a single Archi bendpoint (stored as offsets from the source and
+ * target diagram-object centers) to an absolute point in Archi coordinate
+ * space.
+ *
+ * Confirmed fixture: source bounds x=48,y=180,w=120,h=55 (center 108,207),
+ * target bounds x=204,y=276,w=120,h=55 (center 264,303), bendpoint
+ * startX=-12,startY=93,endX=-168,endY=-3 resolves to absolute (96, 300) via
+ * either offset.
+ *
+ * When both offsets are present, they are cross-checked against each other;
+ * a material disagreement is reported via `mismatch` rather than silently
+ * resolved, so the caller can surface a diagnostic instead of guessing.
+ */
+export declare function resolveBendpoint(bendpoint: {
+    startX: number | null;
+    startY: number | null;
+    endX: number | null;
+    endY: number | null;
+}, sourceBounds: Rect, targetBounds: Rect): BendpointResolution | null;
+//# sourceMappingURL=bendpoints.d.ts.map

package/dist/geometry/bendpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bendpoints.d.ts","sourceRoot":"","sources":["../../src/geometry/bendpoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKjD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,aAAa,GAAG,aAAa,CAAC;AAExE,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,kBAAkB,CAAC;IAC9B,wGAAwG;IACxG,QAAQ,CAAC,EAAE;QACT,UAAU,EAAE,KAAK,CAAC;QAClB,UAAU,EAAE,KAAK,CAAC;KACnB,CAAC;CACH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACrG,YAAY,EAAE,IAAI,EAClB,YAAY,EAAE,IAAI,GACjB,mBAAmB,GAAG,IAAI,CAgC5B"}

package/dist/geometry/bendpoints.js

@@ -0,0 +1,44 @@
+import { centerOf } from './geometry.js';
+const AGREEMENT_EPSILON = 0.01;
+/**
+ * Resolves a single Archi bendpoint (stored as offsets from the source and
+ * target diagram-object centers) to an absolute point in Archi coordinate
+ * space.
+ *
+ * Confirmed fixture: source bounds x=48,y=180,w=120,h=55 (center 108,207),
+ * target bounds x=204,y=276,w=120,h=55 (center 264,303), bendpoint
+ * startX=-12,startY=93,endX=-168,endY=-3 resolves to absolute (96, 300) via
+ * either offset.
+ *
+ * When both offsets are present, they are cross-checked against each other;
+ * a material disagreement is reported via `mismatch` rather than silently
+ * resolved, so the caller can surface a diagnostic instead of guessing.
+ */
+export function resolveBendpoint(bendpoint, sourceBounds, targetBounds) {
+    const hasSourceOffset = bendpoint.startX !== null && bendpoint.startY !== null;
+    const hasTargetOffset = bendpoint.endX !== null && bendpoint.endY !== null;
+    if (!hasSourceOffset && !hasTargetOffset) {
+        return null;
+    }
+    const sourceCenter = centerOf(sourceBounds);
+    const targetCenter = centerOf(targetBounds);
+    const fromSource = hasSourceOffset
+        ? { x: sourceCenter.x + bendpoint.startX, y: sourceCenter.y + bendpoint.startY }
+        : null;
+    const fromTarget = hasTargetOffset
+        ? { x: targetCenter.x + bendpoint.endX, y: targetCenter.y + bendpoint.endY }
+        : null;
+    if (fromSource && fromTarget) {
+        const deltaX = Math.abs(fromSource.x - fromTarget.x);
+        const deltaY = Math.abs(fromSource.y - fromTarget.y);
+        if (deltaX > AGREEMENT_EPSILON || deltaY > AGREEMENT_EPSILON) {
+            return { point: fromSource, agreement: 'both', mismatch: { fromSource, fromTarget } };
+        }
+        return { point: fromSource, agreement: 'both' };
+    }
+    if (fromSource) {
+        return { point: fromSource, agreement: 'source-only' };
+    }
+    return { point: fromTarget, agreement: 'target-only' };
+}
+//# sourceMappingURL=bendpoints.js.map

package/dist/geometry/bendpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bendpoints.js","sourceRoot":"","sources":["../../src/geometry/bendpoints.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAe/B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAqG,EACrG,YAAkB,EAClB,YAAkB;IAElB,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC;IAC/E,MAAM,eAAe,GAAG,SAAS,CAAC,IAAI,KAAK,IAAI,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC;IAE3E,IAAI,CAAC,eAAe,IAAI,CAAC,eAAe,EAAE,CAAC;QACzC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC5C,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAE5C,MAAM,UAAU,GAAiB,eAAe;QAC9C,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,GAAI,SAAS,CAAC,MAAiB,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,GAAI,SAAS,CAAC,MAAiB,EAAE;QACxG,CAAC,CAAC,IAAI,CAAC;IACT,MAAM,UAAU,GAAiB,eAAe;QAC9C,CAAC,CAAC,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,GAAI,SAAS,CAAC,IAAe,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC,GAAI,SAAS,CAAC,IAAe,EAAE;QACpG,CAAC,CAAC,IAAI,CAAC;IAET,IAAI,UAAU,IAAI,UAAU,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QACrD,IAAI,MAAM,GAAG,iBAAiB,IAAI,MAAM,GAAG,iBAAiB,EAAE,CAAC;YAC7D,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC;QACxF,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAClD,CAAC;IAED,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC;IACzD,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,UAAmB,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC;AAClE,CAAC"}

package/dist/geometry/geometry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Confirmed across all catalogue shapes and the relationship fixture: XMA
+ * geometry is Archi geometry uniformly scaled by 3 (x, y, width, height,
+ * and bendpoint coordinates alike).
+ */
+export declare const XMA_SCALE = 3;
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function scaleValue(archiValue: number): number;
+export declare function scaleRect(bounds: Rect): Rect;
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare function scalePoint(point: Point): Point;
+/**
+ * Rect center, floored to a whole pixel — confirmed against the proven
+ * bendpoint fixture: a 55px-tall shape's center is Archi's own `180 + 55/2`
+ * truncated to `207`, not `207.5`. Using the exact fraction here would
+ * throw off every bendpoint resolved against an odd-height/width shape.
+ */
+export declare function centerOf(bounds: Rect): Point;
+interface NullableBounds {
+    x: number | null;
+    y: number | null;
+    width: number | null;
+    height: number | null;
+}
+/** Type guard: true when every bounds field is set, narrowing to a usable `Rect`. */
+export declare function hasCompleteBounds(bounds: NullableBounds | null): bounds is Rect;
+export {};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/geometry/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/geometry/geometry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CAO5C;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,IAAI,GAAG,KAAK,CAK5C;AAED,UAAU,cAAc;IACtB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,GAAG,MAAM,IAAI,IAAI,CAQ/E"}

package/dist/geometry/geometry.js

@@ -0,0 +1,41 @@
+/**
+ * Confirmed across all catalogue shapes and the relationship fixture: XMA
+ * geometry is Archi geometry uniformly scaled by 3 (x, y, width, height,
+ * and bendpoint coordinates alike).
+ */
+export const XMA_SCALE = 3;
+export function scaleValue(archiValue) {
+    return archiValue * XMA_SCALE;
+}
+export function scaleRect(bounds) {
+    return {
+        x: scaleValue(bounds.x),
+        y: scaleValue(bounds.y),
+        width: scaleValue(bounds.width),
+        height: scaleValue(bounds.height),
+    };
+}
+export function scalePoint(point) {
+    return { x: scaleValue(point.x), y: scaleValue(point.y) };
+}
+/**
+ * Rect center, floored to a whole pixel — confirmed against the proven
+ * bendpoint fixture: a 55px-tall shape's center is Archi's own `180 + 55/2`
+ * truncated to `207`, not `207.5`. Using the exact fraction here would
+ * throw off every bendpoint resolved against an odd-height/width shape.
+ */
+export function centerOf(bounds) {
+    return {
+        x: Math.floor(bounds.x + bounds.width / 2),
+        y: Math.floor(bounds.y + bounds.height / 2),
+    };
+}
+/** Type guard: true when every bounds field is set, narrowing to a usable `Rect`. */
+export function hasCompleteBounds(bounds) {
+    return (bounds !== null &&
+        bounds.x !== null &&
+        bounds.y !== null &&
+        bounds.width !== null &&
+        bounds.height !== null);
+}
+//# sourceMappingURL=geometry.js.map

package/dist/geometry/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../src/geometry/geometry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC;AAS3B,MAAM,UAAU,UAAU,CAAC,UAAkB;IAC3C,OAAO,UAAU,GAAG,SAAS,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,MAAY;IACpC,OAAO;QACL,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QACvB,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QACvB,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC;QAC/B,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;KAClC,CAAC;AACJ,CAAC;AAOD,MAAM,UAAU,UAAU,CAAC,KAAY;IACrC,OAAO,EAAE,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAY;IACnC,OAAO;QACL,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;QAC1C,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;KAC5C,CAAC;AACJ,CAAC;AASD,qFAAqF;AACrF,MAAM,UAAU,iBAAiB,CAAC,MAA6B;IAC7D,OAAO,CACL,MAAM,KAAK,IAAI;QACf,MAAM,CAAC,CAAC,KAAK,IAAI;QACjB,MAAM,CAAC,CAAC,KAAK,IAAI;QACjB,MAAM,CAAC,KAAK,KAAK,IAAI;QACrB,MAAM,CAAC,MAAM,KAAK,IAAI,CACvB,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { serializeXma, inspectXmaSupport } from './serializer/serialize-xma.js';
+export type { XmaSerializeOptions } from './serializer/serialize-xma.js';
+export { XmaSerializationError } from './diagnostics/errors.js';
+export type { XmaDiagnostic, XmaDiagnosticSeverity } from './diagnostics/diagnostics.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAChF,YAAY,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { serializeXma, inspectXmaSupport } from './serializer/serialize-xma.js';
+export { XmaSerializationError } from './diagnostics/errors.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEhF,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/infrastructure/id-allocator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Deterministic numeric XMA id allocator.
+ *
+ * XMA reference documents use small sequential integer ids. We do not (and
+ * cannot) reproduce Archi's string ids — instead we hand out ids in strictly
+ * increasing order, starting from 1, driven entirely by serializer traversal
+ * order. As long as the traversal order over a given `ArchiModel` is stable
+ * (it is: every `ArchiModel` collection preserves source document order),
+ * the same input always yields the same ids.
+ *
+ * Never uses Math.random(), Date.now(), or any other non-deterministic or
+ * environment-specific source.
+ */
+export declare class XmaIdAllocator {
+    private counter;
+    next(): number;
+}
+/**
+ * A registry mapping arbitrary string keys (Archi ids, or synthetic
+ * composite keys) to allocated XMA numeric ids, with reference-consistent
+ * reuse: asking for the same key twice returns the same id.
+ */
+export declare class XmaIdRegistry {
+    private readonly allocator;
+    private readonly ids;
+    constructor(allocator: XmaIdAllocator);
+    /** Allocates (or returns the previously allocated) id for `key`. */
+    idFor(key: string): number;
+    /** Allocates a fresh id not tied to any lookup key (e.g. structural scaffolding elements). */
+    fresh(): number;
+    has(key: string): boolean;
+    get(key: string): number | undefined;
+}
+//# sourceMappingURL=id-allocator.d.ts.map

package/dist/infrastructure/id-allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-allocator.d.ts","sourceRoot":"","sources":["../../src/infrastructure/id-allocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAK;IAEpB,IAAI,IAAI,MAAM;CAIf;AAED;;;;GAIG;AACH,qBAAa,aAAa;IAGZ,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;gBAEpB,SAAS,EAAE,cAAc;IAEtD,oEAAoE;IACpE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAU1B,8FAA8F;IAC9F,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAGrC"}

package/dist/infrastructure/id-allocator.js

@@ -0,0 +1,54 @@
+/**
+ * Deterministic numeric XMA id allocator.
+ *
+ * XMA reference documents use small sequential integer ids. We do not (and
+ * cannot) reproduce Archi's string ids — instead we hand out ids in strictly
+ * increasing order, starting from 1, driven entirely by serializer traversal
+ * order. As long as the traversal order over a given `ArchiModel` is stable
+ * (it is: every `ArchiModel` collection preserves source document order),
+ * the same input always yields the same ids.
+ *
+ * Never uses Math.random(), Date.now(), or any other non-deterministic or
+ * environment-specific source.
+ */
+export class XmaIdAllocator {
+    constructor() {
+        this.counter = 0;
+    }
+    next() {
+        this.counter += 1;
+        return this.counter;
+    }
+}
+/**
+ * A registry mapping arbitrary string keys (Archi ids, or synthetic
+ * composite keys) to allocated XMA numeric ids, with reference-consistent
+ * reuse: asking for the same key twice returns the same id.
+ */
+export class XmaIdRegistry {
+    constructor(allocator) {
+        this.allocator = allocator;
+        this.ids = new Map();
+    }
+    /** Allocates (or returns the previously allocated) id for `key`. */
+    idFor(key) {
+        const existing = this.ids.get(key);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const id = this.allocator.next();
+        this.ids.set(key, id);
+        return id;
+    }
+    /** Allocates a fresh id not tied to any lookup key (e.g. structural scaffolding elements). */
+    fresh() {
+        return this.allocator.next();
+    }
+    has(key) {
+        return this.ids.has(key);
+    }
+    get(key) {
+        return this.ids.get(key);
+    }
+}
+//# sourceMappingURL=id-allocator.js.map

package/dist/infrastructure/id-allocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-allocator.js","sourceRoot":"","sources":["../../src/infrastructure/id-allocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,cAAc;IAA3B;QACU,YAAO,GAAG,CAAC,CAAC;IAMtB,CAAC;IAJC,IAAI;QACF,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,aAAa;IAGxB,YAA6B,SAAyB;QAAzB,cAAS,GAAT,SAAS,CAAgB;QAFrC,QAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEQ,CAAC;IAE1D,oEAAoE;IACpE,KAAK,CAAC,GAAW;QACf,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,8FAA8F;IAC9F,KAAK;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC/B,CAAC;IAED,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,GAAG,CAAC,GAAW;QACb,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;CACF"}

package/dist/infrastructure/xml-writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Minimal typed XML element tree + deterministic serializer.
+ *
+ * Business logic builds `XmlElement` trees (attribute order and child order
+ * are explicit arrays, controlled entirely by the caller) and this module
+ * turns them into text. No implicit ordering, no host/timestamp-dependent
+ * output, no third-party XML dependency — keeps the runtime browser-safe.
+ */
+export interface XmlElement {
+    tag: string;
+    attrs?: Array<[string, string]>;
+    children?: XmlElement[];
+    /** Leaf text content. Mutually exclusive with `children` in practice. */
+    text?: string;
+}
+export declare function element(tag: string, attrs?: Array<[string, string]>, children?: XmlElement[]): XmlElement;
+export declare function textElement(tag: string, text: string, attrs?: Array<[string, string]>): XmlElement;
+/** Renders a root element to a complete, deterministic XML document string. */
+export declare function renderXmlDocument(root: XmlElement): string;
+//# sourceMappingURL=xml-writer.d.ts.map

package/dist/infrastructure/xml-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-writer.d.ts","sourceRoot":"","sources":["../../src/infrastructure/xml-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAC;IACxB,yEAAyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,OAAO,CACrB,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC/B,QAAQ,CAAC,EAAE,UAAU,EAAE,GACtB,UAAU,CAEZ;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,UAAU,CAElG;AAsCD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAI1D"}