Support live-reload and fallback

Former-commit-id: c3f9d77391589b65951616a632af87107fba469f

4 files changed, 258 insertions, 2 deletions

diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index 367932105..a15f7b878 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -119,6 +119,19 @@ type uint32 = number;
     4: "debug",
     debug: "debug"
   }
+  export enum Reloader {
+    disable = 1,
+    live = 2,
+    fast_refresh = 3
+  }
+  export const ReloaderKeys = {
+    1: "disable",
+    disable: "disable",
+    2: "live",
+    live: "live",
+    3: "fast_refresh",
+    fast_refresh: "fast_refresh"
+  }
   export enum WebsocketMessageKind {
     welcome = 1,
     file_change_notification = 2,
@@ -301,6 +314,7 @@ type uint32 = number;
 
   export interface WebsocketMessageWelcome {
     epoch: uint32;
+    javascriptReloader: Reloader;
   }
 
   export interface WebsocketMessageFileChangeNotification {
@@ -341,6 +355,21 @@ type uint32 = number;
     ids: Uint32Array;
   }
 
+  export interface FileList {
+    ptrs: StringPointer[];
+    files: string;
+  }
+
+  export interface WebsocketMessageResolveIDs {
+    id: Uint32Array;
+    list: FileList;
+  }
+
+  export interface WebsocketCommandResolveIDs {
+    ptrs: StringPointer[];
+    files: string;
+  }
+
   export interface WebsocketMessageManifestSuccess {
     id: uint32;
     module_path: string;
@@ -411,6 +440,12 @@ type uint32 = number;
   export declare function decodeWebsocketMessageBuildFailure(buffer: ByteBuffer): WebsocketMessageBuildFailure;
   export declare function  encodeDependencyManifest(message: DependencyManifest, bb: ByteBuffer): void;
   export declare function decodeDependencyManifest(buffer: ByteBuffer): DependencyManifest;
+  export declare function  encodeFileList(message: FileList, bb: ByteBuffer): void;
+  export declare function decodeFileList(buffer: ByteBuffer): FileList;
+  export declare function  encodeWebsocketMessageResolveIDs(message: WebsocketMessageResolveIDs, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageResolveIDs(buffer: ByteBuffer): WebsocketMessageResolveIDs;
+  export declare function  encodeWebsocketCommandResolveIDs(message: WebsocketCommandResolveIDs, bb: ByteBuffer): void;
+  export declare function decodeWebsocketCommandResolveIDs(buffer: ByteBuffer): WebsocketCommandResolveIDs;
   export declare function  encodeWebsocketMessageManifestSuccess(message: WebsocketMessageManifestSuccess, bb: ByteBuffer): void;
   export declare function decodeWebsocketMessageManifestSuccess(buffer: ByteBuffer): WebsocketMessageManifestSuccess;
   export declare function  encodeWebsocketMessageManifestFailure(message: WebsocketMessageManifestFailure, bb: ByteBuffer): void;
diff --git a/src/api/schema.js b/src/api/schema.js
index f460064e5..c4341c1d4 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -1236,6 +1236,22 @@ function encodeLog(message, bb) {
   }
 
 }
+const Reloader = {
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "disable": 1,
+  "live": 2,
+  "fast_refresh": 3
+};
+const ReloaderKeys = {
+  "1": "disable",
+  "2": "live",
+  "3": "fast_refresh",
+  "disable": "disable",
+  "live": "live",
+  "fast_refresh": "fast_refresh"
+};
 const WebsocketMessageKind = {
   "1": 1,
   "2": 2,
@@ -1309,6 +1325,7 @@ function decodeWebsocketMessageWelcome(bb) {
   var result = {};
 
   result["epoch"] = bb.readUint32();
+  result["javascriptReloader"] = Reloader[bb.readByte()];
   return result;
 }
 
@@ -1321,6 +1338,15 @@ function encodeWebsocketMessageWelcome(message, bb) {
     throw new Error("Missing required field \"epoch\"");
   }
 
+  var value = message["javascriptReloader"];
+  if (value != null) {
+    var encoded = Reloader[value];
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Reloader\"");
+bb.writeByte(encoded);
+  } else {
+    throw new Error("Missing required field \"javascriptReloader\"");
+  }
+
 }
 
 function decodeWebsocketMessageFileChangeNotification(bb) {
@@ -1537,6 +1563,98 @@ function encodeDependencyManifest(message, bb) {
 
 }
 
+function decodeFileList(bb) {
+  var result = {};
+
+  var length = bb.readVarUint();
+  var values = result["ptrs"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
+  result["files"] = bb.readString();
+  return result;
+}
+
+function encodeFileList(message, bb) {
+
+  var value = message["ptrs"];
+  if (value != null) {
+    var values = value, n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeStringPointer(value, bb);
+    }
+  } else {
+    throw new Error("Missing required field \"ptrs\"");
+  }
+
+  var value = message["files"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error("Missing required field \"files\"");
+  }
+
+}
+
+function decodeWebsocketMessageResolveIDs(bb) {
+  var result = {};
+
+  result["id"] = bb.readUint32ByteArray();
+  result["list"] = decodeFileList(bb);
+  return result;
+}
+
+function encodeWebsocketMessageResolveIDs(message, bb) {
+
+  var value = message["id"];
+  if (value != null) {
+   bb.writeUint32ByteArray(value);
+  } else {
+    throw new Error("Missing required field \"id\"");
+  }
+
+  var value = message["list"];
+  if (value != null) {
+    encodeFileList(value, bb);
+  } else {
+    throw new Error("Missing required field \"list\"");
+  }
+
+}
+
+function decodeWebsocketCommandResolveIDs(bb) {
+  var result = {};
+
+  var length = bb.readVarUint();
+  var values = result["ptrs"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
+  result["files"] = bb.readString();
+  return result;
+}
+
+function encodeWebsocketCommandResolveIDs(message, bb) {
+
+  var value = message["ptrs"];
+  if (value != null) {
+    var values = value, n = values.length;
+    bb.writeVarUint(n);
+    for (var i = 0; i < n; i++) {
+      value = values[i];
+      encodeStringPointer(value, bb);
+    }
+  } else {
+    throw new Error("Missing required field \"ptrs\"");
+  }
+
+  var value = message["files"];
+  if (value != null) {
+    bb.writeString(value);
+  } else {
+    throw new Error("Missing required field \"files\"");
+  }
+
+}
+
 function decodeWebsocketMessageManifestSuccess(bb) {
   var result = {};
 
@@ -1679,6 +1797,8 @@ export { decodeMessage }
 export { encodeMessage }
 export { decodeLog }
 export { encodeLog }
+export { Reloader }
+export { ReloaderKeys }
 export { WebsocketMessageKind }
 export { WebsocketMessageKindKeys }
 export { WebsocketCommandKind }
@@ -1701,6 +1821,12 @@ export { decodeWebsocketMessageBuildFailure }
 export { encodeWebsocketMessageBuildFailure }
 export { decodeDependencyManifest }
 export { encodeDependencyManifest }
+export { decodeFileList }
+export { encodeFileList }
+export { decodeWebsocketMessageResolveIDs }
+export { encodeWebsocketMessageResolveIDs }
+export { decodeWebsocketCommandResolveIDs }
+export { encodeWebsocketCommandResolveIDs }
 export { decodeWebsocketMessageManifestSuccess }
 export { encodeWebsocketMessageManifestSuccess }
 export { decodeWebsocketMessageManifestFailure }
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index 477ce5d0b..74050e90f 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -235,9 +235,17 @@ struct Log {
 }
 
 
+smol Reloader {
+  disable = 1;
+  // equivalent of CMD + R 
+  live = 2;
+  // React Fast Refresh
+  fast_refresh = 3;
+}
+
 // The WebSocket protocol
 // Server: "hey, this file changed. Does anyone want it?"
-// Client: *checks hash table* "uhh yeah, ok. rebuild that for me"
+// Browser: *checks array* "uhh yeah, ok. rebuild that for me"
 // Server: "here u go"
 // This makes the client responsible for tracking which files it needs to listen for.
 // From a server perspective, this means the filesystem watching thread can send the same WebSocket message
@@ -267,6 +275,7 @@ struct WebsocketMessage {
 // This is the first.
 struct WebsocketMessageWelcome {
   uint32 epoch;
+  Reloader javascriptReloader;
 }
 
 struct WebsocketMessageFileChangeNotification {
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 00460fcc6..8227f5e88 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1271,6 +1271,24 @@ pub const Api = struct {
         }
     };
 
+    pub const Reloader = enum(u8) {
+        _none,
+        /// disable
+        disable,
+
+        /// live
+        live,
+
+        /// fast_refresh
+        fast_refresh,
+
+        _,
+
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
+
     pub const WebsocketMessageKind = enum(u8) {
         _none,
         /// welcome
@@ -1334,19 +1352,24 @@ pub const Api = struct {
         }
     };
 
-    pub const WebsocketMessageWelcome = packed struct {
+    pub const WebsocketMessageWelcome = struct {
         /// epoch
         epoch: u32 = 0,
 
+        /// javascriptReloader
+        javascript_reloader: Reloader,
+
         pub fn decode(reader: anytype) anyerror!WebsocketMessageWelcome {
             var this = std.mem.zeroes(WebsocketMessageWelcome);
 
             this.epoch = try reader.readValue(u32);
+            this.javascript_reloader = try reader.readValue(Reloader);
             return this;
         }
 
         pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
             try writer.writeInt(this.epoch);
+            try writer.writeEnum(this.javascript_reloader);
         }
     };
 
@@ -1512,6 +1535,69 @@ pub const Api = struct {
         }
     };
 
+    pub const FileList = struct {
+        /// ptrs
+        ptrs: []const StringPointer,
+
+        /// files
+        files: []const u8,
+
+        pub fn decode(reader: anytype) anyerror!FileList {
+            var this = std.mem.zeroes(FileList);
+
+            this.ptrs = try reader.readArray(StringPointer);
+            this.files = try reader.readValue([]const u8);
+            return this;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(StringPointer, this.ptrs);
+            try writer.writeValue(this.files);
+        }
+    };
+
+    pub const WebsocketMessageResolveIDs = struct {
+        /// id
+        id: []const u32,
+
+        /// list
+        list: FileList,
+
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageResolveIDs {
+            var this = std.mem.zeroes(WebsocketMessageResolveIDs);
+
+            this.id = try reader.readArray(u32);
+            this.list = try reader.readValue(FileList);
+            return this;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(u32, this.id);
+            try writer.writeValue(this.list);
+        }
+    };
+
+    pub const WebsocketCommandResolveIDs = struct {
+        /// ptrs
+        ptrs: []const StringPointer,
+
+        /// files
+        files: []const u8,
+
+        pub fn decode(reader: anytype) anyerror!WebsocketCommandResolveIDs {
+            var this = std.mem.zeroes(WebsocketCommandResolveIDs);
+
+            this.ptrs = try reader.readArray(StringPointer);
+            this.files = try reader.readValue([]const u8);
+            return this;
+        }
+
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(StringPointer, this.ptrs);
+            try writer.writeValue(this.files);
+        }
+    };
+
     pub const WebsocketMessageManifestSuccess = struct {
         /// id
         id: u32 = 0,