@dialecte/scl 0.5.0 → 0.7.0

package/dist/v2019C1/test/assert-coherent-scl-references.d.ts

@@ -0,0 +1,19 @@
+import { AssertCoherentSclReferencesParams, AssertCoherentSclReferencesTestCasesParams, CollectReferenceViolationsParams, ReferenceViolation } from './assert-coherent-scl-references.types';
+/**
+ * Every reference of a test XML document that a real file could not contain: a uuid that
+ * points at nothing, or at an element the reference cannot target, or a written path that
+ * is not the path of the element the uuid points at.
+ */
+export declare function collectReferenceViolations(params: CollectReferenceViolationsParams): ReferenceViolation[];
+/**
+ * Assert every reference of a test XML document is coherent. Throws with every violation
+ * when one is not.
+ */
+export declare function assertCoherentSclReferences(params: AssertCoherentSclReferencesParams): void;
+/**
+ * Check every case's `sourceXml`/`targetXml` and throw ONCE with the violations of all
+ * incoherent cases, each attributed to its case name. A case that sets
+ * `allowIncoherentReferences` is left unchecked.
+ */
+export declare function assertCoherentSclReferencesTestCases(params: AssertCoherentSclReferencesTestCasesParams): void;
+//# sourceMappingURL=assert-coherent-scl-references.d.ts.map

package/dist/v2019C1/test/assert-coherent-scl-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-coherent-scl-references.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-coherent-scl-references.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACX,iCAAiC,EACjC,0CAA0C,EAC1C,gCAAgC,EAChC,kBAAkB,EAClB,MAAM,wCAAwC,CAAA;AAQ/C;;;;GAIG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,gCAAgC,GACtC,kBAAkB,EAAE,CAQtB;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,iCAAiC,GAAG,IAAI,CAI3F;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CACnD,MAAM,EAAE,0CAA0C,GAChD,IAAI,CAcN"}

package/dist/v2019C1/test/assert-coherent-scl-references.types.d.ts

@@ -0,0 +1,50 @@
+/** One incoherent reference found in a test XML document. */
+export type ReferenceViolation = {
+    kind: 'path';
+    referenceTagName: string;
+    pathAttribute: string;
+    uuidAttribute: string;
+    uuid: string;
+    /** The path written in the document. */
+    written: string;
+    /** The path of the element the uuid points at. */
+    expected: string;
+} | {
+    kind: 'dangling';
+    referenceTagName: string;
+    uuidAttribute: string;
+    uuid: string;
+} | {
+    kind: 'wrong-target';
+    referenceTagName: string;
+    uuidAttribute: string;
+    uuid: string;
+    /** The tag of the element carrying that uuid, which the reference cannot point at. */
+    targetTagName: string;
+} | {
+    kind: 'empty';
+    referenceTagName: string;
+    uuidAttribute: string;
+};
+export type CollectReferenceViolationsParams = {
+    xml: string;
+};
+export type AssertCoherentSclReferencesParams = {
+    xml: string;
+    /** Names the document in the failure message. */
+    label?: string;
+};
+/** A test case as the reference check reads it. */
+export type ReferenceCoherenceTestCase = {
+    sourceXml: string;
+    targetXml?: string;
+    /**
+     * Set when the case NEEDS an incoherent reference (an orphan to clean up, a path to
+     * repair): the reason it does. The case's documents are then left unchecked.
+     */
+    allowIncoherentReferences?: string;
+};
+export type AssertCoherentSclReferencesTestCasesParams = {
+    testCases: Record<string, ReferenceCoherenceTestCase>;
+};
+//# sourceMappingURL=assert-coherent-scl-references.types.d.ts.map

