@x12i/memorix-metadata 3.2.3 → 3.4.0

package/dist/validate.js

@@ -3,7 +3,7 @@ import { foldLegacyAbstractBindings } from "./fold-bindings.js";
 import { isForbiddenOperationalKindId, METADATA_KIND_IDS, } from "./kinds.js";
 import { validateMappingMap } from "@x12i/memorix-mapping";
 import { isPlatformInterfaceId, platformInterfaceForCategory, } from "./platform-interfaces.js";
-import { parentIdsOf } from "./types.js";
+import { ANALYTICS_PSEUDO_PROPERTIES, ANALYTICS_RESERVED_BUCKETS, parentIdsOf, } from "./types.js";
 function issue(path, code, message) {
     return { path, code, message };
 }
@@ -142,6 +142,26 @@ function validateObjectType(raw, path, issues) {
             requireNonEmptyString(o.contentTypes[i]?.id, `${path}.contentTypes[${i}].id`, issues);
         }
     }
+    if (o.fields !== undefined) {
+        if (!Array.isArray(o.fields)) {
+            issues.push(issue(`${path}.fields`, "META-TYPE", `${path}.fields must be an array`));
+        }
+        else {
+            for (let i = 0; i < o.fields.length; i++) {
+                const f = o.fields[i];
+                const fp = `${path}.fields[${i}]`;
+                if (!f || typeof f !== "object") {
+                    issues.push(issue(fp, "META-TYPE", `${fp} must be an object`));
+                    continue;
+                }
+                requireNonEmptyString(f.path, `${fp}.path`, issues);
+                requireNonEmptyString(f.valueType, `${fp}.valueType`, issues);
+                if (f.enum !== undefined) {
+                    validateEnumList(f.enum, `${fp}.enum`, issues);
+                }
+            }
+        }
+    }
 }
 function validateAbstractType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
@@ -167,6 +187,9 @@ function validateAbstractType(raw, path, issues) {
                 const p = a.properties[i];
                 requireNonEmptyString(p?.id, `${path}.properties[${i}].id`, issues);
                 requireNonEmptyString(p?.valueType, `${path}.properties[${i}].valueType`, issues);
+                if (p?.enum !== undefined) {
+                    validateEnumList(p.enum, `${path}.properties[${i}].enum`, issues);
+                }
             }
         }
     }
@@ -331,6 +354,423 @@ function validateWrite(raw, path, issues) {
     requireNonEmptyString(w.objectType, `${path}.objectType`, issues);
     requireNonEmptyString(w.contentType, `${path}.contentType`, issues);
 }
