@featurevisor/core 2.10.0 → 2.12.0

package/lib/linter/featureSchema.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFeatureZodSchema = getFeatureZodSchema;
 const zod_1 = require("zod");
-const propertySchema_1 = require("./propertySchema");
+const schema_1 = require("./schema");
 const tagRegex = /^[a-z0-9-]+$/;
 function isArrayOfStrings(value) {
     return Array.isArray(value) && value.every((v) => typeof v === "string");
@@ -18,6 +18,201 @@ function getVariableLabel(variableSchema, variableKey, path) {
         variableSchema?.key ??
         (path.length > 0 ? String(path[path.length - 1]) : "variable"));
 }
+/**
+ * Resolve variable schema to the Schema used for value validation.
+ * When variable has `schema` (reference), returns the parsed Schema from schemasByKey; otherwise returns the inline variable schema.
+ */
+function resolveVariableSchema(variableSchema, schemasByKey) {
+    if (variableSchema.schema) {
+        return schemasByKey?.[variableSchema.schema] ?? null;
+    }
+    return variableSchema;
+}
+/** Resolve a schema by following schema references (schema: key). Used for nested schemas that may have oneOf. */
+function resolveSchemaRefs(schema, schemasByKey) {
+    if (schema.schema && schemasByKey?.[schema.schema]) {
+        return resolveSchemaRefs(schemasByKey[schema.schema], schemasByKey);
+    }
+    return schema;
+}
+/**
+ * Returns true if the value matches the given schema (const, enum, type, object properties, array items, or exactly one of oneOf).
+ * Used for oneOf validation: value must match exactly one branch.
+ */
+function valueMatchesSchema(schema, value, schemasByKey) {
+    const resolved = resolveSchemaRefs(schema, schemasByKey);
+    if (resolved.oneOf && Array.isArray(resolved.oneOf) && resolved.oneOf.length > 0) {
+        const matchCount = resolved.oneOf.filter((branch) => valueMatchesSchema(branch, value, schemasByKey)).length;
+        return matchCount === 1;
+    }
+    if (resolved.const !== undefined) {
+        return valueDeepEqual(value, resolved.const);
+    }
+    if (resolved.enum !== undefined && Array.isArray(resolved.enum)) {
+        return resolved.enum.some((e) => valueDeepEqual(value, e));
+    }
+    const type = resolved.type;
+    if (!type)
+        return false;
+    if (type === "string") {
+        if (typeof value !== "string")
+            return false;
+        const s = value;
+        if (resolved.minLength !== undefined && s.length < resolved.minLength)
+            return false;
+        if (resolved.maxLength !== undefined && s.length > resolved.maxLength)
+            return false;
+        if (resolved.pattern !== undefined) {
+            try {
+                if (!new RegExp(resolved.pattern).test(s))
+                    return false;
+            }
+            catch {
+                return true;
+            }
+        }
+        return true;
+    }
+    if (type === "boolean")
+        return typeof value === "boolean";
+    if (type === "integer") {
+        if (typeof value !== "number" || !Number.isInteger(value))
+            return false;
+        if (resolved.minimum !== undefined && value < resolved.minimum)
+            return false;
+        if (resolved.maximum !== undefined && value > resolved.maximum)
+            return false;
+        return true;
+    }
+    if (type === "double") {
+        if (typeof value !== "number")
+            return false;
+        if (resolved.minimum !== undefined && value < resolved.minimum)
+            return false;
+        if (resolved.maximum !== undefined && value > resolved.maximum)
+            return false;
+        return true;
+    }
+    if (type === "json")
+        return typeof value === "string";
+    if (type === "object") {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return false;
+        const props = resolved.properties;
+        if (!props || typeof props !== "object")
+            return true;
+        const obj = value;
+        const required = new Set(resolved.required || []);
+        for (const key of required) {
+            if (!Object.prototype.hasOwnProperty.call(obj, key))
+                return false;
+            if (!valueMatchesSchema(props[key], obj[key], schemasByKey))
+                return false;
+        }
+        for (const key of Object.keys(obj)) {
+            const propSchema = props[key];
+            if (!propSchema)
+                return false;
+            if (!valueMatchesSchema(propSchema, obj[key], schemasByKey))
+                return false;
+        }
+        return true;
+    }
+    if (type === "array") {
+        if (!Array.isArray(value))
+            return false;
+        const arr = value;
+        if (resolved.minItems !== undefined && arr.length < resolved.minItems)
+            return false;
+        if (resolved.maxItems !== undefined && arr.length > resolved.maxItems)
+            return false;
+        if (resolved.uniqueItems) {
+            for (let i = 0; i < arr.length; i++) {
+                for (let j = i + 1; j < arr.length; j++) {
+                    if (valueDeepEqual(arr[i], arr[j]))
+                        return false;
+                }
+            }
+        }
+        const itemSchema = resolved.items;
+        if (!itemSchema || typeof itemSchema !== "object")
+            return arr.every((v) => typeof v === "string");
+        return arr.every((item) => valueMatchesSchema(itemSchema, item, schemasByKey));
+    }
+    return false;
+}
+/** Deep equality for variable values (primitives, plain objects, arrays). */
+function valueDeepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (a === null || b === null)
+        return a === b;
+    if (typeof a === "object" && typeof b === "object") {
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            return a.every((v, i) => valueDeepEqual(v, b[i]));
+        }
+        const keysA = Object.keys(a).sort();
+        const keysB = Object.keys(b).sort();
+        if (keysA.length !== keysB.length || keysA.some((k, i) => k !== keysB[i]))
+            return false;
+        return keysA.every((k) => valueDeepEqual(a[k], b[k]));
+    }
+    return false;
+}
+/**
+ * Recursively validates that every `required` array (at this level and in nested
+ * object/array schemas) only contains keys that exist in the same level's `properties`.
+ * Adds Zod issues with the correct path for invalid required field names.
+ */
+function refineRequiredKeysInSchema(schema, pathPrefix, ctx) {
+    if (!schema || typeof schema !== "object")
+        return;
+    const effectiveType = schema.type;
+    const properties = schema.properties;
+    const required = schema.required;
+    const items = schema.items;
+    if (effectiveType === "object" &&
+        Array.isArray(required) &&
+        required.length > 0 &&
+        properties &&
+        typeof properties === "object") {
+        const allowedKeys = Object.keys(properties);
+        required.forEach((key, index) => {
+            if (!allowedKeys.includes(key)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Unknown required field "${key}". \`required\` must only contain property names defined in \`properties\`. Allowed: ${allowedKeys.length ? allowedKeys.join(", ") : "(none)"}.`,
+                    path: [...pathPrefix, "required", index],
+                });
+            }
+        });
+    }
+    if (properties && typeof properties === "object") {
+        for (const key of Object.keys(properties)) {
+            const nested = properties[key];
+            if (nested && typeof nested === "object") {
+                refineRequiredKeysInSchema(nested, [...pathPrefix, "properties", key], ctx);
+            }
+        }
+    }
+    if (items && typeof items === "object" && !Array.isArray(items)) {
+        refineRequiredKeysInSchema(items, [...pathPrefix, "items"], ctx);
+    }
+    const oneOf = schema.oneOf;
+    if (oneOf && Array.isArray(oneOf)) {
+        oneOf.forEach((branch, i) => {
+            if (branch && typeof branch === "object") {
+                refineRequiredKeysInSchema(branch, [...pathPrefix, "oneOf", i], ctx);
+            }
+        });
+    }
+}
 function typeOfValue(value) {
     if (value === null)
         return "null";
@@ -30,13 +225,45 @@ function typeOfValue(value) {
 /**
  * Validates a variable value against an array schema. Recursively validates each item
  * when the schema defines `items` (nested arrays/objects use the same refinement).
+ * Enforces minItems, maxItems, and uniqueItems when set.
  */
-function refineVariableValueArray(projectConfig, variableSchema, variableValue, path, ctx, variableKey) {
+function refineVariableValueArray(projectConfig, variableSchema, variableValue, path, ctx, variableKey, schemasByKey) {
     const label = getVariableLabel(variableSchema, variableKey, path);
+    const minItems = variableSchema.minItems;
+    const maxItems = variableSchema.maxItems;
+    const uniqueItems = variableSchema.uniqueItems;
+    if (minItems !== undefined && variableValue.length < minItems) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Variable "${label}" (type array) length (${variableValue.length}) is less than \`minItems\` (${minItems}).`,
+            path,
+        });
+    }
+    if (maxItems !== undefined && variableValue.length > maxItems) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Variable "${label}" (type array) length (${variableValue.length}) is greater than \`maxItems\` (${maxItems}).`,
+            path,
+        });
+    }
+    if (uniqueItems) {
+        for (let i = 0; i < variableValue.length; i++) {
+            for (let j = i + 1; j < variableValue.length; j++) {
+                if (valueDeepEqual(variableValue[i], variableValue[j])) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Variable "${label}" (type array) has duplicate items at indices ${i} and ${j} but \`uniqueItems\` is true.`,
+                        path,
+                    });
+                    break;
+                }
+            }
+        }
+    }
     const itemSchema = variableSchema.items;
     if (itemSchema) {
         variableValue.forEach((item, index) => {
-            superRefineVariableValue(projectConfig, itemSchema, item, [...path, index], ctx, variableKey);
+            superRefineVariableValue(projectConfig, itemSchema, item, [...path, index], ctx, variableKey, schemasByKey);
         });
     }
     else {
@@ -63,12 +290,12 @@ function refineVariableValueArray(projectConfig, variableSchema, variableValue,
  * Validates a variable value against an object schema. Recursively validates each property
  * when the schema defines `properties` (nested objects/arrays use the same refinement).
  */
-function refineVariableValueObject(projectConfig, variableSchema, variableValue, path, ctx, variableKey) {
+function refineVariableValueObject(projectConfig, variableSchema, variableValue, path, ctx, variableKey, schemasByKey) {
     const label = getVariableLabel(variableSchema, variableKey, path);
     const schemaProperties = variableSchema.properties;
     if (schemaProperties && typeof schemaProperties === "object") {
         const requiredKeys = variableSchema.required && variableSchema.required.length > 0
-            ? variableSchema.required
+            ? variableSchema.required.filter((k) => Object.prototype.hasOwnProperty.call(schemaProperties, k))
             : Object.keys(schemaProperties);
         for (const key of requiredKeys) {
             if (!Object.prototype.hasOwnProperty.call(variableValue, key)) {
@@ -89,7 +316,7 @@ function refineVariableValueObject(projectConfig, variableSchema, variableValue,
                 });
             }
             else {
-                superRefineVariableValue(projectConfig, propSchema, variableValue[key], [...path, key], ctx, key);
+                superRefineVariableValue(projectConfig, propSchema, variableValue[key], [...path, key], ctx, key, schemasByKey);
             }
         }
     }
@@ -116,7 +343,7 @@ function refineVariableValueObject(projectConfig, variableSchema, variableValue,
         }
     }
 }
-function superRefineVariableValue(projectConfig, variableSchema, variableValue, path, ctx, variableKey) {
+function superRefineVariableValue(projectConfig, variableSchema, variableValue, path, ctx, variableKey, schemasByKey) {
     const label = getVariableLabel(variableSchema, variableKey, path);
     if (!variableSchema) {
         const variableName = path.length > 0 && typeof path[path.length - 1] === "string"
@@ -130,6 +357,60 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         });
         return;
     }
+    const effectiveSchema = resolveVariableSchema(variableSchema, schemasByKey);
+    if (variableSchema.schema && effectiveSchema === null) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Schema "${variableSchema.schema}" could not be loaded for value validation.`,
+            path,
+        });
+        return;
+    }
+    if (!effectiveSchema) {
+        return;
+    }
+    const effectiveOneOf = effectiveSchema.oneOf;
+    if (effectiveOneOf !== undefined && Array.isArray(effectiveOneOf) && effectiveOneOf.length > 0) {
+        const matchCount = effectiveOneOf.filter((branch) => valueMatchesSchema(branch, variableValue, schemasByKey)).length;
+        if (matchCount === 0) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" must match exactly one of the \`oneOf\` schemas (got ${JSON.stringify(variableValue)}; matched none).`,
+                path,
+            });
+        }
+        else if (matchCount > 1) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" must match exactly one of the \`oneOf\` schemas (matched ${matchCount}).`,
+                path,
+            });
+        }
+        return;
+    }
+    const effectiveConst = effectiveSchema.const;
+    if (effectiveConst !== undefined) {
+        if (!valueDeepEqual(variableValue, effectiveConst)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" must equal the constant value defined in schema (got ${JSON.stringify(variableValue)}).`,
+                path,
+            });
+        }
+        return;
+    }
+    const effectiveEnum = effectiveSchema.enum;
+    if (effectiveEnum !== undefined && Array.isArray(effectiveEnum) && effectiveEnum.length > 0) {
+        const allowed = effectiveEnum.some((v) => valueDeepEqual(variableValue, v));
+        if (!allowed) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" must be one of the allowed enum values (got ${JSON.stringify(variableValue)}).`,
+                path,
+            });
+        }
+        return;
+    }
     // Require a value (no undefined) for every variable usage
     if (variableValue === undefined) {
         ctx.addIssue({
@@ -139,9 +420,9 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
         });
         return;
     }
