cfsolve 0.1.1 → 0.1.2

data/vendor/cfsolve/src/vm/session.rs

@@ -2,8 +2,8 @@
 //! layout, instance fields, and opcode handlers. [`Session::constructed`] adds the constructor
 //! fields that depend on a program.
 //!
-//! Each handler run copies mutable values; see [`super::interpret`]. Only decrypted strings
-//! ([`Session::decrypted`]) and lazily compiled plans are cached between runs.
+//! Each handler run copies mutable values; see [`super::interpret`]. Only lazily compiled plans
+//! are cached between runs, besides the decrypted strings a loaded program caches.
 
 use std::cell::RefCell;
 use std::collections::BTreeSet;
@@ -17,7 +17,7 @@ use swc_core::ecma::ast::{
 };
 
 use super::extract::{self, RunMethod};
-use super::interpret::{self, Plans, Run, Spare};
+use super::interpret::{self, Branching, Frozen, Intrinsics, Plans, Run, Spare};
 use super::output::{Constant, Position, Term};
 use super::registers::Member;
 use super::value::Value;
@@ -33,6 +33,10 @@ pub(crate) struct Session<'ast> {
     /// Lazily prepared handlers and helpers, including unsupported functions.
     pub compiled: Plans<'ast>,
     pub spare: RefCell<Spare<'ast>>,
+    /// Session binding objects handler runs share instead of copying.
+    pub frozen: Frozen,
+    /// What exploration has learned about each handler's paths, by handler address.
+    pub branching: RefCell<HashMap<usize, Branching>>,
     pub bindings: HashMap<Atom, Value<'ast>>,
     /// Names interrupted setup statements may have written, with their errors. Reading them
     /// stops interpretation.
@@ -43,9 +47,9 @@ pub(crate) struct Session<'ast> {
     /// Initial register stacks created by the constructor for handler execution.
     pub initial: Vec<(u8, Value<'ast>)>,
     /// Function used to decrypt string records stored in registers.
-    pub record_decoder: Option<Atom>,
-    /// Decrypted strings cached by record position, length, and key.
-    pub decrypted: RefCell<HashMap<(u32, u32, u32), Value<'ast>>>,
+    pub record_decoder: Option<&'ast Function>,
+    /// Script functions run natively.
+    pub intrinsics: Intrinsics,
     /// The symbol the instance keeps its program under, if any.
     pub program_key: Option<Rc<()>>,
     /// Instance objects stored under the remaining symbols.
@@ -81,16 +85,22 @@ impl<'ast> Session<'ast> {
         let functions = extract::functions(&body.stmts);
         let run = extract::run_method(&functions, run)?;
         let handlers = extract::handlers(&functions, &run.dispatch)?;
+        let record_decoder =
+            extract::record_decoder(body).and_then(|name| functions.get(&name).copied());
         let mut session = Self {
             functions,
             handlers,
             entry: extract::entry(body)?,
-            record_decoder: extract::record_decoder(body),
+            record_decoder,
             ..Self::unevaluated(constructor)
         };
         (session.bindings, session.unavailable) = interpret::setup(&session, prelude, &body.stmts);
         let constructed = construct(&mut Run::method(&session), constructor);
-        (session.state, session.layout, session.initial) = state(&run, &constructed)?;
+        Recovered {
+            state: session.state,
+            layout: session.layout,
+            initial: session.initial,
+        } = state(&run, &constructed)?;
         session.symbol_fields = constructed.objects;
         session.program_key = match &constructed.programs[..] {
             [] => None,
@@ -98,6 +108,8 @@ impl<'ast> Session<'ast> {
             symbols => bail!("the VM constructor keys {} values by symbol", symbols.len()),
         };
         session.fields = concrete(constructed.fields);
+        session.intrinsics = interpret::intrinsics(&session);
+        session.frozen = Frozen::of(&session.bindings);
         Ok(session)
     }
 
@@ -107,6 +119,8 @@ impl<'ast> Session<'ast> {
             function_values: RefCell::default(),
             compiled: Default::default(),
             spare: RefCell::default(),
+            frozen: Frozen::default(),
+            branching: RefCell::default(),
             bindings: HashMap::default(),
             unavailable: HashMap::default(),
             layout: Layout::default(),
@@ -115,7 +129,7 @@ impl<'ast> Session<'ast> {
             symbol_fields: Vec::new(),
             initial: Vec::new(),
             record_decoder: None,
-            decrypted: RefCell::default(),
+            intrinsics: Intrinsics::default(),
             fields: HashMap::default(),
             constructor,
             handlers: HashMap::default(),
@@ -345,13 +359,17 @@ fn concrete<'a>(mut fields: HashMap<String, Value<'a>>) -> HashMap<String, Value
     fields
 }
 
+/// The handler state, register layout and initial register stacks [`state`] recovers.
+struct Recovered<'a> {
+    state: HashMap<String, Value<'a>>,
+    layout: Layout,
+    initial: Vec<(u8, Value<'a>)>,
+}
+
 /// Recovers state-field values and register layout. The constructor computes indices as
 /// `this.<mask> ^ <register>` with a random mask per run. Uses zero for the mask during
 /// analysis.
-fn state<'a>(
-    names: &RunMethod<'_>,
-    constructed: &Constructed<'a>,
-) -> Result<(HashMap<String, Value<'a>>, Layout, Vec<(u8, Value<'a>)>)> {
+fn state<'a>(names: &RunMethod<'_>, constructed: &Constructed<'a>) -> Result<Recovered<'a>> {
     let fields = &constructed.fields;
     let pc = constructed
         .pc
@@ -402,7 +420,11 @@ fn state<'a>(
         .map(|write| (write.register, write.value.clone()))
         .collect();
     state.extend(mask.map(|mask| (mask, Value::Number(0.0))));
-    Ok((state, layout, initial))
+    Ok(Recovered {
+        state,
+        layout,
+        initial,
+    })
 }
 
 /// Extracts the register and optional mask field from `this.<mask> ^ <register>` or a bare

data/vendor/cfsolve/src/vm/value.rs

@@ -215,6 +215,19 @@ impl<'ast> Value<'ast> {
         }
     }
 
