@x12i/memorix-metadata 3.3.0 → 3.4.1

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 };
 }
@@ -110,6 +110,219 @@ function validateAgent(raw, path, issues) {
         }
     }
 }
+function validateContentTypeProfile(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-REQUIRED", `${path} is required (declare allowSnapshotBuckets)`));
+        return;
+    }
+    const profile = raw;
+    if (typeof profile.allowSnapshotBuckets !== "boolean") {
+        issues.push(issue(`${path}.allowSnapshotBuckets`, "META-REQUIRED", `${path}.allowSnapshotBuckets must be a boolean`));
+    }
+}
+function validateContentTypeDiscriminator(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const disc = raw;
+    requireNonEmptyString(disc.path, `${path}.path`, issues);
+    if (disc.required !== undefined && typeof disc.required !== "boolean") {
+        issues.push(issue(`${path}.required`, "META-TYPE", `${path}.required must be a boolean`));
+    }
+    if (disc.defaultValue !== undefined &&
+        (typeof disc.defaultValue !== "string" || !disc.defaultValue.trim())) {
+        issues.push(issue(`${path}.defaultValue`, "META-TYPE", `${path}.defaultValue must be a non-empty string`));
+    }
+}
+function validateFieldMappings(raw, path, issues) {
+    if (!Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an array`));
+        return;
+    }
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        const itemPath = `${path}[${i}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            issues.push(issue(itemPath, "META-TYPE", `${itemPath} must be an object`));
+            continue;
+        }
+        const profile = item;
+        requireNonEmptyString(profile.id, `${itemPath}.id`, issues);
+        requireNonEmptyString(profile.namespace, `${itemPath}.namespace`, issues);
+        if (profile.format !== "memorix-field-map/1") {
+            issues.push(issue(`${itemPath}.format`, "META-TYPE", `${itemPath}.format must be memorix-field-map/1`));
+        }
+        if (!profile.fieldMap || typeof profile.fieldMap !== "object" || Array.isArray(profile.fieldMap)) {
+            issues.push(issue(`${itemPath}.fieldMap`, "META-TYPE", `${itemPath}.fieldMap must be an object`));
+        }
+    }
+}
+const PRESENTATION_TABS = new Set(["always", "whenPresent", "hidden"]);
+const ORIGIN_PRODUCERS = new Set(["model", "code", "mixed"]);
+const ORIGIN_USES = new Set(["always", "conditional"]);
+const FUNCTION_KINDS = new Set(["spine", "threads"]);
+function validateContentTypePresentation(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const presentation = raw;
+    if (presentation.label !== undefined && typeof presentation.label !== "string") {
+        issues.push(issue(`${path}.label`, "META-TYPE", `${path}.label must be a string`));
+    }
+    if (presentation.order !== undefined && typeof presentation.order !== "number") {
+        issues.push(issue(`${path}.order`, "META-TYPE", `${path}.order must be a number`));
+    }
+    if (presentation.tab !== undefined &&
+        (typeof presentation.tab !== "string" || !PRESENTATION_TABS.has(presentation.tab))) {
+        issues.push(issue(`${path}.tab`, "META-TYPE", `${path}.tab must be always, whenPresent, or hidden`));
+    }
+    if (presentation.values === undefined)
+        return;
+    if (!Array.isArray(presentation.values)) {
+        issues.push(issue(`${path}.values`, "META-TYPE", `${path}.values must be an array`));
+        return;
+    }
+    for (let i = 0; i < presentation.values.length; i++) {
+        const value = presentation.values[i];
+        const valuePath = `${path}.values[${i}]`;
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            issues.push(issue(valuePath, "META-TYPE", `${valuePath} must be an object`));
+            continue;
+        }
+        requireNonEmptyString(value.value, `${valuePath}.value`, issues);
+    }
+}
+function validateContentTypeOrigin(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const origin = raw;
+    if (origin.producer !== undefined &&
+        (typeof origin.producer !== "string" || !ORIGIN_PRODUCERS.has(origin.producer))) {
+        issues.push(issue(`${path}.producer`, "META-TYPE", `${path}.producer must be model, code, or mixed`));
+    }
+    if (origin.use !== undefined && (typeof origin.use !== "string" || !ORIGIN_USES.has(origin.use))) {
+        issues.push(issue(`${path}.use`, "META-TYPE", `${path}.use must be always or conditional`));
+    }
+    if (origin.record !== undefined && (typeof origin.record !== "string" || !origin.record.trim())) {
+        issues.push(issue(`${path}.record`, "META-TYPE", `${path}.record must be a non-empty string`));
+    }
+}
+function validateFunctionRead(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const read = raw;
+    for (const key of ["objectType", "contentType", "recordId", "template"]) {
+        const value = read[key];
+        if (value !== undefined && (typeof value !== "string" || !value.trim())) {
+            issues.push(issue(`${path}.${key}`, "META-TYPE", `${path}.${key} must be a non-empty string`));
+        }
+    }
+    if (read.sameSubject !== undefined && typeof read.sameSubject !== "boolean") {
+        issues.push(issue(`${path}.sameSubject`, "META-TYPE", `${path}.sameSubject must be a boolean`));
+    }
+}
+function validateObjectTypeFunctions(raw, path, issues) {
+    if (!Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an array`));
+        return;
+    }
+    requireUniqueIds(raw, path, issues);
+    const templates = new Map();
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        const itemPath = `${path}[${i}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            issues.push(issue(itemPath, "META-TYPE", `${itemPath} must be an object`));
+            continue;
+        }
+        const fn = item;
+        requireNonEmptyString(fn.id, `${itemPath}.id`, issues);
+        requireNonEmptyString(fn.question, `${itemPath}.question`, issues);
+        requireNonEmptyString(fn.page, `${itemPath}.page`, issues);
+        if (typeof fn.composes !== "boolean") {
+            issues.push(issue(`${itemPath}.composes`, "META-TYPE", `${itemPath}.composes must be a boolean`));
+        }
+        if (typeof fn.pageStory !== "boolean") {
+            issues.push(issue(`${itemPath}.pageStory`, "META-TYPE", `${itemPath}.pageStory must be a boolean`));
+        }
+        if (fn.template !== undefined) {
+            if (typeof fn.template !== "string" || !fn.template.trim()) {
+                issues.push(issue(`${itemPath}.template`, "META-TYPE", `${itemPath}.template must be a non-empty string`));
+            }
+            else {
+                const template = fn.template.trim();
+                const previous = templates.get(template);
+                if (previous !== undefined) {
+                    issues.push(issue(`${itemPath}.template`, "META-STORY-TEMPLATE", `template "${template}" is already used by ${path}[${previous}]`));
+                }
+                else {
+                    templates.set(template, i);
+                }
+            }
+        }
+        if (fn.kind !== undefined && (typeof fn.kind !== "string" || !FUNCTION_KINDS.has(fn.kind))) {
+            issues.push(issue(`${itemPath}.kind`, "META-TYPE", `${itemPath}.kind must be spine or threads`));
+        }
+        if (!Array.isArray(fn.reads)) {
+            issues.push(issue(`${itemPath}.reads`, "META-TYPE", `${itemPath}.reads must be an array`));
+        }
+        else {
+            for (let r = 0; r < fn.reads.length; r++) {
+                validateFunctionRead(fn.reads[r], `${itemPath}.reads[${r}]`, issues);
+            }
+        }
+    }
+}
+function storyPresentationTemplates(contentTypes) {
+    if (!Array.isArray(contentTypes))
+        return [];
+    const templates = [];
+    for (const contentType of contentTypes) {
+        if (!contentType || typeof contentType !== "object" || Array.isArray(contentType))
+            continue;
+        const spec = contentType;
+        if (spec.id !== "story")
+            continue;
+        const values = spec.presentation?.values;
+        if (!Array.isArray(values))
+            continue;
+        for (const value of values) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const raw = value.value;
+            if (typeof raw === "string" && raw.trim())
+                templates.push(raw.trim());
+        }
+    }
+    return templates;
+}
+function assertStoryFunctionTemplates(contentTypes, functions, path, issues) {
+    const counts = new Map();
+    for (const fn of functions) {
+        if (!fn || typeof fn !== "object" || Array.isArray(fn))
+            continue;
+        const template = fn.template;
+        if (typeof template !== "string" || !template.trim())
+            continue;
+        const key = template.trim();
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const seen = new Set();
+    for (const template of storyPresentationTemplates(contentTypes)) {
+        if (seen.has(template))
+            continue;
+        seen.add(template);
+        if ((counts.get(template) ?? 0) === 0) {
+            issues.push(issue(`${path}.functions`, "META-STORY-TEMPLATE", `story template "${template}" must have exactly one function on this object type`));
+        }
+    }
+}
 function validateObjectType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
         issues.push(issue(path, "META-TYPE", `${path} must be an object`));
@@ -134,12 +347,53 @@ function validateObjectType(raw, path, issues) {
             }
         }
     }
