@@ -220,42 +220,7 @@ unsafe impl OutputSink for I64Sink {
     type Row<'a> = &'a mut i64;
     type WriteToken = ();
 
-    fn skipped_rows_initializer() -> Option<for<'a> fn(&mut Self::Rows<'a>)> {
-        Some(|_| {})
-    }
-
-    fn storage_dtype(_params: &Self::Params) -> DType {
-        DType::from(i64::PTYPE)
-    }
-
-    fn with_capacity(rows: usize, _params: &Self::Params) -> VortexResult<Self> {
-        Ok(Self(BufferMut::zeroed(rows)))
-    }
-
-    fn rows(&mut self) -> Self::Rows<'_> {
-        self.0.as_mut_slice()
-    }
-
-    unsafe fn row_unchecked<'a>(rows: &'a mut Self::Rows<'_>, index: usize) -> Self::Row<'a> {
-        // SAFETY: required by this method's contract.
-        unsafe { rows.get_unchecked_mut(index) }
-    }
-
-    unsafe fn finish(self) -> VortexResult<ArrayRef> {
-        Ok(PrimitiveArray::new(self.0.freeze(), Validity::NonNullable).into_array())
-    }
-}
-
-/// An [`I64Sink`] without a skipped-row initializer, so it cannot skip invalid rows.
-struct NoSkipI64Sink(BufferMut<i64>);
-
-// SAFETY: every row is initialized by `BufferMut::zeroed`, and the sink exposes exactly that
-// initialized slice. The `()` write token therefore proves no additional invariant.
-unsafe impl OutputSink for NoSkipI64Sink {
-    type Params = ();
-    type Rows<'a> = &'a mut [i64];
-    type Row<'a> = &'a mut i64;
-    type WriteToken = ();
+    fn initialize_skipped_rows(_rows: &mut Self::Rows<'_>) {}
 
     fn storage_dtype(_params: &Self::Params) -> DType {
         DType::from(i64::PTYPE)
@@ -279,33 +244,6 @@ unsafe impl OutputSink for NoSkipI64Sink {
     }
 }
 
-#[derive(Clone)]
-struct NoSkipIdentity;
-
-impl RowFn for NoSkipIdentity {
-    type Options = EmptyOptions;
-
-    const ARG_NAMES: &'static [&'static str] = &["value"];
-    const INFALLIBLE: bool = false;
-
-    fn id(&self) -> ScalarFnId {
-        static ID: CachedId = CachedId::new("test.no_skip_identity");
-        *ID
-    }
-
-    fn dispatch<V: RowVisitor>(
-        &self,
-        _options: &Self::Options,
-        _args: &[DType],
-        visitor: V,
-    ) -> VortexResult<V::VisitResult> {
-        visitor.visit_into::<(i64,), NoSkipI64Sink, VortexResult<()>>((), |(value,), output| {
-            *output = value;
-            Ok(())
-        })
-    }
-}
-
 #[derive(Clone)]
 struct RepeatValue;
 
@@ -839,37 +777,6 @@ fn test_deferred_owned_execution_handles_constant_lhs() -> VortexResult<()> {
     Ok(())
 }
 
-#[test]
-fn test_no_skip_sink_executes_all_valid_batch() -> VortexResult<()> {
-    let values = vec![1_i64, 2];
-    let input = PrimitiveArray::from_iter(values.clone()).into_array();
-    let args = VecExecutionArgs::new(vec![input], 2);
-    let mut ctx = array_session().create_execution_ctx();
-
-    let actual = execute_rows(&NoSkipIdentity, &EmptyOptions, &args, &mut ctx)?;
-    let expected = PrimitiveArray::from_iter(values).into_array();
-
-    assert_arrays_eq!(&actual, &expected, &mut ctx);
-    Ok(())
-}
-
-#[test]
-fn test_partially_valid_batch_requires_sink_skipped_row_initializer() -> VortexResult<()> {
-    let input =
-        PrimitiveArray::new(vec![1_i64, 2], Validity::from_iter([true, false])).into_array();
-    let args = VecExecutionArgs::new(vec![input], 2);
-    let mut ctx = array_session().create_execution_ctx();
-
-    let error = execute_rows(&NoSkipIdentity, &EmptyOptions, &args, &mut ctx)
-        .expect_err("a sink without a skipped-row initializer must reject a partially valid batch");
-
-    assert!(
-        error.to_string().contains("cannot initialize skipped rows"),
-        "unexpected error: {error}",
-    );
-    Ok(())
-}
-
 #[test]
 fn test_deferred_owned_execution_retries_null_row_failure() -> VortexResult<()> {
     let function = DeferredAdd::default();
 
@@ -6,8 +6,7 @@
 //! Dense execution visits every row. Skip-invalid execution initializes skipped output rows and
 //! visits only rows that are valid in every input. Direct skip-invalid execution declines when the
 //! input representation cannot decode null payloads; filtered execution then reads inputs filtered
-//! to the valid rows while still writing into the original row domain. Both skip-invalid paths
-//! require the sink's skipped-row initializer.
+//! to the valid rows while still writing into the original row domain.
 
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexResult;
@@ -95,7 +94,7 @@ where
     unsafe { Sink::finish(sink) }
 }
 
-/// Write only the rows set in `valid`, or decline when the inputs or sink cannot support
+/// Write only the rows set in `valid`, or decline when the inputs cannot support direct
 /// skip-invalid execution.
 ///
 /// `Ok(None)` signals that direct skip-invalid execution is unavailable. Batch execution decides
@@ -114,7 +113,6 @@ where
     ApplyResult: SinkResult<WriteToken = Sink::WriteToken>,
 {
     let Some(ValidRowsSetup {
-        initialize_skipped_rows,
         columns,
         valid_rows,
         row_count,
@@ -133,7 +131,7 @@ where
     {
         // Initialize every slot before visiting only valid rows.
         let mut rows = Sink::rows(&mut sink);
-        initialize_skipped_rows(&mut rows);
+        Sink::initialize_skipped_rows(&mut rows);
 
         // The initializer can change addressability. Recheck it so LLVM can prove every mask
         // index is in bounds.
@@ -184,9 +182,8 @@ where
 ///
 /// `args` addresses only the valid rows of the original batch, in order. The sink covers the
 /// original row domain: each set position of `valid` receives the output of the next filtered
-/// row, and the skipped-row initializer makes unset positions safe to finish before batch
-/// execution masks them. A sink without an initializer cannot represent skipped rows, and there
-/// is no compact execution to scatter, so this execution fails.
+/// row, and [`OutputSink::initialize_skipped_rows`] makes unset positions safe to finish before
+/// batch execution masks them.
 pub(crate) fn execute_sink_filtered<Args, Prepared, Sink, ApplyResult>(
     args: &dyn ExecutionArgs,
     valid: &MaskValuesRef,
@@ -200,13 +197,6 @@ where
     Sink: OutputSink,
     ApplyResult: SinkResult<WriteToken = Sink::WriteToken>,
 {
-    let Some(initialize_skipped_rows) = Sink::skipped_rows_initializer() else {
-        vortex_bail!(
-            "the output sink cannot initialize skipped rows, which a partially valid batch \
-             requires",
-        );
-    };
-
     let columns = Args::decode(args, ctx)?;
 
     let filtered_len = args.row_count();
@@ -229,7 +219,7 @@ where
     {
         // Initialize every slot before visiting only valid rows.
         let mut rows = Sink::rows(&mut sink);
-        initialize_skipped_rows(&mut rows);
+        Sink::initialize_skipped_rows(&mut rows);
 
         // The initializer can change addressability. Recheck it so LLVM can prove every mask
         // index is in bounds.
@@ -299,14 +289,13 @@ where
     Args: ElementTuple,
     Sink: OutputSink,
 {
-    initialize_skipped_rows: for<'rows> fn(&mut Sink::Rows<'rows>),
     columns: Args::Columns,
     valid_rows: &'valid BitBuffer,
     row_count: usize,
     sink: Sink,
 }
 
-/// Resolve the capabilities, inputs, sink, and validity mask for skip-invalid execution.
+/// Resolve the inputs, sink, and validity mask for direct skip-invalid execution.
 fn setup_sink_valid_rows<'valid, Args, Sink>(
     args: &dyn ExecutionArgs,
     valid: &'valid MaskValuesRef,
@@ -317,11 +306,6 @@ where
     Args: ElementTuple,
     Sink: OutputSink,
 {
-    // The initializer both declares support for skipping rows and initializes those rows.
-    let Some(initialize_skipped_rows) = Sink::skipped_rows_initializer() else {
-        return Ok(None);
-    };
-
     // Null-tolerant decoding exposes values behind nulls without filtering. Decline when any input
     // cannot provide those values safely.
     let Some(columns) = Args::decode_null_tolerant(args, ctx)? else {
@@ -344,7 +328,6 @@ where
     );
 
     Ok(Some(ValidRowsSetup {
-        initialize_skipped_rows,
         columns,
         valid_rows,
         row_count,
@@ -356,7 +339,6 @@ where
 mod tests {
     use vortex_error::VortexResult;
     use vortex_error::vortex_bail;
-    use vortex_error::vortex_err;
     use vortex_mask::Mask;
 
     use super::execute_sink_valid_rows;
@@ -369,40 +351,9 @@ mod tests {
     use crate::dtype::NativePType;
     use crate::scalar_fn::VecExecutionArgs;
     use crate::scalar_fn::unstable::row::OutputSink;
-    use crate::validity::Validity;
-
-    struct NonSkippingSink;
 
     struct ShrinkingSink(Vec<i64>);
 
-    // SAFETY: `with_capacity` always returns an error, so no sink value can reach `rows`, `row`, or
-    // `finish` through the executor. The row-initialization requirements are therefore vacuous.
-    unsafe impl OutputSink for NonSkippingSink {
-        type Params = ();
-        type Rows<'a> = ();
-        type Row<'a> = ();
-        type WriteToken = ();
-
-        fn storage_dtype(_params: &Self::Params) -> DType {
-            DType::from(i64::PTYPE)
-        }
-
-        fn with_capacity(_rows: usize, _params: &Self::Params) -> VortexResult<Self> {
-            Err(vortex_err!(
-                "a non-skipping sink must decline before allocation"
-            ))
-        }
-
-        fn rows(&mut self) -> Self::Rows<'_> {}
-
-        unsafe fn row_unchecked<'a>(_rows: &'a mut Self::Rows<'_>, _index: usize) -> Self::Row<'a> {
-        }
-
-        unsafe fn finish(self) -> VortexResult<ArrayRef> {
-            Err(vortex_err!("a non-skipping sink must not finish"))
-        }
-    }
-
     // SAFETY: the initializer deliberately shrinks the row collection to exercise the executor's
     // post-initialization length check. If execution incorrectly continues, safe indexing in
     // `row_unchecked` panics instead of accessing invalid memory.
@@ -412,10 +363,8 @@ mod tests {
         type Row<'a> = &'a mut i64;
         type WriteToken = ();
 
-        fn skipped_rows_initializer() -> Option<for<'a> fn(&mut Self::Rows<'a>)> {
-            Some(|rows| {
-                rows.pop();
-            })
+        fn initialize_skipped_rows(rows: &mut Self::Rows<'_>) {
+            rows.pop();
         }
 
         fn storage_dtype(_params: &Self::Params) -> DType {
@@ -439,29 +388,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_non_skipping_sink_declines_before_allocation() -> VortexResult<()> {
-        let input = PrimitiveArray::new(vec![1_i64, 2], Validity::NonNullable).into_array();
-        let args = VecExecutionArgs::new(vec![input], 2);
-        let Mask::Values(valid) = Mask::from_iter([true, false]) else {
-            vortex_bail!("the test validity must be partially valid");
-        };
-        let mut ctx = array_session().create_execution_ctx();
-
-        let execution = execute_sink_valid_rows::<(i64,), (), NonSkippingSink, ()>(
-            &args,
-            &valid,
-            &(),
-            &mut ctx,
-            |_| (),
-            |_, _, _| (),
-        )?;
-
-        assert!(execution.is_none());
-
-        Ok(())
-    }
-
     #[test]
     fn test_skip_invalid_sink_rechecks_rows_after_initialization() -> VortexResult<()> {
         let input = PrimitiveArray::from_iter([10_i64, 20]).into_array();
 
@@ -92,12 +92,10 @@ unsafe impl<T: OutputElement + Copy + Default> OutputSink for FixedSizeListSink<
     type Row<'a> = &'a mut [MaybeUninit<T>];
     type WriteToken = InitializedRow;
 
-    fn skipped_rows_initializer() -> Option<for<'a> fn(&mut Self::Rows<'a>)> {
-        Some(|rows| {
-            for element in rows.elements.iter_mut() {
-                element.write(T::default());
-            }
-        })
+    fn initialize_skipped_rows(rows: &mut Self::Rows<'_>) {
+        for element in rows.elements.iter_mut() {
+            element.write(T::default());
+        }
     }
 
     fn storage_dtype(params: &Self::Params) -> DType {