+    /// Whether nothing a run does can change the value or its [`Value::expr`]: it is not a
+    /// container or a function with captured state.
+    pub(super) fn is_immutable(&self) -> bool {
+        match self {
+            Self::Array(_) | Self::Object(_) | Self::Set(_) | Self::Map(_) => false,
+            Self::Function(callable) => matches!(
+                &**callable,
+                Callable::Builtin(_) | Callable::Standard(_) | Callable::Script { scope: None, .. }
+            ),
+            _ => true,
+        }
+    }
+
     pub(super) fn is_symbolic(&self) -> bool {
         matches!(self, Self::Symbolic(_))
     }

data/vendor/cfsolve/src/vm.rs

@@ -18,6 +18,7 @@ mod extract;
 mod interpret;
 mod machine;
 mod output;
+mod packed_names;
 mod registers;
 mod session;
 mod value;

data/vendor/cfsolve/vendor/btls-sys/src/lib.rs

@@ -1,4 +1,7 @@
+// cfsolve patch: vendored code is not ours to lint; keep `cargo clippy` output to cfsolve.
 #![allow(
+    clippy::all,
+    unnecessary_transmutes,
     clippy::missing_safety_doc,
     clippy::redundant_static_lifetimes,
     clippy::too_many_arguments,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cfsolve
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Oliver Morgan
@@ -684,6 +684,9 @@ files:
 - vendor/cfsolve/LICENSE
 - vendor/cfsolve/README.md
 - vendor/cfsolve/examples/build_profile.rs
+- vendor/cfsolve/examples/capture_session.rs
+- vendor/cfsolve/examples/check_answers.rs
+- vendor/cfsolve/examples/compare_session.rs
 - vendor/cfsolve/examples/disassemble.rs
 - vendor/cfsolve/examples/fill_profile.rs
 - vendor/cfsolve/examples/probe_plan.rs
@@ -698,6 +701,8 @@ files:
 - vendor/cfsolve/profiles/safari-26-ios/challenge-page-answers.json
 - vendor/cfsolve/rust-toolchain.toml
 - vendor/cfsolve/rustfmt.toml
+- vendor/cfsolve/scripts/capture_cssom.mjs
+- vendor/cfsolve/scripts/serve_cssom.py
 - vendor/cfsolve/src/bin/capture-proxy/cli.rs
 - vendor/cfsolve/src/bin/capture-proxy/io.rs
 - vendor/cfsolve/src/bin/capture-proxy/main.rs
@@ -722,6 +727,7 @@ files:
 - vendor/cfsolve/src/challenge/codec.rs
 - vendor/cfsolve/src/challenge/expression.rs
 - vendor/cfsolve/src/challenge/installed.rs
