chore: import upstream snapshot with attribution

std/args.0

@@ -0,0 +1,44 @@
+fn __zero_std_args_has(index: usize) -> Bool {
+    let value: Maybe<String> = std.args.get(index)
+    return value.has
+}
+
+fn __zero_std_args_get_or(index: usize, fallback: String) -> String {
+    let value: Maybe<String> = std.args.get(index)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_args_find(name: String) -> Maybe<usize> {
+    var index: usize = 1
+    while index < std.args.len() {
+        let value: Maybe<String> = std.args.get(index)
+        if value.has && std.mem.eql(value.value, name) {
+            return index
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_args_value_after(name: String) -> Maybe<String> {
+    let index: Maybe<usize> = __zero_std_args_find(name)
+    if index.has {
+        let value: Maybe<String> = std.args.get(index.value + 1)
+        if value.has {
+            return value.value
+        }
+        return null
+    }
+    return null
+}
+
+fn __zero_std_args_parse_u32(index: usize) -> Maybe<u32> {
+    let value: Maybe<String> = std.args.get(index)
+    if value.has {
+        return std.parse.parseU32(value.value)
+    }
+    return null
+}

std/ascii.0

@@ -0,0 +1,61 @@
+fn __zero_std_ascii_is_digit(byte: u8) -> Bool {
+    return byte >= 48_u8 && byte <= 57_u8
+}
+
+fn __zero_std_ascii_is_lower(byte: u8) -> Bool {
+    return byte >= 97_u8 && byte <= 122_u8
+}
+
+fn __zero_std_ascii_is_upper(byte: u8) -> Bool {
+    return byte >= 65_u8 && byte <= 90_u8
+}
+
+fn __zero_std_ascii_is_alpha(byte: u8) -> Bool {
+    return __zero_std_ascii_is_lower(byte) || __zero_std_ascii_is_upper(byte)
+}
+
+fn __zero_std_ascii_is_alnum(byte: u8) -> Bool {
+    return __zero_std_ascii_is_alpha(byte) || __zero_std_ascii_is_digit(byte)
+}
+
+fn __zero_std_ascii_is_whitespace(byte: u8) -> Bool {
+    return byte == 32_u8 || byte == 9_u8 || byte == 10_u8 || byte == 13_u8
+}
+
+fn __zero_std_ascii_is_hex_digit(byte: u8) -> Bool {
+    return __zero_std_ascii_is_digit(byte) || (byte >= 65_u8 && byte <= 70_u8) || (byte >= 97_u8 && byte <= 102_u8)
+}
+
+fn __zero_std_ascii_to_lower(byte: u8) -> u8 {
+    if __zero_std_ascii_is_upper(byte) {
+        return byte + 32_u8
+    }
+    return byte
+}
+
+fn __zero_std_ascii_to_upper(byte: u8) -> u8 {
+    if __zero_std_ascii_is_lower(byte) {
+        return byte - 32_u8
+    }
+    return byte
+}
+
+fn __zero_std_ascii_digit_value(byte: u8) -> Maybe<u8> {
+    if __zero_std_ascii_is_digit(byte) {
+        return byte - 48_u8
+    }
+    return null
+}
+
+fn __zero_std_ascii_hex_value(byte: u8) -> Maybe<u8> {
+    if __zero_std_ascii_is_digit(byte) {
+        return byte - 48_u8
+    }
+    if byte >= 65_u8 && byte <= 70_u8 {
+        return byte - 55_u8
+    }
+    if byte >= 97_u8 && byte <= 102_u8 {
+        return byte - 87_u8
+    }
+    return null
+}

std/cli.0

@@ -0,0 +1,373 @@
+fn __zero_std_cli_arg_equals(index: usize, expected: String) -> Bool {
+    let value: Maybe<String> = std.args.get(index)
+    return value.has && std.mem.eql(value.value, expected)
+}
+
+fn __zero_std_cli_has_flag(name: String) -> Bool {
+    let index: Maybe<usize> = std.args.find(name)
+    return index.has
+}
+
+fn __zero_std_cli_option_value(name: String) -> Maybe<String> {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    return value
+}
+
+fn __zero_std_cli_option_value_or(name: String, fallback: String) -> String {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_option_u32(name: String) -> Maybe<u32> {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    if value.has {
+        return std.parse.parseU32(value.value)
+    }
+    return null
+}
+
+fn __zero_std_cli_option_bool(name: String) -> Maybe<Bool> {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    if value.has {
+        return std.parse.parseBool(value.value)
+    }
+    return null
+}
+
+fn __zero_std_cli_option_bool_or(name: String, fallback: Bool) -> Bool {
+    let value: Maybe<Bool> = __zero_std_cli_option_bool(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_option_i32(name: String) -> Maybe<i32> {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    if value.has {
+        return std.parse.parseI32(value.value)
+    }
+    return null
+}
+
+fn __zero_std_cli_option_i32_or(name: String, fallback: i32) -> i32 {
+    let value: Maybe<i32> = __zero_std_cli_option_i32(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_option_u32_or(name: String, fallback: u32) -> u32 {
+    let value: Maybe<u32> = __zero_std_cli_option_u32(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_option_usize(name: String) -> Maybe<usize> {
+    let value: Maybe<String> = std.args.valueAfter(name)
+    if value.has {
+        return std.parse.parseUsize(value.value)
+    }
+    return null
+}
+
+fn __zero_std_cli_option_usize_or(name: String, fallback: usize) -> usize {
+    let value: Maybe<usize> = __zero_std_cli_option_usize(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_success_exit_code() -> i32 {
+    return 0
+}
+
+fn __zero_std_cli_usage_exit_code() -> i32 {
+    return 2
+}
+
+fn __zero_std_cli_command() -> Maybe<String> {
+    let command: Maybe<String> = std.args.get(1)
+    return command
+}
+
+fn __zero_std_cli_command_or(fallback: String) -> String {
+    return std.args.getOr(1, fallback)
+}
+
+fn __zero_std_cli_command_equals(expected: String) -> Bool {
+    return __zero_std_cli_arg_equals(1, expected)
+}
+
+fn __zero_std_cli_arg_or(index: usize, fallback: String) -> String {
+    return std.args.getOr(index, fallback)
+}
+
+fn __zero_std_cli_arg_u32_or(index: usize, fallback: u32) -> u32 {
+    let value: Maybe<u32> = std.args.parseU32(index)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_cli_is_help(command: Span<u8>) -> Bool {
+    return std.mem.eql(command, "help") || std.mem.eql(command, "--help") || std.mem.eql(command, "-h")
+}
+
+fn __zero_std_cli_needs_help() -> Bool {
+    if !std.args.has(1) {
+        return true
+    }
+    return std.cli.argEquals(1, "help") || std.cli.argEquals(1, "--help") || std.cli.argEquals(1, "-h")
+}
+
+fn __zero_std_cli_command_in2(command: Span<u8>, first: Span<u8>, second: Span<u8>) -> Bool {
+    return std.mem.eql(command, first) || std.mem.eql(command, second)
+}
+
+fn __zero_std_cli_command_in3(command: Span<u8>, first: Span<u8>, second: Span<u8>, third: Span<u8>) -> Bool {
+    return std.mem.eql(command, first) || std.mem.eql(command, second) || std.mem.eql(command, third)
+}
+
+fn __zero_std_cli_write_span(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    if std.mem.len(bytes) > std.mem.len(buffer) - offset {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        buffer[offset + index] = bytes[index]
+        index = index + 1
+    }
+    return offset + std.mem.len(bytes)
+}
+
+fn __zero_std_cli_format_usage(buffer: MutSpan<u8>, program: Span<u8>, syntax: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "usage: ")
+    if !prefix.has {
+        return null
+    }
+    offset = prefix.value
+    let wrote_program: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, program)
+    if !wrote_program.has {
+        return null
+    }
+    offset = wrote_program.value
+    let space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
+    if !space.has {
+        return null
+    }
+    offset = space.value
+    let wrote_syntax: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, syntax)
+    if wrote_syntax.has {
+        return buffer[..wrote_syntax.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_command(buffer: MutSpan<u8>, name: Span<u8>, syntax: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let indent: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "  ")
+    if !indent.has {
+        return null
+    }
+    offset = indent.value
+    let wrote_name: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, name)
+    if !wrote_name.has {
+        return null
+    }
+    offset = wrote_name.value
+    if std.mem.len(syntax) > 0 {
+        let name_space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
+        if !name_space.has {
+            return null
+        }
+        offset = name_space.value
+        let wrote_syntax: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, syntax)
+        if !wrote_syntax.has {
+            return null
+        }
+        offset = wrote_syntax.value
+    }
+    let gap: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "  ")
+    if !gap.has {
+        return null
+    }
+    offset = gap.value
+    let wrote_summary: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, summary)
+    if wrote_summary.has {
+        return buffer[..wrote_summary.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_option(buffer: MutSpan<u8>, name: Span<u8>, value_name: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
+    return __zero_std_cli_format_command(buffer, name, value_name, summary)
+}
+
+fn __zero_std_cli_format_error(buffer: MutSpan<u8>, message: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: ")
+    if !prefix.has {
+        return null
+    }
+    offset = prefix.value
+    let wrote_message: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, message)
+    if wrote_message.has {
+        return buffer[..wrote_message.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_unknown_command(buffer: MutSpan<u8>, command: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: unknown command: ")
+    if !prefix.has {
+        return null
+    }
+    offset = prefix.value
+    let wrote_command: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, command)
+    if wrote_command.has {
+        return buffer[..wrote_command.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_missing_operand(buffer: MutSpan<u8>, operand: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: missing operand: ")
+    if !prefix.has {
+        return null
+    }
+    offset = prefix.value
+    let wrote_operand: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, operand)
+    if wrote_operand.has {
+        return buffer[..wrote_operand.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_invalid_option(buffer: MutSpan<u8>, option: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: invalid option: ")
+    if !prefix.has {
+        return null
+    }
+    offset = prefix.value
+    let wrote_option: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, option)
+    if wrote_option.has {
+        return buffer[..wrote_option.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_section(buffer: MutSpan<u8>, title: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let wrote_title: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, title)
+    if !wrote_title.has {
+        return null
+    }
+    offset = wrote_title.value
+    let colon: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, ":\n")
+    if colon.has {
+        return buffer[..colon.value]
+    }
+    return null
+}
+
+fn __zero_std_cli_format_help_row_with_width(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>, width: usize) -> Maybe<Span<u8>> {
+    return __zero_std_cli_format_help_row_custom(buffer, label, summary, 2_usize, width)
+}
+
+fn __zero_std_cli_format_help(buffer: MutSpan<u8>, usage: Span<u8>, description: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let usage_label: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "Usage: ")
+    if !usage_label.has {
+        return null
+    }
+    offset = usage_label.value
+    let wrote_usage: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, usage)
+    if !wrote_usage.has {
+        return null
+    }
+    offset = wrote_usage.value
+    let usage_newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
+    if !usage_newline.has {
+        return null
+    }
+    offset = usage_newline.value
+    if std.mem.len(description) > 0_usize {
+        let description_gap: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
+        if !description_gap.has {
+            return null
+        }
+        offset = description_gap.value
+        let wrote_description: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, description)
+        if !wrote_description.has {
+            return null
+        }
+        offset = wrote_description.value
+        let description_newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
+        if !description_newline.has {
+            return null
+        }
+        offset = description_newline.value
+    }
+    return buffer[..offset]
+}
+
+fn __zero_std_cli_format_help_row(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
+    return __zero_std_cli_format_help_row_custom(buffer, label, summary, 2_usize, 17_usize)
+}
+
+fn __zero_std_cli_format_help_row_custom(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>, indent: usize, width: usize) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    var indent_index: usize = 0
+    while indent_index < indent {
+        let indent_space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
+        if !indent_space.has {
+            return null
+        }
+        offset = indent_space.value
+        indent_index = indent_index + 1_usize
+    }
+    let wrote_label: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, label)
+    if !wrote_label.has {
+        return null
+    }
+    offset = wrote_label.value
+    var spaces: usize = 2_usize
+    if std.mem.len(label) < width {
+        spaces = spaces + (width - std.mem.len(label))
+    }
+    var index: usize = 0
+    while index < spaces {
+        let space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
+        if !space.has {
+            return null
+        }
+        offset = space.value
+        index = index + 1_usize
+    }
+    let wrote_summary: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, summary)
+    if !wrote_summary.has {
+        return null
+    }
+    offset = wrote_summary.value
+    let newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
+    if newline.has {
+        return buffer[..newline.value]
+    }
+    return null
+}

std/collections.0

@@ -0,0 +1,972 @@
+type FixedSet<T: Type> {
+    items: MutSpan<T>,
+    len: usize,
+}
+
+type FixedDeque<T: Type> {
+    items: MutSpan<T>,
+    len: usize,
+}
+
+type FixedRingBuffer<T: Type> {
+    items: MutSpan<T>,
+    head: usize,
+    len: usize,
+}
+
+type FixedMap<K: Type, V: Type> {
+    keys: MutSpan<K>,
+    values: MutSpan<V>,
+    len: usize,
+}
+
+fn __zero_std_collections_fixed_set<T: Type>(items: MutSpan<T>, len: usize) -> FixedSet<T> {
+    var live_len: usize = len
+    if live_len > std.mem.len(items) {
+        live_len = std.mem.len(items)
+    }
+    return FixedSet { items: items, len: live_len }
+}
+
+fn __zero_std_collections_fixed_set_len<T: Type>(fixed_set: ref<FixedSet<T>>) -> usize {
+    return fixed_set.len
+}
+
+fn __zero_std_collections_fixed_set_view<T: Type>(fixed_set: ref<FixedSet<T>>) -> Span<T> {
+    var end: usize = fixed_set.len
+    if end > std.mem.len(fixed_set.items) {
+        end = std.mem.len(fixed_set.items)
+    }
+    return fixed_set.items[..end]
+}
+
+fn __zero_std_collections_fixed_set_contains<T: Type>(fixed_set: ref<FixedSet<T>>, value: T) -> Bool {
+    let live: Span<T> = __zero_std_collections_fixed_set_view(fixed_set)
+    var index: usize = 0
+    while index < std.mem.len(live) {
+        if live[index] == value {
+            return true
+        }
+        index = index + 1
+    }
+    return false
+}
+
+fn __zero_std_collections_fixed_set_insert<T: Type>(fixed_set: mutref<FixedSet<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = fixed_set.items
+    let next_len: usize = __zero_std_collections_set_insert(items, fixed_set.len, value)
+    if next_len != fixed_set.len {
+        fixed_set.len = next_len
+        return true
+    }
+    return false
+}
+
+fn __zero_std_collections_fixed_set_remove<T: Type>(fixed_set: mutref<FixedSet<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = fixed_set.items
+    let next_len: usize = __zero_std_collections_set_remove(items, fixed_set.len, value)
+    if next_len != fixed_set.len {
+        fixed_set.len = next_len
+        return true
+    }
+    return false
+}
+
+fn __zero_std_collections_fixed_set_clear<T: Type>(fixed_set: mutref<FixedSet<T>>) -> usize {
+    fixed_set.len = 0
+    return fixed_set.len
+}
+
+fn __zero_std_collections_fixed_set_truncate<T: Type>(fixed_set: mutref<FixedSet<T>>, new_len: usize) -> usize {
+    var live_len: usize = fixed_set.len
+    if live_len > std.mem.len(fixed_set.items) {
+        live_len = std.mem.len(fixed_set.items)
+    }
+    if new_len < live_len {
+        live_len = new_len
+    }
+    fixed_set.len = live_len
+    return fixed_set.len
+}
+
+fn __zero_std_collections_fixed_set_remaining<T: Type>(fixed_set: ref<FixedSet<T>>) -> usize {
+    let capacity: usize = std.mem.len(fixed_set.items)
+    if fixed_set.len >= capacity {
+        return 0
+    }
+    return capacity - fixed_set.len
+}
+
+fn __zero_std_collections_fixed_set_is_full<T: Type>(fixed_set: ref<FixedSet<T>>) -> Bool {
+    return __zero_std_collections_fixed_set_remaining(fixed_set) == 0
+}
+
+fn __zero_std_collections_fixed_deque<T: Type>(items: MutSpan<T>, len: usize) -> FixedDeque<T> {
+    var live_len: usize = len
+    if live_len > std.mem.len(items) {
+        live_len = std.mem.len(items)
+    }
+    return FixedDeque { items: items, len: live_len }
+}
+
+fn __zero_std_collections_fixed_deque_len<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> usize {
+    return fixed_deque.len
+}
+
+fn __zero_std_collections_fixed_deque_view<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> Span<T> {
+    var end: usize = fixed_deque.len
+    if end > std.mem.len(fixed_deque.items) {
+        end = std.mem.len(fixed_deque.items)
+    }
+    return fixed_deque.items[..end]
+}
+
+fn __zero_std_collections_fixed_deque_front<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> Maybe<T> {
+    let live: Span<T> = __zero_std_collections_fixed_deque_view(fixed_deque)
+    if std.mem.len(live) == 0 {
+        return null
+    }
+    return live[0]
+}
+
+fn __zero_std_collections_fixed_deque_back<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> Maybe<T> {
+    let live: Span<T> = __zero_std_collections_fixed_deque_view(fixed_deque)
+    let live_len: usize = std.mem.len(live)
+    if live_len == 0 {
+        return null
+    }
+    return live[live_len - 1]
+}
+
+fn __zero_std_collections_fixed_deque_push_back<T: Type>(fixed_deque: mutref<FixedDeque<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = fixed_deque.items
+    let next_len: usize = __zero_std_collections_deque_push_back(items, fixed_deque.len, value)
+    if next_len != fixed_deque.len {
+        fixed_deque.len = next_len
+        return true
+    }
+    return false
+}
+
+fn __zero_std_collections_fixed_deque_push_front<T: Type>(fixed_deque: mutref<FixedDeque<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = fixed_deque.items
+    let next_len: usize = __zero_std_collections_deque_push_front(items, fixed_deque.len, value)
+    if next_len != fixed_deque.len {
+        fixed_deque.len = next_len
+        return true
+    }
+    return false
+}
+
+fn __zero_std_collections_fixed_deque_pop_back<T: Type>(fixed_deque: mutref<FixedDeque<T>>) -> Maybe<T> {
+    var live_len: usize = fixed_deque.len
+    if live_len > std.mem.len(fixed_deque.items) {
+        live_len = std.mem.len(fixed_deque.items)
+    }
+    if live_len == 0 {
+        return null
+    }
+    let result: T = fixed_deque.items[live_len - 1]
+    fixed_deque.len = live_len - 1
+    return result
+}
+
+fn __zero_std_collections_fixed_deque_pop_front<T: Type>(fixed_deque: mutref<FixedDeque<T>>) -> Maybe<T> {
+    let items: MutSpan<T> = fixed_deque.items
+    var live_len: usize = fixed_deque.len
+    if live_len > std.mem.len(items) {
+        live_len = std.mem.len(items)
+    }
+    if live_len == 0 {
+        return null
+    }
+    let result: T = items[0]
+    fixed_deque.len = __zero_std_collections_deque_pop_front(items, live_len)
+    return result
+}
+
+fn __zero_std_collections_fixed_deque_clear<T: Type>(fixed_deque: mutref<FixedDeque<T>>) -> usize {
+    fixed_deque.len = 0
+    return fixed_deque.len
+}
+
+fn __zero_std_collections_fixed_deque_truncate<T: Type>(fixed_deque: mutref<FixedDeque<T>>, new_len: usize) -> usize {
+    var live_len: usize = fixed_deque.len
+    if live_len > std.mem.len(fixed_deque.items) {
+        live_len = std.mem.len(fixed_deque.items)
+    }
+    if new_len < live_len {
+        live_len = new_len
+    }
+    fixed_deque.len = live_len
+    return fixed_deque.len
+}
+
+fn __zero_std_collections_fixed_deque_remaining<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> usize {
+    let capacity: usize = std.mem.len(fixed_deque.items)
+    if fixed_deque.len >= capacity {
+        return 0
+    }
+    return capacity - fixed_deque.len
+}
+
+fn __zero_std_collections_fixed_deque_is_full<T: Type>(fixed_deque: ref<FixedDeque<T>>) -> Bool {
+    return __zero_std_collections_fixed_deque_remaining(fixed_deque) == 0
+}
+
+fn __zero_std_collections_fixed_ring_buffer<T: Type>(items: MutSpan<T>, head: usize, len: usize) -> FixedRingBuffer<T> {
+    let capacity: usize = std.mem.len(items)
+    var live_head: usize = 0
+    if capacity != 0 {
+        live_head = head % capacity
+    }
+    var live_len: usize = len
+    if live_len > capacity {
+        live_len = capacity
+    }
+    if live_len == 0 {
+        live_head = 0
+    }
+    return FixedRingBuffer { items: items, head: live_head, len: live_len }
+}
+
+fn __zero_std_collections_fixed_ring_buffer_len<T: Type>(ring: ref<FixedRingBuffer<T>>) -> usize {
+    return ring.len
+}
+
+fn __zero_std_collections_fixed_ring_buffer_capacity<T: Type>(ring: ref<FixedRingBuffer<T>>) -> usize {
+    return std.mem.len(ring.items)
+}
+
+fn __zero_std_collections_fixed_ring_buffer_remaining<T: Type>(ring: ref<FixedRingBuffer<T>>) -> usize {
+    let capacity: usize = std.mem.len(ring.items)
+    if ring.len >= capacity {
+        return 0
+    }
+    return capacity - ring.len
+}
+
+fn __zero_std_collections_fixed_ring_buffer_is_full<T: Type>(ring: ref<FixedRingBuffer<T>>) -> Bool {
+    return __zero_std_collections_fixed_ring_buffer_remaining(ring) == 0
+}
+
+fn __zero_std_collections_fixed_ring_buffer_index<T: Type>(ring: ref<FixedRingBuffer<T>>, offset: usize) -> usize {
+    let capacity: usize = std.mem.len(ring.items)
+    if capacity == 0 {
+        return 0
+    }
+    return (ring.head + offset) % capacity
+}
+
+fn __zero_std_collections_fixed_ring_buffer_get<T: Type>(ring: ref<FixedRingBuffer<T>>, index: usize) -> Maybe<T> {
+    if index >= ring.len || ring.len > std.mem.len(ring.items) {
+        return null
+    }
+    let storage_index: usize = __zero_std_collections_fixed_ring_buffer_index(ring, index)
+    return ring.items[storage_index]
+}
+
+fn __zero_std_collections_fixed_ring_buffer_front<T: Type>(ring: ref<FixedRingBuffer<T>>) -> Maybe<T> {
+    return __zero_std_collections_fixed_ring_buffer_get(ring, 0_usize)
+}
+
+fn __zero_std_collections_fixed_ring_buffer_back<T: Type>(ring: ref<FixedRingBuffer<T>>) -> Maybe<T> {
+    if ring.len == 0 {
+        return null
+    }
+    return __zero_std_collections_fixed_ring_buffer_get(ring, ring.len - 1)
+}
+
+fn __zero_std_collections_fixed_ring_buffer_push_back<T: Type>(ring: mutref<FixedRingBuffer<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = ring.items
+    let capacity: usize = std.mem.len(items)
+    if capacity == 0 || ring.len >= capacity {
+        return false
+    }
+    ring.head = ring.head % capacity
+    let storage_index: usize = (ring.head + ring.len) % capacity
+    items[storage_index] = value
+    ring.len = ring.len + 1
+    return true
+}
+
+fn __zero_std_collections_fixed_ring_buffer_push_front<T: Type>(ring: mutref<FixedRingBuffer<T>>, value: T) -> Bool {
+    let items: MutSpan<T> = ring.items
+    let capacity: usize = std.mem.len(items)
+    if capacity == 0 || ring.len >= capacity {
+        return false
+    }
+    ring.head = ring.head % capacity
+    if ring.head == 0 {
+        ring.head = capacity - 1
+    } else {
+        ring.head = ring.head - 1
+    }
+    items[ring.head] = value
+    ring.len = ring.len + 1
+    return true
+}
+
+fn __zero_std_collections_fixed_ring_buffer_pop_back<T: Type>(ring: mutref<FixedRingBuffer<T>>) -> Maybe<T> {
+    let capacity: usize = std.mem.len(ring.items)
+    if capacity == 0 || ring.len == 0 || ring.len > capacity {
+        return null
+    }
+    ring.head = ring.head % capacity
+    let storage_index: usize = (ring.head + ring.len - 1) % capacity
+    let result: T = ring.items[storage_index]
+    ring.len = ring.len - 1
+    if ring.len == 0 {
+        ring.head = 0
+    }
+    return result
+}
+
+fn __zero_std_collections_fixed_ring_buffer_pop_front<T: Type>(ring: mutref<FixedRingBuffer<T>>) -> Maybe<T> {
+    let capacity: usize = std.mem.len(ring.items)
+    if capacity == 0 || ring.len == 0 || ring.len > capacity {
+        return null
+    }
+    ring.head = ring.head % capacity
+    let result: T = ring.items[ring.head]
+    ring.len = ring.len - 1
+    if ring.len == 0 {
+        ring.head = 0
+    } else {
+        ring.head = (ring.head + 1) % capacity
+    }
+    return result
+}
+
+fn __zero_std_collections_fixed_ring_buffer_clear<T: Type>(ring: mutref<FixedRingBuffer<T>>) -> usize {
+    ring.head = 0
+    ring.len = 0
+    return ring.len
+}
+
+fn __zero_std_collections_fixed_ring_buffer_truncate<T: Type>(ring: mutref<FixedRingBuffer<T>>, new_len: usize) -> usize {
+    let capacity: usize = std.mem.len(ring.items)
+    if capacity == 0 {
+        ring.head = 0
+    } else {
+        ring.head = ring.head % capacity
+    }
+    var live_len: usize = ring.len
+    if live_len > capacity {
+        live_len = capacity
+    }
+    if new_len < live_len {
+        live_len = new_len
+    }
+    ring.len = live_len
+    if ring.len == 0 {
+        ring.head = 0
+    }
+    return ring.len
+}
+
+fn __zero_std_collections_fixed_map<K: Type, V: Type>(keys: MutSpan<K>, values: MutSpan<V>, len: usize) -> FixedMap<K, V> {
+    var live_len: usize = len
+    if live_len > std.mem.len(keys) {
+        live_len = std.mem.len(keys)
+    }
+    if live_len > std.mem.len(values) {
+        live_len = std.mem.len(values)
+    }
+    return FixedMap { keys: keys, values: values, len: live_len }
+}
+
+fn __zero_std_collections_fixed_map_len<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>) -> usize {
+    return fixed_map.len
+}
+
+fn __zero_std_collections_fixed_map_keys<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>) -> Span<K> {
+    var end: usize = fixed_map.len
+    if end > std.mem.len(fixed_map.keys) {
+        end = std.mem.len(fixed_map.keys)
+    }
+    return fixed_map.keys[..end]
+}
+
+fn __zero_std_collections_fixed_map_values<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>) -> Span<V> {
+    var end: usize = fixed_map.len
+    if end > std.mem.len(fixed_map.keys) {
+        end = std.mem.len(fixed_map.keys)
+    }
+    if end > std.mem.len(fixed_map.values) {
+        end = std.mem.len(fixed_map.values)
+    }
+    return fixed_map.values[..end]
+}
+
+fn __zero_std_collections_fixed_map_get<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>, key: K) -> Maybe<V> {
+    let keys: Span<K> = __zero_std_collections_fixed_map_keys(fixed_map)
+    let values: Span<V> = __zero_std_collections_fixed_map_values(fixed_map)
+    return __zero_std_collections_map_get(keys, values, std.mem.len(keys), key)
+}
+
+fn __zero_std_collections_fixed_map_contains<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>, key: K) -> Bool {
+    let keys: Span<K> = __zero_std_collections_fixed_map_keys(fixed_map)
+    return __zero_std_collections_map_contains(keys, std.mem.len(keys), key)
+}
+
+fn __zero_std_collections_fixed_map_index<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>, key: K) -> usize {
+    let keys: Span<K> = __zero_std_collections_fixed_map_keys(fixed_map)
+    return __zero_std_collections_map_index(keys, std.mem.len(keys), key)
+}
+
+fn __zero_std_collections_fixed_map_put<K: Type, V: Type>(fixed_map: mutref<FixedMap<K, V>>, key: K, value: V) -> Bool {
+    let keys: MutSpan<K> = fixed_map.keys
+    let values: MutSpan<V> = fixed_map.values
+    if fixed_map.len > std.mem.len(keys) || fixed_map.len > std.mem.len(values) {
+        return false
+    }
+    var index: usize = 0
+    while index < fixed_map.len {
+        if keys[index] == key {
+            values[index] = value
+            return true
+        }
+        index = index + 1
+    }
+    if fixed_map.len >= std.mem.len(keys) || fixed_map.len >= std.mem.len(values) {
+        return false
+    }
+    keys[fixed_map.len] = key
+    values[fixed_map.len] = value
+    fixed_map.len = fixed_map.len + 1
+    return true
+}
+
+fn __zero_std_collections_fixed_map_remove<K: Type, V: Type>(fixed_map: mutref<FixedMap<K, V>>, key: K) -> Bool {
+    let keys: MutSpan<K> = fixed_map.keys
+    let values: MutSpan<V> = fixed_map.values
+    if fixed_map.len == 0 || fixed_map.len > std.mem.len(keys) || fixed_map.len > std.mem.len(values) {
+        return false
+    }
+    var index: usize = 0
+    while index < fixed_map.len {
+        if keys[index] == key {
+            break
+        }
+        index = index + 1
+    }
+    if index >= fixed_map.len {
+        return false
+    }
+    let next_len: usize = fixed_map.len - 1
+    if index != next_len {
+        keys[index] = keys[next_len]
+        values[index] = values[next_len]
+    }
+    fixed_map.len = next_len
+    return true
+}
+
+fn __zero_std_collections_fixed_map_clear<K: Type, V: Type>(fixed_map: mutref<FixedMap<K, V>>) -> usize {
+    fixed_map.len = 0
+    return fixed_map.len
+}
+
+fn __zero_std_collections_fixed_map_truncate<K: Type, V: Type>(fixed_map: mutref<FixedMap<K, V>>, new_len: usize) -> usize {
+    var capacity: usize = std.mem.len(fixed_map.keys)
+    if capacity > std.mem.len(fixed_map.values) {
+        capacity = std.mem.len(fixed_map.values)
+    }
+    var live_len: usize = fixed_map.len
+    if live_len > capacity {
+        live_len = capacity
+    }
+    if new_len < live_len {
+        live_len = new_len
+    }
+    fixed_map.len = live_len
+    return fixed_map.len
+}
+
+fn __zero_std_collections_fixed_map_remaining<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>) -> usize {
+    var capacity: usize = std.mem.len(fixed_map.keys)
+    if capacity > std.mem.len(fixed_map.values) {
+        capacity = std.mem.len(fixed_map.values)
+    }
+    if fixed_map.len >= capacity {
+        return 0
+    }
+    return capacity - fixed_map.len
+}
+
+fn __zero_std_collections_fixed_map_is_full<K: Type, V: Type>(fixed_map: ref<FixedMap<K, V>>) -> Bool {
+    return __zero_std_collections_fixed_map_remaining(fixed_map) == 0
+}
+
+fn __zero_std_collections_push<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    if len >= std.mem.len(items) {
+        return len
+    }
+    items[len] = value
+    return len + 1
+}
+
+fn __zero_std_collections_append<T: Type>(items: MutSpan<T>, len: usize, values: Span<T>) -> usize {
+    let capacity: usize = std.mem.len(items)
+    let value_count: usize = std.mem.len(values)
+    if len > capacity || value_count > capacity - len {
+        return len
+    }
+    var index: usize = 0
+    while index < value_count {
+        items[len + index] = values[index]
+        index = index + 1
+    }
+    return len + value_count
+}
+
+fn __zero_std_collections_view<T: Type>(items: Span<T>, len: usize) -> Span<T> {
+    var end: usize = len
+    if end > std.mem.len(items) {
+        end = std.mem.len(items)
+    }
+    return items[..end]
+}
+
+fn __zero_std_collections_contains<T: Type>(items: Span<T>, len: usize, needle: T) -> Bool {
+    let view: Span<T> = __zero_std_collections_view(items, len)
+    var index: usize = 0
+    while index < std.mem.len(view) {
+        if view[index] == needle {
+            return true
+        }
+        index = index + 1
+    }
+    return false
+}
+
+fn __zero_std_collections_count<T: Type>(items: Span<T>, len: usize, needle: T) -> usize {
+    let view: Span<T> = __zero_std_collections_view(items, len)
+    var index: usize = 0
+    var total: usize = 0
+    while index < std.mem.len(view) {
+        if view[index] == needle {
+            total = total + 1
+        }
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_collections_remove_swap<T: Type>(items: MutSpan<T>, len: usize, index: usize) -> usize {
+    if len == 0 || len > std.mem.len(items) || index >= len {
+        return len
+    }
+    let next_len: usize = len - 1
+    if index != next_len {
+        items[index] = items[next_len]
+    }
+    return next_len
+}
+
+fn __zero_std_collections_move_to_front<T: Type>(items: MutSpan<T>, len: usize, index: usize) -> usize {
+    if len > std.mem.len(items) || index == 0 || index >= len {
+        return len
+    }
+    let chosen: T = items[index]
+    var cursor: usize = index
+    while cursor > 0 {
+        items[cursor] = items[cursor - 1]
+        cursor = cursor - 1
+    }
+    items[0] = chosen
+    return len
+}
+
+fn __zero_std_collections_remaining<T: Type>(items: Span<T>, len: usize) -> usize {
+    let capacity: usize = std.mem.len(items)
+    if len >= capacity {
+        return 0
+    }
+    return capacity - len
+}
+
+fn __zero_std_collections_is_full<T: Type>(items: Span<T>, len: usize) -> Bool {
+    return __zero_std_collections_remaining(items, len) == 0
+}
+
+fn __zero_std_collections_insert_unique<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    if len > std.mem.len(items) {
+        return len
+    }
+    var index: usize = 0
+    while index < len {
+        if items[index] == value {
+            return len
+        }
+        index = index + 1
+    }
+    if len >= std.mem.len(items) {
+        return len
+    }
+    items[len] = value
+    return len + 1
+}
+
+fn __zero_std_collections_remove_value<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    if len > std.mem.len(items) {
+        return len
+    }
+    var index: usize = 0
+    while index < len {
+        if items[index] == value {
+            return __zero_std_collections_remove_swap(items, len, index)
+        }
+        index = index + 1
+    }
+    return len
+}
+
+fn __zero_std_collections_map_index<K: Type>(keys: Span<K>, len: usize, key: K) -> usize {
+    let live: Span<K> = __zero_std_collections_view(keys, len)
+    var index: usize = 0
+    while index < std.mem.len(live) {
+        if live[index] == key {
+            return index
+        }
+        index = index + 1
+    }
+    return std.mem.len(live)
+}
+
+fn __zero_std_collections_map_get<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize, key: K) -> Maybe<V> {
+    var live_len: usize = len
+    if live_len > std.mem.len(keys) {
+        live_len = std.mem.len(keys)
+    }
+    if live_len > std.mem.len(values) {
+        live_len = std.mem.len(values)
+    }
+    let index: usize = __zero_std_collections_map_index(keys, live_len, key)
+    if index < live_len {
+        return values[index]
+    }
+    return null
+}
+
+fn __zero_std_collections_map_remove<K: Type, V: Type>(keys: MutSpan<K>, values: MutSpan<V>, len: usize, key: K) -> usize {
+    if len == 0 || len > std.mem.len(keys) || len > std.mem.len(values) {
+        return len
+    }
+    var index: usize = 0
+    while index < len {
+        if keys[index] == key {
+            break
+        }
+        index = index + 1
+    }
+    if index >= len {
+        return len
+    }
+    let next_len: usize = len - 1
+    if index != next_len {
+        keys[index] = keys[next_len]
+        values[index] = values[next_len]
+    }
+    return next_len
+}
+
+fn __zero_std_collections_map_put<K: Type, V: Type>(keys: MutSpan<K>, values: MutSpan<V>, len: usize, key: K, value: V) -> usize {
+    if len > std.mem.len(keys) || len > std.mem.len(values) {
+        return len
+    }
+    var index: usize = 0
+    while index < len {
+        if keys[index] == key {
+            break
+        }
+        index = index + 1
+    }
+    if index < len {
+        values[index] = value
+        return len
+    }
+    if len >= std.mem.len(keys) || len >= std.mem.len(values) {
+        return len
+    }
+    keys[len] = key
+    values[len] = value
+    return len + 1
+}
+
+fn __zero_std_collections_map_contains<K: Type>(keys: Span<K>, len: usize, key: K) -> Bool {
+    let live: Span<K> = __zero_std_collections_view(keys, len)
+    let index: usize = __zero_std_collections_map_index(live, std.mem.len(live), key)
+    return index < std.mem.len(live)
+}
+
+fn __zero_std_collections_set_contains<T: Type>(items: Span<T>, len: usize, value: T) -> Bool {
+    return __zero_std_collections_contains(items, len, value)
+}
+
+fn __zero_std_collections_set_insert<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    return __zero_std_collections_insert_unique(items, len, value)
+}
+
+fn __zero_std_collections_set_remove<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    return __zero_std_collections_remove_value(items, len, value)
+}
+
+fn __zero_std_collections_clear<T: Type>(items: Span<T>, len: usize) -> usize {
+    return 0
+}
+
+fn __zero_std_collections_truncate<T: Type>(items: Span<T>, len: usize, new_len: usize) -> usize {
+    let live: Span<T> = __zero_std_collections_view(items, len)
+    let live_len: usize = std.mem.len(live)
+    if new_len < live_len {
+        return new_len
+    }
+    return live_len
+}
+
+fn __zero_std_collections_first<T: Type>(items: Span<T>, len: usize) -> Maybe<T> {
+    let live: Span<T> = __zero_std_collections_view(items, len)
+    if std.mem.len(live) == 0 {
+        return null
+    }
+    return live[0]
+}
+
+fn __zero_std_collections_last<T: Type>(items: Span<T>, len: usize) -> Maybe<T> {
+    let live: Span<T> = __zero_std_collections_view(items, len)
+    let live_len: usize = std.mem.len(live)
+    if live_len == 0 {
+        return null
+    }
+    return live[live_len - 1]
+}
+
+fn __zero_std_collections_pop<T: Type>(items: Span<T>, len: usize) -> usize {
+    let live: Span<T> = __zero_std_collections_view(items, len)
+    let live_len: usize = std.mem.len(live)
+    if live_len == 0 {
+        return 0
+    }
+    return live_len - 1
+}
+
+fn __zero_std_collections_insert_at<T: Type>(items: MutSpan<T>, len: usize, index: usize, value: T) -> usize {
+    let capacity: usize = std.mem.len(items)
+    if len >= capacity || index > len {
+        return len
+    }
+    var cursor: usize = len
+    while cursor > index {
+        items[cursor] = items[cursor - 1]
+        cursor = cursor - 1
+    }
+    items[index] = value
+    return len + 1
+}
+
+fn __zero_std_collections_remove_at<T: Type>(items: MutSpan<T>, len: usize, index: usize) -> usize {
+    if len == 0 || len > std.mem.len(items) || index >= len {
+        return len
+    }
+    let next_len: usize = len - 1
+    var cursor: usize = index
+    while cursor < next_len {
+        items[cursor] = items[cursor + 1]
+        cursor = cursor + 1
+    }
+    return next_len
+}
+
+fn __zero_std_collections_set_view<T: Type>(items: Span<T>, len: usize) -> Span<T> {
+    return __zero_std_collections_view(items, len)
+}
+
+fn __zero_std_collections_map_keys<K: Type>(keys: Span<K>, len: usize) -> Span<K> {
+    return __zero_std_collections_view(keys, len)
+}
+
+fn __zero_std_collections_map_values<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize) -> Span<V> {
+    var live_len: usize = len
+    if live_len > std.mem.len(keys) {
+        live_len = std.mem.len(keys)
+    }
+    if live_len > std.mem.len(values) {
+        live_len = std.mem.len(values)
+    }
+    return values[..live_len]
+}
+
+fn __zero_std_collections_set_clear<T: Type>(items: Span<T>, len: usize) -> usize {
+    return __zero_std_collections_clear(items, len)
+}
+
+fn __zero_std_collections_set_truncate<T: Type>(items: Span<T>, len: usize, new_len: usize) -> usize {
+    return __zero_std_collections_truncate(items, len, new_len)
+}
+
+fn __zero_std_collections_set_remaining<T: Type>(items: Span<T>, len: usize) -> usize {
+    return __zero_std_collections_remaining(items, len)
+}
+
+fn __zero_std_collections_set_is_full<T: Type>(items: Span<T>, len: usize) -> Bool {
+    return __zero_std_collections_is_full(items, len)
+}
+
+fn __zero_std_collections_map_clear<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize) -> usize {
+    return 0
+}
+
+fn __zero_std_collections_map_truncate<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize, new_len: usize) -> usize {
+    var live_len: usize = len
+    if live_len > std.mem.len(keys) {
+        live_len = std.mem.len(keys)
+    }
+    if live_len > std.mem.len(values) {
+        live_len = std.mem.len(values)
+    }
+    if new_len < live_len {
+        return new_len
+    }
+    return live_len
+}
+
+fn __zero_std_collections_map_remaining<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize) -> usize {
+    var capacity: usize = std.mem.len(keys)
+    if std.mem.len(values) < capacity {
+        capacity = std.mem.len(values)
+    }
+    if len >= capacity {
+        return 0
+    }
+    return capacity - len
+}
+
+fn __zero_std_collections_map_is_full<K: Type, V: Type>(keys: Span<K>, values: Span<V>, len: usize) -> Bool {
+    return __zero_std_collections_map_remaining(keys, values, len) == 0
+}
+
+fn __zero_std_collections_deque_push_back<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    return __zero_std_collections_push(items, len, value)
+}
+
+fn __zero_std_collections_deque_push_front<T: Type>(items: MutSpan<T>, len: usize, value: T) -> usize {
+    return __zero_std_collections_insert_at(items, len, 0_usize, value)
+}
+
+fn __zero_std_collections_deque_pop_back<T: Type>(items: Span<T>, len: usize) -> usize {
+    return __zero_std_collections_pop(items, len)
+}
+
+fn __zero_std_collections_deque_pop_front<T: Type>(items: MutSpan<T>, len: usize) -> usize {
+    return __zero_std_collections_remove_at(items, len, 0_usize)
+}
+
+fn __zero_std_collections_deque_front<T: Type>(items: Span<T>, len: usize) -> Maybe<T> {
+    return __zero_std_collections_first(items, len)
+}
+
+fn __zero_std_collections_deque_back<T: Type>(items: Span<T>, len: usize) -> Maybe<T> {
+    return __zero_std_collections_last(items, len)
+}
+
+fn __zero_std_collections_replace_at<T: Type>(items: MutSpan<T>, len: usize, index: usize, value: T) -> Bool {
+    if len > std.mem.len(items) || index >= len {
+        return false
+    }
+    items[index] = value
+    return true
+}
+
+fn __zero_std_collections_swap_at<T: Type>(items: MutSpan<T>, len: usize, left: usize, right: usize) -> Bool {
+    if len > std.mem.len(items) || left >= len || right >= len {
+        return false
+    }
+    if left != right {
+        let temporary: T = items[left]
+        items[left] = items[right]
+        items[right] = temporary
+    }
+    return true
+}
+
+fn __zero_std_collections_fill<T: Type>(items: MutSpan<T>, len: usize, value: T) -> Bool {
+    if len > std.mem.len(items) {
+        return false
+    }
+    var index: usize = 0
+    while index < len {
+        items[index] = value
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_collections_reverse<T: Type>(items: MutSpan<T>, len: usize) -> Bool {
+    if len > std.mem.len(items) {
+        return false
+    }
+    var left: usize = 0
+    var right: usize = len
+    while left < right {
+        right = right - 1
+        if left < right {
+            let temporary: T = items[left]
+            items[left] = items[right]
+            items[right] = temporary
+            left = left + 1
+        }
+    }
+    return true
+}
+
+fn __zero_std_collections_rotate_left<T: Type>(items: MutSpan<T>, len: usize, count: usize) -> Bool {
+    if len > std.mem.len(items) {
+        return false
+    }
+    if len == 0 || len == 1 {
+        return true
+    }
+    var steps: usize = count
+    while steps >= len {
+        steps = steps - len
+    }
+    while steps > 0 {
+        let first: T = items[0]
+        let last_index: usize = len - 1
+        var index: usize = 0
+        while index < last_index {
+            items[index] = items[index + 1]
+            index = index + 1
+        }
+        items[last_index] = first
+        steps = steps - 1
+    }
+    return true
+}
+
+fn __zero_std_collections_rotate_right<T: Type>(items: MutSpan<T>, len: usize, count: usize) -> Bool {
+    if len > std.mem.len(items) {
+        return false
+    }
+    if len == 0 || len == 1 {
+        return true
+    }
+    var steps: usize = count
+    while steps >= len {
+        steps = steps - len
+    }
+    while steps > 0 {
+        let last_index: usize = len - 1
+        let last: T = items[last_index]
+        var index: usize = last_index
+        while index > 0 {
+            items[index] = items[index - 1]
+            index = index - 1
+        }
+        items[0] = last
+        steps = steps - 1
+    }
+    return true
+}

std/crypto.0

@@ -0,0 +1,34 @@
+fn crypto_fixed_hex32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    if std.mem.len(buffer) < 8 {
+        return null
+    }
+    var place: u32 = 268435456_u32
+    var index: usize = 0
+    while index < 8 {
+        let digit: u8 = ((value / place) % 16_u32) as u8
+        if digit < 10_u8 {
+            buffer[index] = 48_u8 + digit
+        } else {
+            buffer[index] = 87_u8 + digit
+        }
+        place = place / 16_u32
+        index = index + 1
+    }
+    return buffer[..8]
+}
+
+fn crypto_hash_hex32(buffer: MutSpan<u8>, bytes: Span<u8>) -> Maybe<Span<u8>> {
+    return crypto_fixed_hex32(buffer, std.crypto.hash32(bytes))
+}
+
+fn crypto_hmac_hex32(buffer: MutSpan<u8>, key: Span<u8>, bytes: Span<u8>) -> Maybe<Span<u8>> {
+    return crypto_fixed_hex32(buffer, std.crypto.hmac32(key, bytes))
+}
+
+fn crypto_stable_id32(buffer: MutSpan<u8>, bytes: Span<u8>) -> Maybe<Span<u8>> {
+    return crypto_fixed_hex32(buffer, std.crypto.hash32(bytes))
+}
+
+fn crypto_random_id32(buffer: MutSpan<u8>) -> Maybe<Span<u8>> {
+    return crypto_fixed_hex32(buffer, std.crypto.secureRandomU32())
+}

std/csv.0

@@ -0,0 +1,392 @@
+fn csv_is_comma(byte: u8) -> Bool {
+    return byte == 44_u8
+}
+
+fn csv_is_quote(byte: u8) -> Bool {
+    return byte == 34_u8
+}
+
+fn csv_is_lf(byte: u8) -> Bool {
+    return byte == 10_u8
+}
+
+fn csv_is_cr(byte: u8) -> Bool {
+    return byte == 13_u8
+}
+
+fn csv_field_needs_quotes(field: Span<u8>) -> Bool {
+    if std.mem.len(field) == 0_usize {
+        return false
+    }
+    var index: usize = 0
+    while index < std.mem.len(field) {
+        let byte: u8 = field[index]
+        if csv_is_comma(byte) || csv_is_quote(byte) || csv_is_lf(byte) || csv_is_cr(byte) {
+            return true
+        }
+        index = index + 1
+    }
+    return false
+}
+
+fn csv_encoded_field_len(field: Span<u8>) -> usize {
+    if !csv_field_needs_quotes(field) {
+        return std.mem.len(field)
+    }
+    var length: usize = 2
+    var index: usize = 0
+    while index < std.mem.len(field) {
+        length = length + 1
+        if csv_is_quote(field[index]) {
+            length = length + 1
+        }
+        index = index + 1
+    }
+    return length
+}
+
+fn csv_record_end(bytes: Span<u8>, start: usize) -> Maybe<usize> {
+    if start > std.mem.len(bytes) {
+        return null
+    }
+    var index: usize = start
+    var in_quotes: Bool = false
+    var after_quote: Bool = false
+    var at_field_start: Bool = true
+    while index < std.mem.len(bytes) {
+        let byte: u8 = bytes[index]
+        if in_quotes {
+            if csv_is_quote(byte) {
+                if index + 1 < std.mem.len(bytes) && csv_is_quote(bytes[index + 1]) {
+                    index = index + 2
+                } else {
+                    in_quotes = false
+                    after_quote = true
+                    index = index + 1
+                }
+            } else {
+                index = index + 1
+            }
+        } else if after_quote {
+            if csv_is_comma(byte) {
+                after_quote = false
+                at_field_start = true
+                index = index + 1
+            } else if csv_is_lf(byte) {
+                return index
+            } else if csv_is_cr(byte) {
+                if index + 1 < std.mem.len(bytes) && csv_is_lf(bytes[index + 1]) {
+                    return index
+                }
+                return null
+            } else {
+                return null
+            }
+        } else if at_field_start && csv_is_quote(byte) {
+            in_quotes = true
+            at_field_start = false
+            index = index + 1
+        } else if csv_is_comma(byte) {
+            at_field_start = true
+            index = index + 1
+        } else if csv_is_lf(byte) {
+            return index
+        } else if csv_is_cr(byte) {
+            if index + 1 < std.mem.len(bytes) && csv_is_lf(bytes[index + 1]) {
+                return index
+            }
+            return null
+        } else if csv_is_quote(byte) {
+            return null
+        } else {
+            at_field_start = false
+            index = index + 1
+        }
+    }
+    if in_quotes {
+        return null
+    }
+    return std.mem.len(bytes)
+}
+
+fn csv_next_record_start(bytes: Span<u8>, end: usize) -> usize {
+    if end >= std.mem.len(bytes) {
+        return std.mem.len(bytes)
+    }
+    if csv_is_cr(bytes[end]) && end + 1 < std.mem.len(bytes) && csv_is_lf(bytes[end + 1]) {
+        return end + 2
+    }
+    return end + 1
+}
+
+fn csv_valid(bytes: Span<u8>) -> Bool {
+    var start: usize = 0
+    while start < std.mem.len(bytes) {
+        let end: Maybe<usize> = csv_record_end(bytes, start)
+        if !end.has {
+            return false
+        }
+        let fields: Maybe<usize> = csv_field_count(bytes[start..end.value])
+        if !fields.has {
+            return false
+        }
+        start = csv_next_record_start(bytes, end.value)
+    }
+    return true
+}
+
+fn csv_record_count(bytes: Span<u8>) -> Maybe<usize> {
+    var count: usize = 0
+    var start: usize = 0
+    while start < std.mem.len(bytes) {
+        let end: Maybe<usize> = csv_record_end(bytes, start)
+        if !end.has {
+            return null
+        }
+        let fields: Maybe<usize> = csv_field_count(bytes[start..end.value])
+        if !fields.has {
+            return null
+        }
+        count = count + 1
+        start = csv_next_record_start(bytes, end.value)
+    }
+    return count
+}
+
+fn csv_record(bytes: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
+    var count: usize = 0
+    var start: usize = 0
+    while start < std.mem.len(bytes) {
+        let end: Maybe<usize> = csv_record_end(bytes, start)
+        if !end.has {
+            return null
+        }
+        let fields: Maybe<usize> = csv_field_count(bytes[start..end.value])
+        if !fields.has {
+            return null
+        }
+        if count == ordinal {
+            return bytes[start..end.value]
+        }
+        count = count + 1
+        start = csv_next_record_start(bytes, end.value)
+    }
+    return null
+}
+
+fn csv_field_count(record: Span<u8>) -> Maybe<usize> {
+    var count: usize = 1
+    var index: usize = 0
+    var in_quotes: Bool = false
+    var after_quote: Bool = false
+    var at_field_start: Bool = true
+    while index < std.mem.len(record) {
+        let byte: u8 = record[index]
+        if in_quotes {
+            if csv_is_quote(byte) {
+                if index + 1 < std.mem.len(record) && csv_is_quote(record[index + 1]) {
+                    index = index + 2
+                } else {
+                    in_quotes = false
+                    after_quote = true
+                    index = index + 1
+                }
+            } else {
+                index = index + 1
+            }
+        } else if after_quote {
+            if csv_is_comma(byte) {
+                count = count + 1
+                after_quote = false
+                at_field_start = true
+                index = index + 1
+            } else {
+                return null
+            }
+        } else if at_field_start && csv_is_quote(byte) {
+            in_quotes = true
+            at_field_start = false
+            index = index + 1
+        } else if csv_is_comma(byte) {
+            count = count + 1
+            at_field_start = true
+            index = index + 1
+        } else if csv_is_lf(byte) || csv_is_cr(byte) || csv_is_quote(byte) {
+            return null
+        } else {
+            at_field_start = false
+            index = index + 1
+        }
+    }
+    if in_quotes {
+        return null
+    }
+    return count
+}
+
+fn csv_field(buffer: MutSpan<u8>, record: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
+    let fields: Maybe<usize> = csv_field_count(record)
+    if !fields.has || ordinal >= fields.value {
+        return null
+    }
+    var field_index: usize = 0
+    var input: usize = 0
+    while input <= std.mem.len(record) {
+        var output: usize = 0
+        if input < std.mem.len(record) && csv_is_quote(record[input]) {
+            input = input + 1
+            var closed: Bool = false
+            while input < std.mem.len(record) {
+                let byte: u8 = record[input]
+                if csv_is_quote(byte) {
+                    if input + 1 < std.mem.len(record) && csv_is_quote(record[input + 1]) {
+                        if field_index == ordinal {
+                            if output >= std.mem.len(buffer) {
+                                return null
+                            }
+                            buffer[output] = 34_u8
+                            output = output + 1
+                        }
+                        input = input + 2
+                    } else {
+                        input = input + 1
+                        if input < std.mem.len(record) && !csv_is_comma(record[input]) {
+                            return null
+                        }
+                        if field_index == ordinal {
+                            return buffer[..output]
+                        }
+                        if input >= std.mem.len(record) {
+                            return null
+                        }
+                        input = input + 1
+                        closed = true
+                        break
+                    }
+                } else {
+                    if field_index == ordinal {
+                        if output >= std.mem.len(buffer) {
+                            return null
+                        }
+                        buffer[output] = byte
+                        output = output + 1
+                    }
+                    input = input + 1
+                }
+            }
+            if !closed {
+                return null
+            }
+        } else {
+            while input < std.mem.len(record) && !csv_is_comma(record[input]) {
+                let byte: u8 = record[input]
+                if csv_is_quote(byte) || csv_is_lf(byte) || csv_is_cr(byte) {
+                    return null
+                }
+                if field_index == ordinal {
+                    if output >= std.mem.len(buffer) {
+                        return null
+                    }
+                    buffer[output] = byte
+                    output = output + 1
+                }
+                input = input + 1
+            }
+            if field_index == ordinal {
+                return buffer[..output]
+            }
+            if input < std.mem.len(record) {
+                input = input + 1
+            } else {
+                return null
+            }
+        }
+        field_index = field_index + 1
+    }
+    return null
+}
+
+fn csv_write_field(buffer: MutSpan<u8>, field: Span<u8>) -> Maybe<Span<u8>> {
+    let length: usize = csv_encoded_field_len(field)
+    if length > std.mem.len(buffer) {
+        return null
+    }
+    if !csv_field_needs_quotes(field) {
+        var index: usize = 0
+        while index < std.mem.len(field) {
+            buffer[index] = field[index]
+            index = index + 1
+        }
+        return buffer[..std.mem.len(field)]
+    }
+    var output: usize = 0
+    buffer[output] = 34_u8
+    output = output + 1
+    var input: usize = 0
+    while input < std.mem.len(field) {
+        let byte: u8 = field[input]
+        buffer[output] = byte
+        output = output + 1
+        if csv_is_quote(byte) {
+            buffer[output] = byte
+            output = output + 1
+        }
+        input = input + 1
+    }
+    buffer[output] = 34_u8
+    return buffer[..output + 1]
+}
+
+fn csv_write_record2(buffer: MutSpan<u8>, left: Span<u8>, right: Span<u8>) -> Maybe<Span<u8>> {
+    let left_len: usize = csv_encoded_field_len(left)
+    let right_len: usize = csv_encoded_field_len(right)
+    let total: usize = left_len + 1 + right_len + 1
+    if total > std.mem.len(buffer) {
+        return null
+    }
+    let left_out: Maybe<Span<u8>> = csv_write_field(buffer, left)
+    if !left_out.has {
+        return null
+    }
+    var offset: usize = std.mem.len(left_out.value)
+    buffer[offset] = 44_u8
+    offset = offset + 1
+    let right_out: Maybe<Span<u8>> = csv_write_field(buffer[offset..], right)
+    if !right_out.has {
+        return null
+    }
+    offset = offset + std.mem.len(right_out.value)
+    buffer[offset] = 10_u8
+    return buffer[..offset + 1]
+}
+
+fn csv_write_record3(buffer: MutSpan<u8>, first: Span<u8>, second: Span<u8>, third: Span<u8>) -> Maybe<Span<u8>> {
+    let first_len: usize = csv_encoded_field_len(first)
+    let second_len: usize = csv_encoded_field_len(second)
+    let third_len: usize = csv_encoded_field_len(third)
+    let total: usize = first_len + 1 + second_len + 1 + third_len + 1
+    if total > std.mem.len(buffer) {
+        return null
+    }
+    let first_out: Maybe<Span<u8>> = csv_write_field(buffer, first)
+    if !first_out.has {
+        return null
+    }
+    var offset: usize = std.mem.len(first_out.value)
+    buffer[offset] = 44_u8
+    offset = offset + 1
+    let second_out: Maybe<Span<u8>> = csv_write_field(buffer[offset..], second)
+    if !second_out.has {
+        return null
+    }
+    offset = offset + std.mem.len(second_out.value)
+    buffer[offset] = 44_u8
+    offset = offset + 1
+    let third_out: Maybe<Span<u8>> = csv_write_field(buffer[offset..], third)
+    if !third_out.has {
+        return null
+    }
+    offset = offset + std.mem.len(third_out.value)
+    buffer[offset] = 10_u8
+    return buffer[..offset + 1]
+}

std/diag.0

@@ -0,0 +1,141 @@
+fn diag_clamp_offset(bytes: Span<u8>, offset: usize) -> usize {
+    if offset > std.mem.len(bytes) {
+        return std.mem.len(bytes)
+    }
+    return offset
+}
+
+fn diag_line_start(bytes: Span<u8>, offset: usize) -> usize {
+    let cursor: usize = diag_clamp_offset(bytes, offset)
+    var start: usize = cursor
+    while start > 0 && bytes[start - 1] != 10_u8 {
+        start = start - 1
+    }
+    return start
+}
+
+fn diag_line_end(bytes: Span<u8>, offset: usize) -> usize {
+    var end: usize = diag_clamp_offset(bytes, offset)
+    while end < std.mem.len(bytes) && bytes[end] != 10_u8 {
+        end = end + 1
+    }
+    if end > 0 && bytes[end - 1] == 13_u8 {
+        return end - 1
+    }
+    return end
+}
+
+fn diag_line(bytes: Span<u8>, offset: usize) -> usize {
+    let cursor: usize = diag_clamp_offset(bytes, offset)
+    var line: usize = 1
+    var index: usize = 0
+    while index < cursor {
+        if bytes[index] == 10_u8 {
+            line = line + 1
+        }
+        index = index + 1
+    }
+    return line
+}
+
+fn diag_column(bytes: Span<u8>, offset: usize) -> usize {
+    let cursor: usize = diag_clamp_offset(bytes, offset)
+    let start: usize = diag_line_start(bytes, cursor)
+    return (cursor - start) + 1
+}
+
+fn diag_line_text(bytes: Span<u8>, offset: usize) -> Span<u8> {
+    let start: usize = diag_line_start(bytes, offset)
+    let end: usize = diag_line_end(bytes, offset)
+    return bytes[start..end]
+}
+
+fn diag_range_len(bytes: Span<u8>, start: usize, end: usize) -> usize {
+    let first: usize = diag_clamp_offset(bytes, start)
+    let last: usize = diag_clamp_offset(bytes, end)
+    if last < first {
+        return 0
+    }
+    return last - first
+}
+
+fn diag_range_text(bytes: Span<u8>, start: usize, end: usize) -> Span<u8> {
+    let first: usize = diag_clamp_offset(bytes, start)
+    let last: usize = diag_clamp_offset(bytes, end)
+    if last < first {
+        return bytes[first..first]
+    }
+    return bytes[first..last]
+}
+
+fn diag_write_span(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    if std.mem.len(bytes) > std.mem.len(buffer) - offset {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        buffer[offset + index] = bytes[index]
+        index = index + 1
+    }
+    return offset + std.mem.len(bytes)
+}
+
+fn diag_write_usize(buffer: MutSpan<u8>, offset: usize, value: usize) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    var digits: usize = 1
+    var scan: usize = value
+    while scan >= 10 {
+        digits = digits + 1
+        scan = scan / 10
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: usize = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u8 = (current % 10) as u8
+        buffer[cursor] = 48_u8 + digit
+        current = current / 10
+    }
+    return offset + digits
+}
+
+fn diag_format_location(buffer: MutSpan<u8>, path: Span<u8>, line: usize, column: usize) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let wrote_path: Maybe<usize> = diag_write_span(buffer, offset, path)
+    if !wrote_path.has {
+        return null
+    }
+    offset = wrote_path.value
+    let first_colon: Maybe<usize> = diag_write_span(buffer, offset, ":")
+    if !first_colon.has {
+        return null
+    }
+    offset = first_colon.value
+    let wrote_line: Maybe<usize> = diag_write_usize(buffer, offset, line)
+    if !wrote_line.has {
+        return null
+    }
+    offset = wrote_line.value
+    let second_colon: Maybe<usize> = diag_write_span(buffer, offset, ":")
+    if !second_colon.has {
+        return null
+    }
+    offset = second_colon.value
+    let wrote_column: Maybe<usize> = diag_write_usize(buffer, offset, column)
+    if wrote_column.has {
+        return buffer[..wrote_column.value]
+    }
+    return null
+}
+
+fn diag_format_offset_location(buffer: MutSpan<u8>, path: Span<u8>, bytes: Span<u8>, offset: usize) -> Maybe<Span<u8>> {
+    return diag_format_location(buffer, path, diag_line(bytes, offset), diag_column(bytes, offset))
+}

