diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..558f002
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,95 @@
+# Changelog
+
+All notable changes to FancyEnumGenerator. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and the project uses [Semantic Versioning](https://semver.org/). Before 1.0, a minor version bump (0.1 → 0.2) can
+include breaking changes, and each one comes with upgrade notes.
+
+## [0.2.0] - 2026-10-01
+
+Thanks to [the suggestion on Reddit](https://www.reddit.com/r/moderndotnet/comments/1wu7mrh/comment/pd7erju/) to return a
+`ReadOnlySpan<T>` from `Values` instead of an inline array: since a span over constants is static data, nothing needs
+to be copied.
+
+### Changed
+
+- **`Values` is now a `ReadOnlySpan<T>` by default.** The compiler stores the members as static data in your
+  assembly, so `Values` no longer copies anything or allocates. This needs .NET 7+, except for enums with a 1-byte
+  underlying type (`byte`, `sbyte`), which now get `Values` on every target, .NET Framework and netstandard2.0
+  included. In 0.1, `Values` was a fresh `[InlineArray]` copy on every access and needed .NET 8+.
+- **The new `ValuesType` setting chooses what `Values` returns**, with the same precedence as every other setting: on
+  `[FancyEnum]`, on `[assembly: FancyEnumDefaults]` or as the MSBuild property `FancyEnumValuesType`. The options are
+  `Span` (the default), `InlineArray` (0.1's default: a storable copy) and `StaticCollection` (a cached
+  `IReadOnlyList<T>`). `InlineArray` and `StaticCollection` also generate `AsSpan`; with `Span`, `Values` already is
+  the span.
+- **`NoInlineArray` now only controls the `[InlineArray]` struct.** Flags enums lose `ListFlagMembers` with it, and
+  `ValuesType = InlineArray` isn't available alongside it.
+- **The `{Enum}Array` struct is only generated when something uses it:** flags enums, for `ListFlagMembers`, and
+  `ValuesType = InlineArray`.
+
+### Removed
+
+- **`CreateStaticReadonlyCollection`**, on both attributes and as the MSBuild property
+  `FancyEnumCreateStaticReadonlyCollection`. Use `ValuesType = FancyEnumValuesType.StaticCollection`.
+
+### Added
+
+- **`FancyEnumValuesType`**, the enum behind `ValuesType`.
+- **HENUM017 (warning):** an explicitly chosen `ValuesType` can't be generated for the current target. That's `Span` on
+  an enum wider than a byte before .NET 7, `InlineArray` before .NET 8, or `InlineArray` with `NoInlineArray`.
+  `Values` is left out for that target only, so a multi-targeted project still builds. The default never warns.
+
+### Fixed
+
+- **An enum named `Inline` no longer breaks the build.** Its generated `InlineArray` struct shadowed the attribute alias
+  in the generated file (CS0616). The attribute is now fully qualified.
+
+### Upgrading from 0.1
+
+Most code needs no changes: `foreach (var value in MyEnum.Values)` and `MyEnum.Values[i]` work the same with every
+`ValuesType`. What does need attention:
+
+| If your 0.1 code... | ...do this in 0.2 |
+|---|---|
+| Sets `CreateStaticReadonlyCollection = true` | Set `ValuesType = FancyEnumValuesType.StaticCollection`. `AsSpan` is unchanged. `Values` becomes an `IReadOnlyList<T>`, where on .NET 8+ it used to be a cached inline-array copy. |
+| Sets `<FancyEnumCreateStaticReadonlyCollection>true</FancyEnumCreateStaticReadonlyCollection>` | Use `<FancyEnumValuesType>StaticCollection</FancyEnumValuesType>`. |
+| Stores the default `Values` in a field, keeps it across an `await`, captures it in a lambda or uses it in an iterator | A span can't do that. Set `ValuesType = FancyEnumValuesType.InlineArray` (exactly 0.1's behavior) or `StaticCollection` (no copy at all), or call `.ToArray()`. |
+| Assigns the default `Values` to a `Span<T>` | Use `ReadOnlySpan<T>`. The members are read-only data now. |
+| Names the `{Enum}Array` type for a non-flags enum, e.g. `FruitArray values = Fruit.Values;` | Use `var` or `ReadOnlySpan<Fruit>`, or set `ValuesType = InlineArray` to keep the struct. |
+| Uses `AsSpan` on an enum that only had it because of `CreateStaticReadonlyCollection` | Either keep it with `ValuesType = StaticCollection`, or move to the default and use `Values`, which is the span. |
+| Combines `NoInlineArray = true` with `CreateStaticReadonlyCollection = true` | Use `ValuesType = StaticCollection`. Keep `NoInlineArray` only if you also want flags enums without `ListFlagMembers`. |
+
+To keep 0.1's `Values` behavior across a whole repo while you migrate, set this in `Directory.Build.props`:
+
+```xml
+<PropertyGroup>
+  <FancyEnumValuesType>InlineArray</FancyEnumValuesType>
+</PropertyGroup>
+```
+
+A note on Debug builds: the JIT doesn't optimize `RuntimeHelpers.CreateSpan` in unoptimized code, so the default
+`Values` allocates in a Debug build. Release builds are allocation-free.
+
+## [0.1.2] - 2026-09-29
+
+### Added
+
+- **`FancyEnumMemberSetItem.NotDefined`:** a string member-set property can fall back to the member's name (`NameOf`,
+  `NameOfLower`, `NameOfUpper`) for members that don't set it, like `NotDefined` on `[FancyEnumMemberMappingSettings]`.
+  It works with `ParseFrom`, `CreateTryFormat` and `IncludeUtf8Value`. `DefaultValue` wins if both are set. On a
+  non-string property it reports HENUM012 and is ignored.
+
+## [0.1.1] - 2026-09-29
+
+### Changed
+
+- Documentation only: full benchmark results, generated from the BenchmarkDotNet reports, and refreshed performance
+  numbers in the README.
+
+## [0.1.0] - 2026-09-29
+
+- First public release.
+
+[0.2.0]: https://github.com/htmlcsstoimage/FancyEnumGenerator/compare/v0.1.2...v0.2.0
+[0.1.2]: https://github.com/htmlcsstoimage/FancyEnumGenerator/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/htmlcsstoimage/FancyEnumGenerator/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/htmlcsstoimage/FancyEnumGenerator/releases/tag/v0.1.0
diff --git a/Directory.Build.props b/Directory.Build.props
index be669e5..1a9b91b 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -6,7 +6,7 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <ManagePackageVersionsCentrally>false</ManagePackageVersionsCentrally>
-        <Version>0.1.2</Version>
+        <Version>0.2.0</Version>
     </PropertyGroup>
 
     <!--
diff --git a/FancyEnumGenerator.slnx b/FancyEnumGenerator.slnx
index ad575a2..a2ca6d1 100644
--- a/FancyEnumGenerator.slnx
+++ b/FancyEnumGenerator.slnx
@@ -5,6 +5,7 @@
     <File Path="global.json" />
     <File Path="LICENSE" />
     <File Path="README.md" />
+    <File Path="CHANGELOG.md" />
   </Folder>
   <Folder Name="/.github/" />
   <Folder Name="/.github/workflows/">
diff --git a/README.md b/README.md
index 5303db9..06cb19d 100644
--- a/README.md
+++ b/README.md
@@ -49,7 +49,7 @@ Fruit.TryParseFancy("Banana", out var f);  // true, f == Fruit.Banana
 Fruit.Apple.IsUnknown;                     // false
 ((Fruit)7).IsUnknown;                      // true
 Fruit.Unknown.IsUnknown;                   // true