+function validateEnumList(value, path, issues) {
+    if (!Array.isArray(value) || value.length === 0) {
+        issues.push(issue(path, "META-ENUM", `${path} must be a non-empty string array`));
+        return;
+    }
+    const seen = new Set();
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (typeof v !== "string" || !v.trim()) {
+            issues.push(issue(`${path}[${i}]`, "META-ENUM", `${path}[${i}] must be a non-empty string (empty string is never a vocabulary member)`));
+            continue;
+        }
+        if (seen.has(v)) {
+            issues.push(issue(`${path}[${i}]`, "META-DUP", `${path} duplicate value "${v}"`));
+        }
+        seen.add(v);
+    }
+}
+function requirePredicate(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const p = raw;
+    requireNonEmptyString(p.property, `${path}.property`, issues);
+    const forms = ["equals", "in", "exists"].filter((k) => k in p);
+    if (forms.length !== 1) {
+        issues.push(issue(path, "META-REQUIRED", `${path} must set exactly one of equals, in, exists`));
+        return;
+    }
+    if (forms[0] === "in" && (!Array.isArray(p.in) || p.in.length === 0)) {
+        issues.push(issue(`${path}.in`, "META-TYPE", `${path}.in must be a non-empty array`));
+    }
+    if (forms[0] === "exists" && typeof p.exists !== "boolean") {
+        issues.push(issue(`${path}.exists`, "META-TYPE", `${path}.exists must be a boolean`));
+    }
+}
+function requireWhere(raw, path, issues) {
+    if (Array.isArray(raw)) {
+        if (raw.length === 0) {
+            issues.push(issue(path, "META-TYPE", `${path} must be a predicate or a non-empty array`));
+            return;
+        }
+        raw.forEach((p, i) => requirePredicate(p, `${path}[${i}]`, issues));
+        return;
+    }
+    requirePredicate(raw, path, issues);
+}
+function whereList(where) {
+    if (!where)
+        return [];
+    return Array.isArray(where) ? where : [where];
+}
+function rejectReservedBuckets(buckets, path, issues) {
+    if (!Array.isArray(buckets))
+        return;
+    for (let i = 0; i < buckets.length; i++) {
+        const b = buckets[i];
+        if (typeof b !== "string")
+            continue;
+        if (ANALYTICS_RESERVED_BUCKETS.includes(b.trim().toLowerCase())) {
+            issues.push(issue(`${path}[${i}]`, "META-ANALYTICS-BUCKET", `${path}[${i}] "${b}" is not a vocabulary member; use split.missing for absent values`));
+        }
+    }
+}
+function validateAnalytics(raw, path, issues) {
+    if (!raw || typeof raw !== "object") {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const a = raw;
+    requireNonEmptyString(a.id, `${path}.id`, issues);
+    requireNonEmptyString(a.name, `${path}.name`, issues);
+    if (a.scope === undefined) {
+        // organization-wide product
+    }
+    else if (!Array.isArray(a.scope) || a.scope.length !== 2) {
+        issues.push(issue(`${path}.scope`, "META-ANALYTICS-SCOPE", `${path}.scope must be an ordered pair of two properties`));
+    }
+    else {
+        for (let i = 0; i < 2; i++) {
+            const s = a.scope[i];
+            const sp = `${path}.scope[${i}]`;
+            if (!s || typeof s !== "object") {
+                issues.push(issue(sp, "META-TYPE", `${sp} must be an object`));
+                continue;
+            }
+            requireNonEmptyString(s.key, `${sp}.key`, issues);
+            requireNonEmptyString(s.abstractType, `${sp}.abstractType`, issues);
+            requireNonEmptyString(s.property, `${sp}.property`, issues);
+        }
+    }
+    if (a.clock !== undefined) {
+        if (!a.clock || typeof a.clock !== "object") {
+            issues.push(issue(`${path}.clock`, "META-TYPE", `${path}.clock must be an object`));
+        }
+        else {
+            requireNonEmptyString(a.clock.abstractType, `${path}.clock.abstractType`, issues);
+            requireNonEmptyString(a.clock.property, `${path}.clock.property`, issues);
+        }
+    }
+    if (!a.target || typeof a.target !== "object") {
+        issues.push(issue(`${path}.target`, "META-REQUIRED", `${path}.target is required`));
+    }
+    else {
+        requireNonEmptyString(a.target.objectType, `${path}.target.objectType`, issues);
+        requireNonEmptyString(a.target.contentType, `${path}.target.contentType`, issues);
+        requireNonEmptyString(a.target.recordId, `${path}.target.recordId`, issues);
+    }
+    if (a.history !== undefined) {
+        if (!a.history || typeof a.history !== "object") {
+            issues.push(issue(`${path}.history`, "META-TYPE", `${path}.history must be an object`));
+        }
+        else {
+            requireNonEmptyString(a.history.recordId, `${path}.history.recordId`, issues);
+            if (a.history.limit !== undefined) {
+                if (typeof a.history.limit !== "number" || !Number.isInteger(a.history.limit) || a.history.limit < 1) {
+                    issues.push(issue(`${path}.history.limit`, "META-TYPE", `${path}.history.limit must be a positive integer`));
+                }
+            }
+        }
+    }
+    if (a.measures !== undefined) {
+        if (!Array.isArray(a.measures)) {
+            issues.push(issue(`${path}.measures`, "META-TYPE", `${path}.measures must be an array`));
+        }
+        else {
+            requireUniqueIds(a.measures.map((m) => ({ id: m.key })), `${path}.measures`, issues);
+            for (let i = 0; i < a.measures.length; i++) {
+                const m = a.measures[i];
+                const mp = `${path}.measures[${i}]`;
+                requireNonEmptyString(m?.key, `${mp}.key`, issues);
+                requireNonEmptyString(m?.abstractType, `${mp}.abstractType`, issues);
+                if (!m?.kind ||
+                    !["count", "distinct", "sum", "mean", "max"].includes(m.kind)) {
+                    issues.push(issue(`${mp}.kind`, "META-ANALYTICS", `${mp}.kind must be count|distinct|sum|mean|max`));
+                }
+                if (m?.kind && m.kind !== "count" && !(typeof m.property === "string" && m.property.trim())) {
+                    issues.push(issue(`${mp}.property`, "META-REQUIRED", `${mp}.property is required for kind ${m.kind}`));
+                }
+                if (m?.where !== undefined)
+                    requireWhere(m.where, `${mp}.where`, issues);
+                if (m?.windows !== undefined) {
+                    if (m.kind !== "count") {
+                        issues.push(issue(`${mp}.windows`, "META-ANALYTICS", `${mp}.windows is only valid for kind count`));
+                    }
+                    if (!Array.isArray(m.windows) || m.windows.length === 0) {
+                        issues.push(issue(`${mp}.windows`, "META-TYPE", `${mp}.windows must be a non-empty array`));
+                    }
+                    else {
+                        for (let j = 0; j < m.windows.length; j++) {
+                            if (!["24h", "7d", "30d"].includes(m.windows[j])) {
+                                issues.push(issue(`${mp}.windows[${j}]`, "META-ANALYTICS", `${mp}.windows[${j}] must be 24h|7d|30d`));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (a.groups !== undefined) {
+        if (!Array.isArray(a.groups)) {
+            issues.push(issue(`${path}.groups`, "META-TYPE", `${path}.groups must be an array`));
+        }
+        else {
+            requireUniqueIds(a.groups.map((g) => ({ id: g?.key })), `${path}.groups`, issues);
+            for (let i = 0; i < a.groups.length; i++) {
+                const g = a.groups[i];
+                const gp = `${path}.groups[${i}]`;
+                requireNonEmptyString(g?.key, `${gp}.key`, issues);
+                requireNonEmptyString(g?.abstractType, `${gp}.abstractType`, issues);
+                requireNonEmptyString(g?.property, `${gp}.property`, issues);
+                const openBuckets = g?.property === "@datasource" && g.buckets === undefined;
+                if (!openBuckets) {
+                    if (!Array.isArray(g?.buckets) || g.buckets.length === 0) {
+                        issues.push(issue(`${gp}.buckets`, "META-REQUIRED", `${gp}.buckets must be a non-empty array`));
+                    }
+                    else {
+                        validateEnumList(g.buckets, `${gp}.buckets`, issues);
+                        rejectReservedBuckets(g.buckets, `${gp}.buckets`, issues);
+                    }
+                }
+                if (g?.subject !== undefined)
+                    requireNonEmptyString(g.subject, `${gp}.subject`, issues);
+                if (g?.where !== undefined)
+                    requireWhere(g.where, `${gp}.where`, issues);
+                if (g?.split !== undefined) {
+                    const s = g.split;
+                    const sp = `${gp}.split`;
+                    if (!s || typeof s !== "object") {
+                        issues.push(issue(sp, "META-TYPE", `${sp} must be an object`));
+                    }
+                    else {
+                        requireNonEmptyString(s.key, `${sp}.key`, issues);
+                        requireNonEmptyString(s.property, `${sp}.property`, issues);
+                        if (!Array.isArray(s.buckets) || s.buckets.length === 0) {
+                            issues.push(issue(`${sp}.buckets`, "META-REQUIRED", `${sp}.buckets must be a non-empty array`));
+                        }
+                        else {
+                            validateEnumList(s.buckets, `${sp}.buckets`, issues);
+                            rejectReservedBuckets(s.buckets, `${sp}.buckets`, issues);
+                        }
+                        if (s.missing !== undefined) {
+                            if (requireNonEmptyString(s.missing, `${sp}.missing`, issues)) {
+                                if (Array.isArray(s.buckets) && s.buckets.includes(s.missing)) {
+                                    issues.push(issue(`${sp}.missing`, "META-ANALYTICS-BUCKET", `${sp}.missing "${s.missing}" must not also be a declared bucket`));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (a.derived !== undefined) {
+        if (!Array.isArray(a.derived)) {
+            issues.push(issue(`${path}.derived`, "META-TYPE", `${path}.derived must be an array`));
+        }
+        else {
+            requireUniqueIds(a.derived.map((d) => ({ id: d?.key })), `${path}.derived`, issues);
+            for (let i = 0; i < a.derived.length; i++) {
+                const d = a.derived[i];
+                const dp = `${path}.derived[${i}]`;
+                requireNonEmptyString(d?.key, `${dp}.key`, issues);
+                if (!d?.op || !["sum", "difference", "ratio"].includes(d.op)) {
+                    issues.push(issue(`${dp}.op`, "META-ANALYTICS", `${dp}.op must be sum|difference|ratio`));
+                }
+                if (!Array.isArray(d?.terms) || d.terms.length === 0) {
+                    issues.push(issue(`${dp}.terms`, "META-REQUIRED", `${dp}.terms must be a non-empty array`));
+                    continue;
+                }
+                d.terms.forEach((t, j) => requireNonEmptyString(t, `${dp}.terms[${j}]`, issues));
+                if (d.op === "ratio" && d.terms.length !== 2) {
+                    issues.push(issue(`${dp}.terms`, "META-ANALYTICS", `${dp}.terms must have exactly two terms for ratio`));
+                }
+                if (d.op === "difference" && d.terms.length < 2) {
+                    issues.push(issue(`${dp}.terms`, "META-ANALYTICS", `${dp}.terms must have at least two terms for difference`));
+                }
+            }
+        }
+    }
+    if (a.ratios !== undefined) {
+        if (!Array.isArray(a.ratios)) {
+            issues.push(issue(`${path}.ratios`, "META-TYPE", `${path}.ratios must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.ratios.length; i++) {
+                const r = a.ratios[i];
+                const rp = `${path}.ratios[${i}]`;
+                requireNonEmptyString(r?.key, `${rp}.key`, issues);
+                requireNonEmptyString(r?.numerator, `${rp}.numerator`, issues);
+                requireNonEmptyString(r?.denominator, `${rp}.denominator`, issues);
+            }
+        }
+    }
+    if (a.splits !== undefined) {
+        if (!Array.isArray(a.splits)) {
+            issues.push(issue(`${path}.splits`, "META-TYPE", `${path}.splits must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.splits.length; i++) {
+                const s = a.splits[i];
+                const sp = `${path}.splits[${i}]`;
+                requireNonEmptyString(s?.key, `${sp}.key`, issues);
+                requireNonEmptyString(s?.abstractType, `${sp}.abstractType`, issues);
+                requireNonEmptyString(s?.property, `${sp}.property`, issues);
+                requireNonEmptyString(s?.totalKey, `${sp}.totalKey`, issues);
+                requireNonEmptyString(s?.subsetKey, `${sp}.subsetKey`, issues);
+                if (!Array.isArray(s?.buckets) || s.buckets.length === 0) {
+                    issues.push(issue(`${sp}.buckets`, "META-REQUIRED", `${sp}.buckets must be a non-empty array`));
+                }
+                else {
+                    validateEnumList(s.buckets, `${sp}.buckets`, issues);
+                }
+                if (s?.subset !== undefined)
+                    requirePredicate(s.subset, `${sp}.subset`, issues);
+                else
+                    issues.push(issue(`${sp}.subset`, "META-REQUIRED", `${sp}.subset is required`));
+            }
+        }
+    }
+    if (a.unwinds !== undefined) {
+        if (!Array.isArray(a.unwinds)) {
+            issues.push(issue(`${path}.unwinds`, "META-TYPE", `${path}.unwinds must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.unwinds.length; i++) {
+                const u = a.unwinds[i];
+                const up = `${path}.unwinds[${i}]`;
+                requireNonEmptyString(u?.key, `${up}.key`, issues);
+                requireNonEmptyString(u?.abstractType, `${up}.abstractType`, issues);
+                requireNonEmptyString(u?.arrayProperty, `${up}.arrayProperty`, issues);
+                if (!Array.isArray(u?.columns) || u.columns.length === 0) {
+                    issues.push(issue(`${up}.columns`, "META-REQUIRED", `${up}.columns must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < u.columns.length; j++) {
+                        requireNonEmptyString(u.columns[j]?.key, `${up}.columns[${j}].key`, issues);
+                        requireNonEmptyString(u.columns[j]?.path, `${up}.columns[${j}].path`, issues);
+                    }
+                }
+            }
+        }
+    }
+    if (a.leaders !== undefined) {
+        if (!Array.isArray(a.leaders)) {
+            issues.push(issue(`${path}.leaders`, "META-TYPE", `${path}.leaders must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.leaders.length; i++) {
+                const l = a.leaders[i];
+                const lp = `${path}.leaders[${i}]`;
+                requireNonEmptyString(l?.key, `${lp}.key`, issues);
+                requireNonEmptyString(l?.abstractType, `${lp}.abstractType`, issues);
+                requireNonEmptyString(l?.idProperty, `${lp}.idProperty`, issues);
+                requireNonEmptyString(l?.labelProperty, `${lp}.labelProperty`, issues);
+                if (l?.countOf !== undefined) {
+                    if (!l.countOf || typeof l.countOf !== "object") {
+                        issues.push(issue(`${lp}.countOf`, "META-TYPE", `${lp}.countOf must be an object`));
+                    }
+                    else {
+                        requireNonEmptyString(l.countOf.abstractType, `${lp}.countOf.abstractType`, issues);
+                        requireNonEmptyString(l.countOf.property, `${lp}.countOf.property`, issues);
+                        if (l.countOf.where !== undefined)
+                            requireWhere(l.countOf.where, `${lp}.countOf.where`, issues);
+                    }
+                }
+                if (l?.sort === undefined && l?.countOf !== undefined) {
+                    // ranked by count
+                }
+                else if (!Array.isArray(l?.sort) || l.sort.length === 0) {
+                    issues.push(issue(`${lp}.sort`, "META-REQUIRED", `${lp}.sort must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < l.sort.length; j++) {
+                        requireNonEmptyString(l.sort[j]?.property, `${lp}.sort[${j}].property`, issues);
+                    }
+                }
+            }
+        }
+    }
+    if (a.coverage !== undefined) {
+        if (!Array.isArray(a.coverage)) {
+            issues.push(issue(`${path}.coverage`, "META-TYPE", `${path}.coverage must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.coverage.length; i++) {
+                const c = a.coverage[i];
+                const cp = `${path}.coverage[${i}]`;
+                requireNonEmptyString(c?.key, `${cp}.key`, issues);
+                requireNonEmptyString(c?.abstractType, `${cp}.abstractType`, issues);
+                if (typeof c?.expected === "number") {
+                    if (!Number.isFinite(c.expected) || c.expected < 0) {
+                        issues.push(issue(`${cp}.expected`, "META-TYPE", `${cp}.expected must be a non-negative number`));
+                    }
+                }
+                else if (c?.expected && typeof c.expected === "object" && "measure" in c.expected) {
+                    requireNonEmptyString(c.expected.measure, `${cp}.expected.measure`, issues);
+                }
+                else {
+                    issues.push(issue(`${cp}.expected`, "META-REQUIRED", `${cp}.expected must be a number or { measure }`));
+                }
+                if (c?.where !== undefined)
+                    requireWhere(c.where, `${cp}.where`, issues);
+            }
+        }
+    }
+    if (a.deltas !== undefined) {
+        if (!Array.isArray(a.deltas)) {
+            issues.push(issue(`${path}.deltas`, "META-TYPE", `${path}.deltas must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.deltas.length; i++) {
+                requireNonEmptyString(a.deltas[i]?.key, `${path}.deltas[${i}].key`, issues);
+                requireNonEmptyString(a.deltas[i]?.measure, `${path}.deltas[${i}].measure`, issues);
+            }
+        }
+    }
+    if (a.transitions !== undefined) {
+        if (!Array.isArray(a.transitions)) {
+            issues.push(issue(`${path}.transitions`, "META-TYPE", `${path}.transitions must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.transitions.length; i++) {
+                const t = a.transitions[i];
+                const tp = `${path}.transitions[${i}]`;
+                requireNonEmptyString(t?.key, `${tp}.key`, issues);
+                requireNonEmptyString(t?.abstractType, `${tp}.abstractType`, issues);
+                requireNonEmptyString(t?.property, `${tp}.property`, issues);
+            }
+        }
+    }
+    if (a.trends !== undefined) {
+        if (!Array.isArray(a.trends)) {
+            issues.push(issue(`${path}.trends`, "META-TYPE", `${path}.trends must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.trends.length; i++) {
+                const t = a.trends[i];
+                const tp = `${path}.trends[${i}]`;
+                requireNonEmptyString(t?.key, `${tp}.key`, issues);
+                requireNonEmptyString(t?.label, `${tp}.label`, issues);
+                requireNonEmptyString(t?.measure, `${tp}.measure`, issues);
+                if (!Array.isArray(t?.windows) || t.windows.length === 0) {
+                    issues.push(issue(`${tp}.windows`, "META-REQUIRED", `${tp}.windows must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < t.windows.length; j++) {
+                        if (!["snapshots", "7d", "30d"].includes(t.windows[j])) {
+                            issues.push(issue(`${tp}.windows[${j}]`, "META-ANALYTICS", `${tp}.windows[${j}] must be snapshots|7d|30d`));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
 function validateSource(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
         issues.push(issue(path, "META-TYPE", `${path} must be an object`));
@@ -708,6 +1148,166 @@ function validateReferenceIntegrity(pack, issues) {
             issues.push(issue(`writes/${w.id}.objectType`, "META-REF-OBJECT", `write references unknown object type "${w.objectType}"`));
         }
     }
+    const absProps = new Map();
+    for (const abs of pack.abstractTypes) {
+        const props = new Map();
+        for (const p of abs.properties ?? []) {
+            if (p?.id)
+                props.set(p.id, { enum: p.enum });
+        }
+        absProps.set(abs.id, props);
+    }
+    const measureKeysByAnalytics = new Map();
+    for (const an of pack.analytics ?? []) {
+        const measureKeys = new Set((an.measures ?? []).map((m) => m.key).filter(Boolean));
+        measureKeysByAnalytics.set(an.id, measureKeys);
+        const checkAbsProp = (abstractType, property, path) => {
+            if (!abstractIds.has(abstractType)) {
+                issues.push(issue(path, "META-REF-ABSTRACT", `analytics references unknown abstract "${abstractType}"`));
+                return null;
+            }
+            if (ANALYTICS_PSEUDO_PROPERTIES.includes(property))
+                return null;
+            const props = absProps.get(abstractType);
+            if (props && props.size > 0 && !props.has(property)) {
+                issues.push(issue(path, "META-REF-PROP", `analytics references unknown property "${property}" on "${abstractType}"`));
+                return null;
+            }
+            return props?.get(property) ?? null;
+        };
+        for (const s of an.scope ?? []) {
+            if (s?.abstractType && s?.property) {
+                checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.scope`);
+            }
+        }
+        if (an.clock?.abstractType && an.clock.property) {
+            checkAbsProp(an.clock.abstractType, an.clock.property, `analytics/${an.id}.clock`);
+        }
+        if (an.target?.objectType && !objectTypeIds.has(an.target.objectType)) {
+            issues.push(issue(`analytics/${an.id}.target.objectType`, "META-REF-OBJECT", `analytics target references unknown object type "${an.target.objectType}"`));
+        }
+        for (const m of an.measures ?? []) {
+            if (m.abstractType && !abstractIds.has(m.abstractType)) {
+                issues.push(issue(`analytics/${an.id}.measures/${m.key}`, "META-REF-ABSTRACT", `analytics references unknown abstract "${m.abstractType}"`));
+            }
+            if (m.property && m.abstractType) {
+                checkAbsProp(m.abstractType, m.property, `analytics/${an.id}.measures/${m.key}.property`);
+            }
+            for (const p of whereList(m.where)) {
+                if (p?.property && m.abstractType) {
+                    checkAbsProp(m.abstractType, p.property, `analytics/${an.id}.measures/${m.key}.where`);
+                }
+            }
+        }
+        const checkBucketsInEnum = (prop, buckets, path, label) => {
+            if (!prop?.enum || !Array.isArray(buckets))
+                return;
+            for (const b of buckets) {
+                if (!prop.enum.includes(b)) {
+                    issues.push(issue(path, "META-ENUM-BUCKET", `bucket "${b}" is not in enum for ${label}`));
+                }
+            }
+        };
+        const groupBuckets = new Map();
+        for (const g of an.groups ?? []) {
+            const prop = g.abstractType && g.property
+                ? checkAbsProp(g.abstractType, g.property, `analytics/${an.id}.groups/${g.key}`)
+                : null;
+            checkBucketsInEnum(prop, g.buckets, `analytics/${an.id}.groups/${g.key}.buckets`, `${g.abstractType}.${g.property}`);
+            if (g.key)
+                groupBuckets.set(g.key, Array.isArray(g.buckets) ? new Set(g.buckets) : "open");
+            for (const p of whereList(g.where)) {
+                if (p?.property && g.abstractType) {
+                    checkAbsProp(g.abstractType, p.property, `analytics/${an.id}.groups/${g.key}.where`);
+                }
+            }
+            if (g.split?.property && g.abstractType) {
+                const splitProp = checkAbsProp(g.abstractType, g.split.property, `analytics/${an.id}.groups/${g.key}.split`);
+                checkBucketsInEnum(splitProp, g.split.buckets, `analytics/${an.id}.groups/${g.key}.split.buckets`, `${g.abstractType}.${g.split.property}`);
+            }
+        }
+        const ratioKeys = new Set((an.ratios ?? []).map((r) => r.key).filter(Boolean));
+        const derivedSoFar = new Set();
+        for (const d of an.derived ?? []) {
+            for (const term of d.terms ?? []) {
+                if (typeof term !== "string" || !term)
+                    continue;
+                let known = measureKeys.has(term) || ratioKeys.has(term) || derivedSoFar.has(term);
+                for (let dot = term.indexOf("."); !known && dot > 0; dot = term.indexOf(".", dot + 1)) {
+                    const buckets = groupBuckets.get(term.slice(0, dot));
+                    known = buckets === "open" || Boolean(buckets?.has(term.slice(dot + 1)));
+                }
+                if (!known) {
+                    issues.push(issue(`analytics/${an.id}.derived/${d.key}`, "META-REF-MEASURE", `derived term "${term}" is not a measure, ratio, earlier derived key, or group.bucket`));
+                }
+            }
+            if (d.key)
+                derivedSoFar.add(d.key);
+        }
+        for (const s of an.splits ?? []) {
+            const prop = s.abstractType && s.property
+                ? checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.splits/${s.key}`)
+                : null;
+            if (prop?.enum && Array.isArray(s.buckets)) {
+                for (const b of s.buckets) {
+                    if (!prop.enum.includes(b)) {
+                        issues.push(issue(`analytics/${an.id}.splits/${s.key}.buckets`, "META-ENUM-BUCKET", `bucket "${b}" is not in enum for ${s.abstractType}.${s.property}`));
+                    }
+                }
+            }
+        }
+        for (const u of an.unwinds ?? []) {
+            if (u.abstractType && u.arrayProperty) {
+                checkAbsProp(u.abstractType, u.arrayProperty, `analytics/${an.id}.unwinds/${u.key}`);
+            }
+        }
+        for (const l of an.leaders ?? []) {
+            if (l.abstractType) {
+                checkAbsProp(l.abstractType, l.idProperty, `analytics/${an.id}.leaders/${l.key}.idProperty`);
+                checkAbsProp(l.abstractType, l.labelProperty, `analytics/${an.id}.leaders/${l.key}.labelProperty`);
+            }
+            if (l.countOf?.abstractType && l.countOf.property) {
+                checkAbsProp(l.countOf.abstractType, l.countOf.property, `analytics/${an.id}.leaders/${l.key}.countOf`);
+                for (const p of whereList(l.countOf.where)) {
+                    if (p?.property) {
+                        checkAbsProp(l.countOf.abstractType, p.property, `analytics/${an.id}.leaders/${l.key}.countOf.where`);
+                    }
+                }
+            }
+        }
+        for (const c of an.coverage ?? []) {
+            if (c.abstractType && !abstractIds.has(c.abstractType)) {
+                issues.push(issue(`analytics/${an.id}.coverage/${c.key}`, "META-REF-ABSTRACT", `analytics references unknown abstract "${c.abstractType}"`));
+            }
+            for (const p of whereList(c.where)) {
+                if (p?.property && c.abstractType) {
+                    checkAbsProp(c.abstractType, p.property, `analytics/${an.id}.coverage/${c.key}.where`);
+                }
+            }
+            if (typeof c.expected === "object" && c.expected?.measure && !measureKeys.has(c.expected.measure)) {
+                issues.push(issue(`analytics/${an.id}.coverage/${c.key}.expected`, "META-REF-MEASURE", `coverage expected measure "${c.expected.measure}" unknown`));
+            }
+        }
+        for (const d of an.deltas ?? []) {
+            if (d.measure && !measureKeys.has(d.measure)) {
+                issues.push(issue(`analytics/${an.id}.deltas/${d.key}`, "META-REF-MEASURE", `delta references unknown measure "${d.measure}"`));
+            }
+        }
+        for (const t of an.trends ?? []) {
+            if (t.measure && !measureKeys.has(t.measure)) {
+                issues.push(issue(`analytics/${an.id}.trends/${t.key}`, "META-REF-MEASURE", `trend references unknown measure "${t.measure}"`));
+            }
+        }
+        for (const r of an.ratios ?? []) {
+            if (r.numerator && !measureKeys.has(r.numerator)) {
+                issues.push(issue(`analytics/${an.id}.ratios/${r.key}`, "META-REF-MEASURE", `ratio numerator "${r.numerator}" unknown`));
+            }
+            if (r.denominator && !measureKeys.has(r.denominator)) {
+                issues.push(issue(`analytics/${an.id}.ratios/${r.key}`, "META-REF-MEASURE", `ratio denominator "${r.denominator}" unknown`));
+            }
+        }
+    }
+    void measureKeysByAnalytics;
     for (const p of pack.pipelines) {
         for (const step of p.steps) {
             if (step.sourceId && !sourceIds.has(step.sourceId)) {
@@ -823,6 +1423,7 @@ export function validateMetadataPack(input, opts) {
         ["services", pack.services, validateService],
         ["pipelines", pack.pipelines, validatePipeline],
         ["schedules", pack.schedules, validateSchedule],
+        ["analytics", pack.analytics ?? [], validateAnalytics],
         ["kindDeclarations", pack.kindDeclarations ?? [], validateKindDeclaration],
     ];
     for (const [name, value, validator] of arrays) {