@ifc-lite/ids 1.14.11 → 1.15.2

package/dist/audit/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * IDS document auditing.
+ *
+ * Authoring tools (`ids-flow`, `ids-light-editor`) historically delegated
+ * IDS-document validation to buildingSMART's `IfcTester-Service` HTTP
+ * endpoint. This module brings that capability in-process so consumers
+ * can drop the network round-trip.
+ *
+ * Three layers of checks run by default:
+ *  1. Permissive parse — a wrapper around `parseIDS` that turns each
+ *     `IDSParseError` into a structured issue.
+ *  2. XSD-level checks — required attributes, enum membership, structural
+ *     shape (cf. `ids.xsd`).
+ *  3. IFC schema cross-checks — entities, predefined types, property
+ *     sets/properties, attribute names against the seed dataset in
+ *     `@ifc-lite/data`.
+ *  4. Restriction & cardinality coherence — empty enumerations, inverted
+ *     bounds, regex patterns that don't compile, etc.
+ *
+ * All four are independently togglable via `IDSAuditOptions`.
+ */
+import type { IDSDocument } from '../types.js';
+import type { IDSAuditOptions, IDSAuditReport } from './types.js';
+export type { IDSAuditCode, IDSAuditIssue, IDSAuditOptions, IDSAuditReport, IDSAuditSeverity, } from './types.js';
+/**
+ * Audit an IDS XML document. The report aggregates issues from every
+ * enabled check phase. Even when parsing fails, the returned report
+ * contains the parse error as a structured issue.
+ */
+export declare function auditIDSDocument(xml: string | ArrayBuffer, options?: IDSAuditOptions): Promise<IDSAuditReport>;
+/**
+ * Audit an already-parsed IDS document. Skips the parse step — useful
+ * when the caller already has an `IDSDocument` (e.g., from an in-app
+ * editor that mutates the structure directly).
+ */
+export declare function auditIDSStructure(doc: IDSDocument, options?: IDSAuditOptions): Promise<IDSAuditReport>;
+//# sourceMappingURL=index.d.ts.map

package/dist/audit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/audit/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,OAAO,KAAK,EAEV,eAAe,EACf,cAAc,EACf,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,YAAY,EACZ,aAAa,EACb,eAAe,EACf,cAAc,EACd,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,GAAG,WAAW,EACzB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,WAAW,EAChB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CAczB"}

package/dist/audit/index.js

@@ -0,0 +1,60 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { runCoherenceAudit } from './coherence/index.js';
+import { runIfcSchemaAudit } from './ifc-schema/index.js';
+import { permissiveParse } from './parser-shim.js';
+import { runStructuralAudit } from './structural/index.js';
+import { runXsdAudit } from './xsd/index.js';
+/**
+ * Audit an IDS XML document. The report aggregates issues from every
+ * enabled check phase. Even when parsing fails, the returned report
+ * contains the parse error as a structured issue.
+ */
+export async function auditIDSDocument(xml, options = {}) {
+    const { document, issues } = permissiveParse(xml);
+    if (!document) {
+        return finalise(issues);
+    }
+    // The structural shape walk needs the raw XML DOM, so it sits in the
+    // top-level entry point (alongside parse), not in
+    // `auditIDSStructure(parsed)`.
+    const structuralIssues = options.xsdValidation === false
+        ? []
+        : await runStructuralAudit(xml);
+    const downstream = await auditIDSStructure(document, options);
+    return finalise([...issues, ...structuralIssues, ...downstream.issues], document);
+}
+/**
+ * Audit an already-parsed IDS document. Skips the parse step — useful
+ * when the caller already has an `IDSDocument` (e.g., from an in-app
+ * editor that mutates the structure directly).
+ */
+export async function auditIDSStructure(doc, options = {}) {
+    const xsdValidation = options.xsdValidation !== false;
+    const ifcSchemaChecks = options.ifcSchemaChecks !== false;
+    const coherenceChecks = options.coherenceChecks !== false;
+    const issues = [];
+    if (xsdValidation)
+        issues.push(...runXsdAudit(doc));
+    if (coherenceChecks)
+        issues.push(...runCoherenceAudit(doc));
+    if (ifcSchemaChecks) {
+        issues.push(...(await runIfcSchemaAudit(doc, { ifcVersion: options.ifcVersion })));
+    }
+    return finalise(issues, doc);
+}
+function finalise(issues, parsedDocument) {
+    let status = 'valid';
+    for (const issue of issues) {
+        if (issue.severity === 'error') {
+            status = 'error';
+            break;
+        }
+        if (issue.severity === 'warning' || issue.severity === 'info') {
+            status = 'warning';
+        }
+    }
+    return { status, issues, parsedDocument };
+}
+//# sourceMappingURL=index.js.map