-Fruit.Values;                              // every non-Unknown member (Apple, Banana, Cherry)
+Fruit.Values;                              // every non-Unknown member (Apple, Banana, Cherry), as a ReadOnlySpan
 ```
 
 `[FancyEnum]` enforces two rules by default (both can be relaxed — see [Settings](#settings)):
@@ -143,7 +143,7 @@ The settings you're most likely to change:
 | `DefaultToStringBehavior` | `NameOf` | What `ToStringFancy()` returns: the name, lower- or upper-cased, a field's value, or the member's `[Description]`, `[Display]`, `[EnumMember]` or `[JsonStringEnumMemberName]`. |
 | `CreateByteParsing` | `false` | Add UTF-8 (`ReadOnlySpan<byte>`) parse overloads. |
 | `CreateTryFormat` | `false` | Add `TryFormat(Span<char>, out int)`, which formats into your own buffer. |
-| `CreateStaticReadonlyCollection` | `false` | Cache `Values` in a static field and add a zero-copy `AsSpan`. |
+| `ValuesType` | `Span` | What `Values` returns: a zero-copy `ReadOnlySpan<T>` (`Span`), a storable inline-array copy (`InlineArray`) or a cached `IReadOnlyList<T>` (`StaticCollection`). |
 | `IncludeObsolete` | `false` | Generate `[Obsolete]` members too; by default they're left out. |
 
 Each can be set in three places. For each setting, the first of these that sets it wins:
@@ -306,6 +306,7 @@ references a static readonly field or parameterless static method instead of a l
 | HENUM014 | A mapped field would generate a member whose name FancyEnum or `System.Enum` already uses (e.g. `Length`, `Values`, `ToString`), or that another field also generates. |
 | HENUM015 | A member-set property can never be set: its type can't be an attribute argument, or it's read-only with no constructor parameter mapped to it. |
 | HENUM016 (warning) | An enum uses a member-set attribute but has no `[FancyEnum]`, so nothing is generated for it. |
+| HENUM017 (warning) | An explicitly chosen `ValuesType` can't be generated for this target (`Span` on a wider-than-byte enum before .NET 7, `InlineArray` before .NET 8 or with `NoInlineArray`), so `Values` is left out there. |
 
 ## Examples
 
@@ -329,13 +330,13 @@ Nothing here allocates except where noted.
 
 ## Footprint
 
-- **No runtime state by default.** Generated members are `switch` expressions over constants and string literals, so an
-  enum adds no static fields and no heap allocations, even on first use. The one exception is the opt-in
-  `CreateStaticReadonlyCollection`: it adds one lazily filled buffer of N × the enum's size, or a plain array when
-  combined with `NoInlineArray`.
-- **Code size, in exchange.** The generated code is compiled into your assembly. In a release build that's about 6.5 KB
-  for a 25-member enum with default settings, about 11.5 KB with UTF-8 parsing, `TryFormat` and the cached collection
-  all on, and about 38 KB for a 200-member enum. Much of that is parsing: exact and case-insensitive lookups each get
+- **No runtime state by default.** Generated members are `switch` expressions over constants and string literals, and
+  `Values` is a span over data stored in your assembly, so an enum adds no static fields and no heap allocations, even
+  on first use. The one exception is the opt-in `ValuesType = StaticCollection`, which adds one array of the members,
+  created once.
+- **Code size, in exchange.** The generated code is compiled into your assembly. In a release build that's about 6 KB
+  for a 25-member enum with default settings, about 10 KB with UTF-8 parsing, `TryFormat` and a cached collection
+  all on, and about 36 KB for a 200-member enum. Much of that is parsing: exact and case-insensitive lookups each get
   their own set of `switch` cases. On top of that comes about 1.5 KB of shared parsing helpers, once per assembly. The
   BCL and reflection-based libraries add no code to your assembly; instead they build their caches at runtime.
 
@@ -346,7 +347,7 @@ Nothing here allocates except where noted.
 
 ## About
 
-FancyEnumGenerator is built and maintained by [HTML/CSS to Image](https://htmlcsstoimage.com), an API for turning HTML/CSS or a URL into an image. We use it for the 150-plus enums across our own codebase. For the story behind it, and how the parsers got fast, see [the blog post](https://htmlcsstoimage.com/blog/fancy-enum-generator).
+FancyEnumGenerator is built and maintained by [HTML/CSS to Image](https://htmlcsstoimage.com), an API for turning HTML/CSS or a URL into an image. We use it for the 150-plus enums across our own codebase. For the story behind it, and how the parsers got fast, see [the blog post](https://htmlcsstoimage.com/blog/fancy-enum-generator). Release notes and upgrade guides are in [CHANGELOG.md](https://github.com/htmlcsstoimage/FancyEnumGenerator/blob/main/CHANGELOG.md).
 
 ## License
 
diff --git a/benchmarks/FancyEnumGenerator.Benchmarks/Subjects.cs b/benchmarks/FancyEnumGenerator.Benchmarks/Subjects.cs
index 15ef431..f3dfa9a 100644
--- a/benchmarks/FancyEnumGenerator.Benchmarks/Subjects.cs
+++ b/benchmarks/FancyEnumGenerator.Benchmarks/Subjects.cs
@@ -20,7 +20,7 @@ public sealed class StationInfoAttribute : Attribute
     public int Order { get; set; }
 }
 
-[FancyEnum(CreateByteParsing = true, CreateTryFormat = true, CreateStaticReadonlyCollection = true)]
+[FancyEnum(CreateByteParsing = true, CreateTryFormat = true)]
 public enum Medium
 {
     Unknown = 0,
@@ -565,6 +565,66 @@ public enum MediumDescribed
     [Description("early valley")] EarlyValley = 24,
 }
 
+[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)]
+public enum MediumInline
+{
+    Unknown = 0,
+    AmberHarbor = 1,
+    IronHarbor = 2,
+    QuietHarbor = 3,
+    EarlyFalcon = 4,
+    MistyFalcon = 5,
+    AmberMeadow = 6,
+    IronMeadow = 7,
+    QuietMeadow = 8,
+    EarlySummit = 9,
+    MistySummit = 10,
+    AmberCanyon = 11,
+    IronCanyon = 12,
+    QuietCanyon = 13,
+    EarlyRiver = 14,
+    MistyRiver = 15,
+    AmberForest = 16,
+    IronForest = 17,
+    QuietForest = 18,
+    EarlyBeacon = 19,
+    MistyBeacon = 20,
+    AmberGlacier = 21,
+    IronGlacier = 22,
+    QuietGlacier = 23,
+    EarlyValley = 24,
+}
+
+[FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)]
+public enum MediumCached
+{
+    Unknown = 0,
+    AmberHarbor = 1,
+    IronHarbor = 2,
+    QuietHarbor = 3,
+    EarlyFalcon = 4,
+    MistyFalcon = 5,
+    AmberMeadow = 6,
+    IronMeadow = 7,
+    QuietMeadow = 8,
+    EarlySummit = 9,
+    MistySummit = 10,
+    AmberCanyon = 11,
+    IronCanyon = 12,
+    QuietCanyon = 13,
+    EarlyRiver = 14,
+    MistyRiver = 15,
+    AmberForest = 16,
+    IronForest = 17,
+    QuietForest = 18,
+    EarlyBeacon = 19,
+    MistyBeacon = 20,
+    AmberGlacier = 21,
+    IronGlacier = 22,
+    QuietGlacier = 23,
+    EarlyValley = 24,
+}
+
 [FancyEnum]
 public enum Station
 {
diff --git a/benchmarks/FancyEnumGenerator.Benchmarks/ValueBenchmarks.cs b/benchmarks/FancyEnumGenerator.Benchmarks/ValueBenchmarks.cs
index ac2d236..7564285 100644
--- a/benchmarks/FancyEnumGenerator.Benchmarks/ValueBenchmarks.cs
+++ b/benchmarks/FancyEnumGenerator.Benchmarks/ValueBenchmarks.cs
@@ -25,10 +25,10 @@ public void Setup()
 }
 
 /// <summary>
-/// Enumerating every member (summing the values, so the loop can't be elided). The BCL and NetEscapades both return a
-/// new array per call; on .NET 10 the JIT can stack-allocate NetEscapades' array here, because once inlined it never
-/// escapes this loop, but code that stores or passes the array on still pays for it. FancyEnum's Values/AsSpan exclude
-/// the Unknown member, so it walks 24 members where the others walk 25.
+/// Enumerating every member (summing the values, so the loop can't be elided), once per FancyEnum ValuesType. The BCL
+/// and NetEscapades both return a new array per call; on .NET 10 the JIT can stack-allocate NetEscapades' array here,
+/// because once inlined it never escapes this loop, but code that stores or passes the array on still pays for it.
+/// FancyEnum's Values/AsSpan exclude the Unknown member, so it walks 24 members where the others walk 25.
 /// </summary>
 [Config(typeof(BenchmarkConfig))]
 public class ValuesBenchmarks
@@ -44,8 +44,9 @@ public int Bcl()
         return sum;
     }
 
+    /// <summary>The default: a span over static data in the assembly.</summary>
     [Benchmark]
-    public int FancyEnum_Values()
+    public int FancyEnum_Span()
     {
         var sum = 0;
         foreach (var value in Medium.Values)
@@ -55,11 +56,36 @@ public int FancyEnum_Values()
         return sum;
     }
 
+    /// <summary>A fresh inline-array copy per call, which can be stored or kept across an await.</summary>
     [Benchmark]
-    public int FancyEnum_AsSpan()
+    public int FancyEnum_InlineArray()
     {
         var sum = 0;
-        foreach (var value in Medium.AsSpan)
+        foreach (var value in MediumInline.Values)
+        {
+            sum += (int)value;
+        }
+        return sum;
+    }
+
+    /// <summary>The cached IReadOnlyList, enumerated through the interface.</summary>
+    [Benchmark]
+    public int FancyEnum_StaticCollection()
+    {
+        var sum = 0;
+        foreach (var value in MediumCached.Values)
+        {
+            sum += (int)value;
+        }
+        return sum;
+    }
+
+    /// <summary>The span over the cached array that StaticCollection also generates.</summary>
+    [Benchmark]
+    public int FancyEnum_StaticCollection_AsSpan()
+    {
+        var sum = 0;
+        foreach (var value in MediumCached.AsSpan)
         {
             sum += (int)value;
         }
diff --git a/benchmarks/combine_results.cs b/benchmarks/combine_results.cs
index ff6a340..076b5e6 100644
--- a/benchmarks/combine_results.cs
+++ b/benchmarks/combine_results.cs
@@ -36,7 +36,7 @@
     ("IsDefinedBenchmarks", "Is a value declared?",
         "For a contiguous and a sparse enum. FancyEnum's check is `!IsUnknown`."),
     ("ValuesBenchmarks", "Enumerating every member",
-        "Summing every member's value. FancyEnum's `Values`/`AsSpan` leave out `Unknown`, so they walk 24 members where the others walk 25. NetEscapades' `GetValues()` returns a new array per call, which .NET 10's JIT can stack-allocate here because the array never leaves the loop."),
+        "Summing every member's value, once for each FancyEnum `ValuesType`: the default `Span`, `InlineArray` (a storable copy) and `StaticCollection` (a cached `IReadOnlyList`, also through its `AsSpan`). FancyEnum leaves out `Unknown`, so it walks 24 members where the others walk 25. NetEscapades' `GetValues()` returns a new array per call, which .NET 10's JIT can stack-allocate here because the array never leaves the loop."),
     ("TryFormatBenchmarks", "Formatting into a buffer",
         "`TryFormat` into a caller-supplied `Span<char>`."),
 ];
diff --git a/benchmarks/generate_subjects.cs b/benchmarks/generate_subjects.cs
index 090cff8..cb3dcba 100644
--- a/benchmarks/generate_subjects.cs
+++ b/benchmarks/generate_subjects.cs
@@ -51,7 +51,7 @@ public sealed class StationInfoAttribute : Attribute
 // Compared across all libraries: (name, FancyEnum attributes, body), each also emitted as Ne{name} for NetEscapades.
 (string Name, string Fancy, string Body)[] shared =
 [
-    ("Medium", "[FancyEnum(CreateByteParsing = true, CreateTryFormat = true, CreateStaticReadonlyCollection = true)]", unknown + Members(medium, description)),
+    ("Medium", "[FancyEnum(CreateByteParsing = true, CreateTryFormat = true)]", unknown + Members(medium, description)),
     ("Large", "[FancyEnum]", unknown + Members(large)),
 ];
 foreach (var (name, fancy, body) in shared)
@@ -66,6 +66,9 @@ public sealed class StationInfoAttribute : Attribute
 // FancyEnum picks its ToString source per enum, so descriptions get their own copy of Medium; the BCL reads
 // [Description] off Medium by reflection for the same comparison.
 parts.Add(Enum("MediumDescribed", "[FancyEnum(DefaultToStringBehavior = FancyEnumDefaultToStringBehavior.DescriptionAttribute)]", unknown + Members(medium, description)));
+// The same members with each of the other ValuesType options, for the enumeration benchmark (Medium uses the default, Span).
+parts.Add(Enum("MediumInline", "[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)]", unknown + Members(medium)));
+parts.Add(Enum("MediumCached", "[FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)]", unknown + Members(medium)));
 // Custom per-member metadata: FancyEnum generates accessors; the BCL reads the attribute at runtime.
 parts.Add(Enum("Station", "[FancyEnum]", unknown + Members(medium, stationInfo)));
 
diff --git a/docs/benchmarks.md b/docs/benchmarks.md
index 5570d79..a704d1d 100644
--- a/docs/benchmarks.md
+++ b/docs/benchmarks.md
@@ -191,7 +191,7 @@ Apple M1 Max, 1 CPU, 10 logical and 10 physical cores
 
 ## Enumerating every member
 
-Summing every member's value. FancyEnum's `Values`/`AsSpan` leave out `Unknown`, so they walk 24 members where the others walk 25. NetEscapades' `GetValues()` returns a new array per call, which .NET 10's JIT can stack-allocate here because the array never leaves the loop.
+Summing every member's value, once for each FancyEnum `ValuesType`: the default `Span`, `InlineArray` (a storable copy) and `StaticCollection` (a cached `IReadOnlyList`, also through its `AsSpan`). FancyEnum leaves out `Unknown`, so it walks 24 members where the others walk 25. NetEscapades' `GetValues()` returns a new array per call, which .NET 10's JIT can stack-allocate here because the array never leaves the loop.
 
 ```
 
