wip

Former-commit-id: f4267e2d1fee0d885630dc2a87be0a5699bf526f

1 files changed, 767 insertions, 725 deletions

diff --git a/src/api/schema.zig b/src/api/schema.zig
index 09da2f058..d34e501a3 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1,739 +1,781 @@
+
 const std = @import("std");
 
-pub const Api = struct {
-    pub const Loader = enum(u8) {
-        _none,
-        /// jsx
-        jsx,
-
-        /// js
-        js,
-
-        /// ts
-        ts,
-
-        /// tsx
-        tsx,
-
-        /// css
-        css,
-
-        /// file
-        file,
-
-        /// json
-        json,
-
-        _,
-
-        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-            return try std.json.stringify(@tagName(self), opts, o);
-        }
-    };
-
-    pub const JsxRuntime = enum(u8) {
-        _none,
-        /// automatic
-        automatic,
-
-        /// classic
-        classic,
-
-        _,
-
-        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-            return try std.json.stringify(@tagName(self), opts, o);
-        }
-    };
-
-    pub const Jsx = struct {
-        /// factory
-        factory: []u8,
-
-        /// runtime
-        runtime: JsxRuntime,
-
-        /// fragment
-        fragment: []u8,
-
-        /// production
-        production: bool = false,
-
-        /// import_source
-        import_source: []u8,
-
-        /// react_fast_refresh
-        react_fast_refresh: bool = false,
-
-        /// loader_keys
-        loader_keys: [][]u8,
-
-        /// loader_values
-        loader_values: []Loader,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Jsx {
-            var obj = std.mem.zeroes(Jsx);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *Jsx, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            length = try reader.readIntNative(u32);
-            if (result.factory.len != length) {
-                result.factory = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.factory);
-            result.runtime = try reader.readEnum(JsxRuntime, .Little);
-            length = try reader.readIntNative(u32);
-            if (result.fragment.len != length) {
-                result.fragment = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.fragment);
-            result.production = (try reader.readByte()) == @as(u8, 1);
-            length = try reader.readIntNative(u32);
-            if (result.import_source.len != length) {
-                result.import_source = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.import_source);
-            result.react_fast_refresh = (try reader.readByte()) == @as(u8, 1);
-            {
-                var array_count = try reader.readIntNative(u32);
-                if (array_count != result.loader_keys.len) {
-                    result.loader_keys = try allocator.alloc([]u8, array_count);
-                }
-                length = try reader.readIntNative(u32);
-                for (result.loader_keys) |content, j| {
-                    if (result.loader_keys[j].len != length) {
-                        result.loader_keys[j] = try allocator.alloc(u8, length);
-                    }
-                    _ = try reader.readAll(result.loader_keys[j]);
-                }
-            }
-            length = try reader.readIntNative(u32);
-            result.loader_values = try allocator.alloc(Loader, length);
-            {
-                var j: usize = 0;
-                while (j < length) : (j += 1) {
-                    result.loader_values[j] = try reader.readEnum(Loader, .Little);
-                }
-            }
-            return;
-        }
 
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            var n: usize = 0;
-            try writer.writeIntNative(u32, @intCast(u32, result.factory.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.factory));
+pub const Api = struct { 
 
-            try writer.writeIntNative(@TypeOf(@enumToInt(result.runtime)), @enumToInt(result.runtime));
+pub const Loader = enum(u8) {
 
-            try writer.writeIntNative(u32, @intCast(u32, result.fragment.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.fragment));
+_none,
+  /// jsx
+  jsx,
 
-            try writer.writeByte(@boolToInt(result.production));
+  /// js
+  js,
 
-            try writer.writeIntNative(u32, @intCast(u32, result.import_source.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.import_source));
+  /// ts
+  ts,
 
-            try writer.writeByte(@boolToInt(result.react_fast_refresh));
+  /// tsx
+  tsx,
 
-            n = result.loader_keys.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    _ = try writer.writeIntNative(u32, @intCast(u32, result.loader_keys[j].len));
-                    try writer.writeAll(std.mem.sliceAsBytes(result.loader_keys[j]));
-                }
-            }
-
-            n = result.loader_values.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    try writer.writeByte(@enumToInt(result.loader_values[j]));
-                }
-            }
-            return;
-        }
-    };
-
-    pub const TransformOptions = struct {
-        /// jsx
-        jsx: Jsx,
-
-        /// ts
-        ts: bool = false,
-
-        /// base_path
-        base_path: []u8,
-
-        /// define_keys
-        define_keys: [][]u8,
-
-        /// define_values
-        define_values: [][]u8,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
-            var obj = std.mem.zeroes(TransformOptions);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *TransformOptions, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            result.jsx = try Jsx.decode(allocator, reader);
-            result.ts = (try reader.readByte()) == @as(u8, 1);
-            length = try reader.readIntNative(u32);
-            if (result.base_path.len != length) {
-                result.base_path = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.base_path);
-            {
-                var array_count = try reader.readIntNative(u32);
-                if (array_count != result.define_keys.len) {
-                    result.define_keys = try allocator.alloc([]u8, array_count);
-                }
-                length = try reader.readIntNative(u32);
-                for (result.define_keys) |content, j| {
-                    if (result.define_keys[j].len != length) {
-                        result.define_keys[j] = try allocator.alloc(u8, length);
-                    }
-                    _ = try reader.readAll(result.define_keys[j]);
-                }
-            }
-            {
-                var array_count = try reader.readIntNative(u32);
-                if (array_count != result.define_values.len) {
-                    result.define_values = try allocator.alloc([]u8, array_count);
-                }
-                length = try reader.readIntNative(u32);
-                for (result.define_values) |content, j| {
-                    if (result.define_values[j].len != length) {
-                        result.define_values[j] = try allocator.alloc(u8, length);
-                    }
-                    _ = try reader.readAll(result.define_values[j]);
-                }
-            }
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            var n: usize = 0;
-            try result.jsx.encode(writer);
-
-            try writer.writeByte(@boolToInt(result.ts));
-
-            try writer.writeIntNative(u32, @intCast(u32, result.base_path.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.base_path));
-
-            n = result.define_keys.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    _ = try writer.writeIntNative(u32, @intCast(u32, result.define_keys[j].len));
-                    try writer.writeAll(std.mem.sliceAsBytes(result.define_keys[j]));
-                }
-            }
-
-            n = result.define_values.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    _ = try writer.writeIntNative(u32, @intCast(u32, result.define_values[j].len));
-                    try writer.writeAll(std.mem.sliceAsBytes(result.define_values[j]));
-                }
-            }
-            return;
-        }
-    };
-
-    pub const FileHandle = struct {
-        /// path
-        path: []u8,
-
-        /// size
-        size: u32 = 0,
-
-        /// fd
-        fd: u32 = 0,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!FileHandle {
-            var obj = std.mem.zeroes(FileHandle);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *FileHandle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            length = try reader.readIntNative(u32);
-            if (result.path.len != length) {
-                result.path = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.path);
-            _ = try reader.readAll(std.mem.asBytes(&result.size));
-            _ = try reader.readAll(std.mem.asBytes(&result.fd));
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            try writer.writeIntNative(u32, @intCast(u32, result.path.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.path));
-
-            try writer.writeIntNative(u32, result.size);
-
-            try writer.writeIntNative(u32, result.fd);
-            return;
-        }
-    };
-
-    pub const Transform = struct {
-        /// handle
-        handle: ?FileHandle = null,
-
-        /// path
-        path: ?[]u8 = null,
-
-        /// contents
-        contents: ?[]u8 = null,
-
-        /// loader
-        loader: ?Loader = null,
-
-        /// options
-        options: ?TransformOptions = null,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Transform {
-            var obj = std.mem.zeroes(Transform);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *Transform, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            while (true) {
-                const field_type: u8 = try reader.readByte();
-                switch (field_type) {
-                    0 => {
-                        return;
-                    },
-
-                    1 => {
-                        result.handle = try FileHandle.decode(allocator, reader);
-                    },
-                    2 => {
-                        length = try reader.readIntNative(u32);
-                        if ((result.path orelse &([_]u8{})).len != length) {
-                            result.path = try allocator.alloc(u8, length);
-                        }
-                        _ = try reader.readAll(result.path.?);
-                    },
-                    3 => {
-                        length = try reader.readIntNative(u32);
-                        if ((result.contents orelse &([_]u8{})).len != length) {
-                            result.contents = try allocator.alloc(u8, length);
-                        }
-                        _ = try reader.readAll(result.contents.?);
-                    },
-                    4 => {
-                        result.loader = try reader.readEnum(Loader, .Little);
-                    },
-                    5 => {
-                        result.options = try TransformOptions.decode(allocator, reader);
-                    },
-                    else => {
-                        return error.InvalidMessage;
-                    },
-                }
-            }
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            if (result.handle) |handle| {
-                try writer.writeByte(1);
-                try handle.encode(writer);
-            }
-
-            if (result.path) |path| {
-                try writer.writeByte(2);
-                try writer.writeIntNative(u32, @intCast(u32, path.len));
-                try writer.writeAll(std.mem.sliceAsBytes(path));
-            }
-
-            if (result.contents) |contents| {
-                try writer.writeByte(3);
-                try writer.writeIntNative(u32, @intCast(u32, contents.len));
-                try writer.writeAll(std.mem.sliceAsBytes(contents));
-            }
-
-            if (result.loader) |loader| {
-                try writer.writeByte(4);
-                try writer.writeIntNative(@TypeOf(@enumToInt(result.loader orelse unreachable)), @enumToInt(result.loader orelse unreachable));
-            }
-
-            if (result.options) |options| {
-                try writer.writeByte(5);
-                try options.encode(writer);
-            }
-            try writer.writeByte(0);
-            return;
-        }
-    };
-
-    pub const TransformResponseStatus = enum(u32) {
-        _none,
-        /// success
-        success,
-
-        /// fail
-        fail,
-
-        _,
-
-        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-            return try std.json.stringify(@tagName(self), opts, o);
-        }
-    };
-
-    pub const OutputFile = struct {
-        /// data
-        data: []u8,
-
-        /// path
-        path: []u8,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!OutputFile {
-            var obj = std.mem.zeroes(OutputFile);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *OutputFile, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            _ = try reader.readAll(result.data);
-            length = try reader.readIntNative(u32);
-            if (result.path.len != length) {
-                result.path = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.path);
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            try writer.writeAll(result.data);
-
-            try writer.writeIntNative(u32, @intCast(u32, result.path.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.path));
-            return;
-        }
-    };
-
-    pub const TransformResponse = struct {
-        /// status
-        status: TransformResponseStatus,
-
-        /// files
-        files: []OutputFile,
-
-        /// errors
-        errors: []Message,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformResponse {
-            var obj = std.mem.zeroes(TransformResponse);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *TransformResponse, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            result.status = try reader.readEnum(TransformResponseStatus, .Little);
-            length = try reader.readIntNative(u32);
-            result.files = try allocator.alloc(OutputFile, length);
-            {
-                var j: usize = 0;
-                while (j < length) : (j += 1) {
-                    result.files[j] = try OutputFile.decode(allocator, reader);
-                }
-            }
-            length = try reader.readIntNative(u32);
-            result.errors = try allocator.alloc(Message, length);
-            {
-                var j: usize = 0;
-                while (j < length) : (j += 1) {
-                    result.errors[j] = try Message.decode(allocator, reader);
-                }
-            }
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            var n: usize = 0;
-            try writer.writeIntNative(@TypeOf(@enumToInt(result.status)), @enumToInt(result.status));
-
-            n = result.files.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    try result.files[j].encode(writer);
-                }
-            }
-
-            n = result.errors.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    try result.errors[j].encode(writer);
-                }
-            }
-            return;
-        }
-    };
-
-    pub const MessageKind = enum(u32) {
-        _none,
-        /// err
-        err,
-
-        /// warn
-        warn,
-
-        /// note
-        note,
-
-        /// debug
-        debug,
-
-        _,
-
-        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-            return try std.json.stringify(@tagName(self), opts, o);
-        }
-    };
-
-    pub const Location = struct {
-        /// file
-        file: []u8,
-
-        /// namespace
-        namespace: []u8,
-
-        /// line
-        line: i32 = 0,
-
-        /// column
-        column: i32 = 0,
-
-        /// line_text
-        line_text: []u8,
-
-        /// suggestion
-        suggestion: []u8,
-
-        /// offset
-        offset: u32 = 0,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Location {
-            var obj = std.mem.zeroes(Location);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *Location, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            length = try reader.readIntNative(u32);
-            if (result.file.len != length) {
-                result.file = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.file);
-            length = try reader.readIntNative(u32);
-            if (result.namespace.len != length) {
-                result.namespace = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.namespace);
-            _ = try reader.readAll(std.mem.asBytes(&result.line));
-            _ = try reader.readAll(std.mem.asBytes(&result.column));
-            length = try reader.readIntNative(u32);
-            if (result.line_text.len != length) {
-                result.line_text = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.line_text);
-            length = try reader.readIntNative(u32);
-            if (result.suggestion.len != length) {
-                result.suggestion = try allocator.alloc(u8, length);
-            }
-            _ = try reader.readAll(result.suggestion);
-            _ = try reader.readAll(std.mem.asBytes(&result.offset));
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            try writer.writeIntNative(u32, @intCast(u32, result.file.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.file));
-
-            try writer.writeIntNative(u32, @intCast(u32, result.namespace.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.namespace));
-
-            try writer.writeIntNative(i32, result.line);
-
-            try writer.writeIntNative(i32, result.column);
-
-            try writer.writeIntNative(u32, @intCast(u32, result.line_text.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.line_text));
-
-            try writer.writeIntNative(u32, @intCast(u32, result.suggestion.len));
-            try writer.writeAll(std.mem.sliceAsBytes(result.suggestion));
-
-            try writer.writeIntNative(u32, result.offset);
-            return;
-        }
-    };
-
-    pub const MessageData = struct {
-        /// text
-        text: ?[]u8 = null,
-
-        /// location
-        location: ?Location = null,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!MessageData {
-            var obj = std.mem.zeroes(MessageData);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *MessageData, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            while (true) {
-                const field_type: u8 = try reader.readByte();
-                switch (field_type) {
-                    0 => {
-                        return;
-                    },
-
-                    1 => {
-                        length = try reader.readIntNative(u32);
-                        if ((result.text orelse &([_]u8{})).len != length) {
-                            result.text = try allocator.alloc(u8, length);
-                        }
-                        _ = try reader.readAll(result.text.?);
-                    },
-                    2 => {
-                        result.location = try Location.decode(allocator, reader);
-                    },
-                    else => {
-                        return error.InvalidMessage;
-                    },
-                }
-            }
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            if (result.text) |text| {
-                try writer.writeByte(1);
-                try writer.writeIntNative(u32, @intCast(u32, text.len));
-                try writer.writeAll(std.mem.sliceAsBytes(text));
-            }
-
-            if (result.location) |location| {
-                try writer.writeByte(2);
-                try location.encode(writer);
-            }
-            try writer.writeByte(0);
-            return;
-        }
-    };
-
-    pub const Message = struct {
-        /// kind
-        kind: MessageKind,
-
-        /// data
-        data: MessageData,
-
-        /// notes
-        notes: []MessageData,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Message {
-            var obj = std.mem.zeroes(Message);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *Message, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            result.kind = try reader.readEnum(MessageKind, .Little);
-            result.data = try MessageData.decode(allocator, reader);
-            length = try reader.readIntNative(u32);
-            result.notes = try allocator.alloc(MessageData, length);
-            {
-                var j: usize = 0;
-                while (j < length) : (j += 1) {
-                    result.notes[j] = try MessageData.decode(allocator, reader);
+  /// css
+  css,
+
+  /// file
+  file,
+
+  /// json
+  json,
+
+_,
+
+                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+                    return try std.json.stringify(@tagName(self), opts, o);
                 }
-            }
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            var n: usize = 0;
-            try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
-
-            try result.data.encode(writer);
-
-            n = result.notes.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    try result.notes[j].encode(writer);
+
+                
+};
+
+pub const JsxRuntime = enum(u8) {
+
+_none,
+  /// automatic
+  automatic,
+
+  /// classic
+  classic,
+
+_,
+
+                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+                    return try std.json.stringify(@tagName(self), opts, o);
                 }
-            }
-            return;
-        }
-    };
-
-    pub const Log = struct {
-        /// warnings
-        warnings: u32 = 0,
-
-        /// errors
-        errors: u32 = 0,
-
-        /// msgs
-        msgs: []Message,
-
-        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Log {
-            var obj = std.mem.zeroes(Log);
-            try update(&obj, allocator, reader);
-            return obj;
-        }
-        pub fn update(result: *Log, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
-            var length: usize = 0;
-            _ = try reader.readAll(std.mem.asBytes(&result.warnings));
-            _ = try reader.readAll(std.mem.asBytes(&result.errors));
-            length = try reader.readIntNative(u32);
-            result.msgs = try allocator.alloc(Message, length);
-            {
-                var j: usize = 0;
-                while (j < length) : (j += 1) {
-                    result.msgs[j] = try Message.decode(allocator, reader);
+
+                
+};
+
+pub const Jsx = struct {
+/// factory
+factory: []u8,
+
+/// runtime
+runtime: JsxRuntime,
+
+/// fragment
+fragment: []u8,
+
+/// production
+production: bool = false,
+
+/// import_source
+import_source: []u8,
+
+/// react_fast_refresh
+react_fast_refresh: bool = false,
+
+/// loader_keys
+loader_keys: [][]u8,
+
+/// loader_values
+loader_values: []Loader,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Jsx {
+var obj = std.mem.zeroes(Jsx);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Jsx, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  length = try reader.readIntNative(u32);
+  if (result.factory.len != length) {
+  result.factory = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.factory);
+  result.runtime = try reader.readEnum(JsxRuntime, .Little);
+  length = try reader.readIntNative(u32);
+  if (result.fragment.len != length) {
+  result.fragment = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.fragment);
+  result.production = (try reader.readByte()) == @as(u8, 1);
+  length = try reader.readIntNative(u32);
+  if (result.import_source.len != length) {
+  result.import_source = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.import_source);
+  result.react_fast_refresh = (try reader.readByte()) == @as(u8, 1);
+  {
+  var array_count = try reader.readIntNative(u32);
+  if (array_count != result.loader_keys.len) {
+  result.loader_keys = try allocator.alloc([]u8, array_count);
+  }
+  length = try reader.readIntNative(u32);
+  for (result.loader_keys) |content, j| {
+  if (result.loader_keys[j].len != length) {
+  result.loader_keys[j] = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.loader_keys[j]);
+  }
+    }
+  length = try reader.readIntNative(u32);
+  result.loader_values = try allocator.alloc(Loader, length);
+  {
+  var j: usize = 0;
+  while(j < length) : (j += 1) {
+     result.loader_values[j] = try reader.readEnum(Loader, .Little);
+  }}
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    var n: usize = 0;
+    try writer.writeIntNative(u32, @intCast(u32, result.factory.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.factory));
+
+    try writer.writeIntNative(@TypeOf(@enumToInt(result.runtime)), @enumToInt(result.runtime));
+
+    try writer.writeIntNative(u32, @intCast(u32, result.fragment.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.fragment));
+
+    try writer.writeByte(@boolToInt(result.production));
+
+    try writer.writeIntNative(u32, @intCast(u32, result.import_source.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.import_source));
+
+    try writer.writeByte(@boolToInt(result.react_fast_refresh));
+
+    n = result.loader_keys.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+     _ = try writer.writeIntNative(u32, @intCast(u32, result.loader_keys[j].len));
+      try writer.writeAll(std.mem.sliceAsBytes(result.loader_keys[j]));
+    }}
+
+    n = result.loader_values.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+      try writer.writeByte(@enumToInt(result.loader_values[j]));
+    }}
+  return;
+}
+
+};
+
+pub const TransformOptions = struct {
+/// jsx
+jsx: Jsx,
+
+/// ts
+ts: bool = false,
+
+/// base_path
+base_path: []u8,
+
+/// define_keys
+define_keys: [][]u8,
+
+/// define_values
+define_values: [][]u8,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
+var obj = std.mem.zeroes(TransformOptions);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *TransformOptions, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  result.jsx = try Jsx.decode(allocator, reader);
+  result.ts = (try reader.readByte()) == @as(u8, 1);
+  length = try reader.readIntNative(u32);
+  if (result.base_path.len != length) {
+  result.base_path = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.base_path);
+  {
+  var array_count = try reader.readIntNative(u32);
+  if (array_count != result.define_keys.len) {
+  result.define_keys = try allocator.alloc([]u8, array_count);
+  }
+  length = try reader.readIntNative(u32);
+  for (result.define_keys) |content, j| {
+  if (result.define_keys[j].len != length) {
+  result.define_keys[j] = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.define_keys[j]);
+  }
+    }
+  {
+  var array_count = try reader.readIntNative(u32);
+  if (array_count != result.define_values.len) {
+  result.define_values = try allocator.alloc([]u8, array_count);
+  }
+  length = try reader.readIntNative(u32);
+  for (result.define_values) |content, j| {
+  if (result.define_values[j].len != length) {
+  result.define_values[j] = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.define_values[j]);
+  }
+    }
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    var n: usize = 0;
+    try result.jsx.encode(writer);
+
+    try writer.writeByte(@boolToInt(result.ts));
+
+    try writer.writeIntNative(u32, @intCast(u32, result.base_path.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.base_path));
+
+    n = result.define_keys.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+     _ = try writer.writeIntNative(u32, @intCast(u32, result.define_keys[j].len));
+      try writer.writeAll(std.mem.sliceAsBytes(result.define_keys[j]));
+    }}
+
+    n = result.define_values.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+     _ = try writer.writeIntNative(u32, @intCast(u32, result.define_values[j].len));
+      try writer.writeAll(std.mem.sliceAsBytes(result.define_values[j]));
+    }}
+  return;
+}
+
+};
+
+pub const FileHandle = struct {
+/// path
+path: []u8,
+
+/// size
+size: u32 = 0,
+
+/// fd
+fd: u32 = 0,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!FileHandle {
+var obj = std.mem.zeroes(FileHandle);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *FileHandle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  length = try reader.readIntNative(u32);
+  if (result.path.len != length) {
+  result.path = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.path);
+  _ = try reader.readAll(std.mem.asBytes(&result.size));
+  _ = try reader.readAll(std.mem.asBytes(&result.fd));
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.path));
+
+    try writer.writeIntNative(u32, result.size);
+
+    try writer.writeIntNative(u32, result.fd);
+  return;
+}
+
+};
+
+pub const Transform = struct {
+/// handle
+handle: ?FileHandle = null,
+
+/// path
+path: ?[]u8 = null,
+
+/// contents
+contents: ?[]u8 = null,
+
+/// loader
+loader: ?Loader = null,
+
+/// options
+options: ?TransformOptions = null,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Transform {
+var obj = std.mem.zeroes(Transform);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Transform, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+      var length: usize = 0;
+  while(true) {
+    const field_type: u8 = try reader.readByte(); 
+    switch (field_type) {
+      0 => { return; },
+
+     1 => {
+      result.handle = try FileHandle.decode(allocator, reader);
+},
+     2 => {
+      length = try reader.readIntNative(u32);
+      if ((result.path orelse &([_]u8{})).len != length) {
+      result.path = try allocator.alloc(u8, length);
+      }
+      _ = try reader.readAll(result.path.?);
+},
+     3 => {
+      length = try reader.readIntNative(u32);
+      if ((result.contents orelse &([_]u8{})).len != length) {
+      result.contents = try allocator.alloc(u8, length);
+      }
+      _ = try reader.readAll(result.contents.?);
+},
+     4 => {
+      result.loader = try reader.readEnum(Loader, .Little);
+},
+     5 => {
+      result.options = try TransformOptions.decode(allocator, reader);
+},
+    else => {
+      return error.InvalidMessage;
+    }
+  }}
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+  if (result.handle) |handle| {
+    try writer.writeByte(1);
+    try handle.encode(writer);
+   }
+
+  if (result.path) |path| {
+    try writer.writeByte(2);
+    try writer.writeIntNative(u32, @intCast(u32, path.len));
+    try writer.writeAll(std.mem.sliceAsBytes(path));
+   }
+
+  if (result.contents) |contents| {
+    try writer.writeByte(3);
+    try writer.writeIntNative(u32, @intCast(u32, contents.len));
+    try writer.writeAll(std.mem.sliceAsBytes(contents));
+   }
+
+  if (result.loader) |loader| {
+    try writer.writeByte(4);
+    try writer.writeIntNative(@TypeOf(@enumToInt(result.loader orelse unreachable)), @enumToInt(result.loader orelse unreachable));
+   }
+
+  if (result.options) |options| {
+    try writer.writeByte(5);
+    try options.encode(writer);
+   }
+  try writer.writeByte(0);
+  return;
+}
+
+};
+
+pub const TransformResponseStatus = enum(u32) {
+
+_none,
+  /// success
+  success,
+
+  /// fail
+  fail,
+
+_,
+
+                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+                    return try std.json.stringify(@tagName(self), opts, o);
                 }