-    const expectedType = variableSchema.type;
+    const expectedType = effectiveSchema.type;
     const gotType = typeOfValue(variableValue);
-    // string — only string allowed
+    // string — only string allowed; schema minLength/maxLength/pattern applied when set
     if (expectedType === "string") {
         if (typeof variableValue !== "string") {
             ctx.addIssue({
@@ -151,6 +432,37 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
             });
             return;
         }
+        const strMinLen = effectiveSchema.minLength;
+        const strMaxLen = effectiveSchema.maxLength;
+        const strPattern = effectiveSchema.pattern;
+        if (strMinLen !== undefined && variableValue.length < strMinLen) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type string) length (${variableValue.length}) is less than \`minLength\` (${strMinLen}).`,
+                path,
+            });
+        }
+        if (strMaxLen !== undefined && variableValue.length > strMaxLen) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type string) length (${variableValue.length}) is greater than \`maxLength\` (${strMaxLen}).`,
+                path,
+            });
+        }
+        if (strPattern !== undefined) {
+            try {
+                if (!new RegExp(strPattern).test(variableValue)) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Variable "${label}" (type string) does not match \`pattern\`.`,
+                        path,
+                    });
+                }
+            }
+            catch {
+                // invalid regex already reported at schema parse time
+            }
+        }
         if (projectConfig.maxVariableStringLength &&
             variableValue.length > projectConfig.maxVariableStringLength) {
             ctx.addIssue({
@@ -185,6 +497,23 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
                 message: `Variable "${label}" (type integer) must be an integer; got ${variableValue}.`,
                 path,
             });
+            return;
+        }
+        const intMin = effectiveSchema.minimum;
+        const intMax = effectiveSchema.maximum;
+        if (intMin !== undefined && variableValue < intMin) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type integer) must be >= minimum (${intMin}); got ${variableValue}.`,
+                path,
+            });
+        }
+        if (intMax !== undefined && variableValue > intMax) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type integer) must be <= maximum (${intMax}); got ${variableValue}.`,
+                path,
+            });
         }
         return;
     }