@@ -203,12 +203,14 @@ Apple M1 Max, 1 CPU, 10 logical and 10 physical cores
 
 
 ```
-| Method           | Mean      | Error     | StdDev    | Ratio | Allocated | Alloc Ratio |
-|----------------- |----------:|----------:|----------:|------:|----------:|------------:|
-| Bcl              | 30.476 ns | 0.6104 ns | 0.5994 ns |  1.00 |     128 B |        1.00 |
-| FancyEnum_Values |  9.668 ns | 0.1438 ns | 0.1345 ns |  0.32 |         - |        0.00 |
-| FancyEnum_AsSpan |  8.861 ns | 0.1153 ns | 0.1079 ns |  0.29 |         - |        0.00 |
-| NetEscapades     |  9.479 ns | 0.0944 ns | 0.0837 ns |  0.31 |         - |        0.00 |
+| Method                            | Mean      | Error     | StdDev    | Ratio | Allocated | Alloc Ratio |
+|---------------------------------- |----------:|----------:|----------:|------:|----------:|------------:|
+| Bcl                               | 32.179 ns | 0.6662 ns | 1.0946 ns |  1.00 |     128 B |        1.00 |
+| FancyEnum_Span                    |  8.645 ns | 0.1238 ns | 0.0967 ns |  0.27 |         - |        0.00 |
+| FancyEnum_InlineArray             |  9.247 ns | 0.0632 ns | 0.0528 ns |  0.29 |         - |        0.00 |
+| FancyEnum_StaticCollection        |  8.577 ns | 0.1220 ns | 0.1141 ns |  0.27 |         - |        0.00 |
+| FancyEnum_StaticCollection_AsSpan |  8.571 ns | 0.1135 ns | 0.1062 ns |  0.27 |         - |        0.00 |
+| NetEscapades                      |  9.594 ns | 0.1027 ns | 0.0910 ns |  0.30 |         - |        0.00 |
 
 ## Formatting into a buffer
 
diff --git a/docs/how-it-works.md b/docs/how-it-works.md
index 256fbc2..bb1f209 100644
--- a/docs/how-it-works.md
+++ b/docs/how-it-works.md
@@ -158,10 +158,18 @@ fields, header names), and it isn't worth a cleverer structure for such a niche
 - **Field mappings**: members that map a field to the same value share one `case`. When three or more of them have
   consecutive values, the case becomes a range pattern (`>= A and <= C`) instead of a list, so the switch stays short
   even for mostly-uniform mappings.
-- **`Values` / `AsSpan`**: on .NET 8+, `Values` is an `[InlineArray]` struct built on each access. It's a value-type
-  copy, not a heap allocation. `CreateStaticReadonlyCollection` caches it in a static field, filled in lazily, and adds
-  an `AsSpan` view over that field without copying. Everything else is `const`, so an enum has no static state by
-  default.
+- **`Values`**: by default it's `ReadOnlySpan<T> Values => [A, B, C];`. With constant elements the compiler doesn't
+  build an array: it stores the members as data in the assembly and returns a span over it (through
+  `RuntimeHelpers.CreateSpan`), so every access is the same memory, with no allocation and no copy. Before .NET 7 that
+  only works for 1-byte types; for anything wider the compiler would allocate a new array on every access, so the
+  property is wrapped in `#if NET7_0_OR_GREATER` and simply doesn't exist on those targets. The opt-in `ValuesType`
+  options trade this for something storable: `InlineArray` builds a fresh `[InlineArray]` struct on each access (a
+  stack copy, .NET 8+), and `StaticCollection` keeps one array in a static field. Both also get an `AsSpan`. Everything
+  else is `const`, so by default an enum has no static state at all. See [`ValuesType`](settings.md#valuestype).
+- **Target-specific code stays in `#if` blocks.** The generator doesn't emit different code per target framework:
+  the same generated file compiles everywhere, with `#if NET7_0_OR_GREATER` and `#if NET8_0_OR_GREATER` around the
+  members that need those runtimes. Only the HENUM017 warning looks at the target, through the compilation's
+  preprocessor symbols.
 
 ## Incremental generation
 
diff --git a/docs/settings.md b/docs/settings.md
index 8e7515b..c5bc10a 100644
--- a/docs/settings.md
+++ b/docs/settings.md
@@ -166,36 +166,48 @@ Adds `IsValidPrefixFancy(prefix, next)`, which answers "could these UTF-8 bytes
 streaming decoders that want to give up on an unknown name early instead of buffering all of it. It's niche, and
 independent of `CreateByteParsing`. See [its own page](is-valid-prefix.md).
 
-### Collections: `CreateStaticReadonlyCollection`, `NoInlineArray`
+### Collections: `ValuesType`, `NoInlineArray`
 
-#### `CreateStaticReadonlyCollection`
+#### `ValuesType`
 
-**Default:** `false`
+**Default:** `Span`
+
+`Values` lists the declared members, except `Unknown` and any marked [`ExcludeFromValues`](#excludefromvalues).
+`ValuesType` (a `FancyEnumValuesType`) picks what it returns:
 
-`Values` lists the declared members, except `Unknown` and any marked [`ExcludeFromValues`](#excludefromvalues). By
-default it's built fresh on each access as an inline-array struct (.NET 8+), which is a value copy on the stack, not
-a heap allocation, and there's no static state at all. That fits most uses: `foreach (var fruit in Fruit.Values)`.
+| `ValuesType` | `Values` is | Can be stored / kept across `await` | Cost | Targets |
+|---|---|---|---|---|
+| `Span` (default) | `ReadOnlySpan<T>` over static data in your assembly | No, it's a ref struct | Nothing: no allocation, no copy, no static field | .NET 7+; on older targets only 1-byte enums (`byte`, `sbyte`) |
+| `InlineArray` | `{Name}Array`, a fresh `[InlineArray]` copy | Yes | A copy of every member per access, on the stack | .NET 8+ |
+| `StaticCollection` | `IReadOnlyList<T>` over a cached array | Yes | One small array, created once | Every target |
 
-`CreateStaticReadonlyCollection = true` keeps one copy in a static field instead, filled in on first access, and adds
-`AsSpan`: a `ReadOnlySpan<T>` over that field, with no copy. Use it when you pass the members around as a span, or
-read them very often.
+`InlineArray` and `StaticCollection` also add `AsSpan`, a zero-copy `ReadOnlySpan<T>` over the same members, for
+loops and LINQ-over-span code. With `Span`, `Values` already is that span.
 
-What you get depends on the target and on `NoInlineArray`:
+`Span` is the default because most code just iterates: `foreach (var fruit in Fruit.Values)`. There the span is as
+cheap as enumeration gets. The compiler stores the members as data in your assembly, so each access returns a span
+over the same memory. In a Debug build the JIT doesn't optimize `RuntimeHelpers.CreateSpan`, so it allocates there;
+Release builds don't. When you need to keep the members in a field or across an `await`, choose `InlineArray` (no
+heap at all, but a copy per access) or `StaticCollection` (no copy, one cached array). You can set it per enum, per
+assembly, or repo-wide with `<FancyEnumValuesType>InlineArray</FancyEnumValuesType>`.
 
-| | Default | `CreateStaticReadonlyCollection = true` |
-|---|---|---|
-| .NET 8+ | `Values`: inline array, built per access | `Values`: inline array, cached; `AsSpan` |
-| Older targets, or `NoInlineArray = true` | Nothing generated | `Values`: `IReadOnlyList<T>` over a static array; `AsSpan` |
+`StaticCollection`'s `Values` is an `IReadOnlyList<T>` rather than the array itself, so callers can't modify the shared
+copy. Enumerating it through the interface is slower than a span, so prefer its `AsSpan` in hot loops.
 
-`Values` is an `IReadOnlyList<T>` rather than the array itself, so callers can't modify the shared copy.
+**When it isn't available.** On a target that can't provide the chosen type, `Values` (and `AsSpan`, where it depends
+on the same feature) is left out for that target only, so a multi-targeted project still builds its other targets.
+If you set `ValuesType` explicitly, on the enum, the assembly, or in MSBuild, this is reported as the warning
+**HENUM017**. That happens for `Span` on an enum wider than a byte on targets older than .NET 7, for `InlineArray` on
+targets older than .NET 8, and for `InlineArray` together with `NoInlineArray`. Leaving `ValuesType` at its default
+never warns. Promote it with `<WarningsAsErrors>HENUM017</WarningsAsErrors>` if you'd rather it fail the build.
 
 #### `NoInlineArray`
 
 **Default:** `false`
 
-Stops the generator from emitting the `{Name}Array` inline-array struct on .NET 8+. Without it, `Values` and `AsSpan`
-exist only with `CreateStaticReadonlyCollection` (backed by a plain array), and flags enums lose `ListFlagMembers`.
-It's for when you'd rather not have the extra public struct in your assembly.
+Stops the generator from emitting any `{Name}Array` inline-array struct. Flags enums then lose `ListFlagMembers`, and
+`ValuesType = InlineArray` isn't available (**HENUM017**). It's for when you'd rather not have the extra public struct
+in your assembly.
 
 ## Assembly-wide only
 
diff --git a/examples/FancyEnumGenerator.Examples/FieldMappings.cs b/examples/FancyEnumGenerator.Examples/FieldMappings.cs
index 18f0829..656796e 100644
--- a/examples/FancyEnumGenerator.Examples/FieldMappings.cs
+++ b/examples/FancyEnumGenerator.Examples/FieldMappings.cs
@@ -2,10 +2,10 @@
 // See Generated/.../Beverage.FancyEnum.g.cs.
 using FancyEnumGenerator.Attributes;
 
-// CreateStaticReadonlyCollection = true: opts into a cached Values/AsSpan pair (built once, lazily, on
-// first access) instead of the default (Values freshly built on every access, no AsSpan at all - see
-// Fruit in BasicUsage.cs for that default).
-[FancyEnum(CreateStaticReadonlyCollection = true)]
+// ValuesType = StaticCollection: Values is an IReadOnlyList over an array created once and cached, so it can be
+// stored or kept across an await, plus AsSpan over the same array. The default (see Fruit in BasicUsage.cs) is a
+// ReadOnlySpan over static data instead.
+[FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)]
 [FancyEnumMemberMappingSettings("Label", NotDefined = FancyEnumMemberFallbackOption.NameOfLower)]
 [FancyEnumMemberMappingSettings<int>("SortOrder", NotDefined = -1)]
 public enum Beverage
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Beverage.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Beverage.FancyEnum.g.cs
index 55056e4..92c4057 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Beverage.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Beverage.FancyEnum.g.cs
@@ -5,38 +5,9 @@
 using CharSpan = global::System.ReadOnlySpan<char>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 3 <see cref="global::Beverage"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(3)]
