@lesliechan721/aw-plugin-core 0.1.0-beta.38 → 0.1.0-beta.39

package/dist/plugin-config.js

@@ -154,7 +154,8 @@ function withArrayPath(issue, index) {
         ...issue,
         path: {
             ...issue.path,
-            segments: [issue.path.field, index, ...(issue.path.property === undefined ? [] : [issue.path.property])],
+            segments: [issue.path.field, index, ...(issue.path.segments?.slice(1)
+                    ?? (issue.path.property === undefined ? [] : [issue.path.property]))],
         },
     };
 }
@@ -249,15 +250,53 @@ function validateScalarField(fieldDefinition, value, field, property, checkChoic
         && matchPluginConfigPreset(fieldDefinition, value) === undefined) {
         issues.push(createIssue('choice', field, 'Expected a declared preset value.', property));
     }
+    if (issues.length === 0 && fieldDefinition.const !== undefined && value !== fieldDefinition.const) {
+        issues.push(createIssue('const', field, 'Expected the declared constant value.', property));
+    }
     return issues;
 }
+/** Resolve visible and allowed own properties without changing the supplied value. */
+export function resolvePluginConfigObjectProperties(definition, value, field = 'value') {
+    const properties = { ...definition.properties };
+    if (definition.properties === undefined || definition.variants === undefined)
+        return { properties, issues: [] };
+    const variants = definition.variants;
+    const input = isSafeJsonRecord(value) ? value : undefined;
+    const missingSelector = input === undefined || !Object.hasOwn(input, variants.discriminator);
+    const selector = ownProperty(input, variants.discriminator);
+    const selectorField = definition.properties[variants.discriminator];
+    const issues = missingSelector ? [] : validateScalarField(selectorField, selector, field, variants.discriminator);
+    if (issues.length > 0)
+        return { properties, issues };
+    const caseName = missingSelector ? variants.missing : selector;
+    const selected = caseName === undefined ? undefined : ownProperty(variants.cases, caseName);
+    if (selected !== undefined) {
+        return { properties: { ...properties, ...selected.properties }, variant: { kind: 'case', case: caseName }, issues };
+    }
+    if (!missingSelector && variants.otherwise !== undefined) {
+        return { properties: { ...properties, ...variants.otherwise.properties }, variant: { kind: 'otherwise' }, issues };
+    }
+    return { properties, issues: [createIssue('variant', field, 'No object variant matches the discriminator.', variants.discriminator)] };
+}
+function withPropertyPath(issue, property) {
+    return {
+        ...issue,
+        path: {
+            field: issue.path.field,
+            property,
+            segments: [issue.path.field, property, ...(issue.path.segments?.slice(1)
+                    ?? (issue.path.property === undefined ? [] : [issue.path.property]))],
+        },
+    };
+}
 function validateObjectField(fieldDefinition, value, field, checkChoices = true) {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
         return [createIssue('type', field, 'Expected an object.')];
     }
     const input = value;
     const keys = Object.keys(input);
-    const issues = [];
+    const resolved = resolvePluginConfigObjectProperties(fieldDefinition, value, field);
+    const issues = [...resolved.issues];
     if (keys.length > MAX_OBJECT_PROPERTIES) {
         issues.push(createIssue('maxProperties', field, `Expected at most ${MAX_OBJECT_PROPERTIES} properties.`));
     }
@@ -269,7 +308,7 @@ function validateObjectField(fieldDefinition, value, field, checkChoices = true)
         && keys.length > fieldDefinition.validation.maxProperties) {
         issues.push(createIssue('maxProperties', field, `Expected at most ${fieldDefinition.validation.maxProperties} properties.`));
     }