-            }
-            return;
-        }
-
-        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
-            var n: usize = 0;
-            try writer.writeIntNative(u32, result.warnings);
-
-            try writer.writeIntNative(u32, result.errors);
-
-            n = result.msgs.len;
-            _ = try writer.writeIntNative(u32, @intCast(u32, n));
-            {
-                var j: usize = 0;
-                while (j < n) : (j += 1) {
-                    try result.msgs[j].encode(writer);
+
+                
+};
+
+pub const OutputFile = struct {
+/// data
+data: []u8,
+
+/// path
+path: []u8,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!OutputFile {
+var obj = std.mem.zeroes(OutputFile);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *OutputFile, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  _ = try reader.readAll(result.data);
+  length = try reader.readIntNative(u32);
+  if (result.path.len != length) {
+  result.path = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.path);
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+   try writer.writeAll(result.data);
+
+    try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.path));
+  return;
+}
+
+};
+
+pub const TransformResponse = struct {
+/// status
+status: TransformResponseStatus,
+
+/// files
+files: []OutputFile,
+
+/// errors
+errors: []Message,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformResponse {
+var obj = std.mem.zeroes(TransformResponse);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *TransformResponse, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  result.status = try reader.readEnum(TransformResponseStatus, .Little);
+  length = try reader.readIntNative(u32);
+  result.files = try allocator.alloc(OutputFile, length);
+  {
+  var j: usize = 0;
+  while(j < length) : (j += 1) {
+     result.files[j] = try OutputFile.decode(allocator, reader);
+  }}
+  length = try reader.readIntNative(u32);
+  result.errors = try allocator.alloc(Message, length);
+  {
+  var j: usize = 0;
+  while(j < length) : (j += 1) {
+     result.errors[j] = try Message.decode(allocator, reader);
+  }}
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    var n: usize = 0;
+    try writer.writeIntNative(@TypeOf(@enumToInt(result.status)), @enumToInt(result.status));
+
+    n = result.files.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+      try result.files[j].encode(writer);
+     
+    }}
+
+    n = result.errors.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+      try result.errors[j].encode(writer);
+     
+    }}
+  return;
+}
+
+};
+
+pub const MessageKind = enum(u32) {
+
+_none,
+  /// err
+  err,
+
+  /// warn
+  warn,
+
+  /// note
+  note,
+
+  /// debug
+  debug,
+
+_,
+
+                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+                    return try std.json.stringify(@tagName(self), opts, o);
                 }
