@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_core/src/json.rs

@@ -0,0 +1,430 @@
+//! JSON parsing and stringification for Tish values.
+
+use crate::{Value, VmRef};
+use std::sync::Arc;
+
+/// Parse JSON string into a Value.
+pub fn json_parse(json: &str) -> Result<Value, String> {
+    let json = json.trim();
+    if json.is_empty() {
+        return Err("SyntaxError: Unexpected end of JSON input".to_string());
+    }
+    let (value, rest) = parse_value(json, 0)?;
+    if !rest.trim().is_empty() {
+        return Err("SyntaxError: Unexpected token at end of JSON".to_string());
+    }
+    Ok(value)
+}
+
+/// Stringify a Value to JSON.
+///
+/// Single-buffer write strategy: all nested values append into one
+/// `String` via [`json_stringify_into`], so we never allocate a transient
+/// per-node `String` only to copy + drop it on the way back up. For a
+/// 20-row TFB `/queries` response (~40 numbers, 2 keys × 20 = ~80 string
+/// ops) that saves dozens of small allocations per request.
+pub fn json_stringify(value: &Value) -> String {
+    // 256 B is enough for typical TFB responses (`/db` is 31 B,
+    // `/queries=20` is ~700 B). Larger payloads reallocate normally.
+    let mut buf = String::with_capacity(256);
+    json_stringify_into(&mut buf, value);
+    buf
+}
+
+/// Append a JSON-stringified `value` to `buf`. Used by JSON.stringify for
+/// the recursive case so we don't pay for an intermediate `String` per
+/// node.
+pub fn json_stringify_into(buf: &mut String, value: &Value) {
+    match value {
+        Value::Null => buf.push_str("null"),
+        Value::Bool(true) => buf.push_str("true"),
+        Value::Bool(false) => buf.push_str("false"),
+        Value::Number(n) => {
+            if n.is_nan() || n.is_infinite() {
+                buf.push_str("null");
+            } else {
+                // `write!` avoids the heap allocation that `to_string`
+                // produces. The f64 → decimal formatter is the same
+                // either way (`std::fmt::Display`).
+                use std::fmt::Write;
+                let _ = write!(buf, "{}", n);
+            }
+        }
+        Value::String(s) => {
+            buf.push('"');
+            escape_json_string_into(buf, s);
+            buf.push('"');
+        }
+        Value::Array(arr) => {
+            let borrowed = arr.borrow();
+            buf.push('[');
+            for (i, item) in borrowed.iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
+                }
+                json_stringify_into(buf, item);
+            }
+            buf.push(']');
+        }
+        Value::NumberArray(arr) => {
+            let borrowed = arr.borrow();
+            buf.push('[');
+            use std::fmt::Write;
+            for (i, n) in borrowed.iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
+                }
+                if n.is_nan() || n.is_infinite() {
+                    buf.push_str("null");
+                } else {
+                    let _ = write!(buf, "{}", n);
+                }
+            }
+            buf.push(']');
+        }
+        Value::Object(obj) => {
+            let borrowed = obj.borrow();
+            // Iterate in insertion order (PropMap preserves it) — matches JS/Node
+            // and `Object.keys`. No intermediate key Vec, no sort: one fewer
+            // allocation per object on the JSON hot path (e.g. TFB /json, /db).
+            buf.push('{');
+            for (i, (key, val)) in borrowed.strings.iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
+                }
+                buf.push('"');
+                escape_json_string_into(buf, key);
+                buf.push_str("\":");
+                json_stringify_into(buf, val);
+            }
+            buf.push('}');
+        }
+        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) | Value::Symbol(_) => {
+            buf.push_str("null");
+        }
+        #[cfg(feature = "regex")]
+        Value::RegExp(_) => buf.push_str("null"),
+    }
+}
+
+/// Append an escaped JSON string body (without the surrounding quotes)
+/// to `buf`. Optimised for the common case where the input is ASCII and
+/// contains no characters that need escaping — we fast-pass the bytes
+/// straight through, only falling into the per-char path on a hit.
+fn escape_json_string_into(buf: &mut String, s: &str) {
+    let bytes = s.as_bytes();
+    let mut start = 0usize;
+    for (i, &b) in bytes.iter().enumerate() {
+        // Anything < 0x20 is a JSON control char that must be escaped;
+        // 0x22 (`"`) and 0x5C (`\`) also need an explicit escape; bytes
+        // ≥ 0x80 are the start of a multi-byte UTF-8 sequence, which is
+        // valid JSON as-is.
+        if b < 0x20 || b == b'"' || b == b'\\' {
+            // Flush the run of clean bytes before this one in one push.
+            if start < i {
+                // SAFETY: `s` is `&str`, every byte in `start..i` was a
+                // single-byte ASCII char (we only stop on ASCII triggers
+                // below 0x80), so the slice is a valid `&str`.
+                buf.push_str(&s[start..i]);
+            }
+            match b {
+                b'"' => buf.push_str("\\\""),
+                b'\\' => buf.push_str("\\\\"),
+                b'\n' => buf.push_str("\\n"),
+                b'\r' => buf.push_str("\\r"),
+                b'\t' => buf.push_str("\\t"),
+                b'\x08' => buf.push_str("\\b"),
+                b'\x0c' => buf.push_str("\\f"),
+                _ => {
+                    use std::fmt::Write;
+                    let _ = write!(buf, "\\u{:04x}", b as u32);
+                }
+            }
+            start = i + 1;
+        }
+    }
+    if start < bytes.len() {
+        buf.push_str(&s[start..]);
+    }
+}
+
+/// Max nesting depth for `JSON.parse`. Bounds recursion so deeply-nested untrusted
+/// input errors instead of overflowing the stack — a Rust stack overflow aborts the
+/// whole process (uncatchable, SIGABRT). 128 matches serde_json's default limit.
+const MAX_JSON_DEPTH: usize = 128;
+
+fn parse_value(input: &str, depth: usize) -> Result<(Value, &str), String> {
+    let input = input.trim_start();
+    if input.is_empty() {
+        return Err("Unexpected end of JSON input".to_string());
+    }
+
+    match input.chars().next().unwrap() {
+        'n' => parse_null(input),
+        't' | 'f' => parse_bool(input),
+        '"' => parse_string(input),
+        '[' => parse_array(input, depth),
+        '{' => parse_object(input, depth),
+        c if c == '-' || c.is_ascii_digit() => parse_number(input),
+        c => Err(format!("Unexpected character '{}' in JSON", c)),
+    }
+}
+
+fn parse_null(input: &str) -> Result<(Value, &str), String> {
+    if let Some(rest) = input.strip_prefix("null") {
+        Ok((Value::Null, rest))
+    } else {
+        Err("Expected 'null'".to_string())
+    }
+}
+
+fn parse_bool(input: &str) -> Result<(Value, &str), String> {
+    if let Some(rest) = input.strip_prefix("true") {
+        Ok((Value::Bool(true), rest))
+    } else if let Some(rest) = input.strip_prefix("false") {
+        Ok((Value::Bool(false), rest))
+    } else {
+        Err("Expected 'true' or 'false'".to_string())
+    }
+}
+
+fn parse_string(input: &str) -> Result<(Value, &str), String> {
+    let input = &input[1..]; // skip opening quote
+    let mut result = String::new();
+    let mut chars = input.chars().peekable();
+    let mut byte_count = 0;
+
+    loop {
+        match chars.next() {
+            None => return Err("Unterminated string".to_string()),
+            Some('"') => {
+                byte_count += 1;
+                break;
+            }
+            Some('\\') => {
+                byte_count += 1;
+                match chars.next() {
+                    Some('n') => {
+                        result.push('\n');
+                        byte_count += 1;
+                    }
+                    Some('r') => {
+                        result.push('\r');
+                        byte_count += 1;
+                    }
+                    Some('t') => {
+                        result.push('\t');
+                        byte_count += 1;
+                    }
+                    Some('\\') => {
+                        result.push('\\');
+                        byte_count += 1;
+                    }
+                    Some('"') => {
+                        result.push('"');
+                        byte_count += 1;
+                    }
+                    Some('/') => {
+                        result.push('/');
+                        byte_count += 1;
+                    }
+                    Some('u') => {
+                        byte_count += 1;
+                        let mut hex = String::new();
+                        for _ in 0..4 {
+                            if let Some(c) = chars.next() {
+                                hex.push(c);
+                                byte_count += c.len_utf8();
+                            }
+                        }
+                        if let Ok(n) = u32::from_str_radix(&hex, 16) {
+                            if let Some(c) = char::from_u32(n) {
+                                result.push(c);
+                            }
+                        }
+                    }
+                    Some(c) => {
+                        result.push(c);
+                        byte_count += c.len_utf8();
+                    }
+                    None => return Err("Unterminated escape sequence".to_string()),
+                }
+            }
+            Some(c) => {
+                result.push(c);
+                byte_count += c.len_utf8();
+            }
+        }
+    }
+
+    Ok((Value::String(result.into()), &input[byte_count..]))
+}
+
+fn parse_number(input: &str) -> Result<(Value, &str), String> {
+    // Byte scan (all number chars are ASCII) — O(token), not O(remaining input).
+    // The old `input.chars().collect::<Vec<char>>()` per number made parsing an
+    // N-number array O(N^2): a CPU-exhaustion DoS on untrusted JSON.
+    let bytes = input.as_bytes();
+    let mut end = 0;
+
+    if bytes.first() == Some(&b'-') {
+        end += 1;
+    }
+    while end < bytes.len() && bytes[end].is_ascii_digit() {
+        end += 1;
+    }
+    if bytes.get(end) == Some(&b'.') {
+        end += 1;
+        while end < bytes.len() && bytes[end].is_ascii_digit() {
+            end += 1;
+        }
+    }
+    if matches!(bytes.get(end), Some(&b'e') | Some(&b'E')) {
+        end += 1;
+        if matches!(bytes.get(end), Some(&b'+') | Some(&b'-')) {
+            end += 1;
+        }
+        while end < bytes.len() && bytes[end].is_ascii_digit() {
+            end += 1;
+        }
+    }
+
+    // `end` lands on an ASCII boundary, so slicing `input` by byte index is valid.
+    let num_str = &input[..end];
+    num_str
+        .parse::<f64>()
+        .map(|n| (Value::Number(n), &input[end..]))
+        .map_err(|_| format!("Invalid number: {}", num_str))
+}
+
+fn parse_array(input: &str, depth: usize) -> Result<(Value, &str), String> {
+    if depth >= MAX_JSON_DEPTH {
+        return Err("JSON nesting too deep".to_string());
+    }
+    let mut input = &input[1..]; // skip '['
+    let mut items = Vec::new();
+
+    input = input.trim_start();
+    if let Some(rest) = input.strip_prefix(']') {
+        return Ok((Value::Array(VmRef::new(items)), rest));
+    }
+
+    loop {
+        let (value, rest) = parse_value(input, depth + 1)?;
+        items.push(value);
+        input = rest.trim_start();
+
+        match input.chars().next() {
+            Some(',') => input = &input[1..],
+            Some(']') => return Ok((Value::Array(VmRef::new(items)), &input[1..])),
+            _ => return Err("Expected ',' or ']' in array".to_string()),
+        }
+    }
+}
+
+fn parse_object(input: &str, depth: usize) -> Result<(Value, &str), String> {
+    if depth >= MAX_JSON_DEPTH {
+        return Err("JSON nesting too deep".to_string());
+    }
+    let mut input = &input[1..]; // skip '{'
+    let mut map = crate::ObjectMap::default();
+
+    input = input.trim_start();
+    if let Some(rest) = input.strip_prefix('}') {
+        return Ok((
+            Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+            rest,
+        ));
+    }
+
+    loop {
+        input = input.trim_start();
+        if !input.starts_with('"') {
+            return Err("Expected string key in object".to_string());
+        }
+
+        let (key_val, rest) = parse_string(input)?;
+        let key: Arc<str> = match key_val {
+            Value::String(s) => Arc::from(s.as_str()),
+            _ => unreachable!(),
+        };
+
+        input = rest.trim_start();
+        if !input.starts_with(':') {
+            return Err("Expected ':' after key in object".to_string());
+        }
+        input = &input[1..];
+
+        let (value, rest) = parse_value(input, depth + 1)?;
+        map.insert(key, value);
+        input = rest.trim_start();
+
+        match input.chars().next() {
+            Some(',') => input = &input[1..],
+            Some('}') => {
+                return Ok((
+                    Value::Object(VmRef::new(crate::ObjectData::from_strings(map))),
+                    &input[1..],
+                ));
+            }
+            _ => return Err("Expected ',' or '}' in object".to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_primitives() {
+        assert!(matches!(json_parse("null").unwrap(), Value::Null));
+        assert!(matches!(json_parse("true").unwrap(), Value::Bool(true)));
+        assert!(matches!(json_parse("false").unwrap(), Value::Bool(false)));
+        assert!(matches!(json_parse("42").unwrap(), Value::Number(n) if n == 42.0));
+        assert!(
+            matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_str() == "hello")
+        );
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        let original = "{\"name\":\"test\",\"count\":42}";
+        let value = json_parse(original).unwrap();
+        let stringified = json_stringify(&value);
+        let reparsed = json_parse(&stringified).unwrap();
+
+        match (&value, &reparsed) {
+            (Value::Object(a), Value::Object(b)) => {
+                assert_eq!(a.borrow().len_entries(), b.borrow().len_entries());
+            }
+            _ => panic!("Expected objects"),
+        }
+    }
+
+    #[test]
+    fn deeply_nested_json_is_rejected_not_crash() {
+        // C1 regression: deeply-nested untrusted input must error at the depth limit,
+        // never recurse deep enough to overflow the stack (an uncatchable SIGABRT that
+        // would crash the whole process / HTTP worker).
+        let under = format!("{}{}", "[".repeat(100), "]".repeat(100));
+        assert!(json_parse(&under).is_ok(), "100 < limit should parse");
+        let over = format!("{}{}", "[".repeat(200), "]".repeat(200));
+        assert!(json_parse(&over).is_err(), "200 > limit must error");
+        // Pathological depth must still just error (fast), not overflow the stack.
+        let huge = format!("{}{}", "[".repeat(200_000), "]".repeat(200_000));
+        assert!(json_parse(&huge).is_err(), "huge depth must error, not crash");
+    }
+
+    #[test]
+    fn large_number_array_parses_correctly() {
+        // C2 regression: parse_number byte-scans (O(token)); the old chars().collect()
+        // over the whole remaining input made an N-number array O(N^2) — a CPU DoS.
+        let n = 50_000;
+        let body = format!("[{}]", vec!["7"; n].join(","));
+        match json_parse(&body).unwrap() {
+            Value::Array(arr) => assert_eq!(arr.borrow().len(), n),
+            _ => panic!("expected array"),
+        }
+    }
+}

package/crates/tish_core/src/lib.rs

@@ -0,0 +1,20 @@
+//! Tish Core - Shared types and utilities for the Tish language.
+//!
+//! This crate provides the unified Value type and utilities used by both
+//! the interpreter (tishlang_eval) and compiled runtime (tishlang_runtime).
+
+mod console_style;
+mod json;
+mod macros;
+mod shape;
+mod uri;
+mod value;
+mod vmref;
+
+pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
+pub use json::{json_parse, json_stringify, json_stringify_into};
+pub use shape::{ShapeId, DICT_SHAPE, EMPTY_SHAPE};
+pub use uri::{percent_decode, percent_encode};
+pub use arcstr::ArcStr;
+pub use value::*;
+pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};

package/crates/tish_core/src/macros.rs

@@ -0,0 +1,36 @@
+//! Macros for building Tish native modules.
+
+/// Build a Tish module object from method name => function pairs.
+///
+/// Each function must have signature `fn(&[Value]) -> Value` (or equivalent closure).
+/// Pass either a `fn` pointer or a closure; the macro wraps them in `Rc::new`.
+///
+/// # Example
+///
+/// ```ignore
+/// use tishlang_core::{tish_module, Value};
+///
+/// pub fn my_object() -> Value {
+///     tish_module! {
+///         "run" => |args: &[Value]| {
+///             // ...
+///             Value::Null
+///         },
+///         "read_csv" => my_read_csv_fn,
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! tish_module {
+    ($($name:expr => $fn:expr),* $(,)?) => {{
+        use std::sync::Arc;
+        use $crate::{ObjectMap, Value};
+        let mut map = ObjectMap::default();
+        $(
+            // `Value::native` picks the right Rc / Arc wrapper depending on
+            // whether the `send-values` feature is enabled upstream.
+            map.insert(Arc::from($name), Value::native($fn));
+        )*
+        Value::object(map)
+    }};
+}

package/crates/tish_core/src/shape.rs

@@ -0,0 +1,85 @@
+//! Hidden-class "shapes" for objects — the JavaScriptCore *Structure* idea.
+//!
+//! A [`ShapeId`] is an interned identity for an object's **ordered string-key set**. Two objects
+//! built by inserting the same keys in the same order share a `ShapeId`. This lets the bytecode VM's
+//! inline caches (see `tish_bytecode::Chunk::inline_caches`) compare a single `u32` instead of hashing
+//! a property name — on a shape hit the property is at a fixed slot index, so access is a direct load.
+//!
+//! Identity is **path-dependent** (like JSC): `{x,y}` and `{y,x}` are *different* shapes, because the
+//! slot index of `x` differs — which is exactly what makes the cached `(shape, index)` correct.
+//!
+//! Phase 1a uses shapes only as opaque identities (the property→index lookup still goes through
+//! `PropMap` on a cache miss). Phase 1b will attach the ordered key list to each shape so objects can
+//! drop per-object key storage entirely (the butterfly representation).
+
+use std::collections::HashMap;
+use std::sync::{Arc, OnceLock, RwLock};
+
+/// Identity of an object's ordered key-set.
+pub type ShapeId = u32;
+
+/// The shape of a freshly-created empty object (`{}`).
+pub const EMPTY_SHAPE: ShapeId = 0;
+
+/// Sentinel for objects that have opted out of shape tracking (after a property *delete*, or when the
+/// shape space is exhausted). Such objects never match an inline cache → always the slow path. Chosen
+/// as `u32::MAX` so it can never collide with a real, sequentially-assigned id.
+pub const DICT_SHAPE: ShapeId = u32::MAX;
+
+/// One node in the structure-transition tree: from this shape, adding a given key yields a child shape.
+#[derive(Default)]
+struct ShapeNode {
+    transitions: HashMap<Arc<str>, ShapeId>,
+}
+
+struct Registry {
+    nodes: Vec<ShapeNode>,
+}
+
+fn registry() -> &'static RwLock<Registry> {
+    static REG: OnceLock<RwLock<Registry>> = OnceLock::new();
+    REG.get_or_init(|| {
+        RwLock::new(Registry {
+            // Index 0 == EMPTY_SHAPE.
+            nodes: vec![ShapeNode::default()],
+        })
+    })
+}
+
+/// The shape reached by adding a **new** key `key` to an object currently of shape `from`.
+///
+/// Cached: the first object to take a given (shape, key) edge creates the child shape; every later
+/// object with the same construction path reuses it. Cheap on the hot path (a read-lock + one hashmap
+/// lookup once the edge exists). A `DICT_SHAPE` input (or shape-space exhaustion) stays `DICT_SHAPE`.
+pub fn transition(from: ShapeId, key: &Arc<str>) -> ShapeId {
+    if from == DICT_SHAPE {
+        return DICT_SHAPE;
+    }
+    // Fast path: the edge already exists (the common case after the first object of this shape).
+    {
+        let reg = registry().read().unwrap();
+        match reg.nodes.get(from as usize) {
+            Some(node) => {
+                if let Some(&next) = node.transitions.get(key.as_ref()) {
+                    return next;
+                }
+            }
+            None => return DICT_SHAPE, // out of range — should not happen; degrade safely
+        }
+    }
+    // Slow path: create the child shape and cache the edge.
+    let mut reg = registry().write().unwrap();
+    // Re-check under the write lock (another thread may have created it meanwhile).
+    if let Some(&next) = reg.nodes[from as usize].transitions.get(key.as_ref()) {
+        return next;
+    }
+    let new_id = reg.nodes.len();
+    if new_id >= DICT_SHAPE as usize {
+        return DICT_SHAPE; // ran out of shape ids — extremely unlikely; degrade to dictionary mode
+    }
+    reg.nodes.push(ShapeNode::default());
+    reg.nodes[from as usize]
+        .transitions
+        .insert(Arc::clone(key), new_id as ShapeId);
+    new_id as ShapeId
+}

