4 files changed, 926 insertions, 0 deletions

diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index 23eafa37b..2162d6901 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -73,6 +73,26 @@ type uint32 = number;
     2: "classic",
     classic: "classic"
   }
+  export enum ScanDependencyMode {
+    app = 1,
+    all = 2
+  }
+  export const ScanDependencyModeKeys = {
+    1: "app",
+    app: "app",
+    2: "all",
+    all: "all"
+  }
+  export enum ModuleImportType {
+    import = 1,
+    require = 2
+  }
+  export const ModuleImportTypeKeys = {
+    1: "import",
+    import: "import",
+    2: "require",
+    require: "require"
+  }
   export enum TransformResponseStatus {
     success = 1,
     fail = 2
@@ -108,6 +128,52 @@ type uint32 = number;
     react_fast_refresh: boolean;
   }
 
+  export interface StringPointer {
+    offset: uint32;
+    length: uint32;
+  }
+
+  export interface JavascriptBundledModule {
+    path: StringPointer;
+    code: StringPointer;
+    package_id: uint32;
+  }
+
+  export interface JavascriptBundledPackage {
+    name: StringPointer;
+    version: StringPointer;
+    hash: uint32;
+    modules_offset: uint32;
+    modules_length: uint32;
+  }
+
+  export interface JavascriptBundle {
+    modules: JavascriptBundledModule[];
+    packages: JavascriptBundledPackage[];
+    etag: Uint8Array;
+    generated_at: uint32;
+    app_package_json_dependencies_hash: Uint8Array;
+    import_from_name: Uint8Array;
+    manifest_string: Uint8Array;
+  }
+
+  export interface JavascriptBundleContainer {
+    bundle_format_version?: uint32;
+    bundle?: JavascriptBundle;
+    code_length?: uint32;
+  }
+
+  export interface ModuleImportRecord {
+    kind: ModuleImportType;
+    path: string;
+    dynamic: boolean;
+  }
+
+  export interface Module {
+    path: string;
+    imports: ModuleImportRecord[];
+  }
+
   export interface TransformOptions {
     jsx?: JSX;
     tsconfig_override?: string;
@@ -129,6 +195,8 @@ type uint32 = number;
     serve?: boolean;
     extension_order?: string[];
     public_dir?: string;
+    only_scan_dependencies?: ScanDependencyMode;
+    generate_node_module_bundle?: boolean;
   }
 
   export interface FileHandle {
@@ -185,6 +253,20 @@ type uint32 = number;
 
   export declare function  encodeJSX(message: JSX, bb: ByteBuffer): void;
   export declare function decodeJSX(buffer: ByteBuffer): JSX;
+  export declare function  encodeStringPointer(message: StringPointer, bb: ByteBuffer): void;
+  export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
+  export declare function  encodeJavascriptBundledModule(message: JavascriptBundledModule, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundledModule(buffer: ByteBuffer): JavascriptBundledModule;
+  export declare function  encodeJavascriptBundledPackage(message: JavascriptBundledPackage, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundledPackage(buffer: ByteBuffer): JavascriptBundledPackage;
+  export declare function  encodeJavascriptBundle(message: JavascriptBundle, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundle(buffer: ByteBuffer): JavascriptBundle;
+  export declare function  encodeJavascriptBundleContainer(message: JavascriptBundleContainer, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundleContainer(buffer: ByteBuffer): JavascriptBundleContainer;
+  export declare function  encodeModuleImportRecord(message: ModuleImportRecord, bb: ByteBuffer): void;
+  export declare function decodeModuleImportRecord(buffer: ByteBuffer): ModuleImportRecord;
+  export declare function  encodeModule(message: Module, bb: ByteBuffer): void;
+  export declare function decodeModule(buffer: ByteBuffer): Module;
   export declare function  encodeTransformOptions(message: TransformOptions, bb: ByteBuffer): void;
   export declare function decodeTransformOptions(buffer: ByteBuffer): TransformOptions;
   export declare function  encodeFileHandle(message: FileHandle, bb: ByteBuffer): void;
diff --git a/src/api/schema.js b/src/api/schema.js
index 0d7d942b3..96d3b54fd 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -135,6 +135,338 @@ bb.writeByte(encoded);
 
 }
 
+function decodeStringPointer(bb) {
+  var result = {};
+
+  result["offset"] = bb.readUint32();
+  result["length"] = bb.readUint32();
+  return result;
+}
+
+function encodeStringPointer(message, bb) {
+
+  var value = message["offset"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"offset\"");
+  }
+
+  var value = message["length"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"length\"");
+  }
+
+}
+
+function decodeJavascriptBundledModule(bb) {
+  var result = {};
+
+  result["path"] = decodeStringPointer(bb);
+  result["code"] = decodeStringPointer(bb);
+  result["package_id"] = bb.readUint32();
+  return result;
+}
+
+function encodeJavascriptBundledModule(message, bb) {
+
+  var value = message["path"];
+  if (value != null) {
+    encodeStringPointer(value, bb);
+  } else {
+    throw new Error("Missing required field \"path\"");
+  }
+
+  var value = message["code"];
+  if (value != null) {
+    encodeStringPointer(value, bb);
+  } else {
+    throw new Error("Missing required field \"code\"");
+  }
+
+  var value = message["package_id"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"package_id\"");
+  }
+
+}
+
+function decodeJavascriptBundledPackage(bb) {
+  var result = {};
+
+  result["name"] = decodeStringPointer(bb);
+  result["version"] = decodeStringPointer(bb);
+  result["hash"] = bb.readUint32();
+  result["modules_offset"] = bb.readUint32();
+  result["modules_length"] = bb.readUint32();
+  return result;
+}
+
+function encodeJavascriptBundledPackage(message, bb) {
+
+  var value = message["name"];
+  if (value != null) {
+    encodeStringPointer(value, bb);
+  } else {
+    throw new Error("Missing required field \"name\"");
+  }
+
+  var value = message["version"];
+  if (value != null) {
+    encodeStringPointer(value, bb);
+  } else {
+    throw new Error("Missing required field \"version\"");
+  }
+
+  var value = message["hash"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"hash\"");
+  }
+
+  var value = message["modules_offset"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"modules_offset\"");
+  }
+
+  var value = message["modules_length"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"modules_length\"");
+  }
+
+}
+
+function decodeJavascriptBundle(bb) {
+  var result = {};
+
+  var length = bb.readVarUint();
+  var values = result["modules"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledModule(bb);
+  var length = bb.readVarUint();
+  var values = result["packages"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledPackage(bb);
+  result["etag"] = bb.readByteArray();
+  result["generated_at"] = bb.readUint32();
+  result["app_package_json_dependencies_hash"] = bb.readByteArray();
+  result["import_from_name"] = bb.readByteArray();
+  result["manifest_string"] = bb.readByteArray();
+  return result;
+}
+
+function encodeJavascriptBundle(message, bb) {
+
+  var value = message["modules"];
+  if (value != null) {
+    var values = value, n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeJavascriptBundledModule(value, bb);
+    }
+  } else {
+    throw new Error("Missing required field \"modules\"");
+  }
+
+  var value = message["packages"];
+  if (value != null) {
+    var values = value, n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeJavascriptBundledPackage(value, bb);
+    }
+  } else {
+    throw new Error("Missing required field \"packages\"");
+  }
+
+  var value = message["etag"];
+  if (value != null) {
+   bb.writeByteArray(value);
+  } else {
+    throw new Error("Missing required field \"etag\"");
+  }
+
+  var value = message["generated_at"];
+  if (value != null) {
+    bb.writeUint32(value);
+  } else {
+    throw new Error("Missing required field \"generated_at\"");
+  }
+
+  var value = message["app_package_json_dependencies_hash"];
+  if (value != null) {
+   bb.writeByteArray(value);
+  } else {
+    throw new Error("Missing required field \"app_package_json_dependencies_hash\"");
+  }
+
+  var value = message["import_from_name"];
+  if (value != null) {
+   bb.writeByteArray(value);
+  } else {
+    throw new Error("Missing required field \"import_from_name\"");
+  }
+
+  var value = message["manifest_string"];
+  if (value != null) {
+   bb.writeByteArray(value);
+  } else {
+    throw new Error("Missing required field \"manifest_string\"");
+  }
+
+}
+
+function decodeJavascriptBundleContainer(bb) {
+  var result = {};
+
+  while (true) {
+    switch (bb.readByte()) {
+    case 0:
+      return result;
+
+    case 1:
+      result["bundle_format_version"] = bb.readUint32();
+      break;
+
+    case 2:
+      result["bundle"] = decodeJavascriptBundle(bb);
+      break;
+
+    case 3:
+      result["code_length"] = bb.readUint32();
+      break;
+
+    default:
+      throw new Error("Attempted to parse invalid message");
+    }
+  }
+}
+
+function encodeJavascriptBundleContainer(message, bb) {
+
+  var value = message["bundle_format_version"];
+  if (value != null) {
+    bb.writeByte(1);
+    bb.writeUint32(value);
+  }
+
+  var value = message["bundle"];
+  if (value != null) {
+    bb.writeByte(2);
+    encodeJavascriptBundle(value, bb);
+  }
+
+  var value = message["code_length"];
+  if (value != null) {
+    bb.writeByte(3);
+    bb.writeUint32(value);
+  }
+  bb.writeByte(0);
+
+}
+const ScanDependencyMode = {
+  "1": 1,
+  "2": 2,
+  "app": 1,
+  "all": 2
+};
+const ScanDependencyModeKeys = {
+  "1": "app",
+  "2": "all",
+  "app": "app",
+  "all": "all"
+};
+const ModuleImportType = {
+  "1": 1,
+  "2": 2,
+  "import": 1,
+  "require": 2
+};
+const ModuleImportTypeKeys = {
+  "1": "import",
+  "2": "require",
+  "import": "import",
+  "require": "require"
+};
+
+function decodeModuleImportRecord(bb) {
+  var result = {};
+
+  result["kind"] = ModuleImportType[bb.readByte()];
+  result["path"] = bb.readString();
+  result["dynamic"] = !!bb.readByte();
+  return result;
+}
+
+function encodeModuleImportRecord(message, bb) {
+
+  var value = message["kind"];
+  if (value != null) {
+    var encoded = ModuleImportType[value];
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ModuleImportType\"");
+bb.writeByte(encoded);
+  } else {
+    throw new Error("Missing required field \"kind\"");
+  }
+
+  var value = message["path"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error("Missing required field \"path\"");
+  }
+
+  var value = message["dynamic"];
+  if (value != null) {
+    bb.writeByte(value);
+  } else {
+    throw new Error("Missing required field \"dynamic\"");
+  }
+
+}
+
+function decodeModule(bb) {
+  var result = {};
+
+  result["path"] = bb.readString();
+  var length = bb.readVarUint();
+  var values = result["imports"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeModuleImportRecord(bb);
+  return result;
+}
+
+function encodeModule(message, bb) {
+
+  var value = message["path"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error("Missing required field \"path\"");
+  }
+
+  var value = message["imports"];
+  if (value != null) {
+    var values = value, n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeModuleImportRecord(value, bb);
+    }
+  } else {
+    throw new Error("Missing required field \"imports\"");
+  }
+
+}
+
 function decodeTransformOptions(bb) {
   var result = {};
 
@@ -241,6 +573,14 @@ function decodeTransformOptions(bb) {
       result["public_dir"] = bb.readString();
       break;
 
+    case 21:
+      result["only_scan_dependencies"] = ScanDependencyMode[bb.readByte()];
+      break;
+
+    case 22:
+      result["generate_node_module_bundle"] = !!bb.readByte();
+      break;
+
     default:
       throw new Error("Attempted to parse invalid message");
     }
@@ -419,6 +759,20 @@ bb.writeByte(encoded);
     bb.writeByte(20);
     bb.writeString(value);
   }