package/dist/v2019C1/test/assert-coherent-scl-references.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-coherent-scl-references.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-coherent-scl-references.types.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAC3B;IACA,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAA;CACf,GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnF;IACA,IAAI,EAAE,cAAc,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,sFAAsF;IACtF,aAAa,EAAE,MAAM,CAAA;CACpB,GACD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAA;AAErE,MAAM,MAAM,gCAAgC,GAAG;IAC9C,GAAG,EAAE,MAAM,CAAA;CACX,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC/C,GAAG,EAAE,MAAM,CAAA;IACX,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,mDAAmD;AACnD,MAAM,MAAM,0BAA0B,GAAG;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,0CAA0C,GAAG;IACxD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAA;CACrD,CAAA"}

package/dist/v2019C1/test/assert-valid-scl-xml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-valid-scl-xml.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,iBAAiB,sGAAiB,CAAA;AAC/C,eAAO,MAAM,uBAAuB,+EAA0B,CAAA"}
+{"version":3,"file":"assert-valid-scl-xml.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,iBAAiB,sGAAiB,CAAA;AAC/C,eAAO,MAAM,uBAAuB,+EAA0B,CAAA"}

package/dist/v2019C1/test/hydrated-test.d.ts

@@ -4,6 +4,7 @@ export declare const XMLNS_SCL_NAMESPACE: string;
 export declare const XMLNS_SCL_6_100_NAMESPACE: string;
 export declare const ALL_XMLNS_NAMESPACES: string;
 export { CUSTOM_RECORD_ID_ATTRIBUTE, CUSTOM_RECORD_ID_ATTRIBUTE_NAME };