-            }
-            return;
-        }
-    };
+
+                
+};
+
+pub const Location = struct {
+/// file
+file: []u8,
+
+/// namespace
+namespace: []u8,
+
+/// line
+line: i32 = 0,
+
+/// column
+column: i32 = 0,
+
+/// line_text
+line_text: []u8,
+
+/// suggestion
+suggestion: []u8,
+
+/// offset
+offset: u32 = 0,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Location {
+var obj = std.mem.zeroes(Location);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Location, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  length = try reader.readIntNative(u32);
+  if (result.file.len != length) {
+  result.file = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.file);
+  length = try reader.readIntNative(u32);
+  if (result.namespace.len != length) {
+  result.namespace = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.namespace);
+  _ = try reader.readAll(std.mem.asBytes(&result.line));
+  _ = try reader.readAll(std.mem.asBytes(&result.column));
+  length = try reader.readIntNative(u32);
+  if (result.line_text.len != length) {
+  result.line_text = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.line_text);
+  length = try reader.readIntNative(u32);
+  if (result.suggestion.len != length) {
+  result.suggestion = try allocator.alloc(u8, length);
+  }
+  _ = try reader.readAll(result.suggestion);
+  _ = try reader.readAll(std.mem.asBytes(&result.offset));
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    try writer.writeIntNative(u32, @intCast(u32, result.file.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.file));
+
+    try writer.writeIntNative(u32, @intCast(u32, result.namespace.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.namespace));
+
+    try writer.writeIntNative(i32, result.line);
+
+    try writer.writeIntNative(i32, result.column);
+
+    try writer.writeIntNative(u32, @intCast(u32, result.line_text.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.line_text));
+
+    try writer.writeIntNative(u32, @intCast(u32, result.suggestion.len));
+    try writer.writeAll(std.mem.sliceAsBytes(result.suggestion));
+
+    try writer.writeIntNative(u32, result.offset);
+  return;
+}
+
 };