-    for (const [property, child] of Object.entries(fieldDefinition.properties ?? {})) {
+    for (const [property, child] of Object.entries(resolved.properties)) {
         if (child.required === true && !Object.hasOwn(input, property)) {
             issues.push(createIssue('required', field, 'Required property is missing.', property));
         }
@@ -279,9 +318,21 @@ function validateObjectField(fieldDefinition, value, field, checkChoices = true)
             issues.push(createIssue('dangerousKey', field, 'Dangerous config key is not allowed.', property));
             continue;
         }
-        const child = ownProperty(fieldDefinition.properties, property);
+        const child = ownProperty(resolved.properties, property);
         if (child !== undefined) {
-            issues.push(...validateScalarField(child, childValue, field, property));
+            if (fieldDefinition.variants?.discriminator === property && resolved.issues.length > 0)
+                continue;
+            if (child.type === 'array' || child.type === 'object') {
+                if (child.type === 'object' && !isSafeJsonRecord(childValue)) {
+                    issues.push(withPropertyPath(createIssue('type', field, 'Expected a JSON object.'), property));
+                }
+                else {
+                    issues.push(...validatePluginConfigValue(child, childValue, field)
+                        .map((issue) => withPropertyPath(issue, property)));
+                }
+            }
+            else
+                issues.push(...validateScalarField(child, childValue, field, property));
             continue;
         }
         const dynamicChild = fieldDefinition.additionalProperties;
@@ -322,6 +373,7 @@ function validateArrayField(fieldDefinition, value, field, checkChoices = true)
     if (count > max)
         issues.push(createIssue('maxItems', field, `Expected at most ${max} items.`));
     const seen = new Set();
+    const seenProperties = new Set();
     for (const [index, item] of value.entries()) {
         const itemIssues = fieldDefinition.items.type === 'object'
             ? isSafeJsonRecord(item)
@@ -329,6 +381,19 @@ function validateArrayField(fieldDefinition, value, field, checkChoices = true)
                 : [createIssue('type', field, 'Expected a JSON object.')]
             : validateScalarField(fieldDefinition.items, item, field);
         issues.push(...itemIssues.map((issue) => withArrayPath(issue, index)));
+        const uniqueBy = fieldDefinition.validation?.uniqueBy;
+        if (uniqueBy !== undefined && itemIssues.length === 0 && isSafeJsonRecord(item)) {
+            if (!Object.hasOwn(item, uniqueBy)) {
+                issues.push(withArrayPath(createIssue('uniqueBy', field, 'Unique property is missing.', uniqueBy), index));
+            }
+            else {
+                const key = item[uniqueBy];
+                if (seenProperties.has(key)) {
+                    issues.push(withArrayPath(createIssue('uniqueBy', field, 'Expected a unique property value.', uniqueBy), index));
+                }
+                seenProperties.add(key);
+            }
+        }
         if (fieldDefinition.validation?.uniqueItems === true && itemIssues.length === 0) {
             const key = stablePluginConfigStringify(item);
             if (seen.has(key)) {
@@ -397,14 +462,164 @@ export function validatePluginConfigDocument(definition, value) {
             issues.push(createIssue('unknownField', field, 'Unknown config field.'));
         }
     }
+    return [...issues, ...validatePluginConfigReferences(definition, input, Object.keys(definition.fields))];
+}
+function scalarSchemas(definition) {
+    if (definition.type === 'array')
+        return scalarSchemas(definition.items);
+    if (definition.type !== 'object')
+        return [definition];
+    return definition.properties === undefined
+        ? [definition.additionalProperties]
+        : [definition.properties, ...Object.values(definition.variants?.cases ?? {}).map((variant) => variant.properties),
+            ...(definition.variants?.otherwise === undefined ? [] : [definition.variants.otherwise.properties])]
+            .flatMap((properties) => Object.values(properties).flatMap((child) => scalarSchemas(child)));
+}
+/** Returns validation dependencies only; callers still project their original allowed keys. */
+export function getPluginConfigDependencyKeys(definition, keys) {
+    const result = new Set();
+    const visit = (key) => {
+        if (result.has(key))
+            return;
+        const field = ownProperty(definition.fields, key);
+        if (field === undefined)
+            throw new Error(`Unknown config key "${key}".`);
+        result.add(key);
+        for (const scalar of scalarSchemas(field)) {
+            if ('valueRef' in scalar && scalar.valueRef !== undefined)
+                visit(scalar.valueRef.field);
+        }
+    };
+    keys.forEach(visit);
+    return [...result];
+}
+function validatePluginConfigReferences(definition, input, keys) {
+    const issues = [];
+    const reservedPaths = new Set();
+    const sources = new Map();
+    const allowedValues = new Map();
+    const check = (scalar, value, field, segments = []) => {
+        if (!('valueRef' in scalar) || scalar.valueRef === undefined)
+            return;
+        const ref = scalar.valueRef;
+        let source = sources.get(ref.field);
+        if (source === undefined) {
+            const sourceSchema = definition.fields[ref.field];
+            const sourceValue = ownProperty(input, ref.field);
+            const valid = sourceValue === undefined
+                ? sourceSchema.required !== true
+                : validatePluginConfigValue(sourceSchema, sourceValue, ref.field).length === 0;
+            source = { valid, entries: valid ? (sourceValue ?? []) : [] };
+            sources.set(ref.field, source);
+        }
+        const add = (code, message) => {
+            const property = segments.find((segment) => typeof segment === 'string');
+            const issue = createIssue(code, field, message, property);
+            issues.push(segments.length < 2 && typeof segments[0] !== 'number'
+                ? issue : { ...issue, path: { ...issue.path, segments: [field, ...segments] } });
+        };
+        if (!source.valid) {
+            add('valueRefSource', `Referenced config "${ref.field}" is invalid; fix its complete array value.`);
+            return;
+        }
+        let allowed = allowedValues.get(ref);
+        if (allowed === undefined) {
+            allowed = new Set(ref.include);
+            for (const [sourceIndex, entry] of source.entries.entries()) {
+                if (ref.include?.includes(entry[ref.key]) === true) {
+                    const pathKey = `${ref.field}\0${sourceIndex}\0${ref.key}`;
+                    if (!reservedPaths.has(pathKey)) {
+                        reservedPaths.add(pathKey);
+                        issues.push(withArrayPath(createIssue('valueRefReserved', ref.field, 'Referenced property collides with a reserved included value.', ref.key), sourceIndex));
+                    }
+                }
+                allowed.add(entry[ref.key]);
+            }
+            allowedValues.set(ref, allowed);
+        }
+        if (value === undefined || validateScalarField(scalar, value, field).length > 0)
+            return;
+        if (!allowed.has(value)) {
+            add('valueRef', `Expected an included value or a key from config "${ref.field}". Add that key first, update dependent fields, then remove the old key.`);
+        }
+    };
+    const walk = (schema, value, field, segments = []) => {
+        if (schema.type === 'array') {
+            // Reserved source values must remain invalid when a dependent array is absent.
+            for (const scalar of scalarSchemas(schema))
+                check(scalar, undefined, field, segments);
+            if (Array.isArray(value) && validatePluginConfigValue(schema, value, field).length === 0) {
+                value.forEach((item, index) => walk(schema.items, item, field, [...segments, index]));
+            }
+        }
+        else if (schema.type === 'object') {
+            if (schema.properties !== undefined) {
+                const resolved = resolvePluginConfigObjectProperties(schema, value, field);
+                for (const [property, child] of Object.entries(resolved.properties)) {
+                    walk(child, isSafeJsonRecord(value) ? ownProperty(value, property) : undefined, field, [...segments, property]);
+                }
+            }
+            else {
+                check(schema.additionalProperties, undefined, field, segments);
+                if (isSafeJsonRecord(value)) {
+                    for (const [property, child] of Object.entries(value)) {
+                        walk(schema.additionalProperties, child, field, [...segments, property]);
+                    }
+                }
+            }
+        }
+        else
+            check(schema, value, field, segments);
+    };
+    for (const field of keys) {
+        const schema = definition.fields[field];
+        walk(schema, ownProperty(input, field), field);
+    }
     return issues;
 }
+/** Validate one effective candidate, including complete sources required by selected fields. */
+export function validatePluginConfigCandidate(definition, values, keys) {
+    if (!isSafeJsonRecord(values))
+        return [createIssue('type', '$document', 'Expected a config JSON object.')];
+    if (keys === undefined)
+        return validatePluginConfigDocument(definition, values);
+    const closure = getPluginConfigDependencyKeys(definition, keys);
+    const projected = Object.fromEntries(closure.flatMap((key) => Object.hasOwn(values, key) ? [[key, values[key]]] : []));
+    return validatePluginConfigDocument({ ...definition, fields: Object.fromEntries(closure.map((key) => [key, definition.fields[key]])) }, projected);
+}
+function assertValueReferenceSchemas(fields, definitions, path, allowReferences = true) {
+    for (const definition of definitions) {
+        for (const scalar of scalarSchemas(definition)) {
+            if (!('valueRef' in scalar) || scalar.valueRef === undefined)
+                continue;
+            if (!allowReferences)
+                throw new Error(`Invalid ${path}: valueRef requires Config Definition v3.`);
+            const ref = scalar.valueRef;
+            const source = ownProperty(fields, ref.field);
+            if (source?.type !== 'array' || source.items.type !== 'object' || source.items.properties === undefined) {
+                throw new Error(`Invalid ${path}.valueRef.field: expected a declared fixed-object array.`);
+            }
+            const key = ownProperty(source.items.properties, ref.key);
+            if (key === undefined || key.type !== scalar.type || source.validation?.uniqueBy !== ref.key) {
+                throw new Error(`Invalid ${path}.valueRef.key: expected a scalar of the same type with matching uniqueBy.`);
+            }
+            if (ref.label !== undefined && ownProperty(source.items.properties, ref.label) === undefined) {
+                throw new Error(`Invalid ${path}.valueRef.label: expected a declared scalar property.`);
+            }
+            const label = ref.label === undefined ? undefined : ownProperty(source.items.properties, ref.label);
+            if (label?.type === 'array' || label?.type === 'object') {
+                throw new Error(`Invalid ${path}.valueRef.label: expected a declared scalar property.`);
+            }
+        }
+    }
+}
 export function canonicalizePluginConfigValue(value) {
     if (typeof value !== 'object')
         return value;
     if (Array.isArray(value))
         return value.map((item) => canonicalizePluginConfigValue(item));
-    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+        .map(([key, child]) => [key, canonicalizePluginConfigValue(child)]));
 }
 export function canonicalizePluginConfigValues(values) {
     return Object.fromEntries(Object.entries(values)
@@ -481,7 +696,9 @@ function normalizeScalarField(value, path, options) {
         allowed.push('required');
     if (options.allowSensitive && type === 'string')
         allowed.push('sensitive');
-    allowed.push('choices');
+    allowed.push('choices', 'valueRef');
+    if (options.allowConst)
+        allowed.push('const');
     if (type !== 'boolean')
         allowed.push('validation');
     assertAllowedKeys(input, path, allowed);
@@ -494,10 +711,51 @@ function normalizeScalarField(value, path, options) {
     if (sensitive === true && input.choices !== undefined) {
         throw new Error(`Invalid ${path}.choices: sensitive fields cannot declare choices.`);
     }
+    if (sensitive === true && input.valueRef !== undefined) {
+        throw new Error(`Invalid ${path}.valueRef: sensitive fields cannot declare value references.`);
+    }
+    if (sensitive === true && Object.hasOwn(input, 'const')) {
+        throw new Error(`Invalid ${path}.const: sensitive fields cannot declare a constant.`);
+    }
+    if (Object.hasOwn(input, 'const') && (typeof input.const !== type
+        || (type === 'number' && !Number.isFinite(input.const)))) {
+        throw new Error(`Invalid ${path}.const: expected a finite scalar of type ${type}.`);
+    }
+    let valueRef;
+    if (input.valueRef !== undefined) {
+        const rawRef = asObject(input.valueRef, `${path}.valueRef`);
+        assertAllowedKeys(rawRef, `${path}.valueRef`, ['field', 'key', 'label', 'include']);
+        let include;
+        if (rawRef.include !== undefined) {
+            if (!Array.isArray(rawRef.include) || !isDenseDataArray(rawRef.include)
+                || rawRef.include.length > PLUGIN_CONFIG_ARRAY_MAX_ITEMS) {
+                throw new Error(`Invalid ${path}.valueRef.include: expected at most ${PLUGIN_CONFIG_ARRAY_MAX_ITEMS} scalar values.`);
+            }
+            include = rawRef.include.map((entry) => {
+                if (typeof entry !== type || (type === 'number' && !Number.isFinite(entry))) {
+                    throw new Error(`Invalid ${path}.valueRef.include: expected values of type ${type}.`);
+                }
+                return entry;
+            });
+            if (new Set(include).size !== include.length) {
+                throw new Error(`Invalid ${path}.valueRef.include: expected unique scalar values.`);
+            }
+            if (Buffer.byteLength(JSON.stringify(include), 'utf8') > PLUGIN_CONFIG_ARRAY_MAX_BYTES) {
+                throw new Error(`Invalid ${path}.valueRef.include: expected at most ${PLUGIN_CONFIG_ARRAY_MAX_BYTES} UTF-8 JSON bytes.`);
+            }
+        }
+        valueRef = {
+            field: nonEmptyString(rawRef.field, `${path}.valueRef.field`),
+            key: nonEmptyString(rawRef.key, `${path}.valueRef.key`),
+            label: optionalText(rawRef.label, `${path}.valueRef.label`),
+            include,
+        };
+    }
     const common = {
         title: optionalText(input.title, `${path}.title`),
         description: optionalText(input.description, `${path}.description`),
         ...(options.allowRequired ? { required: optionalBoolean(input.required, `${path}.required`) } : {}),
+        ...(valueRef === undefined ? {} : { valueRef }),
     };
     const defaultValue = options.allowDefault && input.default !== undefined
         ? input.default
@@ -516,6 +774,7 @@ function normalizeScalarField(value, path, options) {
         return {
             type,
             ...common,
+            ...(Object.hasOwn(input, 'const') ? { const: input.const } : {}),
             ...(options.allowSensitive ? { sensitive } : {}),
             ...(options.allowDefault ? { default: defaultValue } : {}),
             choices: input.choices === undefined
@@ -530,6 +789,7 @@ function normalizeScalarField(value, path, options) {
         return {
             type,
             ...common,
+            ...(Object.hasOwn(input, 'const') ? { const: input.const } : {}),
             ...(options.allowDefault ? { default: defaultValue } : {}),
             choices: input.choices === undefined
                 ? undefined
@@ -542,6 +802,7 @@ function normalizeScalarField(value, path, options) {
     return {
         type,
         ...common,
+        ...(Object.hasOwn(input, 'const') ? { const: input.const } : {}),
         ...(options.allowDefault ? { default: defaultValue } : {}),
         choices: input.choices === undefined
             ? undefined
@@ -578,7 +839,79 @@ function assertChoices(definition, path) {
         throw new Error(`Invalid ${path}.choices: expected at most one recommended preset.`);
     }
 }
-function normalizeObjectField(value, path) {
+function assertFieldConstraints(definition, path) {
+    assertChoices(definition, path);
+    if (definition.type !== 'object' && definition.type !== 'array' && definition.const !== undefined) {
+        const issues = validateScalarField(definition, definition.const, path);
+        if (issues.length > 0)
+            throw new Error(`Invalid ${path}.const: ${formatPluginConfigIssue(issues[0])}`);
+    }
+}
+function normalizeObjectProperty(value, path, v4) {
+    const input = asObject(value, path);
+    let definition;
+    if (v4 && (input.type === 'array' || input.type === 'object')) {
+        if (Object.hasOwn(input, 'default') || Object.hasOwn(input, 'sensitive')) {
+            throw new Error(`Invalid ${path}: object properties cannot declare default or sensitive.`);
+        }
+        if (input.type === 'object' && (Object.hasOwn(input, 'properties') || Object.hasOwn(input, 'variants'))) {
+            throw new Error(`Invalid ${path}: nested objects must be scalar key-value objects.`);
+        }
+        definition = (input.type === 'array'
+            ? normalizeArrayField(input, path, true, true)
+            : normalizeObjectField(input, path, true));
+        delete definition.default;
+    }
+    else {
+        definition = normalizeScalarField(input, path, {
+            allowDefault: false, allowRequired: true, allowSensitive: false, allowConst: v4,
+        });
+    }
+    assertFieldConstraints(definition, path);
+    return definition;
+}
+function normalizeObjectVariants(value, properties, path) {
+    const input = asObject(value, path);
+    assertAllowedKeys(input, path, ['discriminator', 'cases', 'missing', 'otherwise']);
+    const discriminator = nonEmptyString(input.discriminator, `${path}.discriminator`);
+    if (ownProperty(properties, discriminator)?.type !== 'string') {
+        throw new Error(`Invalid ${path}.discriminator: expected a declared own string property.`);
+    }
+    const casesInput = asObject(input.cases, `${path}.cases`);
+    if (Object.keys(casesInput).length < 1 || Object.keys(casesInput).length > MAX_OBJECT_PROPERTIES) {
+        throw new Error(`Invalid ${path}.cases: expected 1..${MAX_OBJECT_PROPERTIES} cases.`);
+    }
+    const normalizeVariant = (value, variantPath) => {
+        const variant = asObject(value, variantPath);
+        assertAllowedKeys(variant, variantPath, ['properties']);
+        const children = asObject(variant.properties, `${variantPath}.properties`);
+        if (Object.keys(children).length + Object.keys(properties).length > MAX_OBJECT_PROPERTIES) {
+            throw new Error(`Invalid ${variantPath}.properties: common and case properties must total at most ${MAX_OBJECT_PROPERTIES}.`);
+        }
+        const result = createPropertyMap();
+        for (const [key, child] of Object.entries(children)) {
+            if (isDangerousConfigKey(key))
+                throw new Error(`Invalid ${variantPath}.properties: dangerous config key.`);
+            if (Object.hasOwn(properties, key))
+                throw new Error(`Invalid ${variantPath}.properties: case cannot override common property "${key}".`);
+            result[key] = normalizeObjectProperty(child, `${variantPath}.properties.${key}`, true);
+        }
+        return { properties: result };
+    };
+    const cases = createPropertyMap();
+    for (const [name, variant] of Object.entries(casesInput)) {
+        if (isDangerousConfigKey(name))
+            throw new Error(`Invalid ${path}.cases: dangerous case key.`);
+        cases[name] = normalizeVariant(variant, `${path}.cases.${name}`);
+    }
+    const missing = optionalText(input.missing, `${path}.missing`);
+    if (missing !== undefined && !Object.hasOwn(cases, missing)) {
+        throw new Error(`Invalid ${path}.missing: expected a declared case.`);
+    }
+    return { discriminator, cases, ...(missing === undefined ? {} : { missing }),
+        ...(input.otherwise === undefined ? {} : { otherwise: normalizeVariant(input.otherwise, `${path}.otherwise`) }) };
+}
+function normalizeObjectField(value, path, v4 = false) {
     const input = asObject(value, path);
     assertAllowedKeys(input, path, [
         'type',
@@ -590,6 +923,7 @@ function normalizeObjectField(value, path) {
         'properties',
         'additionalProperties',
         'validation',
+        ...(v4 ? ['variants'] : []),
     ]);
     if (input.properties === undefined && (input.additionalProperties === undefined || input.additionalProperties === false)) {
         throw new Error(`Invalid ${path}: key-value object config requires a scalar additionalProperties field.`);
@@ -608,12 +942,7 @@ function normalizeObjectField(value, path) {
             if (isDangerousConfigKey(property)) {
                 throw new Error(`Invalid ${path}.properties: dangerous config key "${property}" is not allowed.`);
             }
-            properties[property] = normalizeScalarField(child, `${path}.properties.${property}`, {
-                allowDefault: false,
-                allowRequired: true,
-                allowSensitive: false,
-            });
-            assertChoices(properties[property], `${path}.properties.${property}`);
+            properties[property] = normalizeObjectProperty(child, `${path}.properties.${property}`, v4);
         }
     }
     let additionalProperties;
@@ -621,8 +950,8 @@ function normalizeObjectField(value, path) {
         additionalProperties = false;
     }
     else {
-        additionalProperties = normalizeScalarField(input.additionalProperties, `${path}.additionalProperties`, { allowDefault: false, allowRequired: false, allowSensitive: false });
-        assertChoices(additionalProperties, `${path}.additionalProperties`);
+        additionalProperties = normalizeScalarField(input.additionalProperties, `${path}.additionalProperties`, { allowDefault: false, allowRequired: false, allowSensitive: false, allowConst: v4 });
+        assertFieldConstraints(additionalProperties, `${path}.additionalProperties`);
     }
     let validation;
     if (input.validation !== undefined) {
@@ -651,6 +980,10 @@ function normalizeObjectField(value, path) {
                 : normalizeStringValidation(validationInput.key, `${path}.validation.key`),
         };
     }
+    if (input.variants !== undefined && properties === undefined) {
+        throw new Error(`Invalid ${path}.variants: variants require a fixed object.`);
+    }
+    const variants = input.variants === undefined ? undefined : normalizeObjectVariants(input.variants, properties, `${path}.variants`);
     return {
         type: 'object',
         title: optionalText(input.title, `${path}.title`),
@@ -662,11 +995,11 @@ function normalizeObjectField(value, path) {
             : normalizeChoices(input.choices, `${path}.choices`),
         ...(properties === undefined
             ? { additionalProperties: additionalProperties }
-            : { properties, additionalProperties: false }),
+            : { properties, additionalProperties: false, ...(variants === undefined ? {} : { variants }) }),
         validation,
     };
 }
-function normalizeArrayField(value, path) {
+function normalizeArrayField(value, path, v4 = false, scalarItemsOnly = false) {
     const input = asObject(value, path);
     assertAllowedKeys(input, path, ['type', 'title', 'description', 'default', 'required', 'items', 'choices', 'validation']);
     const itemPath = `${path}.items`;
@@ -677,20 +1010,20 @@ function normalizeArrayField(value, path) {
         }
     }
     let items;
-    if (item.type === 'object') {
-        const { default: _default, required: _required, ...objectItem } = normalizeObjectField(item, itemPath);
+    if (item.type === 'object' && !scalarItemsOnly) {
+        const { default: _default, required: _required, ...objectItem } = normalizeObjectField(item, itemPath, v4);
         items = objectItem;
     }
     else {
         items = normalizeScalarField(item, itemPath, {
-            allowDefault: false, allowRequired: false, allowSensitive: false,
+            allowDefault: false, allowRequired: false, allowSensitive: false, allowConst: v4,
         });
     }
-    assertChoices(items, itemPath);
+    assertFieldConstraints(items, itemPath);
     let validation;
     if (input.validation !== undefined) {
         const rawValidation = asObject(input.validation, `${path}.validation`);
-        assertAllowedKeys(rawValidation, `${path}.validation`, ['minItems', 'maxItems', 'uniqueItems']);
+        assertAllowedKeys(rawValidation, `${path}.validation`, ['minItems', 'maxItems', 'uniqueItems', 'uniqueBy']);
         const minItems = rawValidation.minItems === undefined
             ? undefined
             : nonNegativeInteger(rawValidation.minItems, `${path}.validation.minItems`);
@@ -703,10 +1036,17 @@ function normalizeArrayField(value, path) {
         if (minItems !== undefined && minItems > (maxItems ?? PLUGIN_CONFIG_ARRAY_MAX_ITEMS)) {
             throw new Error(`Invalid ${path}.validation.minItems: must not exceed effective maxItems.`);
         }
+        const uniqueBy = optionalText(rawValidation.uniqueBy, `${path}.validation.uniqueBy`);
+        const uniqueProperty = items.type === 'object' && uniqueBy !== undefined ? ownProperty(items.properties, uniqueBy) : undefined;
+        if (uniqueBy !== undefined && (uniqueProperty === undefined
+            || uniqueProperty.type === 'array' || uniqueProperty.type === 'object')) {
+            throw new Error(`Invalid ${path}.validation.uniqueBy: expected a declared fixed scalar property.`);
+        }
         validation = {
             minItems,
             maxItems,
             uniqueItems: optionalBoolean(rawValidation.uniqueItems, `${path}.validation.uniqueItems`),
+            ...(uniqueBy === undefined ? {} : { uniqueBy }),
         };
     }
     return {
@@ -732,7 +1072,7 @@ export function decodePluginConfigSummaryPath(value) {
         throw new Error('Invalid summary path: dangerous config key.');
     return property;
 }
-function expandConfigReferences(input, path) {
+function expandConfigReferences(input, path, v4 = false) {
     const definitions = input.definitions === undefined ? {} : asObject(input.definitions, `${path}.definitions`);
     if (Object.keys(definitions).length > PLUGIN_CONFIG_V3_MAX_DEFINITIONS) {
         throw new Error(`Invalid ${path}.definitions: expected at most ${PLUGIN_CONFIG_V3_MAX_DEFINITIONS} definitions.`);
@@ -742,7 +1082,7 @@ function expandConfigReferences(input, path) {
             throw new Error(`Invalid ${path}.definitions: invalid definition name "${name}".`);
         }
     }
-    const expand = (value, fieldPath, chain, child = false) => {
+    const expand = (value, fieldPath, chain, context = 'field') => {
         const field = asObject(value, fieldPath);
         if (Object.hasOwn(field, '$ref')) {
             assertAllowedKeys(field, fieldPath, ['$ref', 'title', 'description', 'default', 'required']);
@@ -757,7 +1097,7 @@ function expandConfigReferences(input, path) {
             if (chain.length >= PLUGIN_CONFIG_V3_MAX_REF_DEPTH) {
                 throw new Error(`Invalid ${fieldPath}.$ref: expected at most ${PLUGIN_CONFIG_V3_MAX_REF_DEPTH} reference edges.`);
             }
-            const result = expand(definitions[name], `${path}.definitions.${name}`, [...chain, name], child);
+            const result = expand(definitions[name], `${path}.definitions.${name}`, [...chain, name], context);
             for (const key of ['title', 'description', 'default', 'required']) {
                 if (Object.hasOwn(field, key))
                     result[key] = field[key];
@@ -765,43 +1105,67 @@ function expandConfigReferences(input, path) {
             return result;
         }
         const result = { ...field };
-        if (child)
+        if (context === 'scalar' || (!v4 && context === 'property'))
             return result;
+        if (context === 'property' && field.type === 'object' && (field.properties !== undefined || field.variants !== undefined)) {
+            throw new Error(`Invalid ${fieldPath}: nested objects must be scalar key-value objects.`);
+        }
         if (field.type === 'array' && field.items !== undefined) {
-            result.items = expand(field.items, `${fieldPath}.items`, chain);
+            result.items = expand(field.items, `${fieldPath}.items`, chain, context === 'property' ? 'scalar' : 'item');
         }
         if (field.properties !== undefined) {
             const properties = asObject(field.properties, `${fieldPath}.properties`);
             if (Object.keys(properties).length > MAX_OBJECT_PROPERTIES) {
                 throw new Error(`Invalid ${fieldPath}.properties: expected at most ${MAX_OBJECT_PROPERTIES} properties.`);
             }
-            result.properties = Object.fromEntries(Object.entries(properties).map(([key, child]) => [key, expand(child, `${fieldPath}.properties.${key}`, chain, true)]));
+            result.properties = Object.fromEntries(Object.entries(properties).map(([key, child]) => [key, expand(child, `${fieldPath}.properties.${key}`, chain, 'property')]));
         }
         if (field.additionalProperties !== undefined && field.additionalProperties !== false) {
-            result.additionalProperties = expand(field.additionalProperties, `${fieldPath}.additionalProperties`, chain, true);
+            result.additionalProperties = expand(field.additionalProperties, `${fieldPath}.additionalProperties`, chain, 'scalar');
+        }
+        if (v4 && field.variants !== undefined) {
+            const variants = asObject(field.variants, `${fieldPath}.variants`);
+            const cases = asObject(variants.cases, `${fieldPath}.variants.cases`);
+            if (Object.keys(cases).length > MAX_OBJECT_PROPERTIES)
+                throw new Error(`Invalid ${fieldPath}.variants.cases: expected at most ${MAX_OBJECT_PROPERTIES} cases.`);
+            const expandVariant = (value, variantPath) => {
+                const variant = asObject(value, variantPath);
+                const properties = asObject(variant.properties, `${variantPath}.properties`);
+                if (Object.keys(properties).length > MAX_OBJECT_PROPERTIES)
+                    throw new Error(`Invalid ${variantPath}.properties: expected at most ${MAX_OBJECT_PROPERTIES} properties.`);
+                return { ...variant, properties: Object.fromEntries(Object.entries(properties).map(([key, child]) => [key, expand(child, `${variantPath}.properties.${key}`, chain, 'property')])) };
+            };
+            result.variants = { ...variants, cases: Object.fromEntries(Object.entries(cases).map(([name, variant]) => [name, expandVariant(variant, `${fieldPath}.variants.cases.${name}`)])),
+                ...(variants.otherwise === undefined ? {} : { otherwise: expandVariant(variants.otherwise, `${fieldPath}.variants.otherwise`) }) };
         }
         return result;
     };
     // Validate unused definitions too, through the same field/default/choice validator.
+    const normalizedDefinitions = [];
     for (const [name, value] of Object.entries(definitions)) {
-        normalizeConfigField(expand(value, `${path}.definitions.${name}`, []), `${path}.definitions.${name}`, true);
+        normalizedDefinitions.push(normalizeConfigField(expand(value, `${path}.definitions.${name}`, []), `${path}.definitions.${name}`, true, v4));
     }
     const fields = asObject(input.fields, `${path}.fields`);
     if (Object.keys(fields).length > PLUGIN_CONFIG_V3_MAX_FIELDS) {
         throw new Error(`Invalid ${path}.fields: expected at most ${PLUGIN_CONFIG_V3_MAX_FIELDS} fields.`);
     }
-    return Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, expand(value, `${path}.fields.${key}`, [])]));
+    const expanded = Object.fromEntries(Object.entries(fields).map(([key, value]) => [key, expand(value, `${path}.fields.${key}`, [])]));
+    if (normalizedDefinitions.some((definition) => scalarSchemas(definition).some((scalar) => 'valueRef' in scalar && scalar.valueRef !== undefined))) {
+        const normalizedFields = Object.fromEntries(Object.entries(expanded).map(([key, value]) => [key, normalizeConfigField(value, `${path}.fields.${key}`, true, v4)]));
+        assertValueReferenceSchemas(normalizedFields, normalizedDefinitions, `${path}.definitions`);
+    }
+    return expanded;
 }
-function normalizeConfigField(rawDefinition, path, allowArray) {
+function normalizeConfigField(rawDefinition, path, allowArray, v4 = false) {
     const rawField = asObject(rawDefinition, path);
     const definition = rawField.type === 'object'
-        ? normalizeObjectField(rawField, path)
+        ? normalizeObjectField(rawField, path, v4)
         : rawField.type === 'array' && allowArray
-            ? normalizeArrayField(rawField, path)
+            ? normalizeArrayField(rawField, path, v4)
             : normalizeScalarField(rawField, path, {
-                allowDefault: true, allowRequired: true, allowSensitive: true,
+                allowDefault: true, allowRequired: true, allowSensitive: true, allowConst: v4,
             });
-    assertChoices(definition, path);
+    assertFieldConstraints(definition, path);
     if (definition.default !== undefined) {
         const issues = validatePluginConfigValue(definition, definition.default, path);
         if (issues.length > 0)
@@ -868,7 +1232,15 @@ function normalizeConfigSummaries(input, fields, path) {
         if (!summary)
             throw new Error(`Invalid ${viewPath}.${itemSummary ? 'itemSummary' : 'summary'}: unknown summary.`);
         for (const part of summary.parts) {
-            if (!ownProperty(objectField.properties, decodePluginConfigSummaryPath(part.path))) {
+            const propertyName = decodePluginConfigSummaryPath(part.path);
+            const declarations = [objectField.properties,
+                ...Object.values(objectField.variants?.cases ?? {}).map((variant) => variant.properties),
+                ...(objectField.variants?.otherwise === undefined ? [] : [objectField.variants.otherwise.properties])]
+                .flatMap((properties) => {
+                const property = ownProperty(properties, propertyName);
+                return property === undefined ? [] : [property];
+            });
+            if (declarations.length === 0 || declarations.some((property) => property.type === 'array' || property.type === 'object')) {
                 throw new Error(`Invalid ${viewPath}: summary path "${part.path}" must name a declared scalar property.`);
             }
         }
@@ -881,15 +1253,23 @@ function normalizeConfigSummaries(input, fields, path) {
 }
 export function normalizePluginConfigDefinition(value, path = 'config') {
     const input = asObject(value, path);
-    const v3 = input.schemaVersion === 3;
+    const v4 = input.schemaVersion === 4;
+    const v3 = input.schemaVersion === 3 || v4;
     assertAllowedKeys(input, path, v3 ? ['schemaVersion', 'definitions', 'fields', 'presentation'] : ['fields', 'presentation']);
-    const fieldsInput = v3 ? expandConfigReferences(input, path) : asObject(input.fields, `${path}.fields`);
+    const fieldsInput = v3 ? expandConfigReferences(input, path, v4) : asObject(input.fields, `${path}.fields`);
     const fields = createPropertyMap();
     for (const [field, rawDefinition] of Object.entries(fieldsInput)) {
         if (!CONFIG_KEY_PATTERN.test(field) || isDangerousConfigKey(field)) {
             throw new Error(`Invalid ${path}.fields: config key "${field}" is not valid.`);
         }
-        fields[field] = normalizeConfigField(rawDefinition, `${path}.fields.${field}`, v3);
+        fields[field] = normalizeConfigField(rawDefinition, `${path}.fields.${field}`, v3, v4);
+    }
+    assertValueReferenceSchemas(fields, Object.values(fields), path, v3);
+    const defaultValues = Object.fromEntries(Object.entries(fields).flatMap(([field, definition]) => definition.default === undefined ? [] : [[field, definition.default]]));
+    const defaultIssues = validatePluginConfigReferences({ schemaVersion: 4, fields }, defaultValues, Object.keys(fields))
+        .filter((issue) => Object.hasOwn(defaultValues, issue.path.field));
+    if (defaultIssues.length > 0) {
+        throw new Error(`Invalid ${path}.default: ${formatPluginConfigIssue(defaultIssues[0])}`);
     }
     let presentation;
     if (input.presentation !== undefined) {
@@ -935,6 +1315,6 @@ export function normalizePluginConfigDefinition(value, path = 'config') {
             }),
         };
     }
-    return { ...(v3 ? { schemaVersion: 3 } : {}), fields, presentation };
+    return { ...(v3 ? { schemaVersion: v4 ? 4 : 3 } : {}), fields, presentation };
 }
 //# sourceMappingURL=plugin-config.js.map