feat(std): Update to latest version of Zig lib

Author: Afirium

build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = .zig_mcp,
+    .version = "0.0.0",
+    .fingerprint = 0x1c29ab0bcd4442bc,
+    .minimum_zig_version = "0.15.0-dev.1474+3ea015db9",
+    .dependencies = .{},
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "docs",
+    },
+}

docs/main.zig

@@ -683,7 +683,6 @@ fn render_docs(
     var parsed_doc = try parser.endInput();
     defer parsed_doc.deinit(gpa);
 
-
     const Writer = std.ArrayListUnmanaged(u8).Writer;
     const Renderer = markdown.Renderer(Writer, Decl.Index);
     const renderer: Renderer = .{
@@ -752,10 +751,10 @@ export fn decl_type_html(decl_index: Decl.Index) String {
 const Oom = error{OutOfMemory};
 
 fn unpackInner(tar_bytes: []u8) !void {
-    var fbs = std.io.fixedBufferStream(tar_bytes);
+    var reader: std.Io.Reader = .fixed(tar_bytes);
     var file_name_buffer: [1024]u8 = undefined;
     var link_name_buffer: [1024]u8 = undefined;
-    var it = std.tar.iterator(fbs.reader(), .{
+    var it: std.tar.Iterator = .init(&reader, .{
         .file_name_buffer = &file_name_buffer,
         .link_name_buffer = &link_name_buffer,
     });
@@ -776,7 +775,7 @@ fn unpackInner(tar_bytes: []u8) !void {
                         {
                             gop.value_ptr.* = file;
                         }
-                        const file_bytes = tar_bytes[fbs.pos..][0..@intCast(tar_file.size)];
+                        const file_bytes = tar_bytes[reader.seek..][0..@intCast(tar_file.size)];
                         assert(file == try Walk.add_file(file_name, file_bytes));
                     }
                 } else {

docs/markdown.zig

@@ -144,13 +144,12 @@ fn mainImpl() !void {
     var parser = try Parser.init(gpa);
     defer parser.deinit();
 
-    var stdin_buf = std.io.bufferedReader(std.fs.File.stdin().deprecatedReader());
-    var line_buf = std.ArrayList(u8).init(gpa);
-    defer line_buf.deinit();
-    while (stdin_buf.reader().streamUntilDelimiter(line_buf.writer(), '\n', null)) {
-        if (line_buf.getLastOrNull() == '\r') _ = line_buf.pop();
-        try parser.feedLine(line_buf.items);
-        line_buf.clearRetainingCapacity();
+    var stdin_buffer: [1024]u8 = undefined;
+    var stdin_reader = std.fs.File.stdin().reader(&stdin_buffer);
+
+    while (stdin_reader.takeDelimiterExclusive('\n')) |line| {
+        const trimmed = std.mem.trimRight(u8, line, '\r');
+        try parser.feedLine(trimmed);
     } else |err| switch (err) {
         error.EndOfStream => {},
         else => |e| return e,
@@ -159,9 +158,10 @@ fn mainImpl() !void {
     var doc = try parser.endInput();
     defer doc.deinit(gpa);
 
-    var stdout_buf = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
-    try doc.render(stdout_buf.writer());
-    try stdout_buf.flush();
+    var stdout_buffer: [1024]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    try doc.render(&stdout_writer.interface);
+    try stdout_writer.interface.flush();
 }
 
 test "empty document" {

docs/markdown/Parser.zig

@@ -29,13 +29,14 @@ const Node = Document.Node;
 const ExtraIndex = Document.ExtraIndex;
 const ExtraData = Document.ExtraData;
 const StringIndex = Document.StringIndex;
+const ArrayList = std.ArrayListUnmanaged;
 
 nodes: Node.List = .{},
-extra: std.ArrayListUnmanaged(u32) = .empty,
-scratch_extra: std.ArrayListUnmanaged(u32) = .empty,
-string_bytes: std.ArrayListUnmanaged(u8) = .empty,
-scratch_string: std.ArrayListUnmanaged(u8) = .empty,
-pending_blocks: std.ArrayListUnmanaged(Block) = .empty,
+extra: ArrayList(u32) = .empty,
+scratch_extra: ArrayList(u32) = .empty,
+string_bytes: ArrayList(u8) = .empty,
+scratch_string: ArrayList(u8) = .empty,
+pending_blocks: ArrayList(Block) = .empty,
 allocator: Allocator,
 
 const Parser = @This();
@@ -86,7 +87,8 @@ const Block = struct {
             continuation_indent: usize,
         },
         table: struct {
-            column_alignments: std.BoundedArray(Node.TableCellAlignment, max_table_columns) = .{},
+            column_alignments_buffer: [max_table_columns]Node.TableCellAlignment,
+            column_alignments_len: usize,
         },
         heading: struct {
             /// Between 1 and 6, inclusive.
@@ -354,7 +356,8 @@ const BlockStart = struct {
             continuation_indent: usize,
         },
         table_row: struct {
-            cells: std.BoundedArray([]const u8, max_table_columns),
+            cells_buffer: [max_table_columns][]const u8,
+            cells_len: usize,
         },
         heading: struct {
             /// Between 1 and 6, inclusive.
@@ -422,7 +425,8 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
             try p.pending_blocks.append(p.allocator, .{
                 .tag = .table,
                 .data = .{ .table = .{
-                    .column_alignments = .{},
+                    .column_alignments_buffer = undefined,
+                    .column_alignments_len = 0,
                 } },
                 .string_start = p.scratch_string.items.len,
                 .extra_start = p.scratch_extra.items.len,
@@ -431,15 +435,20 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
 
         const current_row = p.scratch_extra.items.len - p.pending_blocks.getLast().extra_start;
         if (current_row <= 1) {
-            if (parseTableHeaderDelimiter(block_start.data.table_row.cells)) |alignments| {
-                p.pending_blocks.items[p.pending_blocks.items.len - 1].data.table.column_alignments = alignments;
+            var buffer: [max_table_columns]Node.TableCellAlignment = undefined;
+            const table_row = &block_start.data.table_row;
+
+            if (parseTableHeaderDelimiter(table_row.cells_buffer[0..table_row.cells_len], &buffer)) |alignments| {
+                const table = &p.pending_blocks.items[p.pending_blocks.items.len - 1].data.table;
+                @memcpy(table.column_alignments_buffer[0..alignments.len], &buffer);
+                table.column_alignments_len = alignments.len;
                 if (current_row == 1) {
                     // We need to go back and mark the header row and its column
                     // alignments.
                     const datas = p.nodes.items(.data);
                     const header_data = datas[p.scratch_extra.getLast()];
                     for (p.extraChildren(header_data.container.children), 0..) |header_cell, i| {
-                        const alignment = if (i < alignments.len) alignments.buffer[i] else .unset;
+                        const alignment = if (i < alignments.len) alignments[i] else .unset;
                         const cell_data = &datas[@intFromEnum(header_cell)].table_cell;
                         cell_data.info.alignment = alignment;
                         cell_data.info.header = true;
@@ -480,8 +489,10 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void {
         // available in the BlockStart. We can immediately parse and append
         // these children now.
         const containing_table = p.pending_blocks.items[p.pending_blocks.items.len - 2];
-        const column_alignments = containing_table.data.table.column_alignments.slice();
-        for (block_start.data.table_row.cells.slice(), 0..) |cell_content, i| {
+        const table = &containing_table.data.table;
+        const column_alignments = table.column_alignments_buffer[0..table.column_alignments_len];
+        const table_row = &block_start.data.table_row;
+        for (table_row.cells_buffer[0..table_row.cells_len], 0..) |cell_content, i| {
             const cell_children = try p.parseInlines(cell_content);
             const alignment = if (i < column_alignments.len) column_alignments[i] else .unset;
             const cell = try p.addNode(.{
@@ -523,7 +534,8 @@ fn startBlock(p: *Parser, line: []const u8) !?BlockStart {
         return .{
             .tag = .table_row,
             .data = .{ .table_row = .{
-                .cells = table_row.cells,
+                .cells_buffer = table_row.cells_buffer,
+                .cells_len = table_row.cells_len,
             } },
             .rest = "",
         };
@@ -606,7 +618,8 @@ fn startListItem(unindented_line: []const u8) ?ListItemStart {
 }
 
 const TableRowStart = struct {
-    cells: std.BoundedArray([]const u8, max_table_columns),
+    cells_buffer: [max_table_columns][]const u8,
+    cells_len: usize,
 };
 
 fn startTableRow(unindented_line: []const u8) ?TableRowStart {
@@ -615,15 +628,16 @@ fn startTableRow(unindented_line: []const u8) ?TableRowStart {
         mem.endsWith(u8, unindented_line, "\\|") or
         !mem.endsWith(u8, unindented_line, "|")) return null;
 
-    var cells: std.BoundedArray([]const u8, max_table_columns) = .{};
+    var cells_buffer: [max_table_columns][]const u8 = undefined;
+    var cells: ArrayList([]const u8) = .initBuffer(&cells_buffer);
     const table_row_content = unindented_line[1 .. unindented_line.len - 1];
     var cell_start: usize = 0;
     var i: usize = 0;
     while (i < table_row_content.len) : (i += 1) {
         switch (table_row_content[i]) {
             '\\' => i += 1,
             '|' => {
-                cells.append(table_row_content[cell_start..i]) catch return null;
+                cells.appendBounded(table_row_content[cell_start..i]) catch return null;
                 cell_start = i + 1;
             },
             '`' => {
@@ -641,20 +655,21 @@ fn startTableRow(unindented_line: []const u8) ?TableRowStart {
             else => {},
         }
     }
-    cells.append(table_row_content[cell_start..]) catch return null;
+    cells.appendBounded(table_row_content[cell_start..]) catch return null;
 
-    return .{ .cells = cells };
+    return .{ .cells_buffer = cells_buffer, .cells_len = cells.items.len };
 }
 
 fn parseTableHeaderDelimiter(
-    row_cells: std.BoundedArray([]const u8, max_table_columns),
-) ?std.BoundedArray(Node.TableCellAlignment, max_table_columns) {
-    var alignments: std.BoundedArray(Node.TableCellAlignment, max_table_columns) = .{};
-    for (row_cells.slice()) |content| {
+    row_cells: []const []const u8,
+    buffer: []Node.TableCellAlignment,
+) ?[]Node.TableCellAlignment {
+    var alignments: ArrayList(Node.TableCellAlignment) = .initBuffer(buffer);
+    for (row_cells) |content| {
         const alignment = parseTableHeaderDelimiterCell(content) orelse return null;
         alignments.appendAssumeCapacity(alignment);
     }
-    return alignments;
+    return alignments.items;
 }
 
 fn parseTableHeaderDelimiterCell(content: []const u8) ?Node.TableCellAlignment {
@@ -928,8 +943,8 @@ const InlineParser = struct {
     parent: *Parser,
     content: []const u8,
     pos: usize = 0,
-    pending_inlines: std.ArrayListUnmanaged(PendingInline) = .empty,
-    completed_inlines: std.ArrayListUnmanaged(CompletedInline) = .empty,
+    pending_inlines: ArrayList(PendingInline) = .empty,
+    completed_inlines: ArrayList(CompletedInline) = .empty,
 
     const PendingInline = struct {
         tag: Tag,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zig-mcp",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "type": "module",
   "bin": {
     "zig-mcp": "dist/mcp.js"