@dialecte/scl 0.3.14 → 0.3.16

package/dist/v2019C1/extensions/reference/transaction/write-provenance.d.ts

@@ -2,17 +2,17 @@ import { WriteProvenanceParams } from './write-provenance.types';
 import { Config } from '../../../config';
 import type * as Core from '@dialecte/core';
 /**
- * Writes the instantiation provenance link on the cloned root: a fresh
- * `FunctionSclRef` / `ApplicationSclRef` > `SclFileReference` pointing back at the
- * template file the instance was created from.
+ * Writes an instantiation/import provenance link: an `SclFileReference` pointing back at the source
+ * file, sourced from the source `Header` (`version` / `revision` / `fileUuid`) and store (`fileName`).
  *
- * The kernel self-sources every field from the source document — `fileType` from
- * the caller, `version` / `revision` / `fileUuid` from the template `Header`,
- * `fileName` from the source store — so no SET dependency. `version` / `revision`
- * fall back to empty strings when the (optional) Header attributes are absent.
+ * The anchor is chosen by `target`:
+ * - `function` / `application` — a fresh `FunctionSclRef` / `ApplicationSclRef` on the cloned root
+ *   (FSD / ASD). Always **creates** a new ref (a root may already carry composition SclRefs; each
+ *   instantiation is a distinct link).
+ * - `document` — appended to the target `Header > SourceFiles` (SSD / SCD): a whole-file source, with
+ *   no per-root wrapper.
  *
- * Always **creates** a new ref (never reuses an existing one): a root may already
- * carry composition-provenance SclRefs, and each instantiation is a distinct link.
+ * `version` / `revision` fall back to empty strings when the (optional) Header attributes are absent.
  */
 export declare function writeProvenance(tx: Core.Transaction<Config>, params: WriteProvenanceParams): Promise<void>;
 //# sourceMappingURL=write-provenance.d.ts.map