+
+  var value = message["only_scan_dependencies"];
+  if (value != null) {
+    bb.writeByte(21);
+    var encoded = ScanDependencyMode[value];
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ScanDependencyMode\"");
+bb.writeByte(encoded);
+  }
+
+  var value = message["generate_node_module_bundle"];
+  if (value != null) {
+    bb.writeByte(22);
+    bb.writeByte(value);
+  }
   bb.writeByte(0);
 
 }
@@ -835,6 +1189,24 @@ export { JSXRuntime }
 export { JSXRuntimeKeys }
 export { decodeJSX }
 export { encodeJSX }
+export { decodeStringPointer }
+export { encodeStringPointer }
+export { decodeJavascriptBundledModule }
+export { encodeJavascriptBundledModule }
+export { decodeJavascriptBundledPackage }
+export { encodeJavascriptBundledPackage }
+export { decodeJavascriptBundle }
+export { encodeJavascriptBundle }
+export { decodeJavascriptBundleContainer }
+export { encodeJavascriptBundleContainer }
+export { ScanDependencyMode }
+export { ScanDependencyModeKeys }
+export { ModuleImportType }
+export { ModuleImportTypeKeys }
+export { decodeModuleImportRecord }
+export { encodeModuleImportRecord }
+export { decodeModule }
+export { encodeModule }
 export { decodeTransformOptions }
 export { encodeTransformOptions }
 export { decodeFileHandle }
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index 9ba51c3d6..1c21c7d5e 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -37,9 +37,73 @@ struct JSX {
   string import_source;
 
   bool react_fast_refresh;
+}
+
+struct StringPointer {
+  uint32 offset;
+  uint32 length;
+}
+
+struct JavascriptBundledModule {
+  // package-relative path including file extension
+  StringPointer path;
+  StringPointer code;
+  uint32 package_id;
+
+}
 
