feat(vortex-file): gate the file writer behind editions

The writer is now gated by Vortex editions, defaulting to the newest
frozen core edition, core2026.07.0:

- The first-party edition declarations move from the `vortex` facade
  into `vortex_edition::declarations` (pure static data), so that
  `vortex-file` can resolve edition encoding sets without a session.
  `vortex::editions` re-exports them and still seeds the default
  session.
- `Scheme::produced_encodings` is a new trait method declaring the
  array encodings a compression scheme may emit. All first-party
  schemes declare their outputs; undeclared schemes are excluded from
  gated writers.
- `BtrBlocksCompressorBuilder::retain_allowed_encodings` filters the
  scheme list down to schemes whose outputs are all allowed.
- `vortex-file`'s `ALLOWED_ENCODINGS` — the set the flat leaf writer
  validates every serialized encoding against (failing the write on a
  violation) — is now derived from `DEFAULT_WRITE_EDITIONS`
  (core2026.07.0, plus the newest unstable draft when the
  `unstable_encodings` feature opts in) instead of being hand
  maintained. `WriteStrategyBuilder::build` applies the same set to
  the data and stats compressors, so compression only ever chooses
  encodings from the enabled editions, and
  `WriteStrategyBuilder::with_editions` lets callers pin different
  editions.

Experimental patches remain a runtime opt-out: `Patched` is only
writable when the experimental environment variable is set.

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,6 +44,7 @@ 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

@@ -3,6 +3,7 @@
 
 //! Builder for configuring `BtrBlocksCompressor` instances.
 
+use vortex_array::ArrayId;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use crate::BtrBlocksCompressor;
@@ -208,6 +209,20 @@ 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.
+    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
+    }
+
     /// Builds the configured [`BtrBlocksCompressor`].
     pub fn build(self) -> BtrBlocksCompressor {
         BtrBlocksCompressor(CascadingCompressor::new(self.schemes))
@@ -216,6 +231,12 @@ impl BtrBlocksCompressorBuilder {
 
 #[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::*;
 
     #[test]
@@ -230,6 +251,42 @@ 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();
+        let builder = BtrBlocksCompressorBuilder::default().retain_allowed_encodings(&allowed);
+        assert_eq!(builder.schemes.len(), 1);
+        assert_eq!(builder.schemes[0].id(), integer::FoRScheme.id());
+
+        let none = BtrBlocksCompressorBuilder::default().retain_allowed_encodings(&HashSet::new());
+        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

@@ -3,10 +3,12 @@
 
 //! Zstd compression for binary arrays.
 
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_compressor::scheme::CompressionEstimate;
 use vortex_compressor::scheme::DeferredEstimate;
 use vortex_error::VortexResult;
@@ -29,6 +31,10 @@ impl Scheme for ZstdScheme {
         canonical.dtype().is_binary()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![vortex_zstd::Zstd.id()])
+    }
+
     fn expected_compression_ratio(
         &self,
         _data: &ArrayAndStats,

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

@@ -3,10 +3,12 @@
 
 //! Zstd buffer-level binary compression preserving array layout for GPU decompression.
 
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_compressor::scheme::CompressionEstimate;
 use vortex_compressor::scheme::DeferredEstimate;
 use vortex_error::VortexResult;
@@ -29,6 +31,10 @@ impl Scheme for ZstdBuffersScheme {
         canonical.dtype().is_binary()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![vortex_zstd::ZstdBuffers.id()])
+    }
+
     fn expected_compression_ratio(
         &self,
         _data: &ArrayAndStats,

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

@@ -3,10 +3,12 @@
 
 //! Decimal compression scheme using byte-part decomposition.
 
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_array::arrays::DecimalArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::decimal::narrowed_decimal;
@@ -38,6 +40,10 @@ impl Scheme for DecimalScheme {
         matches!(canonical, Canonical::Decimal(_))
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![DecimalByteParts.id()])
+    }
+
     /// Children: primitive=0.
     fn num_children(&self) -> usize {
         1

vortex-btrblocks/src/schemes/decimal.rs

@@ -7,10 +7,12 @@ use vortex_alp::ALP;
 use vortex_alp::ALPArrayExt;
 use vortex_alp::ALPArraySlotsExt;
 use vortex_alp::alp_encode;
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_array::arrays::Patched;
 use vortex_array::arrays::patched::use_experimental_patches;
 use vortex_array::arrays::primitive::PrimitiveArrayExt;
@@ -40,6 +42,14 @@ impl Scheme for ALPScheme {
         canonical.dtype().is_float()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        let mut encodings = vec![ALP.id()];
+        if use_experimental_patches() {
+            encodings.push(Patched.id());
+        }
+        Some(encodings)
+    }
+
     /// Children: encoded_ints=0.
     fn num_children(&self) -> usize {
         1

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

@@ -6,10 +6,12 @@
 use vortex_alp::ALPRDArrayExt;
 use vortex_alp::ALPRDArrayOwnedExt;
 use vortex_alp::RDEncoder;
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_array::arrays::primitive::PrimitiveArrayExt;
 use vortex_array::dtype::PType;
 use vortex_compressor::scheme::CompressionEstimate;
@@ -37,6 +39,10 @@ impl Scheme for ALPRDScheme {
         canonical.dtype().is_float()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![vortex_alp::ALPRD.id()])
+    }
+
     fn expected_compression_ratio(
         &self,
         data: &ArrayAndStats,

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

@@ -3,10 +3,12 @@
 
 //! Pco (pcodec) float compression.
 
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
+use vortex_array::VTable;
 use vortex_compressor::scheme::CompressionEstimate;
 use vortex_compressor::scheme::DeferredEstimate;
 use vortex_error::VortexResult;
@@ -29,6 +31,10 @@ impl Scheme for PcoScheme {
         canonical.dtype().is_float()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![vortex_pco::Pco.id()])
+    }
+
     fn expected_compression_ratio(
         &self,
         _data: &ArrayAndStats,

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

@@ -3,15 +3,18 @@
 
 //! Run-length float encoding.
 
+use vortex_array::ArrayId;
 use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
+use vortex_array::VTable;
 use vortex_compressor::scheme::AncestorExclusion;
 use vortex_compressor::scheme::CompressionEstimate;
 use vortex_compressor::scheme::DeferredEstimate;
 use vortex_compressor::scheme::DescendantExclusion;
 use vortex_compressor::scheme::EstimateVerdict;
 use vortex_error::VortexResult;
+use vortex_fastlanes::RLE;
 
 use crate::ArrayAndStats;
 use crate::CascadingCompressor;
@@ -35,6 +38,10 @@ impl Scheme for FloatRLEScheme {
         canonical.dtype().is_float()
     }
 
+    fn produced_encodings(&self) -> Option<Vec<ArrayId>> {
+        Some(vec![RLE.id()])
+    }
+
     /// Children: values=0, indices=1, offsets=2.
     fn num_children(&self) -> usize {
         3