std/env.0

@@ -0,0 +1,84 @@
+fn __zero_std_env_has(name: String) -> Bool {
+    let value: Maybe<String> = std.env.get(name)
+    return value.has
+}
+
+fn __zero_std_env_get_or(name: String, fallback: String) -> String {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_env_parse_bool(name: String) -> Maybe<Bool> {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return std.parse.parseBool(value.value)
+    }
+    return null
+}
+
+fn __zero_std_env_parse_u32(name: String) -> Maybe<u32> {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return std.parse.parseU32(value.value)
+    }
+    return null
+}
+
+fn __zero_std_env_parse_i32(name: String) -> Maybe<i32> {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return std.parse.parseI32(value.value)
+    }
+    return null
+}
+
+fn __zero_std_env_parse_usize(name: String) -> Maybe<usize> {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return std.parse.parseUsize(value.value)
+    }
+    return null
+}
+
+fn __zero_std_env_equals(name: String, expected: String) -> Bool {
+    let value: Maybe<String> = std.env.get(name)
+    if value.has {
+        return std.mem.eql(value.value, expected)
+    }
+    return false
+}
+
+fn __zero_std_env_parse_bool_or(name: String, fallback: Bool) -> Bool {
+    let value: Maybe<Bool> = std.env.parseBool(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_env_parse_u32_or(name: String, fallback: u32) -> u32 {
+    let value: Maybe<u32> = std.env.parseU32(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_env_parse_i32_or(name: String, fallback: i32) -> i32 {
+    let value: Maybe<i32> = std.env.parseI32(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}
+
+fn __zero_std_env_parse_usize_or(name: String, fallback: usize) -> usize {
+    let value: Maybe<usize> = std.env.parseUsize(name)
+    if value.has {
+        return value.value
+    }
+    return fallback
+}

std/fmt.0

@@ -0,0 +1,495 @@
+fn __zero_std_fmt_write_u32_at(buffer: MutSpan<u8>, offset: usize, value: u32) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    var digits: usize = 1
+    var scan: u32 = value
+    while scan >= 10_u32 {
+        digits = digits + 1
+        scan = scan / 10_u32
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: u32 = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u8 = (current % 10_u32) as u8
+        buffer[cursor] = 48_u8 + digit
+        current = current / 10_u32
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_write_usize_at(buffer: MutSpan<u8>, offset: usize, value: usize) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    var digits: usize = 1
+    var scan: usize = value
+    while scan >= 10 {
+        digits = digits + 1
+        scan = scan / 10
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: usize = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u8 = (current % 10) as u8
+        buffer[cursor] = 48_u8 + digit
+        current = current / 10
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_write_u64_at(buffer: MutSpan<u8>, offset: usize, value: u64) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    var digits: usize = 1
+    var scan: u64 = value
+    while scan >= 10_u64 {
+        digits = digits + 1
+        scan = scan / 10_u64
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: u64 = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u8 = (current % 10_u64) as u8
+        buffer[cursor] = 48_u8 + digit
+        current = current / 10_u64
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_digit_lower(value: u32) -> u8 {
+    if value < 10_u32 {
+        return 48_u8 + (value as u8)
+    }
+    return 87_u8 + (value as u8)
+}
+
+fn __zero_std_fmt_write_u32_base_at(buffer: MutSpan<u8>, offset: usize, value: u32, base: u32) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
+        return null
+    }
+    var digits: usize = 1
+    var scan: u32 = value
+    while scan >= base {
+        digits = digits + 1
+        scan = scan / base
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: u32 = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u32 = current % base
+        buffer[cursor] = __zero_std_fmt_digit_lower(digit)
+        current = current / base
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_write_usize_base_at(buffer: MutSpan<u8>, offset: usize, value: usize, base: u32) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
+        return null
+    }
+    let usize_base: usize = base as usize
+    var digits: usize = 1
+    var scan: usize = value
+    while scan >= usize_base {
+        digits = digits + 1
+        scan = scan / usize_base
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: usize = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u32 = (current % usize_base) as u32
+        buffer[cursor] = __zero_std_fmt_digit_lower(digit)
+        current = current / usize_base
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_write_u64_base_at(buffer: MutSpan<u8>, offset: usize, value: u64, base: u32) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) || (base < 2_u32 || base > 36_u32) {
+        return null
+    }
+    let u64_base: u64 = base as u64
+    var digits: usize = 1
+    var scan: u64 = value
+    while scan >= u64_base {
+        digits = digits + 1
+        scan = scan / u64_base
+    }
+    if offset + digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = offset + digits
+    var current: u64 = value
+    while cursor > offset {
+        cursor = cursor - 1
+        let digit: u32 = (current % u64_base) as u32
+        buffer[cursor] = __zero_std_fmt_digit_lower(digit)
+        current = current / u64_base
+    }
+    return offset + digits
+}
+
+fn __zero_std_fmt_write_bytes(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    if std.mem.len(text) > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(text) {
+        buffer[index] = text[index]
+        index = index + 1
+    }
+    return buffer[..std.mem.len(text)]
+}
+
+fn __zero_std_fmt_bool(buffer: MutSpan<u8>, value: Bool) -> Maybe<Span<u8>> {
+    if value {
+        return __zero_std_fmt_write_bytes(buffer, "true")
+    }
+    return __zero_std_fmt_write_bytes(buffer, "false")
+}
+
+fn __zero_std_fmt_u32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 0, value)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_usize(buffer: MutSpan<u8>, value: usize) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_usize_at(buffer, 0, value)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_u64(buffer: MutSpan<u8>, value: u64) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 0, value)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i32(buffer: MutSpan<u8>, value: i32) -> Maybe<Span<u8>> {
+    if value >= 0 {
+        return __zero_std_fmt_u32(buffer, value as u32)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 45_u8
+    let min_i32: i32 = 0 - 2147483647 - 1
+    if value == min_i32 {
+        let written_min: Maybe<Span<u8>> = __zero_std_fmt_write_bytes(buffer[1..], "2147483648")
+        if written_min.has {
+            return buffer[..11]
+        }
+        return null
+    }
+    let magnitude: u32 = (0 - value) as u32
+    let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 1, magnitude)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i64(buffer: MutSpan<u8>, value: i64) -> Maybe<Span<u8>> {
+    if value >= 0 {
+        return __zero_std_fmt_u64(buffer, value as u64)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 45_u8
+    let min_i64: i64 = 0 - 9223372036854775807 - 1
+    if value == min_i64 {
+        let written_min: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, 9223372036854775808_u64)
+        if written_min.has {
+            return buffer[..written_min.value]
+        }
+        return null
+    }
+    let magnitude: u64 = (0_i64 - value) as u64
+    let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, magnitude)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_u32_base(buffer: MutSpan<u8>, value: u32, base: u32) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 0, value, base)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_usize_base(buffer: MutSpan<u8>, value: usize, base: u32) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_usize_base_at(buffer, 0, value, base)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_u64_base(buffer: MutSpan<u8>, value: u64, base: u32) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 0, value, base)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i32_base(buffer: MutSpan<u8>, value: i32, base: u32) -> Maybe<Span<u8>> {
+    if base < 2_u32 || base > 36_u32 {
+        return null
+    }
+    if value >= 0 {
+        return __zero_std_fmt_u32_base(buffer, value as u32, base)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 45_u8
+    let min_i32: i32 = 0 - 2147483647 - 1
+    if value == min_i32 {
+        let written_min: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 1, 2147483648_u32, base)
+        if written_min.has {
+            return buffer[..written_min.value]
+        }
+        return null
+    }
+    let magnitude: u32 = (0 - value) as u32
+    let written: Maybe<usize> = __zero_std_fmt_write_u32_base_at(buffer, 1, magnitude, base)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i64_base(buffer: MutSpan<u8>, value: i64, base: u32) -> Maybe<Span<u8>> {
+    if base < 2_u32 || base > 36_u32 {
+        return null
+    }
+    if value >= 0 {
+        return __zero_std_fmt_u64_base(buffer, value as u64, base)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 45_u8
+    let min_i64: i64 = 0 - 9223372036854775807 - 1
+    if value == min_i64 {
+        let written_min: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 1, 9223372036854775808_u64, base)
+        if written_min.has {
+            return buffer[..written_min.value]
+        }
+        return null
+    }
+    let magnitude: u64 = (0_i64 - value) as u64
+    let written: Maybe<usize> = __zero_std_fmt_write_u64_base_at(buffer, 1, magnitude, base)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i32_sign(buffer: MutSpan<u8>, value: i32) -> Maybe<Span<u8>> {
+    if value < 0 {
+        return __zero_std_fmt_i32(buffer, value)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 43_u8
+    let written: Maybe<usize> = __zero_std_fmt_write_u32_at(buffer, 1, value as u32)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_i64_sign(buffer: MutSpan<u8>, value: i64) -> Maybe<Span<u8>> {
+    if value < 0 {
+        return __zero_std_fmt_i64(buffer, value)
+    }
+    if std.mem.len(buffer) == 0 {
+        return null
+    }
+    buffer[0] = 43_u8
+    let written: Maybe<usize> = __zero_std_fmt_write_u64_at(buffer, 1, value as u64)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_fmt_pad_left(buffer: MutSpan<u8>, text: Span<u8>, width: usize, pad: u8) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len >= width {
+        return __zero_std_fmt_write_bytes(buffer, text)
+    }
+    if width > std.mem.len(buffer) {
+        return null
+    }
+    let fill: usize = width - len
+    var index: usize = 0
+    while index < fill {
+        buffer[index] = pad
+        index = index + 1
+    }
+    var text_index: usize = 0
+    while text_index < len {
+        buffer[fill + text_index] = text[text_index]
+        text_index = text_index + 1
+    }
+    return buffer[..width]
+}
+
+fn __zero_std_fmt_pad_right(buffer: MutSpan<u8>, text: Span<u8>, width: usize, pad: u8) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len >= width {
+        return __zero_std_fmt_write_bytes(buffer, text)
+    }
+    if width > std.mem.len(buffer) {
+        return null
+    }
+    var text_index: usize = 0
+    while text_index < len {
+        buffer[text_index] = text[text_index]
+        text_index = text_index + 1
+    }
+    var index: usize = len
+    while index < width {
+        buffer[index] = pad
+        index = index + 1
+    }
+    return buffer[..width]
+}
+
+fn __zero_std_fmt_write_span(writer: mutref<FixedWriter>, text: Span<u8>) -> Bool {
+    return std.io.fixedWriterWrite(writer, text)
+}
+
+fn __zero_std_fmt_write_bool(writer: mutref<FixedWriter>, value: Bool) -> Bool {
+    var storage: [5]u8 = [0_u8; 5]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_bool(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_u32(writer: mutref<FixedWriter>, value: u32) -> Bool {
+    var storage: [10]u8 = [0_u8; 10]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_u32(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_usize(writer: mutref<FixedWriter>, value: usize) -> Bool {
+    var storage: [20]u8 = [0_u8; 20]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_usize(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_u64(writer: mutref<FixedWriter>, value: u64) -> Bool {
+    var storage: [20]u8 = [0_u8; 20]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_u64(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_i32(writer: mutref<FixedWriter>, value: i32) -> Bool {
+    var storage: [12]u8 = [0_u8; 12]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_i32(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_i64(writer: mutref<FixedWriter>, value: i64) -> Bool {
+    var storage: [20]u8 = [0_u8; 20]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_i64(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_i32_sign(writer: mutref<FixedWriter>, value: i32) -> Bool {
+    var storage: [12]u8 = [0_u8; 12]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_i32_sign(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_write_i64_sign(writer: mutref<FixedWriter>, value: i64) -> Bool {
+    var storage: [20]u8 = [0_u8; 20]
+    let text: Maybe<Span<u8>> = __zero_std_fmt_i64_sign(storage, value)
+    if text.has {
+        return __zero_std_fmt_write_span(writer, text.value)
+    }
+    return false
+}
+
+fn __zero_std_fmt_hex_lower_u32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    var digits: usize = 1
+    var scan: u32 = value
+    while scan >= 16_u32 {
+        digits = digits + 1
+        scan = scan / 16_u32
+    }
+    if digits > std.mem.len(buffer) {
+        return null
+    }
+    var cursor: usize = digits
+    var current: u32 = value
+    while cursor > 0 {
+        cursor = cursor - 1
+        let digit: u8 = (current % 16_u32) as u8
+        if digit < 10_u8 {
+            buffer[cursor] = 48_u8 + digit
+        } else {
+            buffer[cursor] = 87_u8 + digit
+        }
+        current = current / 16_u32
+    }
+    return buffer[..digits]
+}

std/fs.0

@@ -0,0 +1,125 @@
+fn __zero_std_fs_read_file(fs: Fs, path: String, buffer: MutSpan<u8>) -> Maybe<usize> {
+    let opened: Maybe<owned<File>> = std.fs.open(fs, path)
+    if opened.has {
+        var file: owned<File> = opened.value
+        var total: usize = 0
+        var ok: Bool = true
+        var done: Bool = false
+        while ok && !done && total < std.mem.len(buffer) {
+            let count: Maybe<usize> = std.fs.read(&mut file, buffer[total..])
+            if !count.has {
+                ok = false
+            } else if count.value == 0 {
+                done = true
+            } else {
+                total = total + count.value
+            }
+        }
+        var extra: [64]u8 = [0_u8; 64]
+        while ok && !done {
+            let count: Maybe<usize> = std.fs.read(&mut file, extra)
+            if !count.has {
+                ok = false
+            } else if count.value == 0 {
+                done = true
+            } else {
+                total = total + count.value
+            }
+        }
+        std.fs.close(&mut file)
+        if ok {
+            return total
+        }
+        return null
+    }
+    return null
+}
+
+fn __zero_std_fs_write_file(fs: Fs, path: String, bytes: Span<u8>) -> Bool {
+    let count: Maybe<usize> = std.fs.writeBytes(path, bytes)
+    return count.has && count.value == std.mem.len(bytes)
+}
+
+fn __zero_std_fs_append_file(fs: Fs, path: String, bytes: Span<u8>) -> Bool {
+    let count: Maybe<usize> = std.fs.appendBytes(path, bytes)
+    return count.has && count.value == std.mem.len(bytes)
+}
+
+fn __zero_std_fs_copy_file(from_path: String, to_path: String, buffer: MutSpan<u8>) -> Bool {
+    if std.mem.len(buffer) == 0 {
+        return false
+    }
+    let fs: Fs = std.fs.host()
+    let opened: Maybe<owned<File>> = std.fs.open(fs, from_path)
+    if !opened.has {
+        return false
+    }
+    var src: owned<File> = opened.value
+    let created: Maybe<owned<File>> = std.fs.create(fs, to_path)
+    if !created.has {
+        std.fs.close(&mut src)
+        return false
+    }
+    var dst: owned<File> = created.value
+    var ok: Bool = true
+    var done: Bool = false
+    while ok && !done {
+        let count: Maybe<usize> = std.fs.read(&mut src, buffer)
+        if !count.has {
+            ok = false
+        } else if count.value == 0 {
+            done = true
+        } else {
+            let chunk: Span<u8> = buffer[..count.value]
+            if !std.fs.writeAll(&mut dst, chunk) {
+                ok = false
+            }
+        }
+    }
+    std.fs.close(&mut src)
+    std.fs.close(&mut dst)
+    return ok
+}
+
+fn __zero_std_fs_file_size(fs: Fs, path: String) -> Maybe<usize> {
+    let opened: Maybe<owned<File>> = std.fs.open(fs, path)
+    if opened.has {
+        var file: owned<File> = opened.value
+        let len: Maybe<usize> = std.fs.fileLen(&mut file)
+        std.fs.close(&mut file)
+        return len
+    }
+    return null
+}
+
+fn __zero_std_fs_is_file(path: String) -> Bool {
+    if std.fs.isDir(path) {
+        return false
+    }
+    let fs: Fs = std.fs.host()
+    let size: Maybe<usize> = std.fs.fileSize(fs, path)
+    return size.has
+}
+
+fn __zero_std_fs_ensure_dir(path: String) -> Bool {
+    if std.fs.isDir(path) {
+        return true
+    }
+    return std.fs.makeDir(path)
+}
+
+fn __zero_std_fs_read_file_bytes(fs: Fs, path: String, buffer: MutSpan<u8>) -> Maybe<Span<u8>> {
+    let count: Maybe<usize> = std.fs.readBytes(path, buffer)
+    if count.has && count.value <= std.mem.len(buffer) {
+        return buffer[..count.value]
+    }
+    return null
+}
+
+fn __zero_std_fs_read_file_equals(fs: Fs, path: String, buffer: MutSpan<u8>, expected: Span<u8>) -> Bool {
+    let bytes: Maybe<Span<u8>> = std.fs.readFileBytes(fs, path, buffer)
+    if bytes.has {
+        return std.mem.eqlBytes(bytes.value, expected)
+    }
+    return false
+}

std/inet.0

@@ -0,0 +1,377 @@
+fn __zero_std_inet_ipv4_core(text: Span<u8>) -> u64 {
+    let len: usize = std.mem.len(text)
+    var pos: usize = 0
+    var octet_index: usize = 0
+    var value: u32 = 0
+    while octet_index < 4 {
+        if pos >= len {
+            return 0
+        }
+        var digits: usize = 0
+        var octet: u32 = 0
+        var leading_zero: Bool = false
+        while pos < len && (text[pos] >= 48_u8 && text[pos] <= 57_u8) {
+            if digits == 0 && text[pos] == 48_u8 {
+                leading_zero = true
+            }
+            if digits >= 3 {
+                return 0
+            }
+            octet = octet * 10_u32 + ((text[pos] - 48_u8) as u32)
+            digits = digits + 1
+            pos = pos + 1
+        }
+        if digits == 0 || octet > 255_u32 {
+            return 0
+        }
+        if leading_zero && digits > 1 {
+            return 0
+        }
+        value = value * 256_u32 + octet
+        octet_index = octet_index + 1
+        if octet_index < 4 {
+            if pos >= len || text[pos] != 46_u8 {
+                return 0
+            }
+            pos = pos + 1
+        }
+    }
+    if pos != len {
+        return 0
+    }
+    return 4294967296_u64 + (value as u64)
+}
+
+fn __zero_std_inet_parse_ipv4(text: Span<u8>) -> Maybe<u32> {
+    let core: u64 = __zero_std_inet_ipv4_core(text)
+    if core == 0 {
+        return null
+    }
+    return (core % 4294967296_u64) as u32
+}
+
+fn __zero_std_inet_ipv4_to_bytes(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    if std.mem.len(buffer) < 4 {
+        return null
+    }
+    buffer[0] = (value / 16777216_u32) as u8
+    buffer[1] = ((value / 65536_u32) % 256_u32) as u8
+    buffer[2] = ((value / 256_u32) % 256_u32) as u8
+    buffer[3] = (value % 256_u32) as u8
+    return buffer[..4]
+}
+
+fn __zero_std_inet_write_ipv4(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    var writer: FixedWriter = std.io.fixedWriter(buffer, 0_usize)
+    let a: u32 = value / 16777216_u32
+    let b: u32 = (value / 65536_u32) % 256_u32
+    let c: u32 = (value / 256_u32) % 256_u32
+    let d: u32 = value % 256_u32
+    if std.fmt.writeU32(&mut writer, a) && (std.io.fixedWriterWriteByte(&mut writer, 46_u8) && std.fmt.writeU32(&mut writer, b)) && (std.io.fixedWriterWriteByte(&mut writer, 46_u8) && std.fmt.writeU32(&mut writer, c)) && (std.io.fixedWriterWriteByte(&mut writer, 46_u8) && std.fmt.writeU32(&mut writer, d)) {
+        return std.io.fixedWriterView(&writer)
+    }
+    return null
+}
+
+fn __zero_std_inet_is_ipv4(text: Span<u8>) -> Bool {
+    return __zero_std_inet_ipv4_core(text) != 0
+}
+
+fn __zero_std_inet_is_ipv4_unspecified(value: u32) -> Bool {
+    return value == 0_u32
+}
+
+fn __zero_std_inet_is_ipv4_loopback(value: u32) -> Bool {
+    return value / 16777216_u32 == 127_u32
+}
+
+fn __zero_std_inet_is_ipv4_private(value: u32) -> Bool {
+    let first: u32 = value / 16777216_u32
+    let second: u32 = (value / 65536_u32) % 256_u32
+    if first == 10_u32 {
+        return true
+    }
+    if first == 172_u32 && (second >= 16_u32 && second <= 31_u32) {
+        return true
+    }
+    return first == 192_u32 && second == 168_u32
+}
+
+fn __zero_std_inet_is_ipv4_link_local(value: u32) -> Bool {
+    let first: u32 = value / 16777216_u32
+    let second: u32 = (value / 65536_u32) % 256_u32
+    return first == 169_u32 && second == 254_u32
+}
+
+fn __zero_std_inet_is_ipv4_multicast(value: u32) -> Bool {
+    let first: u32 = value / 16777216_u32
+    return first >= 224_u32 && first <= 239_u32
+}
+
+fn __zero_std_inet_hex_value(byte: u8) -> u32 {
+    if byte >= 48_u8 && byte <= 57_u8 {
+        return (byte - 48_u8) as u32
+    }
+    if byte >= 97_u8 && byte <= 102_u8 {
+        return (byte - 87_u8) as u32
+    }
+    if byte >= 65_u8 && byte <= 70_u8 {
+        return (byte - 55_u8) as u32
+    }
+    return 4294967295_u32
+}
+
+fn __zero_std_inet_parse_ipv6(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    if std.mem.len(buffer) < 16 {
+        return null
+    }
+    let len: usize = std.mem.len(text)
+    if len == 0 {
+        return null
+    }
+    var head: [8]u32 = [0; 8]
+    var tail: [8]u32 = [0; 8]
+    var head_count: usize = 0
+    var tail_count: usize = 0
+    var seen_gap: Bool = false
+    var pos: usize = 0
+    if text[0] == 58_u8 {
+        if len < 2 || text[1] != 58_u8 {
+            return null
+        }
+        seen_gap = true
+        pos = 2
+    }
+    while pos < len {
+        var token_end: usize = pos
+        var has_dot: Bool = false
+        while token_end < len && text[token_end] != 58_u8 {
+            if text[token_end] == 46_u8 {
+                has_dot = true
+            }
+            token_end = token_end + 1
+        }
+        if token_end == pos {
+            return null
+        }
+        if has_dot {
+            if token_end != len {
+                return null
+            }
+            let v4: u64 = __zero_std_inet_ipv4_core(text[pos..len])
+            if v4 == 0 {
+                return null
+            }
+            let quad: u32 = (v4 % 4294967296_u64) as u32
+            if seen_gap {
+                if tail_count + 2 > 8 {
+                    return null
+                }
+                tail[tail_count] = quad / 65536_u32
+                tail[tail_count + 1] = quad % 65536_u32
+                tail_count = tail_count + 2
+            } else {
+                if head_count + 2 > 8 {
+                    return null
+                }
+                head[head_count] = quad / 65536_u32
+                head[head_count + 1] = quad % 65536_u32
+                head_count = head_count + 2
+            }
+            pos = len
+            break
+        }
+        if token_end - pos > 4 {
+            return null
+        }
+        var group: u32 = 0
+        var scan: usize = pos
+        while scan < token_end {
+            let digit: u32 = __zero_std_inet_hex_value(text[scan])
+            if digit == 4294967295_u32 {
+                return null
+            }
+            group = group * 16_u32 + digit
+            scan = scan + 1
+        }
+        if seen_gap {
+            if tail_count + 1 > 8 {
+                return null
+            }
+            tail[tail_count] = group
+            tail_count = tail_count + 1
+        } else {
+            if head_count + 1 > 8 {
+                return null
+            }
+            head[head_count] = group
+            head_count = head_count + 1
+        }
+        pos = token_end
+        if pos < len {
+            pos = pos + 1
+            if pos < len && text[pos] == 58_u8 {
+                if seen_gap {
+                    return null
+                }
+                seen_gap = true
+                pos = pos + 1
+                if pos == len {
+                    break
+                }
+            } else if pos == len {
+                return null
+            }
+        }
+    }
+    let total: usize = head_count + tail_count
+    if seen_gap {
+        if total > 7 {
+            return null
+        }
+    } else {
+        if total != 8 {
+            return null
+        }
+    }
+    var groups: [8]u32 = [0; 8]
+    var index: usize = 0
+    while index < head_count {
+        groups[index] = head[index]
+        index = index + 1
+    }
+    var tail_index: usize = 0
+    while tail_index < tail_count {
+        groups[8 - tail_count + tail_index] = tail[tail_index]
+        tail_index = tail_index + 1
+    }
+    var out_index: usize = 0
+    while out_index < 8 {
+        buffer[out_index * 2] = (groups[out_index] / 256_u32) as u8
+        buffer[out_index * 2 + 1] = (groups[out_index] % 256_u32) as u8
+        out_index = out_index + 1
+    }
+    return buffer[..16]
+}
+
+fn __zero_std_inet_is_ipv6(text: Span<u8>) -> Bool {
+    var storage: [16]u8 = [0; 16]
+    let buffer: MutSpan<u8> = storage
+    let parsed: Maybe<Span<u8>> = __zero_std_inet_parse_ipv6(buffer, text)
+    return parsed.has
+}
+
+fn __zero_std_inet_is_ip(text: Span<u8>) -> Bool {
+    return __zero_std_inet_is_ipv4(text) || __zero_std_inet_is_ipv6(text)
+}
+
+fn __zero_std_inet_parse_ip(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    let ipv4: Maybe<u32> = __zero_std_inet_parse_ipv4(text)
+    if ipv4.has {
+        return __zero_std_inet_ipv4_to_bytes(buffer, ipv4.value)
+    }
+    return __zero_std_inet_parse_ipv6(buffer, text)
+}
+
+fn __zero_std_inet_is_ipv6_unspecified(bytes: Span<u8>) -> Bool {
+    if std.mem.len(bytes) != 16 {
+        return false
+    }
+    var index: usize = 0
+    while index < 16 {
+        if bytes[index] != 0_u8 {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_inet_is_ipv6_loopback(bytes: Span<u8>) -> Bool {
+    if std.mem.len(bytes) != 16 {
+        return false
+    }
+    var index: usize = 0
+    while index < 15 {
+        if bytes[index] != 0_u8 {
+            return false
+        }
+        index = index + 1
+    }
+    return bytes[15] == 1_u8
+}
+
+fn __zero_std_inet_is_ipv6_multicast(bytes: Span<u8>) -> Bool {
+    return std.mem.len(bytes) == 16 && bytes[0] == 255_u8
+}
+
+fn __zero_std_inet_is_ipv6_link_local(bytes: Span<u8>) -> Bool {
+    return std.mem.len(bytes) == 16 && (bytes[0] == 254_u8 && (bytes[1] >= 128_u8 && bytes[1] <= 191_u8))
+}
+
+fn __zero_std_inet_is_ipv6_private(bytes: Span<u8>) -> Bool {
+    return std.mem.len(bytes) == 16 && (bytes[0] == 252_u8 || bytes[0] == 253_u8)
+}
+
+fn __zero_std_inet_is_ipv6_unique_local(bytes: Span<u8>) -> Bool {
+    return __zero_std_inet_is_ipv6_private(bytes)
+}
+
+fn __zero_std_inet_is_ipv6_mapped_ipv4(bytes: Span<u8>) -> Bool {
+    if std.mem.len(bytes) != 16 {
+        return false
+    }
+    var index: usize = 0
+    while index < 10 {
+        if bytes[index] != 0_u8 {
+            return false
+        }
+        index = index + 1
+    }
+    return bytes[10] == 255_u8 && bytes[11] == 255_u8
+}
+
+fn __zero_std_inet_ipv6_mapped_ipv4(bytes: Span<u8>) -> Maybe<u32> {
+    if !__zero_std_inet_is_ipv6_mapped_ipv4(bytes) {
+        return null
+    }
+    return (bytes[12] as u32) * 16777216_u32 + (bytes[13] as u32) * 65536_u32 + (bytes[14] as u32) * 256_u32 + (bytes[15] as u32)
+}
+
+fn __zero_std_inet_is_hostname(text: Span<u8>) -> Bool {
+    let len: usize = std.mem.len(text)
+    if len == 0 || len > 253 {
+        return false
+    }
+    var pos: usize = 0
+    var label_len: usize = 0
+    while pos < len {
+        let byte: u8 = text[pos]
+        if byte == 46_u8 {
+            if label_len == 0 {
+                return false
+            }
+            if text[pos - 1] == 45_u8 {
+                return false
+            }
+            label_len = 0
+        } else {
+            if label_len == 0 && byte == 45_u8 {
+                return false
+            }
+            let is_alnum: Bool = (byte >= 48_u8 && byte <= 57_u8) || ((byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8))
+            if !is_alnum && byte != 45_u8 {
+                return false
+            }
+            label_len = label_len + 1
+            if label_len > 63 {
+                return false
+            }
+        }
+        pos = pos + 1
+    }
+    if label_len == 0 {
+        return false
+    }
+    return text[len - 1] != 45_u8
+}

std/io.0

@@ -0,0 +1,539 @@
+type FixedReader {
+    bytes: Span<u8>,
+    cursor: usize,
+}
+
+type FixedWriter {
+    buffer: MutSpan<u8>,
+    cursor: usize,
+}
+
+fn __zero_std_io_write_byte(buffer: MutSpan<u8>, offset: usize, byte: u8) -> Maybe<usize> {
+    if offset >= std.mem.len(buffer) {
+        return null
+    }
+    buffer[offset] = byte
+    return offset + 1
+}
+
+fn __zero_std_io_write_span(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    if std.mem.len(bytes) > std.mem.len(buffer) - offset {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        buffer[offset + index] = bytes[index]
+        index = index + 1
+    }
+    return offset + std.mem.len(bytes)
+}
+
+fn __zero_std_io_write_all(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    return __zero_std_io_write_span(buffer, offset, bytes)
+}
+
+fn __zero_std_io_write_at(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    return __zero_std_io_write_span(buffer, offset, bytes)
+}
+
+fn __zero_std_io_read(bytes: Span<u8>, offset: usize, buffer: MutSpan<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(bytes) {
+        return null
+    }
+    let available: usize = std.mem.len(bytes) - offset
+    var count: usize = std.mem.len(buffer)
+    if available < count {
+        count = available
+    }
+    var index: usize = 0
+    while index < count {
+        buffer[index] = bytes[offset + index]
+        index = index + 1
+    }
+    return offset + count
+}
+
+fn __zero_std_io_read_exact(bytes: Span<u8>, offset: usize, buffer: MutSpan<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(bytes) {
+        return null
+    }
+    if std.mem.len(buffer) > std.mem.len(bytes) - offset {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(buffer) {
+        buffer[index] = bytes[offset + index]
+        index = index + 1
+    }
+    return offset + std.mem.len(buffer)
+}
+
+fn __zero_std_io_read_at(bytes: Span<u8>, offset: usize, buffer: MutSpan<u8>) -> Maybe<usize> {
+    return __zero_std_io_read(bytes, offset, buffer)
+}
+
+fn __zero_std_io_read_all(bytes: Span<u8>, buffer: MutSpan<u8>) -> Maybe<Span<u8>> {
+    let count: usize = std.mem.len(bytes)
+    let copied: Maybe<usize> = __zero_std_io_copy_n(buffer, bytes, count)
+    if copied.has {
+        return __zero_std_io_written(buffer, copied.value)
+    }
+    return null
+}
+
+fn __zero_std_io_copy(buffer: MutSpan<u8>, bytes: Span<u8>) -> usize {
+    var count: usize = std.mem.len(bytes)
+    if std.mem.len(buffer) < count {
+        count = std.mem.len(buffer)
+    }
+    var index: usize = 0
+    while index < count {
+        buffer[index] = bytes[index]
+        index = index + 1
+    }
+    return count
+}
+
+fn __zero_std_io_read_byte(bytes: Span<u8>, offset: usize) -> Maybe<u8> {
+    if offset >= std.mem.len(bytes) {
+        return null
+    }
+    return bytes[offset]
+}
+
+fn __zero_std_io_copy_n(buffer: MutSpan<u8>, bytes: Span<u8>, count: usize) -> Maybe<usize> {
+    if count > std.mem.len(buffer) {
+        return null
+    }
+    if count > std.mem.len(bytes) {
+        return null
+    }
+    var index: usize = 0
+    while index < count {
+        buffer[index] = bytes[index]
+        index = index + 1
+    }
+    return count
+}
+
+fn __zero_std_io_written(buffer: Span<u8>, len: usize) -> Span<u8> {
+    if len > std.mem.len(buffer) {
+        return buffer
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_io_remaining(buffer: Span<u8>, offset: usize) -> usize {
+    if offset >= std.mem.len(buffer) {
+        return 0
+    }
+    return std.mem.len(buffer) - offset
+}
+
+fn __zero_std_io_next_line(bytes: Span<u8>, start: usize) -> Maybe<Span<u8>> {
+    if start >= std.mem.len(bytes) {
+        return null
+    }
+    var end: usize = start
+    while end < std.mem.len(bytes) && bytes[end] != 10_u8 {
+        end = end + 1
+    }
+    if end > start && bytes[end - 1] == 13_u8 {
+        return bytes[start..end - 1]
+    }
+    return bytes[start..end]
+}
+
+fn __zero_std_io_read_line(bytes: Span<u8>, start: usize) -> Maybe<Span<u8>> {
+    return __zero_std_io_next_line(bytes, start)
+}
+
+fn __zero_std_io_next_line_start(bytes: Span<u8>, start: usize) -> usize {
+    if start >= std.mem.len(bytes) {
+        return std.mem.len(bytes)
+    }
+    var end: usize = start
+    while end < std.mem.len(bytes) && bytes[end] != 10_u8 {
+        end = end + 1
+    }
+    if end < std.mem.len(bytes) {
+        return end + 1
+    }
+    return std.mem.len(bytes)
+}
+
+fn __zero_std_io_read_line_start(bytes: Span<u8>, start: usize) -> usize {
+    return __zero_std_io_next_line_start(bytes, start)
+}
+
+fn __zero_std_io_read_until_delimiter(bytes: Span<u8>, start: usize, delimiter: u8) -> Maybe<Span<u8>> {
+    if start >= std.mem.len(bytes) {
+        return null
+    }
+    var end: usize = start
+    while end < std.mem.len(bytes) && bytes[end] != delimiter {
+        end = end + 1
+    }
+    return bytes[start..end]
+}
+
+fn __zero_std_io_read_until_delimiter_start(bytes: Span<u8>, start: usize, delimiter: u8) -> usize {
+    if start >= std.mem.len(bytes) {
+        return std.mem.len(bytes)
+    }
+    var end: usize = start
+    while end < std.mem.len(bytes) && bytes[end] != delimiter {
+        end = end + 1
+    }
+    if end < std.mem.len(bytes) {
+        return end + 1
+    }
+    return std.mem.len(bytes)
+}
+
+fn __zero_std_io_fixed_reader(bytes: Span<u8>, cursor: usize) -> FixedReader {
+    var start: usize = cursor
+    if start > std.mem.len(bytes) {
+        start = std.mem.len(bytes)
+    }
+    return FixedReader { bytes: bytes, cursor: start }
+}
+
+fn __zero_std_io_fixed_reader_cursor(reader: ref<FixedReader>) -> usize {
+    return reader.cursor
+}
+
+fn __zero_std_io_fixed_reader_len(reader: ref<FixedReader>) -> usize {
+    return std.mem.len(reader.bytes)
+}
+
+fn __zero_std_io_fixed_reader_remaining(reader: ref<FixedReader>) -> usize {
+    return __zero_std_io_remaining(reader.bytes, reader.cursor)
+}
+
+fn __zero_std_io_fixed_reader_done(reader: ref<FixedReader>) -> Bool {
+    return reader.cursor >= std.mem.len(reader.bytes)
+}
+
+fn __zero_std_io_fixed_reader_seek(reader: mutref<FixedReader>, cursor: usize) -> Bool {
+    if cursor > std.mem.len(reader.bytes) {
+        return false
+    }
+    reader.cursor = cursor
+    return true
+}
+
+fn __zero_std_io_fixed_reader_limit(reader: ref<FixedReader>, count: usize) -> FixedReader {
+    let bytes: Span<u8> = std.mem.cursorChunk(reader.bytes, reader.cursor, count)
+    return FixedReader { bytes: bytes, cursor: 0 }
+}
+
+fn __zero_std_io_fixed_reader_read(reader: mutref<FixedReader>, buffer: MutSpan<u8>) -> usize {
+    let before: usize = reader.cursor
+    let next: Maybe<usize> = __zero_std_io_read(reader.bytes, before, buffer)
+    if next.has {
+        reader.cursor = next.value
+        return next.value - before
+    }
+    return 0
+}
+
+fn __zero_std_io_fixed_reader_read_exact(reader: mutref<FixedReader>, buffer: MutSpan<u8>) -> Bool {
+    let next: Maybe<usize> = __zero_std_io_read_exact(reader.bytes, reader.cursor, buffer)
+    if next.has {
+        reader.cursor = next.value
+        return true
+    }
+    return false
+}
+
+fn __zero_std_io_fixed_reader_read_at(reader: ref<FixedReader>, offset: usize, buffer: MutSpan<u8>) -> Maybe<usize> {
+    return __zero_std_io_read(reader.bytes, offset, buffer)
+}
+
+fn __zero_std_io_fixed_reader_read_byte(reader: mutref<FixedReader>) -> Maybe<u8> {
+    let byte: Maybe<u8> = __zero_std_io_read_byte(reader.bytes, reader.cursor)
+    if byte.has {
+        reader.cursor = reader.cursor + 1
+    }
+    return byte
+}
+
+fn __zero_std_io_fixed_reader_read_line(reader: mutref<FixedReader>) -> Maybe<Span<u8>> {
+    let line: Maybe<Span<u8>> = __zero_std_io_next_line(reader.bytes, reader.cursor)
+    if line.has {
+        reader.cursor = __zero_std_io_next_line_start(reader.bytes, reader.cursor)
+    }
+    return line
+}
+
+fn __zero_std_io_fixed_reader_read_until_delimiter(reader: mutref<FixedReader>, delimiter: u8) -> Maybe<Span<u8>> {
+    let chunk: Maybe<Span<u8>> = __zero_std_io_read_until_delimiter(reader.bytes, reader.cursor, delimiter)
+    if chunk.has {
+        reader.cursor = __zero_std_io_read_until_delimiter_start(reader.bytes, reader.cursor, delimiter)
+    }
+    return chunk
+}
+
+fn __zero_std_io_fixed_reader_read_all(reader: mutref<FixedReader>, buffer: MutSpan<u8>) -> Maybe<Span<u8>> {
+    let remaining: usize = __zero_std_io_fixed_reader_remaining(reader)
+    if remaining > std.mem.len(buffer) {
+        return null
+    }
+    let copied: Maybe<usize> = __zero_std_io_copy_n(buffer, reader.bytes[reader.cursor..], remaining)
+    if copied.has {
+        reader.cursor = std.mem.len(reader.bytes)
+        return __zero_std_io_written(buffer, copied.value)
+    }
+    return null
+}
+
+fn __zero_std_io_fixed_writer(buffer: MutSpan<u8>, cursor: usize) -> FixedWriter {
+    var start: usize = cursor
+    if start > std.mem.len(buffer) {
+        start = std.mem.len(buffer)
+    }
+    return FixedWriter { buffer: buffer, cursor: start }
+}
+
+fn __zero_std_io_fixed_writer_cursor(writer: ref<FixedWriter>) -> usize {
+    return writer.cursor
+}
+
+fn __zero_std_io_fixed_writer_capacity(writer: ref<FixedWriter>) -> usize {
+    return std.mem.len(writer.buffer)
+}
+
+fn __zero_std_io_fixed_writer_remaining(writer: ref<FixedWriter>) -> usize {
+    return __zero_std_io_remaining(writer.buffer, writer.cursor)
+}
+
+fn __zero_std_io_fixed_writer_view(writer: ref<FixedWriter>) -> Span<u8> {
+    return __zero_std_io_written(writer.buffer, writer.cursor)
+}
+
+fn __zero_std_io_fixed_writer_clear(writer: mutref<FixedWriter>) -> usize {
+    writer.cursor = 0
+    return writer.cursor
+}
+
+fn __zero_std_io_fixed_writer_truncate(writer: mutref<FixedWriter>, len: usize) -> usize {
+    if len < writer.cursor {
+        writer.cursor = len
+    }
+    return writer.cursor
+}
+
+fn __zero_std_io_fixed_writer_seek(writer: mutref<FixedWriter>, cursor: usize) -> Bool {
+    if cursor > std.mem.len(writer.buffer) {
+        return false
+    }
+    writer.cursor = cursor
+    return true
+}
+
+fn __zero_std_io_fixed_writer_write_byte(writer: mutref<FixedWriter>, byte: u8) -> Bool {
+    let next: Maybe<usize> = __zero_std_io_write_byte(writer.buffer, writer.cursor, byte)
+    if next.has {
+        writer.cursor = next.value
+        return true
+    }
+    return false
+}
+
+fn __zero_std_io_fixed_writer_write(writer: mutref<FixedWriter>, bytes: Span<u8>) -> Bool {
+    let next: Maybe<usize> = __zero_std_io_write_all(writer.buffer, writer.cursor, bytes)
+    if next.has {
+        writer.cursor = next.value
+        return true
+    }
+    return false
+}
+
+fn __zero_std_io_fixed_writer_write_all(writer: mutref<FixedWriter>, bytes: Span<u8>) -> Bool {
+    return __zero_std_io_fixed_writer_write(writer, bytes)
+}
+
+fn __zero_std_io_fixed_writer_write_at(writer: mutref<FixedWriter>, offset: usize, bytes: Span<u8>) -> Bool {
+    let next: Maybe<usize> = __zero_std_io_write_at(writer.buffer, offset, bytes)
+    return next.has
+}
+
+fn __zero_std_io_copy_buffer(reader: mutref<FixedReader>, writer: mutref<FixedWriter>, scratch: MutSpan<u8>) -> usize {
+    if std.mem.len(scratch) == 0 {
+        return 0
+    }
+    var total: usize = 0
+    while true {
+        let writable: usize = __zero_std_io_fixed_writer_remaining(writer)
+        if writable == 0 {
+            return total
+        }
+        var chunk_len: usize = std.mem.len(scratch)
+        if writable < chunk_len {
+            chunk_len = writable
+        }
+        let chunk_buffer: MutSpan<u8> = scratch[..chunk_len]
+        let before: usize = reader.cursor
+        let count: usize = __zero_std_io_fixed_reader_read(reader, chunk_buffer)
+        if count == 0 {
+            return total
+        }
+        let chunk: Span<u8> = __zero_std_io_written(chunk_buffer, count)
+        if !__zero_std_io_fixed_writer_write_all(writer, chunk) {
+            reader.cursor = before
+            return total
+        }
+        total = total + count
+    }
+    return total
+}
+
+fn __zero_std_io_copy_reader_n(reader: mutref<FixedReader>, writer: mutref<FixedWriter>, count: usize, scratch: MutSpan<u8>) -> Maybe<usize> {
+    if count == 0 {
+        return 0_usize
+    }
+    if std.mem.len(scratch) == 0 {
+        return null
+    }
+    let reader_start: usize = reader.cursor
+    let writer_start: usize = writer.cursor
+    if count > __zero_std_io_fixed_reader_remaining(reader) {
+        return null
+    }
+    if count > __zero_std_io_fixed_writer_remaining(writer) {
+        return null
+    }
+    var copied: usize = 0
+    while copied < count {
+        var chunk_len: usize = count - copied
+        if chunk_len > std.mem.len(scratch) {
+            chunk_len = std.mem.len(scratch)
+        }
+        let chunk_buffer: MutSpan<u8> = scratch[..chunk_len]
+        if !__zero_std_io_fixed_reader_read_exact(reader, chunk_buffer) {
+            reader.cursor = reader_start
+            writer.cursor = writer_start
+            return null
+        }
+        let chunk: Span<u8> = __zero_std_io_written(chunk_buffer, chunk_len)
+        if !__zero_std_io_fixed_writer_write_all(writer, chunk) {
+            reader.cursor = reader_start
+            writer.cursor = writer_start
+            return null
+        }
+        copied = copied + chunk_len
+    }
+    return copied
+}
+
+fn __zero_std_io_discard(reader: mutref<FixedReader>, scratch: MutSpan<u8>) -> usize {
+    if std.mem.len(scratch) == 0 {
+        return 0
+    }
+    var total: usize = 0
+    while true {
+        let count: usize = __zero_std_io_fixed_reader_read(reader, scratch)
+        if count == 0 {
+            return total
+        }
+        total = total + count
+    }
+    return total
+}
+
+fn __zero_std_io_tee_read(reader: mutref<FixedReader>, writer: mutref<FixedWriter>, buffer: MutSpan<u8>) -> Maybe<usize> {
+    let before: usize = reader.cursor
+    let count: usize = __zero_std_io_fixed_reader_read(reader, buffer)
+    if count == 0 {
+        return 0_usize
+    }
+    let chunk: Span<u8> = __zero_std_io_written(buffer, count)
+    if __zero_std_io_fixed_writer_write_all(writer, chunk) {
+        return count
+    }
+    reader.cursor = before
+    return null
+}
+
+fn __zero_std_io_multi_read(first: mutref<FixedReader>, second: mutref<FixedReader>, buffer: MutSpan<u8>) -> usize {
+    let first_count: usize = __zero_std_io_fixed_reader_read(first, buffer)
+    if first_count >= std.mem.len(buffer) {
+        return first_count
+    }
+    let second_count: usize = __zero_std_io_fixed_reader_read(second, buffer[first_count..])
+    return first_count + second_count
+}
+
+fn __zero_std_io_error_none() -> u32 {
+    return 0_u32
+}
+
+fn __zero_std_io_error_eof() -> u32 {
+    return 1_u32
+}
+
+fn __zero_std_io_error_short_read() -> u32 {
+    return 2_u32
+}
+
+fn __zero_std_io_error_short_write() -> u32 {
+    return 3_u32
+}
+
+fn __zero_std_io_error_capacity() -> u32 {
+    return 4_u32
+}
+
+fn __zero_std_io_error_permission() -> u32 {
+    return 5_u32
+}
+
+fn __zero_std_io_error_timeout() -> u32 {
+    return 6_u32
+}
+
+fn __zero_std_io_error_io() -> u32 {
+    return 7_u32
+}
+
+fn __zero_std_io_error_name(code: u32) -> String {
+    if code == 0_u32 {
+        return "none"
+    }
+    if code == 1_u32 {
+        return "eof"
+    }
+    if code == 2_u32 {
+        return "short_read"
+    }
+    if code == 3_u32 {
+        return "short_write"
+    }
+    if code == 4_u32 {
+        return "capacity"
+    }
+    if code == 5_u32 {
+        return "permission"
+    }
+    if code == 6_u32 {
+        return "timeout"
+    }
+    if code == 7_u32 {
+        return "io"
+    }
+    return "unknown"
+}
+
+fn __zero_std_io_count_lines(bytes: Span<u8>) -> usize {
+    var start: usize = 0
+    var count: usize = 0
+    while start < std.mem.len(bytes) {
+        count = count + 1
+        start = __zero_std_io_next_line_start(bytes, start)
+    }
+    return count
+}

std/log.0

@@ -0,0 +1,191 @@
+fn __zero_std_log_write(buffer: MutSpan<u8>, offset: usize, bytes: Span<u8>) -> Maybe<usize> {
+    return std.io.writeSpan(buffer, offset, bytes)
+}
+
+fn __zero_std_log_write_json(buffer: MutSpan<u8>, offset: usize, value: Span<u8>) -> Maybe<usize> {
+    if offset > std.mem.len(buffer) {
+        return null
+    }
+    let written: Maybe<Span<u8>> = std.json.writeStringBytes(buffer[offset..], value)
+    if written.has {
+        return offset + std.mem.len(written.value)
+    }
+    return null
+}
+
+fn __zero_std_log_message(buffer: MutSpan<u8>, level: Span<u8>, message: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let opened: Maybe<usize> = __zero_std_log_write(buffer, offset, "{\"level\":")
+    if !opened.has {
+        return null
+    }
+    offset = opened.value
+    let wrote_level: Maybe<usize> = __zero_std_log_write_json(buffer, offset, level)
+    if !wrote_level.has {
+        return null
+    }
+    offset = wrote_level.value
+    let wrote_message_key: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"message\":")
+    if !wrote_message_key.has {
+        return null
+    }
+    offset = wrote_message_key.value
+    let wrote_message: Maybe<usize> = __zero_std_log_write_json(buffer, offset, message)
+    if !wrote_message.has {
+        return null
+    }
+    offset = wrote_message.value
+    let closed: Maybe<usize> = __zero_std_log_write(buffer, offset, "}\n")
+    if closed.has {
+        return buffer[..closed.value]
+    }
+    return null
+}
+
+fn __zero_std_log_key_value(buffer: MutSpan<u8>, level: Span<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let opened: Maybe<usize> = __zero_std_log_write(buffer, offset, "{\"level\":")
+    if !opened.has {
+        return null
+    }
+    offset = opened.value
+    let wrote_level: Maybe<usize> = __zero_std_log_write_json(buffer, offset, level)
+    if !wrote_level.has {
+        return null
+    }
+    offset = wrote_level.value
+    let wrote_key_name: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"key\":")
+    if !wrote_key_name.has {
+        return null
+    }
+    offset = wrote_key_name.value
+    let wrote_key: Maybe<usize> = __zero_std_log_write_json(buffer, offset, key)
+    if !wrote_key.has {
+        return null
+    }
+    offset = wrote_key.value
+    let wrote_value_name: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"value\":")
+    if !wrote_value_name.has {
+        return null
+    }
+    offset = wrote_value_name.value
+    let wrote_value: Maybe<usize> = __zero_std_log_write_json(buffer, offset, value)
+    if !wrote_value.has {
+        return null
+    }
+    offset = wrote_value.value
+    let closed: Maybe<usize> = __zero_std_log_write(buffer, offset, "}\n")
+    if closed.has {
+        return buffer[..closed.value]
+    }
+    return null
+}
+
+fn __zero_std_log_level_debug() -> String {
+    return "debug"
+}
+
+fn __zero_std_log_level_info() -> String {
+    return "info"
+}
+
+fn __zero_std_log_level_warn() -> String {
+    return "warn"
+}
+
+fn __zero_std_log_level_error() -> String {
+    return "error"
+}
+
+fn __zero_std_log_write_string_field(buffer: MutSpan<u8>, offset: usize, key: Span<u8>, value: Span<u8>) -> Maybe<usize> {
+    let wrote_key: Maybe<usize> = __zero_std_log_write_json(buffer, offset, key)
+    if !wrote_key.has {
+        return null
+    }
+    var cursor: usize = wrote_key.value
+    let colon: Maybe<usize> = __zero_std_log_write(buffer, cursor, ":")
+    if !colon.has {
+        return null
+    }
+    cursor = colon.value
+    return __zero_std_log_write_json(buffer, cursor, value)
+}
+
+fn __zero_std_log_string_field(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    let written: Maybe<usize> = __zero_std_log_write_string_field(buffer, 0, key, value)
+    if written.has {
+        return buffer[..written.value]
+    }
+    return null
+}
+
+fn __zero_std_log_message_field(buffer: MutSpan<u8>, level: Span<u8>, message: Span<u8>, field: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let opened: Maybe<usize> = __zero_std_log_write(buffer, offset, "{\"level\":")
+    if !opened.has {
+        return null
+    }
+    offset = opened.value
+    let wrote_level: Maybe<usize> = __zero_std_log_write_json(buffer, offset, level)
+    if !wrote_level.has {
+        return null
+    }
+    offset = wrote_level.value
+    let wrote_message_key: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"message\":")
+    if !wrote_message_key.has {
+        return null
+    }
+    offset = wrote_message_key.value
+    let wrote_message: Maybe<usize> = __zero_std_log_write_json(buffer, offset, message)
+    if !wrote_message.has {
+        return null
+    }
+    offset = wrote_message.value
+    let comma: Maybe<usize> = __zero_std_log_write(buffer, offset, ",")
+    if !comma.has {
+        return null
+    }
+    offset = comma.value
+    let wrote_field: Maybe<usize> = __zero_std_log_write(buffer, offset, field)
+    if !wrote_field.has {
+        return null
+    }
+    offset = wrote_field.value
+    let closed: Maybe<usize> = __zero_std_log_write(buffer, offset, "}\n")
+    if closed.has {
+        if !std.json.validateBytes(buffer[..closed.value - 1]) {
+            return null
+        }
+        return buffer[..closed.value]
+    }
+    return null
+}
+
+fn __zero_std_log_redacted(buffer: MutSpan<u8>, level: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let opened: Maybe<usize> = __zero_std_log_write(buffer, offset, "{\"level\":")
+    if !opened.has {
+        return null
+    }
+    offset = opened.value
+    let wrote_level: Maybe<usize> = __zero_std_log_write_json(buffer, offset, level)
+    if !wrote_level.has {
+        return null
+    }
+    offset = wrote_level.value
+    let key_label: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"key\":")
+    if !key_label.has {
+        return null
+    }
+    offset = key_label.value
+    let wrote_key: Maybe<usize> = __zero_std_log_write_json(buffer, offset, key)
+    if !wrote_key.has {
+        return null
+    }
+    offset = wrote_key.value
+    let closed: Maybe<usize> = __zero_std_log_write(buffer, offset, ",\"redacted\":true}\n")
+    if closed.has {
+        return buffer[..closed.value]
+    }
+    return null
+}

std/math.0

@@ -0,0 +1,518 @@
+fn __zero_std_math_min_u32(left: u32, right: u32) -> u32 {
+    if left < right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_max_u32(left: u32, right: u32) -> u32 {
+    if left > right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_clamp_u32(value: u32, low: u32, high: u32) -> u32 {
+    let lower: u32 = __zero_std_math_min_u32(low, high)
+    let upper: u32 = __zero_std_math_max_u32(low, high)
+    if value < lower {
+        return lower
+    }
+    if value > upper {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_math_min_i32(left: i32, right: i32) -> i32 {
+    if left < right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_max_i32(left: i32, right: i32) -> i32 {
+    if left > right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_clamp_i32(value: i32, low: i32, high: i32) -> i32 {
+    let lower: i32 = __zero_std_math_min_i32(low, high)
+    let upper: i32 = __zero_std_math_max_i32(low, high)
+    if value < lower {
+        return lower
+    }
+    if value > upper {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_math_min_usize(left: usize, right: usize) -> usize {
+    if left < right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_max_usize(left: usize, right: usize) -> usize {
+    if left > right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_clamp_usize(value: usize, low: usize, high: usize) -> usize {
+    let lower: usize = __zero_std_math_min_usize(low, high)
+    let upper: usize = __zero_std_math_max_usize(low, high)
+    if value < lower {
+        return lower
+    }
+    if value > upper {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_math_min_i64(left: i64, right: i64) -> i64 {
+    if left < right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_max_i64(left: i64, right: i64) -> i64 {
+    if left > right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_clamp_i64(value: i64, low: i64, high: i64) -> i64 {
+    let lower: i64 = __zero_std_math_min_i64(low, high)
+    let upper: i64 = __zero_std_math_max_i64(low, high)
+    if value < lower {
+        return lower
+    }
+    if value > upper {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_math_min_u64(left: u64, right: u64) -> u64 {
+    if left < right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_max_u64(left: u64, right: u64) -> u64 {
+    if left > right {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_math_clamp_u64(value: u64, low: u64, high: u64) -> u64 {
+    let lower: u64 = __zero_std_math_min_u64(low, high)
+    let upper: u64 = __zero_std_math_max_u64(low, high)
+    if value < lower {
+        return lower
+    }
+    if value > upper {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_math_abs_i32(value: i32) -> u32 {
+    let min_i32: i32 = 0 - 2147483647 - 1
+    if value == min_i32 {
+        return 2147483648_u32
+    }
+    if value < 0 {
+        return (0 - value) as u32
+    }
+    return value as u32
+}
+
+fn __zero_std_math_abs_i64(value: i64) -> u64 {
+    let min_i64: i64 = 0 - 9223372036854775807 - 1
+    if value == min_i64 {
+        return 9223372036854775808_u64
+    }
+    if value < 0 {
+        return (0_i64 - value) as u64
+    }
+    return value as u64
+}
+
+fn __zero_std_math_checked_add_u32(left: u32, right: u32) -> Maybe<u32> {
+    if left > 4294967295_u32 - right {
+        return null
+    }
+    return left + right
+}
+
+fn __zero_std_math_checked_sub_u32(left: u32, right: u32) -> Maybe<u32> {
+    if left < right {
+        return null
+    }
+    return left - right
+}
+
+fn __zero_std_math_checked_mul_u32(left: u32, right: u32) -> Maybe<u32> {
+    if left != 0 && right > 4294967295_u32 / left {
+        return null
+    }
+    return left * right
+}
+
+fn __zero_std_math_saturating_add_u32(left: u32, right: u32) -> u32 {
+    let result: Maybe<u32> = __zero_std_math_checked_add_u32(left, right)
+    if result.has {
+        return result.value
+    }
+    return 4294967295_u32
+}
+
+fn __zero_std_math_saturating_sub_u32(left: u32, right: u32) -> u32 {
+    let result: Maybe<u32> = __zero_std_math_checked_sub_u32(left, right)
+    if result.has {
+        return result.value
+    }
+    return 0
+}
+
+fn __zero_std_math_saturating_mul_u32(left: u32, right: u32) -> u32 {
+    let result: Maybe<u32> = __zero_std_math_checked_mul_u32(left, right)
+    if result.has {
+        return result.value
+    }
+    return 4294967295_u32
+}
+
+fn __zero_std_math_checked_add_usize(left: usize, right: usize) -> Maybe<usize> {
+    let max: usize = 18446744073709551615
+    if left > max - right {
+        return null
+    }
+    return left + right
+}
+
+fn __zero_std_math_checked_sub_usize(left: usize, right: usize) -> Maybe<usize> {
+    if left < right {
+        return null
+    }
+    return left - right
+}
+
+fn __zero_std_math_checked_mul_usize(left: usize, right: usize) -> Maybe<usize> {
+    let max: usize = 18446744073709551615
+    if left != 0 && right > max / left {
+        return null
+    }
+    return left * right
+}
+
+fn __zero_std_math_saturating_add_usize(left: usize, right: usize) -> usize {
+    let result: Maybe<usize> = __zero_std_math_checked_add_usize(left, right)
+    if result.has {
+        return result.value
+    }
+    return 18446744073709551615
+}
+
+fn __zero_std_math_saturating_sub_usize(left: usize, right: usize) -> usize {
+    let result: Maybe<usize> = __zero_std_math_checked_sub_usize(left, right)
+    if result.has {
+        return result.value
+    }
+    return 0
+}
+
+fn __zero_std_math_saturating_mul_usize(left: usize, right: usize) -> usize {
+    let result: Maybe<usize> = __zero_std_math_checked_mul_usize(left, right)
+    if result.has {
+        return result.value
+    }
+    return 18446744073709551615
+}
+
+fn __zero_std_math_checked_add_i32(left: i32, right: i32) -> Maybe<i32> {
+    let max: i32 = 2147483647
+    let min: i32 = 0 - 2147483647 - 1
+    if right > 0 && left > max - right {
+        return null
+    }
+    if right < 0 && left < min - right {
+        return null
+    }
+    return left + right
+}
+
+fn __zero_std_math_checked_sub_i32(left: i32, right: i32) -> Maybe<i32> {
+    let max: i32 = 2147483647
+    let min: i32 = 0 - 2147483647 - 1
+    if right > 0 && left < min + right {
+        return null
+    }
+    if right < 0 && left > max + right {
+        return null
+    }
+    return left - right
+}
+
+fn __zero_std_math_checked_mul_i32(left: i32, right: i32) -> Maybe<i32> {
+    let max: i64 = 2147483647
+    let min: i64 = 0 - 2147483647 - 1
+    let wide: i64 = (left as i64) * (right as i64)
+    if wide > max || wide < min {
+        return null
+    }
+    return wide as i32
+}
+
+fn __zero_std_math_saturating_add_i32(left: i32, right: i32) -> i32 {
+    let result: Maybe<i32> = __zero_std_math_checked_add_i32(left, right)
+    if result.has {
+        return result.value
+    }
+    if right > 0 {
+        return 2147483647
+    }
+    return 0 - 2147483647 - 1
+}
+
+fn __zero_std_math_saturating_sub_i32(left: i32, right: i32) -> i32 {
+    let result: Maybe<i32> = __zero_std_math_checked_sub_i32(left, right)
+    if result.has {
+        return result.value
+    }
+    if right > 0 {
+        return 0 - 2147483647 - 1
+    }
+    return 2147483647
+}
+
+fn __zero_std_math_saturating_mul_i32(left: i32, right: i32) -> i32 {
+    let result: Maybe<i32> = __zero_std_math_checked_mul_i32(left, right)
+    if result.has {
+        return result.value
+    }
+    if (left < 0 && right < 0) || (left > 0 && right > 0) {
+        return 2147483647
+    }
+    return 0 - 2147483647 - 1
+}
+
+fn __zero_std_math_gcd_u32(a0: u32, b0: u32) -> u32 {
+    var a: u32 = a0
+    var b: u32 = b0
+    while b != 0 {
+        let next: u32 = a % b
+        a = b
+        b = next
+    }
+    return a
+}
+
+fn __zero_std_math_lcm_u32(left: u32, right: u32) -> u32 {
+    if left == 0 || right == 0 {
+        return 0
+    }
+    return left / __zero_std_math_gcd_u32(left, right) * right
+}
+
+fn __zero_std_math_checked_lcm_u32(left: u32, right: u32) -> Maybe<u32> {
+    if left == 0 || right == 0 {
+        return 0_u32
+    }
+    return __zero_std_math_checked_mul_u32(left / __zero_std_math_gcd_u32(left, right), right)
+}
+
+fn __zero_std_math_pow_u32(base: u32, exponent: u32) -> u32 {
+    var result: u32 = 1
+    var current: u32 = base
+    var exp: u32 = exponent
+    while exp > 0 {
+        if exp % 2 == 1 {
+            result = result * current
+        }
+        current = current * current
+        exp = exp / 2
+    }
+    return result
+}
+
+fn __zero_std_math_checked_pow_u32(base: u32, exponent: u32) -> Maybe<u32> {
+    var result: u32 = 1
+    var current: u32 = base
+    var exp: u32 = exponent
+    while exp > 0 {
+        if exp % 2 == 1 {
+            let next_result: Maybe<u32> = __zero_std_math_checked_mul_u32(result, current)
+            if !next_result.has {
+                return null
+            }
+            result = next_result.value
+        }
+        exp = exp / 2
+        if exp > 0 {
+            let next_current: Maybe<u32> = __zero_std_math_checked_mul_u32(current, current)
+            if !next_current.has {
+                return null
+            }
+            current = next_current.value
+        }
+    }
+    return result
+}
+
+fn __zero_std_math_mod_pow_u32(base: u32, exponent: u32, modulus: u32) -> u32 {
+    if modulus == 0 {
+        return 0
+    }
+    let wide_modulus: u64 = modulus as u64
+    var result: u64 = 1_u64 % wide_modulus
+    var current: u64 = (base as u64) % wide_modulus
+    var exp: u32 = exponent
+    while exp > 0 {
+        if exp % 2 == 1 {
+            result = result * current % wide_modulus
+        }
+        current = current * current % wide_modulus
+        exp = exp / 2
+    }
+    return result as u32
+}
+
+fn __zero_std_math_is_prime_u32(value: u32) -> Bool {
+    if value < 2 {
+        return false
+    }
+    if value == 2 {
+        return true
+    }
+    if value % 2 == 0 {
+        return false
+    }
+    var divisor: u32 = 3
+    while divisor <= value / divisor {
+        if value % divisor == 0 {
+            return false
+        }
+        divisor = divisor + 2
+    }
+    return true
+}
+
+fn __zero_std_math_is_even_u32(value: u32) -> Bool {
+    return value % 2 == 0
+}
+
+fn __zero_std_math_is_odd_u32(value: u32) -> Bool {
+    return value % 2 == 1
+}
+
+fn __zero_std_math_sqrt_floor_u32(value: u32) -> u32 {
+    var low: u32 = 0
+    var high: u32 = 65536
+    while low + 1 < high {
+        let mid: u32 = low + (high - low) / 2
+        if mid <= value / mid {
+            low = mid
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_math_factorial_u32(value: u32) -> Maybe<u32> {
+    var result: u32 = 1
+    var next: u32 = 2
+    while next <= value {
+        let multiplied: Maybe<u32> = __zero_std_math_checked_mul_u32(result, next)
+        if !multiplied.has {
+            return null
+        }
+        result = multiplied.value
+        next = next + 1
+    }
+    return result
+}
+
+fn __zero_std_math_binomial_u32(n: u32, k0: u32) -> Maybe<u32> {
+    if k0 > n {
+        return null
+    }
+    var k: u32 = k0
+    if k > n - k {
+        k = n - k
+    }
+    var result: u32 = 1
+    var i: u32 = 1
+    while i <= k {
+        var numerator: u32 = n - k + i
+        var denominator: u32 = i
+        let numerator_gcd: u32 = __zero_std_math_gcd_u32(numerator, denominator)
+        numerator = numerator / numerator_gcd
+        denominator = denominator / numerator_gcd
+        let result_gcd: u32 = __zero_std_math_gcd_u32(result, denominator)
+        result = result / result_gcd
+        denominator = denominator / result_gcd
+        if denominator != 1 {
+            return null
+        }
+        let multiplied: Maybe<u32> = __zero_std_math_checked_mul_u32(result, numerator)
+        if !multiplied.has {
+            return null
+        }
+        result = multiplied.value
+        i = i + 1
+    }
+    return result
+}
+
+fn __zero_std_math_divisor_count_u32(value: u32) -> u32 {
+    if value == 0 {
+        return 0
+    }
+    var count: u32 = 0
+    var divisor: u32 = 1
+    while divisor <= value / divisor {
+        if value % divisor == 0 {
+            let paired: u32 = value / divisor
+            if paired == divisor {
+                count = count + 1
+            } else {
+                count = count + 2
+            }
+        }
+        divisor = divisor + 1
+    }
+    return count
+}
+
+fn __zero_std_math_proper_divisor_sum_u32(value: u32) -> u32 {
+    if value <= 1 {
+        return 0
+    }
+    var sum: u32 = 1
+    var divisor: u32 = 2
+    while divisor <= value / divisor {
+        if value % divisor == 0 {
+            let paired: u32 = value / divisor
+            sum = sum + divisor
+            if paired != divisor {
+                sum = sum + paired
+            }
+        }
+        divisor = divisor + 1
+    }
+    return sum
+}

std/mem.0

@@ -0,0 +1,298 @@
+fn __zero_std_mem_copy_items<T: Type>(dst: MutSpan<T>, src: Span<T>) -> usize {
+    var count: usize = std.mem.len(src)
+    let capacity: usize = std.mem.len(dst)
+    if count > capacity {
+        count = capacity
+    }
+    var index: usize = 0
+    while index < count {
+        dst[index] = src[index]
+        index = index + 1
+    }
+    return count
+}
+
+fn __zero_std_mem_fill_items<T: Type>(dst: MutSpan<T>, value: T) -> usize {
+    var index: usize = 0
+    let len: usize = std.mem.len(dst)
+    while index < len {
+        dst[index] = value
+        index = index + 1
+    }
+    return len
+}
+
+fn __zero_std_mem_contains<T: Type>(items: Span<T>, needle: T) -> Bool {
+    var index: usize = 0
+    while index < std.mem.len(items) {
+        if items[index] == needle {
+            return true
+        }
+        index = index + 1
+    }
+    return false
+}
+
+fn __zero_std_mem_compare_i32(left: Span<i32>, right: Span<i32>) -> i32 {
+    var index: usize = 0
+    let left_len: usize = std.mem.len(left)
+    let right_len: usize = std.mem.len(right)
+    while index < left_len && index < right_len {
+        if left[index] < right[index] {
+            return -1
+        }
+        if left[index] > right[index] {
+            return 1
+        }
+        index = index + 1
+    }
+    if left_len < right_len {
+        return -1
+    }
+    if left_len > right_len {
+        return 1
+    }
+    return 0
+}
+
+fn __zero_std_mem_compare_u32(left: Span<u32>, right: Span<u32>) -> i32 {
+    var index: usize = 0
+    let left_len: usize = std.mem.len(left)
+    let right_len: usize = std.mem.len(right)
+    while index < left_len && index < right_len {
+        if left[index] < right[index] {
+            return -1
+        }
+        if left[index] > right[index] {
+            return 1
+        }
+        index = index + 1
+    }
+    if left_len < right_len {
+        return -1
+    }
+    if left_len > right_len {
+        return 1
+    }
+    return 0
+}
+
+fn __zero_std_mem_compare_usize(left: Span<usize>, right: Span<usize>) -> i32 {
+    var index: usize = 0
+    let left_len: usize = std.mem.len(left)
+    let right_len: usize = std.mem.len(right)
+    while index < left_len && index < right_len {
+        if left[index] < right[index] {
+            return -1
+        }
+        if left[index] > right[index] {
+            return 1
+        }
+        index = index + 1
+    }
+    if left_len < right_len {
+        return -1
+    }
+    if left_len > right_len {
+        return 1
+    }
+    return 0
+}
+
+fn __zero_std_mem_compare_u8(left: Span<u8>, right: Span<u8>) -> i32 {
+    var index: usize = 0
+    let left_len: usize = std.mem.len(left)
+    let right_len: usize = std.mem.len(right)
+    while index < left_len && index < right_len {
+        if left[index] < right[index] {
+            return -1
+        }
+        if left[index] > right[index] {
+            return 1
+        }
+        index = index + 1
+    }
+    if left_len < right_len {
+        return -1
+    }
+    if left_len > right_len {
+        return 1
+    }
+    return 0
+}
+
+fn __zero_std_mem_compare_bytes(left: Span<u8>, right: Span<u8>) -> i32 {
+    return __zero_std_mem_compare_u8(left, right)
+}
+
+fn __zero_std_mem_starts_with<T: Type>(items: Span<T>, prefix_items: Span<T>) -> Bool {
+    let prefix_len: usize = std.mem.len(prefix_items)
+    if prefix_len > std.mem.len(items) {
+        return false
+    }
+    var index: usize = 0
+    while index < prefix_len {
+        if items[index] != prefix_items[index] {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_mem_ends_with<T: Type>(items: Span<T>, suffix_items: Span<T>) -> Bool {
+    let suffix_len: usize = std.mem.len(suffix_items)
+    let item_len: usize = std.mem.len(items)
+    if suffix_len > item_len {
+        return false
+    }
+    let offset: usize = item_len - suffix_len
+    var index: usize = 0
+    while index < suffix_len {
+        if items[offset + index] != suffix_items[index] {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_mem_split_before<T: Type>(items: Span<T>, delimiter: T) -> Span<T> {
+    var index: usize = 0
+    while index < std.mem.len(items) {
+        if items[index] == delimiter {
+            return items[..index]
+        }
+        index = index + 1
+    }
+    return items
+}
+
+fn __zero_std_mem_split_after<T: Type>(items: Span<T>, delimiter: T) -> Span<T> {
+    var index: usize = 0
+    while index < std.mem.len(items) {
+        if items[index] == delimiter {
+            return items[index + 1..]
+        }
+        index = index + 1
+    }
+    return items[std.mem.len(items)..]
+}
+
+fn __zero_std_mem_is_empty<T: Type>(items: Span<T>) -> Bool {
+    return std.mem.len(items) == 0
+}
+
+fn __zero_std_mem_prefix<T: Type>(items: Span<T>, count: usize) -> Span<T> {
+    var end: usize = count
+    if end > std.mem.len(items) {
+        end = std.mem.len(items)
+    }
+    return items[..end]
+}
+
+fn __zero_std_mem_drop_prefix<T: Type>(items: Span<T>, count: usize) -> Span<T> {
+    var start: usize = count
+    if start > std.mem.len(items) {
+        start = std.mem.len(items)
+    }
+    return items[start..]
+}
+
+fn __zero_std_mem_suffix<T: Type>(items: Span<T>, count: usize) -> Span<T> {
+    let length: usize = std.mem.len(items)
+    var start: usize = 0
+    if count < length {
+        start = length - count
+    }
+    return items[start..]
+}
+
+fn __zero_std_mem_drop_suffix<T: Type>(items: Span<T>, count: usize) -> Span<T> {
+    var end: usize = std.mem.len(items)
+    if count < end {
+        end = end - count
+    } else {
+        end = 0
+    }
+    return items[..end]
+}
+
+fn __zero_std_mem_slice<T: Type>(items: Span<T>, start: usize, count: usize) -> Span<T> {
+    let length: usize = std.mem.len(items)
+    var begin: usize = start
+    if begin > length {
+        begin = length
+    }
+    var end: usize = begin + count
+    if end < begin || end > length {
+        end = length
+    }
+    return items[begin..end]
+}
+
+fn __zero_std_mem_chunk_count<T: Type>(items: Span<T>, chunk_size: usize) -> usize {
+    if chunk_size == 0 {
+        return 0
+    }
+    let length: usize = std.mem.len(items)
+    let full: usize = length / chunk_size
+    if length % chunk_size == 0 {
+        return full
+    }
+    return full + 1
+}
+
+fn __zero_std_mem_chunk<T: Type>(items: Span<T>, chunk_index: usize, chunk_size: usize) -> Span<T> {
+    let count: usize = __zero_std_mem_chunk_count(items, chunk_size)
+    let length: usize = std.mem.len(items)
+    if chunk_index >= count {
+        return items[length..]
+    }
+    let start: usize = chunk_index * chunk_size
+    return __zero_std_mem_slice(items, start, chunk_size)
+}
+
+fn __zero_std_mem_window_count<T: Type>(items: Span<T>, window_size: usize) -> usize {
+    if window_size == 0 {
+        return 0
+    }
+    let length: usize = std.mem.len(items)
+    if window_size > length {
+        return 0
+    }
+    return length - window_size + 1
+}
+
+fn __zero_std_mem_window<T: Type>(items: Span<T>, window_index: usize, window_size: usize) -> Span<T> {
+    let count: usize = __zero_std_mem_window_count(items, window_size)
+    let length: usize = std.mem.len(items)
+    if window_index >= count {
+        return items[length..]
+    }
+    return __zero_std_mem_slice(items, window_index, window_size)
+}
+
+fn __zero_std_mem_advance<T: Type>(items: Span<T>, cursor: usize, count: usize) -> usize {
+    let length: usize = std.mem.len(items)
+    if cursor >= length {
+        return length
+    }
+    let next: usize = cursor + count
+    if next < cursor || next > length {
+        return length
+    }
+    return next
+}
+
+fn __zero_std_mem_cursor_done<T: Type>(items: Span<T>, cursor: usize) -> Bool {
+    return cursor >= std.mem.len(items)
+}
+
+fn __zero_std_mem_remaining<T: Type>(items: Span<T>, cursor: usize) -> Span<T> {
+    return __zero_std_mem_drop_prefix(items, cursor)
+}
+
+fn __zero_std_mem_cursor_chunk<T: Type>(items: Span<T>, cursor: usize, count: usize) -> Span<T> {
+    return __zero_std_mem_slice(items, cursor, count)
+}

std/net.0

@@ -0,0 +1,7 @@
+fn __zero_std_net_localhost(port: u16) -> Address {
+    return std.net.address("localhost", port)
+}
+
+fn __zero_std_net_loopback(port: u16) -> Address {
+    return std.net.address("127.0.0.1", port)
+}

std/parse.0

@@ -0,0 +1,580 @@
+fn __zero_std_parse_is_ascii_digit(value: Span<u8>) -> Bool {
+    return std.mem.len(value) > 0 && value[0] >= 48_u8 && value[0] <= 57_u8
+}
+
+fn __zero_std_parse_is_ascii_alpha(value: Span<u8>) -> Bool {
+    if std.mem.len(value) == 0 {
+        return false
+    }
+    let byte: u8 = value[0]
+    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8)
+}
+
+fn __zero_std_parse_is_identifier_start(value: Span<u8>) -> Bool {
+    if std.mem.len(value) == 0 {
+        return false
+    }
+    let byte: u8 = value[0]
+    return __zero_std_parse_is_ascii_alpha(value) || byte == 95_u8
+}
+
+fn __zero_std_parse_is_whitespace(value: Span<u8>) -> Bool {
+    if std.mem.len(value) == 0 {
+        return false
+    }
+    let byte: u8 = value[0]
+    return byte == 32_u8 || byte == 9_u8 || byte == 10_u8 || byte == 13_u8
+}
+
+fn __zero_std_parse_scan_digits(value: Span<u8>) -> usize {
+    var index: usize = 0
+    while index < std.mem.len(value) && value[index] >= 48_u8 && value[index] <= 57_u8 {
+        index = index + 1
+    }
+    return index
+}
+
+fn __zero_std_parse_scan_whitespace(value: Span<u8>) -> usize {
+    var index: usize = 0
+    while index < std.mem.len(value) && (value[index] == 32_u8 || value[index] == 9_u8 || value[index] == 10_u8 || value[index] == 13_u8) {
+        index = index + 1
+    }
+    return index
+}
+
+fn __zero_std_parse_identifier_byte(byte: u8) -> Bool {
+    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8) || (byte >= 48_u8 && byte <= 57_u8) || byte == 95_u8
+}
+
+fn __zero_std_parse_scan_identifier(value: Span<u8>) -> usize {
+    if !__zero_std_parse_is_identifier_start(value) {
+        return 0
+    }
+    var index: usize = 1
+    while index < std.mem.len(value) && __zero_std_parse_identifier_byte(value[index]) {
+        index = index + 1
+    }
+    return index
+}
+
+fn __zero_std_parse_scan_until_byte(value: Span<u8>, byte: u8) -> usize {
+    var index: usize = 0
+    while index < std.mem.len(value) {
+        if value[index] == byte {
+            return index
+        }
+        index = index + 1
+    }
+    return std.mem.len(value)
+}
+
+fn __zero_std_parse_token_ascii(value: Span<u8>) -> Span<u8> {
+    let start: usize = __zero_std_parse_scan_whitespace(value)
+    var end: usize = start
+    while end < std.mem.len(value) && !(value[end] == 32_u8 || value[end] == 9_u8 || value[end] == 10_u8 || value[end] == 13_u8) {
+        end = end + 1
+    }
+    return value[start..end]
+}
+
+fn __zero_std_parse_parse_u32_max(value: Span<u8>, max: u32) -> Maybe<u32> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var index: usize = 0
+    var total: u32 = 0
+    while index < std.mem.len(value) {
+        let byte: u8 = value[index]
+        if byte < 48_u8 || byte > 57_u8 {
+            return null
+        }
+        let digit: u32 = (byte - 48_u8) as u32
+        if total > (max - digit) / 10_u32 {
+            return null
+        }
+        total = total * 10_u32 + digit
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_parse_digit_value(byte: u8) -> Maybe<u32> {
+    if byte >= 48_u8 && byte <= 57_u8 {
+        return (byte - 48_u8) as u32
+    }
+    if byte >= 65_u8 && byte <= 90_u8 {
+        return ((byte - 65_u8) as u32) + 10_u32
+    }
+    if byte >= 97_u8 && byte <= 122_u8 {
+        return ((byte - 97_u8) as u32) + 10_u32
+    }
+    return null
+}
+
+fn __zero_std_parse_parse_u32_base_max(value: Span<u8>, base: u32, max: u32) -> Maybe<u32> {
+    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
+        return null
+    }
+    var index: usize = 0
+    var total: u32 = 0
+    while index < std.mem.len(value) {
+        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
+        if !digit.has || digit.value >= base {
+            return null
+        }
+        if total > (max - digit.value) / base {
+            return null
+        }
+        total = total * base + digit.value
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_parse_parse_u64_base_max(value: Span<u8>, base: u32, max: u64) -> Maybe<u64> {
+    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
+        return null
+    }
+    var index: usize = 0
+    var total: u64 = 0_u64
+    let u64_base: u64 = base as u64
+    while index < std.mem.len(value) {
+        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
+        if !digit.has || digit.value >= base {
+            return null
+        }
+        let u64_digit: u64 = digit.value as u64
+        if total > (max - u64_digit) / u64_base {
+            return null
+        }
+        total = total * u64_base + u64_digit
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_parse_parse_u32_base(value: Span<u8>, base: u32) -> Maybe<u32> {
+    return __zero_std_parse_parse_u32_base_max(value, base, 4294967295_u32)
+}
+
+fn __zero_std_parse_parse_u64_base(value: Span<u8>, base: u32) -> Maybe<u64> {
+    return __zero_std_parse_parse_u64_base_max(value, base, 18446744073709551615_u64)
+}
+
+fn __zero_std_parse_parse_usize_base(value: Span<u8>, base: u32) -> Maybe<usize> {
+    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
+        return null
+    }
+    var index: usize = 0
+    var total: usize = 0
+    let max: usize = 18446744073709551615
+    let usize_base: usize = base as usize
+    while index < std.mem.len(value) {
+        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
+        if !digit.has || digit.value >= base {
+            return null
+        }
+        let usize_digit: usize = digit.value as usize
+        if total > (max - usize_digit) / usize_base {
+            return null
+        }
+        total = total * usize_base + usize_digit
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_parse_parse_i64_base(value: Span<u8>, base: u32) -> Maybe<i64> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var start: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 {
+        negative = true
+        start = 1
+    } else if value[0] == 43_u8 {
+        start = 1
+    }
+    if start == std.mem.len(value) {
+        return null
+    }
+    let limit: u64 = 9223372036854775808_u64
+    let parsed: Maybe<u64> = __zero_std_parse_parse_u64_base_max(value[start..], base, limit)
+    if !parsed.has {
+        return null
+    }
+    if negative {
+        if parsed.value == limit {
+            return 0_i64 - 9223372036854775807_i64 - 1_i64
+        }
+        return 0_i64 - (parsed.value as i64)
+    }
+    if parsed.value > 9223372036854775807_u64 {
+        return null
+    }
+    return parsed.value as i64
+}
+
+fn __zero_std_parse_parse_i32_base(value: Span<u8>, base: u32) -> Maybe<i32> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var start: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 {
+        negative = true
+        start = 1
+    } else if value[0] == 43_u8 {
+        start = 1
+    }
+    if start == std.mem.len(value) {
+        return null
+    }
+    let limit: u32 = 2147483648_u32
+    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_base_max(value[start..], base, limit)
+    if !parsed.has {
+        return null
+    }
+    if negative {
+        if parsed.value == limit {
+            return 0 - 2147483647 - 1
+        }
+        return 0 - (parsed.value as i32)
+    }
+    if parsed.value > 2147483647_u32 {
+        return null
+    }
+    return parsed.value as i32
+}
+
+fn __zero_std_parse_prefixed_base(value: Span<u8>) -> u32 {
+    if std.mem.len(value) >= 2 && value[0] == 48_u8 {
+        if value[1] == 120_u8 || value[1] == 88_u8 {
+            return 16_u32
+        }
+        if value[1] == 98_u8 || value[1] == 66_u8 {
+            return 2_u32
+        }
+        if value[1] == 111_u8 || value[1] == 79_u8 {
+            return 8_u32
+        }
+    }
+    return 10_u32
+}
+
+fn __zero_std_parse_prefixed_digits(value: Span<u8>) -> Span<u8> {
+    if std.mem.len(value) >= 2 && value[0] == 48_u8 {
+        if value[1] == 120_u8 || value[1] == 88_u8 || (value[1] == 98_u8 || value[1] == 66_u8) || (value[1] == 111_u8 || value[1] == 79_u8) {
+            return value[2..]
+        }
+    }
+    return value
+}
+
+fn __zero_std_parse_parse_u32_prefix(value: Span<u8>) -> Maybe<u32> {
+    let base: u32 = __zero_std_parse_prefixed_base(value)
+    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
+    return __zero_std_parse_parse_u32_base(digits, base)
+}
+
+fn __zero_std_parse_parse_u64_prefix(value: Span<u8>) -> Maybe<u64> {
+    let base: u32 = __zero_std_parse_prefixed_base(value)
+    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
+    return __zero_std_parse_parse_u64_base(digits, base)
+}
+
+fn __zero_std_parse_parse_usize_prefix(value: Span<u8>) -> Maybe<usize> {
+    let base: u32 = __zero_std_parse_prefixed_base(value)
+    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
+    return __zero_std_parse_parse_usize_base(digits, base)
+}
+
+fn __zero_std_parse_parse_i64_prefix(value: Span<u8>) -> Maybe<i64> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var start: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 || value[0] == 43_u8 {
+        negative = value[0] == 45_u8
+        start = 1
+    }
+    if start == std.mem.len(value) {
+        return null
+    }
+    let base: u32 = __zero_std_parse_prefixed_base(value[start..])
+    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value[start..])
+    let limit: u64 = 9223372036854775808_u64
+    let parsed: Maybe<u64> = __zero_std_parse_parse_u64_base_max(digits, base, limit)
+    if !parsed.has {
+        return null
+    }
+    if negative {
+        if parsed.value == limit {
+            return 0_i64 - 9223372036854775807_i64 - 1_i64
+        }
+        return 0_i64 - (parsed.value as i64)
+    }
+    if parsed.value > 9223372036854775807_u64 {
+        return null
+    }
+    return parsed.value as i64
+}
+
+fn __zero_std_parse_parse_i32_prefix(value: Span<u8>) -> Maybe<i32> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var start: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 || value[0] == 43_u8 {
+        negative = value[0] == 45_u8
+        start = 1
+    }
+    if start == std.mem.len(value) {
+        return null
+    }
+    let base: u32 = __zero_std_parse_prefixed_base(value[start..])
+    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value[start..])
+    let limit: u32 = 2147483648_u32
+    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_base_max(digits, base, limit)
+    if !parsed.has {
+        return null
+    }
+    if negative {
+        if parsed.value == limit {
+            return 0 - 2147483647 - 1
+        }
+        return 0 - (parsed.value as i32)
+    }
+    if parsed.value > 2147483647_u32 {
+        return null
+    }
+    return parsed.value as i32
+}
+
+fn __zero_std_parse_parse_u8(value: Span<u8>) -> Maybe<u8> {
+    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value, 255_u32)
+    if parsed.has {
+        return parsed.value as u8
+    }
+    return null
+}
+
+fn __zero_std_parse_parse_u16(value: Span<u8>) -> Maybe<u16> {
+    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value, 65535_u32)
+    if parsed.has {
+        return parsed.value as u16
+    }
+    return null
+}
+
+fn __zero_std_parse_parse_u32(value: Span<u8>) -> Maybe<u32> {
+    return __zero_std_parse_parse_u32_max(value, 4294967295_u32)
+}
+
+fn __zero_std_parse_parse_u64(value: Span<u8>) -> Maybe<u64> {
+    return __zero_std_parse_parse_u64_base(value, 10_u32)
+}
+
+fn __zero_std_parse_parse_usize(value: Span<u8>) -> Maybe<usize> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var index: usize = 0
+    var total: usize = 0
+    let max: usize = 18446744073709551615
+    while index < std.mem.len(value) {
+        let byte: u8 = value[index]
+        if byte < 48_u8 || byte > 57_u8 {
+            return null
+        }
+        let digit: usize = (byte - 48_u8) as usize
+        if total > (max - digit) / 10 {
+            return null
+        }
+        total = total * 10 + digit
+        index = index + 1
+    }
+    return total
+}
+
+fn __zero_std_parse_parse_i64(value: Span<u8>) -> Maybe<i64> {
+    return __zero_std_parse_parse_i64_base(value, 10_u32)
+}
+
+fn __zero_std_parse_parse_i32(value: Span<u8>) -> Maybe<i32> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var start: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 {
+        negative = true
+        start = 1
+    } else if value[0] == 43_u8 {
+        start = 1
+    }
+    if start == std.mem.len(value) {
+        return null
+    }
+    let limit: u32 = 2147483648_u32
+    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value[start..], limit)
+    if !parsed.has {
+        return null
+    }
+    if negative {
+        if parsed.value == limit {
+            return 0 - 2147483647 - 1
+        }
+        return 0 - (parsed.value as i32)
+    }
+    if parsed.value > 2147483647_u32 {
+        return null
+    }
+    return parsed.value as i32
+}
+
+fn __zero_std_parse_parse_bool(value: Span<u8>) -> Maybe<Bool> {
+    if std.mem.eql(value, "true") {
+        return true
+    }
+    if std.mem.eql(value, "false") {
+        return false
+    }
+    return null
+}
+
+fn __zero_std_parse_duration_unit_ns(value: Span<u8>) -> Maybe<u64> {
+    if std.mem.eql(value, "ns") {
+        return 1_u64
+    }
+    if std.mem.eql(value, "us") {
+        return 1000_u64
+    }
+    if std.mem.eql(value, "ms") {
+        return 1000000_u64
+    }
+    if std.mem.eql(value, "s") {
+        return 1000000000_u64
+    }
+    if std.mem.eql(value, "m") {
+        return 60000000000_u64
+    }
+    if std.mem.eql(value, "h") {
+        return 3600000000000_u64
+    }
+    return null
+}
+
+fn __zero_std_parse_parse_duration(value: Span<u8>) -> Maybe<Duration> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var index: usize = 0
+    var negative: Bool = false
+    if value[0] == 45_u8 || value[0] == 43_u8 {
+        negative = value[0] == 45_u8
+        index = 1
+    }
+    if index == std.mem.len(value) {
+        return null
+    }
+    var max: u64 = 9223372036854775807_u64
+    if negative {
+        max = 9223372036854775808_u64
+    }
+    var total: u64 = 0_u64
+    var saw_component: Bool = false
+    while index < std.mem.len(value) {
+        let digit_start: usize = index
+        while index < std.mem.len(value) && (value[index] >= 48_u8 && value[index] <= 57_u8) {
+            index = index + 1
+        }
+        if digit_start == index {
+            return null
+        }
+        let amount: Maybe<u64> = __zero_std_parse_parse_u64(value[digit_start..index])
+        if !amount.has {
+            return null
+        }
+        let unit_start: usize = index
+        while index < std.mem.len(value) && (value[index] < 48_u8 || value[index] > 57_u8) {
+            index = index + 1
+        }
+        if unit_start == index {
+            return null
+        }
+        let multiplier: Maybe<u64> = __zero_std_parse_duration_unit_ns(value[unit_start..index])
+        if !multiplier.has {
+            return null
+        }
+        if amount.value > (max - total) / multiplier.value {
+            return null
+        }
+        total = total + amount.value * multiplier.value
+        saw_component = true
+    }
+    if !saw_component {
+        return null
+    }
+    if negative {
+        if total == 9223372036854775808_u64 {
+            return std.time.ns(0_i64 - 9223372036854775807_i64 - 1_i64)
+        }
+        return std.time.ns(0_i64 - (total as i64))
+    }
+    return std.time.ns(total as i64)
+}
+
+fn __zero_std_parse_byte_size_multiplier(unit: Span<u8>) -> Maybe<usize> {
+    if std.mem.len(unit) == 0 || std.mem.eql(unit, "B") {
+        return 1_usize
+    }
+    if std.mem.eql(unit, "KB") {
+        return 1000_usize
+    }
+    if std.mem.eql(unit, "MB") {
+        return 1000000_usize
+    }
+    if std.mem.eql(unit, "GB") {
+        return 1000000000_usize
+    }
+    if std.mem.eql(unit, "KiB") {
+        return 1024_usize
+    }
+    if std.mem.eql(unit, "MiB") {
+        return 1048576_usize
+    }
+    if std.mem.eql(unit, "GiB") {
+        return 1073741824_usize
+    }
+    return null
+}
+
+fn __zero_std_parse_parse_byte_size(value: Span<u8>) -> Maybe<usize> {
+    if std.mem.len(value) == 0 {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(value) && (value[index] >= 48_u8 && value[index] <= 57_u8) {
+        index = index + 1
+    }
+    if index == 0 {
+        return null
+    }
+    let amount: Maybe<usize> = __zero_std_parse_parse_usize(value[..index])
+    if !amount.has {
+        return null
+    }
+    let multiplier: Maybe<usize> = __zero_std_parse_byte_size_multiplier(value[index..])
+    if !multiplier.has {
+        return null
+    }
+    let max: usize = 18446744073709551615
+    if amount.value > max / multiplier.value {
+        return null
+    }
+    return amount.value * multiplier.value
+}

std/path.0

@@ -0,0 +1,365 @@
+fn __zero_std_path_is_sep(byte: u8) -> Bool {
+    return byte == 47_u8 || byte == 92_u8
+}
+
+fn __zero_std_path_is_abs(path: String) -> Bool {
+    return std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0])
+}
+
+fn __zero_std_path_segment_end(path: String, index: usize) -> Bool {
+    return index >= std.mem.len(path) || __zero_std_path_is_sep(path[index])
+}
+
+fn __zero_std_path_trim_end(path: String) -> usize {
+    var end: usize = std.mem.len(path)
+    while end > 0 && __zero_std_path_is_sep(path[end - 1]) {
+        end = end - 1
+    }
+    return end
+}
+
+fn __zero_std_path_basename(path: String) -> String {
+    let end: usize = __zero_std_path_trim_end(path)
+    var start: usize = end
+    while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
+        start = start - 1
+    }
+    return path[start..end]
+}
+
+fn __zero_std_path_dirname(path: String) -> String {
+    let end: usize = __zero_std_path_trim_end(path)
+    var root_len: usize = 0
+    if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {
+        root_len = 1
+    }
+    if root_len > 0 && end == 0 {
+        return path[..root_len]
+    }
+    var split: usize = end
+    while split > 0 && !__zero_std_path_is_sep(path[split - 1]) {
+        split = split - 1
+    }
+    while split > root_len && __zero_std_path_is_sep(path[split - 1]) {
+        split = split - 1
+    }
+    return path[..split]
+}
+
+fn __zero_std_path_extension(path: String) -> String {
+    let end: usize = __zero_std_path_trim_end(path)
+    var start: usize = end
+    while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
+        start = start - 1
+    }
+    var dot: usize = end
+    var scan: usize = end
+    while scan > start {
+        scan = scan - 1
+        if path[scan] == 46_u8 {
+            dot = scan
+            scan = start
+        }
+    }
+    if dot == end {
+        return path[end..end]
+    }
+    if dot == start {
+        return path[end..end]
+    }
+    return path[dot + 1..end]
+}
+
+fn __zero_std_path_stem(path: String) -> String {
+    let end: usize = __zero_std_path_trim_end(path)
+    var start: usize = end
+    while start > 0 && !__zero_std_path_is_sep(path[start - 1]) {
+        start = start - 1
+    }
+    var dot: usize = end
+    var scan: usize = end
+    while scan > start {
+        scan = scan - 1
+        if path[scan] == 46_u8 {
+            dot = scan
+            scan = start
+        }
+    }
+    if dot == end {
+        return path[start..end]
+    }
+    if dot == start {
+        return path[start..end]
+    }
+    if end - start == 2 && path[start] == 46_u8 && path[start + 1] == 46_u8 {
+        return path[start..end]
+    }
+    return path[start..dot]
+}
+
+fn __zero_std_path_split_dir(path: String) -> String {
+    return __zero_std_path_dirname(path)
+}
+
+fn __zero_std_path_split_base(path: String) -> String {
+    return __zero_std_path_basename(path)
+}
+
+fn __zero_std_path_component_count(path: String) -> usize {
+    var count: usize = 0
+    var index: usize = 0
+    while index < std.mem.len(path) {
+        while index < std.mem.len(path) && __zero_std_path_is_sep(path[index]) {
+            index = index + 1
+        }
+        if index < std.mem.len(path) {
+            count = count + 1
+            while index < std.mem.len(path) && !__zero_std_path_is_sep(path[index]) {
+                index = index + 1
+            }
+        }
+    }
+    return count
+}
+
+fn __zero_std_path_component(path: String, component_index: usize) -> Maybe<String> {
+    var count: usize = 0
+    var index: usize = 0
+    while index < std.mem.len(path) {
+        while index < std.mem.len(path) && __zero_std_path_is_sep(path[index]) {
+            index = index + 1
+        }
+        if index < std.mem.len(path) {
+            let start: usize = index
+            while index < std.mem.len(path) && !__zero_std_path_is_sep(path[index]) {
+                index = index + 1
+            }
+            if count == component_index {
+                return path[start..index]
+            }
+            count = count + 1
+        }
+    }
+    return null
+}
+
+fn __zero_std_path_abs(buffer: MutSpan<u8>, base: String, target: String) -> Maybe<String> {
+    if __zero_std_path_is_abs(target) {
+        return __zero_std_path_copy(buffer, target)
+    }
+    var base_end: usize = __zero_std_path_trim_end(base)
+    if base_end == 0 && (std.mem.len(base) > 0 && __zero_std_path_is_sep(base[0])) {
+        base_end = 1
+    }
+    let base_is_root: Bool = base_end == 1 && __zero_std_path_is_sep(base[0])
+    let target_len: usize = std.mem.len(target)
+    var total: usize = base_end + target_len
+    if base_end > 0 && target_len > 0 && !base_is_root {
+        total = total + 1
+    }
+    if total > std.mem.len(buffer) {
+        return null
+    }
+    var out: usize = 0
+    while out < base_end {
+        if base_is_root && out == 0 {
+            buffer[out] = 47_u8
+        } else {
+            buffer[out] = base[out]
+        }
+        out = out + 1
+    }
+    if base_end > 0 && target_len > 0 && !base_is_root {
+        buffer[out] = 47_u8
+        out = out + 1
+    }
+    var read: usize = 0
+    while read < target_len {
+        buffer[out] = target[read]
+        out = out + 1
+        read = read + 1
+    }
+    return buffer[..out]
+}
+
+fn __zero_std_path_copy(buffer: MutSpan<u8>, source: String) -> Maybe<String> {
+    let len: usize = std.mem.len(source)
+    if len > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < len {
+        buffer[index] = source[index]
+        index = index + 1
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_path_join(buffer: MutSpan<u8>, left: String, right: String) -> Maybe<String> {
+    var left_end: usize = __zero_std_path_trim_end(left)
+    if left_end == 0 && (std.mem.len(left) > 0 && __zero_std_path_is_sep(left[0])) {
+        left_end = 1
+    }
+    let left_is_root: Bool = left_end == 1 && __zero_std_path_is_sep(left[0])
+    let right_is_root: Bool = std.mem.len(right) > 0 && __zero_std_path_is_sep(right[0])
+    var right_start: usize = 0
+    while right_start < std.mem.len(right) && __zero_std_path_is_sep(right[right_start]) {
+        right_start = right_start + 1
+    }
+    let right_len: usize = std.mem.len(right) - right_start
+    var total: usize = left_end + right_len
+    if left_end == 0 && right_is_root {
+        total = total + 1
+    }
+    if left_end > 0 && right_len > 0 && !left_is_root {
+        total = total + 1
+    }
+    if total > std.mem.len(buffer) {
+        return null
+    }
+    var out: usize = 0
+    while out < left_end {
+        if left_is_root && out == 0 {
+            buffer[out] = 47_u8
+        } else {
+            buffer[out] = left[out]
+        }
+        out = out + 1
+    }
+    if left_end == 0 && right_is_root {
+        buffer[out] = 47_u8
+        out = out + 1
+    }
+    if left_end > 0 && right_len > 0 && !left_is_root {
+        buffer[out] = 47_u8
+        out = out + 1
+    }
+    var read: usize = right_start
+    while read < std.mem.len(right) {
+        buffer[out] = right[read]
+        out = out + 1
+        read = read + 1
+    }
+    return buffer[..out]
+}
+
+fn __zero_std_path_output_ends_parent(buffer: MutSpan<u8>, out: usize, root_len: usize) -> Bool {
+    if out <= root_len {
+        return false
+    }
+    var segment_start: usize = out
+    while segment_start > root_len && !__zero_std_path_is_sep(buffer[segment_start - 1]) {
+        segment_start = segment_start - 1
+    }
+    let segment_len: usize = out - segment_start
+    if segment_len != 2 {
+        return false
+    }
+    return buffer[segment_start] == 46_u8 && buffer[segment_start + 1] == 46_u8
+}
+
+fn __zero_std_path_normalize(buffer: MutSpan<u8>, path: String) -> Maybe<String> {
+    var read: usize = 0
+    var out: usize = 0
+    var root_len: usize = 0
+    if std.mem.len(path) > 0 && __zero_std_path_is_sep(path[0]) {
+        if std.mem.len(buffer) == 0 {
+            return null
+        }
+        buffer[0] = 47_u8
+        out = 1
+        root_len = 1
+        read = 1
+    }
+    while read < std.mem.len(path) {
+        while read < std.mem.len(path) && __zero_std_path_is_sep(path[read]) {
+            read = read + 1
+        }
+        if read < std.mem.len(path) {
+            let segment_start: usize = read
+            while read < std.mem.len(path) && !__zero_std_path_is_sep(path[read]) {
+                read = read + 1
+            }
+            let segment_end: usize = read
+            let segment_len: usize = segment_end - segment_start
+            if segment_len == 1 && path[segment_start] == 46_u8 {
+                read = segment_end
+            } else if segment_len == 2 && path[segment_start] == 46_u8 && path[segment_start + 1] == 46_u8 {
+                if root_len == 1 && out == root_len {
+                    read = segment_end
+                } else if out > root_len && !__zero_std_path_output_ends_parent(buffer, out, root_len) {
+                    while out > root_len && !__zero_std_path_is_sep(buffer[out - 1]) {
+                        out = out - 1
+                    }
+                    if out > root_len && __zero_std_path_is_sep(buffer[out - 1]) {
+                        out = out - 1
+                    }
+                } else {
+                    var needed: usize = segment_len
+                    if out > root_len {
+                        needed = needed + 1
+                    }
+                    if out + needed > std.mem.len(buffer) {
+                        return null
+                    }
+                    if out > root_len {
+                        buffer[out] = 47_u8
+                        out = out + 1
+                    }
+                    var copy: usize = segment_start
+                    while copy < segment_end {
+                        buffer[out] = path[copy]
+                        out = out + 1
+                        copy = copy + 1
+                    }
+                }
+            } else {
+                var needed: usize = segment_len
+                if out > root_len {
+                    needed = needed + 1
+                }
+                if out + needed > std.mem.len(buffer) {
+                    return null
+                }
+                if out > root_len {
+                    buffer[out] = 47_u8
+                    out = out + 1
+                }
+                var copy: usize = segment_start
+                while copy < segment_end {
+                    buffer[out] = path[copy]
+                    out = out + 1
+                    copy = copy + 1
+                }
+            }
+        }
+    }
+    return buffer[..out]
+}
+
+fn __zero_std_path_relative(buffer: MutSpan<u8>, base: String, target: String) -> Maybe<String> {
+    let base_end: usize = __zero_std_path_trim_end(base)
+    let target_len: usize = std.mem.len(target)
+    let base_prefix: String = base[..base_end]
+    let base_matches: Bool = std.str.startsWith(target, base_prefix)
+    if base_matches && base_end == target_len {
+        return buffer[..0]
+    }
+    if base_matches && base_end < target_len {
+        if __zero_std_path_is_sep(target[base_end]) {
+            var out: usize = 0
+            var read: usize = base_end + 1
+            let rel_len: usize = target_len - read
+            if rel_len > std.mem.len(buffer) {
+                return null
+            }
+            while read < target_len {
+                buffer[out] = target[read]
+                out = out + 1
+                read = read + 1
+            }
+            return buffer[..out]
+        }
+    }
+    return __zero_std_path_copy(buffer, target)
+}

std/proc.0

@@ -0,0 +1,17 @@
+fn __zero_std_proc_succeeded(status: ProcStatus) -> Bool {
+    return std.proc.exitCode(status) == 0
+}
+
+fn __zero_std_proc_failed(status: ProcStatus) -> Bool {
+    return std.proc.exitCode(status) != 0
+}
+
+fn __zero_std_proc_run_ok(command: String) -> Bool {
+    let status: ProcStatus = std.proc.spawnInherit(command)
+    return std.proc.succeeded(status)
+}
+
+fn __zero_std_proc_run_code(command: String) -> i32 {
+    let status: ProcStatus = std.proc.spawnInherit(command)
+    return std.proc.exitCode(status)
+}

std/rand.0

@@ -0,0 +1,22 @@
+fn rand_fixed_hex32(buffer: MutSpan<u8>, value: u32) -> Maybe<Span<u8>> {
+    if std.mem.len(buffer) < 8 {
+        return null
+    }
+    var place: u32 = 268435456_u32
+    var index: usize = 0
+    while index < 8 {
+        let digit: u8 = ((value / place) % 16_u32) as u8
+        if digit < 10_u8 {
+            buffer[index] = 48_u8 + digit
+        } else {
+            buffer[index] = 87_u8 + digit
+        }
+        place = place / 16_u32
+        index = index + 1
+    }
+    return buffer[..8]
+}
+
+fn rand_entropy_hex32(buffer: MutSpan<u8>) -> Maybe<Span<u8>> {
+    return rand_fixed_hex32(buffer, std.rand.entropyU32())
+}

std/search.0

@@ -0,0 +1,525 @@
+fn __zero_std_search_index_of<T: Type>(items: Span<T>, needle: T) -> usize {
+    var index: usize = 0
+    while index < std.mem.len(items) {
+        if items[index] == needle {
+            return index
+        }
+        index = index + 1
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_last_index_of<T: Type>(items: Span<T>, needle: T) -> usize {
+    var index: usize = std.mem.len(items)
+    while index > 0 {
+        index = index - 1
+        if items[index] == needle {
+            return index
+        }
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_lower_bound_i32(items: Span<i32>, needle: i32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] < needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_i32(items: Span<i32>, needle: i32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] <= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_i32(items: Span<i32>, needle: i32) -> usize {
+    let index: usize = __zero_std_search_lower_bound_i32(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_i32(items: Span<i32>, needle: i32) -> Bool {
+    return __zero_std_search_binary_i32(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_i32(items: Span<i32>, needle: i32) -> usize {
+    return __zero_std_search_upper_bound_i32(items, needle) - __zero_std_search_lower_bound_i32(items, needle)
+}
+
+fn __zero_std_search_equal_range_i32(items: Span<i32>, needle: i32) -> Span<i32> {
+    let start: usize = __zero_std_search_lower_bound_i32(items, needle)
+    let end: usize = __zero_std_search_upper_bound_i32(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_i32(items: Span<i32>, pivot: i32) -> usize {
+    return __zero_std_search_lower_bound_i32(items, pivot)
+}
+
+fn __zero_std_search_lower_bound_desc_i32(items: Span<i32>, needle: i32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] > needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_desc_i32(items: Span<i32>, needle: i32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] >= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_desc_i32(items: Span<i32>, needle: i32) -> usize {
+    let index: usize = __zero_std_search_lower_bound_desc_i32(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_desc_i32(items: Span<i32>, needle: i32) -> Bool {
+    return __zero_std_search_binary_desc_i32(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_desc_i32(items: Span<i32>, needle: i32) -> usize {
+    return __zero_std_search_upper_bound_desc_i32(items, needle) - __zero_std_search_lower_bound_desc_i32(items, needle)
+}
+
+fn __zero_std_search_equal_range_desc_i32(items: Span<i32>, needle: i32) -> Span<i32> {
+    let start: usize = __zero_std_search_lower_bound_desc_i32(items, needle)
+    let end: usize = __zero_std_search_upper_bound_desc_i32(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_desc_i32(items: Span<i32>, pivot: i32) -> usize {
+    return __zero_std_search_lower_bound_desc_i32(items, pivot)
+}
+
+fn __zero_std_search_min_i32(items: Span<i32>) -> Maybe<i32> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: i32 = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_min_index_i32(items: Span<i32>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_i32(items: Span<i32>) -> Maybe<i32> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: i32 = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_index_i32(items: Span<i32>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_lower_bound_u32(items: Span<u32>, needle: u32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] < needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_u32(items: Span<u32>, needle: u32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] <= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_u32(items: Span<u32>, needle: u32) -> usize {
+    let index: usize = __zero_std_search_lower_bound_u32(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_u32(items: Span<u32>, needle: u32) -> Bool {
+    return __zero_std_search_binary_u32(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_u32(items: Span<u32>, needle: u32) -> usize {
+    return __zero_std_search_upper_bound_u32(items, needle) - __zero_std_search_lower_bound_u32(items, needle)
+}
+
+fn __zero_std_search_equal_range_u32(items: Span<u32>, needle: u32) -> Span<u32> {
+    let start: usize = __zero_std_search_lower_bound_u32(items, needle)
+    let end: usize = __zero_std_search_upper_bound_u32(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_u32(items: Span<u32>, pivot: u32) -> usize {
+    return __zero_std_search_lower_bound_u32(items, pivot)
+}
+
+fn __zero_std_search_lower_bound_desc_u32(items: Span<u32>, needle: u32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] > needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_desc_u32(items: Span<u32>, needle: u32) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] >= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_desc_u32(items: Span<u32>, needle: u32) -> usize {
+    let index: usize = __zero_std_search_lower_bound_desc_u32(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_desc_u32(items: Span<u32>, needle: u32) -> Bool {
+    return __zero_std_search_binary_desc_u32(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_desc_u32(items: Span<u32>, needle: u32) -> usize {
+    return __zero_std_search_upper_bound_desc_u32(items, needle) - __zero_std_search_lower_bound_desc_u32(items, needle)
+}
+
+fn __zero_std_search_equal_range_desc_u32(items: Span<u32>, needle: u32) -> Span<u32> {
+    let start: usize = __zero_std_search_lower_bound_desc_u32(items, needle)
+    let end: usize = __zero_std_search_upper_bound_desc_u32(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_desc_u32(items: Span<u32>, pivot: u32) -> usize {
+    return __zero_std_search_lower_bound_desc_u32(items, pivot)
+}
+
+fn __zero_std_search_min_u32(items: Span<u32>) -> Maybe<u32> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: u32 = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_min_index_u32(items: Span<u32>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_u32(items: Span<u32>) -> Maybe<u32> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: u32 = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_index_u32(items: Span<u32>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_lower_bound_usize(items: Span<usize>, needle: usize) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] < needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_usize(items: Span<usize>, needle: usize) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] <= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_usize(items: Span<usize>, needle: usize) -> usize {
+    let index: usize = __zero_std_search_lower_bound_usize(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_usize(items: Span<usize>, needle: usize) -> Bool {
+    return __zero_std_search_binary_usize(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_usize(items: Span<usize>, needle: usize) -> usize {
+    return __zero_std_search_upper_bound_usize(items, needle) - __zero_std_search_lower_bound_usize(items, needle)
+}
+
+fn __zero_std_search_equal_range_usize(items: Span<usize>, needle: usize) -> Span<usize> {
+    let start: usize = __zero_std_search_lower_bound_usize(items, needle)
+    let end: usize = __zero_std_search_upper_bound_usize(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_usize(items: Span<usize>, pivot: usize) -> usize {
+    return __zero_std_search_lower_bound_usize(items, pivot)
+}
+
+fn __zero_std_search_lower_bound_desc_usize(items: Span<usize>, needle: usize) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] > needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_upper_bound_desc_usize(items: Span<usize>, needle: usize) -> usize {
+    var low: usize = 0
+    var high: usize = std.mem.len(items)
+    while low < high {
+        let mid: usize = low + (high - low) / 2
+        if items[mid] >= needle {
+            low = mid + 1
+        } else {
+            high = mid
+        }
+    }
+    return low
+}
+
+fn __zero_std_search_binary_desc_usize(items: Span<usize>, needle: usize) -> usize {
+    let index: usize = __zero_std_search_lower_bound_desc_usize(items, needle)
+    if index < std.mem.len(items) && items[index] == needle {
+        return index
+    }
+    return std.mem.len(items)
+}
+
+fn __zero_std_search_contains_sorted_desc_usize(items: Span<usize>, needle: usize) -> Bool {
+    return __zero_std_search_binary_desc_usize(items, needle) < std.mem.len(items)
+}
+
+fn __zero_std_search_count_sorted_desc_usize(items: Span<usize>, needle: usize) -> usize {
+    return __zero_std_search_upper_bound_desc_usize(items, needle) - __zero_std_search_lower_bound_desc_usize(items, needle)
+}
+
+fn __zero_std_search_equal_range_desc_usize(items: Span<usize>, needle: usize) -> Span<usize> {
+    let start: usize = __zero_std_search_lower_bound_desc_usize(items, needle)
+    let end: usize = __zero_std_search_upper_bound_desc_usize(items, needle)
+    return items[start..end]
+}
+
+fn __zero_std_search_partition_point_desc_usize(items: Span<usize>, pivot: usize) -> usize {
+    return __zero_std_search_lower_bound_desc_usize(items, pivot)
+}
+
+fn __zero_std_search_min_usize(items: Span<usize>) -> Maybe<usize> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: usize = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_min_index_usize(items: Span<usize>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] < items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_usize(items: Span<usize>) -> Maybe<usize> {
+    if std.mem.isEmpty(items) {
+        return null
+    }
+    var best: usize = items[0]
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > best {
+            best = items[index]
+        }
+        index = index + 1
+    }
+    return best
+}
+
+fn __zero_std_search_max_index_usize(items: Span<usize>) -> usize {
+    if std.mem.isEmpty(items) {
+        return std.mem.len(items)
+    }
+    var best: usize = 0
+    var index: usize = 1
+    while index < std.mem.len(items) {
+        if items[index] > items[best] {
+            best = index
+        }
+        index = index + 1
+    }
+    return best
+}

std/str.0

@@ -0,0 +1,444 @@
+fn __zero_std_str_is_ascii_space(byte: u8) -> Bool {
+    return byte == 32_u8 || byte == 9_u8 || (byte == 10_u8 || byte == 13_u8)
+}
+
+fn __zero_std_str_to_lower_byte(byte: u8) -> u8 {
+    if byte >= 65_u8 && byte <= 90_u8 {
+        return byte + 32_u8
+    }
+    return byte
+}
+
+fn __zero_std_str_to_upper_byte(byte: u8) -> u8 {
+    if byte >= 97_u8 && byte <= 122_u8 {
+        return byte - 32_u8
+    }
+    return byte
+}
+
+fn __zero_std_str_copy(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < len {
+        buffer[index] = text[index]
+        index = index + 1
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_str_concat(buffer: MutSpan<u8>, left: Span<u8>, right: Span<u8>) -> Maybe<Span<u8>> {
+    let left_len: usize = std.mem.len(left)
+    let right_len: usize = std.mem.len(right)
+    if left_len > std.mem.len(buffer) || right_len > std.mem.len(buffer) - left_len {
+        return null
+    }
+    var index: usize = 0
+    while index < left_len {
+        buffer[index] = left[index]
+        index = index + 1
+    }
+    var right_index: usize = 0
+    while right_index < right_len {
+        buffer[left_len + right_index] = right[right_index]
+        right_index = right_index + 1
+    }
+    return buffer[..left_len + right_len]
+}
+
+fn __zero_std_str_repeat(buffer: MutSpan<u8>, text: Span<u8>, count: usize) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if count > 0 && len > std.mem.len(buffer) / count {
+        return null
+    }
+    var out: usize = 0
+    var repetition: usize = 0
+    while repetition < count {
+        var index: usize = 0
+        while index < len {
+            buffer[out] = text[index]
+            out = out + 1
+            index = index + 1
+        }
+        repetition = repetition + 1
+    }
+    return buffer[..out]
+}
+
+fn __zero_std_str_replace(buffer: MutSpan<u8>, text: Span<u8>, old: Span<u8>, replacement: Span<u8>) -> Maybe<Span<u8>> {
+    let old_len: usize = std.mem.len(old)
+    if old_len == 0 {
+        return null
+    }
+    let text_len: usize = std.mem.len(text)
+    var read: usize = 0
+    var write: usize = 0
+    while read < text_len {
+        if old_len <= text_len - read && __zero_std_str_starts_with(text[read..], old) {
+            if std.mem.len(replacement) > std.mem.len(buffer) - write {
+                return null
+            }
+            var new_index: usize = 0
+            while new_index < std.mem.len(replacement) {
+                buffer[write] = replacement[new_index]
+                write = write + 1
+                new_index = new_index + 1
+            }
+            read = read + old_len
+        } else {
+            if write >= std.mem.len(buffer) {
+                return null
+            }
+            buffer[write] = text[read]
+            write = write + 1
+            read = read + 1
+        }
+    }
+    return buffer[..write]
+}
+
+fn __zero_std_str_to_lower_ascii(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < len {
+        buffer[index] = __zero_std_str_to_lower_byte(text[index])
+        index = index + 1
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_str_to_upper_ascii(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < len {
+        buffer[index] = __zero_std_str_to_upper_byte(text[index])
+        index = index + 1
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_str_reverse(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    let len: usize = std.mem.len(text)
+    if len > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < len {
+        buffer[index] = text[len - 1 - index]
+        index = index + 1
+    }
+    return buffer[..len]
+}
+
+fn __zero_std_str_count_byte(text: Span<u8>, byte: u8) -> usize {
+    var index: usize = 0
+    var count: usize = 0
+    while index < std.mem.len(text) {
+        if text[index] == byte {
+            count = count + 1
+        }
+        index = index + 1
+    }
+    return count
+}
+
+fn __zero_std_str_starts_with(text: Span<u8>, prefix: Span<u8>) -> Bool {
+    let prefix_len: usize = std.mem.len(prefix)
+    if prefix_len > std.mem.len(text) {
+        return false
+    }
+    var index: usize = 0
+    while index < prefix_len {
+        if text[index] != prefix[index] {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_str_ends_with(text: Span<u8>, suffix: Span<u8>) -> Bool {
+    let text_len: usize = std.mem.len(text)
+    let suffix_len: usize = std.mem.len(suffix)
+    if suffix_len > text_len {
+        return false
+    }
+    let start: usize = text_len - suffix_len
+    var index: usize = 0
+    while index < suffix_len {
+        if text[start + index] != suffix[index] {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_str_contains(text: Span<u8>, needle: Span<u8>) -> Bool {
+    let needle_len: usize = std.mem.len(needle)
+    if needle_len == 0 {
+        return true
+    }
+    let text_len: usize = std.mem.len(text)
+    if needle_len > text_len {
+        return false
+    }
+    let last_start: usize = text_len - needle_len
+    var start: usize = 0
+    while start <= last_start {
+        var offset: usize = 0
+        var same: Bool = true
+        while same && offset < needle_len {
+            if text[start + offset] != needle[offset] {
+                same = false
+            } else {
+                offset = offset + 1
+            }
+        }
+        if same {
+            return true
+        }
+        start = start + 1
+    }
+    return false
+}
+
+fn __zero_std_str_index_of(text: Span<u8>, needle: Span<u8>) -> usize {
+    let needle_len: usize = std.mem.len(needle)
+    if needle_len == 0 {
+        return 0
+    }
+    let text_len: usize = std.mem.len(text)
+    if needle_len > text_len {
+        return text_len
+    }
+    let last_start: usize = text_len - needle_len
+    var start: usize = 0
+    while start <= last_start {
+        var offset: usize = 0
+        var same: Bool = true
+        while same && offset < needle_len {
+            if text[start + offset] != needle[offset] {
+                same = false
+            } else {
+                offset = offset + 1
+            }
+        }
+        if same {
+            return start
+        }
+        start = start + 1
+    }
+    return text_len
+}
+
+fn __zero_std_str_last_index_of(text: Span<u8>, needle: Span<u8>) -> usize {
+    let needle_len: usize = std.mem.len(needle)
+    let text_len: usize = std.mem.len(text)
+    if needle_len == 0 {
+        return text_len
+    }
+    if needle_len > text_len {
+        return text_len
+    }
+    var start: usize = text_len - needle_len + 1
+    while start > 0 {
+        start = start - 1
+        var offset: usize = 0
+        var same: Bool = true
+        while same && offset < needle_len {
+            if text[start + offset] != needle[offset] {
+                same = false
+            } else {
+                offset = offset + 1
+            }
+        }
+        if same {
+            return start
+        }
+    }
+    return text_len
+}
+
+fn __zero_std_str_count(text: Span<u8>, needle: Span<u8>) -> usize {
+    let needle_len: usize = std.mem.len(needle)
+    if needle_len == 0 {
+        return std.mem.len(text) + 1
+    }
+    var index: usize = 0
+    var count: usize = 0
+    while index <= std.mem.len(text) {
+        let rest: Span<u8> = text[index..]
+        let found: usize = __zero_std_str_index_of(rest, needle)
+        if found == std.mem.len(rest) {
+            return count
+        }
+        count = count + 1
+        index = index + found + needle_len
+    }
+    return count
+}
+
+fn __zero_std_str_split_count(text: Span<u8>, sep: Span<u8>) -> usize {
+    if std.mem.len(sep) == 0 {
+        return 0
+    }
+    return __zero_std_str_count(text, sep) + 1
+}
+
+fn __zero_std_str_split(text: Span<u8>, sep: Span<u8>, part_index: usize) -> Maybe<Span<u8>> {
+    let sep_len: usize = std.mem.len(sep)
+    if sep_len == 0 {
+        return null
+    }
+    var current: usize = 0
+    var start: usize = 0
+    while start <= std.mem.len(text) {
+        let rest: Span<u8> = text[start..]
+        let found: usize = __zero_std_str_index_of(rest, sep)
+        let end: usize = start + found
+        if current == part_index {
+            return text[start..end]
+        }
+        if found == std.mem.len(rest) {
+            return null
+        }
+        current = current + 1
+        start = end + sep_len
+    }
+    return null
+}
+
+fn __zero_std_str_eql_ignore_ascii_case(left: Span<u8>, right: Span<u8>) -> Bool {
+    if std.mem.len(left) != std.mem.len(right) {
+        return false
+    }
+    var index: usize = 0
+    while index < std.mem.len(left) {
+        if __zero_std_str_to_lower_byte(left[index]) != __zero_std_str_to_lower_byte(right[index]) {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_str_trim_ascii(text: Span<u8>) -> Span<u8> {
+    var start: usize = 0
+    var end: usize = std.mem.len(text)
+    while start < end && __zero_std_str_is_ascii_space(text[start]) {
+        start = start + 1
+    }
+    while end > start && __zero_std_str_is_ascii_space(text[end - 1]) {
+        end = end - 1
+    }
+    return text[start..end]
+}
+
+fn __zero_std_str_trim_start_ascii(text: Span<u8>) -> Span<u8> {
+    var start: usize = 0
+    while start < std.mem.len(text) && __zero_std_str_is_ascii_space(text[start]) {
+        start = start + 1
+    }
+    return text[start..]
+}
+
+fn __zero_std_str_trim_end_ascii(text: Span<u8>) -> Span<u8> {
+    var end: usize = std.mem.len(text)
+    while end > 0 && __zero_std_str_is_ascii_space(text[end - 1]) {
+        end = end - 1
+    }
+    return text[..end]
+}
+
+fn __zero_std_str_field_count_ascii(text: Span<u8>) -> usize {
+    return __zero_std_str_word_count_ascii(text)
+}
+
+fn __zero_std_str_field_ascii(text: Span<u8>, field_index: usize) -> Maybe<Span<u8>> {
+    var index: usize = 0
+    var current: usize = 0
+    while index < std.mem.len(text) {
+        while index < std.mem.len(text) && __zero_std_str_is_ascii_space(text[index]) {
+            index = index + 1
+        }
+        if index >= std.mem.len(text) {
+            return null
+        }
+        let start: usize = index
+        while index < std.mem.len(text) && !__zero_std_str_is_ascii_space(text[index]) {
+            index = index + 1
+        }
+        if current == field_index {
+            return text[start..index]
+        }
+        current = current + 1
+    }
+    return null
+}
+
+fn __zero_std_str_line_count(text: Span<u8>) -> usize {
+    if std.mem.len(text) == 0 {
+        return 0
+    }
+    var count: usize = 1
+    var index: usize = 0
+    while index < std.mem.len(text) {
+        if text[index] == 10_u8 && index + 1 < std.mem.len(text) {
+            count = count + 1
+        }
+        index = index + 1
+    }
+    return count
+}
+
+fn __zero_std_str_line(text: Span<u8>, line_index: usize) -> Maybe<Span<u8>> {
+    if std.mem.len(text) == 0 {
+        return null
+    }
+    var current: usize = 0
+    var start: usize = 0
+    var index: usize = 0
+    while index <= std.mem.len(text) {
+        if index == std.mem.len(text) || text[index] == 10_u8 {
+            if index == std.mem.len(text) && start == std.mem.len(text) {
+                return null
+            }
+            var end: usize = index
+            if end > start && text[end - 1] == 13_u8 {
+                end = end - 1
+            }
+            if current == line_index {
+                return text[start..end]
+            }
+            current = current + 1
+            start = index + 1
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_str_word_count_ascii(text: Span<u8>) -> usize {
+    var index: usize = 0
+    var count: usize = 0
+    var in_word: Bool = false
+    while index < std.mem.len(text) {
+        if __zero_std_str_is_ascii_space(text[index]) {
+            in_word = false
+        } else if !in_word {
+            count = count + 1
+            in_word = true
+        }
+        index = index + 1
+    }
+    return count
+}

std/term.0

@@ -0,0 +1,74 @@
+fn term_empty(buffer: MutSpan<u8>) -> Span<u8> {
+    return buffer[..0]
+}
+
+fn term_cursor_count(buffer: MutSpan<u8>, count: usize, suffix: Span<u8>) -> Maybe<Span<u8>> {
+    if count == 0_usize {
+        return term_empty(buffer)
+    }
+    var digits_storage: [20]u8 = [0_u8; 20]
+    let digits: Maybe<Span<u8>> = std.fmt.usize(digits_storage, count)
+    if !digits.has {
+        return null
+    }
+    let start: Maybe<usize> = std.io.writeSpan(buffer, 0_usize, "\x1b[")
+    if !start.has {
+        return null
+    }
+    let wrote_count: Maybe<usize> = std.io.writeSpan(buffer, start.value, digits.value)
+    if !wrote_count.has {
+        return null
+    }
+    let wrote_suffix: Maybe<usize> = std.io.writeSpan(buffer, wrote_count.value, suffix)
+    if !wrote_suffix.has {
+        return null
+    }
+    return std.io.written(buffer, wrote_suffix.value)
+}
+
+fn term_cursor_to(buffer: MutSpan<u8>, row: usize, column: usize) -> Maybe<Span<u8>> {
+    var row_storage: [20]u8 = [0_u8; 20]
+    var column_storage: [20]u8 = [0_u8; 20]
+    let row_text: Maybe<Span<u8>> = std.fmt.usize(row_storage, row)
+    let column_text: Maybe<Span<u8>> = std.fmt.usize(column_storage, column)
+    if !row_text.has || !column_text.has {
+        return null
+    }
+    let start: Maybe<usize> = std.io.writeSpan(buffer, 0_usize, "\x1b[")
+    if !start.has {
+        return null
+    }
+    let wrote_row: Maybe<usize> = std.io.writeSpan(buffer, start.value, row_text.value)
+    if !wrote_row.has {
+        return null
+    }
+    let wrote_separator: Maybe<usize> = std.io.writeSpan(buffer, wrote_row.value, ";")
+    if !wrote_separator.has {
+        return null
+    }
+    let wrote_column: Maybe<usize> = std.io.writeSpan(buffer, wrote_separator.value, column_text.value)
+    if !wrote_column.has {
+        return null
+    }
+    let finish: Maybe<usize> = std.io.writeSpan(buffer, wrote_column.value, "H")
+    if !finish.has {
+        return null
+    }
+    return std.io.written(buffer, finish.value)
+}
+
+fn term_cursor_up(buffer: MutSpan<u8>, count: usize) -> Maybe<Span<u8>> {
+    return term_cursor_count(buffer, count, "A")
+}
+
+fn term_cursor_down(buffer: MutSpan<u8>, count: usize) -> Maybe<Span<u8>> {
+    return term_cursor_count(buffer, count, "B")
+}
+
+fn term_cursor_right(buffer: MutSpan<u8>, count: usize) -> Maybe<Span<u8>> {
+    return term_cursor_count(buffer, count, "C")
+}
+
+fn term_cursor_left(buffer: MutSpan<u8>, count: usize) -> Maybe<Span<u8>> {
+    return term_cursor_count(buffer, count, "D")
+}

std/testing.0

@@ -0,0 +1,102 @@
+fn __zero_std_testing_is_true(value: Bool) -> Bool {
+    return value
+}
+
+fn __zero_std_testing_is_false(value: Bool) -> Bool {
+    return !value
+}
+
+fn __zero_std_testing_equal_bool(actual: Bool, expected: Bool) -> Bool {
+    return actual == expected
+}
+
+fn __zero_std_testing_equal_usize(actual: usize, expected: usize) -> Bool {
+    return actual == expected
+}
+
+fn __zero_std_testing_equal_u32(actual: u32, expected: u32) -> Bool {
+    return actual == expected
+}
+
+fn __zero_std_testing_equal_i32(actual: i32, expected: i32) -> Bool {
+    return actual == expected
+}
+
+fn __zero_std_testing_equal_bytes(actual: Span<u8>, expected: Span<u8>) -> Bool {
+    return std.mem.eqlBytes(actual, expected)
+}
+
+fn __zero_std_testing_contains_bytes(actual: Span<u8>, needle: Span<u8>) -> Bool {
+    return std.str.contains(actual, needle)
+}
+
+fn __zero_std_testing_starts_with(actual: Span<u8>, prefix: Span<u8>) -> Bool {
+    return std.str.startsWith(actual, prefix)
+}
+
+fn __zero_std_testing_ends_with(actual: Span<u8>, suffix: Span<u8>) -> Bool {
+    return std.str.endsWith(actual, suffix)
+}
+
+fn __zero_std_testing_not_equal_bytes(actual: Span<u8>, expected: Span<u8>) -> Bool {
+    return !std.mem.eqlBytes(actual, expected)
+}
+
+fn __zero_std_testing_diff_index_bytes(actual: Span<u8>, expected: Span<u8>) -> Maybe<usize> {
+    var index: usize = 0
+    while index < std.mem.len(actual) && index < std.mem.len(expected) {
+        if actual[index] != expected[index] {
+            return index
+        }
+        index = index + 1
+    }
+    if std.mem.len(actual) != std.mem.len(expected) {
+        return index
+    }
+    return null
+}
+
+fn __zero_std_testing_json_field_equals(actual: Span<u8>, key: Span<u8>, expected: Span<u8>) -> Bool {
+    let field: Maybe<Span<u8>> = std.json.field(actual, key)
+    if field.has {
+        return std.mem.eqlBytes(field.value, expected)
+    }
+    return false
+}
+
+fn __zero_std_testing_json_path_equals(actual: Span<u8>, path: Span<u8>, expected: Span<u8>) -> Bool {
+    let value: Maybe<Span<u8>> = std.json.path(actual, path)
+    if value.has {
+        return std.mem.eqlBytes(value.value, expected)
+    }
+    return false
+}
+
+fn __zero_std_testing_case_name(buffer: MutSpan<u8>, suite: Span<u8>, index: usize) -> Maybe<Span<u8>> {
+    var offset: usize = 0
+    let wrote_suite: Maybe<usize> = std.io.writeSpan(buffer, offset, suite)
+    if !wrote_suite.has {
+        return null
+    }
+    offset = wrote_suite.value
+    let open: Maybe<usize> = std.io.writeSpan(buffer, offset, "[")
+    if !open.has {
+        return null
+    }
+    offset = open.value
+    var index_storage: [24]u8 = [0_u8; 24]
+    let index_text: Maybe<Span<u8>> = std.fmt.usize(index_storage, index)
+    if !index_text.has {
+        return null
+    }
+    let wrote_index: Maybe<usize> = std.io.writeSpan(buffer, offset, index_text.value)
+    if !wrote_index.has {
+        return null
+    }
+    offset = wrote_index.value
+    let close: Maybe<usize> = std.io.writeSpan(buffer, offset, "]")
+    if close.has {
+        return buffer[..close.value]
+    }
+    return null
+}

std/text.0

@@ -0,0 +1,112 @@
+fn __zero_std_text_is_ascii(text: Span<u8>) -> Bool {
+    var index: usize = 0
+    while index < std.mem.len(text) {
+        if text[index] >= 128_u8 {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_text_utf8_sequence_len(first: u8) -> usize {
+    if first < 128_u8 {
+        return 1
+    }
+    if first >= 194_u8 && first <= 223_u8 {
+        return 2
+    }
+    if first >= 224_u8 && first <= 239_u8 {
+        return 3
+    }
+    if first >= 240_u8 && first <= 244_u8 {
+        return 4
+    }
+    return 0
+}
+
+fn __zero_std_text_is_cont(byte: u8) -> Bool {
+    return byte >= 128_u8 && byte <= 191_u8
+}
+
+fn __zero_std_text_utf8_valid(text: Span<u8>) -> Bool {
+    var index: usize = 0
+    while index < std.mem.len(text) {
+        let first: u8 = text[index]
+        let width: usize = __zero_std_text_utf8_sequence_len(first)
+        if width == 0 || index + width > std.mem.len(text) {
+            return false
+        }
+        if width == 2 {
+            if !__zero_std_text_is_cont(text[index + 1]) {
+                return false
+            }
+        } else if width == 3 {
+            let second: u8 = text[index + 1]
+            if !__zero_std_text_is_cont(second) || !__zero_std_text_is_cont(text[index + 2]) {
+                return false
+            }
+            if first == 224_u8 && second < 160_u8 {
+                return false
+            }
+            if first == 237_u8 && second > 159_u8 {
+                return false
+            }
+        } else if width == 4 {
+            let second: u8 = text[index + 1]
+            if !__zero_std_text_is_cont(second) || !__zero_std_text_is_cont(text[index + 2]) || !__zero_std_text_is_cont(text[index + 3]) {
+                return false
+            }
+            if first == 240_u8 && second < 144_u8 {
+                return false
+            }
+            if first == 244_u8 && second > 143_u8 {
+                return false
+            }
+        }
+        index = index + width
+    }
+    return true
+}
+
+fn __zero_std_text_utf8_len(text: Span<u8>) -> Maybe<usize> {
+    var index: usize = 0
+    var count: usize = 0
+    while index < std.mem.len(text) {
+        let first: u8 = text[index]
+        let width: usize = __zero_std_text_utf8_sequence_len(first)
+        if width == 0 || index + width > std.mem.len(text) {
+            return null
+        }
+        if width == 2 {
+            if !__zero_std_text_is_cont(text[index + 1]) {
+                return null
+            }
+        } else if width == 3 {
+            let second: u8 = text[index + 1]
+            if !__zero_std_text_is_cont(second) || !__zero_std_text_is_cont(text[index + 2]) {
+                return null
+            }
+            if first == 224_u8 && second < 160_u8 {
+                return null
+            }
+            if first == 237_u8 && second > 159_u8 {
+                return null
+            }
+        } else if width == 4 {
+            let second: u8 = text[index + 1]
+            if !__zero_std_text_is_cont(second) || !__zero_std_text_is_cont(text[index + 2]) || !__zero_std_text_is_cont(text[index + 3]) {
+                return null
+            }
+            if first == 240_u8 && second < 144_u8 {
+                return null
+            }
+            if first == 244_u8 && second > 143_u8 {
+                return null
+            }
+        }
+        index = index + width
+        count = count + 1
+    }
+    return count
+}

std/time.0

@@ -0,0 +1,360 @@
+fn __zero_std_time_zero() -> Duration {
+    return std.time.ns(0)
+}
+
+fn __zero_std_time_minutes(value: i32) -> Duration {
+    return std.time.ns((value as i64) * 60000000000)
+}
+
+fn __zero_std_time_hours(value: i32) -> Duration {
+    return std.time.ns((value as i64) * 3600000000000)
+}
+
+fn __zero_std_time_min(left: Duration, right: Duration) -> Duration {
+    if std.time.lessThan(left, right) {
+        return left
+    }
+    return right
+}
+
+fn __zero_std_time_max(left: Duration, right: Duration) -> Duration {
+    if std.time.lessThan(left, right) {
+        return right
+    }
+    return left
+}
+
+fn __zero_std_time_clamp(value: Duration, low: Duration, high: Duration) -> Duration {
+    let lower: Duration = __zero_std_time_min(low, high)
+    let upper: Duration = __zero_std_time_max(low, high)
+    if std.time.lessThan(value, lower) {
+        return lower
+    }
+    if std.time.lessThan(upper, value) {
+        return upper
+    }
+    return value
+}
+
+fn __zero_std_time_as_us_floor(value: Duration) -> i64 {
+    let ns: i64 = std.time.asNs(value)
+    let quotient: i64 = ns / 1000_i64
+    let remainder: i64 = ns % 1000_i64
+    if ns < 0_i64 && remainder != 0_i64 {
+        return quotient - 1_i64
+    }
+    return quotient
+}
+
+fn __zero_std_time_as_ms_floor(value: Duration) -> i32 {
+    let ns: i64 = std.time.asNs(value)
+    let quotient: i64 = ns / 1000000_i64
+    let remainder: i64 = ns % 1000000_i64
+    if ns < 0_i64 && remainder != 0_i64 {
+        return (quotient - 1_i64) as i32
+    }
+    return quotient as i32
+}
+
+fn __zero_std_time_as_seconds_floor(value: Duration) -> i64 {
+    let ns: i64 = std.time.asNs(value)
+    let quotient: i64 = ns / 1000000000_i64
+    let remainder: i64 = ns % 1000000000_i64
+    if ns < 0_i64 && remainder != 0_i64 {
+        return quotient - 1_i64
+    }
+    return quotient
+}
+
+fn __zero_std_time_is_zero(value: Duration) -> Bool {
+    return std.time.asNs(value) == 0
+}
+
+fn __zero_std_time_abs(value: Duration) -> Duration {
+    if std.time.lessThan(value, std.time.zero()) {
+        return std.time.sub(std.time.zero(), value)
+    }
+    return value
+}
+
+fn __zero_std_time_between(start: Duration, end: Duration) -> Duration {
+    if std.time.lessThan(end, start) {
+        return std.time.sub(start, end)
+    }
+    return std.time.sub(end, start)
+}
+
+fn __zero_std_time_has_elapsed(start: Duration, now: Duration, timeout: Duration) -> Bool {
+    if std.time.lessThan(now, start) {
+        return false
+    }
+    let elapsed: Duration = std.time.sub(now, start)
+    return !std.time.lessThan(elapsed, timeout)
+}
+
+fn __zero_std_time_deadline_after(start: Duration, timeout: Duration) -> Duration {
+    return std.time.add(start, timeout)
+}
+
+fn __zero_std_time_remaining_until(deadline: Duration, now: Duration) -> Duration {
+    if !std.time.lessThan(now, deadline) {
+        return std.time.zero()
+    }
+    return std.time.sub(deadline, now)
+}
+
+fn __zero_std_time_deadline_expired(deadline: Duration, now: Duration) -> Bool {
+    return !std.time.lessThan(now, deadline)
+}
+
+fn __zero_std_time_rfc_is_digit(byte: u8) -> Bool {
+    return byte >= 48_u8 && byte <= 57_u8
+}
+
+fn __zero_std_time_rfc_digit(byte: u8) -> u32 {
+    return (byte - 48_u8) as u32
+}
+
+fn __zero_std_time_is_leap_year(year: u32) -> Bool {
+    if year % 4_u32 != 0_u32 {
+        return false
+    }
+    if year % 100_u32 != 0_u32 {
+        return true
+    }
+    return year % 400_u32 == 0_u32
+}
+
+fn __zero_std_time_days_in_month(year: u32, month: u32) -> u32 {
+    if month < 1_u32 || month > 12_u32 {
+        return 0_u32
+    }
+    if month == 2_u32 {
+        if __zero_std_time_is_leap_year(year) {
+            return 29_u32
+        }
+        return 28_u32
+    }
+    if month == 4_u32 || month == 6_u32 || (month == 9_u32 || month == 11_u32) {
+        return 30_u32
+    }
+    return 31_u32
+}
+
+fn __zero_std_time_rfc_date_core(text: Span<u8>) -> u64 {
+    if std.mem.len(text) != 10 {
+        return 0
+    }
+    if text[4] != 45_u8 || text[7] != 45_u8 {
+        return 0
+    }
+    var index: usize = 0
+    while index < 10 {
+        if index != 4 && index != 7 {
+            if !__zero_std_time_rfc_is_digit(text[index]) {
+                return 0
+            }
+        }
+        index = index + 1
+    }
+    let year: u32 = __zero_std_time_rfc_digit(text[0]) * 1000_u32 + __zero_std_time_rfc_digit(text[1]) * 100_u32 + __zero_std_time_rfc_digit(text[2]) * 10_u32 + __zero_std_time_rfc_digit(text[3])
+    let month: u32 = __zero_std_time_rfc_digit(text[5]) * 10_u32 + __zero_std_time_rfc_digit(text[6])
+    let day: u32 = __zero_std_time_rfc_digit(text[8]) * 10_u32 + __zero_std_time_rfc_digit(text[9])
+    let max_day: u32 = __zero_std_time_days_in_month(year, month)
+    if max_day == 0_u32 || (day < 1_u32 || day > max_day) {
+        return 0
+    }
+    return 4294967296_u64 + (year as u64) * 65536_u64 + (month as u64) * 256_u64 + (day as u64)
+}
+
+fn __zero_std_time_rfc_time_core(text: Span<u8>) -> u64 {
+    let len: usize = std.mem.len(text)
+    if len < 9 {
+        return 0
+    }
+    if text[2] != 58_u8 || text[5] != 58_u8 {
+        return 0
+    }
+    var index: usize = 0
+    while index < 8 {
+        if index != 2 && index != 5 {
+            if !__zero_std_time_rfc_is_digit(text[index]) {
+                return 0
+            }
+        }
+        index = index + 1
+    }
+    let hh: u32 = __zero_std_time_rfc_digit(text[0]) * 10_u32 + __zero_std_time_rfc_digit(text[1])
+    let mm: u32 = __zero_std_time_rfc_digit(text[3]) * 10_u32 + __zero_std_time_rfc_digit(text[4])
+    let ss: u32 = __zero_std_time_rfc_digit(text[6]) * 10_u32 + __zero_std_time_rfc_digit(text[7])
+    if hh > 23_u32 || (mm > 59_u32 || ss > 60_u32) {
+        return 0
+    }
+    var pos: usize = 8
+    if text[pos] == 46_u8 {
+        pos = pos + 1
+        var fraction_digits: usize = 0
+        while pos < len && __zero_std_time_rfc_is_digit(text[pos]) {
+            fraction_digits = fraction_digits + 1
+            pos = pos + 1
+        }
+        if fraction_digits == 0 {
+            return 0
+        }
+    }
+    if pos >= len {
+        return 0
+    }
+    var offset_minutes: i64 = 0
+    let marker: u8 = text[pos]
+    if marker == 90_u8 || marker == 122_u8 {
+        if pos + 1 != len {
+            return 0
+        }
+    } else if marker == 43_u8 || marker == 45_u8 {
+        if pos + 6 != len {
+            return 0
+        }
+        if text[pos + 3] != 58_u8 {
+            return 0
+        }
+        if !__zero_std_time_rfc_is_digit(text[pos + 1]) || (!__zero_std_time_rfc_is_digit(text[pos + 2]) || (!__zero_std_time_rfc_is_digit(text[pos + 4]) || !__zero_std_time_rfc_is_digit(text[pos + 5]))) {
+            return 0
+        }
+        let oh: u32 = __zero_std_time_rfc_digit(text[pos + 1]) * 10_u32 + __zero_std_time_rfc_digit(text[pos + 2])
+        let om: u32 = __zero_std_time_rfc_digit(text[pos + 4]) * 10_u32 + __zero_std_time_rfc_digit(text[pos + 5])
+        if oh > 23_u32 || om > 59_u32 {
+            return 0
+        }
+        offset_minutes = (oh as i64) * 60_i64 + (om as i64)
+        if marker == 45_u8 {
+            offset_minutes = 0_i64 - offset_minutes
+        }
+    } else {
+        return 0
+    }
+    if ss == 60_u32 {
+        var normalized: i64 = (hh as i64) * 60_i64 + (mm as i64) - offset_minutes
+        normalized = normalized % 1440_i64
+        if normalized < 0_i64 {
+            normalized = normalized + 1440_i64
+        }
+        if normalized != 1439_i64 {
+            return 0
+        }
+    }
+    return 1099511627776_u64 + (hh as u64) * 4294967296_u64 + (mm as u64) * 16777216_u64 + (ss as u64) * 65536_u64 + ((offset_minutes + 1440_i64) as u64)
+}
+
+fn __zero_std_time_is_rfc3339_date(text: Span<u8>) -> Bool {
+    return __zero_std_time_rfc_date_core(text) != 0
+}
+
+fn __zero_std_time_is_rfc3339_time(text: Span<u8>) -> Bool {
+    return __zero_std_time_rfc_time_core(text) != 0
+}
+
+fn __zero_std_time_rfc_datetime_split(text: Span<u8>) -> usize {
+    let len: usize = std.mem.len(text)
+    if len < 11 {
+        return 0
+    }
+    if text[10] == 84_u8 || text[10] == 116_u8 {
+        return 10
+    }
+    return 0
+}
+
+fn __zero_std_time_is_rfc3339_datetime(text: Span<u8>) -> Bool {
+    let split: usize = __zero_std_time_rfc_datetime_split(text)
+    if split == 0 {
+        return false
+    }
+    if __zero_std_time_rfc_date_core(text[..split]) == 0 {
+        return false
+    }
+    return __zero_std_time_rfc_time_core(text[split + 1..]) != 0
+}
+
+fn __zero_std_time_days_from_civil(year: i64, month: i64, day: i64) -> i64 {
+    var y: i64 = year
+    if month <= 2_i64 {
+        y = y - 1_i64
+    }
+    var era: i64 = y
+    if era < 0_i64 {
+        era = era - 399_i64
+    }
+    era = era / 400_i64
+    let yoe: i64 = y - era * 400_i64
+    var mp: i64 = month + 9_i64
+    if month > 2_i64 {
+        mp = month - 3_i64
+    }
+    let doy: i64 = (153_i64 * mp + 2_i64) / 5_i64 + day - 1_i64
+    let doe: i64 = yoe * 365_i64 + yoe / 4_i64 - yoe / 100_i64 + doy
+    return era * 146097_i64 + doe - 719468_i64
+}
+
+fn __zero_std_time_parse_rfc3339_datetime_or(text: Span<u8>, fallback: i64) -> i64 {
+    let split: usize = __zero_std_time_rfc_datetime_split(text)
+    if split == 0 {
+        return fallback
+    }
+    let date: u64 = __zero_std_time_rfc_date_core(text[..split])
+    if date == 0 {
+        return fallback
+    }
+    let clock: u64 = __zero_std_time_rfc_time_core(text[split + 1..])
+    if clock == 0 {
+        return fallback
+    }
+    let year: i64 = ((date / 65536_u64) % 65536_u64) as i64
+    let month: i64 = ((date / 256_u64) % 256_u64) as i64
+    let day: i64 = (date % 256_u64) as i64
+    let hh: i64 = ((clock / 4294967296_u64) % 256_u64) as i64
+    let mm: i64 = ((clock / 16777216_u64) % 256_u64) as i64
+    var ss: i64 = ((clock / 65536_u64) % 256_u64) as i64
+    if ss == 60_i64 {
+        ss = 59_i64
+    }
+    let offset_minutes: i64 = ((clock % 65536_u64) as i64) - 1440_i64
+    let days: i64 = __zero_std_time_days_from_civil(year, month, day)
+    return days * 86400_i64 + hh * 3600_i64 + mm * 60_i64 + ss - offset_minutes * 60_i64
+}
+
+fn __zero_std_time_write_i64_unit(buffer: MutSpan<u8>, value: i64, unit: Span<u8>) -> Maybe<Span<u8>> {
+    var digits_storage: [24]u8 = [0_u8; 24]
+    let digits: Maybe<Span<u8>> = std.fmt.i64(digits_storage, value)
+    if !digits.has {
+        return null
+    }
+    let wrote_digits: Maybe<usize> = std.io.writeSpan(buffer, 0, digits.value)
+    if !wrote_digits.has {
+        return null
+    }
+    let wrote_unit: Maybe<usize> = std.io.writeSpan(buffer, wrote_digits.value, unit)
+    if !wrote_unit.has {
+        return null
+    }
+    return buffer[..wrote_unit.value]
+}
+
+fn __zero_std_time_write_duration_ns(buffer: MutSpan<u8>, value: Duration) -> Maybe<Span<u8>> {
+    return __zero_std_time_write_i64_unit(buffer, std.time.asNs(value), "ns")
+}
+
+fn __zero_std_time_write_duration_ms(buffer: MutSpan<u8>, value: Duration) -> Maybe<Span<u8>> {
+    let ns: i64 = std.time.asNs(value)
+    let quotient: i64 = ns / 1000000_i64
+    let remainder: i64 = ns % 1000000_i64
+    var milliseconds: i64 = quotient
+    if ns < 0_i64 && remainder != 0_i64 {
+        milliseconds = quotient - 1_i64
+    }
+    return __zero_std_time_write_i64_unit(buffer, milliseconds, "ms")
+}
+
+fn __zero_std_time_write_duration_seconds(buffer: MutSpan<u8>, value: Duration) -> Maybe<Span<u8>> {
+    return __zero_std_time_write_i64_unit(buffer, std.time.asSecondsFloor(value), "s")
+}

std/toml.0

@@ -0,0 +1,660 @@
+fn __zero_std_toml_validate(bytes: Span<u8>) -> Bool {
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        let line_end: usize = __zero_std_toml_line_end(bytes, index)
+        let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
+        let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
+        if start < content_end {
+            if bytes[start] == 91_u8 {
+                let table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
+                if !table_end.has {
+                    return false
+                }
+            } else {
+                let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
+                if !equals.has {
+                    return false
+                }
+                let key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
+                let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
+                let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
+                if key_end == start || value_start == value_end || !__zero_std_toml_value_valid(bytes[value_start..value_end]) {
+                    return false
+                }
+            }
+        }
+        index = line_end
+        if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
+            index = index + 1
+        }
+    }
+    return true
+}
+
+fn __zero_std_toml_validate_bytes(bytes: Span<u8>) -> Bool {
+    return __zero_std_toml_validate(bytes)
+}
+
+fn __zero_std_toml_field(bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    var table_start: usize = 0
+    var table_end: usize = 0
+    var has_table: Bool = false
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        let line_end: usize = __zero_std_toml_line_end(bytes, index)
+        let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
+        let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
+        if start < content_end {
+            if bytes[start] == 91_u8 {
+                let next_table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
+                if !next_table_end.has {
+                    return null
+                }
+                table_start = start + 1
+                table_end = next_table_end.value
+                has_table = true
+            } else {
+                let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
+                if !equals.has {
+                    return null
+                }
+                let field_key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
+                let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
+                let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
+                var table: Span<u8> = bytes[0..0]
+                if has_table {
+                    table = bytes[table_start..table_end]
+                }
+                if __zero_std_toml_key_matches(table, bytes[start..field_key_end], key) {
+                    return bytes[value_start..value_end]
+                }
+            }
+        }
+        index = line_end
+        if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
+            index = index + 1
+        }
+    }
+    return null
+}
+
+fn __zero_std_toml_string_decode(buffer: MutSpan<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    if std.mem.len(value) < 2 || value[0] != 34_u8 || value[std.mem.len(value) - 1] != 34_u8 {
+        return null
+    }
+    var input: usize = 1
+    var output: usize = 0
+    while input + 1 < std.mem.len(value) {
+        var byte: u8 = value[input]
+        if byte == 92_u8 {
+            input = input + 1
+            if input + 1 >= std.mem.len(value) {
+                return null
+            }
+            let escaped: u8 = value[input]
+            if escaped == 34_u8 {
+                byte = 34_u8
+            } else if escaped == 92_u8 {
+                byte = 92_u8
+            } else if escaped == 110_u8 {
+                byte = 10_u8
+            } else if escaped == 114_u8 {
+                byte = 13_u8
+            } else if escaped == 116_u8 {
+                byte = 9_u8
+            } else {
+                return null
+            }
+        }
+        if output >= std.mem.len(buffer) {
+            return null
+        }
+        buffer[output] = byte
+        output = output + 1
+        input = input + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_toml_string(buffer: MutSpan<u8>, bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
+    if !raw.has {
+        return null
+    }
+    return __zero_std_toml_string_decode(buffer, raw.value)
+}
+
+fn __zero_std_toml_u32(bytes: Span<u8>, key: Span<u8>) -> Maybe<u32> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseU32(raw.value)
+}
+
+fn __zero_std_toml_i32(bytes: Span<u8>, key: Span<u8>) -> Maybe<i32> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseI32(raw.value)
+}
+
+fn __zero_std_toml_bool(bytes: Span<u8>, key: Span<u8>) -> Maybe<Bool> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseBool(raw.value)
+}
+
+fn __zero_std_toml_array_count(value: Span<u8>) -> Maybe<usize> {
+    if !__zero_std_toml_array_valid(value) {
+        return null
+    }
+    var count: usize = 0
+    var index: usize = 1
+    let end: usize = std.mem.len(value) - 1
+    while index < end {
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index == end {
+            return count
+        }
+        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
+        if !item_end.has {
+            return null
+        }
+        count = count + 1
+        index = item_end.value
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index < end {
+            index = index + 1
+        }
+    }
+    return count
+}
+
+fn __zero_std_toml_array_value(value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
+    if !__zero_std_toml_array_valid(value) {
+        return null
+    }
+    var count: usize = 0
+    var index: usize = 1
+    let end: usize = std.mem.len(value) - 1
+    while index < end {
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index == end {
+            return null
+        }
+        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
+        if !item_end.has {
+            return null
+        }
+        if count == ordinal {
+            return value[index..item_end.value]
+        }
+        count = count + 1
+        index = item_end.value
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index < end {
+            index = index + 1
+        }
+    }
+    return null
+}
+
+fn __zero_std_toml_array_string(buffer: MutSpan<u8>, value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
+    if !raw.has {
+        return null
+    }
+    return __zero_std_toml_string_decode(buffer, raw.value)
+}
+
+fn __zero_std_toml_array_u32(value: Span<u8>, ordinal: usize) -> Maybe<u32> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseU32(raw.value)
+}
+
+fn __zero_std_toml_array_i32(value: Span<u8>, ordinal: usize) -> Maybe<i32> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseI32(raw.value)
+}
+
+fn __zero_std_toml_array_bool(value: Span<u8>, ordinal: usize) -> Maybe<Bool> {
+    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
+    if !raw.has {
+        return null
+    }
+    return std.parse.parseBool(raw.value)
+}
+
+fn __zero_std_toml_key_byte_valid(byte: u8) -> Bool {
+    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8) || (byte >= 48_u8 && byte <= 57_u8) || byte == 45_u8 || byte == 95_u8
+}
+
+fn __zero_std_toml_dotted_key_valid(key: Span<u8>) -> Bool {
+    if std.mem.len(key) == 0 {
+        return false
+    }
+    var index: usize = 0
+    var segment_has_byte: Bool = false
+    while index < std.mem.len(key) {
+        let byte: u8 = key[index]
+        if byte == 46_u8 {
+            if !segment_has_byte {
+                return false
+            }
+            segment_has_byte = false
+        } else if __zero_std_toml_key_byte_valid(byte) {
+            segment_has_byte = true
+        } else {
+            return false
+        }
+        index = index + 1
+    }
+    return segment_has_byte
+}
+
+fn __zero_std_toml_write_key_value_string(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    if !__zero_std_toml_dotted_key_valid(key) {
+        return null
+    }
+    var cursor: usize = 0
+    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
+    if !key_end.has {
+        return null
+    }
+    cursor = key_end.value
+    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
+    if !sep_end.has {
+        return null
+    }
+    cursor = sep_end.value
+    let value_end: Maybe<usize> = __zero_std_toml_write_escaped_string(buffer, cursor, value)
+    if !value_end.has {
+        return null
+    }
+    cursor = value_end.value
+    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
+    if !line_end.has {
+        return null
+    }
+    return buffer[..line_end.value]
+}
+
+fn __zero_std_toml_write_key_value_u32(buffer: MutSpan<u8>, key: Span<u8>, value: u32) -> Maybe<Span<u8>> {
+    if !__zero_std_toml_dotted_key_valid(key) {
+        return null
+    }
+    var cursor: usize = 0
+    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
+    if !key_end.has {
+        return null
+    }
+    cursor = key_end.value
+    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
+    if !sep_end.has {
+        return null
+    }
+    cursor = sep_end.value
+    let digits: Maybe<Span<u8>> = std.fmt.u32(buffer[cursor..], value)
+    if !digits.has {
+        return null
+    }
+    cursor = cursor + std.mem.len(digits.value)
+    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
+    if !line_end.has {
+        return null
+    }
+    return buffer[..line_end.value]
+}
+
+fn __zero_std_toml_write_key_value_bool(buffer: MutSpan<u8>, key: Span<u8>, value: Bool) -> Maybe<Span<u8>> {
+    if !__zero_std_toml_dotted_key_valid(key) {
+        return null
+    }
+    var cursor: usize = 0
+    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
+    if !key_end.has {
+        return null
+    }
+    cursor = key_end.value
+    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
+    if !sep_end.has {
+        return null
+    }
+    cursor = sep_end.value
+    var value_end: Maybe<usize> = null
+    if value {
+        value_end = __zero_std_toml_write_span(buffer, cursor, "true")
+    } else {
+        value_end = __zero_std_toml_write_span(buffer, cursor, "false")
+    }
+    if !value_end.has {
+        return null
+    }
+    cursor = value_end.value
+    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
+    if !line_end.has {
+        return null
+    }
+    return buffer[..line_end.value]
+}
+
+fn __zero_std_toml_write_table_header(buffer: MutSpan<u8>, table: Span<u8>) -> Maybe<Span<u8>> {
+    if !__zero_std_toml_dotted_key_valid(table) {
+        return null
+    }
+    var cursor: usize = 0
+    let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "[")
+    if !open_end.has {
+        return null
+    }
+    cursor = open_end.value
+    let table_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, table)
+    if !table_end.has {
+        return null
+    }
+    cursor = table_end.value
+    let close_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "]\n")
+    if !close_end.has {
+        return null
+    }
+    return buffer[..close_end.value]
+}
+
+fn __zero_std_toml_line_end(bytes: Span<u8>, start: usize) -> usize {
+    var index: usize = start
+    while index < std.mem.len(bytes) && bytes[index] != 10_u8 {
+        index = index + 1
+    }
+    return index
+}
+
+fn __zero_std_toml_skip_ws(bytes: Span<u8>, start: usize, end: usize) -> usize {
+    var index: usize = start
+    while index < end && (bytes[index] == 32_u8 || bytes[index] == 9_u8 || bytes[index] == 13_u8) {
+        index = index + 1
+    }
+    return index
+}
+
+fn __zero_std_toml_trim_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
+    var index: usize = end
+    while index > start && (bytes[index - 1] == 32_u8 || bytes[index - 1] == 9_u8 || bytes[index - 1] == 13_u8) {
+        index = index - 1
+    }
+    return index
+}
+
+fn __zero_std_toml_comment_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
+    var index: usize = start
+    var in_string: Bool = false
+    var escaped: Bool = false
+    while index < end {
+        let byte: u8 = bytes[index]
+        if escaped {
+            escaped = false
+        } else if in_string && byte == 92_u8 {
+            escaped = true
+        } else if byte == 34_u8 {
+            in_string = !in_string
+        } else if !in_string && byte == 35_u8 {
+            return __zero_std_toml_trim_end(bytes, start, index)
+        }
+        index = index + 1
+    }
+    return end
+}
+
+fn __zero_std_toml_find_equals(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
+    var index: usize = start
+    var in_string: Bool = false
+    var escaped: Bool = false
+    while index < end {
+        let byte: u8 = bytes[index]
+        if escaped {
+            escaped = false
+        } else if in_string && byte == 92_u8 {
+            escaped = true
+        } else if byte == 34_u8 {
+            in_string = !in_string
+        } else if !in_string && byte == 61_u8 {
+            return index
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_toml_table_end(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
+    if start >= end || bytes[start] != 91_u8 {
+        return null
+    }
+    var index: usize = start + 1
+    while index < end {
+        if bytes[index] == 93_u8 {
+            let trailing: usize = __zero_std_toml_skip_ws(bytes, index + 1, end)
+            if trailing == end && index > start + 1 {
+                return index
+            }
+            return null
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_toml_string_value_end(value: Span<u8>) -> Maybe<usize> {
+    if std.mem.len(value) == 0 || value[0] != 34_u8 {
+        return null
+    }
+    var index: usize = 1
+    var escaped: Bool = false
+    while index < std.mem.len(value) {
+        let byte: u8 = value[index]
+        if escaped {
+            if !(byte == 34_u8 || byte == 92_u8 || byte == 110_u8 || byte == 114_u8 || byte == 116_u8) {
+                return null
+            }
+            escaped = false
+        } else if byte == 92_u8 {
+            escaped = true
+        } else if byte == 34_u8 {
+            return index + 1
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_toml_array_valid(value: Span<u8>) -> Bool {
+    if std.mem.len(value) < 2 || value[0] != 91_u8 || value[std.mem.len(value) - 1] != 93_u8 {
+        return false
+    }
+    var index: usize = 1
+    let end: usize = std.mem.len(value) - 1
+    while index < end {
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index == end {
+            return true
+        }
+        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
+        if !item_end.has {
+            return false
+        }
+        index = item_end.value
+        index = __zero_std_toml_skip_ws(value, index, end)
+        if index < end {
+            if value[index] != 44_u8 {
+                return false
+            }
+            index = index + 1
+        }
+    }
+    return true
+}
+
+fn __zero_std_toml_array_item_end(value: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
+    if start >= end {
+        return null
+    }
+    if value[start] == 34_u8 {
+        let item_end: Maybe<usize> = __zero_std_toml_string_value_end(value[start..end])
+        if !item_end.has {
+            return null
+        }
+        return start + item_end.value
+    }
+    var index: usize = start
+    while index < end && value[index] != 44_u8 {
+        index = index + 1
+    }
+    let trimmed: usize = __zero_std_toml_trim_end(value, start, index)
+    if trimmed == start {
+        return null
+    }
+    if __zero_std_toml_value_valid(value[start..trimmed]) {
+        return trimmed
+    }
+    return null
+}
+
+fn __zero_std_toml_value_valid(value: Span<u8>) -> Bool {
+    if std.mem.len(value) == 0 {
+        return false
+    }
+    if value[0] == 34_u8 {
+        let end: Maybe<usize> = __zero_std_toml_string_value_end(value)
+        return end.has && end.value == std.mem.len(value)
+    }
+    if value[0] == 91_u8 {
+        return __zero_std_toml_array_valid(value)
+    }
+    if std.mem.eql(value, "true") || std.mem.eql(value, "false") {
+        return true
+    }
+    let signed: Maybe<i32> = std.parse.parseI32(value)
+    if signed.has {
+        return true
+    }
+    let unsigned: Maybe<u32> = std.parse.parseU32(value)
+    return unsigned.has
+}
+
+fn __zero_std_toml_write_span(buffer: MutSpan<u8>, cursor: usize, bytes: Span<u8>) -> Maybe<usize> {
+    if cursor + std.mem.len(bytes) > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        buffer[cursor + index] = bytes[index]
+        index = index + 1
+    }
+    return cursor + std.mem.len(bytes)
+}
+
+fn __zero_std_toml_write_escaped_string(buffer: MutSpan<u8>, cursor: usize, value: Span<u8>) -> Maybe<usize> {
+    var output: usize = cursor
+    let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\"")
+    if !open_end.has {
+        return null
+    }
+    output = open_end.value
+    var index: usize = 0
+    while index < std.mem.len(value) {
+        let byte: u8 = value[index]
+        if byte == 34_u8 {
+            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\"")
+            if !next.has {
+                return null
+            }
+            output = next.value
+        } else if byte == 92_u8 {
+            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\\")
+            if !next.has {
+                return null
+            }
+            output = next.value
+        } else if byte == 10_u8 {
+            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\n")
+            if !next.has {
+                return null
+            }
+            output = next.value
+        } else if byte == 13_u8 {
+            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\r")
+            if !next.has {
+                return null
+            }
+            output = next.value
+        } else if byte == 9_u8 {
+            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\t")
+            if !next.has {
+                return null
+            }
+            output = next.value
+        } else {
+            if byte < 32_u8 || output >= std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = byte
+            output = output + 1
+        }
+        index = index + 1
+    }
+    return __zero_std_toml_write_span(buffer, output, "\"")
+}
+
+fn __zero_std_toml_span_eq(left: Span<u8>, right: Span<u8>) -> Bool {
+    if std.mem.len(left) != std.mem.len(right) {
+        return false
+    }
+    var index: usize = 0
+    while index < std.mem.len(right) {
+        if left[index] != right[index] {
+            return false
+        }
+        index = index + 1
+    }
+    return true
+}
+
+fn __zero_std_toml_key_matches(table: Span<u8>, field: Span<u8>, query: Span<u8>) -> Bool {
+    if __zero_std_toml_span_eq(field, query) {
+        return true
+    }
+    if std.mem.len(table) == 0 {
+        return false
+    }
+    let table_len: usize = std.mem.len(table)
+    let field_len: usize = std.mem.len(field)
+    if std.mem.len(query) != table_len + 1 + field_len {
+        return false
+    }
+    var index: usize = 0
+    while index < table_len {
+        if query[index] != table[index] {
+            return false
+        }
+        index = index + 1
+    }
+    if query[table_len] != 46_u8 {
+        return false
+    }
+    var field_index: usize = 0
+    while field_index < field_len {
+        if query[table_len + 1 + field_index] != field[field_index] {
+            return false
+        }
+        field_index = field_index + 1
+    }
+    return true
+}

std/unicode.0

@@ -0,0 +1,272 @@
+fn __zero_std_unicode_decode_raw(text: Span<u8>, index: usize) -> u64 {
+    let len: usize = std.mem.len(text)
+    if index >= len {
+        return 0
+    }
+    let first: u8 = text[index]
+    if first < 128_u8 {
+        return 4294967296_u64 + (first as u64)
+    }
+    if first >= 194_u8 && first <= 223_u8 {
+        if index + 2 > len {
+            return 0
+        }
+        let second: u8 = text[index + 1]
+        if second < 128_u8 || second > 191_u8 {
+            return 0
+        }
+        let cp: u64 = ((first as u64) - 192_u64) * 64_u64 + ((second as u64) - 128_u64)
+        return 2_u64 * 4294967296_u64 + cp
+    }
+    if first >= 224_u8 && first <= 239_u8 {
+        if index + 3 > len {
+            return 0
+        }
+        let second: u8 = text[index + 1]
+        let third: u8 = text[index + 2]
+        if second < 128_u8 || second > 191_u8 || (third < 128_u8 || third > 191_u8) {
+            return 0
+        }
+        if first == 224_u8 && second < 160_u8 {
+            return 0
+        }
+        if first == 237_u8 && second > 159_u8 {
+            return 0
+        }
+        let cp: u64 = ((first as u64) - 224_u64) * 4096_u64 + ((second as u64) - 128_u64) * 64_u64 + ((third as u64) - 128_u64)
+        return 3_u64 * 4294967296_u64 + cp
+    }
+    if first >= 240_u8 && first <= 244_u8 {
+        if index + 4 > len {
+            return 0
+        }
+        let second: u8 = text[index + 1]
+        let third: u8 = text[index + 2]
+        let fourth: u8 = text[index + 3]
+        if second < 128_u8 || second > 191_u8 {
+            return 0
+        }
+        if third < 128_u8 || third > 191_u8 || (fourth < 128_u8 || fourth > 191_u8) {
+            return 0
+        }
+        if first == 240_u8 && second < 144_u8 {
+            return 0
+        }
+        if first == 244_u8 && second > 143_u8 {
+            return 0
+        }
+        let cp: u64 = ((first as u64) - 240_u64) * 262144_u64 + ((second as u64) - 128_u64) * 4096_u64 + ((third as u64) - 128_u64) * 64_u64 + ((fourth as u64) - 128_u64)
+        return 4_u64 * 4294967296_u64 + cp
+    }
+    return 0
+}
+
+fn __zero_std_unicode_decode_at(text: Span<u8>, index: usize) -> Maybe<u32> {
+    let raw: u64 = __zero_std_unicode_decode_raw(text, index)
+    if raw == 0 {
+        return null
+    }
+    return (raw % 4294967296_u64) as u32
+}
+
+fn __zero_std_unicode_decode_status_at(text: Span<u8>, index: usize) -> u32 {
+    let len: usize = std.mem.len(text)
+    if index >= len {
+        return 1_u32
+    }
+    let first: u8 = text[index]
+    if first < 128_u8 {
+        return 0_u32
+    }
+    if first >= 128_u8 && first <= 191_u8 {
+        return 2_u32
+    }
+    if first == 192_u8 || first == 193_u8 {
+        return 6_u32
+    }
+    if first >= 194_u8 && first <= 223_u8 {
+        if index + 2 > len {
+            return 4_u32
+        }
+        let second: u8 = text[index + 1]
+        if second < 128_u8 || second > 191_u8 {
+            return 5_u32
+        }
+        return 0_u32
+    }
+    if first >= 224_u8 && first <= 239_u8 {
+        if index + 3 > len {
+            return 4_u32
+        }
+        let second: u8 = text[index + 1]
+        let third: u8 = text[index + 2]
+        if second < 128_u8 || second > 191_u8 {
+            return 5_u32
+        }
+        if third < 128_u8 || third > 191_u8 {
+            return 5_u32
+        }
+        if first == 224_u8 && second < 160_u8 {
+            return 6_u32
+        }
+        if first == 237_u8 && second > 159_u8 {
+            return 7_u32
+        }
+        return 0_u32
+    }
+    if first >= 240_u8 && first <= 244_u8 {
+        if index + 4 > len {
+            return 4_u32
+        }
+        let second: u8 = text[index + 1]
+        let third: u8 = text[index + 2]
+        let fourth: u8 = text[index + 3]
+        if second < 128_u8 || second > 191_u8 {
+            return 5_u32
+        }
+        if third < 128_u8 || third > 191_u8 {
+            return 5_u32
+        }
+        if fourth < 128_u8 || fourth > 191_u8 {
+            return 5_u32
+        }
+        if first == 240_u8 && second < 144_u8 {
+            return 6_u32
+        }
+        if first == 244_u8 && second > 143_u8 {
+            return 8_u32
+        }
+        return 0_u32
+    }
+    return 3_u32
+}
+
+fn __zero_std_unicode_status_name(status: u32) -> String {
+    if status == 0_u32 {
+        return "ok"
+    }
+    if status == 1_u32 {
+        return "out of range"
+    }
+    if status == 2_u32 {
+        return "unexpected continuation byte"
+    }
+    if status == 3_u32 {
+        return "invalid leading byte"
+    }
+    if status == 4_u32 {
+        return "truncated sequence"
+    }
+    if status == 5_u32 {
+        return "invalid continuation byte"
+    }
+    if status == 6_u32 {
+        return "overlong encoding"
+    }
+    if status == 7_u32 {
+        return "surrogate codepoint"
+    }
+    if status == 8_u32 {
+        return "codepoint above U+10FFFF"
+    }
+    return "unknown status"
+}
+
+fn __zero_std_unicode_next_index(text: Span<u8>, index: usize) -> Maybe<usize> {
+    let width: Maybe<usize> = __zero_std_unicode_width_at(text, index)
+    if width.has {
+        return index + width.value
+    }
+    return null
+}
+
+fn __zero_std_unicode_invalid_index(text: Span<u8>) -> usize {
+    var index: usize = 0
+    while index < std.mem.len(text) {
+        let next: Maybe<usize> = __zero_std_unicode_next_index(text, index)
+        if !next.has {
+            return index
+        }
+        index = next.value
+    }
+    return std.mem.len(text)
+}
+
+fn __zero_std_unicode_width_at(text: Span<u8>, index: usize) -> Maybe<usize> {
+    let raw: u64 = __zero_std_unicode_decode_raw(text, index)
+    if raw == 0 {
+        return null
+    }
+    return (raw / 4294967296_u64) as usize
+}
+
+fn __zero_std_unicode_encoded_width(cp: u32) -> Maybe<usize> {
+    if cp >= 55296_u32 && cp <= 57343_u32 {
+        return null
+    }
+    if cp > 1114111_u32 {
+        return null
+    }
+    if cp < 128_u32 {
+        return 1_usize
+    }
+    if cp < 2048_u32 {
+        return 2_usize
+    }
+    if cp < 65536_u32 {
+        return 3_usize
+    }
+    return 4_usize
+}
+
+fn __zero_std_unicode_encode(buffer: MutSpan<u8>, cp: u32) -> Maybe<Span<u8>> {
+    let width: Maybe<usize> = __zero_std_unicode_encoded_width(cp)
+    if !width.has {
+        return null
+    }
+    let needed: usize = width.value
+    if needed > std.mem.len(buffer) {
+        return null
+    }
+    if needed == 1 {
+        buffer[0] = cp as u8
+        return buffer[..1]
+    }
+    if needed == 2 {
+        buffer[0] = (192_u32 + cp / 64_u32) as u8
+        buffer[1] = (128_u32 + cp % 64_u32) as u8
+        return buffer[..2]
+    }
+    if needed == 3 {
+        buffer[0] = (224_u32 + cp / 4096_u32) as u8
+        buffer[1] = (128_u32 + (cp / 64_u32) % 64_u32) as u8
+        buffer[2] = (128_u32 + cp % 64_u32) as u8
+        return buffer[..3]
+    }
+    buffer[0] = (240_u32 + cp / 262144_u32) as u8
+    buffer[1] = (128_u32 + (cp / 4096_u32) % 64_u32) as u8
+    buffer[2] = (128_u32 + (cp / 64_u32) % 64_u32) as u8
+    buffer[3] = (128_u32 + cp % 64_u32) as u8
+    return buffer[..4]
+}
+
+fn __zero_std_unicode_is_digit(cp: u32) -> Bool {
+    return cp >= 48_u32 && cp <= 57_u32
+}
+
+fn __zero_std_unicode_is_word(cp: u32) -> Bool {
+    return (cp >= 48_u32 && cp <= 57_u32) || ((cp >= 65_u32 && cp <= 90_u32) || (cp >= 97_u32 && cp <= 122_u32) || cp == 95_u32)
+}
+
+fn __zero_std_unicode_is_space(cp: u32) -> Bool {
+    if cp == 9_u32 || cp == 10_u32 || (cp == 11_u32 || cp == 12_u32) || (cp == 13_u32 || cp == 32_u32) {
+        return true
+    }
+    if cp == 160_u32 || cp == 5760_u32 || (cp == 8232_u32 || cp == 8233_u32) {
+        return true
+    }
+    if cp >= 8192_u32 && cp <= 8202_u32 {
+        return true
+    }
+    return cp == 8239_u32 || cp == 8287_u32 || (cp == 12288_u32 || cp == 65279_u32)
+}

std/url.0

@@ -0,0 +1,491 @@
+fn __zero_std_url_is_unreserved(byte: u8) -> Bool {
+    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8) || (byte >= 48_u8 && byte <= 57_u8) || byte == 45_u8 || byte == 46_u8 || byte == 95_u8 || byte == 126_u8
+}
+
+fn __zero_std_url_hex_char(value: u8) -> u8 {
+    if value < 10_u8 {
+        return 48_u8 + value
+    }
+    return 65_u8 + value - 10_u8
+}
+
+fn __zero_std_url_percent_encode(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    var input: usize = 0
+    var output: usize = 0
+    while input < std.mem.len(text) {
+        let byte: u8 = text[input]
+        if __zero_std_url_is_unreserved(byte) {
+            if output >= std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = byte
+            output = output + 1
+        } else {
+            if output + 3 > std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = 37_u8
+            buffer[output + 1] = __zero_std_url_hex_char(byte / 16_u8)
+            buffer[output + 2] = __zero_std_url_hex_char(byte % 16_u8)
+            output = output + 3
+        }
+        input = input + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_percent_decode(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    var input: usize = 0
+    var output: usize = 0
+    while input < std.mem.len(text) {
+        if output >= std.mem.len(buffer) {
+            return null
+        }
+        let byte: u8 = text[input]
+        if byte == 37_u8 {
+            if input + 2 >= std.mem.len(text) {
+                return null
+            }
+            let high: Maybe<u8> = std.ascii.hexValue(text[input + 1])
+            let low: Maybe<u8> = std.ascii.hexValue(text[input + 2])
+            if !high.has || !low.has {
+                return null
+            }
+            buffer[output] = high.value * 16_u8 + low.value
+            input = input + 3
+        } else {
+            buffer[output] = byte
+            input = input + 1
+        }
+        output = output + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_query_escape(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    var input: usize = 0
+    var output: usize = 0
+    while input < std.mem.len(text) {
+        let byte: u8 = text[input]
+        if byte == 32_u8 {
+            if output >= std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = 43_u8
+            output = output + 1
+        } else if __zero_std_url_is_unreserved(byte) {
+            if output >= std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = byte
+            output = output + 1
+        } else {
+            if output + 3 > std.mem.len(buffer) {
+                return null
+            }
+            buffer[output] = 37_u8
+            buffer[output + 1] = __zero_std_url_hex_char(byte / 16_u8)
+            buffer[output + 2] = __zero_std_url_hex_char(byte % 16_u8)
+            output = output + 3
+        }
+        input = input + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_query_unescape(buffer: MutSpan<u8>, text: Span<u8>) -> Maybe<Span<u8>> {
+    var input: usize = 0
+    var output: usize = 0
+    while input < std.mem.len(text) {
+        if output >= std.mem.len(buffer) {
+            return null
+        }
+        let byte: u8 = text[input]
+        if byte == 43_u8 {
+            buffer[output] = 32_u8
+            input = input + 1
+        } else if byte == 37_u8 {
+            if input + 2 >= std.mem.len(text) {
+                return null
+            }
+            let high: Maybe<u8> = std.ascii.hexValue(text[input + 1])
+            let low: Maybe<u8> = std.ascii.hexValue(text[input + 2])
+            if !high.has || !low.has {
+                return null
+            }
+            buffer[output] = high.value * 16_u8 + low.value
+            input = input + 3
+        } else {
+            buffer[output] = byte
+            input = input + 1
+        }
+        output = output + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_scheme(url: Span<u8>) -> Maybe<Span<u8>> {
+    var index: usize = 0
+    while index < std.mem.len(url) {
+        let byte: u8 = url[index]
+        if byte == 58_u8 {
+            if index == 0 {
+                return null
+            }
+            return url[..index]
+        }
+        if byte == 47_u8 || byte == 63_u8 || byte == 35_u8 {
+            return null
+        }
+        index = index + 1
+    }
+    return null
+}
+
+fn __zero_std_url_authority_start(url: Span<u8>) -> Maybe<usize> {
+    let scheme: Maybe<Span<u8>> = __zero_std_url_scheme(url)
+    if !scheme.has {
+        return null
+    }
+    let start: usize = std.mem.len(scheme.value) + 1
+    if start + 1 >= std.mem.len(url) || url[start] != 47_u8 || url[start + 1] != 47_u8 {
+        return null
+    }
+    return start + 2
+}
+
+fn __zero_std_url_authority(url: Span<u8>) -> Maybe<Span<u8>> {
+    let start: Maybe<usize> = __zero_std_url_authority_start(url)
+    if !start.has {
+        return null
+    }
+    var end: usize = start.value
+    while end < std.mem.len(url) && url[end] != 47_u8 && url[end] != 63_u8 && url[end] != 35_u8 {
+        end = end + 1
+    }
+    if end == start.value {
+        return null
+    }
+    return url[start.value..end]
+}
+
+fn __zero_std_url_host(url: Span<u8>) -> Maybe<Span<u8>> {
+    let authority: Maybe<Span<u8>> = __zero_std_url_authority(url)
+    if !authority.has {
+        return null
+    }
+    var start: usize = 0
+    var index: usize = 0
+    while index < std.mem.len(authority.value) {
+        if authority.value[index] == 64_u8 {
+            start = index + 1
+        }
+        index = index + 1
+    }
+    if start < std.mem.len(authority.value) && authority.value[start] == 91_u8 {
+        var close: usize = start + 1
+        while close < std.mem.len(authority.value) && authority.value[close] != 93_u8 {
+            close = close + 1
+        }
+        if close >= std.mem.len(authority.value) || close == start + 1 {
+            return null
+        }
+        if close + 1 < std.mem.len(authority.value) && authority.value[close + 1] != 58_u8 {
+            return null
+        }
+        return authority.value[start..close + 1]
+    }
+    var end: usize = start
+    while end < std.mem.len(authority.value) && authority.value[end] != 58_u8 {
+        end = end + 1
+    }
+    if end == start {
+        return null
+    }
+    return authority.value[start..end]
+}
+
+fn __zero_std_url_path(url: Span<u8>) -> Span<u8> {
+    var start: usize = 0
+    let scheme: Maybe<Span<u8>> = __zero_std_url_scheme(url)
+    let authority_start: Maybe<usize> = __zero_std_url_authority_start(url)
+    if authority_start.has {
+        start = authority_start.value
+        while start < std.mem.len(url) && url[start] != 47_u8 && url[start] != 63_u8 && url[start] != 35_u8 {
+            start = start + 1
+        }
+    } else if scheme.has {
+        start = std.mem.len(scheme.value) + 1
+    }
+    if start >= std.mem.len(url) {
+        return url[std.mem.len(url)..]
+    }
+    var end: usize = start
+    while end < std.mem.len(url) && url[end] != 63_u8 && url[end] != 35_u8 {
+        end = end + 1
+    }
+    return url[start..end]
+}
+
+fn __zero_std_url_query(url: Span<u8>) -> Maybe<Span<u8>> {
+    var start: usize = 0
+    while start < std.mem.len(url) && url[start] != 63_u8 {
+        if url[start] == 35_u8 {
+            return null
+        }
+        start = start + 1
+    }
+    if start >= std.mem.len(url) {
+        return null
+    }
+    start = start + 1
+    var end: usize = start
+    while end < std.mem.len(url) && url[end] != 35_u8 {
+        end = end + 1
+    }
+    return url[start..end]
+}
+
+fn __zero_std_url_fragment(url: Span<u8>) -> Maybe<Span<u8>> {
+    var start: usize = 0
+    while start < std.mem.len(url) && url[start] != 35_u8 {
+        start = start + 1
+    }
+    if start >= std.mem.len(url) {
+        return null
+    }
+    return url[start + 1..]
+}
+
+fn __zero_std_url_query_value(query: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    var start: usize = 0
+    while start <= std.mem.len(query) {
+        var end: usize = start
+        while end < std.mem.len(query) && query[end] != 38_u8 {
+            end = end + 1
+        }
+        var eq: usize = start
+        while eq < end && query[eq] != 61_u8 {
+            eq = eq + 1
+        }
+        let name: Span<u8> = query[start..eq]
+        if std.mem.eql(name, key) {
+            if eq < end {
+                return query[eq + 1..end]
+            }
+            return query[end..end]
+        }
+        if end == std.mem.len(query) {
+            return null
+        }
+        start = end + 1
+    }
+    return null
+}
+
+fn __zero_std_url_query_value_decoded(buffer: MutSpan<u8>, query: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    var start: usize = 0
+    while start <= std.mem.len(query) {
+        var end: usize = start
+        while end < std.mem.len(query) && query[end] != 38_u8 {
+            end = end + 1
+        }
+        var eq: usize = start
+        while eq < end && query[eq] != 61_u8 {
+            eq = eq + 1
+        }
+        let name: Span<u8> = query[start..eq]
+        var matched: Bool = std.mem.eql(name, key)
+        if !matched {
+            let decoded_name: Maybe<Span<u8>> = __zero_std_url_query_unescape(buffer, name)
+            if decoded_name.has {
+                matched = std.mem.eql(decoded_name.value, key)
+            }
+        }
+        if matched {
+            if eq < end {
+                return __zero_std_url_query_unescape(buffer, query[eq + 1..end])
+            }
+            return buffer[..0]
+        }
+        if end == std.mem.len(query) {
+            return null
+        }
+        start = end + 1
+    }
+    return null
+}
+
+fn __zero_std_url_write_query_param(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    var output: usize = 0
+    let encoded_key: Maybe<Span<u8>> = __zero_std_url_query_escape(buffer, key)
+    if !encoded_key.has {
+        return null
+    }
+    output = output + std.mem.len(encoded_key.value)
+    if output >= std.mem.len(buffer) {
+        return null
+    }
+    buffer[output] = 61_u8
+    output = output + 1
+    let encoded_value: Maybe<Span<u8>> = __zero_std_url_query_escape(buffer[output..], value)
+    if !encoded_value.has {
+        return null
+    }
+    output = output + std.mem.len(encoded_value.value)
+    return buffer[..output]
+}
+
+fn __zero_std_url_write_form_field(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
+    return __zero_std_url_write_query_param(buffer, key, value)
+}
+
+fn __zero_std_url_append_form_field(buffer: MutSpan<u8>, form: Span<u8>, field: Span<u8>) -> Maybe<Span<u8>> {
+    let form_len: usize = std.mem.len(form)
+    let field_len: usize = std.mem.len(field)
+    if form_len == 0_usize {
+        if field_len > std.mem.len(buffer) {
+            return null
+        }
+        var field_index: usize = 0
+        while field_index < field_len {
+            buffer[field_index] = field[field_index]
+            field_index = field_index + 1
+        }
+        return buffer[..field_len]
+    }
+    if form_len >= std.mem.len(buffer) {
+        return null
+    }
+    if field_len > std.mem.len(buffer) - form_len - 1_usize {
+        return null
+    }
+    var output: usize = 0
+    while output < form_len {
+        buffer[output] = form[output]
+        output = output + 1
+    }
+    buffer[output] = 38_u8
+    output = output + 1
+    var field_index: usize = 0
+    while field_index < field_len {
+        buffer[output] = field[field_index]
+        output = output + 1
+        field_index = field_index + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_form_value(buffer: MutSpan<u8>, form: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
+    return __zero_std_url_query_value_decoded(buffer, form, key)
+}
+
+fn __zero_std_url_append_query(buffer: MutSpan<u8>, base: Span<u8>, query: Span<u8>) -> Maybe<Span<u8>> {
+    let base_len: usize = std.mem.len(base)
+    if base_len >= std.mem.len(buffer) {
+        return null
+    }
+    if std.mem.len(query) > std.mem.len(buffer) - base_len - 1 {
+        return null
+    }
+    var fragment: usize = 0
+    while fragment < base_len && base[fragment] != 35_u8 {
+        fragment = fragment + 1
+    }
+    var output: usize = 0
+    while output < fragment {
+        buffer[output] = base[output]
+        output = output + 1
+    }
+    var separator: u8 = 63_u8
+    var index: usize = 0
+    while index < fragment {
+        if base[index] == 63_u8 {
+            separator = 38_u8
+        }
+        index = index + 1
+    }
+    buffer[output] = separator
+    output = output + 1
+    var query_index: usize = 0
+    while query_index < std.mem.len(query) {
+        buffer[output] = query[query_index]
+        output = output + 1
+        query_index = query_index + 1
+    }
+    var fragment_index: usize = fragment
+    while fragment_index < base_len {
+        buffer[output] = base[fragment_index]
+        output = output + 1
+        fragment_index = fragment_index + 1
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_write_url(buffer: MutSpan<u8>, scheme: Span<u8>, host: Span<u8>, path: Span<u8>) -> Maybe<Span<u8>> {
+    if std.mem.len(scheme) == 0 || std.mem.len(host) == 0 {
+        return null
+    }
+    var output: usize = 0
+    let scheme_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, scheme)
+    if !scheme_end.has {
+        return null
+    }
+    output = scheme_end.value
+    let sep_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "://")
+    if !sep_end.has {
+        return null
+    }
+    output = sep_end.value
+    let host_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, host)
+    if !host_end.has {
+        return null
+    }
+    output = host_end.value
+    if std.mem.len(path) > 0 {
+        if path[0] != 47_u8 {
+            let slash_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "/")
+            if !slash_end.has {
+                return null
+            }
+            output = slash_end.value
+        }
+        let path_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, path)
+        if !path_end.has {
+            return null
+        }
+        output = path_end.value
+    }
+    return buffer[..output]
+}
+
+fn __zero_std_url_append_fragment(buffer: MutSpan<u8>, base: Span<u8>, fragment: Span<u8>) -> Maybe<Span<u8>> {
+    var output: usize = 0
+    let base_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, base)
+    if !base_end.has {
+        return null
+    }
+    output = base_end.value
+    let marker_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, "#")
+    if !marker_end.has {
+        return null
+    }
+    output = marker_end.value
+    let fragment_end: Maybe<usize> = __zero_std_url_write_span(buffer, output, fragment)
+    if !fragment_end.has {
+        return null
+    }
+    return buffer[..fragment_end.value]
+}
+
+fn __zero_std_url_write_span(buffer: MutSpan<u8>, cursor: usize, bytes: Span<u8>) -> Maybe<usize> {
+    if cursor + std.mem.len(bytes) > std.mem.len(buffer) {
+        return null
+    }
+    var index: usize = 0
+    while index < std.mem.len(bytes) {
+        buffer[cursor + index] = bytes[index]
+        index = index + 1
+    }
+    return cursor + std.mem.len(bytes)
+}