mustardscript 0.1.0 → 0.1.1

package/crates/mustard/src/runtime/serialization.rs

@@ -1,127 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::diagnostic::{DiagnosticKind, MustardError, MustardResult};
-
-use super::{
-    Runtime, api::ExecutionSnapshot, bytecode::BytecodeProgram,
-    validation::validate_bytecode_program,
-};
-
-const SERIAL_FORMAT_VERSION: u32 = 1;
-
-pub fn dump_program(program: &BytecodeProgram) -> MustardResult<Vec<u8>> {
-    bincode::serialize(&SerializedProgram {
-        version: SERIAL_FORMAT_VERSION,
-        program: program.clone(),
-    })
-    .map_err(|error| MustardError::Message {
-        kind: DiagnosticKind::Serialization,
-        message: error.to_string(),
-        span: None,
-        traceback: Vec::new(),
-    })
-}
-
-pub fn load_program(bytes: &[u8]) -> MustardResult<BytecodeProgram> {
-    let decoded: SerializedProgram =
-        bincode::deserialize(bytes).map_err(|error| MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: error.to_string(),
-            span: None,
-            traceback: Vec::new(),
-        })?;
-    if decoded.version != SERIAL_FORMAT_VERSION {
-        return Err(MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: format!(
-                "serialized program version mismatch: expected {}, got {}",
-                SERIAL_FORMAT_VERSION, decoded.version
-            ),
-            span: None,
-            traceback: Vec::new(),
-        });
-    }
-    validate_bytecode_program(&decoded.program)?;
-    Ok(decoded.program)
-}
-
-pub fn dump_snapshot(snapshot: &ExecutionSnapshot) -> MustardResult<Vec<u8>> {
-    bincode::serialize(&SerializedSnapshot {
-        version: SERIAL_FORMAT_VERSION,
-        runtime: snapshot.runtime.clone(),
-    })
-    .map_err(|error| MustardError::Message {
-        kind: DiagnosticKind::Serialization,
-        message: error.to_string(),
-        span: None,
-        traceback: Vec::new(),
-    })
-}
-
-pub fn load_snapshot(bytes: &[u8]) -> MustardResult<ExecutionSnapshot> {
-    let decoded: SerializedSnapshot =
-        bincode::deserialize(bytes).map_err(|error| MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: error.to_string(),
-            span: None,
-            traceback: Vec::new(),
-        })?;
-    if decoded.version != SERIAL_FORMAT_VERSION {
-        return Err(MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: format!(
-                "serialized snapshot version mismatch: expected {}, got {}",
-                SERIAL_FORMAT_VERSION, decoded.version
-            ),
-            span: None,
-            traceback: Vec::new(),
-        });
-    }
-    ExecutionSnapshot::restore_loaded_runtime(decoded.runtime)
-}
-
-pub fn canonical_snapshot_auth_bytes(bytes: &[u8]) -> MustardResult<Vec<u8>> {
-    let decoded: SerializedSnapshot =
-        bincode::deserialize(bytes).map_err(|error| MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: error.to_string(),
-            span: None,
-            traceback: Vec::new(),
-        })?;
-    if decoded.version != SERIAL_FORMAT_VERSION {
-        return Err(MustardError::Message {
-            kind: DiagnosticKind::Serialization,
-            message: format!(
-                "serialized snapshot version mismatch: expected {}, got {}",
-                SERIAL_FORMAT_VERSION, decoded.version
-            ),
-            span: None,
-            traceback: Vec::new(),
-        });
-    }
-
-    let mut snapshot = ExecutionSnapshot::restore_loaded_runtime(decoded.runtime)?;
-    snapshot.runtime.snapshot_nonce = 0;
-    bincode::serialize(&SerializedSnapshot {
-        version: SERIAL_FORMAT_VERSION,
-        runtime: snapshot.runtime,
-    })
-    .map_err(|error| MustardError::Message {
-        kind: DiagnosticKind::Serialization,
-        message: error.to_string(),
-        span: None,
-        traceback: Vec::new(),
-    })
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct SerializedProgram {
-    version: u32,
-    program: BytecodeProgram,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct SerializedSnapshot {
-    version: u32,
-    runtime: Runtime,
-}

package/crates/mustard/src/runtime/shared.rs

@@ -1,108 +0,0 @@
-//! Shared runtime helpers used across sibling runtime modules.
-
-use std::sync::atomic::{AtomicU64, Ordering};
-
-use super::*;
-
-pub(super) struct CallbackCallOptions<'a> {
-    pub(super) non_callable_message: &'a str,
-    pub(super) host_suspension_message: &'a str,
-    pub(super) unsettled_message: &'a str,
-    pub(super) allow_host_suspension: bool,
-    pub(super) allow_pending_promise_result: bool,
-}
-
-pub(super) fn limit_error(message: impl Into<String>) -> MustardError {
-    MustardError::Message {
-        kind: DiagnosticKind::Limit,
-        message: message.into(),
-        span: None,
-        traceback: Vec::new(),
-    }
-}
-
-pub(super) fn serialization_error(message: impl Into<String>) -> MustardError {
-    MustardError::Message {
-        kind: DiagnosticKind::Serialization,
-        message: message.into(),
-        span: None,
-        traceback: Vec::new(),
-    }
-}
-
-pub(super) fn next_snapshot_nonce() -> u64 {
-    static NEXT_SNAPSHOT_NONCE: AtomicU64 = AtomicU64::new(1);
-    NEXT_SNAPSHOT_NONCE.fetch_add(1, Ordering::Relaxed)
-}
-
-pub(super) fn pop_many(stack: &mut Vec<Value>, count: usize) -> MustardResult<Vec<Value>> {
-    if stack.len() < count {
-        return Err(MustardError::runtime("stack underflow"));
-    }
-    let start = stack.len() - count;
-    Ok(stack.drain(start..).collect())
-}
-
-pub(super) fn resume_behavior_for_capability(capability: &str) -> ResumeBehavior {
-    match capability {
-        "console.log" | "console.warn" | "console.error" => ResumeBehavior::Undefined,
-        _ => ResumeBehavior::Value,
-    }
-}
-
-pub(super) fn is_truthy(value: &Value) -> bool {
-    match value {
-        Value::Undefined | Value::Null => false,
-        Value::Bool(value) => *value,
-        Value::Number(value) => *value != 0.0 && !value.is_nan(),
-        Value::BigInt(value) => value != &0.into(),
-        Value::String(value) => !value.is_empty(),
-        Value::Object(_)
-        | Value::Array(_)
-        | Value::Map(_)
-        | Value::Set(_)
-        | Value::Iterator(_)
-        | Value::Promise(_)
-        | Value::Closure(_)
-        | Value::BuiltinFunction(_)
-        | Value::HostFunction(_) => true,
-    }
-}
-
-pub(super) fn is_callable(value: &Value) -> bool {
-    matches!(
-        value,
-        Value::Closure(_) | Value::BuiltinFunction(_) | Value::HostFunction(_)
-    )
-}
-
-pub(super) fn strict_equal(left: &Value, right: &Value) -> bool {
-    match (left, right) {
-        (Value::Undefined, Value::Undefined) => true,
-        (Value::Null, Value::Null) => true,
-        (Value::Bool(left), Value::Bool(right)) => left == right,
-        (Value::Number(left), Value::Number(right)) => left == right,
-        (Value::BigInt(left), Value::BigInt(right)) => left == right,
-        (Value::String(left), Value::String(right)) => left == right,
-        (Value::Object(left), Value::Object(right)) => left == right,
-        (Value::Array(left), Value::Array(right)) => left == right,
-        (Value::Map(left), Value::Map(right)) => left == right,
-        (Value::Set(left), Value::Set(right)) => left == right,
-        (Value::Iterator(left), Value::Iterator(right)) => left == right,
-        (Value::Promise(left), Value::Promise(right)) => left == right,
-        (Value::Closure(left), Value::Closure(right)) => left == right,
-        (Value::BuiltinFunction(left), Value::BuiltinFunction(right)) => left == right,
-        (Value::HostFunction(left), Value::HostFunction(right)) => left == right,
-        _ => false,
-    }
-}
-
-pub(super) fn same_value_zero(left: &Value, right: &Value) -> bool {
-    match (left, right) {
-        (Value::Number(left), Value::Number(right)) => {
-            (left == right) || (left.is_nan() && right.is_nan())
-        }
-        (Value::BigInt(left), Value::BigInt(right)) => left == right,
-        _ => strict_equal(left, right),
-    }
-}

