Store enabled editions on the session and gate the writer through it

Rework after review feedback:

- The first-party edition declarations stay in the `vortex` facade
  (`vortex::editions`); the earlier move into `vortex-edition` is
  reverted. `vortex-edition` again holds only the types, the session
  variable, and the test harness.
- `EditionSession` now stores the set of enabled editions alongside the
  declarations: `enable()` (validated, at most one edition per family),
  `enabled()`, and `enabled_encodings()` — the resolved union of the
  enabled editions' encoding sets. `register_default_editions` declares
  the editions and enables the default write editions: core2026.07.0,
  plus the newest unstable draft under the `unstable_encodings`
  feature.
- The writer resolves its allow set from the session at write time:
  the flat leaf writer's normalize-with-error validation, the writer's
  pre-populated ArrayContext, and the compressor's scheme selection
  (via `CascadingCompressor::with_enabled_editions_gating`, resolved
  from the execution context per compression) all use the session's
  enabled encodings, falling back to the static `ALLOWED_ENCODINGS`
  registry for sessions with no enabled editions. Explicit
  `with_allow_encodings` sets still override everything.
- `Scheme::produced_encodings` is now a required method returning
  `Vec<ArrayId>` (empty means the scheme only rearranges canonical
  arrays); all schemes, including test schemes and the tensor
  L2Denorm scheme, implement it.

Signed-off-by: Claude <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CK2nCuXnyd2g3mNHQC8Lz2

Author: claude

Cargo.lock

@@ -44,7 +44,6 @@ insta = { workspace = true }
 rstest = { workspace = true }
 test-with = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
-vortex-edition = { workspace = true }
 vortex-session = { workspace = true }
 
 [features]

vortex-btrblocks/Cargo.toml

@@ -91,12 +91,14 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
 #[derive(Debug, Clone)]
 pub struct BtrBlocksCompressorBuilder {
     schemes: Vec<&'static dyn Scheme>,
+    gate_by_enabled_editions: bool,
 }
 
 impl Default for BtrBlocksCompressorBuilder {
     fn default() -> Self {
         Self {
             schemes: ALL_SCHEMES.to_vec(),
+            gate_by_enabled_editions: false,
         }
     }
 }