+    let declaredContentTypes = new Set();
     if (!Array.isArray(o.contentTypes) || o.contentTypes.length === 0) {
         issues.push(issue(`${path}.contentTypes`, "META-REQUIRED", `${path}.contentTypes must be a non-empty array`));
     }
     else {
+        let leadingCount = 0;
         for (let i = 0; i < o.contentTypes.length; i++) {
-            requireNonEmptyString(o.contentTypes[i]?.id, `${path}.contentTypes[${i}].id`, issues);
+            const ct = o.contentTypes[i];
+            const cp = `${path}.contentTypes[${i}]`;
+            if (!ct || typeof ct !== "object" || Array.isArray(ct)) {
+                issues.push(issue(cp, "META-TYPE", `${cp} must be an object`));
+                continue;
+            }
+            if (requireNonEmptyString(ct.id, `${cp}.id`, issues)) {
+                declaredContentTypes.add(ct.id);
+            }
+            validateContentTypeProfile(ct.profile, `${cp}.profile`, issues);
+            if (ct.required !== undefined && typeof ct.required !== "boolean") {
+                issues.push(issue(`${cp}.required`, "META-TYPE", `${cp}.required must be a boolean`));
+            }
+            else if (ct.required === true) {
+                requireNonEmptyString(ct.requiredReason, `${cp}.requiredReason`, issues);
+            }
+            if (ct.leading !== undefined) {
+                if (typeof ct.leading !== "boolean") {
+                    issues.push(issue(`${cp}.leading`, "META-TYPE", `${cp}.leading must be a boolean`));
+                }
+                else if (ct.leading) {
+                    leadingCount += 1;
+                }
+            }
+            if (ct.discriminator !== undefined) {
+                validateContentTypeDiscriminator(ct.discriminator, `${cp}.discriminator`, issues);
+            }
+            if (ct.fieldMappings !== undefined) {
+                validateFieldMappings(ct.fieldMappings, `${cp}.fieldMappings`, issues);
+            }
+            if (ct.presentation !== undefined) {
+                validateContentTypePresentation(ct.presentation, `${cp}.presentation`, issues);
+            }
+            if (ct.origin !== undefined) {
+                validateContentTypeOrigin(ct.origin, `${cp}.origin`, issues);
+            }
+        }
+        requireUniqueIds(o.contentTypes, `${path}.contentTypes`, issues);
+        if (leadingCount > 1) {
+            issues.push(issue(`${path}.contentTypes`, "META-LEADING", `object type "${typeof o.id === "string" ? o.id : ""}" has more than one leading content type`));
         }
     }
     if (o.fields !== undefined) {
@@ -156,12 +410,26 @@ function validateObjectType(raw, path, issues) {
                 }
                 requireNonEmptyString(f.path, `${fp}.path`, issues);
                 requireNonEmptyString(f.valueType, `${fp}.valueType`, issues);
+                if (f.contentType !== undefined) {
+                    if (typeof f.contentType !== "string" || !f.contentType.trim()) {
+                        issues.push(issue(`${fp}.contentType`, "META-TYPE", `${fp}.contentType must be a non-empty string`));
+                    }
+                    else if (!declaredContentTypes.has(f.contentType)) {
+                        issues.push(issue(`${fp}.contentType`, "META-REF-CONTENT", `content type "${f.contentType}" is not registered on this object type`));
+                    }
+                }
                 if (f.enum !== undefined) {
                     validateEnumList(f.enum, `${fp}.enum`, issues);
                 }
             }
         }
     }
