Add comprehensive frontend UI and distributed infrastructure

Frontend Enhancements:
- Complete React TypeScript frontend with modern UI components
- Distributed workflows management interface with real-time updates
- Socket.IO integration for live agent status monitoring
- Agent management dashboard with cluster visualization
- Project management interface with metrics and task tracking
- Responsive design with proper error handling and loading states

Backend Infrastructure:
- Distributed coordinator for multi-agent workflow orchestration
- Cluster management API with comprehensive agent operations
- Enhanced database models for agents and projects
- Project service for filesystem-based project discovery
- Performance monitoring and metrics collection
- Comprehensive API documentation and error handling

Documentation:
- Complete distributed development guide (README_DISTRIBUTED.md)
- Comprehensive development report with architecture insights
- System configuration templates and deployment guides

The platform now provides a complete web interface for managing the distributed AI cluster
with real-time monitoring, workflow orchestration, and agent coordination capabilities.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

frontend/node_modules/react-refresh/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frontend/node_modules/react-refresh/README.md

@@ -0,0 +1,5 @@
+# react-refresh
+
+This package implements the wiring necessary to integrate Fast Refresh into bundlers. Fast Refresh is a feature that lets you edit React components in a running application without losing their state. It is similar to an old feature known as "hot reloading", but Fast Refresh is more reliable and officially supported by React.
+
+This package is primarily aimed at developers of bundler plugins. If you’re working on one, here is a [rough guide](https://github.com/facebook/react/issues/16604#issuecomment-528663101) for Fast Refresh integration using this package.

frontend/node_modules/react-refresh/babel.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/react-refresh-babel.production.js');
+} else {
+  module.exports = require('./cjs/react-refresh-babel.development.js');
+}

frontend/node_modules/react-refresh/cjs/react-refresh-babel.development.js