package/dist/audit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/audit/index.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAyB/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAM3D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAU7C;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAAyB,EACzB,UAA2B,EAAE;IAE7B,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;IAClD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IACD,qEAAqE;IACrE,kDAAkD;IAClD,+BAA+B;IAC/B,MAAM,gBAAgB,GACpB,OAAO,CAAC,aAAa,KAAK,KAAK;QAC7B,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,MAAM,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACpC,MAAM,UAAU,GAAG,MAAM,iBAAiB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC9D,OAAO,QAAQ,CACb,CAAC,GAAG,MAAM,EAAE,GAAG,gBAAgB,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,EACtD,QAAQ,CACT,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,GAAgB,EAChB,UAA2B,EAAE;IAE7B,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,KAAK,KAAK,CAAC;IACtD,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,KAAK,KAAK,CAAC;IAC1D,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,KAAK,KAAK,CAAC;IAE1D,MAAM,MAAM,GAAoB,EAAE,CAAC;IACnC,IAAI,aAAa;QAAE,MAAM,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,IAAI,eAAe;QAAE,MAAM,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,IAAI,eAAe,EAAE,CAAC;QACpB,MAAM,CAAC,IAAI,CACT,GAAG,CAAC,MAAM,iBAAiB,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CACtE,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,QAAQ,CACf,MAAuB,EACvB,cAA4B;IAE5B,IAAI,MAAM,GAA6B,OAAO,CAAC;IAC/C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAC/B,MAAM,GAAG,OAAO,CAAC;YACjB,MAAM;QACR,CAAC;QACD,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;YAC9D,MAAM,GAAG,SAAS,CAAC;QACrB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;AAC5C,CAAC"}

package/dist/audit/parser-shim.d.ts

@@ -0,0 +1,13 @@
+import type { IDSDocument } from '../types.js';
+import type { IDSAuditIssue } from './types.js';
+export interface PermissiveParseResult {
+    document?: IDSDocument;
+    issues: IDSAuditIssue[];
+}
+/**
+ * Try to parse `xml`. On success, returns the document with no issues. On
+ * failure, returns an empty issue list with the original `IDSParseError`
+ * mapped onto a structured `IDSAuditIssue`.
+ */
+export declare function permissiveParse(xml: string | ArrayBuffer): PermissiveParseResult;
+//# sourceMappingURL=parser-shim.d.ts.map

package/dist/audit/parser-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-shim.d.ts","sourceRoot":"","sources":["../../src/audit/parser-shim.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,GAAG,WAAW,GACxB,qBAAqB,CAOvB"}

package/dist/audit/parser-shim.js