+    if (o.functions !== undefined) {
+        validateObjectTypeFunctions(o.functions, `${path}.functions`, issues);
+        if (Array.isArray(o.functions)) {
+            assertStoryFunctionTemplates(o.contentTypes, o.functions, path, issues);
+        }
+    }
 }
 function validateAbstractType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
@@ -373,15 +641,73 @@ function validateEnumList(value, path, issues) {
     }
 }
 function requirePredicate(raw, path, issues) {
-    if (!raw || typeof raw !== "object") {
+    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);
-    if (!("equals" in p)) {
-        issues.push(issue(`${path}.equals`, "META-REQUIRED", `${path}.equals is required`));
+    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`));
+        }
+    }
+}
+/** A measure, group, or split names an abstract or a stored object type and content type. */
+function requireRecordSelector(node, path, issues) {
+    const abs = typeof node?.abstractType === "string" && node.abstractType.trim().length > 0;
+    const ot = typeof node?.objectType === "string" && node.objectType.trim().length > 0;
+    const ct = typeof node?.contentType === "string" && node.contentType.trim().length > 0;
+    if (abs && (ot || ct)) {
+        issues.push(issue(path, "META-ANALYTICS", `${path} names abstractType or objectType and contentType, not both`));
+        return;
     }
+    if (abs)
+        return;
+    if (ot && ct)
+        return;
+    if (!ot && !ct) {
+        issues.push(issue(path, "META-REQUIRED", `${path} must name abstractType or objectType and contentType`));
+        return;
+    }
+    if (!ot)
+        requireNonEmptyString(node?.objectType, `${path}.objectType`, issues);
+    if (!ct)
+        requireNonEmptyString(node?.contentType, `${path}.contentType`, issues);
 }
 function validateAnalytics(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
@@ -391,7 +717,10 @@ function validateAnalytics(raw, path, issues) {
     const a = raw;
     requireNonEmptyString(a.id, `${path}.id`, issues);
     requireNonEmptyString(a.name, `${path}.name`, issues);
-    if (!Array.isArray(a.scope) || a.scope.length !== 2) {
+    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 {
@@ -447,7 +776,7 @@ function validateAnalytics(raw, path, issues) {
                 const m = a.measures[i];
                 const mp = `${path}.measures[${i}]`;
                 requireNonEmptyString(m?.key, `${mp}.key`, issues);
-                requireNonEmptyString(m?.abstractType, `${mp}.abstractType`, issues);
+                requireRecordSelector(m, mp, 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`));
@@ -456,7 +785,22 @@ function validateAnalytics(raw, path, issues) {
                     issues.push(issue(`${mp}.property`, "META-REQUIRED", `${mp}.property is required for kind ${m.kind}`));
                 }
                 if (m?.where !== undefined)