@@ -0,0 +1,601 @@
+/**
+ * @license React
+ * react-refresh-babel.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+"use strict";
+"production" !== process.env.NODE_ENV &&
+  (module.exports = function (babel) {
+    function createRegistration(programPath, persistentID) {
+      var handle = programPath.scope.generateUidIdentifier("c");
+      registrationsByProgramPath.has(programPath) ||
+        registrationsByProgramPath.set(programPath, []);
+      registrationsByProgramPath
+        .get(programPath)
+        .push({ handle: handle, persistentID: persistentID });
+      return handle;
+    }
+    function isComponentishName(name) {
+      return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
+    }
+    function findInnerComponents(inferredName, path, callback) {
+      var node = path.node;
+      switch (node.type) {
+        case "Identifier":
+          if (!isComponentishName(node.name)) break;
+          callback(inferredName, node, null);
+          return !0;
+        case "FunctionDeclaration":
+          return callback(inferredName, node.id, null), !0;
+        case "ArrowFunctionExpression":
+          if ("ArrowFunctionExpression" === node.body.type) break;
+          callback(inferredName, node, path);
+          return !0;
+        case "FunctionExpression":
+          return callback(inferredName, node, path), !0;
+        case "CallExpression":
+          var argsPath = path.get("arguments");
+          if (void 0 === argsPath || 0 === argsPath.length) break;
+          var calleePath = path.get("callee");
+          switch (calleePath.node.type) {
+            case "MemberExpression":
+            case "Identifier":
+              calleePath = calleePath.getSource();
+              if (
+                !findInnerComponents(
+                  inferredName + "$" + calleePath,
+                  argsPath[0],
+                  callback
+                )
+              )
+                return !1;
+              callback(inferredName, node, path);
+              return !0;
+            default:
+              return !1;
+          }
+        case "VariableDeclarator":
+          if (
+            ((argsPath = node.init),
+            null !== argsPath &&
+              ((calleePath = node.id.name), isComponentishName(calleePath)))
+          ) {
+            switch (argsPath.type) {
+              case "ArrowFunctionExpression":
+              case "FunctionExpression":
+                break;
+              case "CallExpression":
+                node = argsPath.callee;
+                var calleeType = node.type;
+                if (
+                  "Import" === calleeType ||
+                  ("Identifier" === calleeType &&
+                    (0 === node.name.indexOf("require") ||
+                      0 === node.name.indexOf("import")))
+                )
+                  return !1;
+                break;
+              case "TaggedTemplateExpression":
+                break;
+              default:
+                return !1;
+            }
+            node = path.get("init");
+            if (findInnerComponents(inferredName, node, callback)) return !0;
+            calleePath = path.scope.getBinding(calleePath);
+            if (void 0 === calleePath) return;
+            path = !1;
+            calleePath = calleePath.referencePaths;
+            for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
+              var ref = calleePath[calleeType];
+              if (
+                !ref.node ||
+                "JSXIdentifier" === ref.node.type ||
+                "Identifier" === ref.node.type
+              ) {
+                ref = ref.parent;
+                if ("JSXOpeningElement" === ref.type) path = !0;
+                else if ("CallExpression" === ref.type) {
+                  ref = ref.callee;
+                  var fnName = void 0;
+                  switch (ref.type) {
+                    case "Identifier":
+                      fnName = ref.name;
+                      break;
+                    case "MemberExpression":
+                      fnName = ref.property.name;
+                  }
+                  switch (fnName) {
+                    case "createElement":
+                    case "jsx":
+                    case "jsxDEV":
+                    case "jsxs":
+                      path = !0;
+                  }
+                }
+                if (path) return callback(inferredName, argsPath, node), !0;
+              }
+            }
+          }
+      }
+      return !1;
+    }
+    function getHookCallsSignature(functionNode) {
+      functionNode = hookCalls.get(functionNode);
+      return void 0 === functionNode
+        ? null
+        : {
+            key: functionNode
+              .map(function (call) {
+                return call.name + "{" + call.key + "}";
+              })
+              .join("\n"),
+            customHooks: functionNode
+              .filter(function (call) {
+                a: switch (call.name) {
+                  case "useState":
+                  case "React.useState":
+                  case "useReducer":
+                  case "React.useReducer":
+                  case "useEffect":
+                  case "React.useEffect":
+                  case "useLayoutEffect":
+                  case "React.useLayoutEffect":
+                  case "useMemo":
+                  case "React.useMemo":
+                  case "useCallback":
+                  case "React.useCallback":
+                  case "useRef":
+                  case "React.useRef":
+                  case "useContext":
+                  case "React.useContext":
+                  case "useImperativeHandle":
+                  case "React.useImperativeHandle":
+                  case "useDebugValue":
+                  case "React.useDebugValue":
+                  case "useId":
+                  case "React.useId":
+                  case "useDeferredValue":
+                  case "React.useDeferredValue":
+                  case "useTransition":
+                  case "React.useTransition":
+                  case "useInsertionEffect":
+                  case "React.useInsertionEffect":
+                  case "useSyncExternalStore":
+                  case "React.useSyncExternalStore":
+                  case "useFormStatus":
+                  case "React.useFormStatus":
+                  case "useFormState":
+                  case "React.useFormState":
+                  case "useActionState":
+                  case "React.useActionState":
+                  case "useOptimistic":
+                  case "React.useOptimistic":
+                    call = !0;
+                    break a;
+                  default:
+                    call = !1;
+                }
+                return !call;
+              })
+              .map(function (call) {
+                return t.cloneDeep(call.callee);
+              })
+          };
+    }
+    function hasForceResetComment(path) {
+      path = path.hub.file;
+      var hasForceReset = hasForceResetCommentByFile.get(path);
+      if (void 0 !== hasForceReset) return hasForceReset;
+      hasForceReset = !1;
+      for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
+        if (-1 !== comments[i].value.indexOf("@refresh reset")) {
+          hasForceReset = !0;
+          break;
+        }
+      hasForceResetCommentByFile.set(path, hasForceReset);
+      return hasForceReset;
+    }
+    function createArgumentsForSignature(node, signature, scope) {
+      var key = signature.key;
+      signature = signature.customHooks;
+      var forceReset = hasForceResetComment(scope.path),
+        customHooksInScope = [];
+      signature.forEach(function (callee) {
+        switch (callee.type) {
+          case "MemberExpression":
+            if ("Identifier" === callee.object.type)
+              var bindingName = callee.object.name;
+            break;
+          case "Identifier":
+            bindingName = callee.name;
+        }
+        scope.hasBinding(bindingName)
+          ? customHooksInScope.push(callee)
+          : (forceReset = !0);
+      });
+      signature = key;
+      "function" !== typeof require ||
+        opts.emitFullSignatures ||
+        (signature = require("crypto")
+          .createHash("sha1")
+          .update(key)
+          .digest("base64"));
+      node = [node, t.stringLiteral(signature)];
+      (forceReset || 0 < customHooksInScope.length) &&
+        node.push(t.booleanLiteral(forceReset));
+      0 < customHooksInScope.length &&
+        node.push(
+          t.functionExpression(
+            null,
+            [],
+            t.blockStatement([
+              t.returnStatement(t.arrayExpression(customHooksInScope))
+            ])
+          )
+        );
+      return node;
+    }
+    function findHOCCallPathsAbove(path) {
+      for (var calls = []; ; ) {
+        if (!path) return calls;
+        var parentPath = path.parentPath;
+        if (!parentPath) return calls;
+        if (
+          "AssignmentExpression" === parentPath.node.type &&
+          path.node === parentPath.node.right
+        )
+          path = parentPath;
+        else if (
+          "CallExpression" === parentPath.node.type &&
+          path.node !== parentPath.node.callee
+        )
+          calls.push(parentPath), (path = parentPath);
+        else return calls;
+      }
+    }
+    var opts =
+      1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
+    if ("function" === typeof babel.env) {
+      var env = babel.env();
+      if ("development" !== env && !opts.skipEnvCheck)
+        throw Error(
+          'React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "' +
+            env +
+            '". If you want to override this check, pass {skipEnvCheck: true} as plugin options.'
+        );
+    }
+    var t = babel.types,
+      refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
+      refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
+      registrationsByProgramPath = new Map(),
+      hasForceResetCommentByFile = new WeakMap(),
+      seenForRegistration = new WeakSet(),
+      seenForSignature = new WeakSet(),
+      seenForOutro = new WeakSet(),
+      hookCalls = new WeakMap(),
+      HookCallsVisitor = {
+        CallExpression: function (path) {
+          var callee = path.node.callee,
+            name = null;
+          switch (callee.type) {
+            case "Identifier":
+              name = callee.name;
+              break;
+            case "MemberExpression":
+              name = callee.property.name;
+          }
+          if (
+            null !== name &&
+            /^use[A-Z]/.test(name) &&
+            ((callee = path.scope.getFunctionParent()), null !== callee)
+          ) {
+            callee = callee.block;
+            hookCalls.has(callee) || hookCalls.set(callee, []);
+            callee = hookCalls.get(callee);
+            var key = "";
+            "VariableDeclarator" === path.parent.type &&
+              (key = path.parentPath.get("id").getSource());
+            var args = path.get("arguments");
+            "useState" === name && 0 < args.length
+              ? (key += "(" + args[0].getSource() + ")")
+              : "useReducer" === name &&
+                1 < args.length &&
+                (key += "(" + args[1].getSource() + ")");
+            callee.push({ callee: path.node.callee, name: name, key: key });
+          }
+        }
+      };
+    return {
+      visitor: {
+        ExportDefaultDeclaration: function (path) {
+          var node = path.node,
+            decl = node.declaration,
+            declPath = path.get("declaration");
+          if (
+            "CallExpression" === decl.type &&
+            !seenForRegistration.has(node)
+          ) {
+            seenForRegistration.add(node);
+            var programPath = path.parentPath;
+            findInnerComponents(
+              "%default%",
+              declPath,
+              function (persistentID, targetExpr, targetPath) {
+                null !== targetPath &&
+                  ((persistentID = createRegistration(
+                    programPath,
+                    persistentID
+                  )),
+                  targetPath.replaceWith(
+                    t.assignmentExpression("=", persistentID, targetExpr)
+                  ));
+              }
+            );
+          }
+        },
+        FunctionDeclaration: {
+          enter: function (path) {
+            var node = path.node,
+              modulePrefix = "";
+            switch (path.parent.type) {
+              case "Program":
+                var insertAfterPath = path;
+                var programPath = path.parentPath;
+                break;
+              case "TSModuleBlock":
+                insertAfterPath = path;
+                programPath = insertAfterPath.parentPath.parentPath;
+                break;
+              case "ExportNamedDeclaration":
+                insertAfterPath = path.parentPath;
+                programPath = insertAfterPath.parentPath;
+                break;
+              case "ExportDefaultDeclaration":
+                insertAfterPath = path.parentPath;
+                programPath = insertAfterPath.parentPath;
+                break;
+              default:
+                return;
+            }
+            if (
+              "TSModuleBlock" === path.parent.type ||
+              "ExportNamedDeclaration" === path.parent.type
+            )
+              for (; "Program" !== programPath.type; ) {
+                if ("TSModuleDeclaration" === programPath.type) {
+                  if (
+                    "Program" !== programPath.parentPath.type &&
+                    "ExportNamedDeclaration" !== programPath.parentPath.type
+                  )
+                    return;
+                  modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+                }
+                programPath = programPath.parentPath;
+              }
+            var id = node.id;
+            null !== id &&
+              ((id = id.name),
+              isComponentishName(id) &&
+                !seenForRegistration.has(node) &&
+                (seenForRegistration.add(node),
+                findInnerComponents(
+                  modulePrefix + id,
+                  path,
+                  function (persistentID, targetExpr) {
+                    persistentID = createRegistration(
+                      programPath,
+                      persistentID
+                    );
+                    insertAfterPath.insertAfter(
+                      t.expressionStatement(
+                        t.assignmentExpression("=", persistentID, targetExpr)
+                      )
+                    );
+                  }
+                )));
+          },
+          exit: function (path) {
+            var node = path.node,
+              id = node.id;
+            if (null !== id) {
+              var signature = getHookCallsSignature(node);
+              if (null !== signature && !seenForSignature.has(node)) {
+                seenForSignature.add(node);
+                node = path.scope.generateUidIdentifier("_s");
+                path.scope.parent.push({
+                  id: node,
+                  init: t.callExpression(refreshSig, [])
+                });
+                path
+                  .get("body")
+                  .unshiftContainer(
+                    "body",
+                    t.expressionStatement(t.callExpression(node, []))
+                  );
+                var insertAfterPath = null;
+                path.find(function (p) {
+                  if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+                });
+                null !== insertAfterPath &&
+                  insertAfterPath.insertAfter(
+                    t.expressionStatement(
+                      t.callExpression(
+                        node,
+                        createArgumentsForSignature(
+                          id,
+                          signature,
+                          insertAfterPath.scope
+                        )
+                      )
+                    )
+                  );
+              }
+            }
+          }
+        },
+        "ArrowFunctionExpression|FunctionExpression": {
+          exit: function (path) {
+            var node = path.node,
+              signature = getHookCallsSignature(node);
+            if (null !== signature && !seenForSignature.has(node)) {
+              seenForSignature.add(node);
+              var sigCallID = path.scope.generateUidIdentifier("_s");
+              path.scope.parent.push({
+                id: sigCallID,
+                init: t.callExpression(refreshSig, [])
+              });
+              "BlockStatement" !== path.node.body.type &&
+                (path.node.body = t.blockStatement([
+                  t.returnStatement(path.node.body)
+                ]));
+              path
+                .get("body")
+                .unshiftContainer(
+                  "body",
+                  t.expressionStatement(t.callExpression(sigCallID, []))
+                );
+              if ("VariableDeclarator" === path.parent.type) {
+                var insertAfterPath = null;
+                path.find(function (p) {
+                  if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+                });
+                null !== insertAfterPath &&
+                  insertAfterPath.insertAfter(
+                    t.expressionStatement(
+                      t.callExpression(
+                        sigCallID,
+                        createArgumentsForSignature(
+                          path.parent.id,
+                          signature,
+                          insertAfterPath.scope
+                        )
+                      )
+                    )
+                  );
+              } else
+                [path]
+                  .concat(findHOCCallPathsAbove(path))
+                  .forEach(function (p) {
+                    p.replaceWith(
+                      t.callExpression(
+                        sigCallID,
+                        createArgumentsForSignature(p.node, signature, p.scope)
+                      )
+                    );
+                  });
+            }
+          }
+        },
+        VariableDeclaration: function (path) {
+          var node = path.node,
+            modulePrefix = "";
+          switch (path.parent.type) {
+            case "Program":
+              var insertAfterPath = path;
+              var programPath = path.parentPath;
+              break;
+            case "TSModuleBlock":
+              insertAfterPath = path;
+              programPath = insertAfterPath.parentPath.parentPath;
+              break;
+            case "ExportNamedDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            case "ExportDefaultDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            default:
+              return;
+          }
+          if (
+            "TSModuleBlock" === path.parent.type ||
+            "ExportNamedDeclaration" === path.parent.type
+          )
+            for (; "Program" !== programPath.type; ) {
+              if ("TSModuleDeclaration" === programPath.type) {
+                if (
+                  "Program" !== programPath.parentPath.type &&
+                  "ExportNamedDeclaration" !== programPath.parentPath.type
+                )
+                  return;
+                modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+              }
+              programPath = programPath.parentPath;
+            }
+          if (
+            !seenForRegistration.has(node) &&
+            (seenForRegistration.add(node),
+            (path = path.get("declarations")),
+            1 === path.length)
+          ) {
+            var declPath = path[0];
+            findInnerComponents(
+              modulePrefix + declPath.node.id.name,
+              declPath,
+              function (persistentID, targetExpr, targetPath) {
+                null !== targetPath &&
+                  ((persistentID = createRegistration(
+                    programPath,
+                    persistentID
+                  )),
+                  "VariableDeclarator" === targetPath.parent.type
+                    ? insertAfterPath.insertAfter(
+                        t.expressionStatement(
+                          t.assignmentExpression(
+                            "=",
+                            persistentID,
+                            declPath.node.id
+                          )
+                        )
+                      )
+                    : targetPath.replaceWith(
+                        t.assignmentExpression("=", persistentID, targetExpr)
+                      ));
+              }
+            );
+          }
+        },
+        Program: {
+          enter: function (path) {
+            path.traverse(HookCallsVisitor);
+          },
+          exit: function (path) {
+            var registrations = registrationsByProgramPath.get(path);
+            if (void 0 !== registrations) {
+              var node = path.node;
+              if (!seenForOutro.has(node)) {
+                seenForOutro.add(node);
+                registrationsByProgramPath.delete(path);
+                var declarators = [];
+                path.pushContainer(
+                  "body",
+                  t.variableDeclaration("var", declarators)
+                );
+                registrations.forEach(function (_ref) {
+                  var handle = _ref.handle;
+                  path.pushContainer(
+                    "body",
+                    t.expressionStatement(
+                      t.callExpression(refreshReg, [
+                        handle,
+                        t.stringLiteral(_ref.persistentID)
+                      ])
+                    )
+                  );
+                  declarators.push(t.variableDeclarator(handle));
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  });

frontend/node_modules/react-refresh/cjs/react-refresh-babel.production.js

@@ -0,0 +1,586 @@
+/**
+ * @license React
+ * react-refresh-babel.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+"use strict";
+module.exports = function (babel) {
+  function createRegistration(programPath, persistentID) {
+    var handle = programPath.scope.generateUidIdentifier("c");
+    registrationsByProgramPath.has(programPath) ||
+      registrationsByProgramPath.set(programPath, []);
+    registrationsByProgramPath
+      .get(programPath)
+      .push({ handle: handle, persistentID: persistentID });
+    return handle;
+  }
+  function isComponentishName(name) {
+    return "string" === typeof name && "A" <= name[0] && "Z" >= name[0];
+  }
+  function findInnerComponents(inferredName, path, callback) {
+    var node = path.node;
+    switch (node.type) {
+      case "Identifier":
+        if (!isComponentishName(node.name)) break;
+        callback(inferredName, node, null);
+        return !0;
+      case "FunctionDeclaration":
+        return callback(inferredName, node.id, null), !0;
+      case "ArrowFunctionExpression":
+        if ("ArrowFunctionExpression" === node.body.type) break;
+        callback(inferredName, node, path);
+        return !0;
+      case "FunctionExpression":
+        return callback(inferredName, node, path), !0;
+      case "CallExpression":
+        var argsPath = path.get("arguments");
+        if (void 0 === argsPath || 0 === argsPath.length) break;
+        var calleePath = path.get("callee");
+        switch (calleePath.node.type) {
+          case "MemberExpression":
+          case "Identifier":
+            calleePath = calleePath.getSource();
+            if (
+              !findInnerComponents(
+                inferredName + "$" + calleePath,
+                argsPath[0],
+                callback
+              )
+            )
+              return !1;
+            callback(inferredName, node, path);
+            return !0;
+          default:
+            return !1;
+        }
+      case "VariableDeclarator":
+        if (
+          ((argsPath = node.init),
+          null !== argsPath &&
+            ((calleePath = node.id.name), isComponentishName(calleePath)))
+        ) {
+          switch (argsPath.type) {
+            case "ArrowFunctionExpression":
+            case "FunctionExpression":
+              break;
+            case "CallExpression":
+              node = argsPath.callee;
+              var calleeType = node.type;
+              if (
+                "Import" === calleeType ||
+                ("Identifier" === calleeType &&
+                  (0 === node.name.indexOf("require") ||
+                    0 === node.name.indexOf("import")))
+              )
+                return !1;
+              break;
+            case "TaggedTemplateExpression":
+              break;
+            default:
+              return !1;
+          }
+          node = path.get("init");
+          if (findInnerComponents(inferredName, node, callback)) return !0;
+          calleePath = path.scope.getBinding(calleePath);
+          if (void 0 === calleePath) return;
+          path = !1;
+          calleePath = calleePath.referencePaths;
+          for (calleeType = 0; calleeType < calleePath.length; calleeType++) {
+            var ref = calleePath[calleeType];
+            if (
+              !ref.node ||
+              "JSXIdentifier" === ref.node.type ||
+              "Identifier" === ref.node.type
+            ) {
+              ref = ref.parent;
+              if ("JSXOpeningElement" === ref.type) path = !0;
+              else if ("CallExpression" === ref.type) {
+                ref = ref.callee;
+                var fnName = void 0;
+                switch (ref.type) {
+                  case "Identifier":
+                    fnName = ref.name;
+                    break;
+                  case "MemberExpression":
+                    fnName = ref.property.name;
+                }
+                switch (fnName) {
+                  case "createElement":
+                  case "jsx":
+                  case "jsxDEV":
+                  case "jsxs":
+                    path = !0;
+                }
+              }
+              if (path) return callback(inferredName, argsPath, node), !0;
+            }
+          }
+        }
+    }
+    return !1;
+  }
+  function getHookCallsSignature(functionNode) {
+    functionNode = hookCalls.get(functionNode);
+    return void 0 === functionNode
+      ? null
+      : {
+          key: functionNode
+            .map(function (call) {
+              return call.name + "{" + call.key + "}";
+            })
+            .join("\n"),
+          customHooks: functionNode
+            .filter(function (call) {
+              a: switch (call.name) {
+                case "useState":
+                case "React.useState":
+                case "useReducer":
+                case "React.useReducer":
+                case "useEffect":
+                case "React.useEffect":
+                case "useLayoutEffect":
+                case "React.useLayoutEffect":
+                case "useMemo":
+                case "React.useMemo":
+                case "useCallback":
+                case "React.useCallback":
+                case "useRef":
+                case "React.useRef":
+                case "useContext":
+                case "React.useContext":
+                case "useImperativeHandle":
+                case "React.useImperativeHandle":
+                case "useDebugValue":
+                case "React.useDebugValue":
+                case "useId":
+                case "React.useId":
+                case "useDeferredValue":
+                case "React.useDeferredValue":
+                case "useTransition":
+                case "React.useTransition":
+                case "useInsertionEffect":
+                case "React.useInsertionEffect":
+                case "useSyncExternalStore":
+                case "React.useSyncExternalStore":
+                case "useFormStatus":
+                case "React.useFormStatus":
+                case "useFormState":
+                case "React.useFormState":
+                case "useActionState":
+                case "React.useActionState":
+                case "useOptimistic":
+                case "React.useOptimistic":
+                  call = !0;
+                  break a;
+                default:
+                  call = !1;
+              }
+              return !call;
+            })
+            .map(function (call) {
+              return t.cloneDeep(call.callee);
+            })
+        };
+  }
+  function hasForceResetComment(path) {
+    path = path.hub.file;
+    var hasForceReset = hasForceResetCommentByFile.get(path);
+    if (void 0 !== hasForceReset) return hasForceReset;
+    hasForceReset = !1;
+    for (var comments = path.ast.comments, i = 0; i < comments.length; i++)
+      if (-1 !== comments[i].value.indexOf("@refresh reset")) {
+        hasForceReset = !0;
+        break;
+      }
+    hasForceResetCommentByFile.set(path, hasForceReset);
+    return hasForceReset;
+  }
+  function createArgumentsForSignature(node, signature, scope) {
+    var key = signature.key;
+    signature = signature.customHooks;
+    var forceReset = hasForceResetComment(scope.path),
+      customHooksInScope = [];
+    signature.forEach(function (callee) {
+      switch (callee.type) {
+        case "MemberExpression":
+          if ("Identifier" === callee.object.type)
+            var bindingName = callee.object.name;
+          break;
+        case "Identifier":
+          bindingName = callee.name;
+      }
+      scope.hasBinding(bindingName)
+        ? customHooksInScope.push(callee)
+        : (forceReset = !0);
+    });
+    signature = key;
+    "function" !== typeof require ||
+      opts.emitFullSignatures ||
+      (signature = require("crypto")
+        .createHash("sha1")
+        .update(key)
+        .digest("base64"));
+    node = [node, t.stringLiteral(signature)];
+    (forceReset || 0 < customHooksInScope.length) &&
+      node.push(t.booleanLiteral(forceReset));
+    0 < customHooksInScope.length &&
+      node.push(
+        t.functionExpression(
+          null,
+          [],
+          t.blockStatement([
+            t.returnStatement(t.arrayExpression(customHooksInScope))
+          ])
+        )
+      );
+    return node;
+  }
+  function findHOCCallPathsAbove(path) {
+    for (var calls = []; ; ) {
+      if (!path) return calls;
+      var parentPath = path.parentPath;
+      if (!parentPath) return calls;
+      if (
+        "AssignmentExpression" === parentPath.node.type &&
+        path.node === parentPath.node.right
+      )
+        path = parentPath;
+      else if (
+        "CallExpression" === parentPath.node.type &&
+        path.node !== parentPath.node.callee
+      )
+        calls.push(parentPath), (path = parentPath);
+      else return calls;
+    }
+  }
+  var opts =
+    1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : {};
+  if ("function" === typeof babel.env) {
+    var env = babel.env();
+    if ("development" !== env && !opts.skipEnvCheck)
+      throw Error(
+        'React Refresh Babel transform should only be enabled in development environment. Instead, the environment is: "' +
+          env +
+          '". If you want to override this check, pass {skipEnvCheck: true} as plugin options.'
+      );
+  }
+  var t = babel.types,
+    refreshReg = t.identifier(opts.refreshReg || "$RefreshReg$"),
+    refreshSig = t.identifier(opts.refreshSig || "$RefreshSig$"),
+    registrationsByProgramPath = new Map(),
+    hasForceResetCommentByFile = new WeakMap(),
+    seenForRegistration = new WeakSet(),
+    seenForSignature = new WeakSet(),
+    seenForOutro = new WeakSet(),
+    hookCalls = new WeakMap(),
+    HookCallsVisitor = {
+      CallExpression: function (path) {
+        var callee = path.node.callee,
+          name = null;
+        switch (callee.type) {
+          case "Identifier":
+            name = callee.name;
+            break;
+          case "MemberExpression":
+            name = callee.property.name;
+        }
+        if (
+          null !== name &&
+          /^use[A-Z]/.test(name) &&
+          ((callee = path.scope.getFunctionParent()), null !== callee)
+        ) {
+          callee = callee.block;
+          hookCalls.has(callee) || hookCalls.set(callee, []);
+          callee = hookCalls.get(callee);
+          var key = "";
+          "VariableDeclarator" === path.parent.type &&
+            (key = path.parentPath.get("id").getSource());
+          var args = path.get("arguments");
+          "useState" === name && 0 < args.length
+            ? (key += "(" + args[0].getSource() + ")")
+            : "useReducer" === name &&
+              1 < args.length &&
+              (key += "(" + args[1].getSource() + ")");
+          callee.push({ callee: path.node.callee, name: name, key: key });
+        }
+      }
+    };
+  return {
+    visitor: {
+      ExportDefaultDeclaration: function (path) {
+        var node = path.node,
+          decl = node.declaration,
+          declPath = path.get("declaration");
+        if ("CallExpression" === decl.type && !seenForRegistration.has(node)) {
+          seenForRegistration.add(node);
+          var programPath = path.parentPath;
+          findInnerComponents(
+            "%default%",
+            declPath,
+            function (persistentID, targetExpr, targetPath) {
+              null !== targetPath &&
+                ((persistentID = createRegistration(programPath, persistentID)),
+                targetPath.replaceWith(
+                  t.assignmentExpression("=", persistentID, targetExpr)
+                ));
+            }
+          );
+        }
+      },
+      FunctionDeclaration: {
+        enter: function (path) {
+          var node = path.node,
+            modulePrefix = "";
+          switch (path.parent.type) {
+            case "Program":
+              var insertAfterPath = path;
+              var programPath = path.parentPath;
+              break;
+            case "TSModuleBlock":
+              insertAfterPath = path;
+              programPath = insertAfterPath.parentPath.parentPath;
+              break;
+            case "ExportNamedDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            case "ExportDefaultDeclaration":
+              insertAfterPath = path.parentPath;
+              programPath = insertAfterPath.parentPath;
+              break;
+            default:
+              return;
+          }
+          if (
+            "TSModuleBlock" === path.parent.type ||
+            "ExportNamedDeclaration" === path.parent.type
+          )
+            for (; "Program" !== programPath.type; ) {
+              if ("TSModuleDeclaration" === programPath.type) {
+                if (
+                  "Program" !== programPath.parentPath.type &&
+                  "ExportNamedDeclaration" !== programPath.parentPath.type
+                )
+                  return;
+                modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+              }
+              programPath = programPath.parentPath;
+            }
+          var id = node.id;
+          null !== id &&
+            ((id = id.name),
+            isComponentishName(id) &&
+              !seenForRegistration.has(node) &&
+              (seenForRegistration.add(node),
+              findInnerComponents(
+                modulePrefix + id,
+                path,
+                function (persistentID, targetExpr) {
+                  persistentID = createRegistration(programPath, persistentID);
+                  insertAfterPath.insertAfter(
+                    t.expressionStatement(
+                      t.assignmentExpression("=", persistentID, targetExpr)
+                    )
+                  );
+                }
+              )));
+        },
+        exit: function (path) {
+          var node = path.node,
+            id = node.id;
+          if (null !== id) {
+            var signature = getHookCallsSignature(node);
+            if (null !== signature && !seenForSignature.has(node)) {
+              seenForSignature.add(node);
+              node = path.scope.generateUidIdentifier("_s");
+              path.scope.parent.push({
+                id: node,
+                init: t.callExpression(refreshSig, [])
+              });
+              path
+                .get("body")
+                .unshiftContainer(
+                  "body",
+                  t.expressionStatement(t.callExpression(node, []))
+                );
+              var insertAfterPath = null;
+              path.find(function (p) {
+                if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+              });
+              null !== insertAfterPath &&
+                insertAfterPath.insertAfter(
+                  t.expressionStatement(
+                    t.callExpression(
+                      node,
+                      createArgumentsForSignature(
+                        id,
+                        signature,
+                        insertAfterPath.scope
+                      )
+                    )
+                  )
+                );
+            }
+          }
+        }
+      },
+      "ArrowFunctionExpression|FunctionExpression": {
+        exit: function (path) {
+          var node = path.node,
+            signature = getHookCallsSignature(node);
+          if (null !== signature && !seenForSignature.has(node)) {
+            seenForSignature.add(node);
+            var sigCallID = path.scope.generateUidIdentifier("_s");
+            path.scope.parent.push({
+              id: sigCallID,
+              init: t.callExpression(refreshSig, [])
+            });
+            "BlockStatement" !== path.node.body.type &&
+              (path.node.body = t.blockStatement([
+                t.returnStatement(path.node.body)
+              ]));
+            path
+              .get("body")
+              .unshiftContainer(
+                "body",
+                t.expressionStatement(t.callExpression(sigCallID, []))
+              );
+            if ("VariableDeclarator" === path.parent.type) {
+              var insertAfterPath = null;
+              path.find(function (p) {
+                if (p.parentPath.isBlock()) return (insertAfterPath = p), !0;
+              });
+              null !== insertAfterPath &&
+                insertAfterPath.insertAfter(
+                  t.expressionStatement(
+                    t.callExpression(
+                      sigCallID,
+                      createArgumentsForSignature(
+                        path.parent.id,
+                        signature,
+                        insertAfterPath.scope
+                      )
+                    )
+                  )
+                );
+            } else
+              [path].concat(findHOCCallPathsAbove(path)).forEach(function (p) {
+                p.replaceWith(
+                  t.callExpression(
+                    sigCallID,
+                    createArgumentsForSignature(p.node, signature, p.scope)
+                  )
+                );
+              });
+          }
+        }
+      },
+      VariableDeclaration: function (path) {
+        var node = path.node,
+          modulePrefix = "";
+        switch (path.parent.type) {
+          case "Program":
+            var insertAfterPath = path;
+            var programPath = path.parentPath;
+            break;
+          case "TSModuleBlock":
+            insertAfterPath = path;
+            programPath = insertAfterPath.parentPath.parentPath;
+            break;
+          case "ExportNamedDeclaration":
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+          case "ExportDefaultDeclaration":
+            insertAfterPath = path.parentPath;
+            programPath = insertAfterPath.parentPath;
+            break;
+          default:
+            return;
+        }
+        if (
+          "TSModuleBlock" === path.parent.type ||
+          "ExportNamedDeclaration" === path.parent.type
+        )
+          for (; "Program" !== programPath.type; ) {
+            if ("TSModuleDeclaration" === programPath.type) {
+              if (
+                "Program" !== programPath.parentPath.type &&
+                "ExportNamedDeclaration" !== programPath.parentPath.type
+              )
+                return;
+              modulePrefix = programPath.node.id.name + "$" + modulePrefix;
+            }
+            programPath = programPath.parentPath;
+          }
+        if (
+          !seenForRegistration.has(node) &&
+          (seenForRegistration.add(node),
+          (path = path.get("declarations")),
+          1 === path.length)
+        ) {
+          var declPath = path[0];
+          findInnerComponents(
+            modulePrefix + declPath.node.id.name,
+            declPath,
+            function (persistentID, targetExpr, targetPath) {
+              null !== targetPath &&
+                ((persistentID = createRegistration(programPath, persistentID)),
+                "VariableDeclarator" === targetPath.parent.type
+                  ? insertAfterPath.insertAfter(
+                      t.expressionStatement(
+                        t.assignmentExpression(
+                          "=",
+                          persistentID,
+                          declPath.node.id
+                        )
+                      )
+                    )
+                  : targetPath.replaceWith(
+                      t.assignmentExpression("=", persistentID, targetExpr)
+                    ));
+            }
+          );
+        }
+      },
+      Program: {
+        enter: function (path) {
+          path.traverse(HookCallsVisitor);
+        },
+        exit: function (path) {
+          var registrations = registrationsByProgramPath.get(path);
+          if (void 0 !== registrations) {
+            var node = path.node;
+            if (!seenForOutro.has(node)) {
+              seenForOutro.add(node);
+              registrationsByProgramPath.delete(path);
+              var declarators = [];
+              path.pushContainer(
+                "body",
+                t.variableDeclaration("var", declarators)
+              );
+              registrations.forEach(function (_ref) {
+                var handle = _ref.handle;
+                path.pushContainer(
+                  "body",
+                  t.expressionStatement(
+                    t.callExpression(refreshReg, [
+                      handle,
+                      t.stringLiteral(_ref.persistentID)
+                    ])
+                  )
+                );
+                declarators.push(t.variableDeclarator(handle));
+              });
+            }
+          }
+        }
+      }
+    }
+  };
+};

frontend/node_modules/react-refresh/cjs/react-refresh-runtime.development.js

@@ -0,0 +1,338 @@
+/**
+ * @license React
+ * react-refresh-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+"use strict";
+"production" !== process.env.NODE_ENV &&
+  (function () {
+    function computeFullKey(signature) {
+      if (null !== signature.fullKey) return signature.fullKey;
+      var fullKey = signature.ownKey;
+      try {
+        var hooks = signature.getCustomHooks();
+      } catch (err) {
+        return (signature.forceReset = !0), (signature.fullKey = fullKey);
+      }
+      for (var i = 0; i < hooks.length; i++) {
+        var hook = hooks[i];
+        if ("function" !== typeof hook)
+          return (signature.forceReset = !0), (signature.fullKey = fullKey);
+        hook = allSignaturesByType.get(hook);
+        if (void 0 !== hook) {
+          var nestedHookKey = computeFullKey(hook);
+          hook.forceReset && (signature.forceReset = !0);
+          fullKey += "\n---\n" + nestedHookKey;
+        }
+      }
+      return (signature.fullKey = fullKey);
+    }
+    function resolveFamily(type) {
+      return updatedFamiliesByType.get(type);
+    }
+    function cloneMap(map) {
+      var clone = new Map();
+      map.forEach(function (value, key) {
+        clone.set(key, value);
+      });
+      return clone;
+    }
+    function cloneSet(set) {
+      var clone = new Set();
+      set.forEach(function (value) {
+        clone.add(value);
+      });
+      return clone;
+    }
+    function getProperty(object, property) {
+      try {
+        return object[property];
+      } catch (err) {}
+    }
+    function register(type, id) {
+      if (
+        !(
+          null === type ||
+          ("function" !== typeof type && "object" !== typeof type) ||
+          allFamiliesByType.has(type)
+        )
+      ) {
+        var family = allFamiliesByID.get(id);
+        void 0 === family
+          ? ((family = { current: type }), allFamiliesByID.set(id, family))
+          : pendingUpdates.push([family, type]);
+        allFamiliesByType.set(type, family);
+        if ("object" === typeof type && null !== type)
+          switch (getProperty(type, "$$typeof")) {
+            case REACT_FORWARD_REF_TYPE:
+              register(type.render, id + "$render");
+              break;
+            case REACT_MEMO_TYPE:
+              register(type.type, id + "$type");
+          }
+      }
+    }
+    function setSignature(type, key) {
+      var forceReset =
+          2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !1,
+        getCustomHooks = 3 < arguments.length ? arguments[3] : void 0;
+      allSignaturesByType.has(type) ||
+        allSignaturesByType.set(type, {
+          forceReset: forceReset,
+          ownKey: key,
+          fullKey: null,
+          getCustomHooks:
+            getCustomHooks ||
+            function () {
+              return [];
+            }
+        });
+      if ("object" === typeof type && null !== type)
+        switch (getProperty(type, "$$typeof")) {
+          case REACT_FORWARD_REF_TYPE:
+            setSignature(type.render, key, forceReset, getCustomHooks);
+            break;
+          case REACT_MEMO_TYPE:
+            setSignature(type.type, key, forceReset, getCustomHooks);
+        }
+    }
+    function collectCustomHooksForSignature(type) {
+      type = allSignaturesByType.get(type);
+      void 0 !== type && computeFullKey(type);
+    }
+    var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+      allFamiliesByID = new Map(),
+      allFamiliesByType = new PossiblyWeakMap(),
+      allSignaturesByType = new PossiblyWeakMap(),
+      updatedFamiliesByType = new PossiblyWeakMap(),
+      pendingUpdates = [],
+      helpersByRendererID = new Map(),
+      helpersByRoot = new Map(),
+      mountedRoots = new Set(),
+      failedRoots = new Set(),
+      rootElements = "function" === typeof WeakMap ? new WeakMap() : null,
+      isPerformingRefresh = !1;
+    exports._getMountedRootCount = function () {
+      return mountedRoots.size;
+    };
+    exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+    exports.createSignatureFunctionForTransform = function () {
+      var savedType,
+        hasCustomHooks,
+        didCollectHooks = !1;
+      return function (type, key, forceReset, getCustomHooks) {
+        if ("string" === typeof key)
+          return (
+            savedType ||
+              ((savedType = type),
+              (hasCustomHooks = "function" === typeof getCustomHooks)),
+            null == type ||
+              ("function" !== typeof type && "object" !== typeof type) ||
+              setSignature(type, key, forceReset, getCustomHooks),
+            type
+          );
+        !didCollectHooks &&
+          hasCustomHooks &&
+          ((didCollectHooks = !0), collectCustomHooksForSignature(savedType));
+      };
+    };
+    exports.getFamilyByID = function (id) {
+      return allFamiliesByID.get(id);
+    };
+    exports.getFamilyByType = function (type) {
+      return allFamiliesByType.get(type);
+    };
+    exports.hasUnrecoverableErrors = function () {
+      return !1;
+    };
+    exports.injectIntoGlobalHook = function (globalObject) {
+      var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (void 0 === hook) {
+        var nextID = 0;
+        globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+          renderers: new Map(),
+          supportsFiber: !0,
+          inject: function () {
+            return nextID++;
+          },
+          onScheduleFiberRoot: function () {},
+          onCommitFiberRoot: function () {},
+          onCommitFiberUnmount: function () {}
+        };
+      }
+      if (hook.isDisabled)
+        console.warn(
+          "Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."
+        );
+      else {
+        var oldInject = hook.inject;
+        hook.inject = function (injected) {
+          var id = oldInject.apply(this, arguments);
+          "function" === typeof injected.scheduleRefresh &&
+            "function" === typeof injected.setRefreshHandler &&
+            helpersByRendererID.set(id, injected);
+          return id;
+        };
+        hook.renderers.forEach(function (injected, id) {
+          "function" === typeof injected.scheduleRefresh &&
+            "function" === typeof injected.setRefreshHandler &&
+            helpersByRendererID.set(id, injected);
+        });
+        var oldOnCommitFiberRoot = hook.onCommitFiberRoot,
+          oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
+        hook.onScheduleFiberRoot = function (id, root, children) {
+          isPerformingRefresh ||
+            (failedRoots.delete(root),
+            null !== rootElements && rootElements.set(root, children));
+          return oldOnScheduleFiberRoot.apply(this, arguments);
+        };
+        hook.onCommitFiberRoot = function (
+          id,
+          root,
+          maybePriorityLevel,
+          didError
+        ) {
+          var helpers = helpersByRendererID.get(id);
+          if (void 0 !== helpers) {
+            helpersByRoot.set(root, helpers);
+            helpers = root.current;
+            var alternate = helpers.alternate;
+            null !== alternate
+              ? ((alternate =
+                  null != alternate.memoizedState &&
+                  null != alternate.memoizedState.element &&
+                  mountedRoots.has(root)),
+                (helpers =
+                  null != helpers.memoizedState &&
+                  null != helpers.memoizedState.element),
+                !alternate && helpers
+                  ? (mountedRoots.add(root), failedRoots.delete(root))
+                  : (alternate && helpers) ||
+                    (alternate && !helpers
+                      ? (mountedRoots.delete(root),
+                        didError
+                          ? failedRoots.add(root)
+                          : helpersByRoot.delete(root))
+                      : alternate ||
+                        helpers ||
+                        (didError && failedRoots.add(root))))
+              : mountedRoots.add(root);
+          }
+          return oldOnCommitFiberRoot.apply(this, arguments);
+        };
+      }
+    };
+    exports.isLikelyComponentType = function (type) {
+      switch (typeof type) {
+        case "function":
+          if (null != type.prototype) {
+            if (type.prototype.isReactComponent) return !0;
+            var ownNames = Object.getOwnPropertyNames(type.prototype);
+            if (
+              1 < ownNames.length ||
+              "constructor" !== ownNames[0] ||
+              type.prototype.__proto__ !== Object.prototype
+            )
+              return !1;
+          }
+          type = type.name || type.displayName;
+          return "string" === typeof type && /^[A-Z]/.test(type);
+        case "object":
+          if (null != type)
+            switch (getProperty(type, "$$typeof")) {
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_MEMO_TYPE:
+                return !0;
+            }
+          return !1;
+        default:
+          return !1;
+      }
+    };
+    exports.performReactRefresh = function () {
+      if (0 === pendingUpdates.length || isPerformingRefresh) return null;
+      isPerformingRefresh = !0;
+      try {
+        var staleFamilies = new Set(),
+          updatedFamilies = new Set(),
+          updates = pendingUpdates;
+        pendingUpdates = [];
+        updates.forEach(function (_ref) {
+          var family = _ref[0];
+          _ref = _ref[1];
+          var prevType = family.current;
+          updatedFamiliesByType.set(prevType, family);
+          updatedFamiliesByType.set(_ref, family);
+          family.current = _ref;
+          (prevType.prototype && prevType.prototype.isReactComponent) ||
+          (_ref.prototype && _ref.prototype.isReactComponent)
+            ? (_ref = !1)
+            : ((prevType = allSignaturesByType.get(prevType)),
+              (_ref = allSignaturesByType.get(_ref)),
+              (_ref =
+                (void 0 === prevType && void 0 === _ref) ||
+                (void 0 !== prevType &&
+                  void 0 !== _ref &&
+                  computeFullKey(prevType) === computeFullKey(_ref) &&
+                  !_ref.forceReset)
+                  ? !0
+                  : !1));
+          _ref ? updatedFamilies.add(family) : staleFamilies.add(family);
+        });
+        var update = {
+          updatedFamilies: updatedFamilies,
+          staleFamilies: staleFamilies
+        };
+        helpersByRendererID.forEach(function (helpers) {
+          helpers.setRefreshHandler(resolveFamily);
+        });
+        var didError = !1,
+          firstError = null,
+          failedRootsSnapshot = cloneSet(failedRoots),
+          mountedRootsSnapshot = cloneSet(mountedRoots),
+          helpersByRootSnapshot = cloneMap(helpersByRoot);
+        failedRootsSnapshot.forEach(function (root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (void 0 === helpers)
+            throw Error(
+              "Could not find helpers for a root. This is a bug in React Refresh."
+            );
+          failedRoots.has(root);
+          if (null !== rootElements && rootElements.has(root)) {
+            var element = rootElements.get(root);
+            try {
+              helpers.scheduleRoot(root, element);
+            } catch (err) {
+              didError || ((didError = !0), (firstError = err));
+            }
+          }
+        });
+        mountedRootsSnapshot.forEach(function (root) {
+          var helpers = helpersByRootSnapshot.get(root);
+          if (void 0 === helpers)
+            throw Error(
+              "Could not find helpers for a root. This is a bug in React Refresh."
+            );
+          mountedRoots.has(root);
+          try {
+            helpers.scheduleRefresh(root, update);
+          } catch (err) {
+            didError || ((didError = !0), (firstError = err));
+          }
+        });
+        if (didError) throw firstError;
+        return update;
+      } finally {
+        isPerformingRefresh = !1;
+      }
+    };
+    exports.register = register;
+    exports.setSignature = setSignature;
+  })();

frontend/node_modules/react-refresh/cjs/react-refresh-runtime.production.js

@@ -0,0 +1,14 @@
+/**
+ * @license React
+ * react-refresh-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+"use strict";
+throw Error(
+  "React Refresh runtime should not be included in the production bundle."
+);

frontend/node_modules/react-refresh/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "react-refresh",
+  "description": "React is a JavaScript library for building user interfaces.",
+  "keywords": [
+    "react"
+  ],
+  "version": "0.17.0",
+  "homepage": "https://react.dev/",
+  "bugs": "https://github.com/facebook/react/issues",
+  "license": "MIT",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "babel.js",
+    "runtime.js",
+    "cjs/"
+  ],
+  "main": "runtime.js",
+  "exports": {
+    ".": "./runtime.js",
+    "./runtime": "./runtime.js",
+    "./babel": "./babel.js",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/react.git",
+    "directory": "packages/react"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "devDependencies": {
+    "react-16-8": "npm:react@16.8.0",
+    "react-dom-16-8": "npm:react-dom@16.8.0",
+    "scheduler-0-13": "npm:scheduler@0.13.0"
+  }
+}

frontend/node_modules/react-refresh/runtime.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./cjs/react-refresh-runtime.production.js');
+} else {
+  module.exports = require('./cjs/react-refresh-runtime.development.js');
+}