@@ -46,7 +46,6 @@ use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_array::buffer::BufferHandle;
 use vortex_error::VortexResult;
-use vortex_mask::Mask;
 use vortex_session::VortexSession;
 
 pub use self::compile::Chain;
@@ -61,7 +60,6 @@ pub use self::scan::ReadRequest;
 pub use self::scan::Scan;
 pub use self::scan::Split;
 pub use self::scan::Turn;
-use crate::plan::PlanRef;
 use crate::segments::SegmentId;
 
 /// Batches an inlet holds before its writer is blocked, unless its reader says otherwise.
@@ -140,13 +138,6 @@ pub trait Source: Operator {
     }
 }
 
-/// A plan a source asks to have compiled into a new inlet.
-pub(crate) struct Spawn {
-    plan: PlanRef,
-    rows: std::ops::Range<u64>,
-    mask: Mask,
-}
-
 /// What a stage may touch during one call: its pipeline's inlets, the bytes it asked for, and
 /// the session.
 pub struct Cx<'a> {
@@ -155,7 +146,6 @@ pub struct Cx<'a> {
     bytes: &'a mut Option<BufferHandle>,
     session: &'a VortexSession,
     exec: &'a mut ExecutionCtx,
-    spawns: &'a mut Vec<Spawn>,
     /// The inlets read during this run, so only their writers are checked for room after it.
     touched: &'a mut SmallVec<[usize; 4]>,
 }
@@ -183,16 +173,6 @@ impl Cx<'_> {
     pub fn exec(&mut self) -> &mut ExecutionCtx {
         self.exec
     }
-
-    /// Asks for `plan` over `rows`, restricted to `mask`, to be compiled into a new inlet of this
-    /// source once the call returns, and returns the inlet's index.
-    ///
-    /// For a source that learns what it must read only from what it has read, as a list learns
-    /// its elements' range from its offsets.
-    pub fn spawn(&mut self, plan: PlanRef, rows: std::ops::Range<u64>, mask: Mask) -> usize {
-        self.spawns.push(Spawn { plan, rows, mask });
-        self.inlets.len() + self.spawns.len() - 1
-    }
 }
 
 #[cfg(test)]
 
@@ -26,7 +26,6 @@ use super::Cx;
 use super::Input;
 use super::Operator;
 use super::Source;
-use super::Spawn;
 use super::Step;
 use super::compile::Chain;
 use super::compile::Shares;
@@ -97,7 +96,6 @@ pub(crate) struct Pipeline {
     inlets: Vec<PortId>,
     outlets: SmallVec<[PortId; 1]>,
     bytes: Option<BufferHandle>,
-    spawns: Vec<Spawn>,
     /// The inlets the last run read.
     touched: SmallVec<[usize; 4]>,
     state: State,
@@ -129,7 +127,6 @@ fn drive(
         inlets,
         outlets,
         bytes,
-        spawns,
         touched,
         ..
     } = pipe;
@@ -139,7 +136,6 @@ fn drive(
         bytes,
         session,
         exec,
-        spawns,
         touched,
     };
     loop {
@@ -283,7 +279,6 @@ impl Core {
             inlets: chain.inlets,
             outlets,
             bytes: None,
-            spawns: Vec::new(),
             touched: SmallVec::new(),
             state: State::Runnable,
             queued: true,
@@ -355,11 +350,6 @@ impl Core {
             .ok_or_else(|| vortex_err!("Pipeline {id} is not live"))?;
         pipe.queued = false;
         let progress = drive(pipe, &mut self.arena, &self.session, &mut self.exec)?;
-        if !pipe.spawns.is_empty() {
-            for spawn in std::mem::take(&mut pipe.spawns) {
-                self.spawn_inlet(id, spawn)?;
-            }
-        }
         match progress {
             Progress::Read(segment_id) => {
                 let read = ReadId(self.next_read);
@@ -384,21 +374,6 @@ impl Core {
         Ok(())
     }
 
-    /// Compiles what a source asked for into a new inlet of it.
-    fn spawn_inlet(&mut self, id: PipelineId, spawn: Spawn) -> VortexResult<()> {
-        let index = self.pipeline(id).inlets.len();
-        let capacity = self.pipeline(id).source.capacity(index);
-        let port = self.arena.create(capacity, None, Reader::Pipeline(id));
-        self.pipeline_mut(id).inlets.push(port);
-        match self.compile(&spawn.plan, spawn.rows, &spawn.mask)? {
-            Some(chain) => {
-                self.add_pipeline(chain, smallvec::smallvec![port]);
-            }
-            None => self.arena.close(port),
-        }
-        Ok(())
-    }
-
     /// Wakes the readers of what pipeline `id` wrote and the writers of what it took.
     fn wake_neighbours(&mut self, id: PipelineId) {
         let mut wake: SmallVec<[PipelineId; 4]> = SmallVec::new();