@@ -204,6 +533,23 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
                 message: `Variable "${label}" (type double) must be a finite number; got ${variableValue}.`,
                 path,
             });
+            return;
+        }
+        const doubleMin = effectiveSchema.minimum;
+        const doubleMax = effectiveSchema.maximum;
+        if (doubleMin !== undefined && variableValue < doubleMin) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type double) must be >= minimum (${doubleMin}); got ${variableValue}.`,
+                path,
+            });
+        }
+        if (doubleMax !== undefined && variableValue > doubleMax) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Variable "${label}" (type double) must be <= maximum (${doubleMax}); got ${variableValue}.`,
+                path,
+            });
         }
         return;
     }
@@ -228,7 +574,7 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
             });
             return;
         }
-        refineVariableValueArray(projectConfig, variableSchema, variableValue, path, ctx, variableKey);
+        refineVariableValueArray(projectConfig, effectiveSchema, variableValue, path, ctx, variableKey, schemasByKey);
         return;
     }
     // object — only plain object allowed (no null, no array)
@@ -243,7 +589,7 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
             });
             return;
         }
-        refineVariableValueObject(projectConfig, variableSchema, variableValue, path, ctx, variableKey);
+        refineVariableValueObject(projectConfig, effectiveSchema, variableValue, path, ctx, variableKey, schemasByKey);
         return;
     }
     // json — only string containing valid JSON allowed