-                    requirePredicate(m.where, `${mp}.where`, issues);
+                    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`));
+                            }
+                        }
+                    }
+                }
             }
         }
     }
@@ -465,17 +809,78 @@ function validateAnalytics(raw, path, issues) {
             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);
+                requireRecordSelector(g, gp, issues);
                 requireNonEmptyString(g?.property, `${gp}.property`, issues);
-                if (!Array.isArray(g?.buckets) || g.buckets.length === 0) {
-                    issues.push(issue(`${gp}.buckets`, "META-REQUIRED", `${gp}.buckets must be a non-empty array`));
+                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);
+                    }
                 }
-                else {
-                    validateEnumList(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`));
                 }
             }
         }
@@ -503,7 +908,7 @@ function validateAnalytics(raw, path, issues) {
                 const s = a.splits[i];
                 const sp = `${path}.splits[${i}]`;
                 requireNonEmptyString(s?.key, `${sp}.key`, issues);
-                requireNonEmptyString(s?.abstractType, `${sp}.abstractType`, issues);
+                requireRecordSelector(s, sp, issues);
                 requireNonEmptyString(s?.property, `${sp}.property`, issues);
                 requireNonEmptyString(s?.totalKey, `${sp}.totalKey`, issues);
                 requireNonEmptyString(s?.subsetKey, `${sp}.subsetKey`, issues);
@@ -555,7 +960,21 @@ function validateAnalytics(raw, path, issues) {
                 requireNonEmptyString(l?.abstractType, `${lp}.abstractType`, issues);
                 requireNonEmptyString(l?.idProperty, `${lp}.idProperty`, issues);
                 requireNonEmptyString(l?.labelProperty, `${lp}.labelProperty`, issues);
-                if (!Array.isArray(l?.sort) || l.sort.length === 0) {
+                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 {
@@ -588,7 +1007,7 @@ function validateAnalytics(raw, path, issues) {
                     issues.push(issue(`${cp}.expected`, "META-REQUIRED", `${cp}.expected must be a number or { measure }`));
                 }
                 if (c?.where !== undefined)
-                    requirePredicate(c.where, `${cp}.where`, issues);
+                    requireWhere(c.where, `${cp}.where`, issues);
             }
         }
     }
@@ -1028,6 +1447,30 @@ function validateReferenceIntegrity(pack, issues) {
         }
         absProps.set(abs.id, props);
     }
