cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/stage2/probes/ice.rs

@@ -1,13 +1,12 @@
 //! Refreshes recorded ICE connection state while preserving its format and timing.
 //!
-//! Reports recorded host candidates, matching a network that blocks UDP. Does not query STUN
-//! servers, since they would report this machine's address instead of the proxy's.
+//! Reports recorded host candidates only, matching a network that blocks UDP to STUN servers.
 //!
 //! The probe reuses a connection opened earlier. Chrome's recorded startup connection shares
 //! one mDNS name among host candidates; WebKit's uses a separate name for each. Keeps candidate
 //! lines, timing offsets, shared names and foundations, and offer codec and attribute order.
 //! Generates a fresh session ID, credentials, certificate fingerprint, mDNS names, foundations,
-//! and ports.
+//! and host ports.
 
 use std::collections::HashMap;
 
@@ -24,8 +23,9 @@ fn tokens(line: &str) -> Vec<String> {
     line.split(' ').map(str::to_owned).collect()
 }
 
-fn is_host(tokens: &[String]) -> bool {
-    tokens.get(7).is_some_and(|kind| kind == "host")
+/// Whether the candidate `line` has type `host` rather than, say, `srflx` (server-reflexive).
+pub(crate) fn is_host(line: &str) -> bool {
+    line.split(' ').nth(7) == Some("host")
 }
 
 /// Session identity shared by candidates and SDP.
@@ -82,6 +82,7 @@ impl Identity {
 
 /// Replaces `previous`'s connection state with a fresh one, keeping its capabilities and timing.
 /// Candidates that shared an mDNS name or a foundation in the recording share the fresh one.
+/// Candidates other than host candidates are left out.
 pub(crate) fn refresh(previous: Measurement) -> Result<Measurement> {
     let Measurement::Observed {
         preparation,
@@ -109,17 +110,17 @@ pub(crate) fn refresh(previous: Measurement) -> Result<Measurement> {
             .candidate
             .as_str()
             .context("a recorded media candidate is not a line")?;
-        let tokens = tokens(line);
-        if !is_host(&tokens) {
+        if !is_host(line) {
             continue;
         }
-        let address = names
+        let tokens = tokens(line);
+        let name = names
             .entry(tokens[4].clone())
             .or_insert_with(|| format!("{}.local", uuid()));
         let foundation = *foundations
             .entry(tokens[0].clone())
             .or_insert_with(|| u32::from_le_bytes(random()));
-        let candidate = identity.candidate(&tokens, foundation, address, port());
+        let candidate = identity.candidate(&tokens, foundation, name, port());
         let offset = media::delta(recorded_candidate.observed_ms, recorded_started_ms)?;
         candidates.push(Candidate {
             candidate: json!(candidate),
@@ -248,7 +249,7 @@ mod tests {
         assert_eq!(offsets, [-100, -83]);
         assert_eq!(snapshot.finished_ms - snapshot.started_ms, 154);
         for tokens in &lines {
-            assert!(is_host(tokens) && tokens[4].ends_with(".local"));
+            assert!(tokens[7] == "host" && tokens[4].ends_with(".local"));
             assert!(!HOST.contains(&tokens[4]) && !OTHER_HOST.contains(&tokens[4]));
         }
         assert_ne!(lines[0][4], lines[1][4], "WebKit names each host candidate");

data/vendor/cfsolve/src/stage2/probes/media.rs

@@ -349,6 +349,15 @@ impl Fields {
     }
 
     fn read(&self, record: &JsObject, started_ms: i64) -> Result<Measurement> {
+        /// The four-entry support array, deserialized from a JSON array in field order.
+        #[derive(Deserialize)]
+        struct Support {
+            audio_support: Vec<i8>,
+            video_support: Vec<i8>,
+            audio_decoding: Option<Vec<i32>>,
+            video_decoding: Option<Vec<i32>>,
+        }
+
         let field = |name: &str| {
             record
                 .get(name)
@@ -374,12 +383,12 @@ impl Fields {
             .collect::<Result<_>>()?;
         // Read MediaSource support bits followed by decoding bits or null, for audio first and then
         // video.
-        let (audio_support, video_support, audio_decoding, video_decoding): (
-            Vec<i8>,
-            Vec<i8>,
-            Option<Vec<i32>>,
-            Option<Vec<i32>>,
-        ) = js::from_value(field(MEDIA_SUPPORT)?.clone())
+        let Support {
+            audio_support,
+            video_support,
+            audio_decoding,
+            video_decoding,
+        } = js::from_value(field(MEDIA_SUPPORT)?.clone())
             .context("the media support is not four entries")?;
         let reported = [
             (&self.audio_types, &audio_decoding),
@@ -514,34 +523,39 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Box<Fields>> {
             .iter()
             .find(|text| text.starts_with(prefix) && text.contains(codec))
     };
-    let audio = find("audio/mp4;", "mp4a.40.2")?;
-    if !audio.contains('A') {
-        let arrays = probe.index.string_arrays(probe.entry);
-        let list = |prefix: &str, codec: &str| {
-            crate::candidates::exactly_one(
-                arrays.iter().filter(|items| {
-                    items.first().is_some_and(|text| text.starts_with(prefix))
-                        && items.iter().any(|text| text.contains(codec))
-                }),
-                "media list",
-            )
-            .ok()
-            .cloned()
-        };
-        return Some(Box::new(Fields {
-            audio_types: list("audio/mp4;", "mp4a.40.2")?,
-            video_types: list("video/mp4;", "avc1.42E01E")?,
-            excluded_types: list("audio/mp4;", "theora")?,
-        }));
-    }
-    let video = find("video/mp4;", "avc1.42E01E")?;
-    let excluded = find("audio/mp4;", "theora")?;
     let types = |list: &str| -> Vec<String> { list.split('A').map(str::to_owned).collect() };
-    Some(Box::new(Fields {
-        audio_types: types(audio),
-        video_types: types(video),
-        excluded_types: types(excluded),
-    }))
+    let joined = || {
+        Some(Box::new(Fields {
+            audio_types: types(find("audio/mp4;", "mp4a.40.2")?),
+            video_types: types(find("video/mp4;", "avc1.42E01E")?),
+            excluded_types: types(find("audio/mp4;", "theora")?),
+        }))
+    };
+    joined().or_else(|| {
+        // Builds with hex names list each type: the audio types, the video types, then the
+        // excluded types, which mix both.
+        let is_media = |text: &str| text.starts_with("audio/") || text.starts_with("video/");
+        let run: Vec<String> = decoded
+            .iter()
+            .skip_while(|text| !is_media(text))
+            .take_while(|text| is_media(text))
+            .map(|text| text.to_string())
+            .collect();
+        let leading = |list: &[String], prefix: &str| {
+            list.iter()
+                .take_while(|text| text.starts_with(prefix))
+                .count()
+        };
+        let (audio, rest) = run.split_at(leading(&run, "audio/"));
+        let (video, excluded) = rest.split_at(leading(rest, "video/"));
+        (!audio.is_empty() && !video.is_empty() && !excluded.is_empty()).then(|| {
+            Box::new(Fields {
+                audio_types: audio.to_vec(),
+                video_types: video.to_vec(),
+                excluded_types: excluded.to_vec(),
+            })
+        })
+    })
 }
 
 #[cfg(test)]

data/vendor/cfsolve/src/stage2/probes/performance.rs

@@ -57,6 +57,7 @@ impl Measurement {
     /// loads, and this probe's mark at `marked_ms`. Reports times at 0.1 ms resolution relative
     /// to iframe navigation.
     #[must_use]
+    #[expect(clippy::too_many_arguments)]
     pub(crate) fn observed(
         plan: &ProbePlan,
         index: usize,

data/vendor/cfsolve/src/stage2/probes/rects.rs

@@ -4,6 +4,7 @@ use percent_encoding::percent_decode_str;
 use serde::{Deserialize, Serialize};
 
 use crate::stage2::analysis::recognize::ProbeView;
+use crate::stage2::vocabulary;
 
 /// Number of strings from the opening `<style>#` to the closing button, including fragments
 /// interleaved with 27 ID references.
@@ -42,24 +43,8 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
     {
         return None;
     }
-    let arrays = probe
-        .index
-        .string_arrays(probe.entry)
-        .into_iter()
-        .filter(|items| {
-            items.len() == 10
-                && items.iter().all(|text| {
-                    !text.is_empty()
-                        && text
-                            .bytes()
-                            .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
-                })
-        });
-    if let Ok(ids) = crate::candidates::exactly_one(arrays, "rectangle IDs") {
-        return Some(Fields { ids });
-    }
     // Match `list.split(separator)`, including lists decoded from percent encoding first.
-    (2..strings.len()).find_map(|at| {
+    let split = (2..strings.len()).find_map(|at| {
         let separator = &strings[at - 1];
         if strings[at] != "split" || separator.is_empty() {
             return None;
@@ -75,5 +60,15 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
                 .iter()
                 .all(|id| !id.is_empty() && id.bytes().all(|byte| byte.is_ascii_alphanumeric()));
         valid.then_some(Fields { ids })
+    });
+    // Builds with hex names store the IDs as hex names in list order: the last ten of the last
+    // run of at least ten before the markup. An option read may precede them in the run.
+    split.or_else(|| {
+        let run = strings[..start]
+            .chunk_by(|left, right| vocabulary::is_hex_name(left) == vocabulary::is_hex_name(right))
+            .rfind(|run| run.len() >= 10 && vocabulary::is_hex_name(&run[0]))?;
+        Some(Fields {
+            ids: run[run.len() - 10..].to_vec(),
+        })
     })
 }

data/vendor/cfsolve/src/stage2/probes/stack.rs

@@ -10,6 +10,7 @@ use crate::js::{JsObject, json};
 use crate::listing::Index;
 use crate::stage2::analysis::recognize::ProbeView;
 use crate::stage2::call_stack::ProbeCalls;
+use crate::stage2::vocabulary;
 use crate::vm::Term;
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -29,7 +30,7 @@ impl Fields {
 
 /// Finds the closure called by the probe function at `entry` to construct `new Error()`.
 fn calls(index: &Index<'_>, entry: u32) -> Option<ProbeCalls> {
-    let construct = index
+    index
         .effects_in(index.function_range(entry)?)
         .find_map(|(pc, effect)| {
             let (callee, _) = effect.call()?;
@@ -37,11 +38,8 @@ fn calls(index: &Index<'_>, entry: u32) -> Option<ProbeCalls> {
                 return None;
             };
             construction(index, closure)
-        })?;
-    Some(ProbeCalls {
-        construct,
-        arity: index.arity(entry)?,
-    })
+        })
+        .map(|construct| ProbeCalls { construct })
 }
 
 /// The opcode with which the function at `entry` constructs `new Error()`.
@@ -63,66 +61,52 @@ fn construction(index: &Index<'_>, entry: u32) -> Option<u8> {
         })
 }
 
-/// A two-byte XOR key that spells `stack` identifies the encoded string table.
-fn encoded_names(features: &[String]) -> Option<Vec<String>> {
+/// Finds the output field hidden by base64 encoding and a two-byte XOR key. A name that decodes to
+/// `stack` identifies the key. The output field is the remaining name after excluding `stack` and
+/// the record counter from the header. Builds with hex names encode only `stack`.
+fn encoded_result_field(features: &[String], header: &BTreeSet<String>) -> Option<String> {
     use base64::Engine;
     use base64::engine::general_purpose::STANDARD;
 
     let decoded: Vec<Vec<u8>> = features
         .iter()
-        .filter_map(|text| {
-            let decoded;
-            let text = if text.starts_with('\0') {
-                decoded = crate::listing::decode_string(text, "").ok()?;
-                &decoded
-            } else {
-                text
-            };
-            STANDARD.decode(text).ok()
-        })
-        .filter(|bytes| (3..=25).contains(&bytes.len()))
+        .filter_map(|text| STANDARD.decode(text).ok())
+        .filter(|bytes| (3..=12).contains(&bytes.len()))
         .collect();
-    let keys: BTreeSet<_> = decoded
+    let plain: BTreeSet<String> = features
         .iter()
-        .filter(|bytes| bytes.len() == 5)
-        .filter_map(|candidate| {
-            let key = [candidate[0] ^ b's', candidate[1] ^ b't'];
-            candidate
-                .iter()
-                .zip(b"stack")
-                .enumerate()
-                .all(|(index, (cipher, plain))| cipher ^ key[index % 2] == *plain)
-                .then_some(key)
-        })
-        .collect();
-    let key = candidates::exactly_one(keys, "stack string key").ok()?;
-    Some(
-        decoded
-            .iter()
-            .filter_map(|bytes| {
-                String::from_utf8(
-                    bytes
-                        .iter()
-                        .zip(key.iter().cycle())
-                        .map(|(byte, mask)| byte ^ mask)
-                        .collect(),
-                )
-                .ok()
-            })
-            .collect(),
-    )
-}
-
-/// Ignore ordinary base64-looking words and the record counter when identifying the output.
-fn encoded_result_field(names: &[String], header: &BTreeSet<String>) -> Option<String> {
-    let names = names.iter().filter(|name| {
-        crate::stage2::vocabulary::is_name(name)
-            && name.as_str() != "stack"
-            && !header.contains(*name)
-    });
-    candidates::at_most_one_distinct(names, "stack result field")
-        .ok()?
+        .filter(|name| vocabulary::is_hex_name(name))
         .cloned()
+        .collect();
+    for candidate in decoded.iter().filter(|bytes| bytes.len() == "stack".len()) {
+        let key = [candidate[0] ^ b's', candidate[1] ^ b't'];
+        let reveal = |bytes: &Vec<u8>| {
+            let revealed = bytes
+                .iter()
+                .zip(key.iter().cycle())
+                .map(|(byte, mask)| byte ^ mask);
+            String::from_utf8(revealed.collect()).ok()
+        };
+        if reveal(candidate).as_deref() != Some("stack") {
+            continue;
+        }
+        // Plain strings such as `this` can also be valid base64. Restrict candidates to the
+        // four-to-nine-character program names.
+        let revealed = decoded.iter().filter_map(reveal).filter(|name| {
+            (4..=9).contains(&name.len())
+                && name.starts_with(|first: char| first.is_ascii_alphabetic())
+                && name
+                    .chars()
+                    .all(|character| character.is_ascii_alphanumeric())
+        });
+        let names = revealed
+            .chain(plain.iter().cloned())
+            .filter(|name| name != "stack" && !header.contains(name));
+        if let Ok(result) = candidates::exactly_one(names, "stack result field") {
+            return Some(result);
+        }
+    }
+    None
 }
 
 /// Finds the output field in the string table by excluding the header's record-counter name,
@@ -158,23 +142,12 @@ fn result_field(features: &[String], header: &BTreeSet<String>) -> Option<String
 }
 
 pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
-    let encoded = encoded_names(probe.session_features);
-    let calls = calls(probe.index, probe.entry);
-    let result = result_field(probe.session_features, probe.header)
-        .or_else(|| encoded_result_field(encoded.as_ref()?, probe.header))
-        .or_else(|| {
-            calls.as_ref()?;
-            encoded.as_ref()?;
-            let fields = probe.writes.fields.iter().filter(|name| {
-                crate::stage2::vocabulary::is_name(name)
-                    && !probe.header.contains(*name)
-                    && !probe.wrapper.contains(*name)
-            });
-            candidates::exactly_one(fields, "plain stack result")
-                .ok()
-                .cloned()
-        })?;
-    Some(Fields { result, calls })
+    result_field(probe.session_features, probe.header)
+        .or_else(|| encoded_result_field(probe.session_features, probe.header))
+        .map(|result| Fields {
+            result,
+            calls: calls(probe.index, probe.entry),
+        })
 }
 
 #[cfg(test)]
@@ -215,38 +188,12 @@ mod tests {
             ],
         ] {
             let features = features.map(str::to_owned);
-            let names = encoded_names(&features).unwrap();
             assert_eq!(
-                encoded_result_field(&names, &header).as_deref(),
+                encoded_result_field(&features, &header).as_deref(),
                 Some("CJkad9"),
                 "{features:?}"
             );
-            assert!(encoded_result_field(&names, &BTreeSet::new()).is_none());
+            assert!(encoded_result_field(&features, &BTreeSet::new()).is_none());
         }
     }
-
-    #[test]
-    fn decodes_inline_tables_and_rejects_conflicting_keys() {
-        use base64::{Engine, engine::general_purpose::STANDARD};
-        let encode = |text: &str, key: [u8; 2]| {
-            STANDARD.encode(
-                text.bytes()
-                    .enumerate()
-                    .map(|(index, byte)| byte ^ key[index % 2])
-                    .collect::<Vec<_>>(),
-            )
-        };
-        let key = [17, 44];
-        let field = "_0123456789abcdef01234567";
-        let features = ["stack", field].map(|text| {
-            let encoded = encode(text, key);
-            format!("\0{}{encoded}padding", char::from(encoded.len() as u8))
-        });
-        let names = encoded_names(&features).unwrap();
-        assert_eq!(
-            encoded_result_field(&names, &BTreeSet::new()).as_deref(),
-            Some(field)
-        );
-        assert!(encoded_names(&[encode("stack", key), encode("stack", [18, 45])]).is_none());
-    }
 }

data/vendor/cfsolve/src/stage2/probes/websocket_echo.rs

@@ -126,13 +126,7 @@ impl Fields {
 ///   or before opening. The close status follows.
 /// - The platform option precedes the URL suffix `/w`.
 pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
-    let mut strings: Vec<String> = probe
-        .session_features
-        .iter()
-        .filter(|text| !matches!(text.as_str(), "Date" | "Math" | "length"))
-        .cloned()
-        .collect();
-    strings.dedup();
+    let strings = probe.session_features;
     let markers = ["WebSocket", "onopen", "onmessage", "onclose", "isFinite"];
     if !markers
         .iter()
@@ -147,21 +141,19 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
     };
     let before = |sequence: &[&str]| strings.get(find(sequence)?.checked_sub(1)?).cloned();
 
-    let start = find(&["readyState", "close"])? + 2;
-    let candidates: std::collections::BTreeSet<_> = strings[start..]
-        .windows(7)
-        .filter(|fields| {
-            fields[..5]
-                .iter()
-                .all(|name| probe.writes.fields.contains(name))
-                && fields[5..].iter().all(|name| {
-                    super::super::vocabulary::is_name(name) && !probe.writes.fields.contains(name)
-                })
-        })
-        .collect();
-    let [status, sent, received, opened, _error, complete, incomplete] =
-        crate::candidates::exactly_one(candidates, "WebSocket summary").ok()?
-    else {
+    // Builds that load builtins such as `length`, `Date` and `Math` in the header omit them
+    // here. Their summary follows `readyState` and `close` instead.
+    let (summary, statuses) = match find(&["length"]) {
+        Some(length) => (length.checked_sub(5)?, length + 1),
+        None => {
+            let summary = find(&["readyState", "close"])? + 2;
+            (summary, summary + 5)
+        }
+    };
+    let [status, sent, received, opened, _error] = strings.get(summary..summary + 5)? else {
+        return None;
+    };
+    let [complete, incomplete] = strings.get(statuses..statuses + 2)? else {
         return None;
     };
     let finite = find(&["isFinite"])?;
@@ -178,11 +170,12 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
         received: received.clone(),
         opened: opened.clone(),
         round_trips: before(&["JSON", "stringify"])?,
-        elapsed: before(&["String", "now"])?,
+        elapsed: before(&["String", "Date", "now"]).or_else(|| before(&["String", "now"]))?,
         statuses: Statuses {
             complete: complete.clone(),
             incomplete: incomplete.clone(),
-            timed_out: before(&["String", "round"])?,
+            timed_out: before(&["String", "Math", "round"])
+                .or_else(|| before(&["String", "round"]))?,
             failed_before_open: failed_before_open.clone(),
             failed_after_open: failed_after_open.clone(),
             closed: closed.clone(),
@@ -207,68 +200,6 @@ pub(crate) fn recognize(probe: &ProbeView<'_>) -> Option<Fields> {
 mod tests {
     use super::*;
 
-    #[test]
-    fn recovers_summary_after_string_conversion_reads() {
-        use crate::{
-            listing::Index,
-            stage2::{analysis::recognize::Strings, records::WriteOrder, vocabulary::Vocabulary},
-            vm::Listing,
-        };
-        use std::collections::BTreeSet;
-
-        let mut features: Vec<String> = "WebSocket readyState close Status1 Sent1 String Sent1 Recv1 String Recv1 Open1 Trips1 JSON stringify Elapsed1 String now Error1 Status1 Sent1 Recv1 Open1 Error1 Done1 Short1 send Time1 String round isFinite"
-            .split_whitespace().map(str::to_owned).collect();
-        features.push(String::new());
-        features.extend(
-            "After1 Before1 Closed1 Route1 /w onopen onmessage onclose"
-                .split_whitespace()
-                .map(str::to_owned),
-        );
-        let writes = WriteOrder {
-            fields: "Status1 Sent1 Recv1 Open1 Error1 Trips1 Elapsed1"
-                .split_whitespace()
-                .map(str::to_owned)
-                .collect(),
-            ..WriteOrder::default()
-        };
-        let listing = Listing::default();
-        let index = Index::new(&listing);
-        let vocabulary = Vocabulary::infer::<&[String]>(&[]);
-        let empty = BTreeSet::new();
-        let recover = |features: &[String]| {
-            recognize(&ProbeView {
-                index: &index,
-                vocabulary: &vocabulary,
-                position: 0,
-                header: &empty,
-                wrapper: &empty,
-                pool: "",
-                entry: 0,
-                session_features: features,
-                writes: &writes,
-                strings: Strings::new(features, &empty),
-            })
-        };
-        let fields = recover(&features).unwrap();
-        assert_eq!(fields.status, "Status1");
-        assert_eq!(fields.sent, "Sent1");
-        assert_eq!(fields.received, "Recv1");
-        assert_eq!(fields.opened, "Open1");
-        assert_eq!(fields.round_trips, "Trips1");
-        assert_eq!(fields.elapsed, "Elapsed1");
-        assert_eq!(fields.statuses.complete, "Done1");
-        assert_eq!(fields.statuses.incomplete, "Short1");
-        features.extend(
-            "Status1 Sent1 Recv1 Open1 Error1 Other1 Other2"
-                .split_whitespace()
-                .map(str::to_owned),
-        );
-        assert!(
-            recover(&features).is_none(),
-            "ambiguous summaries must not be guessed"
-        );
-    }
-
     fn fields() -> Fields {
         Fields {
             platform: "ppebL7".into(),

data/vendor/cfsolve/src/stage2/probes.rs

@@ -17,7 +17,6 @@ mod platform;
 pub(crate) mod private_token;
 pub(super) mod rects;
 pub(super) mod stack;
-pub(crate) mod stylesheets;
 pub(crate) mod websocket_echo;
 pub(crate) mod worker_fetch;
 pub(super) mod worker_navigator;

data/vendor/cfsolve/src/stage2/records.rs

@@ -124,13 +124,13 @@ pub struct Probe {
     pub operation: Option<Operation>,
     /// The strings the probe's collection function uses, in order.
     pub features: Vec<String>,
-    /// Collection strings including uses of constants held in registers.
-    #[serde(default)]
-    pub expanded_features: Vec<String>,
     /// Recovered write order used to arrange computed fields. Replayed answers retain the
     /// browser's recorded order.
     #[serde(default)]
     pub writes: WriteOrder,
+    /// Session literals recovered from result writes that cannot be replayed unchanged.
+    #[serde(default)]
+    pub replay_literals: JsObject,
 }
 
 impl Probe {
@@ -144,8 +144,6 @@ impl Probe {
 /// The order in which a probe's collection function writes its record's fields.
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct WriteOrder {
-    #[serde(default)]
-    pub internal: Vec<String>,
     /// Stored names in execution order: the synchronous body first, then its callbacks.
     pub fields: Vec<String>,
     /// Fields that only callbacks write after the probe has finished. They follow the clock
@@ -207,14 +205,7 @@ impl ProbePlan {
                 .iter()
                 .map(|probe| probe.features.as_slice())
                 .collect();
-            let mut vocabulary = Vocabulary::infer(&features);
-            let expanded: Vec<&[String]> = self
-                .probes
-                .iter()
-                .map(|probe| probe.expanded_features.as_slice())
-                .collect();
-            vocabulary.extend_expanded(&expanded);
-            vocabulary
+            Vocabulary::infer(&features)
         })
     }