+- vendor/cfsolve/src/challenge/installed/audit.rs
 - vendor/cfsolve/src/challenge/merge.rs
 - vendor/cfsolve/src/challenge/orchestrator.rs
 - vendor/cfsolve/src/challenge/payload.rs
@@ -789,7 +795,6 @@ files:
 - vendor/cfsolve/src/listing.rs
 - vendor/cfsolve/src/listing/fold.rs
 - vendor/cfsolve/src/listing/index.rs
-- vendor/cfsolve/src/listing/normalize.rs
 - vendor/cfsolve/src/listing/query.rs
 - vendor/cfsolve/src/listing/strings.rs
 - vendor/cfsolve/src/main.rs
@@ -816,8 +821,8 @@ files:
 - vendor/cfsolve/src/stage2/analysis/discovery.rs
 - vendor/cfsolve/src/stage2/analysis/envelope.rs
 - vendor/cfsolve/src/stage2/analysis/outcome.rs
-- vendor/cfsolve/src/stage2/analysis/outputs.rs
 - vendor/cfsolve/src/stage2/analysis/recognize.rs
+- vendor/cfsolve/src/stage2/audit_globals.rs
 - vendor/cfsolve/src/stage2/benchmark.rs
 - vendor/cfsolve/src/stage2/call_stack.rs
 - vendor/cfsolve/src/stage2/challenge_page.rs
@@ -851,18 +856,16 @@ files:
 - vendor/cfsolve/src/stage2/probes/private_token.rs
 - vendor/cfsolve/src/stage2/probes/rects.rs
 - vendor/cfsolve/src/stage2/probes/stack.rs
-- vendor/cfsolve/src/stage2/probes/stylesheets.rs
 - vendor/cfsolve/src/stage2/probes/websocket_echo.rs
 - vendor/cfsolve/src/stage2/probes/worker_fetch.rs
 - vendor/cfsolve/src/stage2/probes/worker_navigator.rs
 - vendor/cfsolve/src/stage2/proof.rs
 - vendor/cfsolve/src/stage2/records.rs
-- vendor/cfsolve/src/stage2/reference-expanded.json
 - vendor/cfsolve/src/stage2/reference.json
 - vendor/cfsolve/src/stage2/reference.rs
 - vendor/cfsolve/src/stage2/registry.rs
 - vendor/cfsolve/src/stage2/replay.rs
-- vendor/cfsolve/src/stage2/session_names.rs
+- vendor/cfsolve/src/stage2/stylesheets.rs
 - vendor/cfsolve/src/stage2/trace.rs
 - vendor/cfsolve/src/stage2/vocabulary.rs
 - vendor/cfsolve/src/stage2/worker_timing.rs
@@ -876,16 +879,20 @@ files:
 - vendor/cfsolve/src/vm/interpret/access.rs
 - vendor/cfsolve/src/vm/interpret/builtin.rs
 - vendor/cfsolve/src/vm/interpret/call.rs
+- vendor/cfsolve/src/vm/interpret/compile.rs
 - vendor/cfsolve/src/vm/interpret/copies.rs
 - vendor/cfsolve/src/vm/interpret/evaluate.rs
 - vendor/cfsolve/src/vm/interpret/evaluate/tests.rs
 - vendor/cfsolve/src/vm/interpret/explore.rs
+- vendor/cfsolve/src/vm/interpret/frozen.rs
+- vendor/cfsolve/src/vm/interpret/intrinsic.rs
 - vendor/cfsolve/src/vm/interpret/plan.rs
 - vendor/cfsolve/src/vm/interpret/run.rs
 - vendor/cfsolve/src/vm/interpret/semantics.rs
 - vendor/cfsolve/src/vm/interpret/setup.rs
 - vendor/cfsolve/src/vm/machine.rs
 - vendor/cfsolve/src/vm/output.rs
+- vendor/cfsolve/src/vm/packed_names.rs
 - vendor/cfsolve/src/vm/registers.rs
 - vendor/cfsolve/src/vm/session.rs
 - vendor/cfsolve/src/vm/value.rs

data/vendor/cfsolve/src/listing/normalize.rs