-public struct BeverageArray {
-	private global::Beverage _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::Beverage"/>.</summary>
 public static partial class BeverageFancyEnumExtensions {
-	#if NET8_0_OR_GREATER
-	private static BeverageArray s_values;
-	private static volatile bool s_valuesInitialized;
-	private static void EnsureBeverageValues() {
-		if (!s_valuesInitialized) {
-			s_values = CreateBeverageValues();
-			s_valuesInitialized = true;
-		}
-		
-	}
-	private static BeverageArray CreateBeverageValues() {
-		BeverageArray values = default;
-		values[0] = thisEnum.Coffee;
-		values[1] = thisEnum.Tea;
-		values[2] = thisEnum.Juice;
-		return values;
-	}
-	#else
 	private static readonly global::Beverage[] s_values = [thisEnum.Coffee, thisEnum.Tea, thisEnum.Juice];
-	#endif
 	extension(global::Beverage value) {
 		/// <summary>This value as its underlying <c>int</c>.</summary>
 		public int AsUnderlying => (int)value;
@@ -171,29 +142,10 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Be
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Beverage ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, cached in a static field on first access. Returned by value, so the caller gets its own copy of the inline buffer.</summary>
-		public static BeverageArray Values {
-			get {
-				EnsureBeverageValues();
-				return s_values;
-			}
-			
-		}
-		/// <summary>The same members as <c>Values</c>, as a read-only span over the cached static storage: no copy, no allocation.</summary>
-		public static global::System.ReadOnlySpan<global::Beverage> AsSpan {
-			get {
-				EnsureBeverageValues();
-				return global::System.Runtime.InteropServices.MemoryMarshal.CreateReadOnlySpan(ref global::System.Runtime.CompilerServices.Unsafe.As<BeverageArray, global::Beverage>(ref global::System.Runtime.CompilerServices.Unsafe.AsRef(in s_values)), 3);
-			}
-			
-		}
-		#else
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, backed by a shared static array. Read-only: the array itself is never exposed.</summary>
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only list over an array created once and cached in a static field.</summary>
 		public static global::System.Collections.Generic.IReadOnlyList<global::Beverage> Values => s_values;
-		/// <summary>The same members as <c>Values</c>, as a read-only span over the cached static storage: no copy, no allocation.</summary>
+		/// <summary>The same members as <c>Values</c>, as a read-only span over the cached array: no copy, no allocation.</summary>
 		public static global::System.ReadOnlySpan<global::Beverage> AsSpan => s_values;
-		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
 	public const int Length = 4;
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/FlagWithObsolete.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/FlagWithObsolete.FancyEnum.g.cs
index c5ff973..a746932 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/FlagWithObsolete.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/FlagWithObsolete.FancyEnum.g.cs
@@ -6,11 +6,8 @@
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
 #if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 3 <see cref="global::FlagWithObsolete"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(3)]
+/// <summary>A fixed-size inline buffer of 3 <see cref="global::FlagWithObsolete"/> values, as returned by <c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
+[global::System.Runtime.CompilerServices.InlineArray(3)]
 public struct FlagWithObsoleteArray {
 	private global::FlagWithObsolete _element0;
 }
@@ -313,18 +310,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Fl
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::FlagWithObsolete ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static FlagWithObsoleteArray Values {
-			get {
-				FlagWithObsoleteArray values = default;
-				values[0] = thisEnum.Search;
-				values[1] = thisEnum.Export;
-				values[2] = thisEnum.Sharing;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::FlagWithObsolete> Values => [thisEnum.Search, thisEnum.Export, thisEnum.Sharing];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Fruit.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Fruit.FancyEnum.g.cs
index eeb2362..02d92ee 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Fruit.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Fruit.FancyEnum.g.cs
@@ -5,16 +5,6 @@
 using CharSpan = global::System.ReadOnlySpan<char>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 3 <see cref="global::Fruit"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(3)]
-public struct FruitArray {
-	private global::Fruit _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::Fruit"/>.</summary>
 public static partial class FruitFancyEnumExtensions {
 	extension(global::Fruit value) {
@@ -131,18 +121,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Fr
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Fruit ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static FruitArray Values {
-			get {
-				FruitArray values = default;
-				values[0] = thisEnum.Apple;
-				values[1] = thisEnum.Banana;
-				values[2] = thisEnum.Cherry;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::Fruit> Values => [thisEnum.Apple, thisEnum.Banana, thisEnum.Cherry];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Gadget.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Gadget.FancyEnum.g.cs
index e7a7922..d8d3217 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Gadget.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Gadget.FancyEnum.g.cs
@@ -5,16 +5,6 @@
 using CharSpan = global::System.ReadOnlySpan<char>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 2 <see cref="global::Gadget"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(2)]
-public struct GadgetArray {
-	private global::Gadget _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::Gadget"/>.</summary>
 public static partial class GadgetFancyEnumExtensions {
 	extension(global::Gadget value) {
@@ -79,17 +69,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Ga
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Gadget ParseOrDefault(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Sprocket;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static GadgetArray Values {
-			get {
-				GadgetArray values = default;
-				values[0] = thisEnum.Sprocket;
-				values[1] = thisEnum.Cog;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::Gadget> Values => [thisEnum.Sprocket, thisEnum.Cog];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/HttpHeader.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/HttpHeader.FancyEnum.g.cs
index 57d642c..55e67cb 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/HttpHeader.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/HttpHeader.FancyEnum.g.cs
@@ -6,16 +6,6 @@
 using ByteSpan = global::System.ReadOnlySpan<byte>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 89 <see cref="global::HttpHeader"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(89)]
-public struct HttpHeaderArray {
-	private global::HttpHeader _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::HttpHeader"/>.</summary>
 public static partial class HttpHeaderFancyEnumExtensions {
 	extension(global::HttpHeader value) {
@@ -2029,104 +2019,9 @@ public static bool TryParseFancy(ByteSpan input, bool ignoreCase, out global::Ht
 		/// <param name="input">The UTF-8 bytes to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::HttpHeader ParseOrUnknown(ByteSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static HttpHeaderArray Values {
-			get {
-				HttpHeaderArray values = default;
-				values[0] = thisEnum.Accept;
-				values[1] = thisEnum.AcceptCharset;
-				values[2] = thisEnum.AcceptEncoding;
-				values[3] = thisEnum.AcceptLanguage;
-				values[4] = thisEnum.AcceptRanges;
-				values[5] = thisEnum.AccessControlAllowCredentials;
-				values[6] = thisEnum.AccessControlAllowHeaders;
-				values[7] = thisEnum.AccessControlAllowMethods;
-				values[8] = thisEnum.AccessControlAllowOrigin;
-				values[9] = thisEnum.AccessControlExposeHeaders;
-				values[10] = thisEnum.AccessControlMaxAge;
-				values[11] = thisEnum.AccessControlRequestHeaders;
-				values[12] = thisEnum.AccessControlRequestMethod;
-				values[13] = thisEnum.Age;
-				values[14] = thisEnum.Allow;
-				values[15] = thisEnum.AltSvc;
-				values[16] = thisEnum.Authorization;
-				values[17] = thisEnum.CacheControl;
-				values[18] = thisEnum.ClearSiteData;
-				values[19] = thisEnum.Connection;
-				values[20] = thisEnum.ContentDisposition;
-				values[21] = thisEnum.ContentEncoding;
-				values[22] = thisEnum.ContentLanguage;
-				values[23] = thisEnum.ContentLength;
-				values[24] = thisEnum.ContentLocation;
-				values[25] = thisEnum.ContentRange;
-				values[26] = thisEnum.ContentSecurityPolicy;
-				values[27] = thisEnum.ContentSecurityPolicyReportOnly;
-				values[28] = thisEnum.ContentType;
-				values[29] = thisEnum.Cookie;
-				values[30] = thisEnum.CrossOriginEmbedderPolicy;
-				values[31] = thisEnum.CrossOriginOpenerPolicy;
-				values[32] = thisEnum.CrossOriginResourcePolicy;
-				values[33] = thisEnum.Date;
-				values[34] = thisEnum.ETag;
-				values[35] = thisEnum.Expect;
-				values[36] = thisEnum.Expires;
-				values[37] = thisEnum.Forwarded;
-				values[38] = thisEnum.From;
-				values[39] = thisEnum.Host;
-				values[40] = thisEnum.IfMatch;
-				values[41] = thisEnum.IfModifiedSince;
-				values[42] = thisEnum.IfNoneMatch;
-				values[43] = thisEnum.IfRange;
-				values[44] = thisEnum.IfUnmodifiedSince;
-				values[45] = thisEnum.KeepAlive;
-				values[46] = thisEnum.LastModified;
-				values[47] = thisEnum.Link;
-				values[48] = thisEnum.Location;
-				values[49] = thisEnum.MaxForwards;
-				values[50] = thisEnum.Origin;
-				values[51] = thisEnum.PermissionsPolicy;
-				values[52] = thisEnum.Pragma;
-				values[53] = thisEnum.Priority;
-				values[54] = thisEnum.ProxyAuthenticate;
-				values[55] = thisEnum.ProxyAuthorization;
-				values[56] = thisEnum.Range;
-				values[57] = thisEnum.Referer;
-				values[58] = thisEnum.ReferrerPolicy;
-				values[59] = thisEnum.RetryAfter;
-				values[60] = thisEnum.SecFetchDest;
-				values[61] = thisEnum.SecFetchMode;
-				values[62] = thisEnum.SecFetchSite;
-				values[63] = thisEnum.SecFetchUser;
-				values[64] = thisEnum.SecWebSocketAccept;
-				values[65] = thisEnum.SecWebSocketExtensions;
-				values[66] = thisEnum.SecWebSocketKey;
-				values[67] = thisEnum.SecWebSocketProtocol;
-				values[68] = thisEnum.SecWebSocketVersion;
-				values[69] = thisEnum.Server;
-				values[70] = thisEnum.ServerTiming;
-				values[71] = thisEnum.SetCookie;
-				values[72] = thisEnum.StrictTransportSecurity;
-				values[73] = thisEnum.Te;
-				values[74] = thisEnum.TimingAllowOrigin;
-				values[75] = thisEnum.Trailer;
-				values[76] = thisEnum.TransferEncoding;
-				values[77] = thisEnum.Upgrade;
-				values[78] = thisEnum.UpgradeInsecureRequests;
-				values[79] = thisEnum.UserAgent;
-				values[80] = thisEnum.Vary;
-				values[81] = thisEnum.Via;
-				values[82] = thisEnum.WwwAuthenticate;
-				values[83] = thisEnum.XContentTypeOptions;
-				values[84] = thisEnum.XForwardedFor;
-				values[85] = thisEnum.XForwardedHost;
-				values[86] = thisEnum.XForwardedProto;
-				values[87] = thisEnum.XFrameOptions;
-				values[88] = thisEnum.XRequestId;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::HttpHeader> Values => [thisEnum.Accept, thisEnum.AcceptCharset, thisEnum.AcceptEncoding, thisEnum.AcceptLanguage, thisEnum.AcceptRanges, thisEnum.AccessControlAllowCredentials, thisEnum.AccessControlAllowHeaders, thisEnum.AccessControlAllowMethods, thisEnum.AccessControlAllowOrigin, thisEnum.AccessControlExposeHeaders, thisEnum.AccessControlMaxAge, thisEnum.AccessControlRequestHeaders, thisEnum.AccessControlRequestMethod, thisEnum.Age, thisEnum.Allow, thisEnum.AltSvc, thisEnum.Authorization, thisEnum.CacheControl, thisEnum.ClearSiteData, thisEnum.Connection, thisEnum.ContentDisposition, thisEnum.ContentEncoding, thisEnum.ContentLanguage, thisEnum.ContentLength, thisEnum.ContentLocation, thisEnum.ContentRange, thisEnum.ContentSecurityPolicy, thisEnum.ContentSecurityPolicyReportOnly, thisEnum.ContentType, thisEnum.Cookie, thisEnum.CrossOriginEmbedderPolicy, thisEnum.CrossOriginOpenerPolicy, thisEnum.CrossOriginResourcePolicy, thisEnum.Date, thisEnum.ETag, thisEnum.Expect, thisEnum.Expires, thisEnum.Forwarded, thisEnum.From, thisEnum.Host, thisEnum.IfMatch, thisEnum.IfModifiedSince, thisEnum.IfNoneMatch, thisEnum.IfRange, thisEnum.IfUnmodifiedSince, thisEnum.KeepAlive, thisEnum.LastModified, thisEnum.Link, thisEnum.Location, thisEnum.MaxForwards, thisEnum.Origin, thisEnum.PermissionsPolicy, thisEnum.Pragma, thisEnum.Priority, thisEnum.ProxyAuthenticate, thisEnum.ProxyAuthorization, thisEnum.Range, thisEnum.Referer, thisEnum.ReferrerPolicy, thisEnum.RetryAfter, thisEnum.SecFetchDest, thisEnum.SecFetchMode, thisEnum.SecFetchSite, thisEnum.SecFetchUser, thisEnum.SecWebSocketAccept, thisEnum.SecWebSocketExtensions, thisEnum.SecWebSocketKey, thisEnum.SecWebSocketProtocol, thisEnum.SecWebSocketVersion, thisEnum.Server, thisEnum.ServerTiming, thisEnum.SetCookie, thisEnum.StrictTransportSecurity, thisEnum.Te, thisEnum.TimingAllowOrigin, thisEnum.Trailer, thisEnum.TransferEncoding, thisEnum.Upgrade, thisEnum.UpgradeInsecureRequests, thisEnum.UserAgent, thisEnum.Vary, thisEnum.Via, thisEnum.WwwAuthenticate, thisEnum.XContentTypeOptions, thisEnum.XForwardedFor, thisEnum.XForwardedHost, thisEnum.XForwardedProto, thisEnum.XFrameOptions, thisEnum.XRequestId];
 		#endif
 	}
 	private static bool TryParseFancy__Exact4(CharSpan input, out global::HttpHeader result) {
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Permission.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Permission.FancyEnum.g.cs
index 8b8cb63..98f95a7 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Permission.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Permission.FancyEnum.g.cs
@@ -6,11 +6,8 @@
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
 #if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 3 <see cref="global::Permission"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(3)]
+/// <summary>A fixed-size inline buffer of 3 <see cref="global::Permission"/> values, as returned by <c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
+[global::System.Runtime.CompilerServices.InlineArray(3)]
 public struct PermissionArray {
 	private global::Permission _element0;
 }
@@ -330,18 +327,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Pe
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Permission ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static PermissionArray Values {
-			get {
-				PermissionArray values = default;
-				values[0] = thisEnum.Read;
-				values[1] = thisEnum.Write;
-				values[2] = thisEnum.Execute;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::Permission> Values => [thisEnum.Read, thisEnum.Write, thisEnum.Execute];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Vegetable.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Vegetable.FancyEnum.g.cs
index 3e30759..c987b33 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Vegetable.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Vegetable.FancyEnum.g.cs
@@ -5,16 +5,6 @@
 using CharSpan = global::System.ReadOnlySpan<char>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 2 <see cref="global::Vegetable"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(2)]
-public struct VegetableArray {
-	private global::Vegetable _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::Vegetable"/>.</summary>
 public static partial class VegetableFancyEnumExtensions {
 	extension(global::Vegetable value) {
@@ -100,17 +90,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Ve
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Vegetable ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static VegetableArray Values {
-			get {
-				VegetableArray values = default;
-				values[0] = thisEnum.Carrot;
-				values[1] = thisEnum.Potato;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::Vegetable> Values => [thisEnum.Carrot, thisEnum.Potato];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Widget.FancyEnum.g.cs b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Widget.FancyEnum.g.cs
index 4d92d69..e941977 100644
--- a/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Widget.FancyEnum.g.cs
+++ b/examples/FancyEnumGenerator.Examples/Generated/FancyEnumGenerator/FancyEnumGenerator.FancyEnumSourceGenerator/Widget.FancyEnum.g.cs
@@ -5,16 +5,6 @@
 using CharSpan = global::System.ReadOnlySpan<char>;
 using StringComparison = global::System.StringComparison;
 using static global::System.MemoryExtensions;
-#if NET8_0_OR_GREATER
-using InlineArray = global::System.Runtime.CompilerServices.InlineArrayAttribute;
-#endif
-#if NET8_0_OR_GREATER
-/// <summary>A fixed-size inline buffer of 3 <see cref="global::Widget"/> values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>
-[InlineArray(3)]
-public struct WidgetArray {
-	private global::Widget _element0;
-}
-#endif
 /// <summary>FancyEnum-generated extension members, and compile-time constants, for <see cref="global::Widget"/>.</summary>
 public static partial class WidgetFancyEnumExtensions {
 	extension(global::Widget value) {
@@ -147,18 +137,9 @@ public static bool TryParseFancy(CharSpan input, bool ignoreCase, out global::Wi
 		/// <param name="input">The text to parse.</param>
 		/// <param name="ignoreCase">Whether to ignore ASCII case.</param>
 		public static global::Widget ParseOrUnknown(CharSpan input, bool ignoreCase) => thisEnum.TryParseFancy(input, ignoreCase, out var result) ? result : thisEnum.Unknown;
-		#if NET8_0_OR_GREATER
-		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.</summary>
-		public static WidgetArray Values {
-			get {
-				WidgetArray values = default;
-				values[0] = thisEnum.Sprocket;
-				values[1] = thisEnum.Cog;
-				values[2] = thisEnum.Gear;
-				return values;
-			}
-			
-		}
+		#if NET7_0_OR_GREATER
+		/// <summary>Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order, as a read-only span over static data in the assembly: no copy, no allocation. A ref struct, so it can't be stored in a field or kept across an <c>await</c>. Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.</summary>
+		public static global::System.ReadOnlySpan<global::Widget> Values => [thisEnum.Sprocket, thisEnum.Cog, thisEnum.Gear];
 		#endif
 	}
 	/// <summary>The number of distinct declared values, including the Unknown member (members sharing a numeric value count once). A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.</summary>
diff --git a/examples/FancyEnumGenerator.Examples/Program.cs b/examples/FancyEnumGenerator.Examples/Program.cs
index 6186001..a0a1f22 100644
--- a/examples/FancyEnumGenerator.Examples/Program.cs
+++ b/examples/FancyEnumGenerator.Examples/Program.cs
@@ -4,11 +4,10 @@
 Console.WriteLine($"Fruit.Apple.IsUnknown: {Fruit.Apple.IsUnknown}");
 Console.WriteLine($"Fruit.Unknown.IsUnknown: {Fruit.Unknown.IsUnknown}");
 
-// Fruit uses the default (CreateStaticReadonlyCollection = false): Values is freshly built on every
-// access (cheap - a value-type copy, not a heap allocation) and there is no AsSpan at all, since a
-// freshly-built value has no stable backing store for a span to safely point at.
+// Fruit uses the default ValuesType (Span): Values is a ReadOnlySpan over static data in the assembly, so there's no
+// allocation and no copy. Being a span, it can't be stored in a field or kept across an await.
 var fruitValues = Fruit.Values;
-Console.WriteLine($"Fruit.Values.GetType(): {fruitValues.GetType().Name} (the inline-array struct, freshly built)");
+Console.WriteLine($"Fruit.Values.Length: {fruitValues.Length} (a ReadOnlySpan over static data)");
 Console.WriteLine($"Fruit.Values contents: {fruitValues[0]}, {fruitValues[1]}, {fruitValues[2]}");
 
 Console.WriteLine();
@@ -19,9 +18,8 @@
 Console.WriteLine($"Beverage.Juice.Label (fallback, NameOfLower): {Beverage.Juice.Label}");
 Console.WriteLine($"Beverage.Juice.SortOrder (fallback, NotDefined=-1): {Beverage.Juice.SortOrder}");
 
-// Beverage sets CreateStaticReadonlyCollection = true: Values/AsSpan are backed by the same lazily-built
-// static storage. Verify the Unsafe.As/MemoryMarshal reinterpretation is actually correct at runtime
-// (matches Values element-by-element), not just that it compiles.
+// Beverage sets ValuesType = StaticCollection: Values is an IReadOnlyList over a cached array, and AsSpan is a span
+// over that same array.
 var beverageValues = Beverage.Values;
 ReadOnlySpan<Beverage> beverageSpan = Beverage.AsSpan;
 Console.WriteLine($"Beverage.AsSpan.Length: {beverageSpan.Length}");
diff --git a/src/FancyEnumGenerator.Attributes/FancyEnumAttributes.cs b/src/FancyEnumGenerator.Attributes/FancyEnumAttributes.cs
index d50e6b0..5e2f345 100644
--- a/src/FancyEnumGenerator.Attributes/FancyEnumAttributes.cs
+++ b/src/FancyEnumGenerator.Attributes/FancyEnumAttributes.cs
@@ -73,6 +73,32 @@ public enum FancyEnumDefaultToStringBehavior
     JsonStringEnumMemberNameAttribute
 }
 
+/// <summary>What the generated <c>Values</c> property returns. See <see cref="FancyEnumAttribute.ValuesType"/>.</summary>
+public enum FancyEnumValuesType
+{
+    /// <summary>
+    /// A <c>ReadOnlySpan&lt;T&gt;</c> over the members, which the compiler stores as static data in your assembly: no
+    /// allocation, no copy and no static field. It's a ref struct, so it can't be stored in a field or kept across an
+    /// <c>await</c>. Needs .NET 7+, except for enums with a 1-byte underlying type (<c>byte</c>, <c>sbyte</c>), which
+    /// get it on every target.
+    /// </summary>
+    Span,
+
+    /// <summary>
+    /// A fresh copy of the members in a generated <c>[InlineArray]</c> struct: no heap allocation, and an ordinary
+    /// value type you can store or keep across an <c>await</c>. Each access copies every member. Needs .NET 8+ and is
+    /// unavailable with <see cref="FancyEnumAttribute.NoInlineArray"/>.
+    /// </summary>
+    InlineArray,
+
+    /// <summary>
+    /// An <see cref="System.Collections.Generic.IReadOnlyList{T}"/> over an array created once and cached in a static
+    /// field: storable, no copy per access, and available on every target. Costs one small array for the lifetime of
+    /// the app.
+    /// </summary>
+    StaticCollection
+}
+
 /// <summary>
 /// Generates fast extension members for this enum: <c>ToStringFancy()</c>, <c>TryParseFancy</c>/<c>ParseOrUnknown</c>,
 /// <c>FromUnderlying</c>, <c>IsUnknown</c>, <c>Values</c>, flags helpers, and a property per field mapping declared
@@ -92,23 +118,20 @@ public enum FancyEnumDefaultToStringBehavior
 public sealed class FancyEnumAttribute : Attribute
 {
     /// <summary>
-    /// Don't generate the .NET 8+ <c>[InlineArray]</c> struct. <c>Values</c>/<c>AsSpan</c> are then only generated
-    /// when <see cref="CreateStaticReadonlyCollection"/> is also set (backed by a plain array), and flags enums lose
-    /// <c>ListFlagMembers</c>. Default: <see langword="false"/>.
+    /// What <c>Values</c> returns: a zero-copy span (<see cref="FancyEnumValuesType.Span"/>), a storable inline-array
+    /// copy (<see cref="FancyEnumValuesType.InlineArray"/>) or a cached <c>IReadOnlyList&lt;T&gt;</c>
+    /// (<see cref="FancyEnumValuesType.StaticCollection"/>). The last two also get <c>AsSpan</c>, a zero-copy
+    /// <c>ReadOnlySpan&lt;T&gt;</c> over the same members, wherever the target supports it. When the chosen type can't be generated
+    /// for the current target, <c>Values</c> is left out and an explicitly set value reports HENUM017.
+    /// Default: <see cref="FancyEnumValuesType.Span"/>.
     /// </summary>
-    public bool NoInlineArray { get; set; }
+    public FancyEnumValuesType ValuesType { get; set; }
 
     /// <summary>
-    /// Cache the member collection in a static field, built lazily on first access, and also generate <c>AsSpan</c>
-    /// (a zero-copy <c>ReadOnlySpan&lt;T&gt;</c> over it). Default: <see langword="false"/>, in which case
-    /// on .NET 8+ <c>Values</c> is built fresh on every access (a value-type copy, no heap allocation) and there is
-    /// no <c>AsSpan</c>; on older targets neither is generated.
+    /// Don't generate any .NET 8+ <c>[InlineArray]</c> struct: flags enums lose <c>ListFlagMembers</c>, and
+    /// <see cref="FancyEnumValuesType.InlineArray"/> isn't available (HENUM017). Default: <see langword="false"/>.
     /// </summary>
-    /// <remarks>
-    /// When the collection is a plain array (older targets, or <see cref="NoInlineArray"/>), <c>Values</c> is typed
-    /// <see cref="System.Collections.Generic.IReadOnlyList{T}"/> so callers can't mutate the shared storage.
-    /// </remarks>
-    public bool CreateStaticReadonlyCollection { get; set; }
+    public bool NoInlineArray { get; set; }
 
     /// <summary>
     /// Allow gaps between the enum's numeric values. Without this, non-contiguous values are a build error (HENUM002).
@@ -186,8 +209,8 @@ public sealed class FancyEnumDefaultsAttribute : Attribute
     /// <summary>Default for <see cref="FancyEnumAttribute.NoInlineArray"/>.</summary>
     public bool NoInlineArray { get; set; }
 
-    /// <summary>Default for <see cref="FancyEnumAttribute.CreateStaticReadonlyCollection"/>.</summary>
-    public bool CreateStaticReadonlyCollection { get; set; }
+    /// <summary>Default for <see cref="FancyEnumAttribute.ValuesType"/>.</summary>
+    public FancyEnumValuesType ValuesType { get; set; }
 
     /// <summary>Default for <see cref="FancyEnumAttribute.AllowNonContiguous"/>.</summary>
     public bool AllowNonContiguous { get; set; }
diff --git a/src/FancyEnumGenerator/AnalyzerReleases.Unshipped.md b/src/FancyEnumGenerator/AnalyzerReleases.Unshipped.md
index f2b7fad..62820a4 100644
--- a/src/FancyEnumGenerator/AnalyzerReleases.Unshipped.md
+++ b/src/FancyEnumGenerator/AnalyzerReleases.Unshipped.md
@@ -1,2 +1,8 @@
 ; Unshipped analyzer release
 ; https://github.com/dotnet/roslyn-analyzers/blob/main/src/Microsoft.CodeAnalysis.Analyzers/ReleaseTrackingAnalyzers.Help.md
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+HENUM017 | FancyEnum | Warning | Values type unavailable for this target
diff --git a/src/FancyEnumGenerator/EnumGeneratorDiagnostics.cs b/src/FancyEnumGenerator/EnumGeneratorDiagnostics.cs
index 248a793..66a4a1c 100644
--- a/src/FancyEnumGenerator/EnumGeneratorDiagnostics.cs
+++ b/src/FancyEnumGenerator/EnumGeneratorDiagnostics.cs
@@ -20,6 +20,7 @@ internal static class EnumGeneratorDiagnostics
     public static readonly DiagnosticDescriptor ReservedFieldName = Create("HENUM014", "Mapped field name collides with a generated member", "Enum '{0}' field '{1}' would generate member '{2}', which {3}; rename the field");
     public static readonly DiagnosticDescriptor MemberSetPropertyUnusable = Create("HENUM015", "Member-set property can never be set", "Property '{0}.{1}' {2}; mark it [FancyEnumMemberSetItem(Ignore = true)] or change it");
     public static readonly DiagnosticDescriptor MemberSetWithoutFancyEnum = Create("HENUM016", "Member-set attribute on an enum without [FancyEnum]", "Enum '{0}' uses member-set attribute '{1}' but has no [FancyEnum], so nothing is generated for it; add [FancyEnum]", DiagnosticSeverity.Warning);
+    public static readonly DiagnosticDescriptor ValuesTypeUnavailable = Create("HENUM017", "Values type unavailable for this target", "Enum '{0}' sets ValuesType = {1}, but {2}, so Values isn't generated for this target", DiagnosticSeverity.Warning);
 
     private static DiagnosticDescriptor Create(string id, string title, string message, DiagnosticSeverity severity = DiagnosticSeverity.Error)
     {
diff --git a/src/FancyEnumGenerator/EnumModels.cs b/src/FancyEnumGenerator/EnumModels.cs
index fe11dfc..736eaf5 100644
--- a/src/FancyEnumGenerator/EnumModels.cs
+++ b/src/FancyEnumGenerator/EnumModels.cs
@@ -10,7 +10,10 @@ internal sealed record EnumModel
     public string UnderlyingType { get; init; } = "int";
     public string Accessibility { get; init; } = "internal";
     public bool NoInlineArray { get; init; }
-    public bool CreateStaticReadonlyCollection { get; init; }
+    public FancyEnumValuesType ValuesType { get; init; }
+    /// <summary>Whether ValuesType was set explicitly (enum, assembly or MSBuild), so an unavailable choice is worth reporting.</summary>
+    public bool ValuesTypeIsExplicit { get; init; }
+    public GeneratorLocationInfo? Location { get; init; }
     public bool AllowNonContiguous { get; init; }
     public bool AllowNoUnknown { get; init; }
     public bool IncludeObsolete { get; init; }
@@ -102,3 +105,13 @@ internal sealed record MemberMappingModel
     public string? StringValue { get; init; }
     public bool HasStaticMemberSource { get; init; }
 }
+
+/// <summary>What the current target supports, read from its preprocessor symbols (the same ones the generated <c>#if</c> blocks test).</summary>
+internal readonly record struct TargetFeatures(bool HasCreateSpan, bool HasInlineArray)
+{
+    public static TargetFeatures From(IEnumerable<string> preprocessorSymbols)
+    {
+        var symbols = preprocessorSymbols as ICollection<string> ?? preprocessorSymbols.ToArray();
+        return new TargetFeatures(symbols.Contains("NET7_0_OR_GREATER"), symbols.Contains("NET8_0_OR_GREATER"));
+    }
+}
diff --git a/src/FancyEnumGenerator/FancyEnumSourceGenerator.Emit.cs b/src/FancyEnumGenerator/FancyEnumSourceGenerator.Emit.cs
index 93767c6..79e3334 100644
--- a/src/FancyEnumGenerator/FancyEnumSourceGenerator.Emit.cs
+++ b/src/FancyEnumGenerator/FancyEnumSourceGenerator.Emit.cs
@@ -11,14 +11,13 @@ public sealed partial class FancyEnumSourceGenerator
     private const string CharSpanAlias = "CharSpan";
     private const string ByteSpanAlias = "ByteSpan";
     private const string StringComparisonAlias = "StringComparison";
-    private const string InlineArrayAlias = "InlineArray";
     /// <summary>The private const holding every declared single-bit flag of a flags enum (see <see cref="HasUndefinedFlagBits"/>).</summary>
     private const string AllDefinedFlagsName = "FancyFlagAllDefined";
 
     /// <summary>Whether <c>value</c> has any bit that isn't one of the enum's declared flags.</summary>
     private static string HasUndefinedFlagBits(EnumModel model) => $"(({model.UnderlyingType})value & ~{AllDefinedFlagsName}) != 0";
 
-    private static GenResult Emit(EnumModel model)
+    private static GenResult Emit(EnumModel model, TargetFeatures target)
     {
         var diagnostics = model.Diagnostics.ToList();
         if (model.FullyQualifiedName.Length == 0 || diagnostics.Any(static diagnostic => diagnostic.Descriptor == EnumGeneratorDiagnostics.UnsupportedEnumContainer))
@@ -52,7 +51,14 @@ private static GenResult Emit(EnumModel model)
         // The static extension properties forward to constants of the same name in this same class (see the end of it).
         var metadataType = $"{model.GeneratedName}FancyEnumExtensions";
         var valuesInitializer = string.Join(", ", arrayMembers.Select(member => $"{EnumTypeAlias}.{member.Name}"));
-        var createTargetConditionalValues = !model.NoInlineArray && arrayMembers.Length > 0;
+        var hasValues = arrayMembers.Length > 0;
+        // The [InlineArray] struct backs ListFlagMembers on flags enums and ValuesType = InlineArray, and nothing else.
+        var createInlineArrayType = !model.NoInlineArray && hasValues && (model.IsFlags || model.ValuesType == FancyEnumValuesType.InlineArray);
+        // A span over constant elements compiles to static data in the assembly: for 1-byte types on every target, for
+        // wider ones only where RuntimeHelpers.CreateSpan exists (.NET 7+). Anywhere else it would allocate an array
+        // on every access, so it isn't generated there.
+        var spanNeedsCreateSpan = model.UnderlyingType is not ("byte" or "sbyte");
+        AppendValuesTypeDiagnostics(model, target, hasValues, spanNeedsCreateSpan, diagnostics);
         var usesByteSpan = model.CreateByteParsing || model.CreateIsValidPrefix || model.MappingSettings.Any(static settings => settings.IncludeUtf8Value);
         var enumCref = $"<see cref=\"{model.FullyQualifiedName}\"/>";
         var lengthDoc = "The number of distinct declared values, including the Unknown member (members sharing a numeric value count once).";
@@ -74,22 +80,19 @@ private static GenResult Emit(EnumModel model)
         // it in scope; consumers can't be assumed to have `using System;` (e.g. ImplicitUsings off). `using static`
         // imports only that class's members, never System's type names, so it can't clash with the consumer's types.
         writer.AppendLine("using static global::System.MemoryExtensions;");
-        if (createTargetConditionalValues)
-        {
-            writer.AppendLine("#if NET8_0_OR_GREATER");
-            writer.AppendLine($"using {InlineArrayAlias} = global::System.Runtime.CompilerServices.InlineArrayAttribute;");
-            writer.AppendLine("#endif");
-        }
         if (model.Namespace.Length > 0)
         {
             writer.AppendLine($"namespace {model.Namespace};");
         }
 
-        if (createTargetConditionalValues)
+        if (createInlineArrayType)
         {
             writer.AppendLine("#if NET8_0_OR_GREATER");
-            writer.AppendLine($"/// <summary>A fixed-size inline buffer of {arrayMembers.Length} {enumCref} values, as returned by <c>Values</c>/<c>ListFlagMembers</c>: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>");
-            writer.AppendLine($"[{InlineArrayAlias}({arrayMembers.Length})]");
+            var returnedBy = string.Join("/", new[] { model.ValuesType == FancyEnumValuesType.InlineArray ? "<c>Values</c>" : null, model.IsFlags ? "<c>ListFlagMembers</c>" : null }.Where(static name => name is not null));
+            writer.AppendLine($"/// <summary>A fixed-size inline buffer of {arrayMembers.Length} {enumCref} values, as returned by {returnedBy}: a value type, so no heap allocation. Index it, <c>foreach</c> over it, or convert it to a span.</summary>");
+            // Fully qualified, not aliased: the struct this attribute marks is named {Enum}Array, so an enum called Inline
+            // would generate an InlineArray type that shadows any alias of that name.
+            writer.AppendLine($"[global::System.Runtime.CompilerServices.InlineArray({arrayMembers.Length})]");
             using (var arrayWriter = writer.StartBraced($"{model.Accessibility} struct {arrayType}"))
             {
                 arrayWriter.AppendLine($"private {model.FullyQualifiedName} _element0;");
@@ -110,26 +113,11 @@ private static GenResult Emit(EnumModel model)
                 var definedFlags = string.Join(" | ", members.Where(member => IsSingleBit(member.NumericValue, model.UnderlyingType)).Select(static member => $"{EnumTypeAlias}.{member.Name}"));
                 classWriter.AppendLine($"private const {model.UnderlyingType} {AllDefinedFlagsName} = ({model.UnderlyingType})({definedFlags});");
             }
-            if (model.CreateStaticReadonlyCollection && arrayMembers.Length > 0)
+            if (model.ValuesType == FancyEnumValuesType.StaticCollection && hasValues)
             {
-                // Opted into a cached, stable collection with a genuine AsSpan (below) - lazily built on first
-                // access rather than eagerly, so an enum nobody ever calls Values/AsSpan on pays nothing.
-                if (createTargetConditionalValues)
-                {
-                    classWriter.AppendLine("#if NET8_0_OR_GREATER");
-                    AppendLazyInlineValuesField(classWriter, model, arrayMembers, arrayType);
-                    classWriter.AppendLine("#else");
-                }
+                // The one array StaticCollection costs, created once. Span and InlineArray need no static field.
                 classWriter.AppendLine($"private static readonly {model.FullyQualifiedName}[] s_values = [{valuesInitializer}];");
-                if (createTargetConditionalValues)
-                {
-                    classWriter.AppendLine("#endif");
-                }
             }
-            // else (the default): no static field at all. On .NET 8+, Values is built fresh on every access
-            // (see AppendFreshInlineValues below) - cheap, since it's a value-type copy, not a heap allocation.
-            // On older targets there's no allocation-free alternative to offer, so Values/AsSpan simply aren't
-            // generated unless CreateStaticReadonlyCollection opts in.
 
             using (var valueExtension = classWriter.StartBraced($"extension({model.FullyQualifiedName} value)"))
             {
@@ -142,7 +130,7 @@ private static GenResult Emit(EnumModel model)
                         "<see langword=\"true\"/> if <c>(value &amp; flag) == flag</c>.",
                         ("flag", "The flag (or combination of flags) to test for."));
                     valueExtension.AppendLine($"public bool HasFlagFancy({model.FullyQualifiedName} flag) => (({model.UnderlyingType})value & ({model.UnderlyingType})flag) == ({model.UnderlyingType})flag;");
-                    if (createTargetConditionalValues)
+                    if (createInlineArrayType)
                     {
                         valueExtension.AppendLine("#if NET8_0_OR_GREATER");
                         AppendListFlagMembers(valueExtension, model, arrayMembers, arrayType);
@@ -279,32 +267,9 @@ private static GenResult Emit(EnumModel model)
                         staticExtension.AppendLine($"public static {model.FullyQualifiedName} {parseMethodName}({spanType} input, bool ignoreCase) => {EnumTypeAlias}.TryParseFancy(input, ignoreCase, out var result) ? result : {parseFallback};");
                     }
                 }
-                if (model.CreateStaticReadonlyCollection && arrayMembers.Length > 0)
+                if (hasValues)
                 {
-                    if (createTargetConditionalValues)
-                    {
-                        staticExtension.AppendLine("#if NET8_0_OR_GREATER");
-                        AppendCachedInlineValuesAndSpan(staticExtension, model, arrayType, arrayMembers.Length);
-                        staticExtension.AppendLine("#else");
-                    }
-                    // s_values is a plain array here. Values is typed as IReadOnlyList<T> rather than T[] so
-                    // callers can't reach in and mutate the shared static backing storage (arrays satisfy
-                    // IReadOnlyList<T> natively - no wrapper object, so this costs nothing extra). AsSpan is
-                    // still the implicit array-to-span conversion straight off the field itself.
-                    AppendDoc(staticExtension, $"{ValuesDocPrefix}, backed by a shared static array. Read-only: the array itself is never exposed.");
-                    staticExtension.AppendLine($"public static global::System.Collections.Generic.IReadOnlyList<{model.FullyQualifiedName}> Values => s_values;");
-                    AppendDoc(staticExtension, AsSpanDoc);
-                    staticExtension.AppendLine($"public static global::System.ReadOnlySpan<{model.FullyQualifiedName}> AsSpan => s_values;");
-                    if (createTargetConditionalValues)
-                    {
-                        staticExtension.AppendLine("#endif");
-                    }
-                }
-                else if (createTargetConditionalValues)
-                {
-                    staticExtension.AppendLine("#if NET8_0_OR_GREATER");
-                    AppendFreshInlineValues(staticExtension, model, arrayMembers, arrayType);
-                    staticExtension.AppendLine("#endif");
+                    AppendValuesAndAsSpan(staticExtension, model, arrayMembers, arrayType, valuesInitializer, spanNeedsCreateSpan);
                 }
 
                 if (model.GenerateParseMethods)
@@ -443,7 +408,7 @@ private static HashSet<string> FindCollidingFields(EnumModel model, string[] fie
     private const string ConstantDocSuffix = "A compile-time constant, for where C# requires one (<c>const</c> fields, attribute arguments, <c>case</c> labels); the same value is also a static extension property on the enum.";
 
     private const string ValuesDocPrefix = "Every declared member except the Unknown member and any marked <c>ExcludeFromValues</c>, in numeric order";
-    private const string AsSpanDoc = "The same members as <c>Values</c>, as a read-only span over the cached static storage: no copy, no allocation.";
+    private const string SpanLimitationsDoc = "A ref struct, so it can't be stored in a field or kept across an <c>await</c>.";
 
     private static string FieldLongestCharLengthDoc(string formatName) =>
         $"The length of the longest string <c>TryFormat_{formatName}</c> can write: a safe buffer size for it.";
@@ -991,62 +956,57 @@ private static void AppendMappingProperty(CodeWriter.BracedWriter writer, EnumMo
     }
 
     /// <summary>
-    /// Declares the lazily-populated backing field for the .NET 8+ inline-array Values/AsSpan pair (opted into
-    /// via CreateStaticReadonlyCollection), plus the ensure/factory methods that populate it on first access.
-    /// Lazy rather than an eager field initializer, so an enum nobody ever calls Values/AsSpan on pays nothing.
-    /// A stable field (rather than rebuilding the array on every access) is also what lets AsSpan create a
-    /// genuine, zero-copy span over it - see AppendCachedInlineValuesAndSpan.
+    /// Values and AsSpan for the chosen ValuesType. A span over constant elements is static data in the assembly. When
+    /// that needs RuntimeHelpers.CreateSpan (.NET 7+, for anything wider than a byte), the span members sit under #if,
+    /// so the same generated file still compiles, without them, on older targets.
     /// </summary>
-    private static void AppendLazyInlineValuesField(CodeWriter.BracedWriter writer, EnumModel model, EnumMemberModel[] members, string arrayType)
+    private static void AppendValuesAndAsSpan(CodeWriter.BracedWriter writer, EnumModel model, EnumMemberModel[] members, string arrayType, string valuesInitializer, bool spanNeedsCreateSpan)
     {
-        writer.AppendLine($"private static {arrayType} s_values;");
-        writer.AppendLine("private static volatile bool s_valuesInitialized;");
-        using (var methodWriter = writer.StartBraced($"private static void Ensure{model.GeneratedName}Values()"))
-        {
-            using (var ifWriter = methodWriter.StartBraced("if (!s_valuesInitialized)"))
-            {
-                ifWriter.AppendLine($"s_values = Create{model.GeneratedName}Values();");
-                ifWriter.AppendLine("s_valuesInitialized = true;");
-            }
-        }
-        using (var methodWriter = writer.StartBraced($"private static {arrayType} Create{model.GeneratedName}Values()"))
-        {
-            methodWriter.AppendLine($"{arrayType} values = default;");
-            for (var index = 0; index < members.Length; index++)
-            {
-                methodWriter.AppendLine($"values[{index}] = {EnumTypeAlias}.{members[index].Name};");
-            }
-            methodWriter.AppendLine("return values;");
+        var spanType = $"global::System.ReadOnlySpan<{model.FullyQualifiedName}>";
+        switch (model.ValuesType)
+        {
+            case FancyEnumValuesType.StaticCollection:
+                // IReadOnlyList<T> rather than T[], so callers can't mutate the shared array. An array implements it
+                // natively, so there's no wrapper object.
+                AppendDoc(writer, $"{ValuesDocPrefix}, as a read-only list over an array created once and cached in a static field.");
+                writer.AppendLine($"public static global::System.Collections.Generic.IReadOnlyList<{model.FullyQualifiedName}> Values => s_values;");
+                AppendDoc(writer, "The same members as <c>Values</c>, as a read-only span over the cached array: no copy, no allocation.");
+                writer.AppendLine($"public static {spanType} AsSpan => s_values;");
+                break;
+            case FancyEnumValuesType.InlineArray:
+                if (!model.NoInlineArray)
+                {
+                    writer.AppendLine("#if NET8_0_OR_GREATER");
+                    AppendFreshInlineValues(writer, model, members, arrayType);
+                    writer.AppendLine("#endif");
+                }
+                AppendStaticDataSpan(writer, "AsSpan", $"The same members as <c>Values</c>, as a read-only span over static data in the assembly: no copy, no allocation. {SpanLimitationsDoc}", spanType, valuesInitializer, spanNeedsCreateSpan);
+                break;
+            default:
+                // Values is already the span, so there's no separate AsSpan.
+                AppendStaticDataSpan(writer, "Values", $"{ValuesDocPrefix}, as a read-only span over static data in the assembly: no copy, no allocation. {SpanLimitationsDoc} Set <c>ValuesType</c> to <c>InlineArray</c> or <c>StaticCollection</c> for a storable collection.", spanType, valuesInitializer, spanNeedsCreateSpan);
+                break;
         }
     }
 
-    /// <summary>Values/AsSpan for the CreateStaticReadonlyCollection + .NET 8+ case: both trigger the lazy ensure, then AsSpan reinterprets the now-populated static field's storage directly (never a by-value copy - see FancyEnumSourceGenerator.Emit.cs comments elsewhere on why that matters for correctness).</summary>
-    private static void AppendCachedInlineValuesAndSpan(CodeWriter.BracedWriter writer, EnumModel model, string arrayType, int length)
+    private static void AppendStaticDataSpan(CodeWriter.BracedWriter writer, string name, string doc, string spanType, string valuesInitializer, bool needsCreateSpan)
     {
-        AppendDoc(writer, $"{ValuesDocPrefix}, cached in a static field on first access. Returned by value, so the caller gets its own copy of the inline buffer.");
-        using (var propertyWriter = writer.StartBraced($"public static {arrayType} Values"))
+        if (needsCreateSpan)
         {
-            using (var getterWriter = propertyWriter.StartBraced("get"))
-            {
-                getterWriter.AppendLine($"Ensure{model.GeneratedName}Values();");
-                getterWriter.AppendLine("return s_values;");
-            }
+            writer.AppendLine("#if NET7_0_OR_GREATER");
         }
-        AppendDoc(writer, AsSpanDoc);
-        using (var propertyWriter = writer.StartBraced($"public static global::System.ReadOnlySpan<{model.FullyQualifiedName}> AsSpan"))
+        AppendDoc(writer, doc);
+        writer.AppendLine($"public static {spanType} {name} => [{valuesInitializer}];");
+        if (needsCreateSpan)
         {
-            using (var getterWriter = propertyWriter.StartBraced("get"))
-            {
-                getterWriter.AppendLine($"Ensure{model.GeneratedName}Values();");
-                getterWriter.AppendLine($"return global::System.Runtime.InteropServices.MemoryMarshal.CreateReadOnlySpan(ref global::System.Runtime.CompilerServices.Unsafe.As<{arrayType}, {model.FullyQualifiedName}>(ref global::System.Runtime.CompilerServices.Unsafe.AsRef(in s_values)), {length});");
-            }
+            writer.AppendLine("#endif");
         }
     }
 
-    /// <summary>Values for the default (CreateStaticReadonlyCollection = false) .NET 8+ case: built fresh on every access - no static field, so no AsSpan either (there is nothing stable to point a span at).</summary>
+    /// <summary>Values for ValuesType = InlineArray: a fresh copy on every access, so there's no static storage, and the caller can store it or keep it across an await.</summary>
     private static void AppendFreshInlineValues(CodeWriter.BracedWriter writer, EnumModel model, EnumMemberModel[] members, string arrayType)
     {
-        AppendDoc(writer, $"{ValuesDocPrefix}. Built fresh on each access as an inline value-type buffer, so there's no heap allocation and no static storage; set <c>CreateStaticReadonlyCollection</c> for a cached copy plus <c>AsSpan</c>.");
+        AppendDoc(writer, $"{ValuesDocPrefix}, as a fresh copy in an inline value-type buffer: no heap allocation and no static storage, and unlike <c>AsSpan</c> it can be stored or kept across an <c>await</c>. Each access copies every member.");
         using (var propertyWriter = writer.StartBraced($"public static {arrayType} Values"))
         {
             using (var getterWriter = propertyWriter.StartBraced("get"))
@@ -1061,6 +1021,29 @@ private static void AppendFreshInlineValues(CodeWriter.BracedWriter writer, Enum
         }
     }
 
+    /// <summary>
+    /// HENUM017: an explicitly chosen ValuesType that can't be generated here. A warning rather than an error, so a
+    /// multi-targeted project still builds its other targets; the default (Span) is left out silently, as before.
+    /// </summary>
+    private static void AppendValuesTypeDiagnostics(EnumModel model, TargetFeatures target, bool hasValues, bool spanNeedsCreateSpan, List<DiagnosticInfo> diagnostics)
+    {
+        if (!model.ValuesTypeIsExplicit || !hasValues)
+        {
+            return;
+        }
+        var reason = model.ValuesType switch
+        {
+            FancyEnumValuesType.Span when spanNeedsCreateSpan && !target.HasCreateSpan => $"a span of '{model.UnderlyingType}' values only compiles to static data on .NET 7+ (older targets support it for 1-byte enums only)",
+            FancyEnumValuesType.InlineArray when model.NoInlineArray => "NoInlineArray is also set",
+            FancyEnumValuesType.InlineArray when !target.HasInlineArray => "inline arrays need .NET 8+",
+            _ => null
+        };
+        if (reason is not null)
+        {
+            diagnostics.Add(DiagnosticInfo.Create(EnumGeneratorDiagnostics.ValuesTypeUnavailable, model.Location, model.FullyQualifiedName, model.ValuesType.ToString(), reason));
+        }
+    }
+
     private static void AppendParsers(CodeWriter.BracedWriter writer, EnumModel model, EnumMemberModel[] members, MappingSettingsModel settings, List<DiagnosticInfo> diagnostics, List<Action<CodeWriter.BracedWriter>> classMembers)
     {
         var fieldMappings = members.Select(member => (Member: member, Mapping: member.Mappings.FirstOrDefault(mapping => mapping.FieldName == settings.FieldName))).Where(static item => item.Mapping is not null).ToArray();
diff --git a/src/FancyEnumGenerator/FancyEnumSourceGenerator.cs b/src/FancyEnumGenerator/FancyEnumSourceGenerator.cs
index 695ddf5..e202b6e 100644
--- a/src/FancyEnumGenerator/FancyEnumSourceGenerator.cs
+++ b/src/FancyEnumGenerator/FancyEnumSourceGenerator.cs
@@ -98,7 +98,9 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Combine(configOptions.Combine(wellKnownTypes).Combine(knownShapes))
             .Select(static (pair, _) => Extract((INamedTypeSymbol)pair.Left.TargetSymbol, pair.Left.Attributes[0], pair.Right.Left.Left, pair.Right.Left.Right, pair.Right.Right));
 
-        context.RegisterSourceOutput(models.Select(static (model, _) => Emit(model)), static (sourceContext, result) => WriteResult(sourceContext, result));
+        // Only HENUM017 needs to know the target: the generated code itself stays target-independent, with #if blocks.
+        var targetFeatures = context.ParseOptionsProvider.Select(static (options, _) => TargetFeatures.From(options.PreprocessorSymbolNames));
+        context.RegisterSourceOutput(models.Combine(targetFeatures).Select(static (pair, _) => Emit(pair.Left, pair.Right)), static (sourceContext, result) => WriteResult(sourceContext, result));
     }
 
     private static void WriteResult(SourceProductionContext sourceContext, GenResult result)
@@ -351,7 +353,9 @@ private static EnumModel Extract(INamedTypeSymbol symbol, AttributeData enumAttr
             UnderlyingType = underlyingType,
             Accessibility = symbol.DeclaredAccessibility == Accessibility.Public && containingTypes.All(static containingType => containingType.DeclaredAccessibility == Accessibility.Public) ? "public" : "internal",
             NoInlineArray = ResolveBoolOption(enumAttribute, assemblyDefaults, globalOptions, nameof(FancyEnumAttribute.NoInlineArray), false),
-            CreateStaticReadonlyCollection = ResolveBoolOption(enumAttribute, assemblyDefaults, globalOptions, nameof(FancyEnumAttribute.CreateStaticReadonlyCollection), false),
+            ValuesType = ResolveEnumOption(enumAttribute, assemblyDefaults, globalOptions, nameof(FancyEnumAttribute.ValuesType), default(FancyEnumValuesType), out var valuesTypeIsExplicit),
+            ValuesTypeIsExplicit = valuesTypeIsExplicit,
+            Location = GeneratorLocationInfo.FromLocation(symbol.Locations.FirstOrDefault()),
             AllowNonContiguous = allowNonContiguous,
             AllowNoUnknown = allowNoUnknown,
             IncludeObsolete = includeObsolete,
@@ -464,8 +468,13 @@ private static bool ResolveBoolOption(AttributeData? perEnumAttribute, Attribute
 
     /// <summary>Same precedence as <see cref="ResolveBoolOption"/>, for enum-valued options.</summary>
     private static TEnum ResolveEnumOption<TEnum>(AttributeData? perEnumAttribute, AttributeData? assemblyDefaults, AnalyzerConfigOptions globalOptions, string propertyName, TEnum hardcodedFallback)
+        where TEnum : struct, Enum => ResolveEnumOption(perEnumAttribute, assemblyDefaults, globalOptions, propertyName, hardcodedFallback, out _);
+
+    /// <summary>Like the overload above, and also reports whether any source set the option (otherwise it's the library default).</summary>
+    private static TEnum ResolveEnumOption<TEnum>(AttributeData? perEnumAttribute, AttributeData? assemblyDefaults, AnalyzerConfigOptions globalOptions, string propertyName, TEnum hardcodedFallback, out bool isExplicit)
         where TEnum : struct, Enum
     {
+        isExplicit = true;
         if (perEnumAttribute.TryReadNamedEnum<TEnum>(propertyName, out var perEnumValue))
         {
             return perEnumValue;
@@ -478,6 +487,7 @@ private static TEnum ResolveEnumOption<TEnum>(AttributeData? perEnumAttribute, A
         {
             return msBuildValue;
         }
+        isExplicit = false;
         return hardcodedFallback;
     }
 
diff --git a/src/FancyEnumGenerator/buildTransitive/FancyEnumGenerator.targets b/src/FancyEnumGenerator/buildTransitive/FancyEnumGenerator.targets
index 5fea858..0ed92b3 100644
--- a/src/FancyEnumGenerator/buildTransitive/FancyEnumGenerator.targets
+++ b/src/FancyEnumGenerator/buildTransitive/FancyEnumGenerator.targets
@@ -10,7 +10,7 @@
     <CompilerVisibleProperty Include="FancyEnumAllowNoUnknown" />
     <CompilerVisibleProperty Include="FancyEnumAllowNonContiguous" />
     <CompilerVisibleProperty Include="FancyEnumNoInlineArray" />
-    <CompilerVisibleProperty Include="FancyEnumCreateStaticReadonlyCollection" />
+    <CompilerVisibleProperty Include="FancyEnumValuesType" />
     <CompilerVisibleProperty Include="FancyEnumIncludeObsolete" />
     <CompilerVisibleProperty Include="FancyEnumDefaultToStringBehavior" />
     <CompilerVisibleProperty Include="FancyEnumDefaultToStringCustomField" />
diff --git a/tests/FancyEnumGenerator.PackageTests/Enums.cs b/tests/FancyEnumGenerator.PackageTests/Enums.cs
index a3e3ea1..cf39fb4 100644
--- a/tests/FancyEnumGenerator.PackageTests/Enums.cs
+++ b/tests/FancyEnumGenerator.PackageTests/Enums.cs
@@ -15,6 +15,18 @@ public enum Fruit
     Banana = 2,
 }
 
+/// <summary>A 1-byte enum: its default <c>Values</c> span is static data on every target, .NET Framework included.</summary>
+[FancyEnum]
+public enum Size : byte
+{
+    /// <summary>Unknown.</summary>
+    Unknown = 0,
+    /// <summary>Small.</summary>
+    Small = 1,
+    /// <summary>Large.</summary>
+    Large = 2,
+}
+
 /// <summary>Flags, formatted as combinations.</summary>
 [Flags]
 [FancyEnum(AllowNoUnknown = true, CreateTryFormat = true)]
@@ -34,7 +46,7 @@ public enum Permission
 /// Enough names of one length (5 and 17 characters) that text parsing uses per-length helpers and UTF-8 parsing uses
 /// packed-ASCII switches, with every other option on.
 /// </summary>
-[FancyEnum(CreateByteParsing = true, CreateTryFormat = true, CreateStaticReadonlyCollection = true, CreateIsValidPrefix = true, ParseCaseSensitive = false)]
+[FancyEnum(CreateByteParsing = true, CreateTryFormat = true, ValuesType = FancyEnumValuesType.StaticCollection, CreateIsValidPrefix = true, ParseCaseSensitive = false)]
 [FancyEnumMemberMappingSettings("Code", IncludeUtf8Value = true, ParseFrom = true, CreateTryFormat = true)]
 public enum Region
 {
diff --git a/tests/FancyEnumGenerator.PackageTests/Program.cs b/tests/FancyEnumGenerator.PackageTests/Program.cs
index 3729cae..f279645 100644
--- a/tests/FancyEnumGenerator.PackageTests/Program.cs
+++ b/tests/FancyEnumGenerator.PackageTests/Program.cs
@@ -48,10 +48,11 @@ void Check(bool condition, string what)
 var codeBuffer = new char[Region.Code_LongestCharLength];
 Check(Region.Omega.TryFormat_Code(codeBuffer, out var codeLength) && new string(codeBuffer, 0, codeLength) == "O5", "TryFormat_Code");
 
-// Cached collection and its span. Values is an inline-array struct on .NET 8+ and an IReadOnlyList (over a plain
-// array) downlevel; both have an indexer, and AsSpan is the same everywhere.
-Check(Region.Values[0] == Region.Alpha, "Values");
-Check(Region.AsSpan.Length == 11 && Region.AsSpan[10] == Region.WestCoastRegion05, "AsSpan");
+// Values. StaticCollection is an IReadOnlyList over a cached array on every target, with a span over it. The default for a
+// 1-byte enum is a span over static data, which works on .NET Framework too.
+Check(Region.Values[0] == Region.Alpha && Region.Values.Count == 11, "StaticCollection Values");
+Check(Region.AsSpan.Length == 11 && Region.AsSpan[10] == Region.WestCoastRegion05, "StaticCollection AsSpan");
+Check(Size.Values.Length == 2 && Size.Values[1] == Size.Large && Size.Values[0] == Size.Small, "byte enum Values span");
 
 // Prefix checks.
 Check(Region.IsValidPrefixFancy(Encoding.UTF8.GetBytes("WestCoast"), Encoding.UTF8.GetBytes("Region0")), "IsValidPrefixFancy hit");
diff --git a/tests/FancyEnumGenerator.RuntimeTests/CollectionTests.cs b/tests/FancyEnumGenerator.RuntimeTests/CollectionTests.cs
index cf6b655..f181c34 100644
--- a/tests/FancyEnumGenerator.RuntimeTests/CollectionTests.cs
+++ b/tests/FancyEnumGenerator.RuntimeTests/CollectionTests.cs
@@ -1,6 +1,10 @@
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using FancyEnumGenerator.RuntimeTests.Enums;
 using Xunit;
 
@@ -9,28 +13,74 @@ namespace FancyEnumGenerator.RuntimeTests;
 public class CollectionTests
 {
     [Fact]
-    public void CachedValuesAndAsSpanAgree()
+    public void SpanValuesLeaveOutUnknownAndExcludedMembers()
     {
-        var values = new List<Cached>();
-        foreach (var value in Cached.Values)
+        Assert.Equal([Spanned.A, Spanned.B, Spanned.C], Spanned.Values.ToArray()); // Hidden is ExcludeFromValues
+    }
+
+    [Fact]
+    public void SpanValuesAreStaticDataInTheAssembly()
+    {
+        // The same memory every call, and nothing allocated: the compiler stores the members as static data.
+        Assert.True(Unsafe.AreSame(ref MemoryMarshal.GetReference(Spanned.Values), ref MemoryMarshal.GetReference(Spanned.Values)));
+        _ = Spanned.Values.Length;
+        // Unoptimized (Debug) code calls RuntimeHelpers.CreateSpan the slow way, which allocates; optimized code is free.
+        var optimized = typeof(CollectionTests).Assembly.GetCustomAttribute<DebuggableAttribute>()?.IsJITOptimizerDisabled != true;
+        var before = GC.GetAllocatedBytesForCurrentThread();
+        long sum = 0;
+        for (var i = 0; i < 1_000; i++)
+        {
+            foreach (var value in Spanned.Values)
+            {
+                sum += (long)value;
+            }
+        }
+        if (optimized)
+        {
+            Assert.Equal(0, GC.GetAllocatedBytesForCurrentThread() - before);
+        }
+        Assert.Equal(1_000 * (1 + 2 + 4), sum);
+    }
+
+    [Fact]
+    public void InlineArrayValuesAreAnIndependentCopy()
+    {
+        var values = Inline.Values;
+        values[0] = Inline.Hidden;
+        Assert.Equal(Inline.A, Inline.Values[0]); // changing a copy never reaches the next caller
+        Assert.Equal([Inline.A, Inline.B, Inline.C], Inline.AsSpan.ToArray());
+    }
+
+    [Fact]
+    public async Task InlineArrayValuesSurviveAnAwait()
+    {
+        var values = Inline.Values;
+        await Task.Yield();
+        var seen = new List<Inline>();
+        foreach (var value in values)
         {
-            values.Add(value);
+            seen.Add(value);
         }
-        Assert.Equal([Cached.A, Cached.B, Cached.C], values); // Hidden is ExcludeFromValues
+        Assert.Equal([Inline.A, Inline.B, Inline.C], seen);
+    }
+
+    [Fact]
+    public void StaticCollectionValuesAndAsSpanAgree()
+    {
+        IReadOnlyList<Cached> values = Cached.Values;
+        Assert.Equal([Cached.A, Cached.B, Cached.C], values);
         Assert.Equal(values, Cached.AsSpan.ToArray());
+        Assert.Same(Cached.Values, Cached.Values); // cached once, not rebuilt per access
     }
 
     [Fact]
-    public void AsSpanPointsAtTheSameStaticStorageEveryTime()
+    public void StaticCollectionAsSpanPointsAtTheCachedArray()
     {
-        // A span over a by-value copy would dangle; it must be the static field itself, every call.
-        var first = Cached.AsSpan;
-        var second = Cached.AsSpan;
-        Assert.True(Unsafe.AreSame(ref MemoryMarshal.GetReference(first), ref MemoryMarshal.GetReference(second)));
+        Assert.True(Unsafe.AreSame(ref MemoryMarshal.GetReference(Cached.AsSpan), ref MemoryMarshal.GetReference(Cached.AsSpan)));
     }
 
     [Fact]
-    public void PlainArrayValuesAreReadOnly()
+    public void StaticCollectionWithoutInlineArrays()
     {
         IReadOnlyList<PlainArray> values = PlainArray.Values;
         Assert.Equal([PlainArray.A, PlainArray.B], values);
diff --git a/tests/FancyEnumGenerator.RuntimeTests/Enums/TestEnums.cs b/tests/FancyEnumGenerator.RuntimeTests/Enums/TestEnums.cs
index 0b686e3..b3a6f28 100644
--- a/tests/FancyEnumGenerator.RuntimeTests/Enums/TestEnums.cs
+++ b/tests/FancyEnumGenerator.RuntimeTests/Enums/TestEnums.cs
@@ -139,12 +139,18 @@ public enum ByUpper { Unknown, FirstOne, SecondOne }
 [FancyEnum(DefaultToStringBehavior = FancyEnumDefaultToStringBehavior.CustomFieldRequired, DefaultToStringCustomField = "Code")]
 public enum ByRequiredField { [FancyEnumMember("Code", "?")] Unknown, [FancyEnumMember("Code", "F1")] First, [FancyEnumMember("Code", "S2")] Second }
 
-[FancyEnum(CreateStaticReadonlyCollection = true)]
+[FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)]
 public enum Cached { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
 
-[FancyEnum(NoInlineArray = true, CreateStaticReadonlyCollection = true)]
+[FancyEnum(NoInlineArray = true, ValuesType = FancyEnumValuesType.StaticCollection)]
 public enum PlainArray { Unknown, A, B }
 
+[FancyEnum]
+public enum Spanned : long { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
+
+[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)]
+public enum Inline { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
+
 /// <summary>Enough same-length and long tokens to exercise every parser strategy (see the generator's Parsing scenario).</summary>
 [FancyEnum(CreateByteParsing = true, CreateTryFormat = true, CreateIsValidPrefix = true, ParseCaseSensitive = false)]
 public enum Station
diff --git a/tests/FancyEnumGenerator.Tests/CompilationTests.cs b/tests/FancyEnumGenerator.Tests/CompilationTests.cs
index 22dd9d2..303b25c 100644
--- a/tests/FancyEnumGenerator.Tests/CompilationTests.cs
+++ b/tests/FancyEnumGenerator.Tests/CompilationTests.cs
@@ -11,9 +11,11 @@ public class CompilationTests
     {
         ["Defaults"] = [],
         ["NoParsing"] = new() { ["FancyEnumGenerateParseMethods"] = "false" },
-        ["Everything"] = new() { ["FancyEnumCreateByteParsing"] = "true", ["FancyEnumCreateTryFormat"] = "true", ["FancyEnumCreateStaticReadonlyCollection"] = "true" },
+        ["Everything"] = new() { ["FancyEnumCreateByteParsing"] = "true", ["FancyEnumCreateTryFormat"] = "true", ["FancyEnumValuesType"] = "StaticCollection" },
+        ["SpanValues"] = new() { ["FancyEnumValuesType"] = "Span" },
+        ["InlineArrayValues"] = new() { ["FancyEnumValuesType"] = "InlineArray" },
         ["NoInlineArray"] = new() { ["FancyEnumNoInlineArray"] = "true" },
-        ["NoInlineArrayCached"] = new() { ["FancyEnumNoInlineArray"] = "true", ["FancyEnumCreateStaticReadonlyCollection"] = "true" },
+        ["NoInlineArrayStatic"] = new() { ["FancyEnumNoInlineArray"] = "true", ["FancyEnumValuesType"] = "StaticCollection" },
         ["CaseInsensitive"] = new() { ["FancyEnumParseCaseSensitive"] = "false" },
     };
 
@@ -45,7 +47,18 @@ public static TheoryData<string, TargetProfile, string> Matrix
     public void CompilesCleanly(string scenario, TargetProfile profile, string optionSet)
     {
         var run = GeneratorHarness.Run(Scenarios.All.Single(candidate => candidate.Name == scenario).Source, profile, OptionSets[optionSet]);
-        run.AssertNoGeneratorDiagnostics();
+        // Explicitly asking for a Values type that can't be generated (one netstandard2.0 lacks, or InlineArray alongside
+        // NoInlineArray) is reported for the enums it affects, and otherwise just leaves Values out, so the rest still compiles.
+        var downlevel = profile == TargetProfile.NetStandard20 && optionSet is "SpanValues" or "InlineArrayValues";
+        var inlineArrayWithout = (optionSet == "InlineArrayValues" && scenario == "Collections") || (scenario == "InlineArrayValues" && optionSet is "NoInlineArray" or "NoInlineArrayStatic");
+        if (downlevel || inlineArrayWithout)
+        {
+            Assert.All(run.GeneratorDiagnostics, static diagnostic => Assert.Equal("HENUM017", diagnostic.Id));
+        }
+        else
+        {
+            run.AssertNoGeneratorDiagnostics();
+        }
         run.AssertCompilesCleanly();
     }
 
diff --git a/tests/FancyEnumGenerator.Tests/DiagnosticTests.cs b/tests/FancyEnumGenerator.Tests/DiagnosticTests.cs
index 5fba16a..a993e84 100644
--- a/tests/FancyEnumGenerator.Tests/DiagnosticTests.cs
+++ b/tests/FancyEnumGenerator.Tests/DiagnosticTests.cs
@@ -95,6 +95,7 @@ public sealed class MetaAttribute : System.Attribute { public int? Size { get; s
             public sealed class MetaAttribute : System.Attribute { public int[]? Sizes { get; set; } }
             [FancyEnum] public enum E { Unknown, [Meta(Sizes = new[] { 1 })] A }
             """ },
+        { "HENUM017", "InlineArray values with NoInlineArray", "[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray, NoInlineArray = true)] public enum E { Unknown, A, B }" },
         { "HENUM015", "read-only property no constructor feeds", """
             [FancyEnumMemberSet, System.AttributeUsage(System.AttributeTargets.Field)]
             public sealed class MetaAttribute : System.Attribute { public string Label { get; } = "fixed"; }
@@ -188,6 +189,43 @@ public void StaysQuiet(string because, string source)
         run.AssertCompilesCleanly();
     }
 
+    /// <summary>netstandard2.0 has neither RuntimeHelpers.CreateSpan nor inline arrays, so some explicit Values types can't be honored there.</summary>
+    public static TheoryData<string, string> DownlevelValuesTypeTriggers => new()
+    {
+        { "explicit Span on an int enum", "[FancyEnum(ValuesType = FancyEnumValuesType.Span)] public enum E { Unknown, A, B }" },
+        { "Span from an assembly default on a long enum", "[assembly: FancyEnumDefaults(ValuesType = FancyEnumValuesType.Span)] [FancyEnum] public enum E : long { Unknown, A, B }" },
+        { "InlineArray", "[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)] public enum E : byte { Unknown, A, B }" },
+    };
+
+    [Theory]
+    [MemberData(nameof(DownlevelValuesTypeTriggers))]
+    public void ReportsUnavailableValuesTypeDownlevel(string because, string source)
+    {
+        _ = because;
+        var run = GeneratorHarness.Run(Usings + source, TargetProfile.NetStandard20);
+        Assert.Equal("HENUM017", Assert.Single(run.GeneratorDiagnostics).Id);
+        run.AssertCompilesCleanly();
+    }
+
+    public static TheoryData<string, string> DownlevelValuesTypeLookAlikes => new()
+    {
+        { "the default Span, not set explicitly, is left out silently", "[FancyEnum] public enum E { Unknown, A, B }" },
+        { "explicit Span on a byte enum is static data everywhere", "[FancyEnum(ValuesType = FancyEnumValuesType.Span)] public enum E : byte { Unknown, A, B }" },
+        { "explicit Span on an sbyte enum is static data everywhere", "[FancyEnum(ValuesType = FancyEnumValuesType.Span)] public enum E : sbyte { Unknown, A, B }" },
+        { "StaticCollection works everywhere", "[FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)] public enum E : long { Unknown, A, B }" },
+        { "an enum with nothing to list has no Values to miss", "[FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)] public enum E { Unknown }" },
+    };
+
+    [Theory]
+    [MemberData(nameof(DownlevelValuesTypeLookAlikes))]
+    public void StaysQuietDownlevel(string because, string source)
+    {
+        _ = because;
+        var run = GeneratorHarness.Run(Usings + source, TargetProfile.NetStandard20);
+        run.AssertNoGeneratorDiagnostics();
+        run.AssertCompilesCleanly();
+    }
+
     private const string BrokenShape = """
         [FancyEnumMemberSet, System.AttributeUsage(System.AttributeTargets.Field)]
         public sealed class MetaAttribute(string text) : System.Attribute { public string Label { get; } = text; }
diff --git a/tests/FancyEnumGenerator.Tests/Scenarios.cs b/tests/FancyEnumGenerator.Tests/Scenarios.cs
index 844da99..88ddeeb 100644
--- a/tests/FancyEnumGenerator.Tests/Scenarios.cs
+++ b/tests/FancyEnumGenerator.Tests/Scenarios.cs
@@ -200,17 +200,42 @@ public enum ByRequiredField { [FancyEnumMember("Code", "?")] Unknown, [FancyEnum
 
             namespace Demo;
 
-            [FancyEnum(CreateStaticReadonlyCollection = true)]
+            [FancyEnum(ValuesType = FancyEnumValuesType.StaticCollection)]
             public enum Cached { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
 
-            [FancyEnum(NoInlineArray = true, CreateStaticReadonlyCollection = true)]
+            [FancyEnum(NoInlineArray = true, ValuesType = FancyEnumValuesType.StaticCollection)]
             public enum PlainArray { Unknown, A, B }
 
+            [FancyEnum]
+            public enum Spanned { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
+
+            [FancyEnum(ValuesType = FancyEnumValuesType.Span)]
+            public enum SmallSpan : byte { Unknown, A, B }
+
             [FancyEnum(NoInlineArray = true)]
             public enum NoCollection { Unknown, A, B }
             """
     };
 
+    /// <summary>ValuesType = InlineArray needs .NET 8+, so this one only builds there (downlevel it reports HENUM017 instead).</summary>
+    public static readonly Scenario InlineArrayValues = new()
+    {
+        Name = nameof(InlineArrayValues),
+        Net10Only = true,
+        Source = """
+            using FancyEnumGenerator.Attributes;
+
+            namespace Demo;
+
+            [FancyEnum(ValuesType = FancyEnumValuesType.InlineArray)]
+            public enum Inline { Unknown, A, B, [FancyEnumMemberSettings(ExcludeFromValues = true)] Hidden, C }
+
+            [System.Flags]
+            [FancyEnum(ValuesType = FancyEnumValuesType.InlineArray, AllowNoUnknown = true)]
+            public enum InlineFlags : long { None = 0, A = 1, B = 2, C = 1L << 40 }
+            """
+    };
+
     /// <summary>Enough same-length and long (&gt; 8 and &gt; 16 char) tokens to exercise every parser strategy: direct compares, the length switch, and packed-ASCII hashing with a tail compare.</summary>
     public static readonly Scenario Parsing = new()
     {
@@ -288,5 +313,5 @@ public enum KeepsObsolete
             """
     };
 
-    public static readonly IReadOnlyList<Scenario> All = [Basic, Flags, FieldMappings, MemberSet, ToStringAttributes, Collections, Parsing, Shapes];
+    public static readonly IReadOnlyList<Scenario> All = [Basic, Flags, FieldMappings, MemberSet, ToStringAttributes, Collections, InlineArrayValues, Parsing, Shapes];
 }