core-interfaces.json

{
  "schema": "rsscript.core-interfaces.v1",
  "version": 1,
  "completeness": "complete",
  "provenance": [
    "rsscript_interface_catalog::CORE_INTERFACES"
  ],
  "sha256_algorithm": "sha256",
  "interfaces": [
    {
      "path": "stdlib/arguments/arguments.rssi",
      "sha256": "71840f601d218fabf02d37c0abb49678ce4794f064c8bad8652d3a43d3c4fe9e",
      "source": "/// Return an owned copy of explicitly supplied program arguments.\npub fn Arguments.all(args: read List<String>) -> fresh List<String>\n\n/// Return the number of explicitly supplied program arguments.\npub fn Arguments.count(args: read List<String>) -> Int\n\n/// Return one explicitly supplied program argument when the index is valid.\npub fn Arguments.get(\n    args: read List<String>,\n    index: Int,\n) -> Option<String>\n\n/// Return one explicitly supplied program argument or the caller-provided default.\npub fn Arguments.get_or_default(\n    args: read List<String>,\n    index: Int,\n    default: String,\n) -> String\n"
    },
    {
      "path": "stdlib/clone/clone.rssi",
      "sha256": "625e50a2e13482a9ecf7dba2671941c871c9ca6a753f0274297f8a74eff6d898",
      "source": "// `Clone` is an explicit, deep value copy, modeled on Swift's value semantics\n// and Rust's `Clone`.\n//\n// A managed `struct` or `sum` satisfies `Clone` by listing `derives(Clone)`,\n// which the compiler expands into a structural copy of every field. The builtin\n// value scalars (`Int`, `String`, `Bool`, ...) satisfy `Clone` directly.\n//\n// `Clone.clone<T>(self: read x)` copies a value out of a shared (`read`) borrow\n// into a `fresh` owned value, closing the \"clone gap\" where a `read` field\n// cannot be moved into a constructor. `Clone` is a pure contract: it introduces\n// no mutation, retention, native, or unsafe boundary.\nprotocol Clone {\n    fn clone(self: Self) -> fresh Self\n}\n"
    },
    {
      "path": "stdlib/cmp/eq.rssi",
      "sha256": "8a2b6eadb67f21d3203a30495f627c92c62040bf8b96bea2a04d55b5d8fa145e",
      "source": "// `Eq` is total, structural value equality, modeled on Swift's `Equatable`.\n//\n// A managed `struct` or `sum` satisfies `Eq` by listing `derives(Eq)` (or\n// `derives(Ord)`, which implies `Eq`), which the compiler expands into a\n// structural equality over every field. The builtin equatable scalars\n// (`Int`, `String`, `Bool`, ...) satisfy `Eq` directly. `Eq` is a pure,\n// total contract: it introduces no mutation, retention, native, or unsafe\n// boundary.\nprotocol Eq {\n    fn equals(self: Self, other: Self) -> Bool\n}\n"
    },
    {
      "path": "stdlib/cmp/ord.rssi",
      "sha256": "cf86bdae2d8459a0abb114626b8c2b65775dad7660a7f43b30ce900e83bc6b5a",
      "source": "protocol Ord {\n    fn compare(self: Self, other: Self) -> Int\n}\n"
    },
    {
      "path": "stdlib/collections/buffer.rssi",
      "sha256": "3eeb1533a58844e847ec5f1479bcdc60f3e5abfb18992a8d90d0cdd51ce02854",
      "source": "\nstruct BufferView\n\npub fn Buffer.new(size: Int) -> fresh Buffer\n\npub fn Buffer.len(buffer: Buffer) -> Int\n\npub fn Buffer.is_empty(buffer: Buffer) -> Bool\n\npub fn Buffer.clear(buffer: mut Buffer) -> Unit\n\npub fn Buffer.view(\n    buffer: Buffer,\n    start: Int,\n    len: Int,\n) -> BufferView\n\npub fn Buffer.consume(buffer: take Buffer) -> Unit\n\npub fn BufferView.slice(\n    value: BufferView,\n    start: Int,\n    len: Int,\n) -> BufferView\n\npub fn BufferView.len(value: BufferView) -> Int\n\npub fn BufferView.is_empty(value: BufferView) -> Bool\n\npub fn BufferView.to_bytes(value: BufferView) -> fresh Bytes\n"
    },
    {
      "path": "stdlib/collections/bytes.rssi",
      "sha256": "07fde846c1f1c60f2d18ce91d88ae59d4753ff1c99d6b219ee2edb2f2c0eaf84",
      "source": "\nstruct BytesView\n\npub fn Bytes.from_string(value: String) -> fresh Bytes\n\npub fn Bytes.from_buffer(buffer: Buffer) -> fresh Bytes\n\npub fn Bytes.from_uints(values: List<Int>) -> fresh Bytes\n\npub fn Bytes.to_uints(value: Bytes) -> fresh List<Int>\n\npub fn Bytes.to_string(value: Bytes) -> fresh String\n\npub fn Bytes.len(value: Bytes) -> Int\n\npub fn Bytes.is_empty(value: Bytes) -> Bool\n\npub fn Bytes.concat(left: Bytes, right: Bytes) -> fresh Bytes\n\npub fn Bytes.slice(\n    value: Bytes,\n    start: Int,\n    len: Int,\n) -> fresh Bytes\n\npub fn Bytes.view(\n    value: Bytes,\n    start: Int,\n    len: Int,\n) -> BytesView\n\npub fn Bytes.consume(bytes: take Bytes) -> Unit\n\npub fn BytesView.slice(\n    value: BytesView,\n    start: Int,\n    len: Int,\n) -> BytesView\n\npub fn BytesView.len(value: BytesView) -> Int\n\npub fn BytesView.is_empty(value: BytesView) -> Bool\n\npub fn BytesView.to_bytes(value: BytesView) -> fresh Bytes\n\npub fn BytesView.starts_with(value: BytesView, prefix: BytesView) -> Bool\n"
    },
    {
      "path": "stdlib/collections/deque.rssi",
      "sha256": "0406c6ae5ce01acee8f73dd7f32548e40cff1b6af22cdb38cad6ac3d5e3c5012",
      "source": "\nstruct Deque<T>\n\npub fn Deque.new<T>() -> fresh Deque<T>\n\npub fn Deque.push_back<T>(\n    deque: mut Deque<T>,\n    value: T,\n) -> Unit\n    retains(value)\n\npub fn Deque.push_front<T>(\n    deque: mut Deque<T>,\n    value: T,\n) -> Unit\n    retains(value)\n\npub fn Deque.pop_back<T>(deque: mut Deque<T>) -> Option<T>\n\npub fn Deque.pop_front<T>(deque: mut Deque<T>) -> Option<T>\n\npub fn Deque.clear<T>(deque: mut Deque<T>) -> Unit\n\npub fn Deque.len<T>(deque: Deque<T>) -> Int\n\npub fn Deque.is_empty<T>(deque: Deque<T>) -> Bool\n\npub fn Deque.to_list<T>(deque: Deque<T>) -> fresh List<T>\n"
    },
    {
      "path": "stdlib/collections/list.rssi",
      "sha256": "45377dd061c7eb79be94fa0a1cb3db396d8eb58b52d21ffdecbc807ace2a52aa",
      "source": "\npub fn List.new<T>() -> fresh List<T>\n\npub fn List.push<T>(\n    list: mut List<T>,\n    value: T,\n) -> Unit\n    retains(value)\n\npub fn List.set<T>(\n    list: mut List<T>,\n    index: Int,\n    value: T,\n) -> Unit\n    retains(value)\n\npub fn List.pop<T>(list: mut List<T>) -> Option<T>\n\npub fn List.clear<T>(list: mut List<T>) -> Unit\n\npub fn List.append<T>(\n    list: mut List<T>,\n    values: List<T>,\n) -> Unit\n    retains(values)\n\npub fn List.len<T>(list: List<T>) -> Int\n\npub fn List.get<T>(\n    list: List<T>,\n    index: Int,\n) -> T\n\npub fn List.count_where<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Int\n\npub fn List.any<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Bool\n\npub fn List.all<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Bool\n\npub fn List.find<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Option<T>\n\npub fn List.filter<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> fresh List<T>\n\npub fn List.map<T, U>(\n    list: List<T>,\n    mapper: noescape Fn(T) -> U,\n) -> fresh List<U>\n\npub fn List.fold<T, U: Struct>(\n    list: List<T>,\n    initial: U,\n    folder: noescape Fn(U, T) -> fresh U,\n) -> fresh U\n\npub fn List.try_fold<T, U: Struct, E>(\n    list: List<T>,\n    initial: U,\n    folder: noescape Fn(U, T) -> Result<fresh U, E>,\n) -> Result<fresh U, E>\n\npub fn List.consume<T>(list: take List<T>) -> Unit\n\npub fn List.contains<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Bool\n\npub fn List.contains_value<T>(\n    list: List<T>,\n    value: T,\n) -> Bool\n\npub fn List.is_empty<T>(list: List<T>) -> Bool\n\npub fn List.sum(list: List<Int>) -> Int\n\npub fn List.min(list: List<Int>) -> Option<Int>\n\npub fn List.max(list: List<Int>) -> Option<Int>\n\npub fn List.flatten<T>(list: List<List<T>>) -> fresh List<T>\n\npub fn List.dedup<T>(list: List<T>) -> fresh List<T>\n\npub fn List.zip<T>(\n    left: List<T>,\n    right: List<T>,\n) -> fresh List<List<T>>\n\npub fn List.enumerate(list: List<Int>) -> fresh List<List<Int>>\n\npub fn List.reverse<T>(list: List<T>) -> fresh List<T>\n\npub fn List.sort<T: Ord>(\n    list: mut List<T>,\n) -> Unit\n\npub fn List.sort_with<T>(\n    list: mut List<T>,\n    compare: noescape Fn(T, T) -> Int,\n) -> Unit\n\npub fn List.sort_by<T, K>(\n    list: List<T>,\n    key: noescape Fn(T) -> K,\n    compare: noescape Fn(K, K) -> Int,\n) -> fresh List<T>\n\npub fn List.group_by<T, K>(\n    list: List<T>,\n    key: noescape Fn(T) -> K,\n) -> fresh Map<K, List<T>>\n\npub fn List.partition<T>(\n    list: List<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> fresh List<List<T>>\n\npub fn List.flat_map<T, U>(\n    list: List<T>,\n    mapper: noescape Fn(T) -> List<U>,\n) -> fresh List<U>\n\npub fn List.take<T>(\n    list: List<T>,\n    count: Int,\n) -> fresh List<T>\n\npub fn List.slice<T>(\n    list: List<T>,\n    start: Int,\n    len: Int,\n) -> fresh List<T>\n\npub fn List.skip<T>(\n    list: List<T>,\n    count: Int,\n) -> fresh List<T>\n\npub fn List.first<T>(list: List<T>) -> Option<T>\n\npub fn List.last<T>(list: List<T>) -> Option<T>\n\npub fn List.remove_at<T>(\n    list: mut List<T>,\n    index: Int,\n) -> Option<T>\n\npub fn List.join(list: List<String>, separator: String) -> fresh String\n\npub fn List.to_json_strings(list: List<String>) -> fresh JsonValue\n\n\npub fn List.to_json_values(list: List<JsonValue>) -> fresh JsonValue\n"
    },
    {
      "path": "stdlib/collections/map.rssi",
      "sha256": "08907b92b67903fed8178fc8a62065b0f0445bc9ed93767ff699a9d7e6f3404d",
      "source": "// `Map<K, V>` is a hash map. Its key type `K` must be `Hashable` (and therefore\n// `Eq`): a builtin hashable scalar, or a managed `struct`/`sum` that lists\n// `derives(Eq, Hash)`. The bound is checked in RSScript, so a non-hashable key\n// is rejected with a clear diagnostic instead of leaking as a rustc trait-bound\n// error.\nstruct Map<K, V>\n\npub fn Map.new<K: Hashable, V>() -> fresh Map<K, V>\n\npub fn Map.len<K: Hashable, V>(map: Map<K, V>) -> Int\n\npub fn Map.is_empty<K: Hashable, V>(map: Map<K, V>) -> Bool\n\npub fn Map.contains_key<K: Hashable, V>(\n    map: Map<K, V>,\n    key: K,\n) -> Bool\n\npub fn Map.get<K: Hashable, V>(\n    map: Map<K, V>,\n    key: K,\n) -> Option<V>\n\npub fn Map.get_or_default<K: Hashable, V>(\n    map: Map<K, V>,\n    key: K,\n    default: V,\n) -> V\n\npub fn Map.insert<K: Hashable, V>(\n    map: mut Map<K, V>,\n    key: K,\n    value: V,\n) -> Unit\n    retains(key) retains(value)\n\npub fn Map.insert_old<K: Hashable, V>(\n    map: mut Map<K, V>,\n    key: K,\n    value: V,\n) -> Option<V>\n    retains(key) retains(value)\n\npub fn Map.remove<K: Hashable, V>(\n    map: mut Map<K, V>,\n    key: K,\n) -> Option<V>\n\npub fn Map.clear<K: Hashable, V>(map: mut Map<K, V>) -> Unit\n\npub fn Map.keys<K: Hashable, V>(map: Map<K, V>) -> fresh List<K>\n\npub fn Map.values<K: Hashable, V>(map: Map<K, V>) -> fresh List<V>\n\npub fn Map.for_each<K: Hashable, V>(\n    map: Map<K, V>,\n    callback: noescape Fn(K, V) -> Unit,\n) -> Unit\n\npub fn Map.map_values<K: Hashable, V, U>(\n    map: Map<K, V>,\n    mapper: noescape Fn(V) -> U,\n) -> fresh Map<K, U>\n\npub fn Map.filter<K: Hashable, V>(\n    map: Map<K, V>,\n    predicate: noescape Fn(K, V) -> Bool,\n) -> fresh Map<K, V>\n\npub fn Map.try_fold<K: Hashable, V, U: Struct, E>(\n    map: Map<K, V>,\n    initial: U,\n    folder: noescape Fn(U, K, V) -> Result<fresh U, E>,\n) -> Result<fresh U, E>\n\npub fn Map.fold<K: Hashable, V, U: Struct>(\n    map: Map<K, V>,\n    initial: U,\n    folder: noescape Fn(U, K, V) -> fresh U,\n) -> fresh U\n\npub fn Map.merge<K: Hashable, V>(\n    left: Map<K, V>,\n    right: Map<K, V>,\n    resolver: noescape Fn(V, V) -> V,\n) -> fresh Map<K, V>\n"
    },
    {
      "path": "stdlib/collections/persistent_map.rssi",
      "sha256": "478fbd17aa50f0c9b614ae5a1cb375ae4191f7c9c9308f08adbc80c8a88da41c",
      "source": "struct PersistentMap<K, V>\n\npub fn PersistentMap.new<K, V>() -> fresh PersistentMap<K, V>\n\npub fn PersistentMap.len<K, V>(map: PersistentMap<K, V>) -> Int\n\npub fn PersistentMap.is_empty<K, V>(map: PersistentMap<K, V>) -> Bool\n\npub fn PersistentMap.contains_key<K, V>(\n    map: PersistentMap<K, V>,\n    key: K,\n) -> Bool\n\npub fn PersistentMap.get<K, V>(\n    map: PersistentMap<K, V>,\n    key: K,\n) -> Option<V>\n\npub fn PersistentMap.insert<K, V>(\n    map: PersistentMap<K, V>,\n    key: K,\n    value: V,\n) -> fresh PersistentMap<K, V>\n    retains(key) retains(value)\n\npub fn PersistentMap.remove<K, V>(\n    map: PersistentMap<K, V>,\n    key: K,\n) -> fresh PersistentMap<K, V>\n\npub fn PersistentMap.clear<K, V>(map: PersistentMap<K, V>) -> fresh PersistentMap<K, V>\n"
    },
    {
      "path": "stdlib/collections/pipeline.rssi",
      "sha256": "58e4fc5fa60767c4a157e130f37f2652b4c18cb69a284e8c187b819df3e26db6",
      "source": "struct Pipeline<T>\n\nstruct FalliblePipeline<T, E>\n\npub fn List.pipeline<T>(\n    list: List<T>,\n) -> fresh Pipeline<T>\n\npub fn Pipeline.map<T, U>(\n    pipeline: Pipeline<T>,\n    mapper: noescape Fn(T) -> U,\n) -> fresh Pipeline<U>\n\npub fn Pipeline.filter<T>(\n    pipeline: Pipeline<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> fresh Pipeline<T>\n\npub fn Pipeline.each<T>(\n    pipeline: Pipeline<T>,\n    action: noescape Fn(T) -> Unit,\n) -> fresh Pipeline<T>\n\npub fn Pipeline.try_map<T, U, E>(\n    pipeline: Pipeline<T>,\n    mapper: noescape Fn(T) -> Result<fresh U, E>,\n) -> fresh FalliblePipeline<U, E>\n\npub fn Pipeline.collect<T>(\n    pipeline: Pipeline<T>,\n) -> fresh List<T>\n\npub fn FalliblePipeline.map<T, U, E>(\n    pipeline: FalliblePipeline<T, E>,\n    mapper: noescape Fn(T) -> U,\n) -> fresh FalliblePipeline<U, E>\n\npub fn FalliblePipeline.filter<T, E>(\n    pipeline: FalliblePipeline<T, E>,\n    predicate: noescape Fn(T) -> Bool,\n) -> fresh FalliblePipeline<T, E>\n\npub fn FalliblePipeline.each<T, E>(\n    pipeline: FalliblePipeline<T, E>,\n    action: noescape Fn(T) -> Unit,\n) -> fresh FalliblePipeline<T, E>\n\npub fn FalliblePipeline.try_map<T, U, E>(\n    pipeline: FalliblePipeline<T, E>,\n    mapper: noescape Fn(T) -> Result<fresh U, E>,\n) -> fresh FalliblePipeline<U, E>\n\npub fn FalliblePipeline.collect<T, E>(\n    pipeline: FalliblePipeline<T, E>,\n) -> Result<fresh List<T>, E>\n"
    },
    {
      "path": "stdlib/collections/set.rssi",
      "sha256": "0c4e8a55e0e5b0a7fa3b724e88df4b4f85ea44861c581910e34a0b3052fb31be",
      "source": "// `Set<T>` is a hash set. Its element type `T` must be `Hashable` (and therefore\n// `Eq`): a builtin hashable scalar, or a managed `struct`/`sum` that lists\n// `derives(Eq, Hash)`. The bound is checked in RSScript, so a non-hashable\n// element is rejected with a clear diagnostic instead of leaking as a rustc\n// trait-bound error.\nstruct Set<T>\n\npub fn Set.new<T: Hashable>() -> fresh Set<T>\n\npub fn Set.len<T: Hashable>(set: Set<T>) -> Int\n\npub fn Set.is_empty<T: Hashable>(set: Set<T>) -> Bool\n\npub fn Set.contains<T: Hashable>(\n    set: Set<T>,\n    value: T,\n) -> Bool\n\npub fn Set.insert<T: Hashable>(\n    set: mut Set<T>,\n    value: T,\n) -> Bool\n    retains(value)\n\npub fn Set.remove<T: Hashable>(\n    set: mut Set<T>,\n    value: T,\n) -> Bool\n\npub fn Set.clear<T: Hashable>(set: mut Set<T>) -> Unit\n\npub fn Set.to_list<T: Hashable>(set: Set<T>) -> fresh List<T>\n\npub fn Set.for_each<T: Hashable>(\n    set: Set<T>,\n    callback: noescape Fn(T) -> Unit,\n) -> Unit\n\npub fn Set.union<T: Hashable>(\n    left: Set<T>,\n    right: Set<T>,\n) -> fresh Set<T>\n\npub fn Set.intersection<T: Hashable>(\n    left: Set<T>,\n    right: Set<T>,\n) -> fresh Set<T>\n\npub fn Set.difference<T: Hashable>(\n    left: Set<T>,\n    right: Set<T>,\n) -> fresh Set<T>\n\npub fn Set.is_subset<T: Hashable>(\n    left: Set<T>,\n    right: Set<T>,\n) -> Bool\n"
    },
    {
      "path": "stdlib/collections/sorted_map.rssi",
      "sha256": "ab6326014459e31f9a10b192972b5c1adf079b01146b9e1c27c4d024703f9edb",
      "source": "struct SortedMap<K, V>\n\npub fn SortedMap.new<K: Ord, V>() -> fresh SortedMap<K, V>\n\npub fn SortedMap.len<K: Ord, V>(map: SortedMap<K, V>) -> Int\n\npub fn SortedMap.is_empty<K: Ord, V>(map: SortedMap<K, V>) -> Bool\n\npub fn SortedMap.contains_key<K: Ord, V>(\n    map: SortedMap<K, V>,\n    key: K,\n) -> Bool\n\npub fn SortedMap.get<K: Ord, V>(\n    map: SortedMap<K, V>,\n    key: K,\n) -> Option<V>\n\npub fn SortedMap.insert<K: Ord, V>(\n    map: mut SortedMap<K, V>,\n    key: K,\n    value: V,\n) -> Unit\n    retains(key) retains(value)\n\npub fn SortedMap.remove<K: Ord, V>(\n    map: mut SortedMap<K, V>,\n    key: K,\n) -> Option<V>\n\npub fn SortedMap.clear<K: Ord, V>(map: mut SortedMap<K, V>) -> Unit\n\npub fn SortedMap.keys<K: Ord, V>(map: SortedMap<K, V>) -> fresh List<K>\n\npub fn SortedMap.values<K: Ord, V>(map: SortedMap<K, V>) -> fresh List<V>\n"
    },
    {
      "path": "stdlib/collections/sorted_set.rssi",
      "sha256": "d3cd75eb83fdb33337059d7ac2e08c822592ed0a62e359cebd7752d380ea5d09",
      "source": "struct SortedSet<T>\n\npub fn SortedSet.new<T: Ord>() -> fresh SortedSet<T>\n\npub fn SortedSet.len<T: Ord>(set: SortedSet<T>) -> Int\n\npub fn SortedSet.is_empty<T: Ord>(set: SortedSet<T>) -> Bool\n\npub fn SortedSet.contains<T: Ord>(\n    set: SortedSet<T>,\n    value: T,\n) -> Bool\n\npub fn SortedSet.insert<T: Ord>(\n    set: mut SortedSet<T>,\n    value: T,\n) -> Bool\n    retains(value)\n\npub fn SortedSet.remove<T: Ord>(\n    set: mut SortedSet<T>,\n    value: T,\n) -> Bool\n\npub fn SortedSet.clear<T: Ord>(set: mut SortedSet<T>) -> Unit\n\npub fn SortedSet.to_list<T: Ord>(set: SortedSet<T>) -> fresh List<T>\n"
    },
    {
      "path": "stdlib/csv/csv.rssi",
      "sha256": "3e022edb1b44c510c6a888d357b395684449d83e750bd726a1abe09c54bc1197",
      "source": "struct RowBuffer\n\nstruct Row\n\npub fn RowBuffer.new(size: Int) -> fresh RowBuffer\n\npub fn Csv.parse_row(buffer: RowBuffer) -> Result<fresh Row, CsvError>\n\npub fn Row.field_string(\n    row: Row,\n    index: Int,\n) -> Result<String, CsvError>\n"
    },
    {
      "path": "stdlib/date/date.rssi",
      "sha256": "1c3c0741e5492bb8cefdc13261aadf2de9b23b983095a83a49e4ffbe5c50e5e1",
      "source": "\npub fn Date.year(unix_ms: Int) -> Int\n\n\npub fn Date.month(unix_ms: Int) -> Int\n\n\npub fn Date.day(unix_ms: Int) -> Int\n\n\npub fn Date.hour(unix_ms: Int) -> Int\n\n\npub fn Date.minute(unix_ms: Int) -> Int\n\n\npub fn Date.second(unix_ms: Int) -> Int\n\n\npub fn Date.add_ms(unix_ms: Int, ms: Int) -> Int\n\n\npub fn Date.add_days(unix_ms: Int, days: Int) -> Int\n\n\npub fn Date.days_between(start_unix_ms: Int, end_unix_ms: Int) -> Int\n\n\npub fn Date.start_of_day(unix_ms: Int) -> Int\n\n\npub fn Date.weekday(unix_ms: Int) -> Int\n\n\npub fn Date.is_leap_year(year: Int) -> Bool\n\n\npub fn Date.days_in_month(year: Int, month: Int) -> Int\n\n\npub fn Date.format_ymd(unix_ms: Int) -> fresh String\n\n\npub fn Date.parse_ymd(value: String) -> Option<Int>\n\n\npub fn Date.format_iso(unix_ms: Int) -> fresh String\n\n\npub fn Date.parse_iso(value: String) -> Option<Int>\n"
    },
    {
      "path": "stdlib/diff/diff.rssi",
      "sha256": "6b2df0c062c7ee4d6d8d7f92f405bd11e69d1a2ba2552863a39d5e7fd4efc1ed",
      "source": "\npub fn Diff.unified(old: String, new: String) -> fresh String\n"
    },
    {
      "path": "stdlib/duration/duration.rssi",
      "sha256": "fe3920802f09e7effffe29a15ba7b905d8cba2916ca070297580cb320d69e456",
      "source": "/// A deterministic duration value. Reading wall-clock time is provider-backed.\nstruct Duration\n\npub fn Duration.ms(value: Int) -> fresh Duration\n\npub fn Duration.seconds(value: Int) -> fresh Duration\n\npub fn Duration.as_ms(value: Duration) -> Int\n\npub fn Duration.as_seconds(value: Duration) -> Int\n\npub fn Duration.add(left: Duration, right: Duration) -> fresh Duration\n"
    },
    {
      "path": "stdlib/dyn/dyn.rssi",
      "sha256": "8e37be8b811d7b36271ca086266d6c5e6ffb35321762d9b5d467bb30edc93066",
      "source": "// Explicit dynamic protocol object. `Dyn` is a language-level dispatch\n// boundary and carries no host authority.\nstruct Dyn<P>\n\npub fn Dyn.from<P, T>(value: take T) -> fresh Dyn<P>\n"
    },
    {
      "path": "stdlib/encoding/encoding.rssi",
      "sha256": "5c85a55fb58588dc72297f79c54b3eaf5ff7d9ed26ecc2c52325c30f737fe7d2",
      "source": "\nstruct DecodeError\n\npub fn Base64.encode(value: String) -> fresh String\n\n\npub fn Base64.encode_bytes(value: Bytes) -> fresh String\n\n\npub fn Base64.decode(text: String) -> Result<fresh Bytes, DecodeError>\n\n\npub fn Base64.decode_string(text: String) -> Result<fresh String, DecodeError>\n\n\npub fn Hex.encode(value: Bytes) -> fresh String\n\n\npub fn Hex.encode_string(value: String) -> fresh String\n\n\npub fn Hex.decode(text: String) -> Result<fresh Bytes, DecodeError>\n\n\npub fn Gzip.decompress_bytes(value: Bytes) -> Result<fresh Bytes, DecodeError>\n\n\npub fn Url.encode_component(value: String) -> fresh String\n\n\npub fn Url.decode_component(value: String) -> Result<fresh String, DecodeError>\n\n\npub fn DecodeError.message(error: DecodeError) -> String\n"
    },
    {
      "path": "stdlib/hash/hash.rssi",
      "sha256": "26179df0deb6d15e7bd896860cc90e7b7743deb27a3c63f8b5b78545aecc0dbe",
      "source": "\npub fn Hash.sha256_string(value: String) -> fresh String\n\n\npub fn Hash.sha256_bytes(value: Bytes) -> fresh String\n\n\npub fn Hash.sha3_224_bytes(value: Bytes) -> fresh Bytes\n\n\npub fn Hash.sha3_256_bytes(value: Bytes) -> fresh Bytes\n\n\npub fn Hash.shake128_bytes(value: Bytes, out_len: Int) -> fresh Bytes\n\n\npub fn Hmac.sha256_string(\n    key: String,\n    value: String,\n) -> fresh String\n\n\npub fn Hmac.sha256_bytes(\n    key: Bytes,\n    value: Bytes,\n) -> fresh String\n"
    },
    {
      "path": "stdlib/hash/hashable.rssi",
      "sha256": "893db83a1e4f8d685b7c6a075ef43421df44a094cfa2a9fdd3e6e4db51819c81",
      "source": "// `Hashable` lets a managed value be used as a `Map<K, V>` key or `Set<K>`\n// element, modeled on Swift's `Hashable` (which refines `Equatable`). A type\n// that is `Hashable` must also be `Eq`: two values that compare equal must hash\n// equal.\n//\n// A managed `struct` or `sum` satisfies `Hashable` by listing\n// `derives(Eq, Hash)`, which the compiler expands into a structural hash and\n// equality over every field — no hand-written boilerplate. The builtin hashable\n// scalars (`Int`, `String`, `Bool`, ...) satisfy `Hashable` directly.\n//\n// `Hashable` is pure and total: it introduces no mutation, retention, native,\n// or unsafe boundary, and adds no capability gate. It is the bound on\n// `Map<K, V>` keys and `Set<K>` elements so that graph interning, dedup, and\n// memoization over user-defined managed types are expressible while a\n// non-hashable key is rejected in RSScript instead of leaking from rustc.\nprotocol Hashable {\n    fn hash_value(self: Self) -> Int\n}\n"
    },
    {
      "path": "stdlib/json/json.rssi",
      "sha256": "81076dcf05605c6bfd77c61a73435f9711e243999c0d692f773f914adfcbd65d",
      "source": "struct JsonValue\nstruct JsonLiteral\n\npub fn Json.parse(text: String) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.json_parse(text: String) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.value(value: JsonLiteral) -> fresh JsonValue\n\n\npub fn Json.clone(value: JsonValue) -> fresh JsonValue\n\n\npub fn Json.decode<T: Struct>(value: JsonValue) -> Result<fresh T, JsonError>\n\n\npub fn Json.decode_text<T: Struct>(text: String) -> Result<fresh T, JsonError>\n\n\npub fn Json.encode(value: JsonLiteral) -> fresh String\n\n\npub fn Json.quote_string(value: String) -> fresh String\n\n\npub fn Json.to_string(value: JsonValue) -> fresh String\n\n\npub fn Json.string_field(name: String, value: String) -> fresh String\n\n\npub fn Json.int_field(name: String, value: Int) -> fresh String\n\n\npub fn Json.bool_field(name: String, value: Bool) -> fresh String\n\n\npub fn Json.raw_field(name: String, value: String) -> fresh String\n\n\npub fn Json.object(fields: List<String>) -> fresh String\n\n\npub fn Json.array(items: List<String>) -> fresh String\n\n\npub fn Json.string_array(items: List<String>) -> fresh String\n\n\npub fn Json.strings(items: List<String>) -> fresh JsonValue\n\n\npub fn Json.values(items: List<JsonValue>) -> fresh JsonValue\n\n\npub fn Json.field(\n    value: JsonValue,\n    name: String,\n) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.field_string(\n    value: JsonValue,\n    name: String,\n) -> Result<String, JsonError>\n\npub fn Json.field_int(\n    value: JsonValue,\n    name: String,\n) -> Result<Int, JsonError>\n\npub fn Json.field_bool(\n    value: JsonValue,\n    name: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.field_optional(\n    value: JsonValue,\n    name: String,\n) -> Result<Option<JsonValue>, JsonError>\n\npub fn Json.field_optional_string(\n    value: JsonValue,\n    name: String,\n) -> Result<Option<String>, JsonError>\n\npub fn Json.field_optional_int(\n    value: JsonValue,\n    name: String,\n) -> Result<Option<Int>, JsonError>\n\npub fn Json.field_optional_bool(\n    value: JsonValue,\n    name: String,\n) -> Result<Option<Bool>, JsonError>\n\npub fn Json.value_at(\n    value: JsonValue,\n    path: String,\n) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.at(\n    value: JsonValue,\n    path: String,\n) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.at_or(\n    value: JsonValue,\n    path: String,\n    fallback: JsonValue,\n) -> fresh JsonValue\n\n\npub fn Json.at_string(\n    value: JsonValue,\n    path: String,\n) -> Result<String, JsonError>\n\npub fn Json.at_int(\n    value: JsonValue,\n    path: String,\n) -> Result<Int, JsonError>\n\npub fn Json.at_bool(\n    value: JsonValue,\n    path: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.at_optional(\n    value: JsonValue,\n    path: String,\n) -> Result<Option<JsonValue>, JsonError>\n\npub fn Json.at_optional_string(\n    value: JsonValue,\n    path: String,\n) -> Result<Option<String>, JsonError>\n\npub fn Json.at_optional_int(\n    value: JsonValue,\n    path: String,\n) -> Result<Option<Int>, JsonError>\n\npub fn Json.at_optional_bool(\n    value: JsonValue,\n    path: String,\n) -> Result<Option<Bool>, JsonError>\n\npub fn Json.at_string_or(\n    value: JsonValue,\n    path: String,\n    fallback: String,\n) -> String\n\n\npub fn Json.at_int_or(\n    value: JsonValue,\n    path: String,\n    fallback: Int,\n) -> Int\n\n\npub fn Json.at_bool_or(\n    value: JsonValue,\n    path: String,\n    fallback: Bool,\n) -> Bool\n\n\npub fn Json.at_to_string(\n    value: JsonValue,\n    path: String,\n) -> Result<String, JsonError>\n\npub fn Json.at_to_string_or(\n    value: JsonValue,\n    path: String,\n    fallback: String,\n) -> String\n\n\npub fn Json.string_at(\n    text: String,\n    path: String,\n) -> Result<String, JsonError>\n\npub fn Json.int_at(\n    text: String,\n    path: String,\n) -> Result<Int, JsonError>\n\npub fn Json.bool_at(\n    text: String,\n    path: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.to_string_at(\n    text: String,\n    path: String,\n) -> Result<String, JsonError>\n\npub fn Json.string_at_or(\n    text: String,\n    path: String,\n    fallback: String,\n) -> String\n\n\npub fn Json.json_string_at_or(\n    text: String,\n    path: String,\n    fallback: String,\n) -> String\n\n\npub fn Json.int_at_or(\n    text: String,\n    path: String,\n    fallback: Int,\n) -> Int\n\n\npub fn Json.json_int_at_or(\n    text: String,\n    path: String,\n    fallback: Int,\n) -> Int\n\n\npub fn Json.bool_at_or(\n    text: String,\n    path: String,\n    fallback: Bool,\n) -> Bool\n\n\npub fn Json.json_bool_at_or(\n    text: String,\n    path: String,\n    fallback: Bool,\n) -> Bool\n\n\npub fn Json.to_string_at_or(\n    text: String,\n    path: String,\n    fallback: String,\n) -> String\n\n\npub fn Json.as_string(value: JsonValue) -> Result<String, JsonError>\n\npub fn Json.as_int(value: JsonValue) -> Result<Int, JsonError>\n\npub fn Json.as_bool(value: JsonValue) -> Result<Bool, JsonError>\n\npub fn Json.is_null(value: JsonValue) -> Bool\n\n\npub fn Json.is_array(value: JsonValue) -> Bool\n\n\npub fn Json.is_object(value: JsonValue) -> Bool\n\n\npub fn Json.kind(value: JsonValue) -> String\n\n\npub fn Json.object_len(value: JsonValue) -> Result<Int, JsonError>\n\npub fn Json.object_keys(value: JsonValue) -> Result<fresh List<String>, JsonError>\n\npub fn Json.array_len(value: JsonValue) -> Result<Int, JsonError>\n\npub fn Json.array_get(\n    value: JsonValue,\n    index: Int,\n) -> Result<fresh JsonValue, JsonError>\n\npub fn Json.array_strings(value: JsonValue) -> Result<fresh List<String>, JsonError>\n\npub fn Json.array_ints(value: JsonValue) -> Result<fresh List<Int>, JsonError>\n\npub fn Json.array_bools(value: JsonValue) -> Result<fresh List<Bool>, JsonError>\n\npub fn Json.array_contains_string(\n    value: JsonValue,\n    item: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.array_contains_substring(\n    value: JsonValue,\n    text: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.array_contains_prefix(\n    value: JsonValue,\n    prefix: String,\n) -> Result<Bool, JsonError>\n\npub fn Json.array_count_where(\n    value: JsonValue,\n    predicate: noescape Fn(JsonValue) -> Result<Bool, JsonError>,\n) -> Result<Int, JsonError>\n\npub fn Json.array_fold<T: Struct>(\n    value: JsonValue,\n    initial: T,\n    folder: noescape Fn(T, JsonValue) -> Result<fresh T, JsonError>,\n) -> Result<fresh T, JsonError>\n\npub fn JsonError.message(error: JsonError) -> String\n"
    },
    {
      "path": "stdlib/math/math.rssi",
      "sha256": "fb8a6c93db092641f217113e329725c2e458d5d3d5137df8ae1acb9a409bfc83",
      "source": "pub fn Math.abs(value: Int) -> Int\n\npub fn Math.min(left: Int, right: Int) -> Int\n\npub fn Math.max(left: Int, right: Int) -> Int\n\npub fn Math.clamp(value: Int, min: Int, max: Int) -> Int\n\npub fn Math.pow(base: Int, exponent: Int) -> Int\n\npub fn Math.wrapping_add(left: Int, right: Int) -> Int\n\npub fn Math.wrapping_sub(left: Int, right: Int) -> Int\n\npub fn Math.wrapping_mul(left: Int, right: Int) -> Int\n\npub fn Math.saturating_add(left: Int, right: Int) -> Int\n\npub fn Math.saturating_sub(left: Int, right: Int) -> Int\n\npub fn Math.saturating_mul(left: Int, right: Int) -> Int\n\npub fn Math.abs_float(value: Float) -> Float\n\npub fn Math.min_float(left: Float, right: Float) -> Float\n\npub fn Math.max_float(left: Float, right: Float) -> Float\n\npub fn Math.clamp_float(value: Float, min: Float, max: Float) -> Float\n\npub fn Math.pow_float(base: Float, exponent: Float) -> Float\n\npub fn Math.exp2(value: Float) -> Float\n\npub fn Math.log2(value: Float) -> Float\n\npub fn Math.sin(value: Float) -> Float\n\npub fn Math.cos(value: Float) -> Float\n\npub fn Math.exp(value: Float) -> Float\n\npub fn Math.log(value: Float) -> Float\n\npub fn Math.tanh(value: Float) -> Float\n\npub fn Math.sqrt(value: Float) -> Float\n\npub fn Math.trunc_float(value: Float) -> Float\n\npub fn Math.floor(value: Float) -> Int\n\npub fn Math.ceil(value: Float) -> Int\n\npub fn Math.round(value: Float) -> Int\n"
    },
    {
      "path": "stdlib/option/option.rssi",
      "sha256": "a98b1fd9258ea342395f1376d8aab91b1821a65939161aaca836c6d6c2edfe48",
      "source": "pub fn Option.is_some<T>(value: Option<T>) -> Bool\n\n\npub fn Option.is_none<T>(value: Option<T>) -> Bool\n\n\npub fn Option.unwrap_or<T>(value: Option<T>, default: T) -> T\n\n\npub fn Option.map<T, U>(\n    value: Option<T>,\n    mapper: noescape Fn(T) -> U,\n) -> Option<U>\n\npub fn Option.and_then<T, U>(\n    value: Option<T>,\n    mapper: noescape Fn(T) -> Option<U>,\n) -> Option<U>\n\npub fn Option.ok_or<T, E>(\n    value: Option<T>,\n    error: E,\n) -> Result<T, E>\n\npub fn Option.or<T>(\n    value: Option<T>,\n    fallback: Option<T>,\n) -> Option<T>\n\npub fn Option.filter<T>(\n    value: Option<T>,\n    predicate: noescape Fn(T) -> Bool,\n) -> Option<T>\n\npub fn Option.unwrap_or_else<T>(\n    value: Option<T>,\n    default: noescape Fn() -> T,\n) -> T\n"
    },
    {
      "path": "stdlib/output/output.rssi",
      "sha256": "4672d89a9d23ba1d3a4b11198898992b4a631aeb891590cb09921510d7c83b4f",
      "source": "pub fn Output.write(message: String) -> Unit\n\npub fn Output.write_json(value: JsonValue) -> Unit\n\npub fn Output.error(message: String) -> Unit\n\npub fn Output.error_json(value: JsonValue) -> Unit\n\npub fn Output.trace(event: String, message: String) -> Unit\n"
    },
    {
      "path": "stdlib/patch/patch.rssi",
      "sha256": "7986a7f9701c9378263bfe1bbb551c57c41b05d9497b4a7a3091d82163513038",
      "source": "\npub fn Patch.apply_text(\n    original: String,\n    patch: String,\n) -> Result<fresh String, String>\n"
    },
    {
      "path": "stdlib/path/path.rssi",
      "sha256": "4689070e083ee93ba3187c10dd0c26702f372aa57386a0d8a4d80a9d0fc67ee9",
      "source": "\npub fn Path.from_string(value: String) -> fresh Path\n\npub fn Path.join(base: Path, child: String) -> fresh Path\n\npub fn Path.safe_relative(value: String) -> Result<fresh Path, String>\n\n\npub fn Path.resolve_relative(\n    root: Path,\n    relative: String,\n) -> Result<fresh Path, String>\n\n\npub fn Path.normalize(path: Path) -> fresh Path\n\n\npub fn Path.to_string(path: Path) -> fresh String\n\n\npub fn Path.file_name(path: Path) -> Option<String>\n\n\npub fn Path.extension(path: Path) -> Option<String>\n\n\npub fn Path.parent(path: Path) -> Option<Path>\n\n\npub fn Path.is_absolute(path: Path) -> Bool\n\n\npub fn Path.with_extension(path: Path, extension: String) -> fresh Path\n\n\npub fn Path.starts_with(path: Path, base: Path) -> Bool\n"
    },
    {
      "path": "stdlib/regex/regex.rssi",
      "sha256": "c87f6103459c68745989f779346e6f943631b4f5521e9a273dbbd0ec9819e57a",
      "source": "\nstruct Regex\nstruct RegexError\n\npub fn Regex.compile(pattern: String) -> Result<fresh Regex, RegexError>\n\n\npub fn Regex.is_match(regex: Regex, value: String) -> Bool\n\n\npub fn Regex.find(regex: Regex, value: String) -> Option<fresh String>\n\n\npub fn Regex.captures(regex: Regex, value: String) -> fresh List<String>\n\n\npub fn Regex.replace_all(\n    regex: Regex,\n    value: String,\n    replacement: String,\n) -> fresh String\n\n\npub fn Regex.split(regex: Regex, value: String) -> fresh List<String>\n\n\npub fn RegexError.message(error: RegexError) -> String\n"
    },
    {
      "path": "stdlib/result/result.rssi",
      "sha256": "9079daceb57309392c6390dca19fa6b57bfeed1b17cc936fac932d8b94e85980",
      "source": "pub fn Result.is_ok<T, E>(value: Result<T, E>) -> Bool\n\n\npub fn Result.is_err<T, E>(value: Result<T, E>) -> Bool\n\n\npub fn Result.unwrap_or<T, E>(value: Result<T, E>, default: T) -> T\n\n\npub fn Result.ok<T, E>(value: Result<T, E>) -> Option<T>\n\n\npub fn Result.err<T, E>(value: Result<T, E>) -> Option<E>\n\n\npub fn Result.err_message<T, E>(value: Result<T, E>) -> Option<String>\n\n\npub fn Result.map_error<T, E, F>(\n    result: Result<T, E>,\n    mapper: noescape Fn(E) -> F,\n) -> Result<T, F>\n\npub fn Result.and_then<T, E, U>(\n    result: Result<T, E>,\n    mapper: noescape Fn(T) -> Result<U, E>,\n) -> Result<U, E>\n\npub fn Result.map<T, E, U>(\n    result: Result<T, E>,\n    mapper: noescape Fn(T) -> U,\n) -> Result<U, E>\n\npub fn Result.unwrap_or_else<T, E>(\n    result: Result<T, E>,\n    fallback: noescape Fn(E) -> T,\n) -> T\n"
    },
    {
      "path": "stdlib/string/string.rssi",
      "sha256": "51c2ae97318b744962d310908f9de310946e1e15997bea9e8a465df18fac89b8",
      "source": "\nstruct StringBuilder\n\nstruct StringView\n\npub fn Char.is_digit(value: Char) -> Bool\n\n\npub fn Char.is_alpha(value: Char) -> Bool\n\n\npub fn Char.is_whitespace(value: Char) -> Bool\n\n\npub fn Char.is_alphanumeric(value: Char) -> Bool\n\n\npub fn Char.is_lower(value: Char) -> Bool\n\n\npub fn Char.is_upper(value: Char) -> Bool\n\n\npub fn Char.to_lower(value: Char) -> Char\n\n\npub fn Char.to_upper(value: Char) -> Char\n\n\npub fn Char.to_code(value: Char) -> Int\n\n\npub fn Char.from_code(value: Int) -> Option<Char>\n\n\npub fn Char.compare(left: Char, right: Char) -> Int\n\n\npub fn Char.to_string(value: Char) -> fresh String\n\n\npub fn String.concat(left: String, right: String) -> fresh String\n\n\npub fn String.copy(value: String) -> fresh String\n\n\npub fn String.clone(value: String) -> fresh String\n\n\npub fn String.from_int(value: Int) -> fresh String\n\n\npub fn String.from_float(value: Float) -> fresh String\n\n\npub fn String.from_bool(value: Bool) -> fresh String\n\n\npub fn Int.to_string(value: Int) -> fresh String\n\n\npub fn Int.to_float(value: Int) -> Float\n\n\npub fn Float.to_string(value: Float) -> fresh String\n\n\npub fn Float.is_nan(value: Float) -> Bool\n\n\npub fn Float.is_finite(value: Float) -> Bool\n\n\npub fn Float.is_infinite(value: Float) -> Bool\n\n\npub fn Int.bit_and(left: Int, right: Int) -> Int\n\n\npub fn Int.bit_or(left: Int, right: Int) -> Int\n\n\npub fn Int.bit_xor(left: Int, right: Int) -> Int\n\n\npub fn Int.bit_not(value: Int) -> Int\n\n\npub fn Int.shift_left(value: Int, bits: Int) -> Int\n\n\npub fn Int.shift_right(value: Int, bits: Int) -> Int\n\n\npub fn String.to_path(value: String) -> fresh Path\n\n\npub fn String.safe_relative(value: String) -> Result<fresh Path, String>\n\n\npub fn String.to_url(value: String) -> fresh Url\n\n\npub fn String.to_bytes(value: String) -> fresh Bytes\n\n\npub fn String.env(value: String) -> Option<fresh String>\n\n\npub fn String.env_or(value: String, default: String) -> fresh String\n\n\npub fn String.len(value: String) -> Int\n\n\npub fn String.is_empty(value: String) -> Bool\n\n\npub fn String.trim(value: String) -> fresh String\n\n\npub fn String.trim_start(value: String) -> fresh String\n\n\npub fn String.trim_end(value: String) -> fresh String\n\n\npub fn String.to_lowercase(value: String) -> fresh String\n\n\npub fn String.to_uppercase(value: String) -> fresh String\n\n\npub fn String.replace(\n    value: String,\n    from: String,\n    to: String,\n) -> fresh String\n\n\npub fn String.replace_first(\n    value: String,\n    from: String,\n    to: String,\n) -> fresh String\n\n\npub fn String.count(\n    value: String,\n    needle: String,\n) -> Int\n\n\npub fn String.pad_left(\n    value: String,\n    width: Int,\n    fill: String,\n) -> fresh String\n\n\npub fn String.pad_right(\n    value: String,\n    width: Int,\n    fill: String,\n) -> fresh String\n\n\npub fn String.reverse(value: String) -> fresh String\n\n\npub fn String.char_at(\n    value: String,\n    index: Int,\n) -> Option<Char>\n\n\npub fn String.starts_with(\n    value: String,\n    prefix: String,\n) -> Bool\n\n\npub fn String.ends_with(\n    value: String,\n    suffix: String,\n) -> Bool\n\n\npub fn String.contains(\n    value: String,\n    needle: String,\n) -> Bool\n\n\npub fn String.lines(value: String) -> fresh List<String>\n\n\npub fn String.chars(value: String) -> fresh List<Char>\n\n\npub fn String.join(\n    parts: List<String>,\n    separator: String,\n) -> fresh String\n\n\npub fn String.format(\n    template: String,\n    args: List<String>,\n) -> fresh String\n\n\npub fn String.strip_prefix(\n    value: String,\n    prefix: String,\n) -> Option<String>\n\n\npub fn String.before(\n    value: String,\n    delimiter: String,\n) -> Option<String>\n\n\npub fn String.after(\n    value: String,\n    delimiter: String,\n) -> Option<String>\n\n\npub fn String.split(\n    value: String,\n    delimiter: String,\n) -> fresh List<String>\n\n\npub fn String.slice(\n    value: String,\n    start: Int,\n    len: Int,\n) -> fresh String\n\n\npub fn String.index_of(\n    value: String,\n    needle: String,\n) -> Option<Int>\n\n\npub fn String.repeat(\n    value: String,\n    count: Int,\n) -> fresh String\n\n\npub fn String.parse_int(value: String) -> Option<Int>\n\n\npub fn String.parse_float(value: String) -> Option<Float>\n\n\npub fn String.view(\n    value: String,\n    start: Int,\n    len: Int,\n) -> StringView\n\n\npub fn StringView.slice(\n    value: StringView,\n    start: Int,\n    len: Int,\n) -> StringView\n\n\npub fn StringView.len(value: StringView) -> Int\n\n\npub fn StringView.is_empty(value: StringView) -> Bool\n\n\npub fn StringView.to_string(value: StringView) -> fresh String\n\n\npub fn StringView.starts_with(\n    value: StringView,\n    prefix: String,\n) -> Bool\n\n\npub fn StringView.contains(\n    value: StringView,\n    needle: String,\n) -> Bool\n\n\npub fn StringView.before(\n    value: StringView,\n    delimiter: String,\n) -> Option<StringView>\n\n\npub fn StringView.after(\n    value: StringView,\n    delimiter: String,\n) -> Option<StringView>\n\n\npub fn StringBuilder.new() -> fresh StringBuilder\n\npub fn StringBuilder.push(\n    builder: mut StringBuilder,\n    value: String,\n) -> Unit\n\npub fn StringBuilder.finish(builder: take StringBuilder) -> fresh String\n"
    },
    {
      "path": "stdlib/test/assert.rssi",
      "sha256": "6f6297e0eb808ea47662dcbb9b5bfdae12e5d5562563a618b5e753b6b848246f",
      "source": "pub fn Assert.equal(left: String, right: String) -> Unit\n\npub fn Assert.equal_int(left: Int, right: Int) -> Unit\n\npub fn Assert.equal_bool(left: Bool, right: Bool) -> Unit\n"
    },
    {
      "path": "stdlib/url/url.rssi",
      "sha256": "b969117cac8866420f8396bf13011a5c0a0e0f80cb185929d05ae8a6dec7410c",
      "source": "pub fn Url.from_string(value: String) -> fresh Url\n\npub fn Url.to_string(url: Url) -> fresh String\n"
    },
    {
      "path": "stdlib/weak/weak.rssi",
      "sha256": "2047bd7a6871d3e0897e51953058f1571a85a4bc12f5a0c818a9c79617189a17",
      "source": "pub fn Weak.from<T: Managed>(value: T) -> T\n\npub fn Weak.downgrade<T: Managed>(value: T) -> T\n\npub fn Weak.upgrade<T: Managed>(value: T) -> Option<T>\n"
    },
    {
      "path": "stdlib/yaml/yaml.rssi",
      "sha256": "4c0455d7850b659b1b345983420b2d978a1f7f3b6b9bedbb4b6b816351ed4d72",
      "source": "pub fn Yaml.parse(text: String) -> Result<fresh JsonValue, JsonError>\n"
    }
  ]
}