+export { assertCoherentSclReferences } from './assert-coherent-scl-references';
 export { assertValidSclXml } from './assert-valid-scl-xml';
 declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Config, {
     cleanUp: {
@@ -25,6 +26,7 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
         query: {
             report: typeof import('../extensions/lifecycle/report').report;
             checkTemplateUuids: typeof import('../extensions/lifecycle/validate').checkTemplateUuids;
+            classifyIeds: typeof import('../extensions/lifecycle/ied').classifyIeds;
         };
         transaction: {
             extract: typeof import("../extensions/lifecycle/extract");
@@ -34,6 +36,7 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
             };
             update: typeof import("../extensions/lifecycle/update");
             apply: typeof import('../extensions/lifecycle/apply').apply;
+            makeUnique: typeof import('../extensions/lifecycle/constraints').makeUnique;
         };
     };
     reference: {
@@ -43,13 +46,14 @@ declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Confi
     signature: {
         query: typeof import("../extensions/signature/query");
     };
-    presentation: {
-        query: typeof import("../extensions/presentation/query");
+    info: {
+        query: typeof import("../extensions/info/query");
     };
 }>;
 /**
- * `createTestRunner`, wrapped so every registered case's XML is checked against the SCL schema
- * before the suite runs — all invalid cases reported at once (see {@link assertValidSclTestCases}).
+ * `createTestRunner`, wrapped so every registered case's XML is checked before the suite runs —
+ * against the SCL schema (see {@link assertValidSclTestCases}), then for coherent references
+ * (see {@link assertCoherentSclReferencesTestCases}). All failing cases are reported at once.
  */
 export declare const runSclTestCases: typeof rawRunSclTestCases;
 export declare function createSclTestProject(params: {
@@ -58,6 +62,8 @@ export declare function createSclTestProject(params: {
     dev?: {
         perf?: boolean;
     };
+    /** The reason the fixtures NEED an incoherent reference; they are then left unchecked. */
+    allowIncoherentReferences?: string;
 }): Promise<import('@dialecte/core/test').TestProjectResult<Config, {
     cleanUp: {
         transaction: typeof import("../extensions/clean-up/transaction");
@@ -78,6 +84,7 @@ export declare function createSclTestProject(params: {
         query: {
             report: typeof import('../extensions/lifecycle/report').report;
             checkTemplateUuids: typeof import('../extensions/lifecycle/validate').checkTemplateUuids;
+            classifyIeds: typeof import('../extensions/lifecycle/ied').classifyIeds;
         };
         transaction: {
             extract: typeof import("../extensions/lifecycle/extract");
@@ -87,6 +94,7 @@ export declare function createSclTestProject(params: {
             };
             update: typeof import("../extensions/lifecycle/update");
             apply: typeof import('../extensions/lifecycle/apply').apply;
+            makeUnique: typeof import('../extensions/lifecycle/constraints').makeUnique;
         };
     };
     reference: {
@@ -96,8 +104,8 @@ export declare function createSclTestProject(params: {
     signature: {
         query: typeof import("../extensions/signature/query");
     };
-    presentation: {
-        query: typeof import("../extensions/presentation/query");
+    info: {
+        query: typeof import("../extensions/info/query");
     };
 }>>;
 export declare const createSclTestRecord: {

package/dist/v2019C1/test/hydrated-test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrated-test.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,0BAA0B,EAC1B,+BAA+B,EAE/B,MAAM,wBAAwB,CAAA;AAa/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAO9D,eAAO,MAAM,mBAAmB,QAA0D,CAAA;AAC1F,eAAO,MAAM,yBAAyB,QAA2G,CAAA;AACjJ,eAAO,MAAM,oBAAoB,QAAsG,CAAA;AACvI,OAAO,EAAE,0BAA0B,EAAE,+BAA+B,EAAE,CAAA;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAI1D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,kBAUpC,CAAA;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAaA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAuD,CAAA;AACvF,eAAO,MAAQ,4BAA4B;;;YAAE,8BAA8B;;;UAI1E,CAAA"}
+{"version":3,"file":"hydrated-test.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.ts"],"names":[],"mappings":"AAMA,OAAO,EACN,0BAA0B,EAC1B,+BAA+B,EAE/B,MAAM,wBAAwB,CAAA;AAa/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAO9D,eAAO,MAAM,mBAAmB,QAA0D,CAAA;AAC1F,eAAO,MAAM,yBAAyB,QAA2G,CAAA;AACjJ,eAAO,MAAM,oBAAoB,QAAsG,CAAA;AACvI,OAAO,EAAE,0BAA0B,EAAE,+BAA+B,EAAE,CAAA;AACtE,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAI1D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,OAAO,kBAYpC,CAAA;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IACxB,0FAA0F;IAC1F,yBAAyB,CAAC,EAAE,MAAM,CAAA;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAAuD,CAAA;AACvF,eAAO,MAAQ,4BAA4B;;;YAAE,8BAA8B;;;UAI1E,CAAA"}

package/dist/v2019C1/test/hydrated-test.types.d.ts

@@ -3,7 +3,14 @@ import { Config } from '../config/dialecte.config';
 import type * as CoreTest from '@dialecte/core/test';
 export declare namespace SclTest {
     type BaseTestCase = CoreTest.BaseTestCase;
-    type BaseXmlTestCase = CoreTest.BaseXmlTestCase;
+    type BaseXmlTestCase = CoreTest.BaseXmlTestCase & {
+        /**
+         * Set when the case NEEDS an incoherent reference (an orphan to clean up, a path to
+         * repair): the reason it does. The case's fixtures are then not checked for coherent
+         * references.
+         */
+        allowIncoherentReferences?: string;
+    };
     type TestCases<T extends BaseTestCase = BaseXmlTestCase> = Record<string, T>;
     type TestDocument = CoreTest.TestDocument<Config>;
     type TestProjectResult = CoreTest.TestProjectResult<Config, typeof SCL_EXTENSION_MODULES>;

package/dist/v2019C1/test/hydrated-test.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrated-test.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAEpD,yBAAiB,OAAO,CAAC;IACxB,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAA;IAChD,KAAY,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAA;IACtD,KAAY,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACnF,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;IACxD,KAAY,iBAAiB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;IAChG,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;IACpD,KAAY,SAAS,CAAC,CAAC,SAAS,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,SAAS,CAC7E,MAAM,EACN,CAAC,EACD,OAAO,qBAAqB,CAC5B,CAAA;IACD,KAAY,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAA;IAC1C,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;CAClF"}
+{"version":3,"file":"hydrated-test.types.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/hydrated-test.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAEpD,yBAAiB,OAAO,CAAC;IACxB,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAA;IAChD,KAAY,eAAe,GAAG,QAAQ,CAAC,eAAe,GAAG;QACxD;;;;WAIG;QACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;KAClC,CAAA;IACD,KAAY,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;IACnF,KAAY,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;IACxD,KAAY,iBAAiB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;IAChG,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;IACpD,KAAY,SAAS,CAAC,CAAC,SAAS,QAAQ,CAAC,eAAe,IAAI,QAAQ,CAAC,SAAS,CAC7E,MAAM,EACN,CAAC,EACD,OAAO,qBAAqB,CAC5B,CAAA;IACD,KAAY,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAA;IAC1C,KAAY,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,qBAAqB,CAAC,CAAA;CAClF"}

package/dist/v2019C1/test.js

@@ -1,38 +1,185 @@
-import { G as e, H as t, W as n, n as r, r as i, t as a } from "../hooks-2Y_WzKF4.js";
-import { CUSTOM_RECORD_ID_ATTRIBUTE as o, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as s, XMLNS_XSI_NAMESPACE as c } from "@dialecte/core/helpers";
-import { XMLNS_DEV_NAMESPACE as l, createTestProject as u, createTestRecordFactory as d, createTestRunner as f, createXmlAssertions as p, createXmlSchemaAssertions as m } from "@dialecte/core/test";
+import { $ as e, C as t, D as n, J as r, Q as i, X as a, et as o, n as s, r as c, t as l, w as u } from "../hooks-Cw9fAx-L.js";
+import { CUSTOM_RECORD_ID_ATTRIBUTE as d, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as f, XMLNS_XSI_NAMESPACE as p } from "@dialecte/core/helpers";
+import { XMLNS_DEV_NAMESPACE as m, createTestProject as h, createTestRecordFactory as g, createTestRunner as _, createXmlAssertions as v, createXmlSchemaAssertions as y } from "@dialecte/core/test";
+//#region src/v2019C1/test/assert-coherent-scl-references.ts
+var b = Object.values(i).map((e) => e.uri);
+function x(e) {
+	let { xml: t } = e, n = [...new DOMParser().parseFromString(t, "application/xml").querySelectorAll("*")].filter(k), r = A(n);
+	return n.flatMap((e) => E({
+		element: e,
+		elementsByUuid: r
+	}));
+}
+function S(e) {
+	let { xml: t, label: n = "test XML" } = e, r = w({
+		xml: t,
+		label: n
+	});
+	if (r) throw Error(r);
+}
+function C(e) {
+	let { testCases: t } = e, n = Object.entries(t).flatMap(([e, t]) => t.allowIncoherentReferences ? [] : [w({
+		xml: t.sourceXml,
+		label: `${e} › sourceXml`
+	}), t.targetXml ? w({
+		xml: t.targetXml,
+		label: `${e} › targetXml`
+	}) : void 0].filter((e) => e !== void 0));
+	if (n.length > 0) throw Error(n.join("\n"));
+}
+function w(e) {
+	let { xml: t, label: n } = e, r = x({ xml: t });
+	if (r.length !== 0) return `${n}: incoherent references:\n  ${r.map(T).join("\n  ")}`;
+}
+function T(e) {
+	let t = `<${e.referenceTagName}>`;
+	switch (e.kind) {
+		case "path": return `[path] ${t} ${e.pathAttribute}="${e.written}" is not the path of the element ${e.uuidAttribute}="${e.uuid}" points at, which is "${e.expected}"`;
+		case "dangling": return `[dangling] ${t} ${e.uuidAttribute}="${e.uuid}" points at no element of the document`;
+		case "wrong-target": return `[wrong-target] ${t} ${e.uuidAttribute}="${e.uuid}" points at a <${e.targetTagName}>, which it cannot reference`;
+		case "empty": return `[empty] ${t} ${e.uuidAttribute} is empty`;
+	}
+}
+function E(e) {
+	let { element: t, elementsByUuid: n } = e, i = r[t.localName];
+	return i ? i.flatMap((e) => D({
+		element: t,
+		pair: e,
+		elementsByUuid: n
+	})) : [];
+}
+function D(e) {
+	let { element: t, pair: n, elementsByUuid: r } = e, i = t.getAttribute(n.attribute.uuid);
+	if (i === null) return [];
+	let a = n.attribute.uuid, o = t.localName;
+	if (i === "") return [{
+		kind: "empty",
+		referenceTagName: o,
+		uuidAttribute: a
+	}];
+	let s = r.get(i) ?? [];
+	if (s.length === 0) return [{
+		kind: "dangling",
+		referenceTagName: o,
+		uuidAttribute: a,
+		uuid: i
+	}];
+	let c = n.target, l = s.find((e) => c.includes(e.localName));
+	if (!l) return [{
+		kind: "wrong-target",
+		referenceTagName: o,
+		uuidAttribute: a,
+		uuid: i,
+		targetTagName: s[0].localName
+	}];
+	if (!O({
+		pair: n,
+		target: l
+	})) return [];
+	let d = t.getAttribute(n.attribute.path);
+	if (d === null) return [];
+	let f = j(l), p = u({
+		record: N(l),
+		ancestry: f.map((e, t) => N(e, `ancestor-${t}`)),
+		specNamings: M(f)
+	});
+	return !p || p.path === d ? [] : [{
+		kind: "path",
+		referenceTagName: o,
+		pathAttribute: n.attribute.path,
+		uuidAttribute: a,
+		uuid: i,
+		written: d,
+		expected: p.path
+	}];
+}
+function O(e) {
+	let { pair: r, target: i } = e;
+	return r.resolution === t.direct ? n[i.localName]?.type === "name" : !1;
+}
+function k(e) {
+	return e.namespaceURI !== null && b.includes(e.namespaceURI);
+}
+function A(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = n.getAttribute("uuid");
+		if (!e) continue;
+		let r = t.get(e) ?? [];
+		t.set(e, [...r, n]);
+	}
+	return t;
+}
+function j(e) {
+	let t = [], n = e.parentElement;
+	for (; n;) t.unshift(n), n = n.parentElement;
+	return t;
+}
+function M(e) {
+	let t = /* @__PURE__ */ new Map();
+	return e.forEach((e, n) => {
+		if (e.localName !== "LNode") return;
+		let r = [...e.getElementsByTagNameNS("*", "LNodeSpecNaming")].find((t) => t.parentElement?.parentElement === e);
+		r && t.set(`ancestor-${n}`, N(r));
+	}), t;
+}
+function N(e, t = "") {
+	return {
+		id: t,
+		tagName: e.localName,
+		namespace: {
+			prefix: e.prefix ?? "",
+			uri: e.namespaceURI ?? ""
+		},
+		attributes: [...e.attributes].map((e) => ({
+			name: e.localName,
+			value: e.value
+		})),
+		value: "",
+		parent: null,
+		children: []
+	};
+}
+//#endregion
 //#region src/v2019C1/test/assert-valid-scl-xml.ts
-var { assertValidXml: h, assertValidXmlTestCases: g } = m({
+var { assertValidXml: P, assertValidXmlTestCases: F } = y({
 	definition: e,
-	namespaces: n,
+	types: o,
+	namespaces: i,
 	schemaName: "SCL"
-}), _ = h, v = g, y = {
-	...r(),
-	...a
-}, b = `xmlns="${t.namespaces.default.uri}"`, x = `xmlns:${t.namespaces.v2019C1.prefix}="${t.namespaces.v2019C1.uri}"`, S = `${b} ${x} ${l} ${c}`, C = { base: i }, w = f({
-	dialecteConfig: t,
-	extensions: C,
-	hooks: y
-}), T = {
-	...w,
+}), I = P, L = F, R = {
+	...s(),
+	...l
+}, z = `xmlns="${a.namespaces.default.uri}"`, B = `xmlns:${a.namespaces.v2019C1.prefix}="${a.namespaces.v2019C1.uri}"`, V = `${z} ${B} ${m} ${p}`, H = { base: c }, U = _({
+	dialecteConfig: a,
+	extensions: H,
+	hooks: R
+}), W = {
+	...U,
 	withExport(e) {
-		v({ testCases: e.testCases }), w.withExport(e);
+		L({ testCases: e.testCases }), C({ testCases: e.testCases }), U.withExport(e);
 	},
 	withoutExport(e) {
-		v({ testCases: e.testCases }), w.withoutExport(e);
+		L({ testCases: e.testCases }), C({ testCases: e.testCases }), U.withoutExport(e);
 	}
 };
-async function E(e) {
-	let { sourceXml: n, targetXml: r, dev: i } = e;
-	return _(n, "sourceXml", { requireComplete: !1 }), r && _(r, "targetXml", { requireComplete: !1 }), u({
-		sourceXml: n,
-		targetXml: r,
-		dialecteConfig: t,
-		extensions: C,
-		hooks: y,
-		dev: i
+async function G(e) {
+	let { sourceXml: t, targetXml: n, dev: r, allowIncoherentReferences: i } = e;
+	return I(t, "sourceXml", { requireComplete: !1 }), n && I(n, "targetXml", { requireComplete: !1 }), i || (S({
+		xml: t,
+		label: "sourceXml"
+	}), n && S({
+		xml: n,
+		label: "targetXml"
+	})), h({
+		sourceXml: t,
+		targetXml: n,
+		dialecteConfig: a,
+		extensions: H,
+		hooks: R,
+		dev: r
 	});
 }
-var D = d(t), { assertExpectedElementQueries: O, assertUnexpectedElementQueries: k } = p({ namespaces: t.namespaces });
+var K = g(a), { assertExpectedElementQueries: q, assertUnexpectedElementQueries: J } = v({ namespaces: a.namespaces });
 //#endregion
-export { S as ALL_XMLNS_NAMESPACES, o as CUSTOM_RECORD_ID_ATTRIBUTE, s as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, x as XMLNS_SCL_6_100_NAMESPACE, b as XMLNS_SCL_NAMESPACE, O as assertExpectedElementQueries, k as assertUnexpectedElementQueries, _ as assertValidSclXml, E as createSclTestProject, D as createSclTestRecord, T as runSclTestCases };
+export { V as ALL_XMLNS_NAMESPACES, d as CUSTOM_RECORD_ID_ATTRIBUTE, f as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, B as XMLNS_SCL_6_100_NAMESPACE, z as XMLNS_SCL_NAMESPACE, S as assertCoherentSclReferences, q as assertExpectedElementQueries, J as assertUnexpectedElementQueries, I as assertValidSclXml, G as createSclTestProject, K as createSclTestRecord, W as runSclTestCases };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/scl",
-	"version": "0.5.0",
+	"version": "0.7.0",
 	"description": "Dialecte - SCL (Substation Configuration Language) sdk",
 	"license": "MIT",
 	"repository": {
@@ -56,10 +56,10 @@
 		"prepare": "husky"
 	},
 	"dependencies": {
-		"@dialecte/core": "0.5.2"
+		"@dialecte/core": "0.6.0"
 	},
 	"devDependencies": {
-		"@dialecte/cli": "0.0.3",
+		"@dialecte/cli": "0.1.0",
 		"@tsconfig/node24": "^24.0.4",
 		"@types/node": "^24.12.4",
 		"@typescript/native": "npm:typescript@^7.0.2",