feat(encoding): implement vortex.ext encoder

Override accepts() and encode() so the writer can encode Extension
dtypes. Encode delegates the storage child to PrimitiveEncoding, then
wraps in a vortex.ext node. Adds round-trip and accepts() unit tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/encoding/ExtEncoding.java

@@ -4,24 +4,33 @@
 import io.github.dfa1.vortex.core.VortexException;
 import io.github.dfa1.vortex.core.array.Array;
 
-/// Decoder for {@code vortex.ext} — extension type transparent storage wrapper.
+/// Encoder/decoder for {@code vortex.ext} — extension type transparent storage wrapper.
 ///
-/// <p>No buffers, empty metadata. Child slot 0: the storage array decoded using
+/// <p>No buffers, empty metadata. Child slot 0: the storage array encoded/decoded using
 /// the extension dtype's storage dtype and same row count.
 ///
-/// <p>Decode: unwraps the single child and returns it directly.
-/// The extension type information (name, metadata) is carried by {@link DType.Extension}
-/// on the parent but is not needed for decoding.
+/// <p>Encode: delegates to {@link PrimitiveEncoding} for the storage child, wraps in ext node.
+/// Decode: unwraps the single child and returns it directly.
 public final class ExtEncoding implements Encoding {
 
 	@Override
 	public EncodingId encodingId() {
 		return EncodingId.VORTEX_EXT;
 	}
 
+	@Override
+	public boolean accepts(DType dtype) {
+		return dtype instanceof DType.Extension;
+	}
+
 	@Override
 	public EncodeResult encode(DType dtype, Object data) {
-		throw new UnsupportedOperationException("encode not supported by " + encodingId());
+		if (!(dtype instanceof DType.Extension ext)) {
+			throw new VortexException(EncodingId.VORTEX_EXT, "expected extension dtype, got " + dtype);
+		}
+		EncodeResult childResult = new PrimitiveEncoding().encode(ext.storageDType(), data);
+		EncodeNode root = new EncodeNode(EncodingId.VORTEX_EXT, null, new EncodeNode[]{childResult.rootNode()}, new int[0]);
+		return new EncodeResult(root, childResult.buffers(), childResult.statsMin(), childResult.statsMax());
 	}
 
 	@Override

core/src/test/java/io/github/dfa1/vortex/encoding/ExtEncodingTest.java

@@ -3,6 +3,7 @@
 import io.github.dfa1.vortex.core.DType;
 import io.github.dfa1.vortex.core.PType;
 import io.github.dfa1.vortex.core.array.LongArray;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import java.lang.foreign.Arena;
@@ -17,6 +18,74 @@ class ExtEncodingTest {
 	private static final ValueLayout.OfLong LE_LONG =
 			ValueLayout.JAVA_LONG_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
 
+	@Nested
+	class Encode {
+
+		@Test
+		void accepts_extensionDtype_returnsTrue() {
+			// Given
+			DType extDType = new DType.Extension("vortex.timestamp",
+					new DType.Primitive(PType.I64, false), null, false);
+			var sut = new ExtEncoding();
+
+			// When / Then
+			assertThat(sut.accepts(extDType)).isTrue();
+		}
+
+		@Test
+		void accepts_primitiveDtype_returnsFalse() {
+			// Given
+			var sut = new ExtEncoding();
+
+			// When / Then
+			assertThat(sut.accepts(new DType.Primitive(PType.I64, false))).isFalse();
+		}
+
+		@Test
+		void encode_extensionWrappingI64_roundTrips() {
+			// Given
+			long[] data = {100L, 200L, 300L, 400L};
+			DType storageDType = new DType.Primitive(PType.I64, false);
+			DType extDType = new DType.Extension("vortex.timestamp", storageDType, null, false);
+			var sut = new ExtEncoding();
+
+			// When
+			EncodeResult result = sut.encode(extDType, data);
+
+			// Then — root is ext, child is primitive
+			assertThat(result.rootNode().encodingId()).isEqualTo(EncodingId.VORTEX_EXT);
+			assertThat(result.rootNode().children()).hasSize(1);
+			assertThat(result.rootNode().children()[0].encodingId()).isEqualTo(EncodingId.VORTEX_PRIMITIVE);
+
+			// Decode back
+			EncodingRegistry registry = EncodingRegistry.empty();
+			registry.register(new PrimitiveEncoding());
+			registry.register(new ExtEncoding());
+			ArrayNode rootNode = encodeNodeToArrayNode(result.rootNode());
+			DecodeContext ctx = new DecodeContext(
+					rootNode, extDType, data.length,
+					result.buffers().toArray(MemorySegment[]::new),
+					registry, Arena.ofAuto());
+			var decoded = sut.decode(ctx);
+
+			assertThat(decoded).isInstanceOf(LongArray.class);
+			for (int i = 0; i < data.length; i++) {
+				assertThat(decoded.getLong(i)).isEqualTo(data[i]);
+			}
+		}
+
+		private ArrayNode encodeNodeToArrayNode(EncodeNode n) {
+			ArrayNode[] children = new ArrayNode[n.children().length];
+			for (int i = 0; i < children.length; i++) {
+				children[i] = encodeNodeToArrayNode(n.children()[i]);
+			}
+			return new ArrayNode(n.encodingId(), n.metadata(), children, n.bufferIndices(), null);
+		}
+	}
+
+	@Nested
+	class Decode {
+
 	@Test
 	void decode_extensionWrappingI64_returnsStorageArray() {
 		// Given
@@ -56,4 +125,5 @@ void decode_extensionWrappingI64_returnsStorageArray() {
 			assertThat(result.getLong(i)).isEqualTo(values[i]);
 		}
 	}
+	}
 }