package/crates/mustard/src/runtime/snapshot_validation_tests.rs

@@ -1,93 +0,0 @@
-use crate::{RuntimeLimits, compile};
-
-use super::*;
-
-fn suspend_async_host_wait(source: &str) -> Suspension {
-    let program = compile(source).expect("source should compile");
-    match start(
-        &program,
-        ExecutionOptions {
-            capabilities: vec!["fetch_data".to_string()],
-            limits: RuntimeLimits::default(),
-            cancellation_token: None,
-            ..ExecutionOptions::default()
-        },
-    )
-    .expect("execution should suspend")
-    {
-        ExecutionStep::Suspended(suspension) => *suspension,
-        other => panic!("expected suspension, got {other:?}"),
-    }
-}
-
-#[test]
-fn rejects_invalid_async_continuation_frame_state() {
-    let mut suspension = suspend_async_host_wait(
-        r#"
-        async function main() {
-          const value = await fetch_data(1);
-          return value + 2;
-        }
-        main();
-        "#,
-    );
-
-    let continuation = suspension
-        .snapshot
-        .runtime
-        .promises
-        .values_mut()
-        .find_map(|promise| promise.awaiters.first_mut())
-        .expect("awaiting async promise continuation should exist");
-    continuation.frames[0].ip = 999;
-
-    let bytes = dump_snapshot(&suspension.snapshot).expect("snapshot should serialize");
-    let error =
-        load_snapshot(&bytes).expect_err("invalid async continuation should fail validation");
-    assert!(
-        error
-            .to_string()
-            .contains("frame instruction pointer 999 is out of range"),
-        "unexpected error: {error}"
-    );
-}
-
-#[test]
-fn rejects_invalid_microtask_frame_state() {
-    let mut suspension = suspend_async_host_wait(
-        r#"
-        async function main() {
-          const value = await fetch_data(1);
-          return value + 2;
-        }
-        main();
-        "#,
-    );
-
-    let mut continuation = suspension
-        .snapshot
-        .runtime
-        .promises
-        .values()
-        .find_map(|promise| promise.awaiters.first().cloned())
-        .expect("awaiting async promise continuation should exist");
-    continuation.frames[0].ip = 999;
-    suspension
-        .snapshot
-        .runtime
-        .microtasks
-        .push_back(MicrotaskJob::ResumeAsync {
-            continuation,
-            outcome: PromiseOutcome::Fulfilled(Value::Number(1.0)),
-        });
-
-    let bytes = dump_snapshot(&suspension.snapshot).expect("snapshot should serialize");
-    let error =
-        load_snapshot(&bytes).expect_err("invalid microtask continuation should fail validation");
-    assert!(
-        error
-            .to_string()
-            .contains("frame instruction pointer 999 is out of range"),
-        "unexpected error: {error}"
-    );
-}