@@ -0,0 +1,66 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Permissive parse layer for the auditor.
+ *
+ * `parseIDS` is intentionally strict — it throws on the first structural
+ * problem so application code never sees a half-parsed document. The audit
+ * use case is the opposite: we want to surface every issue at once, and
+ * keep going even when individual specs fail to parse. This module wraps
+ * `parseIDS` and converts an `IDSParseError` into an `IDSAuditIssue`.
+ *
+ * For richer salvaging (e.g., parsing each `<specification>` independently
+ * so one bad spec doesn't sink the whole document), see Phase 2+ — for now
+ * we collect a single parse error and stop.
+ */
+import { IDSParseError, parseIDS } from '../parser/xml-parser.js';
+/**
+ * Try to parse `xml`. On success, returns the document with no issues. On
+ * failure, returns an empty issue list with the original `IDSParseError`
+ * mapped onto a structured `IDSAuditIssue`.
+ */
+export function permissiveParse(xml) {
+    try {
+        const document = parseIDS(xml);
+        return { document, issues: [] };
+    }
+    catch (err) {
+        return { issues: [parseErrorToIssue(err)] };
+    }
+}
+function parseErrorToIssue(err) {
+    if (err instanceof IDSParseError) {
+        const message = err.details
+            ? `${err.message}: ${err.details}`
+            : err.message;
+        // Heuristic mapping — distinguish the few error sites in `parseIDS` so
+        // consumers can dispatch on `code`. The parser throws three families
+        // of errors, all surfaced as `IDSParseError`.
+        let code = 'E_PARSE_UNKNOWN';
+        if (err.message.includes('Failed to parse IDS XML') ||
+            err.message.includes('Invalid XML format') ||
+            err.message.includes('No DOMParser')) {
+            code = 'E_PARSE_XML';
+        }
+        else if (err.message.includes('Invalid root element')) {
+            code = 'E_PARSE_ROOT';
+        }
+        else if (err.message.includes('facet')) {
+            code = 'E_PARSE_FACET';
+        }
+        return {
+            severity: 'error',
+            code,
+            message,
+            path: '',
+        };
+    }
+    return {
+        severity: 'error',
+        code: 'E_PARSE_UNKNOWN',
+        message: err instanceof Error ? err.message : String(err),
+        path: '',
+    };
+}
+//# sourceMappingURL=parser-shim.js.map

package/dist/audit/parser-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser-shim.js","sourceRoot":"","sources":["../../src/audit/parser-shim.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AASlE;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAyB;IAEzB,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAClC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,EAAE,MAAM,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;IAC9C,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,GAAY;IACrC,IAAI,GAAG,YAAY,aAAa,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO;YACzB,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO,EAAE;YAClC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC;QAChB,uEAAuE;QACvE,qEAAqE;QACrE,8CAA8C;QAC9C,IAAI,IAAI,GAA0B,iBAAiB,CAAC;QACpD,IACE,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAC;YAC/C,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC;YAC1C,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,EACpC,CAAC;YACD,IAAI,GAAG,aAAa,CAAC;QACvB,CAAC;aAAM,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,CAAC;YACxD,IAAI,GAAG,cAAc,CAAC;QACxB,CAAC;aAAM,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACzC,IAAI,GAAG,eAAe,CAAC;QACzB,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,IAAI;YACJ,OAAO;YACP,IAAI,EAAE,EAAE;SACT,CAAC;IACJ,CAAC;IACD,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,iBAAiB;QACvB,OAAO,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;QACzD,IAAI,EAAE,EAAE;KACT,CAAC;AACJ,CAAC"}

package/dist/audit/structural/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Structural shape audit — walks the raw IDS XML DOM and verifies every
+ * element/attribute against the IDS 1.0 XSD's element shapes.
+ *
+ * This is the precise contract upstream IDS-Audit-tool encodes in
+ * `IdsXmlNode.cs` / `IdsRootElement.cs`: rather than running a generic
+ * XSD validator, the auditor walks each known element and rejects
+ * attributes/children that aren't part of that element's signature.
+ *
+ * The shapes encoded here mirror `Resources/XsdSchemas/ids.xsd`. When
+ * upstream evolves the IDS schema, regenerate this table from the XSD.
+ */
+import type { IDSAuditIssue } from '../types.js';
+/**
+ * Walks the parsed XML root and emits issues for any element/attribute
+ * outside the IDS XSD's shape. Re-uses xmldom/native DOMParser for the
+ * walk so we have access to the original element tree (the high-level
+ * `IDSDocument` shape can't tell us about extra attributes/elements
+ * stripped during parsing).
+ */
+export declare function runStructuralAudit(xml: string | ArrayBuffer): Promise<IDSAuditIssue[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/audit/structural/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/audit/structural/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA0MjD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,GAAG,WAAW,GACxB,OAAO,CAAC,aAAa,EAAE,CAAC,CAoB1B"}

package/dist/audit/structural/index.js

@@ -0,0 +1,441 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+const XS_NS = 'http://www.w3.org/2001/XMLSchema';
+// `xmlns`, `xmlns:*`, `xsi:*`, `xml:*` are tolerated as global hooks —
+// they're not specific to any IDS element but XML allows them anywhere.
+const TOLERATED_GLOBAL_ATTR_PREFIXES = new Set(['xmlns', 'xsi', 'xml']);
+const SHAPE_IDS = {
+    attrs: [],
+    children: ['info', 'specifications'],
+};
+const SHAPE_INFO = {
+    attrs: [],
+    children: [
+        'title',
+        'copyright',
+        'version',
+        'description',
+        'author',
+        'date',
+        'purpose',
+        'milestone',
+    ],
+};
+const SHAPE_SPECIFICATIONS = {
+    attrs: [],
+    children: ['specification'],
+};
+const SHAPE_SPECIFICATION = {
+    attrs: ['name', 'ifcVersion', 'identifier', 'description', 'instructions'],
+    requiredAttrs: ['name', 'ifcVersion'],
+    children: ['applicability', 'requirements'],
+};
+const SHAPE_APPLICABILITY = {
+    // The XSD attaches the xs:occurs attribute group → minOccurs, maxOccurs.
+    attrs: ['minOccurs', 'maxOccurs'],
+    children: [
+        'entity',
+        'partOf',
+        'classification',
+        'attribute',
+        'property',
+        'material',
+    ],
+};
+const SHAPE_REQUIREMENTS = {
+    attrs: ['description'],
+    children: [
+        'entity',
+        'partOf',
+        'classification',
+        'attribute',
+        'property',
+        'material',
+    ],
+};
+// Per-facet shapes in *applicability* context (no cardinality / uri /
+// instructions) vs *requirements* context (extension types per XSD).
+const SHAPE_ENTITY_BODY = {
+    attrs: [],
+    children: ['name', 'predefinedType'],
+};
+const SHAPE_ATTRIBUTE_BODY = {
+    attrs: [],
+    children: ['name', 'value'],
+};
+const SHAPE_CLASSIFICATION_BODY = {
+    attrs: [],
+    children: ['value', 'system'],
+};
+const SHAPE_PARTOF_BODY = {
+    attrs: ['relation'],
+    children: ['entity'],
+};
+const SHAPE_PROPERTY_BODY = {
+    attrs: ['dataType'],
+    children: ['propertySet', 'baseName', 'value'],
+};
+const SHAPE_MATERIAL_BODY = {
+    attrs: [],
+    children: ['value'],
+};
+// In *requirements* context, the schema extends each facet with
+// cardinality / instructions / uri (and entity gets just instructions).
+function shapeInRequirements(facetTag) {
+    const base = facetBaseShape(facetTag);
+    switch (facetTag.toLowerCase()) {
+        case 'entity':
+            return { ...base, attrs: [...base.attrs, 'instructions'] };
+        case 'partof':
+            return {
+                ...base,
+                attrs: [...base.attrs, 'cardinality', 'instructions'],
+            };
+        case 'attribute':
+            return {
+                ...base,
+                attrs: [...base.attrs, 'cardinality', 'instructions'],
+            };
+        case 'classification':
+        case 'property':
+        case 'material':
+            return {
+                ...base,
+                attrs: [...base.attrs, 'cardinality', 'instructions', 'uri'],
+            };
+        default:
+            return base;
+    }
+}
+function facetBaseShape(tag) {
+    // Tags arrive lowercased from `localName.toLowerCase()`. Match
+    // case-insensitively so `partof` resolves to the partOf shape.
+    switch (tag.toLowerCase()) {
+        case 'entity':
+            return SHAPE_ENTITY_BODY;
+        case 'attribute':
+            return SHAPE_ATTRIBUTE_BODY;
+        case 'classification':
+            return SHAPE_CLASSIFICATION_BODY;
+        case 'partof':
+            return SHAPE_PARTOF_BODY;
+        case 'property':
+            return SHAPE_PROPERTY_BODY;
+        case 'material':
+            return SHAPE_MATERIAL_BODY;
+        default:
+            return { attrs: [], children: [] };
+    }
+}
+// idsValue (used for <name>, <value>, <baseName>, <propertySet>,
+// <system>, <predefinedType>): choice of simpleValue OR xs:restriction.
+const SHAPE_IDS_VALUE = {
+    attrs: [],
+    children: ['simpleValue'],
+    xsChildren: ['restriction'],
+};
+const SHAPE_SIMPLE_VALUE = {
+    attrs: [],
+    children: [],
+    textOnly: true,
+};
+// xs:restriction child facets the IDS XSD admits.
+const XS_RESTRICTION_FACETS = [
+    'enumeration',
+    'pattern',
+    'minInclusive',
+    'maxInclusive',
+    'minExclusive',
+    'maxExclusive',
+    'length',
+    'minLength',
+    'maxLength',
+    'totalDigits',
+    'fractionDigits',
+    'whiteSpace',
+];
+const SHAPE_XS_RESTRICTION = {
+    attrs: ['base'],
+    children: [],
+    xsChildren: XS_RESTRICTION_FACETS,
+};
+// Each xs:enumeration/xs:pattern/etc carries a `value` attribute.
+const SHAPE_XS_FACET = {
+    attrs: ['value'],
+    children: [],
+    textOnly: true,
+};
+/**
+ * Walks the parsed XML root and emits issues for any element/attribute
+ * outside the IDS XSD's shape. Re-uses xmldom/native DOMParser for the
+ * walk so we have access to the original element tree (the high-level
+ * `IDSDocument` shape can't tell us about extra attributes/elements
+ * stripped during parsing).
+ */
+export async function runStructuralAudit(xml) {
+    const issues = [];
+    const xmlString = typeof xml === 'string' ? xml : new TextDecoder().decode(xml);
+    // BOM strip — same fix as parser.
+    const bomStripped = xmlString.charCodeAt(0) === 0xfeff ? xmlString.slice(1) : xmlString;
+    const parser = await getParser();
+    let doc;
+    try {
+        doc = parser.parseFromString(bomStripped, 'text/xml');
+    }
+    catch {
+        // Parse failure already surfaced by the permissive parser.
+        return issues;
+    }
+    const root = doc.documentElement;
+    if (!root || (root.localName ?? '').toLowerCase() !== 'ids')
+        return issues;
+    walkIds(root, issues);
+    return issues;
+}
+let parserPromise;
+function getParser() {
+    if (parserPromise)
+        return parserPromise;
+    parserPromise = (async () => {
+        const browserCtor = globalThis.DOMParser;
+        if (typeof browserCtor === 'function')
+            return new browserCtor();
+        // Hide the dynamic import behind a runtime-computed specifier so
+        // browser bundlers don't pull xmldom into the client bundle.
+        const moduleName = '@xmldom/xmldom';
+        const xmldom = (await import(/* @vite-ignore */ moduleName));
+        return new xmldom.DOMParser();
+    })();
+    return parserPromise;
+}
+function walkIds(el, issues) {
+    checkShape(el, SHAPE_IDS, 'ids', issues);
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        if (ln === 'info')
+            walkInfo(child, 'ids.info', issues);
+        else if (ln === 'specifications')
+            walkSpecifications(child, 'ids.specifications', issues);
+    }
+}
+function walkInfo(el, path, issues) {
+    checkShape(el, SHAPE_INFO, path, issues);
+    // Info children are leaf text nodes; don't recurse.
+}
+function walkSpecifications(el, path, issues) {
+    checkShape(el, SHAPE_SPECIFICATIONS, path, issues);
+    let i = 0;
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        if (ln === 'specification')
+            walkSpecification(child, `${path}.specification[${i++}]`, issues);
+    }
+}
+function walkSpecification(el, path, issues) {
+    checkShape(el, SHAPE_SPECIFICATION, path, issues);
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        if (ln === 'applicability')
+            walkFacetContainer(child, `${path}.applicability`, false, issues);
+        else if (ln === 'requirements')
+            walkFacetContainer(child, `${path}.requirements`, true, issues);
+    }
+}
+function walkFacetContainer(el, path, isRequirements, issues) {
+    checkShape(el, isRequirements ? SHAPE_REQUIREMENTS : SHAPE_APPLICABILITY, path, issues);
+    let i = 0;
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        walkFacet(child, ln, `${path}.facets[${i++}]`, isRequirements, issues);
+    }
+}
+function walkFacet(el, tag, path, inRequirements, issues) {
+    const shape = inRequirements
+        ? shapeInRequirements(tag)
+        : facetBaseShape(tag);
+    checkShape(el, shape, path, issues);
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        walkIdsValueOrFacet(child, ln, `${path}.${ln}`, inRequirements, issues);
+    }
+}
+function walkIdsValueOrFacet(el, tag, path, inRequirements, issues) {
+    switch (tag) {
+        case 'entity':
+            // `partOf > entity` is a nested entity facet (applicability shape).
+            walkFacet(el, 'entity', path, false, issues);
+            return;
+        case 'name':
+        case 'value':
+        case 'baseName':
+        case 'propertySet':
+        case 'system':
+        case 'predefinedType':
+            walkIdsValue(el, path, issues);
+            return;
+        default:
+            // Unknown child of a facet — already flagged by the parent's checkShape.
+            return;
+    }
+}
+function walkIdsValue(el, path, issues) {
+    checkShape(el, SHAPE_IDS_VALUE, path, issues);
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        if (ln === 'simpleValue') {
+            checkShape(child, SHAPE_SIMPLE_VALUE, `${path}.simpleValue`, issues);
+        }
+        else if (ln === 'restriction' &&
+            (child.namespaceURI === XS_NS || child.namespaceURI === null)) {
+            walkXsRestriction(child, `${path}.restriction`, issues);
+        }
+    }
+}
+function walkXsRestriction(el, path, issues) {
+    checkShape(el, SHAPE_XS_RESTRICTION, path, issues);
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        if (XS_RESTRICTION_FACETS.includes(ln)) {
+            checkShape(child, SHAPE_XS_FACET, `${path}.${ln}`, issues);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Shape enforcement primitives
+// ---------------------------------------------------------------------------
+function checkShape(el, shape, path, issues) {
+    // Attributes
+    const allowedAttrs = new Set(shape.attrs.map((a) => a.toLowerCase()));
+    for (const attr of Array.from(el.attributes ?? [])) {
+        if (isNamespaceAttribute(attr))
+            continue;
+        const name = attr.nodeName ?? '';
+        if (isToleratedGlobalAttr(name))
+            continue;
+        const rawLocalName = attr.localName ?? attr.nodeName ?? '';
+        // happy-dom sometimes keeps the prefix (e.g. `xsi:schemaLocation`)
+        // in localName with namespaceURI=null. Strip the prefix before
+        // matching shape rules.
+        const colonIdx = rawLocalName.indexOf(':');
+        const localName = colonIdx === -1
+            ? rawLocalName.toLowerCase()
+            : rawLocalName.slice(colonIdx + 1).toLowerCase();
+        const prefix = colonIdx === -1 ? '' : rawLocalName.slice(0, colonIdx).toLowerCase();
+        // `xmlns="..."` and `xmlns:*` declarations.
+        if (!localName || localName === 'xmlns' || prefix === 'xmlns')
+            continue;
+        // Globally tolerated XML/XSI attributes (e.g. xsi:schemaLocation,
+        // xml:lang) when the prefix is known.
+        if (TOLERATED_GLOBAL_ATTR_PREFIXES.has(prefix))
+            continue;
+        if (!allowedAttrs.has(localName)) {
+            issues.push({
+                severity: 'error',
+                code: 'E_XSD_STRUCTURE',
+                message: `unexpected attribute "${rawLocalName}" on <${el.localName}>`,
+                path,
+                detail: {
+                    attribute: rawLocalName,
+                    element: el.localName ?? '',
+                },
+            });
+        }
+    }
+    // Required attributes
+    if (shape.requiredAttrs) {
+        for (const req of shape.requiredAttrs) {
+            if (!hasAttribute(el, req)) {
+                issues.push({
+                    severity: 'error',
+                    code: 'E_XSD_REQUIRED_ATTR',
+                    message: `<${el.localName}> is missing required @${req}`,
+                    path,
+                    detail: { attribute: req, element: el.localName ?? '' },
+                });
+            }
+        }
+    }
+    // Children
+    const allowedChildren = new Set(shape.children.map((c) => c.toLowerCase()));
+    const allowedXsChildren = new Set((shape.xsChildren ?? []).map((c) => c.toLowerCase()));
+    for (const child of childElements(el)) {
+        const ln = (child.localName ?? '').toLowerCase();
+        const isXs = child.namespaceURI === XS_NS;
+        if (isXs) {
+            if (!allowedXsChildren.has(ln)) {
+                issues.push({
+                    severity: 'error',
+                    code: 'E_XSD_STRUCTURE',
+                    message: `unexpected XSD child <xs:${ln}> in <${el.localName}>`,
+                    path,
+                    detail: { child: `xs:${ln}`, parent: el.localName ?? '' },
+                });
+            }
+            continue;
+        }
+        if (!allowedChildren.has(ln)) {
+            issues.push({
+                severity: 'error',
+                code: 'E_XSD_STRUCTURE',
+                message: `unexpected child <${child.localName}> in <${el.localName}>`,
+                path,
+                detail: { child: child.localName ?? '', parent: el.localName ?? '' },
+            });
+        }
+    }
+    if (shape.textOnly) {
+        // Element should have no element children — text already checked
+        // implicitly by children loop above.
+    }
+}
+function hasAttribute(el, name) {
+    if (typeof el.hasAttribute === 'function' && el.hasAttribute(name))
+        return true;
+    // xmldom returns attribute objects under `attributes`; iterate.
+    for (const attr of Array.from(el.attributes ?? [])) {
+        const ln = (attr.localName ?? attr.nodeName ?? '').toLowerCase();
+        if (ln === name.toLowerCase())
+            return true;
+    }
+    return false;
+}
+function isToleratedGlobalAttr(name) {
+    if (!name)
+        return false;
+    if (name === 'xmlns')
+        return true;
+    const colon = name.indexOf(':');
+    if (colon === -1)
+        return false;
+    return TOLERATED_GLOBAL_ATTR_PREFIXES.has(name.slice(0, colon));
+}
+/**
+ * XML and XML-derived namespaces whose attributes are tolerated on any
+ * IDS element regardless of the element's shape — `xmlns`, `xml:lang`,
+ * `xsi:schemaLocation`, etc.
+ */
+const TOLERATED_ATTR_NAMESPACES = new Set([
+    'http://www.w3.org/2000/xmlns/',
+    'http://www.w3.org/XML/1998/namespace',
+    'http://www.w3.org/2001/XMLSchema-instance',
+]);
+function isNamespaceAttribute(attr) {
+    return (attr.namespaceURI !== null &&
+        TOLERATED_ATTR_NAMESPACES.has(attr.namespaceURI));
+}
+function childElements(el) {
+    // Some xmldom versions populate `children`; others only `childNodes`.
+    if (el.children && el.children.length !== undefined) {
+        return Array.from(el.children);
+    }
+    const out = [];
+    const nodes = el.childNodes ?? [];
+    for (let i = 0; i < nodes.length; i++) {
+        const n = nodes[i];
+        if (n && n.nodeType === 1)
+            out.push(n);
+    }
+    return out;
+}
+//# sourceMappingURL=index.js.map