+    const otContent = new Map();
+    const otFields = new Map();
+    const snapshotBucketsByContentType = new Map();
+    for (const ot of pack.objectTypes) {
+        otContent.set(ot.id, new Set((ot.contentTypes ?? []).map((c) => c.id).filter(Boolean)));
+        for (const c of ot.contentTypes ?? []) {
+            const flag = c?.profile?.allowSnapshotBuckets;
+            if (!c?.id || typeof flag !== "boolean")
+                continue;
+            const previous = snapshotBucketsByContentType.get(c.id);
+            if (previous !== undefined && previous !== flag) {
+                issues.push(issue(`objectTypes/${ot.id}.contentTypes`, "META-CT-PROFILE", `content type "${c.id}" must declare allowSnapshotBuckets the same way on every object type`));
+            }
+            else {
+                snapshotBucketsByContentType.set(c.id, flag);
+            }
+        }
+        const fields = new Map();
+        for (const f of ot.fields ?? []) {
+            if (f?.path)
+                fields.set(f.path, { enum: f.enum });
+        }
+        otFields.set(ot.id, fields);
+    }
     const measureKeysByAnalytics = new Map();
     for (const an of pack.analytics ?? []) {
         const measureKeys = new Set((an.measures ?? []).map((m) => m.key).filter(Boolean));
@@ -1037,6 +1480,8 @@ function validateReferenceIntegrity(pack, issues) {
                 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}"`));
@@ -1044,6 +1489,26 @@ function validateReferenceIntegrity(pack, issues) {
             }
             return props?.get(property) ?? null;
         };
+        const namesContent = (node) => Boolean((node.objectType?.trim() || node.contentType?.trim()) && !node.abstractType?.trim());
+        const checkStored = (node, path) => {
+            const objectType = node.objectType?.trim() ?? "";
+            const contentType = node.contentType?.trim() ?? "";
+            if (!objectTypeIds.has(objectType)) {
+                issues.push(issue(path, "META-REF-OBJECT", `analytics references unknown object type "${objectType}"`));
+                return;
+            }
+            if (!otContent.get(objectType)?.has(contentType)) {
+                issues.push(issue(path, "META-REF-CONTENT", `content type "${contentType}" is not registered on "${objectType}"`));
+            }
+        };
+        const storedEnum = (objectType, property) => {
+            if (!objectType || !property)
+                return null;
+            if (ANALYTICS_PSEUDO_PROPERTIES.includes(property))
+                return null;
+            const en = otFields.get(objectType)?.get(property)?.enum;
+            return en?.length ? { enum: en } : null;
+        };
         for (const s of an.scope ?? []) {
             if (s?.abstractType && s?.property) {
                 checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.scope`);
@@ -1056,29 +1521,90 @@ function validateReferenceIntegrity(pack, issues) {
             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 (namesContent(m)) {
+                checkStored(m, `analytics/${an.id}.measures/${m.key}`);
+                continue;
+            }
             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`);
             }
-            if (m.where?.property && m.abstractType) {
-                checkAbsProp(m.abstractType, m.where.property, `analytics/${an.id}.measures/${m.key}.where`);
+            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 ?? []) {
+            if (namesContent(g)) {
+                checkStored(g, `analytics/${an.id}.groups/${g.key}`);
+                checkBucketsInEnum(storedEnum(g.objectType, g.property), g.buckets, `analytics/${an.id}.groups/${g.key}.buckets`, `${g.objectType}.${g.property}`);
+                if (g.key)
+                    groupBuckets.set(g.key, Array.isArray(g.buckets) ? new Set(g.buckets) : "open");
+                if (g.split?.property) {
+                    checkBucketsInEnum(storedEnum(g.objectType, g.split.property), g.split.buckets, `analytics/${an.id}.groups/${g.key}.split.buckets`, `${g.objectType}.${g.split.property}`);
+                }
+                continue;
+            }
             const prop = g.abstractType && g.property
                 ? checkAbsProp(g.abstractType, g.property, `analytics/${an.id}.groups/${g.key}`)
                 : null;
-            if (prop?.enum && Array.isArray(g.buckets)) {
-                for (const b of g.buckets) {
-                    if (!prop.enum.includes(b)) {
-                        issues.push(issue(`analytics/${an.id}.groups/${g.key}.buckets`, "META-ENUM-BUCKET", `bucket "${b}" is not in enum for ${g.abstractType}.${g.property}`));
-                    }
+            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 ?? []) {
+            if (namesContent(s)) {
+                checkStored(s, `analytics/${an.id}.splits/${s.key}`);
+                const prop = storedEnum(s.objectType, s.property);
+                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.objectType}.${s.property}`));
+                        }
+                    }
+                }
+                continue;
+            }
             const prop = s.abstractType && s.property
                 ? checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.splits/${s.key}`)
                 : null;
@@ -1100,13 +1626,23 @@ function validateReferenceIntegrity(pack, issues) {
                 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}"`));
             }
-            if (c.where?.property && c.abstractType) {
-                checkAbsProp(c.abstractType, c.where.property, `analytics/${an.id}.coverage/${c.key}.where`);
+            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`));