package/crates/tish_core/src/uri.rs

@@ -0,0 +1,118 @@
+//! URI encoding/decoding utilities.
+
+/// Percent-decode a string (for decodeURI).
+/// Does NOT decode reserved URI characters: ; / ? : @ & = + $ , #
+/// These are characters that encodeURI does not encode, so decodeURI won't decode them.
+pub fn percent_decode(input: &str) -> Result<String, String> {
+    // Reserved characters that decodeURI should NOT decode (because encodeURI doesn't encode them)
+    const RESERVED_ENCODED: &[&str] = &[
+        "%3B", "%3b", // ;
+        "%2F", "%2f", // /
+        "%3F", "%3f", // ?
+        "%3A", "%3a", // :
+        "%40", // @
+        "%26", // &
+        "%3D", "%3d", // =
+        "%2B", "%2b", // +
+        "%24", // $
+        "%2C", "%2c", // ,
+        "%23", // #
+    ];
+
+    let mut result = String::with_capacity(input.len());
+    let mut chars = input.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        if c == '%' {
+            // Peek at the next two characters to check if this is a reserved sequence
+            let mut hex = String::new();
+            let mut peek_chars = Vec::new();
+            for _ in 0..2 {
+                match chars.next() {
+                    Some(h) if h.is_ascii_hexdigit() => {
+                        hex.push(h);
+                        peek_chars.push(h);
+                    }
+                    Some(h) => {
+                        // Not a valid hex sequence, push as-is
+                        result.push('%');
+                        for pc in peek_chars {
+                            result.push(pc);
+                        }
+                        result.push(h);
+                        hex.clear();
+                        break;
+                    }
+                    None => return Err("URIError: malformed URI sequence".to_string()),
+                }
+            }
+
+            if hex.len() == 2 {
+                let encoded = format!("%{}", hex);
+                // Check if this is a reserved character that should NOT be decoded
+                if RESERVED_ENCODED
+                    .iter()
+                    .any(|r| r.eq_ignore_ascii_case(&encoded))
+                {
+                    result.push_str(&encoded);
+                } else if let Ok(byte) = u8::from_str_radix(&hex, 16) {
+                    result.push(byte as char);
+                }
+            }
+        } else {
+            result.push(c);
+        }
+    }
+
+    Ok(result)
+}
+
+/// Percent-encode a string (for encodeURI).
+/// Preserves: A-Z a-z 0-9 - _ . ! ~ * ' ( ) ; / ? : @ & = + $ , #
+pub fn percent_encode(input: &str) -> String {
+    const UNRESERVED: &[char] = &[
+        '-', '_', '.', '!', '~', '*', '\'', '(', ')', ';', '/', '?', ':', '@', '&', '=', '+', '$',
+        ',', '#',
+    ];
+
+    let mut result = String::with_capacity(input.len());
+    for c in input.chars() {
+        if c.is_ascii_alphanumeric() || UNRESERVED.contains(&c) {
+            result.push(c);
+        } else {
+            for byte in c.to_string().as_bytes() {
+                result.push_str(&format!("%{:02X}", byte));
+            }
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn percent_encode_component(input: &str) -> String {
+        const UNRESERVED: &[char] = &['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
+        let mut result = String::new();
+        for c in input.chars() {
+            if c.is_ascii_alphanumeric() || UNRESERVED.contains(&c) {
+                result.push(c);
+            } else {
+                for byte in c.to_string().as_bytes() {
+                    result.push_str(&format!("%{:02X}", byte));
+                }
+            }
+        }
+        result
+    }
+
+    #[test]
+    fn test_encode_decode_roundtrip() {
+        let original = "hello world";
+        let encoded = percent_encode_component(original);
+        assert_eq!(encoded, "hello%20world");
+        let decoded = percent_decode(&encoded).unwrap();
+        assert_eq!(decoded, original);
+    }
+}