+
+pub const MessageData = struct {
+/// text
+text: ?[]u8 = null,
+
+/// location
+location: ?Location = null,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!MessageData {
+var obj = std.mem.zeroes(MessageData);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *MessageData, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+      var length: usize = 0;
+  while(true) {
+    const field_type: u8 = try reader.readByte(); 
+    switch (field_type) {
+      0 => { return; },
+
+     1 => {
+      length = try reader.readIntNative(u32);
+      if ((result.text orelse &([_]u8{})).len != length) {
+      result.text = try allocator.alloc(u8, length);
+      }
+      _ = try reader.readAll(result.text.?);
+},
+     2 => {
+      result.location = try Location.decode(allocator, reader);
+},
+    else => {
+      return error.InvalidMessage;
+    }
+  }}
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+  if (result.text) |text| {
+    try writer.writeByte(1);
+    try writer.writeIntNative(u32, @intCast(u32, text.len));
+    try writer.writeAll(std.mem.sliceAsBytes(text));
+   }
+
+  if (result.location) |location| {
+    try writer.writeByte(2);
+    try location.encode(writer);
+   }
+  try writer.writeByte(0);
+  return;
+}
+
+};
+
+pub const Message = struct {
+/// kind
+kind: MessageKind,
+
+/// data
+data: MessageData,
+
+/// notes
+notes: []MessageData,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Message {
+var obj = std.mem.zeroes(Message);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Message, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  result.kind = try reader.readEnum(MessageKind, .Little);
+  result.data = try MessageData.decode(allocator, reader);
+  length = try reader.readIntNative(u32);
+  result.notes = try allocator.alloc(MessageData, length);
+  {
+  var j: usize = 0;
+  while(j < length) : (j += 1) {
+     result.notes[j] = try MessageData.decode(allocator, reader);
+  }}
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    var n: usize = 0;
+    try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
+
+    try result.data.encode(writer);
+
+    n = result.notes.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+      try result.notes[j].encode(writer);
+     
+    }}
+  return;
+}
+
+};
+
+pub const Log = struct {
+/// warnings
+warnings: u32 = 0,
+
+/// errors
+errors: u32 = 0,
+
+/// msgs
+msgs: []Message,
+
+
+pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Log {
+var obj = std.mem.zeroes(Log);
+try update(&obj, allocator, reader);
+return obj;
+}
+pub fn update(result: *Log, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+
+  var length: usize = 0;
+  _ = try reader.readAll(std.mem.asBytes(&result.warnings));
+  _ = try reader.readAll(std.mem.asBytes(&result.errors));
+  length = try reader.readIntNative(u32);
+  result.msgs = try allocator.alloc(Message, length);
+  {
+  var j: usize = 0;
+  while(j < length) : (j += 1) {
+     result.msgs[j] = try Message.decode(allocator, reader);
+  }}
+  return;
+}
+
+pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+
+    var n: usize = 0;
+    try writer.writeIntNative(u32, result.warnings);
+
+    try writer.writeIntNative(u32, result.errors);
+
+    n = result.msgs.len;
+    _ = try writer.writeIntNative(u32, @intCast(u32, n));
+    {
+ var j: usize = 0;
+   while (j < n) : (j += 1) {
+      try result.msgs[j].encode(writer);
+     
+    }}
+  return;
+}
+
+};
+
+
+};
\ No newline at end of file