finished nuking that thing

src/errors.zig

@@ -29,5 +29,5 @@ pub const DiscordError = struct {
 };
 
 pub fn Result(comptime T: type) type {
-    return @import("json.zig").OwnedEither(DiscordError, T);
+    return @import("json-helper.zig").OwnedEither(DiscordError, T);
 }

src/http.zig

@@ -18,7 +18,8 @@ const std = @import("std");
 const mem = std.mem;
 const http = std.http;
 const json = std.json;
-const zjson = @import("json.zig");
+const json_helpers = @import("json-helper.zig");
+
 pub const Result = @import("errors.zig").Result;
 pub const DiscordError = @import("errors.zig").DiscordError;
 
@@ -100,16 +101,16 @@ pub const FetchReq = struct {
     pub fn get(self: *FetchReq, comptime T: type, path: []const u8) !Result(T) {
         const result = try self.makeRequest(.GET, path, null);
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        const output = try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        const output = try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
         return output;
     }
 
     pub fn delete(self: *FetchReq, path: []const u8) !Result(void) {
         const result = try self.makeRequest(.DELETE, path, null);
         if (result.status != .no_content)
-            return try zjson.tryParse(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.tryParse(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }
@@ -124,9 +125,9 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PATCH, path, try string.toOwnedSlice());
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn patch2(self: *FetchReq, path: []const u8, object: anytype) !void {
@@ -139,7 +140,7 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PATCH, path, try string.toOwnedSlice());
 
         if (result.status != .no_content)
-            return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }
@@ -154,9 +155,9 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PUT, path, try string.toOwnedSlice());
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn put2(self: *FetchReq, comptime T: type, path: []const u8, object: anytype) !Result(T) {
@@ -169,16 +170,16 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PUT, path, try string.toOwnedSlice());
 
         if (result.status == .no_content)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn put3(self: *FetchReq, path: []const u8) !Result(void) {
         const result = try self.makeRequest(.PUT, path, null);
 
         if (result.status != .no_content)
-            return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }
@@ -187,9 +188,9 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PUT, path, null);
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn put5(self: *FetchReq, path: []const u8, object: anytype) !Result(void) {
@@ -202,7 +203,7 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.PUT, path, try self.body.toOwnedSlice());
 
         if (result.status != .no_content)