@@ -286,7 +632,7 @@ function superRefineVariableValue(projectConfig, variableSchema, variableValue,
     });
 }
 function refineForce({ ctx, parsedFeature, // eslint-disable-line
-variableSchemaByKey, variationValues, force, pathPrefix, projectConfig, }) {
+variableSchemaByKey, variationValues, force, pathPrefix, projectConfig, schemasByKey, }) {
     force.forEach((f, fN) => {
         // force[n].variation
         if (f.variation) {
@@ -301,17 +647,37 @@ variableSchemaByKey, variationValues, force, pathPrefix, projectConfig, }) {
         // force[n].variables[key]
         if (f.variables) {
             Object.keys(f.variables).forEach((variableKey) => {
-                superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], f.variables[variableKey], pathPrefix.concat([fN, "variables", variableKey]), ctx, variableKey);
+                const variableSchema = variableSchemaByKey[variableKey];
+                if (!variableSchema) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Variable "${variableKey}" is not defined in \`variablesSchema\`.`,
+                        path: pathPrefix.concat([fN, "variables", variableKey]),
+                    });
+                }
+                else {
+                    superRefineVariableValue(projectConfig, variableSchema, f.variables[variableKey], pathPrefix.concat([fN, "variables", variableKey]), ctx, variableKey, schemasByKey);
+                }
             });
         }
     });
 }
