mustardscript 0.1.0

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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,108 @@
+//! 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

@@ -0,0 +1,93 @@
+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}"
+    );
+}