@@ -1,264 +0,0 @@
-//! Exposes constant expressions to structural readers without executing calls.
-
-use std::collections::BTreeSet;
-use std::convert::Infallible;
-use std::ops::ControlFlow;
-
-use super::Index;
-use super::fold::{self, Frame, Known};
-use crate::js::JsValue;
-use crate::vm::{Constant, Effect, Listing, Term, dataflow};
-
-fn evaluate(frame: &Frame, term: &Term) -> Option<Known> {
-    if let Some(known) = frame.resolve(term) {
-        return Some(known);
-    }
-    let value = fold::constant(frame, term);
-    if matches!(term, Term::Binary(_, _, _)) && matches!(value, Some(JsValue::String(_))) {
-        return None;
-    }
-    value.map(|value| {
-        if matches!(value, JsValue::String(_)) {
-            Known::Decoded(value)
-        } else {
-            Known::Literal(value)
-        }
-    })
-}
-
-/// Fold only values agreed on by every incoming path. Function and dispatcher
-/// entries start with common header facts, never another function's registers.
-pub(crate) fn constants(listing: &mut Listing) {
-    let setup = Frame::seeded(Index::new(listing).header());
-    let mut entries: BTreeSet<_> = listing
-        .functions
-        .iter()
-        .map(|entry| entry.pc)
-        .chain(listing.hidden.iter().map(|branch| branch.target.pc))
-        .collect();
-    for instruction in listing.instructions.values() {
-        for effect in instruction.effects() {
-            effect.visit_terms(&mut |term| {
-                if let Term::Array(frame) = term {
-                    entries.extend(crate::vm::catch_frame(frame).map(|handler| handler.pc));
-                }
-            });
-        }
-    }
-    let entries = entries.into_iter().map(|pc| (pc, setup.clone()));
-    let ControlFlow::<Infallible, _>::Continue(incoming) =
-        dataflow::forward(listing, entries, |pc, path, frame| {
-            frame.begin();
-            if !fold::feasible(path, |term| evaluate(frame, term)) {
-                return ControlFlow::Continue(false);
-            }
-            frame.follow(pc, &path.effects, evaluate, |_, _| {});
-            ControlFlow::Continue(true)
-        });
-    for (&pc, instruction) in &mut listing.instructions {
-        let Some(entry) = incoming.get(&pc) else {
-            continue;
-        };
-        for path in &mut instruction.paths {
-            let mut frame = entry.clone();
-            frame.begin();
-            for effect in &mut path.effects {
-                if let Effect::SetProperty { key, .. } = effect
-                    && let Some(Known::Decoded(JsValue::String(text))) = frame.resolve(key)
-                {
-                    **key = Term::Const(Constant::String(text));
-                }
-                let folded = match &*effect {
-                    Effect::Let(_, value) | Effect::Set(_, value) => evaluate(&frame, value),
-                    _ => None,
-                };
-                frame.follow(pc, std::slice::from_ref(effect), evaluate, |_, _| {});
-                if let Effect::Let(_, value) | Effect::Set(_, value) = effect {
-                    match folded {
-                        Some(Known::Decoded(JsValue::String(text))) => {
-                            *value = Term::Const(Constant::String(text))
-                        }
-                        Some(Known::Literal(JsValue::Number(number)))
-                            if matches!(value, Term::Call { .. } | Term::Binary(_, _, _)) =>
-                        {
-                            *value = Term::Const(Constant::Number(number))
-                        }
-                        _ => {}
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::vm::{Exit, Instruction, Path, Position};
-
-    fn text(value: &str) -> Term {
-        Term::Const(Constant::String(value.into()))
-    }
-
-    fn slice(register: u8) -> Term {
-        Term::Call {
-            callee: Box::new(Term::Get(
-                Box::new(Term::Reg(register)),
-                Box::new(text("slice")),
-            )),
-            this: Some(Box::new(Term::Reg(register))),
-            arguments: vec![
-                Term::Const(Constant::Number(2.0)),
-                Term::Const(Constant::Number(7.0)),
-            ],
-        }
-    }
-
-    fn path(effects: Vec<Effect>, exit: Exit) -> Path {
-        Path {
-            conditions: vec![],
-            effects,
-            exit,
-        }
-    }
-
-    fn program(paths: Vec<Vec<Path>>) -> Listing {
-        let mut listing = Listing::default();
-        listing.functions.push(Position::new(0, 0));
-        for (pc, paths) in (0..).zip(paths) {
-            listing.instructions.insert(
-                pc,
-                Instruction {
-                    pc,
-                    key: 0,
-                    opcode: 0,
-                    paths,
-                },
-            );
-        }
-        // End the common header before any branch-specific constants.
-        listing.instructions.get_mut(&0).unwrap().paths[0]
-            .effects
-            .insert(
-                0,
-                Effect::Set(
-                    255,
-                    Term::Closure {
-                        pc: 100,
-                        key: 0,
-                        parameters: vec![],
-                        arity: 0,
-                    },
-                ),
-            );
-        listing
-    }
-
-    #[test]
-    fn decoded_strings_survive_temporaries_and_instruction_boundaries() {
-        let mut listing = program(vec![
-            vec![path(
-                vec![Effect::Set(1, text("\0\u{5}freshpadding"))],
-                Exit::Next { pc: 1, key: 0 },
-            )],
-            vec![path(
-                vec![Effect::Let(0, slice(1)), Effect::Set(2, Term::Temp(0))],
-                Exit::Next { pc: 2, key: 0 },
-            )],
-            vec![path(vec![Effect::Set(3, Term::Reg(2))], Exit::Return)],
-        ]);
-        constants(&mut listing);
-        assert_eq!(
-            listing.instructions[&1].paths[0].effects[1],
-            Effect::Set(2, text("fresh"))
-        );
-        assert_eq!(
-            listing.instructions[&2].paths[0].effects[0],
-            Effect::Set(3, text("fresh"))
-        );
-    }
-
-    #[test]
-    fn disagreement_and_unknown_writes_leave_calls_unfolded() {
-        let mut listing = program(vec![
-            vec![path(vec![], Exit::Next { pc: 1, key: 0 })],
-            vec![
-                path(
-                    vec![Effect::Set(1, text("\0\u{5}first"))],
-                    Exit::Next { pc: 2, key: 0 },
-                ),
-                path(
-                    vec![Effect::Set(1, text("\0\u{5}other"))],
-                    Exit::Next { pc: 2, key: 0 },
-                ),
-            ],
-            vec![path(
-                vec![
-                    Effect::Set(2, slice(1)),
-                    Effect::Set(1, Term::Global("unknown".into())),
-                    Effect::Set(3, slice(1)),
-                ],
-                Exit::Return,
-            )],
-        ]);
-        let expected = listing.instructions[&2].paths[0].effects.clone();
-        constants(&mut listing);
-        assert_eq!(listing.instructions[&2].paths[0].effects, expected);
-    }
-
-    #[test]
-    fn ordinary_register_copies_and_string_assembly_keep_their_shape() {
-        use swc_core::ecma::ast::BinaryOp;
-        let mut listing = program(vec![vec![path(
-            vec![
-                Effect::Set(1, text("window")),
-                Effect::Set(2, Term::Reg(1)),
-                Effect::Set(
-                    3,
-                    Term::Binary(
-                        BinaryOp::Add,
-                        Box::new(text("prefix")),
-                        Box::new(text("suffix")),
-                    ),
-                ),
-            ],
-            Exit::Return,
-        )]]);
-        let expected = listing.instructions[&0].paths[0].effects.clone();
-        constants(&mut listing);
-        assert_eq!(listing.instructions[&0].paths[0].effects, expected);
-    }
-
-    #[test]
-    fn exception_handlers_start_with_header_facts_and_decode_their_own_strings() {
-        let frame = Term::Array(vec![
-            Term::Const(Constant::Number(1.0)),
-            Term::Const(Constant::Number(0.0)),
-            Term::Cells,
-            Term::Const(Constant::Number(0.0)),
-        ]);
-        let mut listing = program(vec![
-            vec![path(
-                vec![Effect::Set(2, text("\0\u{5}prior")), Effect::Let(0, frame)],
-                Exit::Return,
-            )],
-            vec![path(
-                vec![
-                    Effect::Set(3, slice(2)),
-                    Effect::Set(1, text("\0\u{5}catch")),
-                ],
-                Exit::Next { pc: 2, key: 0 },
-            )],
-            vec![path(vec![Effect::Set(4, slice(1))], Exit::Return)],
-        ]);
-        constants(&mut listing);
-        assert_eq!(
-            listing.instructions[&1].paths[0].effects[0],
-            Effect::Set(3, slice(2))
-        );
-        assert_eq!(
-            listing.instructions[&2].paths[0].effects[0],
-            Effect::Set(4, text("catch"))
-        );
-    }
-}