-function refineRules({ ctx, parsedFeature, variableSchemaByKey, variationValues, rules, pathPrefix, projectConfig, }) {
+function refineRules({ ctx, parsedFeature, variableSchemaByKey, variationValues, rules, pathPrefix, projectConfig, schemasByKey, }) {
     rules.forEach((rule, ruleN) => {
         // rules[n].variables[key]
         if (rule.variables) {
             Object.keys(rule.variables).forEach((variableKey) => {
-                superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], rule.variables[variableKey], pathPrefix.concat([ruleN, "variables", variableKey]), ctx, variableKey);
+                const variableSchema = variableSchemaByKey[variableKey];
+                if (!variableSchema) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: `Variable "${variableKey}" is not defined in \`variablesSchema\`.`,
+                        path: pathPrefix.concat([ruleN, "variables", variableKey]),
+                    });
+                }
+                else {
+                    superRefineVariableValue(projectConfig, variableSchema, rule.variables[variableKey], pathPrefix.concat([ruleN, "variables", variableKey]), ctx, variableKey, schemasByKey);
+                }
             });
         }
         // rules[n].variationWeights
@@ -366,9 +732,9 @@ function refineRules({ ctx, parsedFeature, variableSchemaByKey, variationValues,
         }
     });
 }
-function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttributeKeys, availableSegmentKeys, availableFeatureKeys) {
-    const propertyZodSchema = (0, propertySchema_1.getPropertyZodSchema)();
-    const variableValueZodSchema = propertySchema_1.valueZodSchema;
+function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttributeKeys, availableSegmentKeys, availableFeatureKeys, availableSchemaKeys = [], schemasByKey = {}) {
+    const schemaZodSchema = (0, schema_1.getSchemaZodSchema)(availableSchemaKeys);
+    const variableValueZodSchema = schema_1.valueZodSchema;
     const variationValueZodSchema = zod_1.z.string().min(1);
     const plainGroupSegment = zod_1.z.string().refine((value) => value === "*" || availableSegmentKeys.includes(value), (value) => ({
         message: `Unknown segment key "${value}"`,
@@ -494,17 +860,98 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
             .record(zod_1.z
             .object({
             deprecated: zod_1.z.boolean().optional(),
-            type: zod_1.z.union([zod_1.z.literal("json"), propertySchema_1.propertyTypeEnum]),
-            // array: when omitted, treated as array of strings
-            items: propertyZodSchema.optional(),
-            // object: when omitted, treated as flat object (primitive values only)
-            properties: zod_1.z.record(propertyZodSchema).optional(),
+            // Reference to a reusable schema (mutually exclusive with type/properties/required/items)
+            schema: zod_1.z
+                .string()
+                .refine((value) => availableSchemaKeys.includes(value), (value) => ({ message: `Unknown schema "${value}"` }))
+                .optional(),
+            // Inline schema (mutually exclusive with schema)
+            type: zod_1.z.union([zod_1.z.literal("json"), schema_1.propertyTypeEnum]).optional(),
+            items: schemaZodSchema.optional(),
+            properties: zod_1.z.record(schemaZodSchema).optional(),
+            required: zod_1.z.array(zod_1.z.string()).optional(),
+            enum: zod_1.z.array(variableValueZodSchema).optional(),
+            const: variableValueZodSchema.optional(),
+            oneOf: zod_1.z.array(schemaZodSchema).min(1).optional(),
+            minimum: zod_1.z.number().optional(),
+            maximum: zod_1.z.number().optional(),
+            minLength: zod_1.z.number().optional(),
+            maxLength: zod_1.z.number().optional(),
+            pattern: zod_1.z.string().optional(),
+            minItems: zod_1.z.number().optional(),
+            maxItems: zod_1.z.number().optional(),
+            uniqueItems: zod_1.z.boolean().optional(),
             description: zod_1.z.string().optional(),
             defaultValue: variableValueZodSchema,
             disabledValue: variableValueZodSchema.optional(),
             useDefaultWhenDisabled: zod_1.z.boolean().optional(),
         })
-            .strict())
+            .strict()
+            .superRefine((variableSchema, ctx) => {
+            const hasRef = "schema" in variableSchema && variableSchema.schema != null;
+            const hasInline = "type" in variableSchema &&
+                variableSchema.type != null &&
+                variableSchema.type !== undefined;
+            const hasOneOf = "oneOf" in variableSchema &&
+                Array.isArray(variableSchema.oneOf) &&
+                variableSchema.oneOf.length > 0;
+            if (hasRef && (hasInline || hasOneOf)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: "Variable schema cannot have both `schema` (reference) and inline properties (`type`, `oneOf`, `properties`, `required`, `items`). Use one or the other.",
+                    path: [],
+                });
+                return;
+            }
+            if (hasRef) {
+                const hasInlineStructure = ("type" in variableSchema && variableSchema.type != null) ||
+                    ("properties" in variableSchema && variableSchema.properties != null) ||
+                    ("required" in variableSchema && variableSchema.required != null) ||
+                    ("items" in variableSchema && variableSchema.items != null) ||
+                    ("oneOf" in variableSchema && variableSchema.oneOf != null);
+                const hasInlineValidation = ("minimum" in variableSchema && variableSchema.minimum !== undefined) ||
+                    ("maximum" in variableSchema && variableSchema.maximum !== undefined) ||
+                    ("minLength" in variableSchema && variableSchema.minLength !== undefined) ||
+                    ("maxLength" in variableSchema && variableSchema.maxLength !== undefined) ||
+                    ("pattern" in variableSchema && variableSchema.pattern !== undefined) ||
+                    ("minItems" in variableSchema && variableSchema.minItems !== undefined) ||
+                    ("maxItems" in variableSchema && variableSchema.maxItems !== undefined) ||
+                    ("uniqueItems" in variableSchema && variableSchema.uniqueItems !== undefined);
+                if (hasInlineStructure) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "When `schema` is set, do not set `type`, `oneOf`, `properties`, `required`, or `items`.",
+                        path: [],
+                    });
+                }
+                if (hasInlineValidation) {
+                    ctx.addIssue({
+                        code: zod_1.z.ZodIssueCode.custom,
+                        message: "When `schema` is set, do not set `minimum`, `maximum`, `minLength`, `maxLength`, `pattern`, `minItems`, `maxItems`, or `uniqueItems`; use the referenced schema to define these.",
+                        path: [],
+                    });
+                }
+                return;
+            }
+            if (!hasInline && !hasOneOf) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: "Variable schema must have either `schema` (reference to a schema key), `type` (inline schema), or `oneOf` (inline oneOf schemas).",
+                    path: [],
+                });
+                return;
+            }
+            if (hasInline && hasOneOf) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: "Variable schema cannot have both `type` and `oneOf` at the top level. Use one or the other.",
+                    path: [],
+                });
+                return;
+            }
+            // Validate required ⊆ properties at this level and in all nested object schemas
+            refineRequiredKeysInSchema(variableSchema, [], ctx);
+        }))
             .optional(),
         disabledVariationValue: variationValueZodSchema.optional(),
         variations: zod_1.z
