fix

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

Cargo.lock

@@ -34,6 +34,7 @@ vortex-proto = { workspace = true, features = ["expr"] }
 vortex-session = { workspace = true }
 
 [dev-dependencies]
+vortex-edition = { workspace = true }
 rstest = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 vortex-array = { workspace = true, features = ["_test-harness"] }

encodings/parquet-variant/Cargo.toml

@@ -326,6 +326,10 @@ mod tests {
     use vortex_buffer::BitBuffer;
     use vortex_buffer::ByteBufferMut;
     use vortex_buffer::buffer;
+    use vortex_edition::Edition;
+    use vortex_edition::EditionId;
+    use vortex_edition::EditionInclusion;
+    use vortex_edition::EditionSessionExt;
     use vortex_error::VortexResult;
     use vortex_error::vortex_err;
     use vortex_file::OpenOptionsSessionExt;
@@ -388,13 +392,30 @@ mod tests {
     }
 
     #[fixture]
-    fn parquet_variant_file_session() -> VortexSession {
+    fn parquet_variant_file_session() -> VortexResult<VortexSession> {
+        const TEST_EDITION: EditionId = EditionId::new("test", 2026, 7, 0);
+
         let session = vortex_array::array_session()
             .with::<LayoutSession>()
             .with::<RuntimeSession>();
         vortex_file::register_default_encodings(&session);
         session.arrays().register(ParquetVariant);
+        let editions = session.editions();
+        editions
+            .declare_edition(Edition {
+                id: TEST_EDITION,
+                min_vortex_version: None,
+            })
+            .map_err(|error| vortex_err!("{error}"))?;
+        for id in session.arrays().registry().ids() {
+            editions
+                .declare_inclusion(EditionInclusion::new(&id, TEST_EDITION))
+                .map_err(|error| vortex_err!("{error}"))?;
+        }
         session
+            .enable_edition(TEST_EDITION)
+            .map_err(|error| vortex_err!("{error}"))?;
+        Ok(session)
     }
 
     #[fixture]
@@ -447,9 +468,10 @@ mod tests {
     #[tokio::test]
     async fn test_file_roundtrip_typed_value_variant_with_statistics(
         #[from(typed_value_variant_array)] expected: VortexResult<ArrayRef>,
-        parquet_variant_file_session: VortexSession,
+        parquet_variant_file_session: VortexResult<VortexSession>,
     ) -> VortexResult<()> {
         let expected = expected?;
+        let parquet_variant_file_session = parquet_variant_file_session?;
 
         let mut bytes = ByteBufferMut::empty();
         parquet_variant_file_session
@@ -474,10 +496,11 @@ mod tests {
     #[tokio::test]
     async fn test_file_roundtrip_typed_value_variant_with_zoned_strategy(
         #[from(typed_value_variant_array)] expected: VortexResult<ArrayRef>,
-        parquet_variant_file_session: VortexSession,
+        parquet_variant_file_session: VortexResult<VortexSession>,
         write_strategy: Arc<dyn LayoutStrategy>,
     ) -> VortexResult<()> {
         let expected = expected?;
+        let parquet_variant_file_session = parquet_variant_file_session?;
 
         let mut bytes = ByteBufferMut::empty();
         parquet_variant_file_session

encodings/parquet-variant/src/vtable.rs

@@ -588,7 +588,7 @@ mod tests {
         let session = array_session();
         session.arrays().register(Patched);
 
-        let ctx = ArrayContext::empty().with_registry(session.arrays().registry().clone());
+        let ctx = ArrayContext::empty().with_valid_ids(session.arrays().registry().ids());
         let serialized = array
             .serialize(&ctx, &session, &SerializeOptions::default())
             .unwrap();

vortex-array/src/arrays/patched/vtable/mod.rs

@@ -190,4 +190,4 @@ pub fn legacy_session() -> &'static VortexSession {
     &LEGACY_SESSION
 }
 
-pub type ArrayContext = Context<ArrayPluginRef>;
+pub type ArrayContext = Context;

vortex-array/src/lib.rs

@@ -15,15 +15,13 @@ use futures::future::LocalBoxFuture;
 use futures::future::ready;
 use futures::pin_mut;
 use futures::select;
-use itertools::Itertools;
 use vortex_array::ArrayContext;
 use vortex_array::ArrayRef;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::FieldPath;
 use vortex_array::expr::stats::Stat;
 use vortex_array::iter::ArrayIterator;
 use vortex_array::iter::ArrayIteratorExt;
-use vortex_array::session::ArraySessionExt;
 use vortex_array::stats::PRUNING_STATS;
 use vortex_array::stream::ArrayStream;
 use vortex_array::stream::ArrayStreamAdapter;
@@ -60,8 +58,7 @@ use crate::segments::writer::BufferedSegmentSink;
 /// Configure a new writer, which can eventually be used to write an [`ArrayStream`] into a sink
 /// that implements [`VortexWrite`].
 ///
-/// Unless overridden, the default [write strategy][crate::WriteStrategyBuilder] will be restricted
-/// to the encodings in the session's enabled editions.
+/// All write strategies are restricted to the encodings in the session's enabled editions.
 ///
 /// Construct with [`WriteOptionsSessionExt::write_options`] for normal use so the writer inherits
 /// the session's runtime, array registry, and memory configuration.
@@ -102,7 +99,7 @@ impl VortexWriteOptions {
     ///
     /// The strategy controls repartitioning, statistics layout, compression, and leaf segment
     /// emission. Use [`WriteStrategyBuilder`] when only a small part of the default strategy needs
-    /// customization.
+    /// customization. Replacing the strategy does not change the enabled-edition encoding policy.
     pub fn with_strategy(mut self, strategy: Arc<dyn LayoutStrategy>) -> Self {
         self.strategy = strategy;
         self
@@ -155,13 +152,11 @@ impl VortexWriteOptions {
         mut write: W,
         stream: SendableArrayStream,
     ) -> VortexResult<WriteSummary> {
-        // Pre-populate the array context with the registered encodings selected by the enabled
-        // editions. This keeps the serialized ordering deterministic without advertising every
-        // encoding the session happens to know how to read.
-        let ctx = ArrayContext::new(self.session.enabled_encoding_ids())
-            // The registry supplies serialization implementations; the layout strategy applies
-            // the enabled-edition write policy before arrays reach serialization.
-            .with_registry(self.session.arrays().registry().clone());
+        let enabled_encoding_ids = self.session.enabled_encoding_ids();
+        // Pre-populate the array context in deterministic order and reject any array encoding
+        // that is not part of an enabled edition, regardless of the configured write strategy.
+        let ctx =
+            ArrayContext::new(enabled_encoding_ids.clone()).with_valid_ids(enabled_encoding_ids);
         let dtype = stream.dtype().clone();
 
         let (mut ptr, eof) = SequenceId::root().split();
@@ -531,36 +526,37 @@ impl WriteSummary {
 
 #[cfg(test)]
 mod tests {
+    use vortex_array::ArrayContext;
     use vortex_array::VTable;
     use vortex_array::array_session;
     use vortex_array::arrays::Bool;
     use vortex_array::arrays::Primitive;
-    use vortex_array::session::ArraySessionExt;
     use vortex_edition::Edition;
     use vortex_edition::EditionDeclaration;
     use vortex_edition::EditionId;
     use vortex_edition::EditionSession;
     use vortex_edition::EditionSessionExt;
 
     #[test]
-    fn initial_array_ids_are_registered_and_enabled() -> Result<(), vortex_edition::EditionError> {
+    fn array_context_only_permits_enabled_encodings() -> Result<(), vortex_edition::EditionError> {
         const EDITION: EditionId = EditionId::new("test", 2026, 7, 0);
         static DECLARATION: EditionDeclaration = EditionDeclaration {
             edition: Edition {
                 id: EDITION,
                 min_vortex_version: None,
             },
-            added: &[&"vortex.primitive", &"test.not_registered"],
+            added: &[&"vortex.primitive"],
         };
 
         let session = array_session().with::<EditionSession>();
         session.register_edition(&DECLARATION)?;
         session.enable_edition(EDITION)?;
 
-        let registry = session.arrays().registry().clone();
-        let ids = session.enabled_encoding_ids();
-        assert_eq!(ids, [Primitive.id()]);
-        assert!(!ids.contains(&Bool.id()));
+        let enabled_encoding_ids = session.enabled_encoding_ids();
+        let ctx =
+            ArrayContext::new(enabled_encoding_ids.clone()).with_valid_ids(enabled_encoding_ids);
+        assert_eq!(ctx.to_ids(), [Primitive.id()]);
+        assert!(ctx.intern(&Bool.id()).is_none());
         Ok(())
     }
 }

vortex-file/src/writer.rs

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_array::session::ArraySessionExt;
+use vortex_edition::Edition;
+use vortex_edition::EditionId;
+use vortex_edition::EditionInclusion;
+use vortex_edition::EditionSessionExt;
+use vortex_error::VortexExpect;
+use vortex_error::vortex_err;
+use vortex_session::VortexSession;
+
+/// This is a vortex edition used for testing and shouldn't made public.
+const TEST_EDITION: EditionId = EditionId::new("test", 2026, 7, 0);
+
+pub fn enable_all_registered_array_encodings(session: &VortexSession) {
+    let editions = session.editions();
+    editions
+        .declare_edition(Edition {
+            id: TEST_EDITION,
+            min_vortex_version: None,
+        })
+        .map_err(|error| vortex_err!("{error}"))
+        .vortex_expect("test edition is valid");
+    for id in session.arrays().registry().ids() {
+        editions
+            .declare_inclusion(EditionInclusion::new(&id, TEST_EDITION))
+            .map_err(|error| vortex_err!("{error}"))
+            .vortex_expect("registered array encoding has one test-edition inclusion");
+    }
+    session
+        .enable_edition(TEST_EDITION)
+        .map_err(|error| vortex_err!("{error}"))
+        .vortex_expect("test edition is registered");
+}

vortex-file/tests/common/mod.rs

@@ -14,23 +14,26 @@ use std::mem::size_of;
 use std::sync::LazyLock;
 
 use vortex_array::IntoArray;
-use vortex_array::session::ArraySessionExt;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_file::OpenOptionsSessionExt;
 use vortex_file::WriteOptionsSessionExt;
-use vortex_file::WriteStrategyBuilder;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
 
+mod common;
+
+use common::enable_all_registered_array_encodings;
+
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     let session = vortex_array::array_session()
         .with::<LayoutSession>()
         .with::<RuntimeSession>();
 
     vortex_file::register_default_encodings(&session);
+    enable_all_registered_array_encodings(&session);
 
     session
 });
@@ -40,14 +43,8 @@ async fn open_buffer_rejects_out_of_bounds_footer_segment() {
     // Write a valid file to obtain a well-formed footer.
     let mut buf = ByteBufferMut::empty();
     let array = Buffer::from((0i32..256).collect::<Vec<i32>>()).into_array();
-    let allowed = SESSION.arrays().registry().ids().collect();
     SESSION
         .write_options()
-        .with_strategy(
-            WriteStrategyBuilder::default()
-                .with_allow_encodings(allowed)
-                .build(),
-        )
         .write(&mut buf, array.to_array_stream())
         .await
         .expect("write");

vortex-file/tests/issue_8819_footer_segment_oob.rs

@@ -18,39 +18,33 @@ use vortex_array::arrays::StructArray;
 use vortex_array::arrays::struct_::StructArrayExt;
 use vortex_array::dtype::FieldNames;
 use vortex_array::field_path;
-use vortex_array::session::ArraySessionExt;
 use vortex_array::validity::Validity;
 use vortex_btrblocks::BtrBlocksCompressor;
 use vortex_buffer::ByteBuffer;
 use vortex_file::OpenOptionsSessionExt;
-use vortex_file::VortexWriteOptions;
 use vortex_file::WriteOptionsSessionExt;
-use vortex_file::WriteStrategyBuilder;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::layouts::compressed::CompressingStrategy;
 use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
 use vortex_layout::layouts::table::TableStrategy;
 use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
+
+mod common;
+
+use common::enable_all_registered_array_encodings;
+
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     let session = vortex_array::array_session()
         .with::<LayoutSession>()
         .with::<RuntimeSession>();
 
     vortex_file::register_default_encodings(&session);
+    enable_all_registered_array_encodings(&session);
 
     session
 });
 
-fn all_registered_write_options() -> VortexWriteOptions {
-    let allowed = SESSION.arrays().registry().ids().collect();
-    SESSION.write_options().with_strategy(
-        WriteStrategyBuilder::default()
-            .with_allow_encodings(allowed)
-            .build(),
-    )
-}
-
 #[tokio::test]
 async fn test_file_roundtrip() {
     let mut ctx = SESSION.create_execution_ctx();
@@ -154,7 +148,8 @@ async fn test_dict_listview_validity_roundtrip() {
         .into_array();
 
     let mut bytes = Vec::new();
-    all_registered_write_options()
+    SESSION
+        .write_options()
         .write(&mut bytes, data.to_array_stream())
         .await
         .expect("write should not fail with fill_null serialization error");
@@ -199,7 +194,8 @@ async fn test_write_empty_nullable_struct_column() {
     .into_array();
 
     let mut bytes = Vec::new();
-    all_registered_write_options()
+    SESSION
+        .write_options()
         .write(&mut bytes, data.to_array_stream())
         .await
         .expect("writing an empty nullable struct column should not panic");