-            return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }
@@ -217,18 +218,18 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.POST, path, try string.toOwnedSlice());
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn post2(self: *FetchReq, comptime T: type, path: []const u8) !Result(T) {
         const result = try self.makeRequest(.POST, path, null);
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn post3(
@@ -247,9 +248,9 @@ pub const FetchReq = struct {
         const result = try self.makeRequestWithFiles(.POST, path, try string.toOwnedSlice(), files);
 
         if (result.status != .ok)
-            return try zjson.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
 
-        return try zjson.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
+        return try json_helpers.parseRight(DiscordError, T, self.allocator, try self.body.toOwnedSlice());
     }
 
     pub fn post4(self: *FetchReq, path: []const u8, object: anytype) !Result(void) {
@@ -262,7 +263,7 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.POST, path, try string.toOwnedSlice());
 
         if (result.status != .no_content)
-            return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }
@@ -271,7 +272,7 @@ pub const FetchReq = struct {
         const result = try self.makeRequest(.POST, path, null);
 
         if (result.status != .no_content)
-            return try zjson.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
+            return try json_helpers.parseLeft(DiscordError, void, self.allocator, try self.body.toOwnedSlice());
 
         return .ok({});
     }

src/json-helper.zig

@@ -15,6 +15,7 @@
 //! PERFORMANCE OF THIS SOFTWARE.
 
 const std = @import("std");
+const json = std.json;
 
 /// a hashmap for key value pairs
 /// where every key is an int
@@ -43,32 +44,25 @@ pub fn AssociativeArray(comptime E: type, comptime V: type) type {
 
     return struct {
         map: std.EnumMap(E, V),
-        pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
+        pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
-            const scanner = std.json.Scanner.initCompleteInput(allocator, src);
-            defer scanner.deinit();
-
             var map: std.EnumMap(E, V) = .{};
 
-            if (try scanner.next() != .object_begin)
+            const value = try std.json.innerParse(std.json.Value, allocator, src, .{
-                return error.InvalidJson;
-
-            while (true) {
-                switch (try scanner.peekNextTokenType()) {
-                    .object_end => break,
-                    .string => {}, // might be a key
-                    else => return error.UnexpectedToken,
-                }
-                const key = try std.json.innerParse(E, allocator, &scanner, .{
-                    .max_value_len = 0x100
-                });
-                const val = try std.json.innerParse(V, allocator, &scanner, .{
                 .max_value_len = 0x100
             });
 
-                if (map.contains(key))
+            var iterator = value.object.iterator();
-                    return error.DuplicateKey;
 
-                map.put(key, val);
+            while (iterator.next()) |it| {
+                const k = it.key_ptr.*;
+                const v = it.value_ptr.*;
+
+                // eg: enum(u8) would be @"enum".tag_type where tag_type is a u8
+                const int = std.fmt.parseInt(@typeInfo(E).@"enum".tag_type, k, 10) catch unreachable;
+
+                const val = try std.json.parseFromValueLeaky(V, allocator, v, .{.max_value_len = 0x100});
+
+                map.put(@enumFromInt(int), val);
             }
 
             return .{.map = map};
@@ -94,38 +88,26 @@ pub fn DiscriminatedUnion(comptime U: type, comptime key: []const u8) type {
 
     return struct {
         t: U,
-        pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
+        pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
-            const scanner = std.json.Scanner.initCompleteInput(allocator, src);
-            defer scanner.deinit();
-
-            if (try scanner.next() != .object_begin)
-                return error.CouldntMatchAgainstNonObjectType;
-
             // extract next value, which should be an object
             // and should have a key "type" or whichever key might be
 
-            const value = try std.json.innerParse(std.json.Value, allocator, &scanner, .{
+            const value = try std.json.innerParse(std.json.Value, allocator, src, .{
                 .max_value_len = 0x100
             });
 
-            if (value != .object)
-                return error.CouldntMatchAgainstNonObjectType;
-
             const discriminator = value.object.get(key) orelse
                 @panic("couldn't find property " ++ key ++ "in raw object");
 
             var u: U = undefined;
 
-            if (discriminator != .integer)
-                return error.CouldntMatchAgainstNonIntegerType;
-
             const tag: @typeInfo(E).@"enum".tag_type = @intCast(discriminator.integer);
 
             inline for (@typeInfo(E).@"enum".fields) |field| {
                 if (field.value == tag) {
                     const T = comptime std.meta.fields(U)[field.value].type;
                     comptime std.debug.assert(@hasField(T, key));
-                    u = @unionInit(U, field.name, try std.json.innerParse(T, allocator, &scanner, .{.max_value_len = 0x100}));
+                    u = @unionInit(U, field.name, try std.json.innerParse(T, allocator, src, .{.max_value_len = 0x100}));
                 }
             }
 
@@ -138,18 +120,11 @@ pub fn DiscriminatedUnion(comptime U: type, comptime key: []const u8) type {
 pub fn Record(comptime T: type) type {
     return struct {
         map: std.StringHashMapUnmanaged(T),
-        pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
+        pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: json.ParseOptions) !@This() {
-            const scanner = std.json.Scanner.initCompleteInput(allocator, src);
+            const value = try std.json.innerParse(std.json.Value, allocator, src, .{
-            defer scanner.deinit();
-
-
-            const value = try std.json.innerParse(std.json.Value, allocator, &scanner, .{
                 .max_value_len = 0x100
             });
 
-            if (value != .object)
-                return error.CouldntMatchAgainstNonObjectType;
-
             errdefer value.object.deinit();
             var iterator = value.object.iterator();
 
@@ -170,3 +145,103 @@ pub fn Record(comptime T: type) type {
     };
 }
 
+/// Either a b = Left a | Right b
+pub fn Either(comptime L: type, comptime R: type) type {
+    return union(enum) {
+        left: L,
+        right: R,
+
+        /// always returns .right
+        pub fn unwrap(self: @This()) R {
+            // discord.zig specifics
+            if (@hasField(L, "code") and @hasField(L, "message") and self == .left)
+                std.debug.panic("Error: {d}, {s}\n", .{ self.left.code, self.left.message });
+
+            // for other libraries, it'll do this
+            if (self == .left)
+                std.debug.panic("Error: {any}\n", .{self.left});
+
+            return self.right;
+        }
+
+        pub fn is(self: @This(), tag: std.meta.Tag(@This())) bool {
+            return self == tag;
+        }
+    };
+}
+
+
+/// meant to handle a `std.json.Value` and handling the deinitialization thereof
+pub fn Owned(comptime T: type) type {
+    return struct {
+        arena: *std.heap.ArenaAllocator,
+        value: T,
+
+        pub fn deinit(self: @This()) void {
+            const allocator = self.arena.child_allocator;
+            self.arena.deinit();
+            allocator.destroy(self.arena);
+        }
+    };
+}
+
+/// same as `Owned` but instead it handles 2 different values, generally `.right` is the correct one and `left` the error type
+pub fn OwnedEither(comptime L: type, comptime R: type) type {
+    return struct {
+        value: Either(L, R),
+        arena: *std.heap.ArenaAllocator,
+
+        pub fn ok(ok_value: R) @This() {
+            return .{ .value = ok_value };
+        }
+
+        pub fn err(err_value: L) @This() {
+            return .{ .value = err_value };
+        }
+
+        pub fn deinit(self: @This()) void {
+            const allocator = self.arena.child_allocator;
+            self.arena.deinit();
+            allocator.destroy(self.arena);
+        }
+    };
+}
+
+/// same as `std.json.parseFromSlice`
+pub fn parseRight(comptime L: type, comptime R: type, child_allocator: std.mem.Allocator, data: []const u8) json.ParseError(json.Scanner)!OwnedEither(L, R) {
+    var owned: OwnedEither(L, R) = .{
+        .arena = try child_allocator.create(std.heap.ArenaAllocator),
+        .value = undefined,
+    };
+    owned.arena.* = .init(child_allocator);
+    const allocator = owned.arena.allocator();
+    const value = try json.parseFromSliceLeaky(json.Value, allocator, data, .{
+        .max_value_len = 0x100,
+    });
+
+    owned.value = .{ .right = try json.parseFromValueLeaky(R, allocator, value, .{.max_value_len = 0x100}) };
+    errdefer owned.arena.deinit();
+
+    return owned;
+}
+
+
+/// same as `std.json.parseFromSlice`
+pub fn parseLeft(comptime L: type, comptime R: type, child_allocator: std.mem.Allocator, data: []const u8) json.ParseError(json.Scanner)!OwnedEither(L, R) {
+    var owned: OwnedEither(L, R) = .{
+        .arena = try child_allocator.create(std.heap.ArenaAllocator),
+        .value = undefined,
+    };
+    owned.arena.* = .init(child_allocator);
+    const allocator = owned.arena.allocator();
+    const value = try json.parseFromSliceLeaky(json.Value, allocator, data, .{
+        .max_value_len = 0x100,
+    });
+
+    owned.value = .{ .left = try json.parseFromValueLeaky(L, allocator, value, .{.max_value_len = 0x100}) };
+    errdefer owned.arena.deinit();
+
+    return owned;
+}
+
+

src/shard.zig

@@ -26,7 +26,7 @@ const http = std.http;
 
 // todo use this to read compressed messages
 const zlib = @import("zlib");
-const zjson = @import("json.zig");
+const json = @import("std").json;
 
 const Result = @import("errors.zig").Result;
 const Self = @This();
@@ -215,7 +215,7 @@ pub fn deinit(self: *Self) void {
     self.client.deinit();
 }
 
-const ReadMessageError = mem.Allocator.Error || zlib.Error || zjson.ParserError;
+const ReadMessageError = mem.Allocator.Error || zlib.Error || json.ParseError(json.Scanner);
 
 /// listens for messages
 fn readMessage(self: *Self, _: anytype) !void {
@@ -250,7 +250,7 @@ fn readMessage(self: *Self, _: anytype) !void {
                 // maybe use threads and call it instead from there
                 if (payload.t) |name| {
                     self.sequence.store(payload.s orelse 0, .monotonic);
-                    try self.handleEvent(name, decompressed); // we use zjson thereonwards
+                    try self.handleEvent(name, decompressed);
                 }
             },
             .Hello => {
@@ -398,389 +398,389 @@ pub fn send(self: *Self, _: bool, data: anytype) SendError!void {
 
 pub fn handleEvent(self: *Self, name: []const u8, payload: []const u8) !void {
     if (mem.eql(u8, name, "READY")) if (self.handler.ready) |event| {
-        const ready = try zjson.parse(GatewayPayload(Types.Ready), self.allocator, payload);
+        const ready = try json.parseFromSlice(GatewayPayload(Types.Ready), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, ready.value.d.?);
     };
 
     if (mem.eql(u8, name, "APPLICATION_COMMAND_PERMISSIONS_UPDATE")) if (self.handler.application_command_permissions_update) |event| {
-        const acp = try zjson.parse(GatewayPayload(Types.ApplicationCommandPermissions), self.allocator, payload);
+        const acp = try json.parseFromSlice(GatewayPayload(Types.ApplicationCommandPermissions), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, acp.value.d.?);
     };
 
     if (mem.eql(u8, name, "CHANNEL_CREATE")) if (self.handler.channel_create) |event| {
-        const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
+        const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, chan.value.d.?);
     };
 
     if (mem.eql(u8, name, "CHANNEL_UPDATE")) if (self.handler.channel_update) |event| {
-        const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
+        const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, chan.value.d.?);
     };
 
     if (mem.eql(u8, name, "CHANNEL_DELETE")) if (self.handler.channel_delete) |event| {
-        const chan = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
+        const chan = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, chan.value.d.?);
     };
 
     if (mem.eql(u8, name, "CHANNEL_PINS_UPDATE")) if (self.handler.channel_pins_update) |event| {
-        const chan_pins_update = try zjson.parse(GatewayPayload(Types.ChannelPinsUpdate), self.allocator, payload);
+        const chan_pins_update = try json.parseFromSlice(GatewayPayload(Types.ChannelPinsUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, chan_pins_update.value.d.?);
     };
 
     if (mem.eql(u8, name, "ENTITLEMENT_CREATE")) if (self.handler.entitlement_create) |event| {
-        const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
+        const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, entitlement.value.d.?);
     };
 
     if (mem.eql(u8, name, "ENTITLEMENT_UPDATE")) if (self.handler.entitlement_update) |event| {
-        const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
+        const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, entitlement.value.d.?);
     };
 
     if (mem.eql(u8, name, "ENTITLEMENT_DELETE")) if (self.handler.entitlement_delete) |event| {
-        const entitlement = try zjson.parse(GatewayPayload(Types.Entitlement), self.allocator, payload);
+        const entitlement = try json.parseFromSlice(GatewayPayload(Types.Entitlement), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, entitlement.value.d.?);
     };
 
     if (mem.eql(u8, name, "INTEGRATION_CREATE")) if (self.handler.integration_create) |event| {
-        const guild_id = try zjson.parse(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload);
+        const guild_id = try json.parseFromSlice(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "INTEGRATION_UPDATE")) if (self.handler.integration_update) |event| {
-        const guild_id = try zjson.parse(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload);
+        const guild_id = try json.parseFromSlice(GatewayPayload(Types.IntegrationCreateUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "INTEGRATION_DELETE")) if (self.handler.integration_delete) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.IntegrationDelete), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.IntegrationDelete), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "INTERACTION_CREATE")) if (self.handler.interaction_create) |event| {
-        const interaction = try zjson.parse(GatewayPayload(Types.MessageInteraction), self.allocator, payload);
+        const interaction = try json.parseFromSlice(GatewayPayload(Types.MessageInteraction), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, interaction.value.d.?);
     };
 
     if (mem.eql(u8, name, "INVITE_CREATE")) if (self.handler.invite_create) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.InviteCreate), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.InviteCreate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "INVITE_DELETE")) if (self.handler.invite_delete) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.InviteDelete), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.InviteDelete), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_CREATE")) if (self.handler.message_create) |event| {
-        const message = try zjson.parse(GatewayPayload(Types.Message), self.allocator, payload);
+        const message = try json.parseFromSlice(GatewayPayload(Types.Message), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, message.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_DELETE")) if (self.handler.message_delete) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.MessageDelete), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.MessageDelete), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_UPDATE")) if (self.handler.message_update) |event| {
-        const message = try zjson.parse(GatewayPayload(Types.Message), self.allocator, payload);
+        const message = try json.parseFromSlice(GatewayPayload(Types.Message), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, message.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_DELETE_BULK")) if (self.handler.message_delete_bulk) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.MessageDeleteBulk), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.MessageDeleteBulk), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_REACTION_ADD")) if (self.handler.message_reaction_add) |event| {
-        const reaction = try zjson.parse(GatewayPayload(Types.MessageReactionAdd), self.allocator, payload);
+        const reaction = try json.parseFromSlice(GatewayPayload(Types.MessageReactionAdd), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, reaction.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE")) if (self.handler.message_reaction_remove) |event| {
-        const reaction = try zjson.parse(GatewayPayload(Types.MessageReactionRemove), self.allocator, payload);
+        const reaction = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, reaction.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE_ALL")) if (self.handler.message_reaction_remove_all) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.MessageReactionRemoveAll), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemoveAll), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSAGE_REACTION_REMOVE_EMOJI")) if (self.handler.message_reaction_remove_emoji) |event| {
-        const emoji = try zjson.parse(GatewayPayload(Types.MessageReactionRemoveEmoji), self.allocator, payload);
+        const emoji = try json.parseFromSlice(GatewayPayload(Types.MessageReactionRemoveEmoji), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, emoji.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_CREATE")) {
         const isAvailable =
-            try zjson.parse(GatewayPayload(struct { unavailable: ?bool }), self.allocator, payload);
+            try json.parseFromSlice(GatewayPayload(struct { unavailable: ?bool }), self.allocator, payload, .{.max_value_len=0x100});
 
         if (isAvailable.value.d.?.unavailable == true) {
-            const guild = try zjson.parse(GatewayPayload(Types.Guild), self.allocator, payload);
+            const guild = try json.parseFromSlice(GatewayPayload(Types.Guild), self.allocator, payload, .{.max_value_len=0x100});
 
             if (self.handler.guild_create) |event| try event(self, guild.value.d.?);
             return;
         }
 
-        const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
+        const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
 
         if (self.handler.guild_create_unavailable) |event| try event(self, guild.value.d.?);
     }
 
     if (mem.eql(u8, name, "GUILD_UPDATE")) if (self.handler.guild_update) |event| {
-        const guild = try zjson.parse(GatewayPayload(Types.Guild), self.allocator, payload);
+        const guild = try json.parseFromSlice(GatewayPayload(Types.Guild), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_DELETE")) if (self.handler.guild_delete) |event| {
-        const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
+        const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_CREATE")) if (self.handler.guild_scheduled_event_create) |event| {
-        const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
+        const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, s_event.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_UPDATE")) if (self.handler.guild_scheduled_event_update) |event| {
-        const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
+        const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, s_event.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_DELETE")) if (self.handler.guild_scheduled_event_delete) |event| {
-        const s_event = try zjson.parse(GatewayPayload(Types.ScheduledEvent), self.allocator, payload);
+        const s_event = try json.parseFromSlice(GatewayPayload(Types.ScheduledEvent), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, s_event.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_USER_ADD")) if (self.handler.guild_scheduled_event_user_add) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.ScheduledEventUserAdd), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.ScheduledEventUserAdd), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_SCHEDULED_EVENT_USER_REMOVE")) if (self.handler.guild_scheduled_event_user_remove) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.ScheduledEventUserRemove), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.ScheduledEventUserRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_MEMBER_ADD")) if (self.handler.guild_member_add) |event| {
-        const guild_id = try zjson.parse(GatewayPayload(Types.GuildMemberAdd), self.allocator, payload);
+        const guild_id = try json.parseFromSlice(GatewayPayload(Types.GuildMemberAdd), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_MEMBER_UPDATE")) if (self.handler.guild_member_update) |event| {
-        const fields = try zjson.parse(GatewayPayload(Types.GuildMemberUpdate), self.allocator, payload);
+        const fields = try json.parseFromSlice(GatewayPayload(Types.GuildMemberUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, fields.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_MEMBER_REMOVE")) if (self.handler.guild_member_remove) |event| {
-        const user = try zjson.parse(GatewayPayload(Types.GuildMemberRemove), self.allocator, payload);
+        const user = try json.parseFromSlice(GatewayPayload(Types.GuildMemberRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, user.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_MEMBERS_CHUNK")) if (self.handler.guild_members_chunk) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.GuildMembersChunk), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.GuildMembersChunk), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_ROLE_CREATE")) if (self.handler.guild_role_create) |event| {
-        const role = try zjson.parse(GatewayPayload(Types.GuildRoleCreate), self.allocator, payload);
+        const role = try json.parseFromSlice(GatewayPayload(Types.GuildRoleCreate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, role.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_ROLE_UPDATE")) if (self.handler.guild_role_update) |event| {
-        const role = try zjson.parse(GatewayPayload(Types.GuildRoleUpdate), self.allocator, payload);
+        const role = try json.parseFromSlice(GatewayPayload(Types.GuildRoleUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, role.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_ROLE_DELETE")) if (self.handler.guild_role_delete) |event| {
-        const role_id = try zjson.parse(GatewayPayload(Types.GuildRoleDelete), self.allocator, payload);
+        const role_id = try json.parseFromSlice(GatewayPayload(Types.GuildRoleDelete), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, role_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_DELETE")) if (self.handler.guild_delete) |event| {
-        const guild = try zjson.parse(GatewayPayload(Types.UnavailableGuild), self.allocator, payload);
+        const guild = try json.parseFromSlice(GatewayPayload(Types.UnavailableGuild), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_BAN_ADD")) if (self.handler.guild_ban_add) |event| {
-        const gba = try zjson.parse(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload);
+        const gba = try json.parseFromSlice(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, gba.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_BAN_REMOVE")) if (self.handler.guild_ban_remove) |event| {
-        const gbr = try zjson.parse(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload);
+        const gbr = try json.parseFromSlice(GatewayPayload(Types.GuildBanAddRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, gbr.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_EMOJIS_UPDATE")) if (self.handler.guild_emojis_update) |event| {
-        const emojis = try zjson.parse(GatewayPayload(Types.GuildEmojisUpdate), self.allocator, payload);
+        const emojis = try json.parseFromSlice(GatewayPayload(Types.GuildEmojisUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, emojis.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_STICKERS_UPDATE")) if (self.handler.guild_stickers_update) |event| {
-        const stickers = try zjson.parse(GatewayPayload(Types.GuildStickersUpdate), self.allocator, payload);
+        const stickers = try json.parseFromSlice(GatewayPayload(Types.GuildStickersUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, stickers.value.d.?);
     };
 
     if (mem.eql(u8, name, "GUILD_INTEGRATIONS_UPDATE")) if (self.handler.guild_integrations_update) |event| {
-        const guild_id = try zjson.parse(GatewayPayload(Types.GuildIntegrationsUpdate), self.allocator, payload);
+        const guild_id = try json.parseFromSlice(GatewayPayload(Types.GuildIntegrationsUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_CREATE")) if (self.handler.thread_create) |event| {
-        const thread = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
+        const thread = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, thread.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_UPDATE")) if (self.handler.thread_update) |event| {
-        const thread = try zjson.parse(GatewayPayload(Types.Channel), self.allocator, payload);
+        const thread = try json.parseFromSlice(GatewayPayload(Types.Channel), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, thread.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_DELETE")) if (self.handler.thread_delete) |event| {
-        const thread_data = try zjson.parse(GatewayPayload(Types.Partial(Types.Channel)), self.allocator, payload);
+        const thread_data = try json.parseFromSlice(GatewayPayload(Types.Partial(Types.Channel)), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, thread_data.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_LIST_SYNC")) if (self.handler.thread_list_sync) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.ThreadListSync), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.ThreadListSync), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_MEMBER_UPDATE")) if (self.handler.thread_member_update) |event| {
-        const guild_id = try zjson.parse(GatewayPayload(Types.ThreadMemberUpdate), self.allocator, payload);
+        const guild_id = try json.parseFromSlice(GatewayPayload(Types.ThreadMemberUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, guild_id.value.d.?);
     };
 
     if (mem.eql(u8, name, "THREAD_MEMBERS_UPDATE")) if (self.handler.thread_members_update) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.ThreadMembersUpdate), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.ThreadMembersUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "TYPING_START")) if (self.handler.typing_start) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.TypingStart), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.TypingStart), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "USER_UPDATE")) if (self.handler.user_update) |event| {
-        const user = try zjson.parse(GatewayPayload(Types.User), self.allocator, payload);
+        const user = try json.parseFromSlice(GatewayPayload(Types.User), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, user.value.d.?);
     };
 
     if (mem.eql(u8, name, "PRESENCE_UPDATE")) if (self.handler.presence_update) |event| {
-        const pu = try zjson.parse(GatewayPayload(Types.PresenceUpdate), self.allocator, payload);
+        const pu = try json.parseFromSlice(GatewayPayload(Types.PresenceUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, pu.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSSAGE_POLL_VOTE_ADD")) if (self.handler.message_poll_vote_add) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.PollVoteAdd), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.PollVoteAdd), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "MESSSAGE_POLL_VOTE_REMOVE")) if (self.handler.message_poll_vote_remove) |event| {
-        const data = try zjson.parse(GatewayPayload(Types.PollVoteRemove), self.allocator, payload);
+        const data = try json.parseFromSlice(GatewayPayload(Types.PollVoteRemove), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, data.value.d.?);
     };
 
     if (mem.eql(u8, name, "WEBHOOKS_UPDATE")) if (self.handler.webhooks_update) |event| {
-        const fields = try zjson.parse(GatewayPayload(Types.WebhookUpdate), self.allocator, payload);
+        const fields = try json.parseFromSlice(GatewayPayload(Types.WebhookUpdate), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, fields.value.d.?);
     };
 
     if (mem.eql(u8, name, "STAGE_INSTANCE_CREATE")) if (self.handler.stage_instance_create) |event| {
-        const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
+        const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, stage.value.d.?);
     };
 
     if (mem.eql(u8, name, "STAGE_INSTANCE_UPDATE")) if (self.handler.stage_instance_update) |event| {
-        const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
+        const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, stage.value.d.?);
     };
 
     if (mem.eql(u8, name, "STAGE_INSTANCE_DELETE")) if (self.handler.stage_instance_delete) |event| {
-        const stage = try zjson.parse(GatewayPayload(Types.StageInstance), self.allocator, payload);
+        const stage = try json.parseFromSlice(GatewayPayload(Types.StageInstance), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, stage.value.d.?);
     };
 
     if (mem.eql(u8, name, "AUTO_MODERATION_RULE_CREATE")) if (self.handler.auto_moderation_rule_create) |event| {
-        const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
+        const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, rule.value.d.?);
     };
 
     if (mem.eql(u8, name, "AUTO_MODERATION_RULE_UPDATE")) if (self.handler.auto_moderation_rule_update) |event| {
-        const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
+        const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, rule.value.d.?);
     };
 
     if (mem.eql(u8, name, "AUTO_MODERATION_RULE_DELETE")) if (self.handler.auto_moderation_rule_delete) |event| {
-        const rule = try zjson.parse(GatewayPayload(Types.AutoModerationRule), self.allocator, payload);
+        const rule = try json.parseFromSlice(GatewayPayload(Types.AutoModerationRule), self.allocator, payload, .{.max_value_len=0x100});
 
         try event(self, rule.value.d.?);
     };
 
     if (mem.eql(u8, name, "AUTO_MODERATION_ACTION_EXECUTION")) if (self.handler.auto_moderation_action_execution) |event| {
-        const ax = try zjson.parse(GatewayPayload(Types.AutoModerationActionExecution), self.allocator, payload);
+        const ax = try json.parseFromSlice(GatewayPayload(Types.AutoModerationActionExecution), self.allocator, payload, .{.max_value_len = 0x100});
 
         try event(self, ax.value.d.?);
     };
@@ -790,7 +790,7 @@ pub fn handleEvent(self: *Self, name: []const u8, payload: []const u8) !void {
         try anyEvent(self, payload);
 }
 
-pub const RequestFailedError = zjson.ParserError || MakeRequestError || error{FailedRequest};
+pub const RequestFailedError = MakeRequestError || error{FailedRequest} || json.ParseError(json.Scanner);
 
 // start http methods
 
@@ -2709,7 +2709,7 @@ pub fn deleteTestEntitlement(self: *Self, application_id: Snowflake) RequestFail
 }
 
 /// Returns all SKUs for a given application.
-pub fn fetchSkus(self: *Self, application_id: Snowflake) RequestFailedError!zjson.Owner([]Types.Sku) {
+pub fn fetchSkus(self: *Self, application_id: Snowflake) RequestFailedError!Result([]Types.Sku) {
     var buf: [256]u8 = undefined;
     const path = try std.fmt.bufPrint(&buf, "/applications/{d}/skus", .{application_id.into()});
 

src/structures/application.zig

@@ -21,7 +21,7 @@ const Partial = @import("partial.zig").Partial;
 const User = @import("user.zig").User;
 const Team = @import("team.zig").Team;
 const Guild = @import("guild.zig").Guild;
-const AssociativeArray = @import("../json.zig").AssociativeArray;
+const AssociativeArray = @import("../json-helper.zig").AssociativeArray;
 
 /// https://discord.com/developers/docs/resources/application#application-object
 pub const Application = struct {

src/structures/component.zig

@@ -5,7 +5,6 @@ const ButtonStyles = @import("shared.zig").ButtonStyles;
 const ChannelTypes = @import("shared.zig").ChannelTypes;
 const MessageComponentTypes = @import("shared.zig").MessageComponentTypes;
 
-const zjson = @import("../json.zig");
 const std = @import("std");
 
 /// https://discord.com/developers/docs/interactions/message-components#buttons
@@ -153,20 +152,20 @@ pub const SelectMenu = union(MessageComponentTypes) {
     SelectMenuUsersAndRoles: SelectMenuUsersAndRoles,
     SelectMenuChannels: SelectMenuChannels,
 
-    pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
+    pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
         const value = try std.json.innerParse(std.json.Value, allocator, src, .{
             .max_value_len  = 0x100,
         });
 
-        if (!value != .object) @panic("coulnd't match against non-object type");
+        if (value != .object) @panic("coulnd't match against non-object type");
 
         switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
             .integer => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num))) {
-                .SelectMenu => .{ .SelectMenu = try std.json.parseFromValue(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
+                .SelectMenu => .{ .SelectMenu = try std.json.parseFromValueLeaky(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValue(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
+                .SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValueLeaky(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValue(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
+                .SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValueLeaky(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValue(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
+                .SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValueLeaky(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValue(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
+                .SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValueLeaky(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
             },
             else => @panic("got type but couldn't match against non enum member `type`"),
         }
@@ -175,21 +174,8 @@ pub const SelectMenu = union(MessageComponentTypes) {
     }
 
     // legacy
-    pub fn json(allocator: std.mem.Allocator, value: zjson.JsonType) !@This() {
+    pub fn json(_: std.mem.Allocator) !SelectMenu {
-        if (!value.is(.object))
+        @compileError("Deprecated, use std.json instead.");
-            @panic("coulnd't match against non-object type");
-
-        switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
-            .number => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num.integer))) {
-                .SelectMenu => .{ .SelectMenu = try zjson.parseInto(SelectMenuString, allocator, value) },
-                .SelectMenuUsers => .{ .SelectMenuUsers = try zjson.parseInto(SelectMenuUsers, allocator, value) },
-                .SelectMenuRoles => .{ .SelectMenuRoles = try zjson.parseInto(SelectMenuRoles, allocator, value) },
-                .SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try zjson.parseInto(SelectMenuUsersAndRoles, allocator, value) },
-                .SelectMenuChannels => .{ .SelectMenuChannels = try zjson.parseInto(SelectMenuChannels, allocator, value) },
-            },
-            else => @panic("got type but couldn't match against non enum member `type`"),
-        }
-        unreachable;
     }
 };
 
@@ -229,22 +215,33 @@ pub const MessageComponent = union(MessageComponentTypes) {
     SelectMenuUsersAndRoles: SelectMenuUsersAndRoles,
     SelectMenuChannels: SelectMenuChannels,
 
-    pub fn json(allocator: std.mem.Allocator, value: zjson.JsonType) !@This() {
+    /// zjson parse
-        if (!value.is(.object))
+    /// legacy
-            @panic("coulnd't match against non-object type");
+    pub fn json(_: std.mem.Allocator) void {
+        @compileError("Deprecated, use std.json instead.");
+    }
+
+    pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
+        const value = try std.json.innerParse(std.json.Value, allocator, src, .{
+            .max_value_len  = 0x100,
+        });
+
+        if (value != .object) @panic("coulnd't match against non-object type");
 
         switch (value.object.get("type") orelse @panic("couldn't find property `type`")) {
-            .number => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num.integer))) {
+            .integer => |num| return switch (@as(MessageComponentTypes, @enumFromInt(num))) {
-                .ActionRow => .{ .ActionRow = try zjson.parseInto([]MessageComponent, allocator, value) },
+                .ActionRow => .{ .ActionRow = try std.json.parseFromValueLeaky([]MessageComponent, allocator, value, .{.max_value_len = 0x100}) },
-                .Button => .{ .Button = try zjson.parseInto(Button, allocator, value) },
+                .Button => .{ .Button = try std.json.parseFromValueLeaky(Button, allocator, value, .{.max_value_len = 0x100}) },
-                .SelectMenu => .{ .SelectMenu = try zjson.parseInto(SelectMenuString, allocator, value) },
+                .SelectMenu => .{ .SelectMenu = try std.json.parseFromValueLeaky(SelectMenuString, allocator, value, .{.max_value_len = 0x100})},
-                .InputText => .{ .InputText = try zjson.parseInto(InputText, allocator, value) },
+                .InputText => .{ .InputText = try std.json.parseFromValueLeaky(InputText, allocator, value, .{.max_value_len = 0x100}) },
-                .SelectMenuUsers => .{ .SelectMenuUsers = try zjson.parseInto(SelectMenuUsers, allocator, value) },
+                .SelectMenuUsers => .{ .SelectMenuUsers = try std.json.parseFromValueLeaky(SelectMenuUsers, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuRoles => .{ .SelectMenuRoles = try zjson.parseInto(SelectMenuRoles, allocator, value) },
+                .SelectMenuRoles => .{ .SelectMenuRoles = try std.json.parseFromValueLeaky(SelectMenuRoles, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try zjson.parseInto(SelectMenuUsersAndRoles, allocator, value) },
+                .SelectMenuUsersAndRoles => .{ .SelectMenuUsersAndRoles = try std.json.parseFromValueLeaky(SelectMenuUsersAndRoles, allocator, value, .{.max_value_len = 0x100})},
-                .SelectMenuChannels => .{ .SelectMenuChannels = try zjson.parseInto(SelectMenuChannels, allocator, value) },
+                .SelectMenuChannels => .{ .SelectMenuChannels = try std.json.parseFromValueLeaky(SelectMenuChannels, allocator, value, .{.max_value_len = 0x100})},
             },
             else => @panic("got type but couldn't match against non enum member `type`"),
         }
+
+        return try MessageComponent.jsonParse(allocator, value);
     }
 };

src/structures/interaction.zig

@@ -32,7 +32,7 @@ const ApplicationCommandTypes = @import("shared.zig").ApplicationCommandTypes;
 const InteractionResponseTypes = @import("shared.zig").InteractionResponseTypes;
 const InteractionContextType = @import("command.zig").InteractionContextType;
 const Entitlement = @import("monetization.zig").Entitlement;
-const Record = @import("../json.zig").Record;
+const Record = @import("../json-helper.zig").Record;
 
 pub const Interaction = struct {
     /// Id of the interaction

src/structures/snowflake.zig

@@ -15,7 +15,6 @@
 //! PERFORMANCE OF THIS SOFTWARE.
 
 const std = @import("std");
-const zjson = @import("../json.zig");
 
 /// Milliseconds since Discord Epoch, the first second of 2015 or 1420070400000.
 pub const discord_epoch = 1420070400000;
@@ -55,16 +54,13 @@ pub const Snowflake = enum(u64) {
 
     /// zjson parse
     /// legacy
-    pub fn json(_: std.mem.Allocator, value: zjson.JsonType) !@This() {
+    pub fn json(_: std.mem.Allocator) void {
-        if (value.is(.string))
+        @compileError("Deprecated, use std.json instead.");
-            return Snowflake.fromRaw(value.string) catch
-                std.debug.panic("invalid snowflake: {s}\n", .{value.string});
-        unreachable;
     }
 
     /// std.json parse
-    pub fn jsonParse(allocator: std.mem.Allocator, src: []const u8) !@This() {
+    pub fn jsonParse(allocator: std.mem.Allocator, src: anytype, _: std.json.ParseOptions) !@This() {
-        const value = try std.json.parseFromSlice(std.json.Value, allocator, src, .{
+        const value = try std.json.innerParse(std.json.Value, allocator, src, .{
         .max_value_len = 0x100
             });
 

src/structures/user.zig

@@ -20,7 +20,7 @@ const Application = @import("application.zig").Application;
 const OAuth2Scope = @import("shared.zig").OAuth2Scope;
 const Integration = @import("integration.zig").Integration;
 const Partial = @import("partial.zig").Partial;
-const Record = @import("../json.zig").Record;
+const Record = @import("../json-helper.zig").Record;
 
 /// https://discord.com/developers/docs/resources/user#user-object
 pub const User = struct {