+struct JavascriptBundledPackage {
+  StringPointer name;
+  StringPointer version;
+  uint32 hash;
+
+  uint32 modules_offset;
+  uint32 modules_length;
+}
+
+struct JavascriptBundle {
+  // This has to be sorted by ${package_prefix}path
+  JavascriptBundledModule[] modules;
+  JavascriptBundledPackage[] packages;
+
+  byte[] etag;
+  // this will be a u64, but that data type doesn't exist in this schema format
+  uint32 generated_at;
+  // generated by hashing all ${name}@${version} in sorted order
+  byte[] app_package_json_dependencies_hash;
+  byte[] import_from_name;
+  // This is what StringPointer refers to 
+  byte[] manifest_string;
 }
 
+message JavascriptBundleContainer {
+  uint32 bundle_format_version = 1;
+  JavascriptBundle bundle = 2;
+  // Don't technically need to store this, but it may be helpful as a sanity check
+  uint32 code_length = 3;
+}
+
+smol ScanDependencyMode {
+  app = 1;
+  all = 2;
+}
+
+smol ModuleImportType {
+  import = 1;
+  require = 2;
+}
+
+struct ModuleImportRecord {
+  ModuleImportType kind;
+  string path;
+
+  bool dynamic;
+}
+
+struct Module {
+  string path;
+  ModuleImportRecord[] imports;
+}
 
 message TransformOptions {
   JSX jsx = 1;
@@ -74,6 +138,10 @@ message TransformOptions {
   string[] extension_order = 19;
 
   string public_dir = 20;
+
+  ScanDependencyMode only_scan_dependencies = 21;
+
+  bool generate_node_module_bundle = 22;
 }
 
 struct FileHandle {
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 262c0d01c..54f854db6 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -148,6 +148,388 @@ pub const Api = struct {
         }
     };
 
+    pub const StringPointer = struct {
+        /// offset
+        offset: u32 = 0,
+
+        /// length
+        length: u32 = 0,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!StringPointer {
+            var obj = std.mem.zeroes(StringPointer);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *StringPointer, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            _ = try reader.readAll(std.mem.asBytes(&result.offset));
+            _ = try reader.readAll(std.mem.asBytes(&result.length));
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeIntNative(u32, result.offset);
+
+            try writer.writeIntNative(u32, result.length);
+            return;
+        }
+    };
+
+    pub const JavascriptBundledModule = struct {
+        /// path
+        path: StringPointer,
+
+        /// code
+        code: StringPointer,
+
+        /// package_id
+        package_id: u32 = 0,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!JavascriptBundledModule {
+            var obj = std.mem.zeroes(JavascriptBundledModule);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *JavascriptBundledModule, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            result.path = try StringPointer.decode(allocator, reader);
+            result.code = try StringPointer.decode(allocator, reader);
+            _ = try reader.readAll(std.mem.asBytes(&result.package_id));
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            try result.path.encode(writer);
+
+            try result.code.encode(writer);
+
+            try writer.writeIntNative(u32, result.package_id);
+            return;
+        }
+    };
+
+    pub const JavascriptBundledPackage = struct {
+        /// name
+        name: StringPointer,
+
+        /// version
+        version: StringPointer,
+
+        /// hash
+        hash: u32 = 0,
+
+        /// modules_offset
+        modules_offset: u32 = 0,
+
+        /// modules_length
+        modules_length: u32 = 0,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!JavascriptBundledPackage {
+            var obj = std.mem.zeroes(JavascriptBundledPackage);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *JavascriptBundledPackage, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            result.name = try StringPointer.decode(allocator, reader);
+            result.version = try StringPointer.decode(allocator, reader);
+            _ = try reader.readAll(std.mem.asBytes(&result.hash));
+            _ = try reader.readAll(std.mem.asBytes(&result.modules_offset));
+            _ = try reader.readAll(std.mem.asBytes(&result.modules_length));
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            try result.name.encode(writer);
+
+            try result.version.encode(writer);
+
+            try writer.writeIntNative(u32, result.hash);
+
+            try writer.writeIntNative(u32, result.modules_offset);
+
+            try writer.writeIntNative(u32, result.modules_length);
+            return;
+        }
+    };
+
+    pub const JavascriptBundle = struct {
+        /// modules
+        modules: []JavascriptBundledModule,
+
+        /// packages
+        packages: []JavascriptBundledPackage,
+
+        /// etag
+        etag: []const u8,
+
+        /// generated_at
+        generated_at: u32 = 0,
+
+        /// app_package_json_dependencies_hash
+        app_package_json_dependencies_hash: []const u8,
+
+        /// import_from_name
+        import_from_name: []const u8,
+
+        /// manifest_string
+        manifest_string: []const u8,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!JavascriptBundle {
+            var obj = std.mem.zeroes(JavascriptBundle);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *JavascriptBundle, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            var length: usize = 0;
+            length = try reader.readIntNative(u32);
+            result.modules = try allocator.alloc(JavascriptBundledModule, length);
+            {
+                var j: usize = 0;
+                while (j < length) : (j += 1) {
+                    result.modules[j] = try JavascriptBundledModule.decode(allocator, reader);
+                }
+            }
+            length = try reader.readIntNative(u32);
+            result.packages = try allocator.alloc(JavascriptBundledPackage, length);
+            {
+                var j: usize = 0;
+                while (j < length) : (j += 1) {
+                    result.packages[j] = try JavascriptBundledPackage.decode(allocator, reader);
+                }
+            }
+            length = @intCast(usize, try reader.readIntNative(u32));
+            if (result.etag != length) {
+                result.etag = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.etag);
+            _ = try reader.readAll(std.mem.asBytes(&result.generated_at));
+            length = @intCast(usize, try reader.readIntNative(u32));
+            if (result.app_package_json_dependencies_hash != length) {
+                result.app_package_json_dependencies_hash = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.app_package_json_dependencies_hash);
+            length = @intCast(usize, try reader.readIntNative(u32));
+            if (result.import_from_name != length) {
+                result.import_from_name = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.import_from_name);
+            length = @intCast(usize, try reader.readIntNative(u32));
+            if (result.manifest_string != length) {
+                result.manifest_string = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.manifest_string);
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            var n: usize = 0;
+            n = result.modules.len;
+            _ = try writer.writeIntNative(u32, @intCast(u32, n));
+            {
+                var j: usize = 0;
+                while (j < n) : (j += 1) {
+                    try result.modules[j].encode(writer);
+                }
+            }
+
+            n = result.packages.len;
+            _ = try writer.writeIntNative(u32, @intCast(u32, n));
+            {
+                var j: usize = 0;
+                while (j < n) : (j += 1) {
+                    try result.packages[j].encode(writer);
+                }
+            }
+
+            try writer.writeIntNative(u32, @intCast(u32, result.etag.len));
+            try writer.writeAll(result.etag);
+
+            try writer.writeIntNative(u32, result.generated_at);
+
+            try writer.writeIntNative(u32, @intCast(u32, result.app_package_json_dependencies_hash.len));
+            try writer.writeAll(result.app_package_json_dependencies_hash);
+
+            try writer.writeIntNative(u32, @intCast(u32, result.import_from_name.len));
+            try writer.writeAll(result.import_from_name);
+
+            try writer.writeIntNative(u32, @intCast(u32, result.manifest_string.len));
+            try writer.writeAll(result.manifest_string);
+            return;
+        }
+    };
+
+    pub const JavascriptBundleContainer = struct {
+        /// bundle_format_version
+        bundle_format_version: ?u32 = null,
+
+        /// bundle
+        bundle: ?JavascriptBundle = null,
+
+        /// code_length
+        code_length: ?u32 = null,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!JavascriptBundleContainer {
+            var obj = std.mem.zeroes(JavascriptBundleContainer);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *JavascriptBundleContainer, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            while (true) {
+                const field_type: u8 = try reader.readByte();
+                switch (field_type) {
+                    0 => {
+                        return;
+                    },
+
+                    1 => {
+                        _ = try reader.readAll(std.mem.asBytes(&result.bundle_format_version));
+                    },
+                    2 => {
+                        result.bundle = try JavascriptBundle.decode(allocator, reader);
+                    },
+                    3 => {
+                        _ = try reader.readAll(std.mem.asBytes(&result.code_length));
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            if (result.bundle_format_version) |bundle_format_version| {
+                try writer.writeByte(1);
+                try writer.writeIntNative(u32, bundle_format_version);
+            }
+
+            if (result.bundle) |bundle| {
+                try writer.writeByte(2);
+                try bundle.encode(writer);
+            }
+
+            if (result.code_length) |code_length| {
+                try writer.writeByte(3);
+                try writer.writeIntNative(u32, code_length);
+            }
+            try writer.writeByte(0);
+            return;
+        }
+    };
+
+    pub const ScanDependencyMode = enum(u8) {
+        _none,
+        /// app
+        app,
+
+        /// all
+        all,
+
+        _,
+
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
+
+    pub const ModuleImportType = enum(u8) {
+        _none,
+        /// import
+        import,
+
+        /// require
+        require,
+
+        _,
+
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
+
+    pub const ModuleImportRecord = struct {
+        /// kind
+        kind: ModuleImportType,
+
+        /// path
+        path: []const u8,
+
+        /// dynamic
+        dynamic: bool = false,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!ModuleImportRecord {
+            var obj = std.mem.zeroes(ModuleImportRecord);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *ModuleImportRecord, allocator: *std.mem.Allocator, reader: anytype) anyerror!void {
+            var length: usize = 0;
+            result.kind = try reader.readEnum(ModuleImportType, .Little);
+            length = try reader.readIntNative(u32);
+            if (result.path.len != length) {
+                result.path = try allocator.alloc(u8, length);
+            }
+            _ = try reader.readAll(result.path);
+            result.dynamic = (try reader.readByte()) == @as(u8, 1);
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeIntNative(@TypeOf(@enumToInt(result.kind)), @enumToInt(result.kind));
+
+            try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+            try writer.writeAll(std.mem.sliceAsBytes(result.path));
+
+            try writer.writeByte(@boolToInt(result.dynamic));
+            return;
+        }
+    };
+
+    pub const Module = struct {
+        /// path
+        path: []const u8,
+
+        /// imports
+        imports: []ModuleImportRecord,
+
+        pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!Module {
+            var obj = std.mem.zeroes(Module);
+            try update(&obj, allocator, reader);
+            return obj;
+        }
+        pub fn update(result: *Module, 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);
+            length = try reader.readIntNative(u32);
+            result.imports = try allocator.alloc(ModuleImportRecord, length);
+            {
+                var j: usize = 0;
+                while (j < length) : (j += 1) {
+                    result.imports[j] = try ModuleImportRecord.decode(allocator, reader);
+                }
+            }
+            return;
+        }
+
+        pub fn encode(result: *const @This(), writer: anytype) anyerror!void {
+            var n: usize = 0;
+            try writer.writeIntNative(u32, @intCast(u32, result.path.len));
+            try writer.writeAll(std.mem.sliceAsBytes(result.path));
+
+            n = result.imports.len;
+            _ = try writer.writeIntNative(u32, @intCast(u32, n));
+            {
+                var j: usize = 0;
+                while (j < n) : (j += 1) {
+                    try result.imports[j].encode(writer);
+                }
+            }
+            return;
+        }
+    };
+
     pub const TransformOptions = struct {
         /// jsx
         jsx: ?Jsx = null,
@@ -209,6 +591,12 @@ pub const Api = struct {
         /// public_dir
         public_dir: ?[]const u8 = null,
 
+        /// only_scan_dependencies
+        only_scan_dependencies: ?ScanDependencyMode = null,
+
+        /// generate_node_module_bundle
+        generate_node_module_bundle: ?bool = null,
+
         pub fn decode(allocator: *std.mem.Allocator, reader: anytype) anyerror!TransformOptions {
             var obj = std.mem.zeroes(TransformOptions);
             try update(&obj, allocator, reader);
@@ -408,6 +796,12 @@ pub const Api = struct {
                         }
                         _ = try reader.readAll(result.public_dir.?);
                     },
+                    21 => {
+                        result.only_scan_dependencies = try reader.readEnum(ScanDependencyMode, .Little);
+                    },
+                    22 => {
+                        result.generate_node_module_bundle = (try reader.readByte()) == @as(u8, 1);
+                    },
                     else => {
                         return error.InvalidMessage;
                     },
@@ -592,6 +986,16 @@ pub const Api = struct {
                 try writer.writeIntNative(u32, @intCast(u32, public_dir.len));
                 try writer.writeAll(std.mem.sliceAsBytes(public_dir));
             }
+
+            if (result.only_scan_dependencies) |only_scan_dependencies| {
+                try writer.writeByte(21);
+                try writer.writeIntNative(@TypeOf(@enumToInt(result.only_scan_dependencies orelse unreachable)), @enumToInt(result.only_scan_dependencies orelse unreachable));
+            }
+
+            if (result.generate_node_module_bundle) |generate_node_module_bundle| {
+                try writer.writeByte(22);
+                try writer.writeByte(@boolToInt(generate_node_module_bundle));
+            }
             try writer.writeByte(0);
             return;
         }