package/dist/v2019C1/extensions/reference/transaction/write-provenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write-provenance.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/transaction/write-provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AACzF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAQ3C;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACpC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE,qBAAqB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAmBf"}
+{"version":3,"file":"write-provenance.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/transaction/write-provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiC,qBAAqB,EAAE,MAAM,0BAA0B,CAAA;AACpG,OAAO,KAAK,EAAE,MAAM,EAAO,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAQ3C;;;;;;;;;;;;GAYG;AACH,wBAAsB,eAAe,CACpC,EAAE,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAC5B,MAAM,EAAE,qBAAqB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/v2019C1/extensions/reference/transaction/write-provenance.types.d.ts

@@ -1,13 +1,28 @@
 import { Scl, Config } from '../../../config';
 import type * as Core from '@dialecte/core';
-/** Which template kind produced the instance (selects the SclRef element + fileType). */
-export type ProvenanceFileType = 'FSD' | 'ASD';
+/** SCL file type recorded on an `SclFileReference` (the Header `fileType` domain). */
+export type SclFileType = 'FSD' | 'ASD' | 'SSD' | 'ISD' | 'ICD' | 'IID' | 'SCD' | 'SED' | 'CID';
+/**
+ * Where a provenance link is anchored.
+ * - `function` / `application` — a per-root `FunctionSclRef` / `ApplicationSclRef` on the cloned
+ *   root (FSD / ASD); the `fileType` is implied by the anchor.
+ * - `document` — a `Header > SourceFiles > SclFileReference` recording the whole source file for the
+ *   document (SSD / SCD / …), appended to the target `Header` (no per-root wrapper exists).
+ */
+export type ProvenanceTarget = {
+    anchor: 'function';
+    root: Scl.Ref<'Function'> | Scl.Ref<'SubFunction'>;
+} | {
+    anchor: 'application';
+    root: Scl.Ref<'Application'>;
+} | {
+    anchor: 'document';
+    fileType: SclFileType;
+};
 export type WriteProvenanceParams = {
-    /** Query over the template document the instance was created from. */
+    /** Query over the source document the provenance is sourced from (Header + file name). */
     sourceQuery: Core.Query<Config>;
-    /** Cloned root element in the target: `Function` for FSD, `Application` for ASD. */
-    targetRoot: Scl.Ref<Scl.ElementsOf>;
-    /** Template kind; selects `FunctionSclRef` (FSD) or `ApplicationSclRef` (ASD). */
-    fileType: ProvenanceFileType;
+    /** Where + how to anchor the link. */
+    target: ProvenanceTarget;
 };
 //# sourceMappingURL=write-provenance.types.d.ts.map

package/dist/v2019C1/extensions/reference/transaction/write-provenance.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write-provenance.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/transaction/write-provenance.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,yFAAyF;AACzF,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,CAAA;AAE9C,MAAM,MAAM,qBAAqB,GAAG;IACnC,sEAAsE;IACtE,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,oFAAoF;IACpF,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACnC,kFAAkF;IAClF,QAAQ,EAAE,kBAAkB,CAAA;CAC5B,CAAA"}
+{"version":3,"file":"write-provenance.types.d.ts","sourceRoot":"","sources":["../../../../../src/v2019C1/extensions/reference/transaction/write-provenance.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,KAAK,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAE3C,sFAAsF;AACtF,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAE/F;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACzB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;CAAE,GAC1E;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,CAAA;AAEhD,MAAM,MAAM,qBAAqB,GAAG;IACnC,0FAA0F;IAC1F,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC/B,sCAAsC;IACtC,MAAM,EAAE,gBAAgB,CAAA;CACxB,CAAA"}

package/dist/v2019C1/hooks/after-standardized-record/uuid-attribute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuid-attribute.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/hooks/after-standardized-record/uuid-attribute.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAEpC;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,SAAS,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE;IACnF,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;CACrC,GAAG,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CA6BhC"}
+{"version":3,"file":"uuid-attribute.d.ts","sourceRoot":"","sources":["../../../../src/v2019C1/hooks/after-standardized-record/uuid-attribute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AACpC;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,SAAS,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE;IACnF,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CAAA;CACrC,GAAG,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,CA6BhC"}

package/dist/v2019C1/hooks/io/io-hooks.d.ts

@@ -3,7 +3,7 @@ import { IOHooks } from '@dialecte/core';
  * Creates SCL IO hooks for UUID reference resolution.
  * The import pipeline is two-pass:
  *
- * **Phase 1 — `beforeImportRecord`** (called once per record, in document order):
+ * **Pass 1 — `beforeImportRecord`** (called once per record, in document order):
  *
  * Records arrive already standardized, so any `uuid` enforced by
  * `afterStandardizedRecord` is already present — no need to ensure it here.
@@ -24,7 +24,7 @@ import { IOHooks } from '@dialecte/core';
  *                         lookupKey: "S1/Bay1/VoltLevel1/Fn1" }]
  * ```
  *
- * **Phase 2 — `afterImport`** (called once, after all records):
+ * **Pass 2 — `afterImport`** (called once, after all records):
  *
  * Each pending resolution is looked up in `pathIndex`:
  * ```

package/dist/v2019C1/index.js

@@ -1,7 +1,7 @@
-import { A as e, C as t, D as n, E as r, O as i, S as a, T as o, _ as s, a as c, b as l, c as u, d, f, g as p, h as m, i as h, k as g, l as _, m as v, n as y, o as b, p as x, r as S, s as C, t as w, u as T, v as E, w as D, x as O, y as k } from "../hooks-By65uB-0.js";
-import { Project as A } from "@dialecte/core";
+import { A as e, C as t, D as n, E as r, M as i, N as a, O as o, P as s, S as c, T as l, _ as u, a as d, b as f, c as p, d as m, f as h, g, h as _, i as v, j as y, k as b, l as x, m as S, n as C, o as w, p as T, r as E, s as D, t as O, u as k, v as A, w as j, x as M, y as N } from "../hooks-BBGXNK0x.js";
+import { Project as P } from "@dialecte/core";
 //#region src/v2019C1/extensions/lifecycle/validate/template-uuid-check.info.ts
-var j = {
+var F = {
 	"cross-type-template-uuid": {
 		title: "Placeholder templateUuid reused across element types",
 		description: "One templateUuid is carried by elements of several different types, so it cannot identify a single template element — it is an authoring placeholder, not real lineage.",
@@ -20,21 +20,21 @@ var j = {
 };
 //#endregion
 //#region src/v2019C1/dialecte.ts
-function M(e) {
+function I(e) {
 	let { storage: t = { type: "local" }, extensions: n } = e ?? {};
-	return new A({
+	return new P({
 		configs: { scl: i },
 		defaultConfigKey: "scl",
 		storage: t,
 		extensions: {
-			base: S,
+			base: E,
 			custom: n
 		},
 		hooks: {
-			...y(),
-			...w
+			...C(),
+			...O
 		}
 	});
 }
 //#endregion
-export { u as ALL_REF_UUID_ATTRIBUTES, _ as ALL_RESOLUTIONS, c as DEFAULT_IGNORED_ATTRIBUTES, l as KEEP_ON_ORPHAN_REFS, T as LOCKED_LNODE_ATTRIBUTES, d as MAPPED_NAME_REFS, f as PAIRS_BY_REF, o as PATH_CONTRIBUTING_ATTRIBUTES, r as PATH_EXTRACTION_CONFIG, O as REFERENCE_TAGS, a as REFERENCE_TAG_NAMES, C as REF_CONTAINERS, x as RESOLUTION_TARGET_REFS, k as RESOLUTION_TYPE, v as RESOLVABLE_RESOLUTIONS, n as SCL_DATABASE_CONFIG, i as SCL_DIALECTE_CONFIG, g as SCL_IO_CONFIG, e as SCL_NAMESPACES, t as TARGET_ELEMENT_TYPES, j as TEMPLATE_UUID_WARNING_INFO, E as TYPE_ID_REFERENCE_PAIRS, m as TYPE_ID_REFERRERS_BY_TARGET, p as TYPE_ID_REF_ATTRIBUTES, s as TYPE_ID_TARGET_TAGS, D as UUID_REFERENCE_PAIRS, M as createSclProject, b as isTypeIdTarget, h as presentationScope };
+export { p as ALL_REF_UUID_ATTRIBUTES, x as ALL_RESOLUTIONS, d as DEFAULT_IGNORED_ATTRIBUTES, f as FRAME_OMIT_CHILD_TAGS, j as KEEP_ON_ORPHAN_REFS, k as LOCKED_LNODE_ATTRIBUTES, m as MAPPED_NAME_REFS, h as PAIRS_BY_REF, b as PATH_CONTRIBUTING_ATTRIBUTES, e as PATH_EXTRACTION_CONFIG, l as REFERENCE_TAGS, r as REFERENCE_TAG_NAMES, D as REF_CONTAINERS, T as RESOLUTION_TARGET_REFS, N as RESOLUTION_TYPE, S as RESOLVABLE_RESOLUTIONS, y as SCL_DATABASE_CONFIG, i as SCL_DIALECTE_CONFIG, a as SCL_IO_CONFIG, s as SCL_NAMESPACES, n as TARGET_ELEMENT_TYPES, t as TEMPLATE_NAME, F as TEMPLATE_UUID_WARNING_INFO, M as TOPOLOGY_EQUIPMENT_TAGS, c as TOPOLOGY_STRUCTURAL_TAGS, A as TYPE_ID_REFERENCE_PAIRS, _ as TYPE_ID_REFERRERS_BY_TARGET, g as TYPE_ID_REF_ATTRIBUTES, u as TYPE_ID_TARGET_TAGS, o as UUID_REFERENCE_PAIRS, I as createSclProject, w as isTypeIdTarget, v as presentationScope };

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

@@ -0,0 +1,18 @@
+/**
+ * Assert a test XML string is valid SCL, structurally: every element's namespace matches its parent
+ * context, every element is an allowed child of its parent, and every attribute is a known attribute of
+ * its element. Elements/parents unknown to the schema are skipped (bespoke content under a transparent
+ * `Private`, or dev-namespace scaffolding).
+ *
+ * `requireComplete` (default `true`) additionally requires every schema-required attribute to be
+ * present. Minimal test fixtures legitimately omit these (e.g. a bare `<SCL>` without
+ * `version`/`revision`/`release`), so the harness runs with it OFF — structural correctness is
+ * enforced, document completeness is not.
+ *
+ * NOT yet enforced (planned with the validation feature): attribute VALUE facets (uuid pattern, enums,
+ * datatypes) and cross-element constraints (unique keys, keyref resolution).
+ */
+export declare function assertValidSclXml(xml: string, label?: string, options?: {
+    requireComplete?: boolean;
+}): void;
+//# sourceMappingURL=assert-valid-scl-xml.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert-valid-scl-xml.d.ts","sourceRoot":"","sources":["../../../src/v2019C1/test/assert-valid-scl-xml.ts"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,MAAM,EACX,KAAK,SAAa,EAClB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GACzC,IAAI,CAqDN"}

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

@@ -4,7 +4,8 @@ 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 declare const runSclTestCases: import('@dialecte/core/test').TestRunner<Config, {
+export { assertValidSclXml } from './assert-valid-scl-xml';
+declare const rawRunSclTestCases: import('@dialecte/core/test').TestRunner<Config, {
     cleanUp: {
         transaction: typeof import("../extensions/clean-up/transaction");
     };
@@ -17,6 +18,7 @@ export declare const runSclTestCases: import('@dialecte/core/test').TestRunner<C
         transaction: typeof import("../extensions/history/transaction");
     };
     identity: {
+        query: typeof import("../extensions/identity/query");
         transaction: typeof import("../extensions/identity/transaction");
     };
     lifecycle: {
@@ -45,6 +47,11 @@ export declare const runSclTestCases: import('@dialecte/core/test').TestRunner<C
         query: typeof import("../extensions/presentation/query");
     };
 }>;
+/**
+ * `createTestRunner`, wrapped so every registered case's XML is checked against the SCL schema's
+ * per-element namespaces before the suite runs (see {@link assertValidSclXml}).
+ */
+export declare const runSclTestCases: typeof rawRunSclTestCases;
 export declare function createSclTestProject(params: {
     sourceXml: string;
     targetXml?: string;
@@ -64,6 +71,7 @@ export declare function createSclTestProject(params: {
         transaction: typeof import("../extensions/history/transaction");
     };
     identity: {
+        query: typeof import("../extensions/identity/query");
         transaction: typeof import("../extensions/identity/transaction");
     };
     lifecycle: {

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":"AAAA,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;AAItE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAA;AAEF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWA;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":"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;AAaF;;;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"}

package/dist/v2019C1/test.js

@@ -1,26 +1,70 @@
-import { O as e, n as t, r as n, t as r } from "../hooks-By65uB-0.js";
-import { CUSTOM_RECORD_ID_ATTRIBUTE as i, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as a, XMLNS_XSI_NAMESPACE as o } from "@dialecte/core/helpers";
-import { XMLNS_DEV_NAMESPACE as s, createTestProject as c, createTestRecordFactory as l, createTestRunner as u, createXmlAssertions as d } from "@dialecte/core/test";
+import { F as e, M as t, n, r, t as i } from "../hooks-BBGXNK0x.js";
+import { CUSTOM_RECORD_ID_ATTRIBUTE as a, CUSTOM_RECORD_ID_ATTRIBUTE_NAME as o, XMLNS_XSI_NAMESPACE as s } from "@dialecte/core/helpers";
+import { XMLNS_DEV_NAMESPACE as c, createTestProject as l, createTestRecordFactory as u, createTestRunner as d, createXmlAssertions as f } from "@dialecte/core/test";
+//#region src/v2019C1/test/assert-valid-scl-xml.ts
+var p = e;
+function m(e, t) {
+	return ((e ? p[e]?.children?.details?.[t]?.namespace : void 0) ?? p[t]?.namespace)?.uri;
+}
+function h(e, t) {
+	let n = e.children;
+	return n ? n.any === !0 || n.sequence?.includes(t) ? !0 : n.details ? t in n.details : !1 : !1;
+}
+function g(e) {
+	return new Set([...e.attributes?.sequence ?? [], ...Object.keys(e.attributes?.details ?? {})]);
+}
+function _(e, t = "test XML", n = {}) {
+	let r = n.requireComplete ?? !0, i = new DOMParser().parseFromString(e, "application/xml"), a = i.querySelector("parsererror");
+	if (a) throw Error(`${t}: malformed XML — ${a.textContent?.trim()}`);
+	let o = [], s = (e, t) => {
+		let n = e.localName, i = p[n], a = m(t, n);
+		if (a !== void 0 && e.namespaceURI !== a) {
+			let n = t ? ` under <${t}>` : "";
+			o.push(`[namespace] <${e.tagName}>${n}: is in ${e.namespaceURI ?? "(no namespace)"}, schema declares ${a}`);
+		}
+		let c = t ? p[t] : void 0;
+		if (c && !h(c, n) && o.push(`[containment] <${n}> is not a valid child of <${t}>`), i?.attributes) {
+			let t = g(i);
+			for (let r of Array.from(e.attributes)) r.namespaceURI === null && (t.has(r.localName) || o.push(`[attribute] <${n}> has unknown attribute '${r.localName}'`));
+			if (r) for (let [t, r] of Object.entries(i.attributes.details ?? {})) r?.required && !e.hasAttribute(t) && o.push(`[required] <${n}> is missing required attribute '${t}'`);
+		}
+		for (let t of Array.from(e.children)) s(t, n);
+	};
+	if (i.documentElement && s(i.documentElement, void 0), o.length > 0) throw Error(`${t}: not valid SCL:\n  ${o.join("\n  ")}`);
+}
+//#endregion
 //#region src/v2019C1/test/hydrated-test.ts
-var f = {
-	...t(),
-	...r
-}, p = `xmlns="${e.namespaces.default.uri}"`, m = `xmlns:${e.namespaces.v2019C1.prefix}="${e.namespaces.v2019C1.uri}"`, h = `${p} ${m} ${s} ${o}`, g = { base: n }, _ = u({
-	dialecteConfig: e,
-	extensions: g,
-	hooks: f
+var v = {
+	...n(),
+	...i
+}, y = `xmlns="${t.namespaces.default.uri}"`, b = `xmlns:${t.namespaces.v2019C1.prefix}="${t.namespaces.v2019C1.uri}"`, x = `${y} ${b} ${c} ${s}`, S = { base: r }, C = d({
+	dialecteConfig: t,
+	extensions: S,
+	hooks: v
 });
-async function v(t) {
-	let { sourceXml: n, targetXml: r, dev: i } = t;
-	return c({
+function w(e) {
+	for (let [t, n] of Object.entries(e)) _(n.sourceXml, `${t} › sourceXml`, { requireComplete: !1 }), n.targetXml && _(n.targetXml, `${t} › targetXml`, { requireComplete: !1 });
+}
+var T = {
+	...C,
+	withExport(e) {
+		w(e.testCases), C.withExport(e);
+	},
+	withoutExport(e) {
+		w(e.testCases), C.withoutExport(e);
+	}
+};
+async function E(e) {
+	let { sourceXml: n, targetXml: r, dev: i } = e;
+	return _(n, "sourceXml", { requireComplete: !1 }), r && _(r, "targetXml", { requireComplete: !1 }), l({
 		sourceXml: n,
 		targetXml: r,
-		dialecteConfig: e,
-		extensions: g,
-		hooks: f,
+		dialecteConfig: t,
+		extensions: S,
+		hooks: v,
 		dev: i
 	});
 }
-var y = l(e), { assertExpectedElementQueries: b, assertUnexpectedElementQueries: x } = d({ namespaces: e.namespaces });
+var D = u(t), { assertExpectedElementQueries: O, assertUnexpectedElementQueries: k } = f({ namespaces: t.namespaces });
 //#endregion
-export { h as ALL_XMLNS_NAMESPACES, i as CUSTOM_RECORD_ID_ATTRIBUTE, a as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, m as XMLNS_SCL_6_100_NAMESPACE, p as XMLNS_SCL_NAMESPACE, b as assertExpectedElementQueries, x as assertUnexpectedElementQueries, v as createSclTestProject, y as createSclTestRecord, _ as runSclTestCases };
+export { x as ALL_XMLNS_NAMESPACES, a as CUSTOM_RECORD_ID_ATTRIBUTE, o as CUSTOM_RECORD_ID_ATTRIBUTE_NAME, b as XMLNS_SCL_6_100_NAMESPACE, y as XMLNS_SCL_NAMESPACE, O as assertExpectedElementQueries, k as assertUnexpectedElementQueries, _ as assertValidSclXml, E as createSclTestProject, D as createSclTestRecord, T as runSclTestCases };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dialecte/scl",
-	"version": "0.3.14",
+	"version": "0.3.16",
 	"description": "Dialecte - SCL (Substation Configuration Language) sdk",
 	"license": "MIT",
 	"repository": {
@@ -44,6 +44,8 @@
 		"lint:fix": "oxlint . --fix -D correctness --ignore-path .gitignore",
 		"format:check": "oxfmt --check",
 		"format:fix": "oxfmt",
+		"format:xml": "dialecte-xmlfmt 'src/**/*.test.ts'",
+		"format:xml:check": "dialecte-xmlfmt --check 'src/**/*.test.ts'",
 		"//====== TYPE PERF ======//": "",
 		"coverage:gen": "dialecte coverage",
 		"type-bench": "npm run coverage:gen && dialecte bench",
@@ -54,7 +56,7 @@
 		"prepare": "husky"
 	},
 	"dependencies": {
-		"@dialecte/core": "0.4.12"
+		"@dialecte/core": "0.4.16"
 	},
 	"devDependencies": {
 		"@dialecte/cli": "0.0.2",