@@ -574,6 +1021,10 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
         if (!value.variablesSchema) {
             return;
         }
+        // Every variable value is validated against its schema from variablesSchema. Sources covered:
+        // 1. variablesSchema[key].defaultValue  2. variablesSchema[key].disabledValue
+        // 3. variations[n].variables[key]       4. variations[n].variableOverrides[key][].value
+        // 5. rules[env][n].variables[key]       6. force[env][n].variables[key]
         const variableSchemaByKey = value.variablesSchema;
         const variationValues = [];
         if (value.variations) {
@@ -585,6 +1036,21 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
         const variableKeys = Object.keys(variableSchemaByKey);
         variableKeys.forEach((variableKey) => {
             const variableSchema = variableSchemaByKey[variableKey];
+            // When type and enum are both present, all enum values must match the type
+            const effectiveSchema = resolveVariableSchema(variableSchema, schemasByKey);
+            if (effectiveSchema &&
+                effectiveSchema.type &&
+                Array.isArray(effectiveSchema.enum) &&
+                effectiveSchema.enum.length > 0) {
+                (0, schema_1.refineEnumMatchesType)(effectiveSchema, ["variablesSchema", variableKey], ctx);
+            }
+            // Inline variable schemas: validate minimum/maximum, minLength/maxLength/pattern, minItems/maxItems/uniqueItems
+            if (!("schema" in variableSchema) || !variableSchema.schema) {
+                const pathPrefix = ["variablesSchema", variableKey];
+                (0, schema_1.refineMinimumMaximum)(variableSchema, pathPrefix, ctx);
+                (0, schema_1.refineStringLengthPattern)(variableSchema, pathPrefix, ctx);
+                (0, schema_1.refineArrayItems)(variableSchema, pathPrefix, ctx);
+            }
             if (variableKey === "variation") {
                 ctx.addIssue({
                     code: zod_1.z.ZodIssueCode.custom,
@@ -593,38 +1059,55 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
                 });
             }
             // defaultValue
-            superRefineVariableValue(projectConfig, variableSchema, variableSchema.defaultValue, ["variablesSchema", variableKey, "defaultValue"], ctx, variableKey);
+            superRefineVariableValue(projectConfig, variableSchema, variableSchema.defaultValue, ["variablesSchema", variableKey, "defaultValue"], ctx, variableKey, schemasByKey);
             // disabledValue (only when present)
             if (variableSchema.disabledValue !== undefined) {
-                superRefineVariableValue(projectConfig, variableSchema, variableSchema.disabledValue, ["variablesSchema", variableKey, "disabledValue"], ctx, variableKey);
+                superRefineVariableValue(projectConfig, variableSchema, variableSchema.disabledValue, ["variablesSchema", variableKey, "disabledValue"], ctx, variableKey, schemasByKey);
             }
         });
-        // variations
+        // variations: validate variation.variables and variation.variableOverrides (each value against its variable schema)
         if (value.variations) {
             value.variations.forEach((variation, variationN) => {
-                if (!variation.variables) {
-                    return;
-                }
                 // variations[n].variables[key]
-                for (const variableKey of Object.keys(variation.variables)) {
-                    const variableValue = variation.variables[variableKey];
-                    superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], variableValue, ["variations", variationN, "variables", variableKey], ctx, variableKey);
-                    // variations[n].variableOverrides[n].value
-                    if (variation.variableOverrides) {
-                        for (const variableKey of Object.keys(variation.variableOverrides)) {
-                            const overrides = variation.variableOverrides[variableKey];
-                            if (Array.isArray(overrides)) {
-                                overrides.forEach((override, overrideN) => {
-                                    superRefineVariableValue(projectConfig, variableSchemaByKey[variableKey], override.value, [
-                                        "variations",
-                                        variationN,
-                                        "variableOverrides",
-                                        variableKey,
-                                        overrideN,
-                                        "value",
-                                    ], ctx, variableKey);
-                                });
-                            }
+                if (variation.variables) {
+                    for (const variableKey of Object.keys(variation.variables)) {
+                        const variableValue = variation.variables[variableKey];
+                        const variableSchema = variableSchemaByKey[variableKey];
+                        if (!variableSchema) {
+                            ctx.addIssue({
+                                code: zod_1.z.ZodIssueCode.custom,
+                                message: `Variable "${variableKey}" is not defined in \`variablesSchema\`.`,
+                                path: ["variations", variationN, "variables", variableKey],
+                            });
+                        }
+                        else {
+                            superRefineVariableValue(projectConfig, variableSchema, variableValue, ["variations", variationN, "variables", variableKey], ctx, variableKey, schemasByKey);
+                        }
+                    }
+                }
+                // variations[n].variableOverrides[key][].value (validated even when variation.variables is absent)
+                if (variation.variableOverrides) {
+                    for (const variableKey of Object.keys(variation.variableOverrides)) {
+                        const overrides = variation.variableOverrides[variableKey];
+                        const variableSchema = variableSchemaByKey[variableKey];
+                        if (!variableSchema) {
+                            ctx.addIssue({
+                                code: zod_1.z.ZodIssueCode.custom,
+                                message: `Variable "${variableKey}" is not defined in \`variablesSchema\`.`,
+                                path: ["variations", variationN, "variableOverrides", variableKey],
+                            });
+                        }
+                        else if (Array.isArray(overrides)) {
+                            overrides.forEach((override, overrideN) => {
+                                superRefineVariableValue(projectConfig, variableSchema, override.value, [
+                                    "variations",
+                                    variationN,
+                                    "variableOverrides",
+                                    variableKey,
+                                    overrideN,
+                                    "value",
+                                ], ctx, variableKey, schemasByKey);
+                            });
                         }
                     }
                 }
@@ -643,6 +1126,7 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
                         pathPrefix: ["rules", environmentKey],
                         ctx,
                         projectConfig,
+                        schemasByKey,
                     });
                 }
                 // force
@@ -655,6 +1139,7 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
                         pathPrefix: ["force", environmentKey],
                         ctx,
                         projectConfig,
+                        schemasByKey,
                     });
                 }
             }
@@ -671,6 +1156,7 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
                     pathPrefix: ["rules"],
                     ctx,
                     projectConfig,
+                    schemasByKey,
                 });
             }
             // force
@@ -683,6 +1169,7 @@ function getFeatureZodSchema(projectConfig, conditionsZodSchema, availableAttrib
                     pathPrefix: ["force"],
                     ctx,
                     projectConfig,
+                    schemasByKey,
                 });
             }
         }