@@ -108,6 +110,7 @@ impl BtrBlocksCompressorBuilder {
     pub fn empty() -> Self {
         Self {
             schemes: Vec::new(),
+            gate_by_enabled_editions: false,
         }
     }
 
@@ -209,32 +212,38 @@ impl BtrBlocksCompressorBuilder {
         self
     }
 
-    /// Retains only schemes whose declared produced encodings all belong to `allowed`.
-    ///
-    /// Schemes that do not declare their produced encodings (see
-    /// [`Scheme::produced_encodings`]) are removed as well: the compressor cannot prove
-    /// their output stays within the allowed set. The file writer uses this to restrict
-    /// compression to the encodings of its configured editions.
+    /// Retains only schemes whose declared produced encodings (see
+    /// [`Scheme::produced_encodings`]) all belong to `allowed`. The file writer uses this
+    /// to restrict compression to an explicitly configured allow set.
     pub fn retain_allowed_encodings(mut self, allowed: &HashSet<ArrayId>) -> Self {
-        self.schemes.retain(|s| {
-            s.produced_encodings()
-                .is_some_and(|ids| ids.iter().all(|id| allowed.contains(id)))
-        });
+        self.schemes
+            .retain(|s| s.produced_encodings().iter().all(|id| allowed.contains(id)));
+        self
+    }
+
+    /// Gate scheme selection by the session's enabled editions at compression time.
+    ///
+    /// See [`CascadingCompressor::with_enabled_editions_gating`]. The file writer enables
+    /// this by default so compression only chooses encodings from the session's enabled
+    /// editions.
+    pub fn gate_by_enabled_editions(mut self) -> Self {
+        self.gate_by_enabled_editions = true;
         self
     }
 
     /// Builds the configured [`BtrBlocksCompressor`].
     pub fn build(self) -> BtrBlocksCompressor {
-        BtrBlocksCompressor(CascadingCompressor::new(self.schemes))
+        let mut compressor = CascadingCompressor::new(self.schemes);
+        if self.gate_by_enabled_editions {
+            compressor = compressor.with_enabled_editions_gating();
+        }
+        BtrBlocksCompressor(compressor)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use vortex_array::VTable;
-    use vortex_edition::declarations::CORE_2026_07_0;
-    use vortex_edition::declarations::UNSTABLE_2026_06_0;
-    use vortex_edition::declarations::encodings_in_editions;
     use vortex_fastlanes::FoR;
 
     use super::*;
@@ -251,17 +260,6 @@ mod tests {
         assert_eq!(builder.schemes.len(), ALL_SCHEMES.len());
     }
 
-    #[test]
-    fn all_schemes_declare_produced_encodings() {
-        for scheme in ALL_SCHEMES {
-            assert!(
-                scheme.produced_encodings().is_some(),
-                "scheme {} must declare its produced encodings",
-                scheme.id()
-            );
-        }
-    }
-
     #[test]
     fn retain_allowed_encodings_filters_schemes() {
         let allowed: HashSet<ArrayId> = [FoR.id()].into_iter().collect();
@@ -273,20 +271,6 @@ mod tests {
         assert!(none.schemes.is_empty());
     }
 
-    /// Every default scheme must produce only encodings covered by the writer's default
-    /// editions, otherwise the default file writer would silently drop it.
-    #[test]
-    fn default_schemes_stay_within_default_editions() {
-        let editions = if cfg!(feature = "unstable_encodings") {
-            vec![CORE_2026_07_0, UNSTABLE_2026_06_0]
-        } else {
-            vec![CORE_2026_07_0]
-        };
-        let allowed: HashSet<ArrayId> = encodings_in_editions(&editions).into_iter().collect();
-        let builder = BtrBlocksCompressorBuilder::default().retain_allowed_encodings(&allowed);
-        assert_eq!(builder.schemes.len(), ALL_SCHEMES.len());
-    }
-
     #[test]
     fn cuda_compatible_excludes_alprd() {
         let builder = BtrBlocksCompressorBuilder::default().only_cuda_compatible();

vortex-btrblocks/src/builder.rs

@@ -31,8 +31,8 @@ impl Scheme for ZstdScheme {
         canonical.dtype().is_binary()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![vortex_zstd::Zstd.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![vortex_zstd::Zstd.id()]
     }
 
     fn expected_compression_ratio(

vortex-btrblocks/src/schemes/binary/zstd.rs

@@ -31,8 +31,8 @@ impl Scheme for ZstdBuffersScheme {
         canonical.dtype().is_binary()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![vortex_zstd::ZstdBuffers.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![vortex_zstd::ZstdBuffers.id()]
     }
 
     fn expected_compression_ratio(

vortex-btrblocks/src/schemes/binary/zstd_buffers.rs

@@ -40,8 +40,8 @@ impl Scheme for DecimalScheme {
         matches!(canonical, Canonical::Decimal(_))
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![DecimalByteParts.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![DecimalByteParts.id()]
     }
 
     /// Children: primitive=0.

vortex-btrblocks/src/schemes/decimal.rs

@@ -42,12 +42,12 @@ impl Scheme for ALPScheme {
         canonical.dtype().is_float()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+    fn produced_encodings(&self) -> Vec<ArrayId> {
         let mut encodings = vec![ALP.id()];
         if use_experimental_patches() {
             encodings.push(Patched.id());
         }
-        Some(encodings)
+        encodings
     }
 
     /// Children: encoded_ints=0.

vortex-btrblocks/src/schemes/float/alp.rs

@@ -39,8 +39,8 @@ impl Scheme for ALPRDScheme {
         canonical.dtype().is_float()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![vortex_alp::ALPRD.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![vortex_alp::ALPRD.id()]
     }
 
     fn expected_compression_ratio(

vortex-btrblocks/src/schemes/float/alprd.rs

@@ -31,8 +31,8 @@ impl Scheme for PcoScheme {
         canonical.dtype().is_float()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![vortex_pco::Pco.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![vortex_pco::Pco.id()]
     }
 
     fn expected_compression_ratio(

vortex-btrblocks/src/schemes/float/pco.rs

@@ -38,8 +38,8 @@ impl Scheme for FloatRLEScheme {
         canonical.dtype().is_float()
     }
 
-    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
-        Some(vec![RLE.id()])
+    fn produced_encodings(&self) -> Vec<ArrayId> {
+        vec![RLE.id()]
     }
 
     /// Children: values=0, indices=1, offsets=2.