@cspeach/cli 1.1.18 → 1.1.20

package/dist/tools/fiori/metadata/audit.js

@@ -0,0 +1,605 @@
+/**
+ * L1-1 — `auditMetadata`: machine truth about one entity set of a published
+ * V4 service. Pure: no network, no filesystem. The tool handler (tools.ts)
+ * does the fetching and hands the documents in.
+ *
+ * What the real documents taught us (fixtures/CAPTURE.md) and this file obeys:
+ *  - Vocabulary aliases are `SAP__common`, `SAP__UI`, … never `Common.`/`UI.`.
+ *    Nothing here matches a term by text: the EDMX parser resolves each
+ *    document's own aliases, and the annotation converter re-keys everything
+ *    under its default aliases (`annotations.Common.Label`, `annotations.UI.LineItem`).
+ *  - Draft action names are fully qualified, and `DraftRoot`'s property ORDER
+ *    differs between documents → read by property name, never by position.
+ *  - A RAP V4 main document carries `ValueListReferences`, not `ValueList`.
+ *    The mapping is `SAP__common.ValueListMapping` in the REFERENCED document,
+ *    targeted at `SAP__ParentService.<EntityType>/<Property>` — which the parser
+ *    unaliases to the parent's namespace, i.e. the main entity type's own
+ *    fully-qualified name.
+ *
+ * One named function per concern — resolveLabel, resolveText, resolveValueHelp,
+ * isCoded, readDraft, readLineItem, readCapabilities, buildFlags — so the
+ * `coded` exclusions can be found without reading the whole file.
+ */
+import { parse, merge } from '@sap-ux/edmx-parser';
+import { convert } from '@sap-ux/annotation-converter';
+import { resolveReferenceUrl } from './references.js';
+const COMMON = 'com.sap.vocabularies.Common.v1';
+const DRAFT_BOOKKEEPING = new Set(['IsActiveEntity', 'HasDraftEntity', 'HasActiveEntity']);
+// ---------------------------------------------------------------------------
+// Small value readers. The converter hands some primitives back as boxed
+// String / Boolean objects (so they can carry nested annotations).
+// ---------------------------------------------------------------------------
+function str(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v === 'string')
+        return v;
+    if (v instanceof String)
+        return v.valueOf();
+    if (typeof v === 'object' && typeof v.path === 'string')
+        return v.path;
+    if (typeof v === 'object' && typeof v.value === 'string')
+        return v.value;
+    return undefined;
+}
+/** Literal false (plain or boxed) → false; absent → `dflt`; anything else (true, a path) → true. */
+function flag(v, dflt) {
+    if (v === undefined || v === null)
+        return dflt;
+    if (v === false)
+        return false;
+    if (v instanceof Boolean)
+        return v.valueOf();
+    if (v === 'false')
+        return false;
+    return true;
+}
+/** Every value of a UI term on the set and the type, qualified or not (`LineItem`, `LineItem#Q`). */
+function uiTerms(set, et, term) {
+    const out = [];
+    for (const holder of [et?.annotations?.UI, set?.annotations?.UI]) {
+        if (!holder)
+            continue;
+        for (const key of Object.keys(holder)) {
+            if (key === '_keys')
+                continue;
+            if (key === term)
+                out.push({ value: holder[key] });
+            else if (key.startsWith(`${term}#`))
+                out.push({ qualifier: key.slice(term.length + 1), value: holder[key] });
+        }
+    }
+    return out;
+}
+function simplePath(v) {
+    const p = str(v?.path !== undefined ? v.path : v?.value);
+    return p && !p.includes('/') ? p : undefined;
+}
+// ---------------------------------------------------------------------------
+// Entity set selection
+// ---------------------------------------------------------------------------
+function pickEntitySet(converted, wanted) {
+    const sets = converted.entitySets ?? [];
+    if (wanted) {
+        const hit = sets.find((s) => s.name === wanted);
+        if (!hit) {
+            throw new Error(`entity set "${wanted}" not found — the service has: ${sets.map((s) => s.name).join(', ') || '(none)'}`);
+        }
+        return hit;
+    }
+    // The brief's default is the first set with a UI.LineItem. Two of the three
+    // captured services carry NO UI annotations at all (no metadata extension),
+    // and `I_DraftAdministrativeData` is listed first — so the fallback is the
+    // draft root, then the first set that is not draft bookkeeping.
+    const withLineItem = sets.find((s) => uiTerms(s, s.entityType, 'LineItem').length > 0);
+    const draftRoot = sets.find((s) => s.annotations?.Common?.DraftRoot || s.entityType?.annotations?.Common?.DraftRoot);
+    const business = sets.find((s) => !/DraftAdministrativeData/.test(String(s.entityType?.name ?? s.name)));
+    const chosen = withLineItem ?? draftRoot ?? business ?? sets[0];
+    if (!chosen)
+        throw new Error('the service $metadata declares no entity set');
+    return chosen;
+}
+// ---------------------------------------------------------------------------
+// Line item, field groups, selection fields, header — and "rendered"
+// ---------------------------------------------------------------------------
+function columnKind(type) {
+    const short = type?.slice(type.lastIndexOf('.') + 1);
+    switch (short) {
+        case 'DataField':
+        case 'DataFieldForAction':
+        case 'DataFieldForAnnotation':
+        case 'DataFieldWithUrl':
+            return short;
+        default:
+            return 'other';
+    }
+}
+function readLineItem(set, et) {
+    const li = et?.annotations?.UI?.LineItem ?? set?.annotations?.UI?.LineItem ?? [];
+    return li.map((rec, position) => {
+        const col = { kind: columnKind(str(rec?.$Type)), position };
+        const property = simplePath(rec?.Value);
+        if (property)
+            col.property = property;
+        const label = str(rec?.Label);
+        if (label !== undefined)
+            col.label = label;
+        return col;
+    });
+}
+function readFieldGroups(set, et) {
+    return uiTerms(set, et, 'FieldGroup').map(({ qualifier, value }) => {
+        const fg = {
+            properties: (value?.Data ?? []).map((d) => simplePath(d?.Value)).filter((p) => !!p),
+        };
+        if (qualifier !== undefined)
+            fg.qualifier = qualifier;
+        const label = str(value?.Label);
+        if (label !== undefined)
+            fg.label = label;
+        return fg;
+    });
+}
+function readSelectionFields(set, et) {
+    const sf = uiTerms(set, et, 'SelectionFields').find((t) => t.qualifier === undefined)?.value ?? [];
+    return sf.map((x) => simplePath(x)).filter((p) => !!p);
+}
+function readHeaderInfo(set, et) {
+    const h = et?.annotations?.UI?.HeaderInfo ?? set?.annotations?.UI?.HeaderInfo;
+    if (!h)
+        return undefined;
+    const out = {};
+    const typeName = str(h.TypeName);
+    const typeNamePlural = str(h.TypeNamePlural);
+    const title = simplePath(h.Title?.Value) ?? str(h.Title?.Value);
+    const description = simplePath(h.Description?.Value) ?? str(h.Description?.Value);
+    if (typeName !== undefined)
+        out.typeName = typeName;
+    if (typeNamePlural !== undefined)
+        out.typeNamePlural = typeNamePlural;
+    if (title !== undefined)
+        out.title = title;
+    if (description !== undefined)
+        out.description = description;
+    return out;
+}
+/** DataField-like records of every LineItem / FieldGroup / Identification, qualified or not. */
+function renderingDataFields(set, et) {
+    const out = [];
+    for (const t of uiTerms(set, et, 'LineItem'))
+        out.push(...(t.value ?? []));
+    for (const t of uiTerms(set, et, 'Identification'))
+        out.push(...(t.value ?? []));
+    for (const t of uiTerms(set, et, 'FieldGroup'))
+        out.push(...(t.value?.Data ?? []));
+    return out;
+}
+function renderedProperties(set, et) {
+    const out = new Set();
+    for (const df of renderingDataFields(set, et)) {
+        const p = simplePath(df?.Value);
+        if (p)
+            out.add(p);
+    }
+    for (const t of uiTerms(set, et, 'SelectionFields')) {
+        for (const x of (t.value ?? [])) {
+            const p = simplePath(x);
+            if (p)
+                out.add(p);
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Labels and texts
+// ---------------------------------------------------------------------------
+function resolveLabel(prop, dataFields) {
+    const common = str(prop?.annotations?.Common?.Label);
+    if (common !== undefined && common !== '')
+        return { label: common, labelSource: 'Common.Label' };
+    for (const df of dataFields) {
+        if (simplePath(df?.Value) !== prop.name)
+            continue;
+        const l = str(df?.Label);
+        if (l !== undefined && l !== '')
+            return { label: l, labelSource: 'DataField.Label' };
+    }
+    return { labelSource: 'none' };
+}
+function arrangementOf(v) {
+    const s = str(v);
+    if (!s)
+        return undefined;
+    const member = s.slice(s.lastIndexOf('/') + 1);
+    return ['TextFirst', 'TextLast', 'TextOnly', 'TextSeparate'].find((m) => m === member);
+}
+function resolveText(prop, et) {
+    const text = prop?.annotations?.Common?.Text;
+    const path = str(text);
+    if (!path)
+        return undefined;
+    const arrangement = arrangementOf(text?.annotations?.UI?.TextArrangement) ??
+        arrangementOf(prop?.annotations?.UI?.TextArrangement) ??
+        arrangementOf(et?.annotations?.UI?.TextArrangement) ??
+        'TextFirst';
+    return { path, arrangement };
+}
+// ---------------------------------------------------------------------------
+// Value helps
+// ---------------------------------------------------------------------------
+const PARAM_KINDS = {
+    ValueListParameterIn: 'In',
+    ValueListParameterOut: 'Out',
+    ValueListParameterInOut: 'InOut',
+    ValueListParameterDisplayOnly: 'DisplayOnly',
+    ValueListParameterFilterOnly: 'FilterOnly',
+    ValueListParameterConstant: 'Constant',
+};
+function param(type, localProperty, valueListProperty, constant) {
+    const kind = type ? PARAM_KINDS[type.slice(type.lastIndexOf('.') + 1)] : undefined;
+    if (!kind || valueListProperty === undefined)
+        return undefined;
+    const p = { kind, valueListProperty };
+    if (localProperty !== undefined && kind !== 'Constant' && kind !== 'DisplayOnly')
+        p.localProperty = localProperty;
+    if (constant !== undefined)
+        p.constant = constant;
+    return p;
+}
+/** A converted (typed) Common.ValueList / ValueListMapping record → Mapping. */
+function mappingFromConverted(rec) {
+    const collectionPath = str(rec?.CollectionPath);
+    if (!collectionPath)
+        return undefined;
+    const parameters = (rec?.Parameters ?? [])
+        .map((p) => param(str(p?.$Type), str(p?.LocalDataProperty), str(p?.ValueListProperty), str(p?.Constant)))
+        .filter((p) => !!p);
+    return { collectionPath, parameters };
+}
+const rawScalar = (v) => v && v.type && typeof v[v.type] === 'string' ? v[v.type] : undefined;
+const rawProps = (rec) => new Map((rec?.propertyValues ?? []).map((pv) => [pv.name, pv.value]));
+/** A raw (parser-level) ValueListMapping record, from a referenced document → Mapping. */
+function mappingFromRaw(rec) {
+    const pv = rawProps(rec);
+    const collectionPath = rawScalar(pv.get('CollectionPath'));
+    if (!collectionPath)
+        return undefined;
+    const params = pv.get('Parameters');
+    const items = (params && Array.isArray(params['Collection']) ? params['Collection'] : []);
+    const parameters = items
+        .map((it) => {
+        const p = rawProps(it);
+        return param(it?.type, rawScalar(p.get('LocalDataProperty')), rawScalar(p.get('ValueListProperty')), rawScalar(p.get('Constant')));
+    })
+        .filter((p) => !!p);
+    return { collectionPath, parameters };
+}
+/**
+ * In a referenced value-help document: the ValueListMapping (or ValueList)
+ * annotated on OUR property. The document declares our namespace under the
+ * `SAP__ParentService` alias; the parser has already unaliased the target, so
+ * it reads `<main namespace>.<EntityType>/<Property>`.
+ */
+function mappingInReferencedDoc(xml, target) {
+    let raw;
+    try {
+        raw = parse(xml, 'valueHelp');
+    }
+    catch {
+        return { fixed: false };
+    }
+    let mapping;
+    let fixed = false;
+    for (const list of Object.values(raw.schema.annotations)) {
+        for (const t of list) {
+            if (t.target !== target)
+                continue;
+            for (const ann of t.annotations) {
+                if (!mapping && (ann.term === `${COMMON}.ValueListMapping` || ann.term === `${COMMON}.ValueList`)) {
+                    mapping = mappingFromRaw(ann.record);
+                }
+                if (ann.term === `${COMMON}.ValueListWithFixedValues`) {
+                    fixed = ann.value === undefined ? true : rawScalar(ann.value) !== 'false' && ann.value?.Bool !== false;
+                }
+            }
+        }
+    }
+    return { mapping, fixed };
+}
+function toValueHelp(propName, mapping, kind, fixedValues, ref) {
+    const keyish = mapping.parameters.filter((p) => p.kind === 'Out' || p.kind === 'InOut');
+    const key = keyish.find((p) => p.localProperty === propName) ?? keyish[0] ?? mapping.parameters[0];
+    const text = mapping.parameters.find((p) => p.kind === 'DisplayOnly') ??
+        keyish.find((p) => p !== key && p.localProperty !== propName);
+    const vh = {
+        kind: fixedValues ? 'fixed' : kind,
+        collectionPath: mapping.collectionPath,
+        keyProperty: key?.valueListProperty ?? '',
+        parameters: mapping.parameters,
+        fixedValues,
+    };
+    if (ref) {
+        vh.referenceUrl = ref.referenceUrl;
+        vh.resolvedPath = ref.resolvedPath;
+    }
+    if (text)
+        vh.textProperty = text.valueListProperty;
+    return vh;
+}
+function resolveValueHelp(prop, et, input) {
+    const common = prop?.annotations?.Common ?? {};
+    const fixedHere = flag(common.ValueListWithFixedValues, false);
+    const inlineRec = common.ValueList ??
+        common.ValueListMapping ??
+        Object.keys(common)
+            .filter((k) => k.startsWith('ValueList#') || k.startsWith('ValueListMapping#'))
+            .map((k) => common[k])[0];
+    if (inlineRec) {
+        const mapping = mappingFromConverted(inlineRec);
+        if (mapping)
+            return { declared: true, valueHelp: toValueHelp(prop.name, mapping, 'inline', fixedHere) };
+    }
+    const urls = (common.ValueListReferences ?? []).map(str).filter((u) => !!u);
+    if (urls.length === 0)
+        return { declared: !!inlineRec };
+    const target = `${et.fullyQualifiedName}/${prop.name}`;
+    let firstProblem;
+    for (const url of urls) {
+        const doc = input.referenceDocs.get(url);
+        if (doc === undefined) {
+            const status = input.referenceFailures?.get(url);
+            firstProblem ??= { url, status: status ?? 'not fetched' };
+            continue;
+        }
+        const { mapping, fixed } = mappingInReferencedDoc(doc, target);
+        if (!mapping) {
+            firstProblem ??= { url, status: 'no mapping' };
+            continue;
+        }
+        return {
+            declared: true,
+            valueHelp: toValueHelp(prop.name, mapping, 'references', fixedHere || fixed, {
+                referenceUrl: url,
+                resolvedPath: resolveReferenceUrl(input.servicePath, url),
+            }),
+        };
+    }
+    return { declared: true, unreachable: firstProblem };
+}
+/** Every `Criticality` path anywhere under the entity's UI annotations, plus property-level UI.Criticality. */
+function collectCriticalityTargets(set, et) {
+    const out = new Set();
+    const seen = new Set();
+    const walk = (v, depth) => {
+        if (!v || typeof v !== 'object' || seen.has(v) || depth > 8)
+            return;
+        seen.add(v);
+        if (Array.isArray(v)) {
+            for (const x of v)
+                walk(x, depth + 1);
+            return;
+        }
+        for (const [k, x] of Object.entries(v)) {
+            if (k === 'Criticality') {
+                const p = simplePath(x);
+                if (p)
+                    out.add(p);
+                continue;
+            }
+            if (k.startsWith('$') || k === 'fullyQualifiedName' || k === 'CollectionPathTarget')
+                continue;
+            walk(x, depth + 1);
+        }
+    };
+    walk(et?.annotations?.UI, 0);
+    walk(set?.annotations?.UI, 0);
+    for (const p of (et?.entityProperties ?? [])) {
+        const c = simplePath(p?.annotations?.UI?.Criticality);
+        if (c)
+            out.add(c);
+    }
+    return out;
+}
+function collectUnitTargets(et) {
+    const out = new Set();
+    for (const p of (et?.entityProperties ?? [])) {
+        for (const term of ['Unit', 'ISOCurrency']) {
+            const t = simplePath(p?.annotations?.Measures?.[term]);
+            if (t)
+                out.add(t);
+        }
+    }
+    return out;
+}
+function isCoded(prop, audit, hasValueHelp, ctx) {
+    // Shape: a short string code, or a small integer that has a value help.
+    const shortString = audit.type === 'Edm.String' && audit.maxLength !== undefined && audit.maxLength >= 1 && audit.maxLength <= 4;
+    const smallInt = (audit.type === 'Edm.Byte' || audit.type === 'Edm.Int16') && hasValueHelp;
+    if (!(shortString || smallInt))
+        return false;
+    if (!audit.rendered)
+        return false;
+    // Exclusions.
+    if (flag(prop?.annotations?.UI?.Hidden, false))
+        return false; // UI.Hidden (literal or dynamic)
+    if (ctx.criticalityTargets.has(prop.name))
+        return false; // another field's Criticality
+    const common = prop?.annotations?.Common ?? {};
+    if (flag(common.IsUnit, false) || flag(common.IsCurrency, false))
+        return false; // Common.IsUnit / IsCurrency
+    if (ctx.unitTargets.has(prop.name))
+        return false; // Measures.Unit / ISOCurrency target
+    if (flag(common.IsLanguageIdentifier, false))
+        return false; // Common.IsLanguageIdentifier
+    if (audit.isKey)
+        return false; // keys
+    if (DRAFT_BOOKKEEPING.has(prop.name) || ctx.draftAdminEntity)
+        return false; // draft bookkeeping
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Draft and capabilities
+// ---------------------------------------------------------------------------
+function readDraft(set, et) {
+    const root = set?.annotations?.Common?.DraftRoot ?? et?.annotations?.Common?.DraftRoot;
+    const node = set?.annotations?.Common?.DraftNode ?? et?.annotations?.Common?.DraftNode;
+    const rec = root ?? node;
+    const actions = {};
+    if (rec) {
+        // By property NAME: DraftRoot's order differs between real documents.
+        const edit = str(rec.EditAction);
+        const activate = str(rec.ActivationAction);
+        const prepare = str(rec.PreparationAction);
+        const discard = str(rec.DiscardAction);
+        if (edit)
+            actions.edit = edit;
+        if (activate)
+            actions.activate = activate;
+        if (prepare)
+            actions.prepare = prepare;
+        if (discard)
+            actions.discard = discard;
+    }
+    return { root: !!root, actions };
+}
+function readCapabilities(set) {
+    const cap = set?.annotations?.Capabilities ?? {};
+    return {
+        insertable: flag(cap.InsertRestrictions?.Insertable, true),
+        updatable: flag(cap.UpdateRestrictions?.Updatable, true),
+        deletable: flag(cap.DeleteRestrictions?.Deletable, true),
+        searchable: flag(cap.SearchRestrictions?.Searchable, true),
+    };
+}
+// ---------------------------------------------------------------------------
+// Flags
+// ---------------------------------------------------------------------------
+function unreachableFix(property, u) {
+    const outcome = typeof u.status === 'number'
+        ? `HTTP ${u.status}`
+        : u.status === 'no mapping'
+            ? `HTTP 200, but it carries no ValueList for this field`
+            : 'not fetched';
+    return `Value-help service for \`${property}\` is not reachable (\`${u.url}\` → ${outcome}) — republish the binding.`;
+}
+function buildFlags(props, valueHelps) {
+    const flags = [];
+    for (const p of props) {
+        const vh = valueHelps.get(p.name);
+        if (p.rendered && p.labelSource === 'none') {
+            flags.push({
+                property: p.name,
+                code: 'no-label',
+                fix: `Property \`${p.name}\` is rendered but has no label. Add \`@EndUserText.label\` in the CDS view, ` +
+                    'or a `Label` in the metadata extension.',
+            });
+        }
+        if (p.coded && !p.text) {
+            flags.push({
+                property: p.name,
+                code: 'coded-without-text',
+                fix: `Coded field \`${p.name}\` has no \`Common.Text\`. Add a text/value-help view and ` +
+                    '`@ObjectModel.text.element` plus `@UI.textArrangement: #TEXT_ONLY`.',
+            });
+        }
+        // A declared-but-unreachable value help is reported as unreachable, not missing.
+        if (p.coded && !p.valueHelp && !vh?.declared) {
+            flags.push({
+                property: p.name,
+                code: 'coded-without-value-help',
+                fix: `Coded field \`${p.name}\` has no value help. Add \`@Consumption.valueHelpDefinition\` ` +
+                    'pointing at the code-list view.',
+            });
+        }
+        if (vh?.unreachable) {
+            flags.push({ property: p.name, code: 'value-help-unreachable', fix: unreachableFix(p.name, vh.unreachable) });
+        }
+    }
+    return flags;
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/** Pure. No network, no filesystem. */
+export function auditMetadata(input) {
+    const main = parse(input.mainXml, 'serviceFile');
+    const raw = input.localAnnotationsXml ? merge(main, parse(input.localAnnotationsXml, 'localAnnotations')) : main;
+    const converted = convert(raw);
+    const set = pickEntitySet(converted, input.entitySet);
+    const et = set.entityType;
+    const keys = new Set((et?.keys ?? []).map((k) => k.name));
+    const rendered = renderedProperties(set, et);
+    const dataFields = renderingDataFields(set, et);
+    const ctx = {
+        criticalityTargets: collectCriticalityTargets(set, et),
+        unitTargets: collectUnitTargets(et),
+        draftAdminEntity: /DraftAdministrativeData/.test(String(et?.name ?? '')),
+    };
+    const valueHelps = new Map();
+    const properties = (et?.entityProperties ?? []).map((prop) => {
+        const vh = resolveValueHelp(prop, et, input);
+        valueHelps.set(prop.name, vh);
+        const base = {
+            name: prop.name,
+            type: String(prop.type),
+            nullable: prop.nullable !== false,
+            isKey: keys.has(prop.name),
+            rendered: rendered.has(prop.name),
+            labelSource: 'none',
+            coded: false,
+        };
+        if (typeof prop.maxLength === 'number')
+            base.maxLength = prop.maxLength;
+        // L1-5b: present only when true, so a property without either annotation
+        // audits exactly as before. A dynamic FieldControl (a Path) is not static
+        // "mandatory".
+        if (flag(prop?.annotations?.Core?.Computed, false))
+            base.computed = true;
+        const fc = prop?.annotations?.Common?.FieldControl;
+        if (typeof fc === 'string' ? /\/Mandatory$/.test(fc) : /\/Mandatory$/.test(String(fc?.valueOf?.() ?? ''))) {
+            base.mandatory = true;
+        }
+        const { label, labelSource } = resolveLabel(prop, dataFields);
+        base.labelSource = labelSource;
+        if (label !== undefined)
+            base.label = label;
+        const text = resolveText(prop, et);
+        if (text)
+            base.text = text;
+        if (vh.valueHelp)
+            base.valueHelp = vh.valueHelp;
+        base.coded = isCoded(prop, base, vh.declared, ctx);
+        return base;
+    });
+    // Every reference the caller fetched (or failed to), in document order.
+    const fetchedReferences = [];
+    const seen = new Set();
+    const record = (url, status) => {
+        if (seen.has(url))
+            return;
+        seen.add(url);
+        fetchedReferences.push({ url, resolvedPath: resolveReferenceUrl(input.servicePath, url), status });
+    };
+    for (const url of input.referenceDocs.keys())
+        record(url, 200);
+    for (const [url, status] of input.referenceFailures ?? [])
+        record(url, status);
+    const audit = {
+        servicePath: input.servicePath,
+        entitySet: set.name,
+        entityType: et?.name,
+        language: input.language ?? 'EN',
+        properties,
+        draft: readDraft(set, et),
+        lineItem: readLineItem(set, et),
+        selectionFields: readSelectionFields(set, et),
+        fieldGroups: readFieldGroups(set, et),
+        capabilities: readCapabilities(set),
+        flags: buildFlags(properties, valueHelps),
+        fetchedReferences,
+    };
+    const headerInfo = readHeaderInfo(set, et);
+    if (headerInfo)
+        audit.headerInfo = headerInfo;
+    return audit;
+}