build: add generating compat.json (#9700 )

This is to add the generation of `compat.json` as a release artifact. It describes the runtime requirements of the release in question. The next step is to have the upgrade server use this information to filter releases provided to clients. This is per the discussion in #9656 --------- Co-authored-by: Ross Smith II <ross@smithii.com>
chore(discovery,upgrade): use regular TLS certificate verification (#9673 )
2024-09-11 09:29:49 +02:00 · 2024-09-11 09:29:19 +02:00 · 2024-09-10 13:36:17 +02:00 · 2024-09-09 03:45:15 +00:00 · 2024-09-08 12:42:32 +02:00 · 2024-09-06 09:39:09 +02:00
59 changed files with 955 additions and 614 deletions
@@ -7,7 +7,7 @@ on:
      - infra-*

 env:
-  GO_VERSION: "~1.22.3"
+  GO_VERSION: "~1.23.0"
  CGO_ENABLED: "0"
  BUILD_USER: docker
  BUILD_HOST: github.syncthing.net
@@ -12,7 +12,7 @@ env:
  # The go version to use for builds. We set check-latest to true when
  # installing, so we get the latest patch version that matches the
  # expression.
-  GO_VERSION: "~1.22.3"
+  GO_VERSION: "~1.23.0"

  # Optimize compatibility on the slow archictures.
  GO386: softfloat
@@ -48,7 +48,7 @@ jobs:
        runner: ["windows-latest", "ubuntu-latest", "macos-latest"]
        # The oldest version in this list should match what we have in our go.mod.
        # Variables don't seem to be supported here, or we could have done something nice.
-        go: ["~1.21.7", "~1.22.3"]
+        go: ["~1.22.6", "~1.23.0"]
    runs-on: ${{ matrix.runner }}
    steps:
      - name: Set git to use LF
@@ -238,7 +238,9 @@ jobs:
        uses: actions/upload-artifact@v4
        with:
          name: packages-linux
-          path: syncthing-linux-*.tar.gz
+          path: |
+            syncthing-linux-*.tar.gz
+            compat.json

  #
  # macOS
@@ -18,3 +18,4 @@ deb
 /repos
 /proto/scripts/protoc-gen-gosyncthing
 /gui/next-gen-gui
+/compat.json
@@ -4,8 +4,8 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at https://mozilla.org/MPL/2.0/.

-//go:build ignore
-// +build ignore
+//go:build tools
+// +build tools

 package main

@@ -34,6 +34,8 @@ import (
 	"time"

 	buildpkg "github.com/syncthing/syncthing/lib/build"
+	"github.com/syncthing/syncthing/lib/upgrade"
+	"sigs.k8s.io/yaml"
 )

 var (
@@ -342,9 +344,11 @@ func runCommand(cmd string, target target) {

 	case "tar":
 		buildTar(target, tags)
+		writeCompatJSON()

 	case "zip":
 		buildZip(target, tags)
+		writeCompatJSON()

 	case "deb":
 		buildDeb(target)
@@ -1557,3 +1561,29 @@ func nextPatchVersion(ver string) string {
 	digits[len(digits)-1] = strconv.Itoa(n + 1)
 	return strings.Join(digits, ".")
 }
+
+func writeCompatJSON() {
+	bs, err := os.ReadFile("compat.yaml")
+	if err != nil {
+		log.Fatal("Reading compat.yaml:", err)
+	}
+
+	var entries []upgrade.ReleaseCompatibility
+	if err := yaml.Unmarshal(bs, &entries); err != nil {
+		log.Fatal("Parsing compat.yaml:", err)
+	}
+
+	rt := runtime.Version()
+	for _, e := range entries {
+		if !strings.HasPrefix(rt, e.Runtime) {
+			continue
+		}
+		bs, _ := json.MarshalIndent(e, "", "  ")
+		if err := os.WriteFile("compat.json", bs, 0o644); err != nil {
+			log.Fatal("Writing compat.json:", err)
+		}
+		return
+	}
+
+	log.Fatalf("runtime %v not found in compat.yaml", rt)
+}
@@ -270,7 +270,7 @@ found in the LICENSE file.
            </h4>
          </div>
          <div id="collapseTwo" class="panel-collapse collapse">
-            <div class="panel-body">
+            <div class="panel-body less-padding">
              <div class="row">
                <div class="col-md-6">
                  <table class="table table-striped">
@@ -0,0 +1,28 @@
+- runtime: go1.21
+  requirements:
+    # See https://en.wikipedia.org/wiki/MacOS_version_history#Releases
+    #
+    # macOS 10.15 (Catalina) per https://go.dev/doc/go1.22#darwin
+    darwin: "19"
+    # Per https://go.dev/doc/go1.23#linux
+    linux: "2.6.32"
+    # Windows 10's initial release was 10.0.10240.16405, per
+    # https://learn.microsoft.com/en-us/windows/release-health/release-information
+    # and Windows 11's initial release was 10.0.22000.194 per
+    # https://learn.microsoft.com/en-us/windows/release-health/windows11-release-information
+    #
+    # Windows 10/Windows Server 2016 per https://go.dev/doc/go1.21#windows
+    windows: "10.0"
+
+- runtime: go1.22
+  requirements:
+    darwin: "19"
+    linux: "2.6.32"
+    windows: "10.0"
+
+- runtime: go1.23
+  requirements:
+    # macOS 11 (Big Sur) per https://tip.golang.org/doc/go1.23#darwin
+    darwin: "20"
+    linux: "2.6.32"
+    windows: "10.0"
@@ -1,6 +1,6 @@
 module github.com/syncthing/syncthing

-go 1.21.0
+go 1.22.0

 require (
 	github.com/AudriusButkevicius/recli v0.0.7-0.20220911121932-d000ce8fbf0f
@@ -46,6 +46,7 @@ require (
 	golang.org/x/time v0.6.0
 	golang.org/x/tools v0.24.0
 	google.golang.org/protobuf v1.34.2
+	sigs.k8s.io/yaml v1.4.0
 )

 require (
@@ -81,6 +81,7 @@ github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
@@ -385,3 +386,5 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
@@ -304,11 +304,7 @@ a.toggler:hover {
    text-decoration: none;
 }

-/**
- * Panel padding decrease
- */
-
-.panel-collapse .panel-body {
+.panel-body.less-padding {
    padding: 5px;
 }

@@ -30,6 +30,7 @@
    "An external command handles the versioning. It has to remove the file from the shared folder. If the path to the application contains spaces, it should be quoted.": "Perintah eksternal menangani pemversian. Ia harus menghapus berkas dari folder yang dibagi. Jika lokasi aplikasi terdapat spasi, itu harus dikutip.",
    "Anonymous Usage Reporting": "Pelaporan Penggunaan Anonim",
    "Anonymous usage report format has changed. Would you like to move to the new format?": "Format pelaporan penggunaan anonim telah berubah. Maukah anda pindah menggunakan format yang baru?",
+    "Applied to LAN": "Digunakan di LAN",
    "Apply": "Terapkan",
    "Are you sure you want to override all remote changes?": "Apakah anda yakin ingin menimpa semua perubahan jarak jauh?",
    "Are you sure you want to permanently delete all these files?": "Apakah anda yakin ingin menghapus semua berkas berikut secara permanen?",
@@ -38,6 +39,7 @@
    "Are you sure you want to restore {%count%} files?": "Apakah anda yakin ingin memulihkan {{count}} berkas?",
    "Are you sure you want to revert all local changes?": "Apakah anda yakin ingin mengembalikan semua perubahan lokal?",
    "Are you sure you want to upgrade?": "Apakah anda yakin ingin meningkatkan?",
+    "Authentication Required": "Otentikasi diperlukan",
    "Authors": "Penulis",
    "Auto Accept": "Terima Otomatis",
    "Automatic Crash Reporting": "Pelaporan Crash Otomatis",
@@ -48,6 +50,7 @@
    "Available debug logging facilities:": "Fasilitas log debug yang ada:",
    "Be careful!": "Harap hati-hati!",
    "Body:": "Badan:",
+    "Bugs": "Bugs",
    "Cancel": "Batal",
    "Changelog": "Log Perubahan",
    "Clean out after": "Bersihkan setelah",
@@ -63,6 +66,7 @@
    "Configured": "Terkonfigurasi",
    "Connected (Unused)": "Terkoneksi (Tidak Digunakan)",
    "Connection Error": "Koneksi Galat",
+    "Connection Management": "Pengaturan Koneksi",
    "Connection Type": "Tipe Koneksi",
    "Connections": "Koneksi",
    "Connections via relays might be rate limited by the relay": "Koneksi melalui relai mungkin dibatasi oleh relai",
@@ -77,6 +81,7 @@
    "Danger!": "Bahaya!",
    "Database Location": "Lokasi Database",
    "Debugging Facilities": "Fasilitas Debug",
+    "Default": "Default",
    "Default Configuration": "Konfigurasi Bawaan",
    "Default Device": "Perangkat Bawaan",
    "Default Folder": "Folder Bawaan",
@@ -21,7 +21,7 @@
    "Advanced": "Avancerat",
    "Advanced Configuration": "Avancerad konfiguration",
    "All Data": "Alla data",
-    "All Time": "All tid",
+    "All Time": "Någonsin",
    "All folders shared with this device must be protected by a password, such that all sent data is unreadable without the given password.": "Alla mappar som delas med denna enhet måste skyddas av ett lösenord, så att alla skickade data är oläsliga utan det angivna lösenordet.",
    "Allow Anonymous Usage Reporting?": "Tillåt anonym användarstatistiksrapportering?",
    "Allowed Networks": "Tillåtna nätverk",
@@ -1 +1 @@
-var langPrettyprint = {"ar":"Arabic","bg":"Bulgarian","ca":"Catalan","ca@valencia":"Valencian","cs":"Czech","da":"Danish","de":"German","el":"Greek","en":"English","en-GB":"English (United Kingdom)","es":"Spanish","eu":"Basque","fil":"Filipino","fr":"French","fy":"Frisian","ga":"Irish","hi":"Hindi","hu":"Hungarian","id":"Indonesian","it":"Italian","ja":"Japanese","ko-KR":"Korean","lt":"Lithuanian","nl":"Dutch","pl":"Polish","pt-BR":"Portuguese (Brazil)","pt-PT":"Portuguese (Portugal)","ro-RO":"Romanian","ru":"Russian","sk":"Slovak","sl":"Slovenian","sv":"Swedish","tr":"Turkish","uk":"Ukrainian","zh-CN":"Chinese (Simplified)","zh-HK":"Chinese (Traditional, Hong Kong)","zh-TW":"Chinese (Traditional)"}
+var langPrettyprint = {"ar":"Arabic","bg":"Bulgarian","ca":"Catalan","ca@valencia":"Valencian","cs":"Czech","da":"Danish","de":"German","el":"Greek","en":"English","en-GB":"English (United Kingdom)","es":"Spanish","eu":"Basque","fil":"Filipino","fr":"French","fy":"Frisian","ga":"Irish","hi":"Hindi","hu":"Hungarian","id":"Indonesian","it":"Italian","ja":"Japanese","ko-KR":"Korean","lt":"Lithuanian","nl":"Dutch","pl":"Polish","pt-BR":"Portuguese (Brazil)","pt-PT":"Portuguese (Portugal)","ro-RO":"Romanian","ru":"Russian","sk":"Slovak","sl":"Slovenian","sv":"Swedish","tr":"Turkish","uk":"Ukrainian","zh-CN":"Chinese (Simplified Han script)","zh-HK":"Chinese (Traditional Han script, Hong Kong)","zh-TW":"Chinese (Traditional Han script)"}
@@ -413,7 +413,7 @@
                </h4>
              </button>
              <div id="folder-{{$index}}" class="panel-collapse collapse">
-                <div class="panel-body">
+                <div class="panel-body less-padding">
                  <table class="table table-condensed table-striped table-auto">
                    <tbody>
                      <tr class="visible-xs">
@@ -681,7 +681,7 @@
              </h4>
            </button>
            <div id="device-this" class="panel-collapse collapse in">
-              <div class="panel-body">
+              <div class="panel-body less-padding">
                <table class="table table-condensed table-striped table-auto">
                  <tbody>
                    <tr>
@@ -796,7 +796,7 @@
                </h4>
              </button>
              <div id="device-{{$index}}" class="panel-collapse collapse">
-                <div class="panel-body">
+                <div class="panel-body less-padding">
                  <table class="table table-condensed table-striped table-auto">
                    <tbody>
                      <tr class="visible-xs">
@@ -59,30 +59,35 @@ angular.module('syncthing.core')
                        // Find the first language in the list provided by the user's browser
                        // that is a prefix of a language we have available. That is, "en"
                        // sent by the browser will match "en" or "en-US", while "zh-TW" will
-                        // match only "zh-TW" and not "zh-CN".
+                        // match only "zh-TW" and not "zh" or "zh-CN".

                        var i,
-                            lang,
+                            browserLang,
                            matching,
-                            locale = _defaultLocale;
+                            locale = _defaultLocale; // Fallback if nothing matched

                        for (i = 0; i < langs.length; i++) {
-                            lang = langs[i];
+                            browserLang = langs[i];

-                            if (lang.length < 2) {
+                            if (browserLang.length < 2) {
                                continue;
                            }

                            matching = _availableLocales.filter(function (possibleLang) {
-                                // The langs returned by the /rest/langs call will be in lower
-                                // case. We compare to the lowercase version of the language
-                                // code we have as well.
+                                // The langs returned by the /rest/svc/langs call will be in
+                                // lower case. We compare to the lowercase version of the
+                                // language code we have as well.
                                possibleLang = possibleLang.toLowerCase();
-                                if (possibleLang.length > lang.length) {
-                                    return possibleLang.indexOf(lang) === 0;
-                                } else {
-                                    return lang.indexOf(possibleLang) === 0;
+                                if (possibleLang.indexOf(browserLang) !== 0) {
+                                    // Prefix does not match
+                                    return false;
                                }
+                                if (possibleLang.length > browserLang.length) {
+                                    // Must match up to the next hyphen separator
+                                    return possibleLang[browserLang.length] === '-';
+                                }
+                                // Same length, exact match
+                                return true;
                            });

                            if (matching.length >= 1) {
@@ -90,7 +95,6 @@ angular.module('syncthing.core')
                                break;
                            }
                        }
-                        // Fallback if nothing matched
                        useLocale(locale);
                    });
                }
@@ -1447,7 +1447,7 @@ angular.module('syncthing.core')
            // Assume hasRemoteGUIAddress is true or we would not be here
            var conn = $scope.connections[deviceCfg.deviceID];
            // Use regex to filter out scope ID from IPv6 addresses.
-            return 'http://' + replaceAddressPort(conn.address, deviceCfg.remoteGUIPort).replace('%.*?\]:', ']:');
+            return 'http://' + replaceAddressPort(conn.address, deviceCfg.remoteGUIPort).replace(/%.*?\]:/, ']:');
        };

        function replaceAddressPort(address, newPort) {
@@ -13,7 +13,7 @@
          <h4 class="panel-title" translate tabindex="0">GUI</h4>
        </div>
        <div id="guiConfig" class="panel-collapse collapse" role="tabpanel" aria-labelledby="guiHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <form class="form-horizontal" role="form">
              <div ng-repeat="(key, value) in advancedConfig.gui" ng-init="type = inputTypeFor(key, value)" ng-if="type != 'skip'" class="form-group">
                <label for="guiInput{{$index}}" class="col-sm-4 control-label">{{key | uncamel}}&nbsp;<a href="{{docsURL('users/config#config-option-gui.')}}{{key | lowercase}}" target="_blank"><span class="fas fa-question-circle"></span></a></label>
@@ -32,7 +32,7 @@
          <h4 class="panel-title" tabindex="0" translate>Options</h4>
        </div>
        <div id="optionsConfig" class="panel-collapse collapse" role="tabpanel" aria-labelledby="optionsHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <form class="form-horizontal" role="form">
              <div ng-repeat="(key, value) in advancedConfig.options" ng-if="inputTypeFor(key, value) != 'skip'" class="form-group">
                <label for="optionsInput{{$index}}" class="col-sm-4 control-label">{{key | uncamel}}&nbsp;<a href="{{docsURL('users/config#config-option-options.')}}{{key | lowercase}}" target="_blank"><span class="fas fa-question-circle"></span></a></label>
@@ -51,7 +51,7 @@
          <h4 class="panel-title" tabindex="0" translate>LDAP</h4>
        </div>
        <div id="ldapConfig" class="panel-collapse collapse" role="tabpanel" aria-labelledby="ldapHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <form class="form-horizontal" role="form">
              <div ng-repeat="(key, value) in advancedConfig.ldap" ng-if="inputTypeFor(key, value) != 'skip'" class="form-group">
                <label for="ldapInput{{$index}}" class="col-sm-4 control-label">{{key | uncamel}}&nbsp;<a href="{{docsURL('users/config#config-option-ldap.')}}{{key | lowercase}}" target="_blank"><span class="fas fa-question-circle"></span></a></label>
@@ -70,7 +70,7 @@
          <h4 class="panel-title" translate>Folders</h4>
        </div>
        <div id="advancedFolders" class="panel-collapse collapse" role="tabpanel" aria-labelledby="advancedFoldersHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <div class="panel panel-default" ng-repeat="folder in advancedConfig.folders" ng-init="folderIndex = $index">
              <div class="panel-heading" role="tab" id="folder{{folderIndex}}Heading" data-toggle="collapse" data-parent="#advancedFolders" href="#folder{{folderIndex}}Config" aria-expanded="false" aria-controls="folder{{folderIndex}}Config" style="cursor: pointer;">
                <h4 ng-if="folder.label.length == 0" class="panel-title" tabindex="0">
@@ -81,7 +81,7 @@
                </h4>
              </div>
              <div id="folder{{folderIndex}}Config" class="panel-collapse collapse" role="tabpanel" aria-labelledby="folder{{folderIndex}}Heading">
-                <div class="panel-body">
+                <div class="panel-body less-padding">
                  <form class="form-horizontal" role="form">
                    <div ng-repeat="(key, value) in folder" ng-if="inputTypeFor(key, value) != 'skip'" class="form-group">
                      <label for="folder{{folderIndex}}Input{{$index}}" class="col-sm-4 control-label">{{key | uncamel}}&nbsp;<a href="{{docsURL('users/config#config-option-folder.')}}{{key | lowercase}}" target="_blank"><span class="fas fa-question-circle"></span></a></label>
@@ -103,7 +103,7 @@
          <h4 class="panel-title" tabindex="0" translate>Devices</h4>
        </div>
        <div id="advancedDevices" class="panel-collapse collapse" role="tabpanel" aria-labelledby="advancedDevicesHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <div class="panel panel-default" ng-repeat="device in advancedConfig.devices" ng-init="deviceIndex = $index">
              <div class="panel-heading" role="tab" id="device{{deviceIndex}}Heading" data-toggle="collapse" data-parent="#advancedDevices" href="#device{{deviceIndex}}Config" aria-expanded="false" aria-controls="device{{deviceIndex}}Config" style="cursor: pointer;">
                <h4 class="panel-title" tabindex="0">
@@ -111,7 +111,7 @@
                </h4>
              </div>
              <div id="device{{deviceIndex}}Config" class="panel-collapse collapse" role="tabpanel" aria-labelledby="device{{deviceIndex}}Heading">
-                <div class="panel-body">
+                <div class="panel-body less-padding">
                  <form class="form-horizontal" role="form">
                    <div ng-repeat="(key, value) in device" ng-if="inputTypeFor(key, value) != 'skip'" class="form-group">
                      <label for="device{{deviceIndex}}Input{{$index}}" class="col-sm-4 control-label">{{key | uncamel}}&nbsp;<a href="{{docsURL('users/config#config-option-device.')}}{{key | lowercase}}" target="_blank"><span class="fas fa-question-circle"></span></a></label>
@@ -133,7 +133,7 @@
          <h4 class="panel-title" tabindex="0" translate>Defaults</h4>
        </div>
        <div id="advancedDefaults" class="panel-collapse collapse" role="tabpanel" aria-labelledby="advancedDefaultsHeading">
-          <div class="panel-body">
+          <div class="panel-body less-padding">

            <div class="panel panel-default">
              <div class="panel-heading" role="tab" id="advancedDefaultFolderHeading" data-toggle="collapse" data-parent="#advancedDefaults" href="#advancedDefaultFolder" aria-expanded="false" aria-controls="advancedDefaultFolder" style="cursor: pointer;">
@@ -11,7 +11,7 @@
          </h4>
        </button>
        <div id="remoteNeed-{{$index}}" class="panel-collapse" ng-class="{collapse: sizeOf(remoteNeedFolders) > 1}">
-          <div class="panel-body">
+          <div class="panel-body less-padding">
            <table class="table table-striped">
              <thead>
                <tr>
@@ -1483,11 +1483,33 @@ func (*service) getDeviceID(w http.ResponseWriter, r *http.Request) {

 func (*service) getLang(w http.ResponseWriter, r *http.Request) {
 	lang := r.Header.Get("Accept-Language")
-	var langs []string
+	var weights = make(map[string]float64)
 	for _, l := range strings.Split(lang, ",") {
 		parts := strings.SplitN(l, ";", 2)
-		langs = append(langs, strings.ToLower(strings.TrimSpace(parts[0])))
+		code := strings.ToLower(strings.TrimSpace(parts[0]))
+		weights[code] = 1.0
+		if len(parts) < 2 {
+			continue
+		}
+		weight := strings.ToLower(strings.TrimSpace(parts[1]))
+		if !strings.HasPrefix(weight, "q=") {
+			continue
+		}
+		if q, err := strconv.ParseFloat(weight[2:], 32); err != nil {
+			// Completely dismiss entries with invalid weight
+			delete(weights, code)
+		} else {
+			weights[code] = q
+		}
 	}
+	var langs = make([]string, 0, len(weights))
+	for code := range weights {
+		langs = append(langs, code)
+	}
+	// Reorder by descending q value
+	sort.SliceStable(langs, func(i, j int) bool {
+		return weights[langs[i]] > weights[langs[j]]
+	})
 	sendJSON(w, langs)
 }

@@ -53,14 +53,14 @@ var (
 	// DefaultDiscoveryServersV4 should be substituted when the configuration
 	// contains <globalAnnounceServer>default-v4</globalAnnounceServer>.
 	DefaultDiscoveryServersV4 = []string{
-		"https://discovery.syncthing.net/v2/?noannounce&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
-		"https://discovery-v4.syncthing.net/v2/?nolookup&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
+		"https://discovery-lookup.syncthing.net/v2/?noannounce",
+		"https://discovery-announce-v4.syncthing.net/v2/?nolookup",
 	}
 	// DefaultDiscoveryServersV6 should be substituted when the configuration
 	// contains <globalAnnounceServer>default-v6</globalAnnounceServer>.
 	DefaultDiscoveryServersV6 = []string{
-		"https://discovery.syncthing.net/v2/?noannounce&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
-		"https://discovery-v6.syncthing.net/v2/?nolookup&id=LYXKCHX-VI3NYZR-ALCJBHF-WMZYSPK-QG6QJA3-MPFYMSO-U56GTUK-NA2MIAW",
+		"https://discovery-lookup.syncthing.net/v2/?noannounce",
+		"https://discovery-announce-v6.syncthing.net/v2/?nolookup",
 	}
 	// DefaultDiscoveryServers should be substituted when the configuration
 	// contains <globalAnnounceServer>default</globalAnnounceServer>.
@@ -20,10 +20,14 @@ type FileInfoBatch struct {
 	infos   []protocol.FileInfo
 	size    int
 	flushFn func([]protocol.FileInfo) error
+	error   error
 }

 // NewFileInfoBatch returns a new FileInfoBatch that calls fn when it's time
-// to flush.
+// to flush. Errors from the flush function are considered non-recoverable;
+// once an error is returned the flush function wil not be called again, and
+// any further calls to Flush will return the same error (unless Reset is
+// called).
 func NewFileInfoBatch(fn func([]protocol.FileInfo) error) *FileInfoBatch {
 	return &FileInfoBatch{flushFn: fn}
 }
@@ -33,6 +37,9 @@ func (b *FileInfoBatch) SetFlushFunc(fn func([]protocol.FileInfo) error) {
 }

 func (b *FileInfoBatch) Append(f protocol.FileInfo) {
+	if b.error != nil {
+		panic("bug: calling append on a failed batch")
+	}
 	if b.infos == nil {
 		b.infos = make([]protocol.FileInfo, 0, MaxBatchSizeFiles)
 	}
@@ -45,6 +52,9 @@ func (b *FileInfoBatch) Full() bool {
 }

 func (b *FileInfoBatch) FlushIfFull() error {
+	if b.error != nil {
+		return b.error
+	}
 	if b.Full() {
 		return b.Flush()
 	}
@@ -52,10 +62,14 @@ func (b *FileInfoBatch) FlushIfFull() error {
 }

 func (b *FileInfoBatch) Flush() error {
+	if b.error != nil {
+		return b.error
+	}
 	if len(b.infos) == 0 {
 		return nil
 	}
 	if err := b.flushFn(b.infos); err != nil {
+		b.error = err
 		return err
 	}
 	b.Reset()
@@ -64,6 +78,7 @@ func (b *FileInfoBatch) Flush() error {

 func (b *FileInfoBatch) Reset() {
 	b.infos = nil
+	b.error = nil
 	b.size = 0
 }

@@ -8,12 +8,14 @@ package db

 import (
 	"encoding/json"
+	"errors"
 	"io"
 	"os"
 	"testing"

 	"github.com/syncthing/syncthing/lib/db/backend"
 	"github.com/syncthing/syncthing/lib/events"
+	"github.com/syncthing/syncthing/lib/protocol"
 )

 // writeJSONS serializes the database to a JSON stream that can be checked
@@ -178,3 +180,53 @@ func snapshot(t testing.TB, fset *FileSet) *Snapshot {
 // 	defer fd.Close()
 // 	writeJSONS(fd, db)
 // }
+
+func TestFileInfoBatchError(t *testing.T) {
+	// Verify behaviour of the flush function returning an error.
+
+	var errReturn error
+	var called int
+	b := NewFileInfoBatch(func([]protocol.FileInfo) error {
+		called += 1
+		return errReturn
+	})
+
+	// Flush should work when the flush function error is nil
+	b.Append(protocol.FileInfo{Name: "test"})
+	if err := b.Flush(); err != nil {
+		t.Fatalf("expected nil, got %v", err)
+	}
+	if called != 1 {
+		t.Fatalf("expected 1, got %d", called)
+	}
+
+	// Flush should fail with an error retur
+	errReturn = errors.New("problem")
+	b.Append(protocol.FileInfo{Name: "test"})
+	if err := b.Flush(); err != errReturn {
+		t.Fatalf("expected %v, got %v", errReturn, err)
+	}
+	if called != 2 {
+		t.Fatalf("expected 2, got %d", called)
+	}
+
+	// Flush function should not be called again when it's already errored,
+	// same error should be returned by Flush()
+	if err := b.Flush(); err != errReturn {
+		t.Fatalf("expected %v, got %v", errReturn, err)
+	}
+	if called != 2 {
+		t.Fatalf("expected 2, got %d", called)
+	}
+
+	// Reset should clear the error (and the file list)
+	errReturn = nil
+	b.Reset()
+	b.Append(protocol.FileInfo{Name: "test"})
+	if err := b.Flush(); err != nil {
+		t.Fatalf("expected nil, got %v", err)
+	}
+	if called != 3 {
+		t.Fatalf("expected 3, got %d", called)
+	}
+}
@@ -11,15 +11,15 @@ package fs

 import (
 	"fmt"
+	"go/version"
 	"os"
+	"runtime"
 	"syscall"
 	"unsafe"

 	"golang.org/x/sys/windows"
 )

-const IO_REPARSE_TAG_DEDUP = 0x80000013
-
 func readReparseTag(path string) (uint32, error) {
 	namep, err := syscall.UTF16PtrFromString(path)
 	if err != nil {
@@ -60,10 +60,6 @@ func isDirectoryJunction(reparseTag uint32) bool {
 	return reparseTag == windows.IO_REPARSE_TAG_MOUNT_POINT
 }

-func isDeduplicatedFile(reparseTag uint32) bool {
-	return reparseTag == IO_REPARSE_TAG_DEDUP
-}
-
 type dirJunctFileInfo struct {
 	os.FileInfo
 }
@@ -71,21 +67,22 @@ type dirJunctFileInfo struct {
 func (fi *dirJunctFileInfo) Mode() os.FileMode {
 	// Simulate a directory and not a symlink; also set the execute
 	// bits so the directory can be traversed Unix-side.
-	return fi.FileInfo.Mode() ^ os.ModeSymlink | os.ModeDir | 0111
+	return fi.FileInfo.Mode() ^ junctionPointModeMask | os.ModeDir | 0111
 }

 func (fi *dirJunctFileInfo) IsDir() bool {
 	return true
 }

-type dedupFileInfo struct {
-	os.FileInfo
-}
+var junctionPointModeMask os.FileMode

-func (fi *dedupFileInfo) Mode() os.FileMode {
-	// A deduplicated file should be treated as a regular file and not an
-	// irregular file.
-	return fi.FileInfo.Mode() &^ os.ModeIrregular
+func init() {
+	junctionPointModeMask = os.ModeSymlink
+	if version.Compare(runtime.Version(), "go1.23") >= 0 {
+		// if GODEBUG=winsymlink=0, then we are in g1.22 mode so let's check for
+		// os.ModeSymlink as well, as it can't hurt.
+		junctionPointModeMask |= os.ModeIrregular
+	}
 }

 func (f *BasicFilesystem) underlyingLstat(name string) (os.FileInfo, error) {
@@ -96,19 +93,11 @@ func (f *BasicFilesystem) underlyingLstat(name string) (os.FileInfo, error) {
 	if err == nil {
 		// NTFS directory junctions can be treated as ordinary directories,
 		// see https://forum.syncthing.net/t/option-to-follow-directory-junctions-symbolic-links/14750
-		if fi.Mode()&os.ModeSymlink != 0 && f.junctionsAsDirs {
+		if fi.Mode()&junctionPointModeMask != 0 && f.junctionsAsDirs {
 			if reparseTag, reparseErr := readReparseTag(name); reparseErr == nil && isDirectoryJunction(reparseTag) {
 				return &dirJunctFileInfo{fi}, nil
 			}
 		}
-
-		// Workaround for #9120 till golang properly handles deduplicated files by
-		// considering them regular files.
-		if fi.Mode()&os.ModeIrregular != 0 {
-			if reparseTag, reparseErr := readReparseTag(name); reparseErr == nil && isDeduplicatedFile(reparseTag) {
-				return &dedupFileInfo{fi}, nil
-			}
-		}
 	}

 	return fi, err
@@ -54,18 +54,20 @@ const randomBlockShift = 14 // 128k
 //     latency=d  to set the amount of time each "disk" operation takes, where d is time.ParseDuration format
 //     content=true to save actual file contents instead of generating pseudorandomly; n.b. memory usage
 //     nostfolder=true skip the creation of .stfolder
+//     timeprecisionsecond=true Modification times are stored with only second precision
 //
 // - Two fakeFS:s pointing at the same root path see the same files.
 type fakeFS struct {
-	counters    fakeFSCounters
-	uri         string
-	mut         sync.Mutex
-	root        *fakeEntry
-	insens      bool
-	withContent bool
-	latency     time.Duration
-	userCache   *userCache
-	groupCache  *groupCache
+	counters            fakeFSCounters
+	uri                 string
+	mut                 sync.Mutex
+	root                *fakeEntry
+	insens              bool
+	withContent         bool
+	timePrecisionSecond bool
+	latency             time.Duration
+	userCache           *userCache
+	groupCache          *groupCache
 }

 type fakeFSCounters struct {
@@ -126,6 +128,7 @@ func newFakeFilesystem(rootURI string, _ ...Option) *fakeFS {
 	fs.insens = params.Get("insens") == "true"
 	fs.withContent = params.Get("content") == "true"
 	nostfolder := params.Get("nostfolder") == "true"
+	fs.timePrecisionSecond = params.Get("timeprecisionsecond") == "true"

 	if sizeavg == 0 {
 		sizeavg = 1 << 20
@@ -259,6 +262,9 @@ func (fs *fakeFS) Chtimes(name string, _ time.Time, mtime time.Time) error {
 	if entry == nil {
 		return os.ErrNotExist
 	}
+	if fs.timePrecisionSecond {
+		mtime = mtime.Truncate(time.Second)
+	}
 	entry.mtime = mtime
 	return nil
 }
@@ -261,6 +261,11 @@ func NewFilesystem(fsType FilesystemType, uri string, opts ...Option) Filesystem
 		}
 	}

+	// Case handling is the innermost, as any filesystem calls by wrappers should be case-resolved
+	if caseOpt != nil {
+		fs = caseOpt.apply(fs)
+	}
+
 	// mtime handling should happen inside walking, as filesystem calls while
 	// walking should be mtime-resolved too
 	if mtimeOpt != nil {
@@ -269,35 +274,15 @@ func NewFilesystem(fsType FilesystemType, uri string, opts ...Option) Filesystem

 	fs = &metricsFS{next: fs}

-	layersAboveWalkFilesystem := 0
-	if caseOpt != nil {
-		// DirNames calls made to check the case of a name will also be
-		// attributed to the calling function.
-		layersAboveWalkFilesystem++
-	}
 	if l.ShouldDebug("walkfs") {
-		// A walkFilesystem is not a layer to skip, it embeds the underlying
-		// filesystem, passing calls directly trough. Except for calls made
-		// during walking, however those are truly originating in the walk
-		// filesystem.
-		fs = NewWalkFilesystem(newLogFilesystem(fs, layersAboveWalkFilesystem))
-	} else if l.ShouldDebug("fs") {
-		fs = newLogFilesystem(NewWalkFilesystem(fs), layersAboveWalkFilesystem)
-	} else {
-		fs = NewWalkFilesystem(fs)
+		return NewWalkFilesystem(&logFilesystem{fs})
 	}

-	// Case handling is at the outermost layer to resolve all input names.
-	// Reason being is that the only names/paths that are potentially "wrong"
-	// come from outside the fs package. Any paths that result from filesystem
-	// operations itself already have the correct case. Thus there's e.g. no
-	// point to check the case on all the stating the walk filesystem does, it
-	// just adds overhead.
-	if caseOpt != nil {
-		fs = caseOpt.apply(fs)
+	if l.ShouldDebug("fs") {
+		return &logFilesystem{NewWalkFilesystem(fs)}
 	}

-	return fs
+	return NewWalkFilesystem(fs)
 }

 // IsInternal returns true if the file, as a path relative to the folder
@@ -7,8 +7,10 @@
 package fs

 import (
+	"fmt"
 	"path/filepath"
 	"testing"
+	"time"

 	"github.com/syncthing/syncthing/lib/build"
 )
@@ -171,3 +173,64 @@ func TestIsParent(t *testing.T) {
 		}
 	}
 }
+
+// Reproduces issue 9677:
+// The combination of caching the entire case FS and moving the case FS to be
+// the outmost layer of the FS lead to the mtime FS disappearing. This is
+// because in many places we intentionally create the filesystem without access
+// to the DB and thus without the mtime FS layer. With the case FS layer
+// outside, all the inner layers are also cached - notable without an mtime FS
+// layer. Later when we do try to create an FS with DB/mtime FS, we still get
+// the cached FS without mtime FS.
+func TestRepro9677MissingMtimeFS(t *testing.T) {
+	mtimeDB := make(mapStore)
+	name := "Testfile"
+	nameLower := UnicodeLowercaseNormalized(name)
+	testTime := time.Unix(1723491493, 123456789)
+
+	// Create a file with an mtime FS entry
+	firstFS := NewFilesystem(FilesystemTypeFake, fmt.Sprintf("%v?insens=true&timeprecisionsecond=true", t.Name()), &OptionDetectCaseConflicts{}, NewMtimeOption(mtimeDB))
+
+	// Create a file, set its mtime and check that we get the expected mtime when stat-ing.
+	file, err := firstFS.Create(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file.Close()
+	err = firstFS.Chtimes(name, testTime, testTime)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	checkMtime := func(fs Filesystem) {
+		t.Helper()
+		info, err := fs.Lstat(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !info.ModTime().Equal(testTime) {
+			t.Errorf("Expected mtime %v for %v, got %v", testTime, name, info.ModTime())
+		}
+		info, err = fs.Lstat(nameLower)
+		if !IsErrCaseConflict(err) {
+			t.Errorf("Expected case-conflict error, got %v", err)
+		}
+	}
+
+	checkMtime(firstFS)
+
+	// Now syncthing gets upgraded (or even just restarted), which resets the
+	// case FS registry as it lives in memory.
+	globalCaseFilesystemRegistry = caseFilesystemRegistry{fss: make(map[fskey]*caseFilesystem)}
+
+	// This time we first create some filesystem without a database and thus no
+	// mtime-FS, which is used in various places outside of the folder code. We
+	// aren't actually going to do anything, this just adds an entry to the
+	// caseFS cache. And that's the crucial bit: In the broken case this test is
+	// reproducing, it will add the FS without mtime-FS, so all future FSes will
+	// be without mtime, even if requested:
+	NewFilesystem(FilesystemTypeFake, fmt.Sprintf("%v?insens=true&timeprecisionsecond=true", t.Name()), &OptionDetectCaseConflicts{})
+
+	newFS := NewFilesystem(FilesystemTypeFake, fmt.Sprintf("%v?insens=true&timeprecisionsecond=true", t.Name()), &OptionDetectCaseConflicts{}, NewMtimeOption(mtimeDB))
+	checkMtime(newFS)
+}
@@ -16,20 +16,10 @@ import (

 type logFilesystem struct {
 	Filesystem
-	// Number of filesystem layers on top of logFilesystem to skip when looking
-	// for the true caller of the filesystem
-	layers int
 }

-func newLogFilesystem(fs Filesystem, layers int) *logFilesystem {
-	return &logFilesystem{
-		Filesystem: fs,
-		layers:     layers,
-	}
-}
-
-func (fs *logFilesystem) getCaller() string {
-	_, file, line, ok := runtime.Caller(fs.layers + 1)
+func getCaller() string {
+	_, file, line, ok := runtime.Caller(2)
 	if !ok {
 		return "unknown"
 	}
@@ -38,139 +28,139 @@ func (fs *logFilesystem) getCaller() string {

 func (fs *logFilesystem) Chmod(name string, mode FileMode) error {
 	err := fs.Filesystem.Chmod(name, mode)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Chmod", name, mode, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Chmod", name, mode, err)
 	return err
 }

 func (fs *logFilesystem) Chtimes(name string, atime time.Time, mtime time.Time) error {
 	err := fs.Filesystem.Chtimes(name, atime, mtime)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Chtimes", name, atime, mtime, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Chtimes", name, atime, mtime, err)
 	return err
 }

 func (fs *logFilesystem) Create(name string) (File, error) {
 	file, err := fs.Filesystem.Create(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Create", name, file, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Create", name, file, err)
 	return file, err
 }

 func (fs *logFilesystem) CreateSymlink(target, name string) error {
 	err := fs.Filesystem.CreateSymlink(target, name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "CreateSymlink", target, name, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "CreateSymlink", target, name, err)
 	return err
 }

 func (fs *logFilesystem) DirNames(name string) ([]string, error) {
 	names, err := fs.Filesystem.DirNames(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "DirNames", name, names, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "DirNames", name, names, err)
 	return names, err
 }

 func (fs *logFilesystem) Lstat(name string) (FileInfo, error) {
 	info, err := fs.Filesystem.Lstat(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Lstat", name, info, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Lstat", name, info, err)
 	return info, err
 }

 func (fs *logFilesystem) Mkdir(name string, perm FileMode) error {
 	err := fs.Filesystem.Mkdir(name, perm)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Mkdir", name, perm, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Mkdir", name, perm, err)
 	return err
 }

 func (fs *logFilesystem) MkdirAll(name string, perm FileMode) error {
 	err := fs.Filesystem.MkdirAll(name, perm)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "MkdirAll", name, perm, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "MkdirAll", name, perm, err)
 	return err
 }

 func (fs *logFilesystem) Open(name string) (File, error) {
 	file, err := fs.Filesystem.Open(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Open", name, file, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Open", name, file, err)
 	return file, err
 }

 func (fs *logFilesystem) OpenFile(name string, flags int, mode FileMode) (File, error) {
 	file, err := fs.Filesystem.OpenFile(name, flags, mode)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "OpenFile", name, flags, mode, file, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "OpenFile", name, flags, mode, file, err)
 	return file, err
 }

 func (fs *logFilesystem) ReadSymlink(name string) (string, error) {
 	target, err := fs.Filesystem.ReadSymlink(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "ReadSymlink", name, target, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "ReadSymlink", name, target, err)
 	return target, err
 }

 func (fs *logFilesystem) Remove(name string) error {
 	err := fs.Filesystem.Remove(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Remove", name, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Remove", name, err)
 	return err
 }

 func (fs *logFilesystem) RemoveAll(name string) error {
 	err := fs.Filesystem.RemoveAll(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "RemoveAll", name, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "RemoveAll", name, err)
 	return err
 }

 func (fs *logFilesystem) Rename(oldname, newname string) error {
 	err := fs.Filesystem.Rename(oldname, newname)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Rename", oldname, newname, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Rename", oldname, newname, err)
 	return err
 }

 func (fs *logFilesystem) Stat(name string) (FileInfo, error) {
 	info, err := fs.Filesystem.Stat(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Stat", name, info, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Stat", name, info, err)
 	return info, err
 }

 func (fs *logFilesystem) SymlinksSupported() bool {
 	supported := fs.Filesystem.SymlinksSupported()
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "SymlinksSupported", supported)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "SymlinksSupported", supported)
 	return supported
 }

 func (fs *logFilesystem) Walk(root string, walkFn WalkFunc) error {
 	err := fs.Filesystem.Walk(root, walkFn)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Walk", root, walkFn, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Walk", root, walkFn, err)
 	return err
 }

 func (fs *logFilesystem) Watch(path string, ignore Matcher, ctx context.Context, ignorePerms bool) (<-chan Event, <-chan error, error) {
 	evChan, errChan, err := fs.Filesystem.Watch(path, ignore, ctx, ignorePerms)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Watch", path, ignore, ignorePerms, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Watch", path, ignore, ignorePerms, err)
 	return evChan, errChan, err
 }

 func (fs *logFilesystem) Unhide(name string) error {
 	err := fs.Filesystem.Unhide(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Unhide", name, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Unhide", name, err)
 	return err
 }

 func (fs *logFilesystem) Hide(name string) error {
 	err := fs.Filesystem.Hide(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Hide", name, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Hide", name, err)
 	return err
 }

 func (fs *logFilesystem) Glob(name string) ([]string, error) {
 	names, err := fs.Filesystem.Glob(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Glob", name, names, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Glob", name, names, err)
 	return names, err
 }

 func (fs *logFilesystem) Roots() ([]string, error) {
 	roots, err := fs.Filesystem.Roots()
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Roots", roots, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Roots", roots, err)
 	return roots, err
 }

 func (fs *logFilesystem) Usage(name string) (Usage, error) {
 	usage, err := fs.Filesystem.Usage(name)
-	l.Debugln(fs.getCaller(), fs.Type(), fs.URI(), "Usage", name, usage, err)
+	l.Debugln(getCaller(), fs.Type(), fs.URI(), "Usage", name, usage, err)
 	return usage, err
 }

@@ -30,8 +30,8 @@ func newFakeConnection(id protocol.DeviceID, model Model) *fakeConnection {
 		model:      model,
 		closed:     make(chan struct{}),
 	}
-	f.RequestCalls(func(ctx context.Context, folder, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
-		return f.fileData[name], nil
+	f.RequestCalls(func(ctx context.Context, req *protocol.Request) ([]byte, error) {
+		return f.fileData[req.Name], nil
 	})
 	f.DeviceIDReturns(id)
 	f.ConnectionIDReturns(rand.String(16))
@@ -60,14 +60,16 @@ type fakeConnection struct {
 }

 func (f *fakeConnection) setIndexFn(fn func(_ context.Context, folder string, fs []protocol.FileInfo) error) {
-	f.IndexCalls(fn)
-	f.IndexUpdateCalls(fn)
+	f.IndexCalls(func(ctx context.Context, idx *protocol.Index) error { return fn(ctx, idx.Folder, idx.Files) })
+	f.IndexUpdateCalls(func(ctx context.Context, idxUp *protocol.IndexUpdate) error {
+		return fn(ctx, idxUp.Folder, idxUp.Files)
+	})
 }

-func (f *fakeConnection) DownloadProgress(_ context.Context, folder string, updates []protocol.FileDownloadProgressUpdate) {
+func (f *fakeConnection) DownloadProgress(_ context.Context, dp *protocol.DownloadProgress) {
 	f.downloadProgressMessages = append(f.downloadProgressMessages, downloadProgressMessage{
-		folder:  folder,
-		updates: updates,
+		folder:  dp.Folder,
+		updates: dp.Updates,
 	})
 }

@@ -17,6 +17,7 @@ import (
 	"github.com/syncthing/syncthing/lib/events"
 	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/svcutil"
+	"github.com/syncthing/syncthing/lib/ur"
 )

 type indexHandler struct {
@@ -222,15 +223,49 @@ func (s *indexHandler) pause() {
 // sendIndexTo sends file infos with a sequence number higher than prevSequence and
 // returns the highest sent sequence number.
 func (s *indexHandler) sendIndexTo(ctx context.Context, fset *db.FileSet) error {
+	// Keep track of the previous sequence we sent. This is separate from
+	// s.prevSequence because the latter will skip over holes in the
+	// sequence numberings, while sentPrevSequence should always be
+	// precisely the highest previously sent sequence.
+	sentPrevSequence := s.prevSequence
+
 	initial := s.prevSequence == 0
 	batch := db.NewFileInfoBatch(nil)
+	var batchError error
 	batch.SetFlushFunc(func(fs []protocol.FileInfo) error {
+		if len(fs) == 0 {
+			// can't happen, flush is not called with an empty batch
+			panic("bug: flush called with empty batch (race condition?)")
+		}
+		if batchError != nil {
+			// can't happen, once an error is returned the index sender exits
+			panic(fmt.Sprintf("bug: once failed it should stay failed (%v)", batchError))
+		}
 		l.Debugf("%v: Sending %d files (<%d bytes)", s, len(fs), batch.Size())
+
+		lastSequence := fs[len(fs)-1].Sequence
+		var err error
 		if initial {
 			initial = false
-			return s.conn.Index(ctx, s.folder, fs)
+			err = s.conn.Index(ctx, &protocol.Index{
+				Folder:       s.folder,
+				Files:        fs,
+				LastSequence: lastSequence,
+			})
+		} else {
+			err = s.conn.IndexUpdate(ctx, &protocol.IndexUpdate{
+				Folder:       s.folder,
+				Files:        fs,
+				PrevSequence: sentPrevSequence,
+				LastSequence: lastSequence,
+			})
 		}
-		return s.conn.IndexUpdate(ctx, s.folder, fs)
+		if err != nil {
+			batchError = err
+			return err
+		}
+		sentPrevSequence = lastSequence
+		return nil
 	})

 	var err error
@@ -251,14 +286,19 @@ func (s *indexHandler) sendIndexTo(ctx context.Context, fset *db.FileSet) error
 			}
 		}

-		if shouldDebug() {
-			if fi.SequenceNo() < s.prevSequence+1 {
-				panic(fmt.Sprintln("sequence lower than requested, got:", fi.SequenceNo(), ", asked to start at:", s.prevSequence+1))
-			}
+		if fi.SequenceNo() < s.prevSequence+1 {
+			s.logSequenceAnomaly("database returned sequence lower than requested", map[string]any{
+				"sequence": fi.SequenceNo(),
+				"start":    s.prevSequence + 1,
+			})
 		}

 		if f.Sequence > 0 && fi.SequenceNo() <= f.Sequence {
-			l.Warnln("Non-increasing sequence detected: Checking and repairing the db...")
+			s.logSequenceAnomaly("database returned non-increasing sequence", map[string]any{
+				"sequence": fi.SequenceNo(),
+				"start":    s.prevSequence + 1,
+				"previous": f.Sequence,
+			})
 			// Abort this round of index sending - the next one will pick
 			// up from the last successful one with the repeaired db.
 			defer func() {
@@ -307,7 +347,7 @@ func (s *indexHandler) sendIndexTo(ctx context.Context, fset *db.FileSet) error
 	return nil
 }

-func (s *indexHandler) receive(fs []protocol.FileInfo, update bool, op string) error {
+func (s *indexHandler) receive(fs []protocol.FileInfo, update bool, op string, prevSequence, lastSequence int64) error {
 	deviceID := s.conn.DeviceID()

 	s.cond.L.Lock()
@@ -328,12 +368,66 @@ func (s *indexHandler) receive(fs []protocol.FileInfo, update bool, op string) e
 	if !update {
 		fset.Drop(deviceID)
 	}
+
+	l.Debugf("Received %d files for %s from %s, prevSeq=%d, lastSeq=%d", len(fs), s.folder, deviceID.Short(), prevSequence, lastSequence)
+
+	// Verify that the previous sequence number matches what we expected
+	if exp := fset.Sequence(deviceID); prevSequence > 0 && prevSequence != exp {
+		s.logSequenceAnomaly("index update with unexpected sequence", map[string]any{
+			"prevSeq":      prevSequence,
+			"lastSeq":      lastSequence,
+			"batch":        len(fs),
+			"expectedPrev": exp,
+		})
+	}
+
 	for i := range fs {
+		// Verify index in relation to the claimed sequence boundaries
+		if fs[i].Sequence < prevSequence {
+			s.logSequenceAnomaly("file with sequence before prevSequence", map[string]any{
+				"prevSeq": prevSequence,
+				"lastSeq": lastSequence,
+				"batch":   len(fs),
+				"seenSeq": fs[i].Sequence,
+				"atIndex": i,
+			})
+		}
+		if lastSequence > 0 && fs[i].Sequence > lastSequence {
+			s.logSequenceAnomaly("file with sequence after lastSequence", map[string]any{
+				"prevSeq": prevSequence,
+				"lastSeq": lastSequence,
+				"batch":   len(fs),
+				"seenSeq": fs[i].Sequence,
+				"atIndex": i,
+			})
+		}
+		if i > 0 && fs[i].Sequence <= fs[i-1].Sequence {
+			s.logSequenceAnomaly("index update with non-increasing sequence", map[string]any{
+				"prevSeq":      prevSequence,
+				"lastSeq":      lastSequence,
+				"batch":        len(fs),
+				"seenSeq":      fs[i].Sequence,
+				"atIndex":      i,
+				"precedingSeq": fs[i-1].Sequence,
+			})
+		}
+
 		// The local attributes should never be transmitted over the wire.
 		// Make sure they look like they weren't.
 		fs[i].LocalFlags = 0
 		fs[i].VersionHash = nil
 	}
+
+	// Verify the claimed last sequence number
+	if lastSequence > 0 && len(fs) > 0 && lastSequence != fs[len(fs)-1].Sequence {
+		s.logSequenceAnomaly("index update with unexpected last sequence", map[string]any{
+			"prevSeq": prevSequence,
+			"lastSeq": lastSequence,
+			"batch":   len(fs),
+			"seenSeq": fs[len(fs)-1].Sequence,
+		})
+	}
+
 	fset.Update(deviceID, fs)

 	seq := fset.Sequence(deviceID)
@@ -348,6 +442,24 @@ func (s *indexHandler) receive(fs []protocol.FileInfo, update bool, op string) e
 	return nil
 }

+var warnSequenceAnomalyOnce sync.Once
+
+func (s *indexHandler) logSequenceAnomaly(msg string, extra map[string]any) {
+	warnSequenceAnomalyOnce.Do(func() {
+		l.Warnf("Index sequence anomaly detected (please report at https://forum.syncthing.net/t/22660): %s (%v)", msg, extra)
+	})
+
+	extraStrs := make(map[string]string, len(extra))
+	for k, v := range extra {
+		extraStrs[k] = fmt.Sprint(v)
+	}
+
+	s.evLogger.Log(events.Failure, ur.FailureData{
+		Description: msg,
+		Extra:       extraStrs,
+	})
+}
+
 func prepareFileInfoForIndex(f protocol.FileInfo) protocol.FileInfo {
 	// Mark the file as invalid if any of the local bad stuff flags are set.
 	f.RawInvalid = f.IsInvalid()
@@ -534,7 +646,7 @@ func (r *indexHandlerRegistry) folderRunningLocked(folder config.FolderConfigura
 	}
 }

-func (r *indexHandlerRegistry) ReceiveIndex(folder string, fs []protocol.FileInfo, update bool, op string) error {
+func (r *indexHandlerRegistry) ReceiveIndex(folder string, fs []protocol.FileInfo, update bool, op string, prevSequence, lastSequence int64) error {
 	r.mut.Lock()
 	defer r.mut.Unlock()
 	is, isOk := r.indexHandlers.Get(folder)
@@ -542,7 +654,7 @@ func (r *indexHandlerRegistry) ReceiveIndex(folder string, fs []protocol.FileInf
 		l.Infof("%v for nonexistent or paused folder %q", op, folder)
 		return fmt.Errorf("%s: %w", folder, ErrFolderMissing)
 	}
-	return is.receive(fs, update, op)
+	return is.receive(fs, update, op, prevSequence, lastSequence)
 }

 // makeForgetUpdate takes an index update and constructs a download progress update
@@ -40,10 +40,10 @@ func TestIndexhandlerConcurrency(t *testing.T) {
 	c2.Start()
 	defer c2.Close(io.EOF)

-	c1.ClusterConfig(protocol.ClusterConfig{})
-	c2.ClusterConfig(protocol.ClusterConfig{})
-	c1.Index(ctx, "foo", nil)
-	c2.Index(ctx, "foo", nil)
+	c1.ClusterConfig(&protocol.ClusterConfig{})
+	c2.ClusterConfig(&protocol.ClusterConfig{})
+	c1.Index(ctx, &protocol.Index{Folder: "foo"})
+	c2.Index(ctx, &protocol.Index{Folder: "foo"})

 	const msgs = 5e2
 	const files = 1e3
@@ -64,7 +64,7 @@ func TestIndexhandlerConcurrency(t *testing.T) {
 	})

 	b1 := db.NewFileInfoBatch(func(fs []protocol.FileInfo) error {
-		return c1.IndexUpdate(ctx, "foo", fs)
+		return c1.IndexUpdate(ctx, &protocol.IndexUpdate{Folder: "foo", Files: fs})
 	})
 	sentEntries := 0
 	for i := 0; i < msgs; i++ {
@@ -1136,16 +1136,16 @@ func (p *pager) done() bool {
 // Index is called when a new device is connected and we receive their full index.
 // Implements the protocol.Model interface.
 func (m *model) Index(conn protocol.Connection, idx *protocol.Index) error {
-	return m.handleIndex(conn, idx.Folder, idx.Files, false)
+	return m.handleIndex(conn, idx.Folder, idx.Files, false, 0, idx.LastSequence)
 }

 // IndexUpdate is called for incremental updates to connected devices' indexes.
 // Implements the protocol.Model interface.
 func (m *model) IndexUpdate(conn protocol.Connection, idxUp *protocol.IndexUpdate) error {
-	return m.handleIndex(conn, idxUp.Folder, idxUp.Files, true)
+	return m.handleIndex(conn, idxUp.Folder, idxUp.Files, true, idxUp.PrevSequence, idxUp.LastSequence)
 }

-func (m *model) handleIndex(conn protocol.Connection, folder string, fs []protocol.FileInfo, update bool) error {
+func (m *model) handleIndex(conn protocol.Connection, folder string, fs []protocol.FileInfo, update bool, prevSequence, lastSequence int64) error {
 	op := "Index"
 	if update {
 		op += " update"
@@ -1173,7 +1173,8 @@ func (m *model) handleIndex(conn protocol.Connection, folder string, fs []protoc
 		l.Debugf("%v for folder (ID %q) sent from device %q: missing index handler", op, folder, deviceID)
 		return fmt.Errorf("%s: %w", folder, ErrFolderNotRunning)
 	}
-	return indexHandler.ReceiveIndex(folder, fs, update, op)
+
+	return indexHandler.ReceiveIndex(folder, fs, update, op, prevSequence, lastSequence)
 }

 type clusterConfigDeviceInfo struct {
@@ -2414,7 +2415,7 @@ func (m *model) promoteConnections() {
 			if conn.Statistics().StartedAt.IsZero() {
 				conn.SetFolderPasswords(passwords)
 				conn.Start()
-				conn.ClusterConfig(protocol.ClusterConfig{Secondary: true})
+				conn.ClusterConfig(&protocol.ClusterConfig{Secondary: true})
 			}
 		}
 	}
@@ -2469,7 +2470,7 @@ func (m *model) RequestGlobal(ctx context.Context, deviceID protocol.DeviceID, f
 	}

 	l.Debugf("%v REQ(out): %s (%s): %q / %q b=%d o=%d s=%d h=%x wh=%x ft=%t", m, deviceID.Short(), conn, folder, name, blockNo, offset, size, hash, weakHash, fromTemporary)
-	return conn.Request(ctx, folder, name, blockNo, offset, size, hash, weakHash, fromTemporary)
+	return conn.Request(ctx, &protocol.Request{Folder: folder, Name: name, BlockNo: blockNo, Offset: offset, Size: size, Hash: hash, WeakHash: weakHash, FromTemporary: fromTemporary})
 }

 // requestConnectionForDevice returns a connection to the given device, to
@@ -2586,14 +2587,14 @@ func (m *model) numHashers(folder string) int {

 // generateClusterConfig returns a ClusterConfigMessage that is correct and the
 // set of folder passwords for the given peer device
-func (m *model) generateClusterConfig(device protocol.DeviceID) (protocol.ClusterConfig, map[string]string) {
+func (m *model) generateClusterConfig(device protocol.DeviceID) (*protocol.ClusterConfig, map[string]string) {
 	m.mut.RLock()
 	defer m.mut.RUnlock()
 	return m.generateClusterConfigRLocked(device)
 }

-func (m *model) generateClusterConfigRLocked(device protocol.DeviceID) (protocol.ClusterConfig, map[string]string) {
-	var message protocol.ClusterConfig
+func (m *model) generateClusterConfigRLocked(device protocol.DeviceID) (*protocol.ClusterConfig, map[string]string) {
+	message := &protocol.ClusterConfig{}
 	folders := m.cfg.FolderList()
 	passwords := make(map[string]string, len(folders))
 	for _, folderCfg := range folders {
@@ -3631,11 +3631,11 @@ func testConfigChangeTriggersClusterConfigs(t *testing.T, expectFirst, expectSec
 	cc1 := make(chan struct{}, 1)
 	cc2 := make(chan struct{}, 1)
 	fc1 := newFakeConnection(device1, m)
-	fc1.ClusterConfigCalls(func(_ protocol.ClusterConfig) {
+	fc1.ClusterConfigCalls(func(_ *protocol.ClusterConfig) {
 		cc1 <- struct{}{}
 	})
 	fc2 := newFakeConnection(device2, m)
-	fc2.ClusterConfigCalls(func(_ protocol.ClusterConfig) {
+	fc2.ClusterConfigCalls(func(_ *protocol.ClusterConfig) {
 		cc2 <- struct{}{}
 	})
 	m.AddConnection(fc1, protocol.Hello{})
@@ -39,7 +39,7 @@ type progressUpdate struct {
 }

 func (p progressUpdate) send(ctx context.Context) {
-	p.conn.DownloadProgress(ctx, p.folder, p.updates)
+	p.conn.DownloadProgress(ctx, &protocol.DownloadProgress{Folder: p.folder, Updates: p.updates})
 }

 // NewProgressEmitter creates a new progress emitter which emits
@@ -334,7 +334,7 @@ func (t *ProgressEmitter) clearLocked() {
 		}
 		for _, folder := range state.folders() {
 			if updates := state.cleanup(folder); len(updates) > 0 {
-				conn.DownloadProgress(context.Background(), folder, updates)
+				conn.DownloadProgress(context.Background(), &protocol.DownloadProgress{Folder: folder, Updates: updates})
 			}
 		}
 	}
@@ -143,11 +143,11 @@ func TestSymlinkTraversalWrite(t *testing.T) {
 		}
 		return nil
 	})
-	fc.RequestCalls(func(ctx context.Context, folder, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
-		if name != "symlink" && strings.HasPrefix(name, "symlink") {
-			badReq <- name
+	fc.RequestCalls(func(ctx context.Context, req *protocol.Request) ([]byte, error) {
+		if req.Name != "symlink" && strings.HasPrefix(req.Name, "symlink") {
+			badReq <- req.Name
 		}
-		return fc.fileData[name], nil
+		return fc.fileData[req.Name], nil
 	})

 	// Send an update for the symlink, wait for it to sync and be reported back.
@@ -338,7 +338,7 @@ func pullInvalidIgnored(t *testing.T, ft config.FolderType) {
 	})
 	// Make sure pulling doesn't interfere, as index updates are racy and
 	// thus we cannot distinguish between scan and pull results.
-	fc.RequestCalls(func(ctx context.Context, folder, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
+	fc.RequestCalls(func(_ context.Context, _ *protocol.Request) ([]byte, error) {
 		return nil, nil
 	})

@@ -926,7 +926,7 @@ func TestNeedFolderFiles(t *testing.T) {
 	defer sub.Unsubscribe()

 	errPreventSync := errors.New("you aren't getting any of this")
-	fc.RequestCalls(func(ctx context.Context, folder, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
+	fc.RequestCalls(func(_ context.Context, _ *protocol.Request) ([]byte, error) {
 		return nil, errPreventSync
 	})

@@ -1065,9 +1065,9 @@ func TestRequestLastFileProgress(t *testing.T) {

 	done := make(chan struct{})

-	fc.RequestCalls(func(ctx context.Context, folder, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
+	fc.RequestCalls(func(_ context.Context, req *protocol.Request) ([]byte, error) {
 		defer close(done)
-		progress, queued, rest, err := m.NeedFolderFiles(folder, 1, 10)
+		progress, queued, rest, err := m.NeedFolderFiles(req.Folder, 1, 10)
 		must(t, err)
 		if len(queued)+len(rest) != 0 {
 			t.Error(`There should not be any queued or "rest" items`)
@@ -1075,7 +1075,7 @@ func TestRequestLastFileProgress(t *testing.T) {
 		if len(progress) != 1 {
 			t.Error("Expected exactly one item in progress.")
 		}
-		return fc.fileData[name], nil
+		return fc.fileData[req.Name], nil
 	})

 	contents := []byte("test file contents\n")
@@ -1232,7 +1232,7 @@ func TestRequestIndexSenderClusterConfigBeforeStart(t *testing.T) {
 	done := make(chan struct{})
 	defer close(done) // Must be the last thing to be deferred, thus first to run.
 	indexChan := make(chan []protocol.FileInfo, 1)
-	ccChan := make(chan protocol.ClusterConfig, 1)
+	ccChan := make(chan *protocol.ClusterConfig, 1)
 	fc.setIndexFn(func(_ context.Context, folder string, fs []protocol.FileInfo) error {
 		select {
 		case indexChan <- fs:
@@ -1240,7 +1240,7 @@ func TestRequestIndexSenderClusterConfigBeforeStart(t *testing.T) {
 		}
 		return nil
 	})
-	fc.ClusterConfigCalls(func(cc protocol.ClusterConfig) {
+	fc.ClusterConfigCalls(func(cc *protocol.ClusterConfig) {
 		select {
 		case ccChan <- cc:
 		case <-done:
@@ -66,8 +66,8 @@ func benchmarkRequestsConnPair(b *testing.B, conn0, conn1 net.Conn) {
 	c1.Start()

 	// Satisfy the assertions in the protocol by sending an initial cluster config
-	c0.ClusterConfig(ClusterConfig{})
-	c1.ClusterConfig(ClusterConfig{})
+	c0.ClusterConfig(&ClusterConfig{})
+	c1.ClusterConfig(&ClusterConfig{})

 	// Report some useful stats and reset the timer for the actual test
 	b.ReportAllocs()
@@ -82,9 +82,9 @@ func benchmarkRequestsConnPair(b *testing.B, conn0, conn1 net.Conn) {
 		// Use c0 and c1 for each alternating request, so we get as much
 		// data flowing in both directions.
 		if i%2 == 0 {
-			buf, err = c0.Request(context.Background(), "folder", "file", i, int64(i), 128<<10, nil, 0, false)
+			buf, err = c0.Request(context.Background(), &Request{Folder: "folder", Name: "file", BlockNo: i, Offset: int64(i), Size: 128 << 10})
 		} else {
-			buf, err = c1.Request(context.Background(), "folder", "file", i, int64(i), 128<<10, nil, 0, false)
+			buf, err = c1.Request(context.Background(), &Request{Folder: "folder", Name: "file", BlockNo: i, Offset: int64(i), Size: 128 << 10})
 		}

 		if err != nil {
@@ -418,8 +418,9 @@ func (m *Device) XXX_DiscardUnknown() {
 var xxx_messageInfo_Device proto.InternalMessageInfo

 type Index struct {
-	Folder string     `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
-	Files  []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
+	Folder       string     `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
+	Files        []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
+	LastSequence int64      `protobuf:"varint,3,opt,name=last_sequence,json=lastSequence,proto3" json:"lastSequence" xml:"lastSequence"`
 }

 func (m *Index) Reset()         { *m = Index{} }
@@ -456,8 +457,10 @@ func (m *Index) XXX_DiscardUnknown() {
 var xxx_messageInfo_Index proto.InternalMessageInfo

 type IndexUpdate struct {
-	Folder string     `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
-	Files  []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
+	Folder       string     `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
+	Files        []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
+	LastSequence int64      `protobuf:"varint,3,opt,name=last_sequence,json=lastSequence,proto3" json:"lastSequence" xml:"lastSequence"`
+	PrevSequence int64      `protobuf:"varint,4,opt,name=prev_sequence,json=prevSequence,proto3" json:"prevSequence" xml:"prevSequence"`
 }

 func (m *IndexUpdate) Reset()         { *m = IndexUpdate{} }
@@ -1145,211 +1148,213 @@ func init() {
 func init() { proto.RegisterFile("lib/protocol/bep.proto", fileDescriptor_311ef540e10d9705) }

 var fileDescriptor_311ef540e10d9705 = []byte{
-	// 3251 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6c, 0x23, 0x47,
-	0x7a, 0x16, 0x9f, 0xa2, 0x4a, 0x8f, 0xa1, 0x6a, 0x5e, 0x34, 0x67, 0xac, 0x66, 0x6a, 0x67, 0x13,
-	0x59, 0x9b, 0x1d, 0xaf, 0xb5, 0xde, 0x8d, 0x63, 0x3b, 0x36, 0xc4, 0x87, 0x34, 0x5c, 0x6b, 0x48,
-	0xb9, 0xa8, 0x19, 0xaf, 0x07, 0x08, 0x88, 0x16, 0xbb, 0x44, 0x35, 0x86, 0xec, 0x66, 0xba, 0x9b,
-	0x7a, 0x2c, 0x72, 0x49, 0x16, 0x58, 0x2c, 0x74, 0x08, 0x82, 0x3d, 0x05, 0xc1, 0x0a, 0x59, 0xe4,
-	0x92, 0x5b, 0x80, 0x1c, 0x72, 0xd9, 0x53, 0x8e, 0x73, 0x1c, 0x2c, 0x10, 0x20, 0xc8, 0xa1, 0x01,
-	0xcf, 0x5c, 0x12, 0xe6, 0xc6, 0x63, 0x0e, 0x41, 0x50, 0x7f, 0x55, 0x57, 0x57, 0xeb, 0xe1, 0x68,
-	0xec, 0x43, 0x4e, 0xc3, 0xfa, 0xfe, 0xef, 0xff, 0xab, 0xba, 0xea, 0x7f, 0x55, 0x69, 0xd0, 0x9d,
-	0x81, 0xbd, 0xf7, 0xee, 0xc8, 0x73, 0x03, 0xb7, 0xe7, 0x0e, 0xde, 0xdd, 0x63, 0xa3, 0x87, 0x30,
-	0xc0, 0x85, 0x08, 0x2b, 0xcf, 0xb1, 0xe3, 0x40, 0x80, 0xe5, 0xef, 0x78, 0x6c, 0xe4, 0xfa, 0x82,
-	0xbe, 0x37, 0xde, 0x7f, 0xb7, 0xef, 0xf6, 0x5d, 0x18, 0xc0, 0x2f, 0x41, 0x22, 0xff, 0x93, 0x46,
-	0xb9, 0x47, 0x6c, 0x30, 0x70, 0x71, 0x0d, 0xcd, 0x5b, 0xec, 0xd0, 0xee, 0xb1, 0xae, 0x63, 0x0e,
-	0x59, 0x29, 0x55, 0x49, 0xad, 0xce, 0x55, 0xc9, 0x24, 0x34, 0x90, 0x80, 0x5b, 0xe6, 0x90, 0x4d,
-	0x43, 0xa3, 0x78, 0x3c, 0x1c, 0x7c, 0x48, 0x62, 0x88, 0x50, 0x4d, 0xce, 0x8d, 0xf4, 0x06, 0x36,
-	0x73, 0x02, 0x61, 0x24, 0x1d, 0x1b, 0x11, 0x70, 0xc2, 0x48, 0x0c, 0x11, 0xaa, 0xc9, 0x71, 0x1b,
-	0x2d, 0x49, 0x23, 0x87, 0xcc, 0xf3, 0x6d, 0xd7, 0x29, 0x65, 0xc0, 0xce, 0xea, 0x24, 0x34, 0x16,
-	0x85, 0xe4, 0xa9, 0x10, 0x4c, 0x43, 0xe3, 0xa6, 0x66, 0x4a, 0xa2, 0x84, 0x26, 0x59, 0xf8, 0x19,
-	0xba, 0xe1, 0x8c, 0x87, 0xdd, 0x9e, 0xeb, 0x38, 0xac, 0x17, 0xd8, 0xae, 0xe3, 0x97, 0xb2, 0x95,
-	0xd4, 0x6a, 0xae, 0xfa, 0xde, 0x24, 0x34, 0x96, 0x9c, 0xf1, 0xb0, 0x16, 0x4b, 0xa6, 0xa1, 0x71,
-	0x0b, 0x4c, 0x26, 0x61, 0xf2, 0xdf, 0xa1, 0x91, 0xb1, 0x9d, 0x80, 0x9e, 0xa3, 0xe3, 0x4f, 0xd0,
-	0x5c, 0x60, 0x0f, 0x99, 0x1f, 0x98, 0xc3, 0x51, 0x29, 0x57, 0x49, 0xad, 0x66, 0xaa, 0x95, 0x49,
-	0x68, 0xc4, 0xe0, 0x34, 0x34, 0x6e, 0x80, 0x41, 0x85, 0x10, 0x1a, 0x4b, 0xc9, 0x3f, 0xa5, 0x50,
-	0xfe, 0x11, 0x33, 0x2d, 0xe6, 0xe1, 0x0d, 0x94, 0x0d, 0x4e, 0x46, 0x62, 0xeb, 0x97, 0xd6, 0x6f,
-	0x3f, 0x8c, 0x0e, 0xf5, 0xe1, 0x63, 0xe6, 0xfb, 0x66, 0x9f, 0xed, 0x9e, 0x8c, 0x58, 0xf5, 0xce,
-	0x24, 0x34, 0x80, 0x36, 0x0d, 0x0d, 0x24, 0xec, 0x9e, 0x8c, 0x18, 0xa1, 0x80, 0x61, 0x0b, 0xcd,
-	0xf7, 0xdc, 0xe1, 0xc8, 0x63, 0x3e, 0xec, 0x5b, 0x1a, 0x2c, 0xdd, 0xbf, 0x60, 0xa9, 0x16, 0x73,
-	0xaa, 0x0f, 0x26, 0xa1, 0xa1, 0x2b, 0x4d, 0x43, 0x63, 0x59, 0xec, 0x69, 0x8c, 0x11, 0xaa, 0x33,
-	0xc8, 0xaf, 0x53, 0x68, 0xb1, 0x36, 0x18, 0xfb, 0x01, 0xf3, 0x6a, 0xae, 0xb3, 0x6f, 0xf7, 0xf1,
-	0x67, 0x68, 0x76, 0xdf, 0x1d, 0x58, 0xcc, 0xf3, 0x4b, 0xa9, 0x4a, 0x66, 0x75, 0x7e, 0xbd, 0x18,
-	0xcf, 0xb9, 0x09, 0x82, 0xaa, 0xf1, 0x22, 0x34, 0x66, 0x26, 0xa1, 0x11, 0x11, 0xa7, 0xa1, 0xb1,
-	0x00, 0xf3, 0x88, 0x31, 0xa1, 0x91, 0x80, 0x6f, 0xa9, 0xcf, 0x7a, 0xae, 0x63, 0x99, 0xde, 0x09,
-	0x7c, 0x42, 0x41, 0x6c, 0xa9, 0x02, 0xd5, 0x96, 0x2a, 0x84, 0xd0, 0x58, 0x4a, 0x7e, 0x9b, 0x45,
-	0x79, 0x31, 0x29, 0x7e, 0x88, 0xd2, 0xb6, 0x25, 0x7d, 0x79, 0xe5, 0x55, 0x68, 0xa4, 0x9b, 0xf5,
-	0x49, 0x68, 0xa4, 0x6d, 0x6b, 0x1a, 0x1a, 0x05, 0x30, 0x61, 0x5b, 0xe4, 0x57, 0x2f, 0x1f, 0xa4,
-	0x9b, 0x75, 0x9a, 0xb6, 0x2d, 0xfc, 0x10, 0xe5, 0x06, 0xe6, 0x1e, 0x1b, 0x48, 0xcf, 0x2d, 0x4d,
-	0x42, 0x43, 0x00, 0xd3, 0xd0, 0x98, 0x07, 0x3e, 0x8c, 0x08, 0x15, 0x28, 0xfe, 0x08, 0xcd, 0x79,
-	0xcc, 0xb4, 0xba, 0xae, 0x33, 0x38, 0x01, 0x2f, 0x2d, 0x54, 0x57, 0x26, 0xa1, 0x51, 0xe0, 0x60,
-	0xdb, 0x19, 0xf0, 0x95, 0x2e, 0x81, 0x5a, 0x04, 0x10, 0xaa, 0x64, 0xb8, 0x8b, 0xb0, 0xdd, 0x77,
-	0x5c, 0x8f, 0x75, 0x47, 0xcc, 0x1b, 0xda, 0xb0, 0xb7, 0xc2, 0x33, 0x0b, 0xd5, 0x1f, 0x4c, 0x42,
-	0x63, 0x59, 0x48, 0x77, 0x62, 0xe1, 0x34, 0x34, 0xee, 0x8a, 0x55, 0x9f, 0x97, 0x10, 0x7a, 0x91,
-	0x8d, 0x3f, 0x43, 0x8b, 0x72, 0x02, 0x8b, 0x0d, 0x58, 0xc0, 0xc0, 0x3f, 0x0b, 0xd5, 0xdf, 0x9f,
-	0x84, 0xc6, 0x82, 0x10, 0xd4, 0x01, 0x9f, 0x86, 0x06, 0xd6, 0xcc, 0x0a, 0x90, 0xd0, 0x04, 0x07,
-	0x5b, 0xe8, 0x96, 0x65, 0xfb, 0xe6, 0xde, 0x80, 0x75, 0x03, 0x36, 0x1c, 0x75, 0x6d, 0xc7, 0x62,
-	0xc7, 0xcc, 0x2f, 0xe5, 0xc1, 0xe6, 0xfa, 0x24, 0x34, 0xb0, 0x94, 0xef, 0xb2, 0xe1, 0xa8, 0x29,
-	0xa4, 0xd3, 0xd0, 0x28, 0x89, 0x84, 0x71, 0x41, 0x44, 0xe8, 0x25, 0x7c, 0xbc, 0x8e, 0xf2, 0x23,
-	0x73, 0xec, 0x33, 0xab, 0x34, 0x0b, 0x76, 0xcb, 0x93, 0xd0, 0x90, 0x88, 0x72, 0x18, 0x31, 0x24,
-	0x54, 0xe2, 0xdc, 0xf9, 0x44, 0x0a, 0xf2, 0x4b, 0xc5, 0xf3, 0xce, 0x57, 0x07, 0x41, 0xec, 0x7c,
-	0x92, 0xa8, 0x6c, 0x89, 0x31, 0xa1, 0x91, 0x80, 0xfc, 0x4b, 0x1e, 0xe5, 0x85, 0x12, 0xae, 0x2a,
-	0xe7, 0x59, 0xa8, 0xae, 0x73, 0x03, 0xff, 0x1e, 0x1a, 0x05, 0x21, 0x6b, 0xd6, 0xaf, 0x72, 0xa6,
-	0x5f, 0xbe, 0x7c, 0x90, 0xd2, 0x1c, 0x6a, 0x0d, 0x65, 0xb5, 0x4c, 0x08, 0xc1, 0xeb, 0x88, 0x1c,
-	0x28, 0x82, 0xd7, 0x81, 0xec, 0x07, 0x18, 0xfe, 0x18, 0xcd, 0x99, 0x96, 0xc5, 0x83, 0x8c, 0xf9,
-	0xa5, 0x4c, 0x25, 0xc3, 0x7d, 0x96, 0xfb, 0xbd, 0x02, 0xa7, 0xa1, 0xb1, 0x08, 0x5a, 0x12, 0x21,
-	0x34, 0x96, 0xe1, 0x3f, 0x4d, 0x86, 0x7e, 0xf6, 0x7c, 0x12, 0xf9, 0x76, 0x31, 0xcf, 0x3d, 0xbd,
-	0xc7, 0x3c, 0x99, 0xd7, 0x73, 0x22, 0xa0, 0xb8, 0xa7, 0x73, 0x50, 0x66, 0x75, 0xe1, 0xe9, 0x11,
-	0x40, 0xa8, 0x92, 0xe1, 0x2d, 0xb4, 0x30, 0x34, 0x8f, 0xbb, 0x3e, 0xfb, 0xb3, 0x31, 0x73, 0x7a,
-	0x0c, 0x7c, 0x26, 0x23, 0x56, 0x31, 0x34, 0x8f, 0x3b, 0x12, 0x56, 0xab, 0xd0, 0x30, 0x42, 0x75,
-	0x06, 0xae, 0x22, 0x64, 0x3b, 0x81, 0xe7, 0x5a, 0xe3, 0x1e, 0xf3, 0xa4, 0x8b, 0x40, 0x79, 0x89,
-	0x51, 0x55, 0x5e, 0x62, 0x88, 0x50, 0x4d, 0x8e, 0xfb, 0xa8, 0x00, 0xbe, 0xdb, 0xb5, 0xad, 0x52,
-	0xa1, 0x92, 0x5a, 0xcd, 0x56, 0xb7, 0xe5, 0xe1, 0xce, 0x82, 0x17, 0xc2, 0xd9, 0x46, 0x3f, 0xb9,
-	0xcf, 0x00, 0xbb, 0x69, 0xa9, 0xdd, 0x97, 0x63, 0x9e, 0x37, 0x22, 0xda, 0xdf, 0xc6, 0x3f, 0x69,
-	0xc4, 0xc7, 0x7f, 0x8e, 0xca, 0xfe, 0x73, 0x9b, 0x47, 0x8a, 0x98, 0x9b, 0x17, 0x8c, 0xae, 0xc7,
-	0x86, 0xee, 0xa1, 0x39, 0xf0, 0x4b, 0x73, 0xb0, 0xf8, 0x4f, 0x26, 0xa1, 0x51, 0xe2, 0xac, 0xa6,
-	0x46, 0xa2, 0x92, 0x33, 0x0d, 0x8d, 0x15, 0x91, 0xe7, 0xae, 0x20, 0x10, 0x7a, 0xa5, 0x2e, 0x3e,
-	0x46, 0x6f, 0x31, 0xa7, 0xe7, 0x9d, 0x8c, 0x60, 0xda, 0x91, 0xe9, 0xfb, 0x47, 0xae, 0x67, 0x75,
-	0x03, 0xf7, 0x39, 0x73, 0x4a, 0x08, 0x9c, 0xfa, 0xe3, 0x49, 0x68, 0xdc, 0x8d, 0x49, 0x3b, 0x92,
-	0xb3, 0xcb, 0x29, 0xd3, 0xd0, 0x78, 0x1b, 0xe6, 0xbe, 0x42, 0x4e, 0xe8, 0x55, 0x9a, 0xe4, 0x2f,
-	0x53, 0x28, 0x07, 0x9b, 0xc1, 0xa3, 0x59, 0x24, 0x75, 0x99, 0x82, 0x21, 0x9a, 0x05, 0x72, 0x21,
-	0xfd, 0x4b, 0x1c, 0x37, 0x50, 0x6e, 0xdf, 0x1e, 0x30, 0xbf, 0x94, 0x86, 0x58, 0xc6, 0x5a, 0x21,
-	0xb1, 0x07, 0xac, 0xe9, 0xec, 0xbb, 0xd5, 0x7b, 0x32, 0x9a, 0x05, 0x51, 0xc5, 0x12, 0x1f, 0x11,
-	0x2a, 0x40, 0xf2, 0xcb, 0x14, 0x9a, 0x87, 0x45, 0x3c, 0x19, 0x59, 0x66, 0xc0, 0xfe, 0x3f, 0x97,
-	0xf2, 0x8b, 0x45, 0x54, 0x88, 0x14, 0x54, 0x42, 0x48, 0x5d, 0x23, 0x21, 0xac, 0xa1, 0xac, 0x6f,
-	0xff, 0x8c, 0x41, 0x61, 0xc9, 0x08, 0x2e, 0x1f, 0x2b, 0x2e, 0x1f, 0x10, 0x0a, 0x18, 0xfe, 0x14,
-	0xa1, 0xa1, 0x6b, 0xd9, 0xfb, 0x36, 0xb3, 0xba, 0xbe, 0xde, 0x88, 0x44, 0x68, 0x47, 0x55, 0x4d,
-	0x85, 0x10, 0x1a, 0x4b, 0x79, 0xfe, 0x50, 0x06, 0xf6, 0x4e, 0x4a, 0x0b, 0x10, 0x19, 0x1f, 0x47,
-	0x91, 0xd1, 0x39, 0x70, 0xbd, 0x00, 0xc2, 0x41, 0x4d, 0x53, 0x3d, 0x51, 0xa1, 0x16, 0x43, 0x84,
-	0x47, 0x82, 0x24, 0x53, 0x8d, 0x8a, 0xb7, 0xd1, 0x6c, 0xd4, 0xcd, 0x71, 0xcf, 0x4f, 0x24, 0xe9,
-	0xa7, 0xac, 0x17, 0xb8, 0x5e, 0xb5, 0x12, 0x25, 0xe9, 0x43, 0xd5, 0xdd, 0x89, 0x80, 0x3b, 0x8c,
-	0xfa, 0xba, 0x48, 0x82, 0x3f, 0x44, 0x05, 0x95, 0x4c, 0x10, 0x7c, 0x2b, 0x24, 0x23, 0x3f, 0xce,
-	0x24, 0x4b, 0xb2, 0x41, 0x88, 0xd2, 0x88, 0x92, 0xe1, 0x9f, 0xa0, 0xfc, 0xde, 0xc0, 0xed, 0x3d,
-	0x8f, 0xaa, 0xc5, 0xcd, 0x78, 0x21, 0x55, 0x8e, 0xc3, 0xb9, 0xbe, 0x2d, 0xd7, 0x22, 0xa9, 0xaa,
-	0xfc, 0xc3, 0x90, 0x50, 0x09, 0xf3, 0x56, 0xd5, 0x3f, 0x19, 0x0e, 0x6c, 0xe7, 0x79, 0x37, 0x30,
-	0xbd, 0x3e, 0x0b, 0x4a, 0xcb, 0x71, 0xab, 0x2a, 0x25, 0xbb, 0x20, 0x50, 0xad, 0x6a, 0x02, 0x25,
-	0x34, 0xc9, 0xe2, 0x0d, 0xb4, 0x30, 0xdd, 0x3d, 0x30, 0xfd, 0x83, 0x12, 0x86, 0x38, 0x85, 0x0c,
-	0x27, 0xe0, 0x47, 0xa6, 0x7f, 0xa0, 0xb6, 0x3d, 0x86, 0x08, 0xd5, 0xe4, 0xbc, 0x81, 0x92, 0xb1,
-	0xc9, 0xac, 0xd2, 0x4d, 0x30, 0x01, 0xae, 0xa0, 0x40, 0xe5, 0x0a, 0x0a, 0x21, 0x34, 0x96, 0xe2,
-	0xaa, 0x6c, 0x44, 0x45, 0xfb, 0x78, 0xe7, 0xa2, 0xdb, 0x5f, 0xa3, 0x13, 0xdd, 0x44, 0xf3, 0xe7,
-	0xbb, 0x9a, 0x45, 0x91, 0xf1, 0x47, 0x89, 0x7e, 0x46, 0x64, 0xfc, 0x91, 0xde, 0xc9, 0xe8, 0x0c,
-	0xfc, 0x13, 0xcd, 0x2d, 0x1d, 0xbf, 0x34, 0x0f, 0x7d, 0xfb, 0x3b, 0xba, 0x1f, 0xb6, 0xfc, 0x0b,
-	0x7e, 0xd8, 0x8a, 0xfb, 0x75, 0x8d, 0x86, 0xf7, 0x91, 0xd8, 0xa5, 0x2e, 0x44, 0xd5, 0x22, 0x98,
-	0xda, 0x7a, 0x15, 0x1a, 0x0b, 0xd4, 0x3c, 0x82, 0xa3, 0xef, 0xd8, 0x3f, 0x63, 0x7c, 0xa3, 0xf6,
-	0xa2, 0x81, 0xda, 0x28, 0x85, 0x44, 0x86, 0x7f, 0xf5, 0xf2, 0x41, 0x42, 0x8d, 0xc6, 0x4a, 0xf8,
-	0x29, 0x2a, 0x8c, 0x06, 0x66, 0xb0, 0xef, 0x7a, 0xc3, 0xd2, 0x12, 0x38, 0xbb, 0xb6, 0x87, 0x3b,
-	0x52, 0x52, 0x37, 0x03, 0xb3, 0x4a, 0xa4, 0x9b, 0x29, 0xbe, 0xf2, 0xdc, 0x08, 0x20, 0x54, 0xc9,
-	0x70, 0x1d, 0xcd, 0x0f, 0xdc, 0x9e, 0x39, 0xe8, 0xee, 0x0f, 0xcc, 0xbe, 0x5f, 0xfa, 0x8f, 0x59,
-	0xd8, 0x54, 0xf0, 0x0e, 0xc0, 0x37, 0x39, 0xac, 0x36, 0x23, 0x86, 0x08, 0xd5, 0xe4, 0xf8, 0x11,
-	0x5a, 0x90, 0x61, 0x24, 0x7c, 0xec, 0x3f, 0x67, 0xc1, 0x43, 0xe0, 0x6c, 0xa4, 0x40, 0x7a, 0xd9,
-	0xb2, 0x1e, 0x7d, 0xc2, 0xcd, 0x74, 0x06, 0xfe, 0x1c, 0xdd, 0xb0, 0x1d, 0xd7, 0x62, 0xdd, 0xde,
-	0x81, 0xe9, 0xf4, 0x19, 0x3f, 0x9f, 0xc9, 0x2c, 0x44, 0x23, 0xf8, 0x3f, 0xc8, 0x6a, 0x20, 0x82,
-	0x33, 0xba, 0x29, 0xab, 0xa7, 0x86, 0x12, 0x9a, 0x64, 0xe1, 0x63, 0xa4, 0x95, 0x95, 0x6e, 0xe0,
-	0x99, 0xf6, 0x80, 0x79, 0xe2, 0xbc, 0xfe, 0x6b, 0x16, 0x0e, 0xec, 0xd3, 0x49, 0x68, 0xdc, 0x8e,
-	0x39, 0xbb, 0x82, 0x22, 0x0f, 0xeb, 0xde, 0xb9, 0x92, 0xa5, 0x49, 0x95, 0x47, 0x5c, 0xae, 0x8c,
-	0x7f, 0xcc, 0xbb, 0x48, 0xde, 0xe9, 0x5a, 0xb2, 0xa5, 0xbd, 0x2f, 0xfa, 0x45, 0x80, 0x54, 0x2a,
-	0x92, 0x63, 0x68, 0x18, 0xe1, 0x17, 0xa6, 0x68, 0xd6, 0x76, 0x0e, 0xcd, 0x81, 0x1d, 0xb5, 0xac,
-	0x1f, 0xbc, 0x0a, 0x0d, 0x44, 0xcd, 0xa3, 0xa6, 0x40, 0x45, 0x07, 0x01, 0x3f, 0xb5, 0x0e, 0x02,
-	0xc6, 0xbc, 0x83, 0xd0, 0x98, 0x34, 0xe2, 0xf1, 0xb4, 0xe2, 0xb8, 0x89, 0x5b, 0x41, 0x01, 0x4c,
-	0xc3, 0xb6, 0x3a, 0x6e, 0xf2, 0x46, 0x20, 0xb6, 0x35, 0x81, 0x12, 0x9a, 0x64, 0x7d, 0x98, 0xfd,
-	0x9b, 0xdf, 0x18, 0x33, 0xe4, 0xab, 0x14, 0x9a, 0x53, 0x29, 0x8e, 0x57, 0x17, 0x38, 0xff, 0x0c,
-	0x1c, 0x3f, 0x44, 0xf3, 0x81, 0x38, 0x77, 0x11, 0xcd, 0x07, 0x70, 0xe0, 0x80, 0xf1, 0xea, 0xe9,
-	0xee, 0xef, 0xfb, 0x2c, 0x80, 0xba, 0x95, 0x11, 0xd5, 0x53, 0x20, 0xaa, 0x7a, 0x8a, 0x21, 0xa1,
-	0x12, 0xc7, 0xef, 0xc9, 0xea, 0x95, 0x86, 0x63, 0x7b, 0xfb, 0xf2, 0xea, 0x15, 0x1d, 0x8a, 0x28,
-	0x62, 0x1f, 0xa1, 0xb9, 0x23, 0x66, 0x3e, 0x17, 0x7e, 0x29, 0x52, 0x06, 0xe4, 0x75, 0x0e, 0x4a,
-	0x9f, 0x14, 0xd1, 0x11, 0x01, 0x84, 0x2a, 0x99, 0xfc, 0xc6, 0x67, 0x28, 0x2f, 0xca, 0x09, 0xde,
-	0x41, 0x85, 0x9e, 0x3b, 0x76, 0x82, 0xf8, 0x52, 0xba, 0xac, 0x77, 0xc3, 0x20, 0xa9, 0xfe, 0x5e,
-	0x14, 0x80, 0x11, 0x55, 0x9d, 0x91, 0x04, 0x78, 0x1b, 0x2b, 0x45, 0xe4, 0xe7, 0x29, 0x34, 0x2b,
-	0x15, 0xf1, 0x23, 0x75, 0x39, 0xc8, 0x56, 0x3f, 0x38, 0x57, 0x25, 0xbf, 0xfe, 0xa2, 0xa9, 0x57,
-	0x48, 0x79, 0xe7, 0x3c, 0x34, 0x07, 0x63, 0xb1, 0x51, 0x59, 0x71, 0xe7, 0x04, 0x40, 0x15, 0x1d,
-	0x18, 0x11, 0x2a, 0x50, 0xf2, 0xf3, 0x2c, 0x5a, 0xd0, 0x93, 0x08, 0x4f, 0xd7, 0x63, 0xc7, 0x3e,
-	0x86, 0xc5, 0x24, 0xba, 0x94, 0x27, 0x8e, 0x7d, 0x0c, 0x69, 0xa6, 0xfc, 0x22, 0x34, 0x52, 0xfc,
-	0x00, 0x38, 0x4f, 0x1d, 0x00, 0x1f, 0x10, 0x0a, 0x18, 0xfe, 0x1c, 0xcd, 0x1e, 0xd9, 0x8e, 0xe5,
-	0x1e, 0xf9, 0xb0, 0x8c, 0x79, 0xfd, 0xe6, 0xf0, 0x85, 0x10, 0x80, 0xa5, 0x8a, 0xb4, 0x14, 0xb1,
-	0xd5, 0x76, 0xc9, 0x31, 0xa1, 0x91, 0x04, 0x6f, 0xa1, 0xdc, 0xc0, 0x76, 0xc6, 0xc7, 0xe0, 0x60,
-	0x89, 0x32, 0xfb, 0x53, 0x33, 0x08, 0x3c, 0x30, 0x77, 0x5f, 0x9a, 0x13, 0xcc, 0xf8, 0x92, 0xcd,
-	0x47, 0xfc, 0x92, 0xcd, 0xff, 0xc5, 0x9f, 0xa1, 0xbc, 0x65, 0x7a, 0x47, 0xb6, 0xb8, 0xd4, 0x5c,
-	0x61, 0x69, 0x45, 0x5a, 0x92, 0xd4, 0xf8, 0x82, 0x07, 0x43, 0x42, 0x25, 0x8e, 0x19, 0x9a, 0xdd,
-	0xf7, 0x18, 0xdb, 0xf3, 0x2d, 0x68, 0x92, 0xae, 0xb0, 0xf6, 0x63, 0x6e, 0x8d, 0x5f, 0x03, 0x36,
-	0x3d, 0xc6, 0xaa, 0x1d, 0xb8, 0x06, 0x48, 0x35, 0xf5, 0xc5, 0x72, 0x0c, 0xd7, 0x00, 0x49, 0xa3,
-	0x11, 0x09, 0x77, 0x51, 0xde, 0x61, 0x01, 0x9f, 0x25, 0x7f, 0xf5, 0x2c, 0xeb, 0x72, 0x96, 0x7c,
-	0x8b, 0x05, 0x62, 0x12, 0xa9, 0xa4, 0x56, 0x2f, 0x86, 0x7c, 0x0a, 0xc9, 0xa1, 0x92, 0x41, 0x7e,
-	0x91, 0x46, 0x85, 0xe8, 0x7c, 0x79, 0xf3, 0xe7, 0x1e, 0x39, 0xcc, 0xd3, 0x9f, 0xee, 0xa0, 0xe2,
-	0x03, 0x2a, 0xaf, 0x67, 0xa2, 0x90, 0x29, 0x84, 0xd0, 0x58, 0xca, 0x0d, 0xf4, 0x3d, 0x77, 0x3c,
-	0xd2, 0x9f, 0xed, 0xc0, 0x00, 0xa0, 0x09, 0x03, 0x0a, 0x21, 0x34, 0x96, 0xe2, 0x8f, 0x50, 0x66,
-	0x6c, 0x5b, 0x70, 0xd4, 0xb9, 0xea, 0x3b, 0xaf, 0x42, 0x23, 0xf3, 0x04, 0x22, 0x80, 0xa3, 0xd3,
-	0xd0, 0x98, 0x13, 0x0e, 0x67, 0x5b, 0x5a, 0xf9, 0xe4, 0x0c, 0xca, 0xe5, 0x5c, 0xb9, 0x6f, 0x5b,
-	0xf2, 0x4d, 0x0e, 0x94, 0xb7, 0x84, 0x72, 0x5f, 0x53, 0xee, 0x27, 0x95, 0xb7, 0xb8, 0x32, 0xc7,
-	0x7e, 0x9d, 0x42, 0xf3, 0x9a, 0x87, 0x7e, 0xfb, 0xbd, 0xd8, 0x46, 0x4b, 0xc2, 0x80, 0xed, 0x77,
-	0xe1, 0x03, 0xe5, 0x1b, 0x14, 0x3c, 0x9b, 0x80, 0xa4, 0xe9, 0x6f, 0x71, 0x5c, 0x3d, 0x9b, 0xe8,
-	0x20, 0xa1, 0x09, 0x0e, 0xe9, 0xa0, 0x39, 0x75, 0xe0, 0x78, 0x13, 0xe5, 0x8f, 0xf9, 0x20, 0x4a,
-	0x48, 0x37, 0xce, 0x79, 0x45, 0xdc, 0x76, 0x0a, 0x9a, 0x0a, 0x08, 0x18, 0x12, 0x2a, 0x61, 0xd2,
-	0x43, 0x39, 0xe0, 0xbf, 0xd1, 0x6d, 0x22, 0x91, 0x67, 0x16, 0xfe, 0xef, 0x3c, 0xf3, 0x17, 0x59,
-	0x34, 0x4b, 0x79, 0xd3, 0xec, 0x07, 0xf8, 0x47, 0x2a, 0xdb, 0xe5, 0xaa, 0xdf, 0xbd, 0x2a, 0xbd,
-	0xc5, 0xa7, 0x13, 0xbd, 0x7e, 0xc4, 0x97, 0xae, 0xf4, 0xb5, 0x2f, 0x5d, 0xd1, 0x27, 0x65, 0xae,
-	0xf1, 0x49, 0x71, 0x59, 0xca, 0xbe, 0x71, 0x59, 0xca, 0x5d, 0xbf, 0x2c, 0x45, 0x95, 0x32, 0x7f,
-	0x8d, 0x4a, 0xd9, 0x46, 0x4b, 0xfb, 0x9e, 0x3b, 0x84, 0x37, 0x32, 0xd7, 0x33, 0xbd, 0x13, 0xd9,
-	0x15, 0x40, 0xe9, 0xe6, 0x92, 0xdd, 0x48, 0xa0, 0x4a, 0x77, 0x02, 0x25, 0x34, 0xc9, 0x4a, 0xd6,
-	0xc4, 0xc2, 0x9b, 0xd5, 0x44, 0xfc, 0x09, 0x2a, 0x88, 0x8e, 0xd7, 0x71, 0xe1, 0xda, 0x95, 0xab,
-	0x7e, 0x87, 0xa7, 0x32, 0xc0, 0x5a, 0xae, 0x4a, 0x65, 0x72, 0xac, 0x3e, 0x3b, 0x22, 0x90, 0x7f,
-	0x4c, 0xa1, 0x02, 0x65, 0xfe, 0xc8, 0x75, 0x7c, 0xf6, 0x4d, 0x9d, 0x60, 0x0d, 0x65, 0x2d, 0x33,
-	0x30, 0xa5, 0xdb, 0xc1, 0xee, 0xf1, 0xb1, 0xda, 0x3d, 0x3e, 0x20, 0x14, 0x30, 0xfc, 0x29, 0xca,
-	0xf6, 0x5c, 0x4b, 0x1c, 0xfe, 0x92, 0x9e, 0x34, 0x1b, 0x9e, 0xe7, 0x7a, 0x35, 0xd7, 0x92, 0xd7,
-	0x0e, 0x4e, 0x52, 0x06, 0xf8, 0x80, 0x50, 0xc0, 0xc8, 0x3f, 0xa4, 0x50, 0xb1, 0xee, 0x1e, 0x39,
-	0x03, 0xd7, 0xb4, 0x76, 0x3c, 0xb7, 0xef, 0x31, 0xdf, 0xff, 0x46, 0x77, 0xff, 0x2e, 0x9a, 0x1d,
-	0xc3, 0xcb, 0x41, 0x74, 0xfb, 0x7f, 0x90, 0xbc, 0x06, 0x9d, 0x9f, 0x44, 0x3c, 0x33, 0xc4, 0x0f,
-	0x8d, 0x52, 0x59, 0xd9, 0x17, 0x63, 0x42, 0x23, 0x01, 0xf9, 0xfb, 0x0c, 0x2a, 0x5f, 0x6d, 0x08,
-	0x0f, 0xd1, 0xbc, 0x60, 0x76, 0xb5, 0xbf, 0x09, 0xac, 0x5e, 0x67, 0x0d, 0x70, 0x39, 0x83, 0x4b,
-	0xc1, 0x58, 0x8d, 0xd5, 0xa5, 0x20, 0x86, 0x08, 0xd5, 0xe4, 0x6f, 0xf4, 0x4e, 0xa9, 0x5d, 0xe5,
-	0x33, 0xdf, 0xfe, 0x2a, 0xdf, 0x41, 0x8b, 0xc2, 0x45, 0xa3, 0x07, 0xe5, 0x6c, 0x25, 0xb3, 0x9a,
-	0xab, 0x3e, 0xe4, 0xd9, 0x76, 0x4f, 0x34, 0xab, 0xd1, 0x53, 0xf2, 0x72, 0xec, 0xac, 0x02, 0x8c,
-	0xbc, 0xad, 0x38, 0x43, 0x13, 0x5c, 0xbc, 0x99, 0xb8, 0xe9, 0x89, 0x50, 0xff, 0x83, 0x6b, 0xde,
-	0xec, 0xb4, 0x9b, 0x1c, 0xc9, 0xa3, 0xec, 0x8e, 0xed, 0xf4, 0xc9, 0x47, 0x28, 0x57, 0x1b, 0xb8,
-	0x3e, 0x64, 0x1c, 0x8f, 0x99, 0xbe, 0xeb, 0xe8, 0xae, 0x24, 0x10, 0x75, 0xd4, 0x62, 0x48, 0xa8,
-	0xc4, 0xd7, 0x7e, 0x9b, 0x41, 0xf3, 0xda, 0x9f, 0x70, 0xf0, 0x9f, 0xa0, 0x7b, 0x8f, 0x1b, 0x9d,
-	0xce, 0xc6, 0x56, 0xa3, 0xbb, 0xfb, 0xe5, 0x4e, 0xa3, 0x5b, 0xdb, 0x7e, 0xd2, 0xd9, 0x6d, 0xd0,
-	0x6e, 0xad, 0xdd, 0xda, 0x6c, 0x6e, 0x15, 0x67, 0xca, 0xf7, 0x4f, 0xcf, 0x2a, 0x25, 0x4d, 0x23,
-	0xf9, 0xb7, 0x96, 0x3f, 0x44, 0x38, 0xa1, 0xde, 0x6c, 0xd5, 0x1b, 0x3f, 0x2d, 0xa6, 0xca, 0xb7,
-	0x4e, 0xcf, 0x2a, 0x45, 0x4d, 0x4b, 0x3c, 0xc1, 0xfd, 0x31, 0x7a, 0xeb, 0x22, 0xbb, 0xfb, 0x64,
-	0xa7, 0xbe, 0xb1, 0xdb, 0x28, 0xa6, 0xcb, 0xe5, 0xd3, 0xb3, 0xca, 0x9d, 0xf3, 0x4a, 0xd2, 0x05,
-	0x7f, 0x80, 0x6e, 0x25, 0x54, 0x69, 0xe3, 0xf3, 0x27, 0x8d, 0xce, 0x6e, 0x31, 0x53, 0xbe, 0x73,
-	0x7a, 0x56, 0xc1, 0x9a, 0x56, 0x54, 0x26, 0xd6, 0xd1, 0xed, 0x73, 0x1a, 0x9d, 0x9d, 0x76, 0xab,
-	0xd3, 0x28, 0x66, 0xcb, 0x77, 0x4f, 0xcf, 0x2a, 0x37, 0x13, 0x2a, 0x32, 0xab, 0xd4, 0xd0, 0x4a,
-	0x42, 0xa7, 0xde, 0xfe, 0xa2, 0xb5, 0xdd, 0xde, 0xa8, 0x77, 0x77, 0x68, 0x7b, 0x8b, 0x36, 0x3a,
-	0x9d, 0x62, 0xae, 0x6c, 0x9c, 0x9e, 0x55, 0xee, 0x69, 0xca, 0x17, 0x22, 0x7c, 0x0d, 0x2d, 0x27,
-	0x8c, 0xec, 0x34, 0x5b, 0x5b, 0xc5, 0x7c, 0xf9, 0xe6, 0xe9, 0x59, 0xe5, 0x86, 0xa6, 0xc7, 0xcf,
-	0xf2, 0xc2, 0xfe, 0xd5, 0xb6, 0xdb, 0x9d, 0x46, 0x71, 0xf6, 0xc2, 0xfe, 0xc1, 0x81, 0xaf, 0xfd,
-	0x5d, 0x0a, 0xe1, 0x8b, 0x7f, 0x35, 0xc3, 0x1f, 0xa0, 0x52, 0x64, 0xa4, 0xd6, 0x7e, 0xbc, 0xc3,
-	0xd7, 0xd9, 0x6c, 0xb7, 0xba, 0xad, 0x76, 0xab, 0x51, 0x9c, 0x49, 0xec, 0xaa, 0xa6, 0xd5, 0x72,
-	0x1d, 0x86, 0xdb, 0xe8, 0xee, 0x65, 0x9a, 0xdb, 0xcf, 0xde, 0x2f, 0xa6, 0xca, 0xeb, 0xa7, 0x67,
-	0x95, 0xdb, 0x17, 0x15, 0xb7, 0x9f, 0xbd, 0xff, 0xbb, 0xbf, 0xfa, 0xee, 0xe5, 0x82, 0x35, 0xde,
-	0x00, 0xe9, 0x4b, 0x7b, 0x0f, 0xdd, 0xd2, 0x0d, 0x3f, 0x6e, 0xec, 0x6e, 0xd4, 0x37, 0x76, 0x37,
-	0x8a, 0x33, 0xe2, 0x0c, 0x34, 0xea, 0x63, 0x16, 0x98, 0x90, 0x76, 0xbf, 0x87, 0x96, 0x13, 0x5f,
-	0xd1, 0x78, 0xda, 0xa0, 0x91, 0x47, 0xe9, 0xeb, 0x67, 0x87, 0xcc, 0xc3, 0xdf, 0x47, 0x58, 0x27,
-	0x6f, 0x6c, 0x7f, 0xb1, 0xf1, 0x65, 0xa7, 0x98, 0x2e, 0xdf, 0x3e, 0x3d, 0xab, 0x2c, 0x6b, 0xec,
-	0x8d, 0xc1, 0x91, 0x79, 0xe2, 0xaf, 0xfd, 0x73, 0x1a, 0x2d, 0xe8, 0xef, 0x46, 0xf8, 0xfb, 0xe8,
-	0xe6, 0x66, 0x73, 0x9b, 0x7b, 0xe2, 0x66, 0x5b, 0x9c, 0x00, 0x1f, 0x16, 0x67, 0xc4, 0x74, 0x3a,
-	0x95, 0xff, 0xc6, 0x7f, 0x84, 0x4a, 0xe7, 0xe8, 0xf5, 0x26, 0x6d, 0xd4, 0x76, 0xdb, 0xf4, 0xcb,
-	0x62, 0xaa, 0xfc, 0x16, 0xdf, 0x30, 0x5d, 0xa7, 0x6e, 0x7b, 0x90, 0x82, 0x4e, 0xf0, 0x27, 0xe8,
-	0xde, 0x39, 0xc5, 0xce, 0x97, 0x8f, 0xb7, 0x9b, 0xad, 0xcf, 0xc4, 0x7c, 0xe9, 0xf2, 0xdb, 0xa7,
-	0x67, 0x95, 0xbb, 0xba, 0x6e, 0x47, 0x3c, 0xc5, 0x71, 0xa8, 0x90, 0xc2, 0x8f, 0x50, 0xe5, 0x0a,
-	0xfd, 0x78, 0x01, 0x99, 0x32, 0x39, 0x3d, 0xab, 0xdc, 0xbf, 0xc4, 0x88, 0x5a, 0x47, 0x21, 0x85,
-	0x7f, 0x88, 0xee, 0x5c, 0x6e, 0x29, 0x8a, 0x8b, 0x4b, 0xf4, 0xd7, 0xfe, 0x35, 0x85, 0xe6, 0x54,
-	0xd5, 0xe3, 0x9b, 0xd6, 0xa0, 0xb4, 0xcd, 0x93, 0x44, 0xbd, 0xd1, 0x6d, 0xb5, 0xbb, 0x30, 0x8a,
-	0x36, 0x4d, 0xf1, 0x5a, 0x2e, 0xfc, 0xe4, 0x3e, 0xae, 0xd1, 0xb7, 0x1a, 0xad, 0x06, 0x6d, 0xd6,
-	0xa2, 0x13, 0x55, 0xec, 0x2d, 0xe6, 0x30, 0xcf, 0xee, 0xe1, 0xf7, 0xd1, 0xdd, 0xa4, 0xf1, 0xce,
-	0x93, 0xda, 0xa3, 0x68, 0x97, 0x60, 0x81, 0xda, 0x04, 0x9d, 0x71, 0xef, 0x00, 0x0e, 0xe6, 0x47,
-	0x09, 0xad, 0x66, 0xeb, 0xe9, 0xc6, 0x76, 0xb3, 0x2e, 0xb4, 0x32, 0xe5, 0xd2, 0xe9, 0x59, 0xe5,
-	0x96, 0xd2, 0x92, 0x0f, 0x1c, 0x5c, 0x6d, 0xed, 0x77, 0x29, 0xb4, 0xf2, 0xf5, 0xc5, 0x0b, 0x7f,
-	0x81, 0xde, 0x81, 0xfd, 0xba, 0x90, 0x0a, 0x64, 0xde, 0x12, 0x7b, 0xb8, 0xb1, 0xb3, 0xd3, 0x68,
-	0xd5, 0x8b, 0x33, 0xe5, 0xd5, 0xd3, 0xb3, 0xca, 0x83, 0xaf, 0x37, 0xb9, 0x31, 0x1a, 0x31, 0xc7,
-	0xba, 0xa6, 0xe1, 0xcd, 0x36, 0xdd, 0x6a, 0xec, 0x16, 0x53, 0xd7, 0x31, 0xbc, 0xe9, 0x7a, 0x7d,
-	0x16, 0x54, 0x1f, 0xbf, 0xf8, 0x6a, 0x65, 0xe6, 0xe5, 0x57, 0x2b, 0x33, 0x2f, 0x5e, 0xad, 0xa4,
-	0x5e, 0xbe, 0x5a, 0x49, 0xfd, 0xf5, 0xeb, 0x95, 0x99, 0xdf, 0xbc, 0x5e, 0x49, 0xbd, 0x7c, 0xbd,
-	0x32, 0xf3, 0x6f, 0xaf, 0x57, 0x66, 0x9e, 0x7d, 0xaf, 0x6f, 0x07, 0x07, 0xe3, 0xbd, 0x87, 0x3d,
-	0x77, 0xf8, 0xae, 0x7f, 0xe2, 0xf4, 0x82, 0x03, 0xdb, 0xe9, 0x6b, 0xbf, 0xf4, 0xff, 0xd9, 0xb1,
-	0x97, 0x87, 0x5f, 0x3f, 0xfc, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x35, 0x55, 0x08, 0x69, 0xf0,
-	0x21, 0x00, 0x00,
+	// 3292 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0x4d, 0x6c, 0x23, 0x47,
+	0x76, 0x16, 0x7f, 0x45, 0x95, 0x7e, 0x86, 0xaa, 0xf9, 0xa3, 0x39, 0x63, 0x35, 0x53, 0x3b, 0x9b,
+	0xc8, 0xda, 0xec, 0x78, 0xad, 0xf5, 0x6e, 0x1c, 0xdb, 0xb1, 0x21, 0xfe, 0x48, 0xc3, 0xb5, 0x86,
+	0x94, 0x8b, 0x9a, 0xf1, 0x7a, 0x80, 0x80, 0x68, 0xb1, 0x4b, 0x54, 0x63, 0xc8, 0x6e, 0xa6, 0xbb,
+	0xa9, 0x9f, 0x45, 0x2e, 0xc1, 0x02, 0x8b, 0x40, 0x87, 0x20, 0xd8, 0x53, 0x10, 0xac, 0x90, 0xc5,
+	0x5e, 0x72, 0x0b, 0x90, 0x43, 0x2e, 0x7b, 0xca, 0x71, 0x6e, 0x19, 0x2c, 0x10, 0x20, 0xc8, 0xa1,
+	0x01, 0xcf, 0x5c, 0x12, 0xe6, 0xc6, 0x63, 0x0e, 0x41, 0x50, 0xaf, 0xaa, 0xab, 0xab, 0xf5, 0xe3,
+	0x68, 0xec, 0x5b, 0x6e, 0xac, 0xef, 0x7d, 0xef, 0x55, 0x75, 0xbd, 0x57, 0xef, 0xbd, 0x2a, 0x09,
+	0xdd, 0x19, 0xd8, 0x7b, 0xef, 0x8e, 0x3c, 0x37, 0x70, 0x7b, 0xee, 0xe0, 0xdd, 0x3d, 0x36, 0x7a,
+	0x08, 0x03, 0x5c, 0x88, 0xb0, 0xf2, 0x1c, 0x3b, 0x0e, 0x04, 0x58, 0xfe, 0x8e, 0xc7, 0x46, 0xae,
+	0x2f, 0xe8, 0x7b, 0xe3, 0xfd, 0x77, 0xfb, 0x6e, 0xdf, 0x85, 0x01, 0xfc, 0x12, 0x24, 0xf2, 0x3f,
+	0x69, 0x94, 0x7b, 0xc4, 0x06, 0x03, 0x17, 0xd7, 0xd0, 0xbc, 0xc5, 0x0e, 0xed, 0x1e, 0xeb, 0x3a,
+	0xe6, 0x90, 0x95, 0x52, 0x95, 0xd4, 0xea, 0x5c, 0x95, 0x4c, 0x42, 0x03, 0x09, 0xb8, 0x65, 0x0e,
+	0xd9, 0x34, 0x34, 0x8a, 0xc7, 0xc3, 0xc1, 0x87, 0x24, 0x86, 0x08, 0xd5, 0xe4, 0xdc, 0x48, 0x6f,
+	0x60, 0x33, 0x27, 0x10, 0x46, 0xd2, 0xb1, 0x11, 0x01, 0x27, 0x8c, 0xc4, 0x10, 0xa1, 0x9a, 0x1c,
+	0xb7, 0xd1, 0x92, 0x34, 0x72, 0xc8, 0x3c, 0xdf, 0x76, 0x9d, 0x52, 0x06, 0xec, 0xac, 0x4e, 0x42,
+	0x63, 0x51, 0x48, 0x9e, 0x0a, 0xc1, 0x34, 0x34, 0x6e, 0x6a, 0xa6, 0x24, 0x4a, 0x68, 0x92, 0x85,
+	0x9f, 0xa1, 0x1b, 0xce, 0x78, 0xd8, 0xed, 0xb9, 0x8e, 0xc3, 0x7a, 0x81, 0xed, 0x3a, 0x7e, 0x29,
+	0x5b, 0x49, 0xad, 0xe6, 0xaa, 0xef, 0x4d, 0x42, 0x63, 0xc9, 0x19, 0x0f, 0x6b, 0xb1, 0x64, 0x1a,
+	0x1a, 0xb7, 0xc0, 0x64, 0x12, 0x26, 0xff, 0x1d, 0x1a, 0x19, 0xdb, 0x09, 0xe8, 0x39, 0x3a, 0xfe,
+	0x04, 0xcd, 0x05, 0xf6, 0x90, 0xf9, 0x81, 0x39, 0x1c, 0x95, 0x72, 0x95, 0xd4, 0x6a, 0xa6, 0x5a,
+	0x99, 0x84, 0x46, 0x0c, 0x4e, 0x43, 0xe3, 0x06, 0x18, 0x54, 0x08, 0xa1, 0xb1, 0x94, 0xfc, 0x63,
+	0x0a, 0xe5, 0x1f, 0x31, 0xd3, 0x62, 0x1e, 0xde, 0x40, 0xd9, 0xe0, 0x64, 0x24, 0xb6, 0x7e, 0x69,
+	0xfd, 0xf6, 0xc3, 0xc8, 0xa9, 0x0f, 0x1f, 0x33, 0xdf, 0x37, 0xfb, 0x6c, 0xf7, 0x64, 0xc4, 0xaa,
+	0x77, 0x26, 0xa1, 0x01, 0xb4, 0x69, 0x68, 0x20, 0x61, 0xf7, 0x64, 0xc4, 0x08, 0x05, 0x0c, 0x5b,
+	0x68, 0xbe, 0xe7, 0x0e, 0x47, 0x1e, 0xf3, 0x61, 0xdf, 0xd2, 0x60, 0xe9, 0xfe, 0x05, 0x4b, 0xb5,
+	0x98, 0x53, 0x7d, 0x30, 0x09, 0x0d, 0x5d, 0x69, 0x1a, 0x1a, 0xcb, 0x62, 0x4f, 0x63, 0x8c, 0x50,
+	0x9d, 0x41, 0x7e, 0x95, 0x42, 0x8b, 0xb5, 0xc1, 0xd8, 0x0f, 0x98, 0x57, 0x73, 0x9d, 0x7d, 0xbb,
+	0x8f, 0x3f, 0x43, 0xb3, 0xfb, 0xee, 0xc0, 0x62, 0x9e, 0x5f, 0x4a, 0x55, 0x32, 0xab, 0xf3, 0xeb,
+	0xc5, 0x78, 0xce, 0x4d, 0x10, 0x54, 0x8d, 0x17, 0xa1, 0x31, 0x33, 0x09, 0x8d, 0x88, 0x38, 0x0d,
+	0x8d, 0x05, 0x98, 0x47, 0x8c, 0x09, 0x8d, 0x04, 0x7c, 0x4b, 0x7d, 0xd6, 0x73, 0x1d, 0xcb, 0xf4,
+	0x4e, 0xe0, 0x13, 0x0a, 0x62, 0x4b, 0x15, 0xa8, 0xb6, 0x54, 0x21, 0x84, 0xc6, 0x52, 0xf2, 0xdb,
+	0x2c, 0xca, 0x8b, 0x49, 0xf1, 0x43, 0x94, 0xb6, 0x2d, 0x19, 0xcb, 0x2b, 0xaf, 0x42, 0x23, 0xdd,
+	0xac, 0x4f, 0x42, 0x23, 0x6d, 0x5b, 0xd3, 0xd0, 0x28, 0x80, 0x09, 0xdb, 0x22, 0xbf, 0x7c, 0xf9,
+	0x20, 0xdd, 0xac, 0xd3, 0xb4, 0x6d, 0xe1, 0x87, 0x28, 0x37, 0x30, 0xf7, 0xd8, 0x40, 0x46, 0x6e,
+	0x69, 0x12, 0x1a, 0x02, 0x98, 0x86, 0xc6, 0x3c, 0xf0, 0x61, 0x44, 0xa8, 0x40, 0xf1, 0x47, 0x68,
+	0xce, 0x63, 0xa6, 0xd5, 0x75, 0x9d, 0xc1, 0x09, 0x44, 0x69, 0xa1, 0xba, 0x32, 0x09, 0x8d, 0x02,
+	0x07, 0xdb, 0xce, 0x80, 0xaf, 0x74, 0x09, 0xd4, 0x22, 0x80, 0x50, 0x25, 0xc3, 0x5d, 0x84, 0xed,
+	0xbe, 0xe3, 0x7a, 0xac, 0x3b, 0x62, 0xde, 0xd0, 0x86, 0xbd, 0x15, 0x91, 0x59, 0xa8, 0xfe, 0x60,
+	0x12, 0x1a, 0xcb, 0x42, 0xba, 0x13, 0x0b, 0xa7, 0xa1, 0x71, 0x57, 0xac, 0xfa, 0xbc, 0x84, 0xd0,
+	0x8b, 0x6c, 0xfc, 0x19, 0x5a, 0x94, 0x13, 0x58, 0x6c, 0xc0, 0x02, 0x06, 0xf1, 0x59, 0xa8, 0xfe,
+	0xfe, 0x24, 0x34, 0x16, 0x84, 0xa0, 0x0e, 0xf8, 0x34, 0x34, 0xb0, 0x66, 0x56, 0x80, 0x84, 0x26,
+	0x38, 0xd8, 0x42, 0xb7, 0x2c, 0xdb, 0x37, 0xf7, 0x06, 0xac, 0x1b, 0xb0, 0xe1, 0xa8, 0x6b, 0x3b,
+	0x16, 0x3b, 0x66, 0x7e, 0x29, 0x0f, 0x36, 0xd7, 0x27, 0xa1, 0x81, 0xa5, 0x7c, 0x97, 0x0d, 0x47,
+	0x4d, 0x21, 0x9d, 0x86, 0x46, 0x49, 0x24, 0x8c, 0x0b, 0x22, 0x42, 0x2f, 0xe1, 0xe3, 0x75, 0x94,
+	0x1f, 0x99, 0x63, 0x9f, 0x59, 0xa5, 0x59, 0xb0, 0x5b, 0x9e, 0x84, 0x86, 0x44, 0x54, 0xc0, 0x88,
+	0x21, 0xa1, 0x12, 0xe7, 0xc1, 0x27, 0x52, 0x90, 0x5f, 0x2a, 0x9e, 0x0f, 0xbe, 0x3a, 0x08, 0xe2,
+	0xe0, 0x93, 0x44, 0x65, 0x4b, 0x8c, 0x09, 0x8d, 0x04, 0xe4, 0x9f, 0xf3, 0x28, 0x2f, 0x94, 0x70,
+	0x55, 0x05, 0xcf, 0x42, 0x75, 0x9d, 0x1b, 0xf8, 0xf7, 0xd0, 0x28, 0x08, 0x59, 0xb3, 0x7e, 0x55,
+	0x30, 0xfd, 0xe5, 0xcb, 0x07, 0x29, 0x2d, 0xa0, 0xd6, 0x50, 0x56, 0xcb, 0x84, 0x70, 0x78, 0x1d,
+	0x91, 0x03, 0xc5, 0xe1, 0x75, 0x20, 0xfb, 0x01, 0x86, 0x3f, 0x46, 0x73, 0xa6, 0x65, 0xf1, 0x43,
+	0xc6, 0xfc, 0x52, 0xa6, 0x92, 0xe1, 0x31, 0xcb, 0xe3, 0x5e, 0x81, 0xd3, 0xd0, 0x58, 0x04, 0x2d,
+	0x89, 0x10, 0x1a, 0xcb, 0xf0, 0x9f, 0x26, 0x8f, 0x7e, 0xf6, 0x7c, 0x12, 0xf9, 0x76, 0x67, 0x9e,
+	0x47, 0x7a, 0x8f, 0x79, 0x32, 0xaf, 0xe7, 0xc4, 0x81, 0xe2, 0x91, 0xce, 0x41, 0x99, 0xd5, 0x45,
+	0xa4, 0x47, 0x00, 0xa1, 0x4a, 0x86, 0xb7, 0xd0, 0xc2, 0xd0, 0x3c, 0xee, 0xfa, 0xec, 0xcf, 0xc6,
+	0xcc, 0xe9, 0x31, 0x88, 0x99, 0x8c, 0x58, 0xc5, 0xd0, 0x3c, 0xee, 0x48, 0x58, 0xad, 0x42, 0xc3,
+	0x08, 0xd5, 0x19, 0xb8, 0x8a, 0x90, 0xed, 0x04, 0x9e, 0x6b, 0x8d, 0x7b, 0xcc, 0x93, 0x21, 0x02,
+	0xe5, 0x25, 0x46, 0x55, 0x79, 0x89, 0x21, 0x42, 0x35, 0x39, 0xee, 0xa3, 0x02, 0xc4, 0x6e, 0xd7,
+	0xb6, 0x4a, 0x85, 0x4a, 0x6a, 0x35, 0x5b, 0xdd, 0x96, 0xce, 0x9d, 0x85, 0x28, 0x04, 0xdf, 0x46,
+	0x3f, 0x79, 0xcc, 0x00, 0xbb, 0x69, 0xa9, 0xdd, 0x97, 0x63, 0x9e, 0x37, 0x22, 0xda, 0xdf, 0xc6,
+	0x3f, 0x69, 0xc4, 0xc7, 0x7f, 0x8e, 0xca, 0xfe, 0x73, 0x9b, 0x9f, 0x14, 0x31, 0x37, 0x2f, 0x18,
+	0x5d, 0x8f, 0x0d, 0xdd, 0x43, 0x73, 0xe0, 0x97, 0xe6, 0x60, 0xf1, 0x9f, 0x4c, 0x42, 0xa3, 0xc4,
+	0x59, 0x4d, 0x8d, 0x44, 0x25, 0x67, 0x1a, 0x1a, 0x2b, 0x22, 0xcf, 0x5d, 0x41, 0x20, 0xf4, 0x4a,
+	0x5d, 0x7c, 0x8c, 0xde, 0x62, 0x4e, 0xcf, 0x3b, 0x19, 0xc1, 0xb4, 0x23, 0xd3, 0xf7, 0x8f, 0x5c,
+	0xcf, 0xea, 0x06, 0xee, 0x73, 0xe6, 0x94, 0x10, 0x04, 0xf5, 0xc7, 0x93, 0xd0, 0xb8, 0x1b, 0x93,
+	0x76, 0x24, 0x67, 0x97, 0x53, 0xa6, 0xa1, 0xf1, 0x36, 0xcc, 0x7d, 0x85, 0x9c, 0xd0, 0xab, 0x34,
+	0xc9, 0xbf, 0xa4, 0x50, 0x0e, 0x36, 0x83, 0x9f, 0x66, 0x91, 0xd4, 0x65, 0x0a, 0x86, 0xd3, 0x2c,
+	0x90, 0x0b, 0xe9, 0x5f, 0xe2, 0xb8, 0x81, 0x72, 0xfb, 0xf6, 0x80, 0xf9, 0xa5, 0x34, 0x9c, 0x65,
+	0xac, 0x15, 0x12, 0x7b, 0xc0, 0x9a, 0xce, 0xbe, 0x5b, 0xbd, 0x27, 0x4f, 0xb3, 0x20, 0xaa, 0xb3,
+	0xc4, 0x47, 0x84, 0x0a, 0x90, 0xe7, 0xbe, 0x81, 0xe9, 0x07, 0x71, 0xcc, 0x65, 0x20, 0xe6, 0x20,
+	0xf7, 0x71, 0x81, 0x16, 0x74, 0x58, 0x26, 0xf6, 0x18, 0x24, 0x34, 0xc1, 0x21, 0xbf, 0x49, 0xa3,
+	0x79, 0xf8, 0xa2, 0x27, 0x23, 0xcb, 0x0c, 0xd8, 0xff, 0x97, 0xef, 0xe2, 0xc6, 0x46, 0x1e, 0x3b,
+	0x8c, 0x8d, 0x65, 0x63, 0x63, 0x5c, 0x70, 0xc1, 0x98, 0x0e, 0x12, 0x9a, 0xe0, 0x90, 0x5f, 0x2c,
+	0xa2, 0x42, 0xf4, 0x29, 0x2a, 0xef, 0xa5, 0xae, 0x91, 0xf7, 0xd6, 0x50, 0xd6, 0xb7, 0x7f, 0x16,
+	0x7d, 0x09, 0x70, 0xf9, 0x58, 0x71, 0xf9, 0x80, 0x50, 0xc0, 0xf0, 0xa7, 0x08, 0x0d, 0x5d, 0xcb,
+	0xde, 0xb7, 0x99, 0xd5, 0xf5, 0xf5, 0x7e, 0x2b, 0x42, 0x3b, 0xaa, 0x39, 0x50, 0x08, 0xa1, 0xb1,
+	0x94, 0xa7, 0x49, 0x65, 0x60, 0xef, 0xa4, 0xb4, 0x00, 0x09, 0xe0, 0xe3, 0x28, 0x01, 0x74, 0x0e,
+	0x5c, 0x2f, 0x80, 0x53, 0xaf, 0xa6, 0xa9, 0x9e, 0xa8, 0x8c, 0x12, 0x43, 0x84, 0x1f, 0x78, 0x49,
+	0xa6, 0x1a, 0x15, 0x6f, 0xa3, 0xd9, 0xa8, 0x69, 0xe5, 0x07, 0x3c, 0x51, 0x8b, 0x9e, 0xb2, 0x5e,
+	0xe0, 0x7a, 0xd5, 0x4a, 0x54, 0x8b, 0x0e, 0x55, 0x13, 0x2b, 0xf2, 0xca, 0x61, 0xd4, 0xbe, 0x46,
+	0x12, 0xfc, 0x21, 0x2a, 0x28, 0xd7, 0x20, 0xf8, 0x56, 0xc8, 0xb9, 0x7e, 0xec, 0x96, 0x25, 0xd9,
+	0x07, 0x45, 0x2e, 0x51, 0x32, 0xfc, 0x13, 0x94, 0xdf, 0x1b, 0xb8, 0xbd, 0xe7, 0x51, 0x51, 0xbc,
+	0x19, 0x2f, 0xa4, 0xca, 0x71, 0x88, 0xb8, 0xb7, 0xe5, 0x5a, 0x24, 0x55, 0x75, 0x39, 0x30, 0x24,
+	0x54, 0xc2, 0xbc, 0x23, 0xf7, 0x4f, 0x86, 0x03, 0xdb, 0x79, 0xde, 0x0d, 0x4c, 0xaf, 0xcf, 0x82,
+	0xd2, 0x72, 0xdc, 0x91, 0x4b, 0xc9, 0x2e, 0x08, 0x54, 0x47, 0x9e, 0x40, 0x09, 0x4d, 0xb2, 0xf8,
+	0x3d, 0x41, 0x98, 0xee, 0x1e, 0x98, 0xfe, 0x41, 0x09, 0x43, 0x3a, 0x82, 0x44, 0x2e, 0xe0, 0x47,
+	0xa6, 0x7f, 0xa0, 0xb6, 0x3d, 0x86, 0x08, 0xd5, 0xe4, 0xbc, 0x4f, 0x94, 0x29, 0x88, 0x59, 0xa5,
+	0x9b, 0x60, 0x02, 0x42, 0x41, 0x81, 0x2a, 0x14, 0x14, 0x42, 0x68, 0x2c, 0xc5, 0x55, 0xd9, 0x6f,
+	0x8b, 0x2e, 0xf9, 0xce, 0xc5, 0x03, 0x79, 0x8d, 0x86, 0x7b, 0x13, 0xcd, 0x9f, 0x6f, 0xde, 0x16,
+	0x45, 0x61, 0x1b, 0x25, 0xda, 0x36, 0x51, 0xd8, 0x46, 0x7a, 0xc3, 0xa6, 0x33, 0xf0, 0x4f, 0xb4,
+	0xb0, 0x74, 0xfc, 0xd2, 0x3c, 0x5c, 0x4f, 0xde, 0xd1, 0xe3, 0xb0, 0xe5, 0x5f, 0x88, 0xc3, 0x56,
+	0x7c, 0x2d, 0xd1, 0x68, 0x78, 0x1f, 0x89, 0x5d, 0xea, 0xc2, 0xa9, 0x5a, 0x04, 0x53, 0x5b, 0xaf,
+	0x42, 0x63, 0x81, 0x9a, 0x47, 0xe0, 0xfa, 0x8e, 0xfd, 0x33, 0xc6, 0x37, 0x6a, 0x2f, 0x1a, 0xa8,
+	0x8d, 0x52, 0x48, 0x64, 0xf8, 0x97, 0x2f, 0x1f, 0x24, 0xd4, 0x68, 0xac, 0x84, 0x9f, 0xa2, 0xc2,
+	0x68, 0x60, 0x06, 0xfb, 0xae, 0x37, 0x2c, 0x2d, 0x41, 0xb0, 0x6b, 0x7b, 0xb8, 0x23, 0x25, 0x75,
+	0x33, 0x30, 0xab, 0x44, 0x86, 0x99, 0xe2, 0xab, 0xc8, 0x8d, 0x00, 0x42, 0x95, 0x0c, 0xd7, 0xd1,
+	0xfc, 0xc0, 0xed, 0x99, 0x83, 0xee, 0xfe, 0xc0, 0xec, 0xfb, 0xa5, 0xff, 0x98, 0x85, 0x4d, 0x85,
+	0xe8, 0x00, 0x7c, 0x93, 0xc3, 0x6a, 0x33, 0x62, 0x88, 0x50, 0x4d, 0x8e, 0x1f, 0xa1, 0x05, 0x79,
+	0x8c, 0x44, 0x8c, 0xfd, 0xe7, 0x2c, 0x44, 0x08, 0xf8, 0x46, 0x0a, 0x64, 0x94, 0x2d, 0xeb, 0xa7,
+	0x4f, 0x84, 0x99, 0xce, 0xc0, 0x9f, 0xa3, 0x1b, 0xb6, 0xe3, 0x5a, 0xac, 0xdb, 0x3b, 0x30, 0x9d,
+	0x3e, 0xe3, 0xfe, 0x99, 0xcc, 0xc2, 0x69, 0x84, 0xf8, 0x07, 0x59, 0x0d, 0x44, 0xe0, 0xa3, 0x9b,
+	0xb2, 0x49, 0xd0, 0x50, 0x42, 0x93, 0x2c, 0x7c, 0x8c, 0xb4, 0xea, 0xd9, 0x0d, 0x3c, 0xd3, 0x1e,
+	0x30, 0x4f, 0xf8, 0xeb, 0xbf, 0x66, 0xc1, 0x61, 0x9f, 0x4e, 0x42, 0xe3, 0x76, 0xcc, 0xd9, 0x15,
+	0x14, 0xe9, 0xac, 0x7b, 0xe7, 0x2a, 0xb3, 0x26, 0x55, 0x11, 0x71, 0xb9, 0x32, 0xfe, 0x31, 0x6f,
+	0x96, 0x79, 0x43, 0x6f, 0xc9, 0xce, 0xfd, 0xbe, 0x68, 0x8b, 0x01, 0x52, 0xa9, 0x48, 0x8e, 0xa1,
+	0x2f, 0x86, 0x5f, 0x98, 0xa2, 0x59, 0xdb, 0x39, 0x34, 0x07, 0x76, 0xd4, 0x99, 0x7f, 0xf0, 0x2a,
+	0x34, 0x10, 0x35, 0x8f, 0x9a, 0x02, 0x15, 0x8d, 0x12, 0xfc, 0xd4, 0x1a, 0x25, 0x18, 0xf3, 0x46,
+	0x49, 0x63, 0xd2, 0x88, 0xc7, 0xd3, 0x8a, 0xe3, 0x26, 0x2e, 0x3f, 0x05, 0x30, 0x0d, 0xdb, 0xea,
+	0xb8, 0xc9, 0x8b, 0x8f, 0xd8, 0xd6, 0x04, 0x4a, 0x68, 0x92, 0xf5, 0x61, 0xf6, 0x6f, 0x7e, 0x6d,
+	0xcc, 0x90, 0xaf, 0x52, 0x68, 0x4e, 0xa5, 0x38, 0x5e, 0x5d, 0xc0, 0xff, 0x19, 0x70, 0x3f, 0x9c,
+	0xe6, 0x03, 0xe1, 0x77, 0x71, 0x9a, 0x0f, 0xc0, 0xe1, 0x80, 0xf1, 0xba, 0xee, 0xee, 0xef, 0xfb,
+	0x2c, 0x80, 0xba, 0x95, 0x11, 0x75, 0x5d, 0x20, 0xaa, 0xae, 0x8b, 0x21, 0xa1, 0x12, 0xc7, 0xef,
+	0xc9, 0xea, 0x95, 0x06, 0xb7, 0xbd, 0x7d, 0x79, 0xf5, 0x8a, 0x9c, 0x22, 0x8a, 0xd8, 0x47, 0x68,
+	0xee, 0x88, 0x99, 0xcf, 0x45, 0x5c, 0x8a, 0x94, 0x01, 0x79, 0x9d, 0x83, 0x32, 0x26, 0xc5, 0xe9,
+	0x88, 0x00, 0x42, 0x95, 0x4c, 0x7e, 0xe3, 0x33, 0x94, 0x17, 0xe5, 0x04, 0xef, 0xa0, 0x42, 0xcf,
+	0x1d, 0x3b, 0x41, 0x7c, 0xf7, 0x5e, 0xd6, 0x9b, 0x7e, 0x90, 0x54, 0x7f, 0x2f, 0x3a, 0x80, 0x11,
+	0x55, 0xf9, 0x48, 0x02, 0xbc, 0x5b, 0x97, 0x22, 0xf2, 0xf3, 0x14, 0x9a, 0x95, 0x8a, 0xf8, 0x91,
+	0xba, 0x03, 0x65, 0xab, 0x1f, 0x9c, 0xab, 0x92, 0x5f, 0x7f, 0x9f, 0xd6, 0x2b, 0xa4, 0xbc, 0x5a,
+	0x1f, 0x9a, 0x83, 0xb1, 0xd8, 0xa8, 0xac, 0xb8, 0x5a, 0x03, 0xa0, 0x8a, 0x0e, 0x8c, 0x08, 0x15,
+	0x28, 0xf9, 0x79, 0x16, 0x2d, 0xe8, 0x49, 0x84, 0xa7, 0xeb, 0xb1, 0x63, 0x1f, 0xc3, 0x62, 0x12,
+	0xfd, 0xd3, 0x13, 0xc7, 0x3e, 0x86, 0x34, 0x53, 0x7e, 0x11, 0x1a, 0x29, 0xee, 0x00, 0xce, 0x53,
+	0x0e, 0xe0, 0x03, 0x42, 0x01, 0xc3, 0x9f, 0xa3, 0xd9, 0x23, 0xdb, 0xb1, 0xdc, 0x23, 0x1f, 0x96,
+	0x31, 0xaf, 0x5f, 0x90, 0xbe, 0x10, 0x02, 0xb0, 0x54, 0x91, 0x96, 0x22, 0xb6, 0xda, 0x2e, 0x39,
+	0x26, 0x34, 0x92, 0xe0, 0x2d, 0x94, 0x1b, 0xd8, 0xce, 0xf8, 0x18, 0x02, 0x2c, 0x51, 0x66, 0x7f,
+	0x6a, 0x06, 0x81, 0x07, 0xe6, 0xee, 0x4b, 0x73, 0x82, 0x19, 0xbf, 0x25, 0xf0, 0x11, 0xa1, 0x02,
+	0xc5, 0x9f, 0xa1, 0xbc, 0x65, 0x7a, 0x47, 0xb6, 0xb8, 0xbb, 0x5d, 0x61, 0x69, 0x45, 0x5a, 0x92,
+	0xd4, 0xf8, 0x1e, 0x0b, 0x43, 0x42, 0x25, 0x8e, 0x19, 0x9a, 0xdd, 0xf7, 0x18, 0xdb, 0xf3, 0x2d,
+	0x68, 0x92, 0xae, 0xb0, 0xf6, 0x63, 0x6e, 0x8d, 0xdf, 0x76, 0x36, 0x3d, 0xc6, 0xaa, 0x1d, 0xb8,
+	0xed, 0x48, 0x35, 0xf5, 0xc5, 0x72, 0x0c, 0xb7, 0x1d, 0x49, 0xa3, 0x11, 0x09, 0x77, 0x51, 0xde,
+	0x61, 0x01, 0x9f, 0x25, 0x7f, 0xf5, 0x2c, 0xeb, 0x72, 0x96, 0x7c, 0x8b, 0x05, 0x62, 0x12, 0xa9,
+	0xa4, 0x56, 0x2f, 0x86, 0x7c, 0x0a, 0xc9, 0xa1, 0x92, 0x41, 0x7e, 0x91, 0x46, 0x85, 0xc8, 0xbf,
+	0xbc, 0xf9, 0x73, 0x8f, 0x1c, 0xe6, 0xe9, 0x2f, 0x94, 0x50, 0xf1, 0x01, 0x95, 0xb7, 0x50, 0x51,
+	0xc8, 0x14, 0x42, 0x68, 0x2c, 0xe5, 0x06, 0xfa, 0x9e, 0x3b, 0x1e, 0xe9, 0xaf, 0x93, 0x60, 0x00,
+	0xd0, 0x84, 0x01, 0x85, 0x10, 0x1a, 0x4b, 0xf1, 0x47, 0x28, 0x33, 0xb6, 0x2d, 0x70, 0x75, 0xae,
+	0xfa, 0xce, 0xab, 0xd0, 0xc8, 0x3c, 0x81, 0x13, 0xc0, 0xd1, 0x69, 0x68, 0xcc, 0x89, 0x80, 0xb3,
+	0x2d, 0xad, 0x7c, 0x72, 0x06, 0xe5, 0x72, 0xae, 0xdc, 0xb7, 0x2d, 0xf9, 0xf4, 0x08, 0xca, 0x5b,
+	0x42, 0xb9, 0xaf, 0x29, 0xf7, 0x93, 0xca, 0x5b, 0x5c, 0x99, 0x63, 0xbf, 0x4a, 0xa1, 0x79, 0x2d,
+	0x42, 0xbf, 0xfd, 0x5e, 0x6c, 0xa3, 0x25, 0x61, 0xc0, 0xf6, 0xbb, 0xf0, 0x81, 0xf2, 0xa9, 0x0d,
+	0x9a, 0x7f, 0x90, 0x34, 0xfd, 0x2d, 0x8e, 0xab, 0xe6, 0x5f, 0x07, 0x09, 0x4d, 0x70, 0x48, 0x07,
+	0xcd, 0x29, 0x87, 0xe3, 0x4d, 0x94, 0x3f, 0xe6, 0x83, 0x28, 0x21, 0xdd, 0x38, 0x17, 0x15, 0x71,
+	0xdb, 0x29, 0x68, 0xea, 0x40, 0xc0, 0x90, 0x50, 0x09, 0x93, 0x1e, 0xca, 0x01, 0xff, 0x8d, 0x6e,
+	0x13, 0x89, 0x3c, 0xb3, 0xf0, 0x7f, 0xe7, 0x99, 0xbf, 0xc8, 0xa2, 0x59, 0xca, 0x9b, 0x66, 0x3f,
+	0xc0, 0x3f, 0x52, 0xd9, 0x2e, 0x57, 0xfd, 0xee, 0x55, 0xe9, 0x2d, 0xf6, 0x4e, 0xf4, 0xc8, 0x13,
+	0x5f, 0x07, 0xd3, 0xd7, 0xbe, 0x0e, 0x46, 0x9f, 0x94, 0xb9, 0xc6, 0x27, 0xc5, 0x65, 0x29, 0xfb,
+	0xc6, 0x65, 0x29, 0x77, 0xfd, 0xb2, 0x14, 0x55, 0xca, 0xfc, 0x35, 0x2a, 0x65, 0x1b, 0x2d, 0xed,
+	0x7b, 0xee, 0x10, 0x9e, 0x02, 0x5d, 0xcf, 0xf4, 0x4e, 0x64, 0x57, 0x00, 0xa5, 0x9b, 0x4b, 0x76,
+	0x23, 0x81, 0x2a, 0xdd, 0x09, 0x94, 0xd0, 0x24, 0x2b, 0x59, 0x13, 0x0b, 0x6f, 0x56, 0x13, 0xf1,
+	0x27, 0xa8, 0x20, 0x3a, 0x5e, 0xc7, 0x85, 0x6b, 0x57, 0xae, 0xfa, 0x1d, 0x9e, 0xca, 0x00, 0x6b,
+	0xb9, 0x2a, 0x95, 0xc9, 0xb1, 0xfa, 0xec, 0x88, 0x40, 0xfe, 0x21, 0x85, 0x0a, 0x94, 0xf9, 0x23,
+	0xd7, 0xf1, 0xd9, 0x37, 0x0d, 0x82, 0x35, 0x94, 0xb5, 0xcc, 0xc0, 0x94, 0x61, 0x07, 0xbb, 0xc7,
+	0xc7, 0x6a, 0xf7, 0xf8, 0x80, 0x50, 0xc0, 0xf0, 0xa7, 0x28, 0xdb, 0x73, 0x2d, 0xe1, 0xfc, 0x25,
+	0x3d, 0x69, 0x36, 0x3c, 0xcf, 0xf5, 0x6a, 0xae, 0x25, 0xaf, 0x1d, 0x9c, 0xa4, 0x0c, 0xf0, 0x01,
+	0xa1, 0x80, 0x91, 0xbf, 0x4f, 0xa1, 0x62, 0xdd, 0x3d, 0x72, 0x06, 0xae, 0x69, 0xed, 0x78, 0x6e,
+	0xdf, 0x63, 0xbe, 0xff, 0x8d, 0x5e, 0x25, 0xba, 0x68, 0x76, 0x0c, 0x6f, 0x1a, 0xd1, 0xbb, 0xc4,
+	0x83, 0xe4, 0x35, 0xe8, 0xfc, 0x24, 0xe2, 0x01, 0x24, 0x7e, 0x4f, 0x95, 0xca, 0xca, 0xbe, 0x18,
+	0x13, 0x1a, 0x09, 0xc8, 0x6f, 0x32, 0xa8, 0x7c, 0xb5, 0x21, 0x3c, 0x44, 0xf3, 0x82, 0xd9, 0xd5,
+	0xfe, 0xf4, 0xb1, 0x7a, 0x9d, 0x35, 0xc0, 0xe5, 0x0c, 0x2e, 0x05, 0x63, 0x35, 0x56, 0x97, 0x82,
+	0x18, 0x22, 0x54, 0x93, 0xbf, 0xd1, 0x73, 0xac, 0x76, 0x95, 0xcf, 0x7c, 0xfb, 0xab, 0x7c, 0x07,
+	0x2d, 0x8a, 0x10, 0x8d, 0xde, 0xcd, 0xb3, 0x95, 0xcc, 0x6a, 0xae, 0xfa, 0x90, 0x67, 0xdb, 0x3d,
+	0xd1, 0xac, 0x46, 0x2f, 0xe6, 0xcb, 0x71, 0xb0, 0x0a, 0x30, 0x8a, 0xb6, 0xe2, 0x0c, 0x4d, 0x70,
+	0xf1, 0x66, 0xe2, 0xa6, 0x27, 0x8e, 0xfa, 0x1f, 0x5c, 0xf3, 0x66, 0xa7, 0xdd, 0xe4, 0x48, 0x1e,
+	0x65, 0x77, 0x6c, 0xa7, 0x4f, 0x3e, 0x42, 0xb9, 0xda, 0xc0, 0xf5, 0x21, 0xe3, 0x78, 0xcc, 0xf4,
+	0x5d, 0x47, 0x0f, 0x25, 0x81, 0x28, 0x57, 0x8b, 0x21, 0xa1, 0x12, 0x5f, 0xfb, 0x6d, 0x06, 0xcd,
+	0x6b, 0x7f, 0xa9, 0xc2, 0x7f, 0x82, 0xee, 0x3d, 0x6e, 0x74, 0x3a, 0x1b, 0x5b, 0x8d, 0xee, 0xee,
+	0x97, 0x3b, 0x8d, 0x6e, 0x6d, 0xfb, 0x49, 0x67, 0xb7, 0x41, 0xbb, 0xb5, 0x76, 0x6b, 0xb3, 0xb9,
+	0x55, 0x9c, 0x29, 0xdf, 0x3f, 0x3d, 0xab, 0x94, 0x34, 0x8d, 0xe4, 0x9f, 0x94, 0xfe, 0x10, 0xe1,
+	0x84, 0x7a, 0xb3, 0x55, 0x6f, 0xfc, 0xb4, 0x98, 0x2a, 0xdf, 0x3a, 0x3d, 0xab, 0x14, 0x35, 0x2d,
+	0xf1, 0xd2, 0xf8, 0xc7, 0xe8, 0xad, 0x8b, 0xec, 0xee, 0x93, 0x9d, 0xfa, 0xc6, 0x6e, 0xa3, 0x98,
+	0x2e, 0x97, 0x4f, 0xcf, 0x2a, 0x77, 0xce, 0x2b, 0xc9, 0x10, 0xfc, 0x01, 0xba, 0x95, 0x50, 0xa5,
+	0x8d, 0xcf, 0x9f, 0x34, 0x3a, 0xbb, 0xc5, 0x4c, 0xf9, 0xce, 0xe9, 0x59, 0x05, 0x6b, 0x5a, 0x51,
+	0x99, 0x58, 0x47, 0xb7, 0xcf, 0x69, 0x74, 0x76, 0xda, 0xad, 0x4e, 0xa3, 0x98, 0x2d, 0xdf, 0x3d,
+	0x3d, 0xab, 0xdc, 0x4c, 0xa8, 0xc8, 0xac, 0x52, 0x43, 0x2b, 0x09, 0x9d, 0x7a, 0xfb, 0x8b, 0xd6,
+	0x76, 0x7b, 0xa3, 0xde, 0xdd, 0xa1, 0xed, 0x2d, 0xda, 0xe8, 0x74, 0x8a, 0xb9, 0xb2, 0x71, 0x7a,
+	0x56, 0xb9, 0xa7, 0x29, 0x5f, 0x38, 0xe1, 0x6b, 0x68, 0x39, 0x61, 0x64, 0xa7, 0xd9, 0xda, 0x2a,
+	0xe6, 0xcb, 0x37, 0x4f, 0xcf, 0x2a, 0x37, 0x34, 0x3d, 0xee, 0xcb, 0x0b, 0xfb, 0x57, 0xdb, 0x6e,
+	0x77, 0x1a, 0xc5, 0xd9, 0x0b, 0xfb, 0x07, 0x0e, 0x5f, 0xfb, 0xbb, 0x14, 0xc2, 0x17, 0xff, 0x38,
+	0x88, 0x3f, 0x40, 0xa5, 0xc8, 0x48, 0xad, 0xfd, 0x78, 0x87, 0xaf, 0xb3, 0xd9, 0x6e, 0x75, 0x5b,
+	0xed, 0x56, 0xa3, 0x38, 0x93, 0xd8, 0x55, 0x4d, 0xab, 0xe5, 0x3a, 0x0c, 0xb7, 0xd1, 0xdd, 0xcb,
+	0x34, 0xb7, 0x9f, 0xbd, 0x5f, 0x4c, 0x95, 0xd7, 0x4f, 0xcf, 0x2a, 0xb7, 0x2f, 0x2a, 0x6e, 0x3f,
+	0x7b, 0xff, 0x77, 0x7f, 0xf5, 0xdd, 0xcb, 0x05, 0x6b, 0xbc, 0x01, 0xd2, 0x97, 0xf6, 0x1e, 0xba,
+	0xa5, 0x1b, 0x7e, 0xdc, 0xd8, 0xdd, 0xa8, 0x6f, 0xec, 0x6e, 0x14, 0x67, 0x84, 0x0f, 0x34, 0xea,
+	0x63, 0x16, 0x98, 0x90, 0x76, 0xbf, 0x87, 0x96, 0x13, 0x5f, 0xd1, 0x78, 0xda, 0xa0, 0x51, 0x44,
+	0xe9, 0xeb, 0x67, 0x87, 0xcc, 0xc3, 0xdf, 0x47, 0x58, 0x27, 0x6f, 0x6c, 0x7f, 0xb1, 0xf1, 0x65,
+	0xa7, 0x98, 0x2e, 0xdf, 0x3e, 0x3d, 0xab, 0x2c, 0x6b, 0xec, 0x8d, 0xc1, 0x91, 0x79, 0xe2, 0xaf,
+	0xfd, 0x53, 0x1a, 0x2d, 0xe8, 0xef, 0x46, 0xf8, 0xfb, 0xe8, 0xe6, 0x66, 0x73, 0x9b, 0x47, 0xe2,
+	0x66, 0x5b, 0x78, 0x80, 0x0f, 0x8b, 0x33, 0x62, 0x3a, 0x9d, 0xca, 0x7f, 0xe3, 0x3f, 0x42, 0xa5,
+	0x73, 0xf4, 0x7a, 0x93, 0x36, 0x6a, 0xbb, 0x6d, 0xfa, 0x65, 0x31, 0x55, 0x7e, 0x8b, 0x6f, 0x98,
+	0xae, 0x53, 0xb7, 0x3d, 0x48, 0x41, 0x27, 0xf8, 0x13, 0x74, 0xef, 0x9c, 0x62, 0xe7, 0xcb, 0xc7,
+	0xdb, 0xcd, 0xd6, 0x67, 0x62, 0xbe, 0x74, 0xf9, 0xed, 0xd3, 0xb3, 0xca, 0x5d, 0x5d, 0xb7, 0x23,
+	0x9e, 0xe2, 0x38, 0x54, 0x48, 0xe1, 0x47, 0xa8, 0x72, 0x85, 0x7e, 0xbc, 0x80, 0x4c, 0x99, 0x9c,
+	0x9e, 0x55, 0xee, 0x5f, 0x62, 0x44, 0xad, 0xa3, 0x90, 0xc2, 0x3f, 0x44, 0x77, 0x2e, 0xb7, 0x14,
+	0x9d, 0x8b, 0x4b, 0xf4, 0xd7, 0xfe, 0x35, 0x85, 0xe6, 0x54, 0xd5, 0xe3, 0x9b, 0xd6, 0xa0, 0xb4,
+	0xcd, 0x93, 0x44, 0xbd, 0xd1, 0x6d, 0xb5, 0xbb, 0x30, 0x8a, 0x36, 0x4d, 0xf1, 0x5a, 0x2e, 0xfc,
+	0xe4, 0x31, 0xae, 0xd1, 0xb7, 0x1a, 0xad, 0x06, 0x6d, 0xd6, 0x22, 0x8f, 0x2a, 0xf6, 0x16, 0x73,
+	0x98, 0x67, 0xf7, 0xf0, 0xfb, 0xe8, 0x6e, 0xd2, 0x78, 0xe7, 0x49, 0xed, 0x51, 0xb4, 0x4b, 0xb0,
+	0x40, 0x6d, 0x82, 0xce, 0xb8, 0x77, 0x00, 0x8e, 0xf9, 0x51, 0x42, 0xab, 0xd9, 0x7a, 0xba, 0xb1,
+	0xdd, 0xac, 0x0b, 0xad, 0x4c, 0xb9, 0x74, 0x7a, 0x56, 0xb9, 0xa5, 0xb4, 0xe4, 0x03, 0x07, 0x57,
+	0x5b, 0xfb, 0x5d, 0x0a, 0xad, 0x7c, 0x7d, 0xf1, 0xc2, 0x5f, 0xa0, 0x77, 0x60, 0xbf, 0x2e, 0xa4,
+	0x02, 0x99, 0xb7, 0xc4, 0x1e, 0x6e, 0xec, 0xec, 0x34, 0x5a, 0xf5, 0xe2, 0x4c, 0x79, 0xf5, 0xf4,
+	0xac, 0xf2, 0xe0, 0xeb, 0x4d, 0x6e, 0x8c, 0x46, 0xcc, 0xb1, 0xae, 0x69, 0x78, 0xb3, 0x4d, 0xb7,
+	0x1a, 0xbb, 0xc5, 0xd4, 0x75, 0x0c, 0x6f, 0xba, 0x5e, 0x9f, 0x05, 0xd5, 0xc7, 0x2f, 0xbe, 0x5a,
+	0x99, 0x79, 0xf9, 0xd5, 0xca, 0xcc, 0x8b, 0x57, 0x2b, 0xa9, 0x97, 0xaf, 0x56, 0x52, 0x7f, 0xfd,
+	0x7a, 0x65, 0xe6, 0xd7, 0xaf, 0x57, 0x52, 0x2f, 0x5f, 0xaf, 0xcc, 0xfc, 0xdb, 0xeb, 0x95, 0x99,
+	0x67, 0xdf, 0xeb, 0xdb, 0xc1, 0xc1, 0x78, 0xef, 0x61, 0xcf, 0x1d, 0xbe, 0xeb, 0x9f, 0x38, 0xbd,
+	0xe0, 0xc0, 0x76, 0xfa, 0xda, 0x2f, 0xfd, 0x1f, 0x58, 0xf6, 0xf2, 0xf0, 0xeb, 0x87, 0xff, 0x1b,
+	0x00, 0x00, 0xff, 0xff, 0xa6, 0x37, 0xc7, 0xbf, 0xd7, 0x22, 0x00, 0x00,
 }

 func (m *Hello) Marshal() (dAtA []byte, err error) {
@@ -1707,6 +1712,11 @@ func (m *Index) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.LastSequence != 0 {
+		i = encodeVarintBep(dAtA, i, uint64(m.LastSequence))
+		i--
+		dAtA[i] = 0x18
+	}
 	if len(m.Files) > 0 {
 		for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -1751,6 +1761,16 @@ func (m *IndexUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.PrevSequence != 0 {
+		i = encodeVarintBep(dAtA, i, uint64(m.PrevSequence))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.LastSequence != 0 {
+		i = encodeVarintBep(dAtA, i, uint64(m.LastSequence))
+		i--
+		dAtA[i] = 0x18
+	}
 	if len(m.Files) > 0 {
 		for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -2781,6 +2801,9 @@ func (m *Index) ProtoSize() (n int) {
 			n += 1 + l + sovBep(uint64(l))
 		}
 	}
+	if m.LastSequence != 0 {
+		n += 1 + sovBep(uint64(m.LastSequence))
+	}
 	return n
 }

@@ -2800,6 +2823,12 @@ func (m *IndexUpdate) ProtoSize() (n int) {
 			n += 1 + l + sovBep(uint64(l))
 		}
 	}
+	if m.LastSequence != 0 {
+		n += 1 + sovBep(uint64(m.LastSequence))
+	}
+	if m.PrevSequence != 0 {
+		n += 1 + sovBep(uint64(m.PrevSequence))
+	}
 	return n
 }

@@ -4200,6 +4229,25 @@ func (m *Index) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastSequence", wireType)
+			}
+			m.LastSequence = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBep
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LastSequence |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipBep(dAtA[iNdEx:])
@@ -4316,6 +4364,44 @@ func (m *IndexUpdate) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastSequence", wireType)
+			}
+			m.LastSequence = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBep
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LastSequence |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevSequence", wireType)
+			}
+			m.PrevSequence = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBep
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PrevSequence |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipBep(dAtA[iNdEx:])
@@ -193,48 +193,52 @@ func (e encryptedConnection) DeviceID() DeviceID {
 	return e.conn.DeviceID()
 }

-func (e encryptedConnection) Index(ctx context.Context, folder string, files []FileInfo) error {
-	if folderKey, ok := e.folderKeys.get(folder); ok {
-		encryptFileInfos(e.keyGen, files, folderKey)
+func (e encryptedConnection) Index(ctx context.Context, idx *Index) error {
+	if folderKey, ok := e.folderKeys.get(idx.Folder); ok {
+		encryptFileInfos(e.keyGen, idx.Files, folderKey)
 	}
-	return e.conn.Index(ctx, folder, files)
+	return e.conn.Index(ctx, idx)
 }

-func (e encryptedConnection) IndexUpdate(ctx context.Context, folder string, files []FileInfo) error {
-	if folderKey, ok := e.folderKeys.get(folder); ok {
-		encryptFileInfos(e.keyGen, files, folderKey)
+func (e encryptedConnection) IndexUpdate(ctx context.Context, idxUp *IndexUpdate) error {
+	if folderKey, ok := e.folderKeys.get(idxUp.Folder); ok {
+		encryptFileInfos(e.keyGen, idxUp.Files, folderKey)
 	}
-	return e.conn.IndexUpdate(ctx, folder, files)
+	return e.conn.IndexUpdate(ctx, idxUp)
 }

-func (e encryptedConnection) Request(ctx context.Context, folder string, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
-	folderKey, ok := e.folderKeys.get(folder)
+func (e encryptedConnection) Request(ctx context.Context, req *Request) ([]byte, error) {
+	folderKey, ok := e.folderKeys.get(req.Folder)
 	if !ok {
-		return e.conn.Request(ctx, folder, name, blockNo, offset, size, hash, weakHash, fromTemporary)
+		return e.conn.Request(ctx, req)
 	}

 	// Encrypt / adjust the request parameters.

-	origSize := size
-	if size < minPaddedSize {
+	origSize := req.Size
+	origName := req.Name
+	if req.Size < minPaddedSize {
 		// Make a request for minPaddedSize data instead of the smaller
 		// block. We'll chop of the extra data later.
-		size = minPaddedSize
+		req.Size = minPaddedSize
 	}
-	encName := encryptName(name, folderKey)
-	encOffset := offset + int64(blockNo*blockOverhead)
-	encSize := size + blockOverhead
+	encName := encryptName(req.Name, folderKey)
+	encOffset := req.Offset + int64(req.BlockNo*blockOverhead)
+	encSize := req.Size + blockOverhead

-	// Perform that request, getting back and encrypted block.
+	// Perform that request, getting back an encrypted block.

-	bs, err := e.conn.Request(ctx, folder, encName, blockNo, encOffset, encSize, nil, 0, false)
+	req.Name = encName
+	req.Offset = encOffset
+	req.Size = encSize
+	bs, err := e.conn.Request(ctx, req)
 	if err != nil {
 		return nil, err
 	}

 	// Return the decrypted block (or an error if it fails decryption)

-	fileKey := e.keyGen.FileKey(name, folderKey)
+	fileKey := e.keyGen.FileKey(origName, folderKey)
 	bs, err = DecryptBytes(bs, fileKey)
 	if err != nil {
 		return nil, err
@@ -242,15 +246,15 @@ func (e encryptedConnection) Request(ctx context.Context, folder string, name st
 	return bs[:origSize], nil
 }

-func (e encryptedConnection) DownloadProgress(ctx context.Context, folder string, updates []FileDownloadProgressUpdate) {
-	if _, ok := e.folderKeys.get(folder); !ok {
-		e.conn.DownloadProgress(ctx, folder, updates)
+func (e encryptedConnection) DownloadProgress(ctx context.Context, dp *DownloadProgress) {
+	if _, ok := e.folderKeys.get(dp.Folder); !ok {
+		e.conn.DownloadProgress(ctx, dp)
 	}

 	// No need to send these
 }

-func (e encryptedConnection) ClusterConfig(config ClusterConfig) {
+func (e encryptedConnection) ClusterConfig(config *ClusterConfig) {
 	e.conn.ClusterConfig(config)
 }

@@ -26,10 +26,10 @@ type Connection struct {
 	closedReturnsOnCall map[int]struct {
 		result1 <-chan struct{}
 	}
-	ClusterConfigStub        func(protocol.ClusterConfig)
+	ClusterConfigStub        func(*protocol.ClusterConfig)
 	clusterConfigMutex       sync.RWMutex
 	clusterConfigArgsForCall []struct {
-		arg1 protocol.ClusterConfig
+		arg1 *protocol.ClusterConfig
 	}
 	ConnectionIDStub        func() string
 	connectionIDMutex       sync.RWMutex
@@ -61,12 +61,11 @@ type Connection struct {
 	deviceIDReturnsOnCall map[int]struct {
 		result1 protocol.DeviceID
 	}
-	DownloadProgressStub        func(context.Context, string, []protocol.FileDownloadProgressUpdate)
+	DownloadProgressStub        func(context.Context, *protocol.DownloadProgress)
 	downloadProgressMutex       sync.RWMutex
 	downloadProgressArgsForCall []struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileDownloadProgressUpdate
+		arg2 *protocol.DownloadProgress
 	}
 	EstablishedAtStub        func() time.Time
 	establishedAtMutex       sync.RWMutex
@@ -78,12 +77,11 @@ type Connection struct {
 	establishedAtReturnsOnCall map[int]struct {
 		result1 time.Time
 	}
-	IndexStub        func(context.Context, string, []protocol.FileInfo) error
+	IndexStub        func(context.Context, *protocol.Index) error
 	indexMutex       sync.RWMutex
 	indexArgsForCall []struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileInfo
+		arg2 *protocol.Index
 	}
 	indexReturns struct {
 		result1 error
@@ -91,12 +89,11 @@ type Connection struct {
 	indexReturnsOnCall map[int]struct {
 		result1 error
 	}
-	IndexUpdateStub        func(context.Context, string, []protocol.FileInfo) error
+	IndexUpdateStub        func(context.Context, *protocol.IndexUpdate) error
 	indexUpdateMutex       sync.RWMutex
 	indexUpdateArgsForCall []struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileInfo
+		arg2 *protocol.IndexUpdate
 	}
 	indexUpdateReturns struct {
 		result1 error
@@ -134,18 +131,11 @@ type Connection struct {
 	remoteAddrReturnsOnCall map[int]struct {
 		result1 net.Addr
 	}
-	RequestStub        func(context.Context, string, string, int, int64, int, []byte, uint32, bool) ([]byte, error)
+	RequestStub        func(context.Context, *protocol.Request) ([]byte, error)
 	requestMutex       sync.RWMutex
 	requestArgsForCall []struct {
 		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 int
-		arg5 int64
-		arg6 int
-		arg7 []byte
-		arg8 uint32
-		arg9 bool
+		arg2 *protocol.Request
 	}
 	requestReturns struct {
 		result1 []byte
@@ -293,10 +283,10 @@ func (fake *Connection) ClosedReturnsOnCall(i int, result1 <-chan struct{}) {
 	}{result1}
 }

-func (fake *Connection) ClusterConfig(arg1 protocol.ClusterConfig) {
+func (fake *Connection) ClusterConfig(arg1 *protocol.ClusterConfig) {
 	fake.clusterConfigMutex.Lock()
 	fake.clusterConfigArgsForCall = append(fake.clusterConfigArgsForCall, struct {
-		arg1 protocol.ClusterConfig
+		arg1 *protocol.ClusterConfig
 	}{arg1})
 	stub := fake.ClusterConfigStub
 	fake.recordInvocation("ClusterConfig", []interface{}{arg1})
@@ -312,13 +302,13 @@ func (fake *Connection) ClusterConfigCallCount() int {
 	return len(fake.clusterConfigArgsForCall)
 }

-func (fake *Connection) ClusterConfigCalls(stub func(protocol.ClusterConfig)) {
+func (fake *Connection) ClusterConfigCalls(stub func(*protocol.ClusterConfig)) {
 	fake.clusterConfigMutex.Lock()
 	defer fake.clusterConfigMutex.Unlock()
 	fake.ClusterConfigStub = stub
 }

-func (fake *Connection) ClusterConfigArgsForCall(i int) protocol.ClusterConfig {
+func (fake *Connection) ClusterConfigArgsForCall(i int) *protocol.ClusterConfig {
 	fake.clusterConfigMutex.RLock()
 	defer fake.clusterConfigMutex.RUnlock()
 	argsForCall := fake.clusterConfigArgsForCall[i]
@@ -484,23 +474,17 @@ func (fake *Connection) DeviceIDReturnsOnCall(i int, result1 protocol.DeviceID)
 	}{result1}
 }

-func (fake *Connection) DownloadProgress(arg1 context.Context, arg2 string, arg3 []protocol.FileDownloadProgressUpdate) {
-	var arg3Copy []protocol.FileDownloadProgressUpdate
-	if arg3 != nil {
-		arg3Copy = make([]protocol.FileDownloadProgressUpdate, len(arg3))
-		copy(arg3Copy, arg3)
-	}
+func (fake *Connection) DownloadProgress(arg1 context.Context, arg2 *protocol.DownloadProgress) {
 	fake.downloadProgressMutex.Lock()
 	fake.downloadProgressArgsForCall = append(fake.downloadProgressArgsForCall, struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileDownloadProgressUpdate
-	}{arg1, arg2, arg3Copy})
+		arg2 *protocol.DownloadProgress
+	}{arg1, arg2})
 	stub := fake.DownloadProgressStub
-	fake.recordInvocation("DownloadProgress", []interface{}{arg1, arg2, arg3Copy})
+	fake.recordInvocation("DownloadProgress", []interface{}{arg1, arg2})
 	fake.downloadProgressMutex.Unlock()
 	if stub != nil {
-		fake.DownloadProgressStub(arg1, arg2, arg3)
+		fake.DownloadProgressStub(arg1, arg2)
 	}
 }

@@ -510,17 +494,17 @@ func (fake *Connection) DownloadProgressCallCount() int {
 	return len(fake.downloadProgressArgsForCall)
 }

-func (fake *Connection) DownloadProgressCalls(stub func(context.Context, string, []protocol.FileDownloadProgressUpdate)) {
+func (fake *Connection) DownloadProgressCalls(stub func(context.Context, *protocol.DownloadProgress)) {
 	fake.downloadProgressMutex.Lock()
 	defer fake.downloadProgressMutex.Unlock()
 	fake.DownloadProgressStub = stub
 }

-func (fake *Connection) DownloadProgressArgsForCall(i int) (context.Context, string, []protocol.FileDownloadProgressUpdate) {
+func (fake *Connection) DownloadProgressArgsForCall(i int) (context.Context, *protocol.DownloadProgress) {
 	fake.downloadProgressMutex.RLock()
 	defer fake.downloadProgressMutex.RUnlock()
 	argsForCall := fake.downloadProgressArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1, argsForCall.arg2
 }

 func (fake *Connection) EstablishedAt() time.Time {
@@ -576,25 +560,19 @@ func (fake *Connection) EstablishedAtReturnsOnCall(i int, result1 time.Time) {
 	}{result1}
 }

-func (fake *Connection) Index(arg1 context.Context, arg2 string, arg3 []protocol.FileInfo) error {
-	var arg3Copy []protocol.FileInfo
-	if arg3 != nil {
-		arg3Copy = make([]protocol.FileInfo, len(arg3))
-		copy(arg3Copy, arg3)
-	}
+func (fake *Connection) Index(arg1 context.Context, arg2 *protocol.Index) error {
 	fake.indexMutex.Lock()
 	ret, specificReturn := fake.indexReturnsOnCall[len(fake.indexArgsForCall)]
 	fake.indexArgsForCall = append(fake.indexArgsForCall, struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileInfo
-	}{arg1, arg2, arg3Copy})
+		arg2 *protocol.Index
+	}{arg1, arg2})
 	stub := fake.IndexStub
 	fakeReturns := fake.indexReturns
-	fake.recordInvocation("Index", []interface{}{arg1, arg2, arg3Copy})
+	fake.recordInvocation("Index", []interface{}{arg1, arg2})
 	fake.indexMutex.Unlock()
 	if stub != nil {
-		return stub(arg1, arg2, arg3)
+		return stub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1
@@ -608,17 +586,17 @@ func (fake *Connection) IndexCallCount() int {
 	return len(fake.indexArgsForCall)
 }

-func (fake *Connection) IndexCalls(stub func(context.Context, string, []protocol.FileInfo) error) {
+func (fake *Connection) IndexCalls(stub func(context.Context, *protocol.Index) error) {
 	fake.indexMutex.Lock()
 	defer fake.indexMutex.Unlock()
 	fake.IndexStub = stub
 }

-func (fake *Connection) IndexArgsForCall(i int) (context.Context, string, []protocol.FileInfo) {
+func (fake *Connection) IndexArgsForCall(i int) (context.Context, *protocol.Index) {
 	fake.indexMutex.RLock()
 	defer fake.indexMutex.RUnlock()
 	argsForCall := fake.indexArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1, argsForCall.arg2
 }

 func (fake *Connection) IndexReturns(result1 error) {
@@ -644,25 +622,19 @@ func (fake *Connection) IndexReturnsOnCall(i int, result1 error) {
 	}{result1}
 }

-func (fake *Connection) IndexUpdate(arg1 context.Context, arg2 string, arg3 []protocol.FileInfo) error {
-	var arg3Copy []protocol.FileInfo
-	if arg3 != nil {
-		arg3Copy = make([]protocol.FileInfo, len(arg3))
-		copy(arg3Copy, arg3)
-	}
+func (fake *Connection) IndexUpdate(arg1 context.Context, arg2 *protocol.IndexUpdate) error {
 	fake.indexUpdateMutex.Lock()
 	ret, specificReturn := fake.indexUpdateReturnsOnCall[len(fake.indexUpdateArgsForCall)]
 	fake.indexUpdateArgsForCall = append(fake.indexUpdateArgsForCall, struct {
 		arg1 context.Context
-		arg2 string
-		arg3 []protocol.FileInfo
-	}{arg1, arg2, arg3Copy})
+		arg2 *protocol.IndexUpdate
+	}{arg1, arg2})
 	stub := fake.IndexUpdateStub
 	fakeReturns := fake.indexUpdateReturns
-	fake.recordInvocation("IndexUpdate", []interface{}{arg1, arg2, arg3Copy})
+	fake.recordInvocation("IndexUpdate", []interface{}{arg1, arg2})
 	fake.indexUpdateMutex.Unlock()
 	if stub != nil {
-		return stub(arg1, arg2, arg3)
+		return stub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1
@@ -676,17 +648,17 @@ func (fake *Connection) IndexUpdateCallCount() int {
 	return len(fake.indexUpdateArgsForCall)
 }

-func (fake *Connection) IndexUpdateCalls(stub func(context.Context, string, []protocol.FileInfo) error) {
+func (fake *Connection) IndexUpdateCalls(stub func(context.Context, *protocol.IndexUpdate) error) {
 	fake.indexUpdateMutex.Lock()
 	defer fake.indexUpdateMutex.Unlock()
 	fake.IndexUpdateStub = stub
 }

-func (fake *Connection) IndexUpdateArgsForCall(i int) (context.Context, string, []protocol.FileInfo) {
+func (fake *Connection) IndexUpdateArgsForCall(i int) (context.Context, *protocol.IndexUpdate) {
 	fake.indexUpdateMutex.RLock()
 	defer fake.indexUpdateMutex.RUnlock()
 	argsForCall := fake.indexUpdateArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+	return argsForCall.arg1, argsForCall.arg2
 }

 func (fake *Connection) IndexUpdateReturns(result1 error) {
@@ -871,31 +843,19 @@ func (fake *Connection) RemoteAddrReturnsOnCall(i int, result1 net.Addr) {
 	}{result1}
 }

-func (fake *Connection) Request(arg1 context.Context, arg2 string, arg3 string, arg4 int, arg5 int64, arg6 int, arg7 []byte, arg8 uint32, arg9 bool) ([]byte, error) {
-	var arg7Copy []byte
-	if arg7 != nil {
-		arg7Copy = make([]byte, len(arg7))
-		copy(arg7Copy, arg7)
-	}
+func (fake *Connection) Request(arg1 context.Context, arg2 *protocol.Request) ([]byte, error) {
 	fake.requestMutex.Lock()
 	ret, specificReturn := fake.requestReturnsOnCall[len(fake.requestArgsForCall)]
 	fake.requestArgsForCall = append(fake.requestArgsForCall, struct {
 		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 int
-		arg5 int64
-		arg6 int
-		arg7 []byte
-		arg8 uint32
-		arg9 bool
-	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8, arg9})
+		arg2 *protocol.Request
+	}{arg1, arg2})
 	stub := fake.RequestStub
 	fakeReturns := fake.requestReturns
-	fake.recordInvocation("Request", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8, arg9})
+	fake.recordInvocation("Request", []interface{}{arg1, arg2})
 	fake.requestMutex.Unlock()
 	if stub != nil {
-		return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
+		return stub(arg1, arg2)
 	}
 	if specificReturn {
 		return ret.result1, ret.result2
@@ -909,17 +869,17 @@ func (fake *Connection) RequestCallCount() int {
 	return len(fake.requestArgsForCall)
 }

-func (fake *Connection) RequestCalls(stub func(context.Context, string, string, int, int64, int, []byte, uint32, bool) ([]byte, error)) {
+func (fake *Connection) RequestCalls(stub func(context.Context, *protocol.Request) ([]byte, error)) {
 	fake.requestMutex.Lock()
 	defer fake.requestMutex.Unlock()
 	fake.RequestStub = stub
 }

-func (fake *Connection) RequestArgsForCall(i int) (context.Context, string, string, int, int64, int, []byte, uint32, bool) {
+func (fake *Connection) RequestArgsForCall(i int) (context.Context, *protocol.Request) {
 	fake.requestMutex.RLock()
 	defer fake.requestMutex.RUnlock()
 	argsForCall := fake.requestArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9
+	return argsForCall.arg1, argsForCall.arg2
 }

 func (fake *Connection) RequestReturns(result1 []byte, result2 error) {
@@ -154,30 +154,30 @@ type RequestResponse interface {
 }

 type Connection interface {
-	// Send an index message. The connection will read and marshal the
-	// parameters asynchronously, so they should not be modified after
-	// calling Index().
-	Index(ctx context.Context, folder string, files []FileInfo) error
+	// Send an Index message to the peer device. The message in the
+	// parameter may be altered by the connection and should not be used
+	// further by the caller.
+	Index(ctx context.Context, idx *Index) error

-	// Send an index update message. The connection will read and marshal
-	// the parameters asynchronously, so they should not be modified after
-	// calling IndexUpdate().
-	IndexUpdate(ctx context.Context, folder string, files []FileInfo) error
+	// Send an Index Update message to the peer device. The message in the
+	// parameter may be altered by the connection and should not be used
+	// further by the caller.
+	IndexUpdate(ctx context.Context, idxUp *IndexUpdate) error

-	// Send a request message. The connection will read and marshal the
-	// parameters asynchronously, so they should not be modified after
-	// calling Request().
-	Request(ctx context.Context, folder string, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error)
+	// Send a Request message to the peer device. The message in the
+	// parameter may be altered by the connection and should not be used
+	// further by the caller.
+	Request(ctx context.Context, req *Request) ([]byte, error)

-	// Send a cluster configuration message. The connection will read and
-	// marshal the message asynchronously, so it should not be modified
-	// after calling ClusterConfig().
-	ClusterConfig(config ClusterConfig)
+	// Send a Cluster Configuration message to the peer device. The message
+	// in the parameter may be altered by the connection and should not be
+	// used further by the caller.
+	ClusterConfig(config *ClusterConfig)

-	// Send a download progress message. The connection will read and
-	// marshal the parameters asynchronously, so they should not be modified
-	// after calling DownloadProgress().
-	DownloadProgress(ctx context.Context, folder string, updates []FileDownloadProgressUpdate)
+	// Send a Download Progress message to the peer device. The message in
+	// the parameter may be altered by the connection and should not be used
+	// further by the caller.
+	DownloadProgress(ctx context.Context, dp *DownloadProgress)

 	Start()
 	SetFolderPasswords(passwords map[string]string)
@@ -185,6 +185,7 @@ type Connection interface {
 	DeviceID() DeviceID
 	Statistics() Statistics
 	Closed() <-chan struct{}
+
 	ConnectionInfo
 }

@@ -349,39 +350,33 @@ func (c *rawConnection) DeviceID() DeviceID {
 }

 // Index writes the list of file information to the connected peer device
-func (c *rawConnection) Index(ctx context.Context, folder string, idx []FileInfo) error {
+func (c *rawConnection) Index(ctx context.Context, idx *Index) error {
 	select {
 	case <-c.closed:
 		return ErrClosed
 	default:
 	}
 	c.idxMut.Lock()
-	c.send(ctx, &Index{
-		Folder: folder,
-		Files:  idx,
-	}, nil)
+	c.send(ctx, idx, nil)
 	c.idxMut.Unlock()
 	return nil
 }

 // IndexUpdate writes the list of file information to the connected peer device as an update
-func (c *rawConnection) IndexUpdate(ctx context.Context, folder string, idx []FileInfo) error {
+func (c *rawConnection) IndexUpdate(ctx context.Context, idxUp *IndexUpdate) error {
 	select {
 	case <-c.closed:
 		return ErrClosed
 	default:
 	}
 	c.idxMut.Lock()
-	c.send(ctx, &IndexUpdate{
-		Folder: folder,
-		Files:  idx,
-	}, nil)
+	c.send(ctx, idxUp, nil)
 	c.idxMut.Unlock()
 	return nil
 }

 // Request returns the bytes for the specified block after fetching them from the connected peer.
-func (c *rawConnection) Request(ctx context.Context, folder string, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
+func (c *rawConnection) Request(ctx context.Context, req *Request) ([]byte, error) {
 	rc := make(chan asyncResult, 1)

 	c.awaitingMut.Lock()
@@ -394,17 +389,8 @@ func (c *rawConnection) Request(ctx context.Context, folder string, name string,
 	c.awaiting[id] = rc
 	c.awaitingMut.Unlock()

-	ok := c.send(ctx, &Request{
-		ID:            id,
-		Folder:        folder,
-		Name:          name,
-		Offset:        offset,
-		Size:          size,
-		BlockNo:       blockNo,
-		Hash:          hash,
-		WeakHash:      weakHash,
-		FromTemporary: fromTemporary,
-	}, nil)
+	req.ID = id
+	ok := c.send(ctx, req, nil)
 	if !ok {
 		return nil, ErrClosed
 	}
@@ -421,9 +407,9 @@ func (c *rawConnection) Request(ctx context.Context, folder string, name string,
 }

 // ClusterConfig sends the cluster configuration message to the peer.
-func (c *rawConnection) ClusterConfig(config ClusterConfig) {
+func (c *rawConnection) ClusterConfig(config *ClusterConfig) {
 	select {
-	case c.clusterConfigBox <- &config:
+	case c.clusterConfigBox <- config:
 	case <-c.closed:
 	}
 }
@@ -433,11 +419,8 @@ func (c *rawConnection) Closed() <-chan struct{} {
 }

 // DownloadProgress sends the progress updates for the files that are currently being downloaded.
-func (c *rawConnection) DownloadProgress(ctx context.Context, folder string, updates []FileDownloadProgressUpdate) {
-	c.send(ctx, &DownloadProgress{
-		Folder:  folder,
-		Updates: updates,
-	}, nil)
+func (c *rawConnection) DownloadProgress(ctx context.Context, dp *DownloadProgress) {
+	c.send(ctx, dp, nil)
 }

 func (c *rawConnection) ping() bool {
@@ -38,8 +38,8 @@ func TestPing(t *testing.T) {
 	c1 := getRawConnection(NewConnection(c1ID, br, aw, testutil.NoopCloser{}, newTestModel(), new(mockedConnectionInfo), CompressionAlways, nil, testKeyGen))
 	c1.Start()
 	defer closeAndWait(c1, ar, bw)
-	c0.ClusterConfig(ClusterConfig{})
-	c1.ClusterConfig(ClusterConfig{})
+	c0.ClusterConfig(&ClusterConfig{})
+	c1.ClusterConfig(&ClusterConfig{})

 	if ok := c0.ping(); !ok {
 		t.Error("c0 ping failed")
@@ -64,8 +64,8 @@ func TestClose(t *testing.T) {
 	c1 := NewConnection(c1ID, br, aw, testutil.NoopCloser{}, m1, new(mockedConnectionInfo), CompressionAlways, nil, testKeyGen)
 	c1.Start()
 	defer closeAndWait(c1, ar, bw)
-	c0.ClusterConfig(ClusterConfig{})
-	c1.ClusterConfig(ClusterConfig{})
+	c0.ClusterConfig(&ClusterConfig{})
+	c1.ClusterConfig(&ClusterConfig{})

 	c0.internalClose(errManual)

@@ -82,10 +82,10 @@ func TestClose(t *testing.T) {

 	ctx := context.Background()

-	c0.Index(ctx, "default", nil)
-	c0.Index(ctx, "default", nil)
+	c0.Index(ctx, &Index{Folder: "default"})
+	c0.Index(ctx, &Index{Folder: "default"})

-	if _, err := c0.Request(ctx, "default", "foo", 0, 0, 0, nil, 0, false); err == nil {
+	if _, err := c0.Request(ctx, &Request{Folder: "default", Name: "foo"}); err == nil {
 		t.Error("Request should return an error")
 	}
 }
@@ -111,7 +111,7 @@ func TestCloseOnBlockingSend(t *testing.T) {

 	wg.Add(1)
 	go func() {
-		c.ClusterConfig(ClusterConfig{})
+		c.ClusterConfig(&ClusterConfig{})
 		wg.Done()
 	}()

@@ -160,10 +160,10 @@ func TestCloseRace(t *testing.T) {
 	c1 := NewConnection(c1ID, br, aw, testutil.NoopCloser{}, m1, new(mockedConnectionInfo), CompressionNever, nil, testKeyGen)
 	c1.Start()
 	defer closeAndWait(c1, ar, bw)
-	c0.ClusterConfig(ClusterConfig{})
-	c1.ClusterConfig(ClusterConfig{})
+	c0.ClusterConfig(&ClusterConfig{})
+	c1.ClusterConfig(&ClusterConfig{})

-	c1.Index(context.Background(), "default", nil)
+	c1.Index(context.Background(), &Index{Folder: "default"})
 	select {
 	case <-indexReceived:
 	case <-time.After(time.Second):
@@ -205,7 +205,7 @@ func TestClusterConfigFirst(t *testing.T) {
 		// Allow some time for c.writerLoop to setup after c.Start
 	}

-	c.ClusterConfig(ClusterConfig{})
+	c.ClusterConfig(&ClusterConfig{})

 	done := make(chan struct{})
 	if ok := c.send(context.Background(), &Ping{}, done); !ok {
@@ -907,7 +907,7 @@ func TestClusterConfigAfterClose(t *testing.T) {

 	done := make(chan struct{})
 	go func() {
-		c.ClusterConfig(ClusterConfig{})
+		c.ClusterConfig(&ClusterConfig{})
 		close(done)
 	}()

@@ -13,23 +13,23 @@ type wireFormatConnection struct {
 	Connection
 }

-func (c wireFormatConnection) Index(ctx context.Context, folder string, fs []FileInfo) error {
-	for i := range fs {
-		fs[i].Name = norm.NFC.String(filepath.ToSlash(fs[i].Name))
+func (c wireFormatConnection) Index(ctx context.Context, idx *Index) error {
+	for i := range idx.Files {
+		idx.Files[i].Name = norm.NFC.String(filepath.ToSlash(idx.Files[i].Name))
 	}

-	return c.Connection.Index(ctx, folder, fs)
+	return c.Connection.Index(ctx, idx)
 }

-func (c wireFormatConnection) IndexUpdate(ctx context.Context, folder string, fs []FileInfo) error {
-	for i := range fs {
-		fs[i].Name = norm.NFC.String(filepath.ToSlash(fs[i].Name))
+func (c wireFormatConnection) IndexUpdate(ctx context.Context, idxUp *IndexUpdate) error {
+	for i := range idxUp.Files {
+		idxUp.Files[i].Name = norm.NFC.String(filepath.ToSlash(idxUp.Files[i].Name))
 	}

-	return c.Connection.IndexUpdate(ctx, folder, fs)
+	return c.Connection.IndexUpdate(ctx, idxUp)
 }

-func (c wireFormatConnection) Request(ctx context.Context, folder string, name string, blockNo int, offset int64, size int, hash []byte, weakHash uint32, fromTemporary bool) ([]byte, error) {
-	name = norm.NFC.String(filepath.ToSlash(name))
-	return c.Connection.Request(ctx, folder, name, blockNo, offset, size, hash, weakHash, fromTemporary)
+func (c wireFormatConnection) Request(ctx context.Context, req *Request) ([]byte, error) {
+	req.Name = norm.NFC.String(filepath.ToSlash(req.Name))
+	return c.Connection.Request(ctx, req)
 }
@@ -38,6 +38,13 @@ type Asset struct {
 	BrowserURL string `json:"browser_download_url,omitempty"`
 }

+// ReleaseCompatibility defines the structure of compat.json, which is
+// included with each elease.
+type ReleaseCompatibility struct {
+	Runtime      string            `json:"runtime,omitempty"`
+	Requirements map[string]string `json:"requirements,omitempty"`
+}
+
 var (
 	ErrNoReleaseDownload  = errors.New("couldn't find a release to download")
 	ErrNoVersionToSelect  = errors.New("no version to select")
@@ -14,7 +14,6 @@ import (
 	"archive/zip"
 	"bytes"
 	"compress/gzip"
-	"crypto/tls"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -61,26 +60,18 @@ const (
 	maxMetadataSize = 10 << 20 // 10 MiB
 )

-// This is an HTTP/HTTPS client that does *not* perform certificate
-// validation. We do this because some systems where Syncthing runs have
-// issues with old or missing CA roots. It doesn't actually matter that we
-// load the upgrade insecurely as we verify an ECDSA signature of the actual
-// binary contents before accepting the upgrade.
-var insecureHTTP = &http.Client{
+var upgradeClient = &http.Client{
 	Timeout: readTimeout,
 	Transport: &http.Transport{
 		DialContext: dialer.DialContext,
 		Proxy:       http.ProxyFromEnvironment,
-		TLSClientConfig: &tls.Config{
-			InsecureSkipVerify: true,
-		},
 	},
 }

 var osVersion string

 func init() {
-	_ = http2.ConfigureTransport(insecureHTTP.Transport.(*http.Transport))
+	_ = http2.ConfigureTransport(upgradeClient.Transport.(*http.Transport))
 	osVersion, _ = host.KernelVersion()
 	osVersion = strings.TrimSpace(osVersion)
 }
@@ -95,7 +86,7 @@ func insecureGet(url, version string) (*http.Response, error) {
 	if osVersion != "" {
 		req.Header.Set("Syncthing-Os-Version", osVersion)
 	}
-	return insecureHTTP.Do(req)
+	return upgradeClient.Do(req)
 }

 // FetchLatestReleases returns the latest releases. The "current" parameter
@@ -233,7 +224,7 @@ func readRelease(archiveName, dir, url string) (string, error) {
 	}

 	req.Header.Add("Accept", "application/octet-stream")
-	resp, err := insecureHTTP.Do(req)
+	resp, err := upgradeClient.Do(req)
 	if err != nil {
 		return "", err
 	}
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "STDISCOSRV" "1" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "STDISCOSRV" "1" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 stdiscosrv \- Syncthing Discovery Server
 .SH SYNOPSIS
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "STRELAYSRV" "1" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "STRELAYSRV" "1" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 strelaysrv \- Syncthing Relay Server
 .SH SYNOPSIS
@@ -28,7 +28,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-BEP" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-BEP" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-bep \- Block Exchange Protocol v1
 .SH INTRODUCTION AND DEFINITIONS
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-CONFIG" "5" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-CONFIG" "5" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-config \- Syncthing Configuration
 .SH SYNOPSIS
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-DEVICE-IDS" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-DEVICE-IDS" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-device-ids \- Understanding Device IDs
 .sp
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-EVENT-API" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-EVENT-API" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-event-api \- Event API
 .SH DESCRIPTION
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-FAQ" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-FAQ" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-faq \- Frequently Asked Questions
 .INDENT 0.0
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-GLOBALDISCO" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-GLOBALDISCO" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-globaldisco \- Global Discovery Protocol v3
 .SH ANNOUNCEMENTS
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-LOCALDISCO" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-LOCALDISCO" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-localdisco \- Local Discovery Protocol v4
 .SH MODE OF OPERATION
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-NETWORKING" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-NETWORKING" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-networking \- Firewall Setup
 .SH ROUTER SETUP
@@ -28,7 +28,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-RELAY" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-RELAY" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-relay \- Relay Protocol v1
 .SH WHAT IS A RELAY?
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-REST-API" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-REST-API" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-rest-api \- REST API
 .sp
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-SECURITY" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-SECURITY" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-security \- Security Principles
 .sp
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-STIGNORE" "5" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-STIGNORE" "5" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-stignore \- Prevent files from being synchronized to other nodes
 .SH SYNOPSIS
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING-VERSIONING" "7" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING-VERSIONING" "7" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing-versioning \- Keep automatic backups of deleted files by other nodes
 .sp
@@ -27,7 +27,7 @@ level margin: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]]
 .in \\n[rst2man-indent\\n[rst2man-indent-level]]u
 ..
-.TH "SYNCTHING" "1" "Aug 15, 2024" "v1.27.10" "Syncthing"
+.TH "SYNCTHING" "1" "Sep 04, 2024" "v1.27.11" "Syncthing"
 .SH NAME
 syncthing \- Syncthing
 .SH SYNOPSIS
@@ -81,13 +81,16 @@ enum Compression {
 // Index and Index Update

 message Index {
-    string            folder = 1;
-    repeated FileInfo files  = 2;
+    string            folder        = 1;
+    repeated FileInfo files         = 2;
+    int64             last_sequence = 3; // the highest sequence in this batch
 }

 message IndexUpdate {
-    string            folder = 1;
-    repeated FileInfo files  = 2;
+    string            folder        = 1;
+    repeated FileInfo files         = 2;
+    int64             last_sequence = 3; // the highest sequence in this batch
+    int64             prev_sequence = 4; // the highest sequence in the previous batch
 }

 message FileInfo {
Author	SHA1	Message	Date
Jakob Borg GitHub Ross Smith II	0ea90dd932	build: add generating compat.json (#9700 ) This is to add the generation of `compat.json` as a release artifact. It describes the runtime requirements of the release in question. The next step is to have the upgrade server use this information to filter releases provided to clients. This is per the discussion in #9656 --------- Co-authored-by: Ross Smith II <ross@smithii.com>	2024-09-11 09:29:49 +02:00
Jakob BorgandGitHub	718b1ce2b7	chore(discovery,upgrade): use regular TLS certificate verification (#9673 ) This changes the two remaining instances where we use insecure HTTPS to use standard HTTPS certificate verification. When we introduced these things, almost a decade ago, HTTPS certificates were expensive and annoying to get, much of the web was still HTTP, and many devices seemed to not have up-to-date CA bundles. Nowadays _all_ of the web is HTTPS and I'm skeptical that any device can work well without understanding LetsEncrypt certificates in particular. Our current discovery servers use hardcoded certificates which has several issues: - Not great for security if it leaks as there is no way to rotate it - Not great for infrastructure flexibility as we can't use many load balancer or TLS termination services - The certificate is a very oddball ECDSA-SHA384 type certificate which has higher CPU cost than a more regular certificate, which has real effects on our infrastructure Using normal TLS certificates here improves these things. I expect there will be some very few devices out there for which this doesn't work. For the foreseeable future they can simply change the config to use the old URLs and parameters -- it'll be years before we can retire those entirely. For the upgrade client this simply seems like better hygiene. While our releases are signed anyway, protecting the metadata exchange is _better_ and, again, I doubt many clients will fail this today.	2024-09-11 09:29:19 +02:00
Simon FreiandGitHub	29f7510f5a	lib/fs: Add test reproducing missing mtimefs issue (ref #9677 ) (#9687 ) The test is quite odd and specific, but it does reproduce the issue that caused #9677, so I'd propose to add it to have a simple regression test for the basic scenario. Also the option to the fakefs might come handy for other scenarios where you want to quickly test some behaviour on a filesystem without nanosecond precision, without actually needing access to one.	2024-09-10 13:36:17 +02:00
Syncthing Release Automation	a7f9ed4a80	gui, man, authors: Update docs, translations, and contributors	2024-09-09 03:45:15 +00:00
tomasz1986andGitHub	1baefea410	gui: Actually filter scope ID out of IPv6 address when using Remote GUI (ref #8084 ) (#9688 ) gui: Actually filter scope ID out of IPv6 address when using Remote GUI (ref #8084) The current code does not work, because it uses a string in the replace() method instead of regex. Thus, change it to a proper regex. Signed-off-by: Tomasz Wilczyński <twilczynski@naver.com>	2024-09-08 12:42:32 +02:00
Jakob Borg	563cec8923	Merge branch 'release' * release: Revert "lib/fs: Put the caseFS as the outermost layer (#9648)"	2024-09-06 09:39:09 +02:00
Jakob Borg	a3c340ece9	Revert "lib/fs: Put the caseFS as the outermost layer (#9648 )" This reverts commit `7517d18fbb`. Fixes #9677	2024-09-06 09:15:45 +02:00
André ColombandGitHub	cb24638ec9	lib/api: Correct ordering of Accept-Language codes by weight (fixes #9670 ) (#9671 ) The preference for languages in the Accept-Language header field should not be deduced from the listed order, but from the passed "quality values", according to the HTTP specification: https://httpwg.org/specs/rfc9110.html#field.accept-language This implements the parsing of q=values and ordering within the API backend, to not complicate things further in the GUI code. Entries with invalid (unparseable) quality values are discarded completely. * gui: Fix API endpoint in comment.	2024-09-02 10:15:04 +02:00
Syncthing Release Automation	2fb24dc2cc	gui, man, authors: Update docs, translations, and contributors	2024-09-02 03:45:15 +00:00
tomasz1986andGitHub	9aa2d2c92f	gui: Fix incorrect UI language auto detection (fixes #9668 ) (#9669 ) gui: Fix incorrect UI language auto detection (fixes #9668) Currently, the code only checks whether the detected language partially matches one of the available languages. This means that if the detected language is "fi" but among the available languages there is only "fil" and no "fi", then it will match "fi" with "fil", even though the two are completely different languages. With this change, the matching is only done when there is a hyphen in the language code, e.g. "en" will match with "en-US". Signed-off-by: Tomasz Wilczyński <twilczynski@naver.com>	2024-08-31 22:47:10 +02:00
Jakob Borg	d1c5100c98	Merge branch 'release' * release: lib/upgrade: Send OS version header to upgrade server (#9663)	2024-08-30 11:32:49 +02:00
Jakob BorgandGitHub	42e677c055	lib/model, lib/protocol: Index sending/receiving debugging (#9657 ) This adds guardrails to the index sending and receiving, to verify that what we thinks is happening is what actually happens.	2024-08-28 15:00:19 +02:00
Jakob BorgandGitHub	feff334547	lib/upgrade: Send OS version header to upgrade server (#9663 ) This adds a header with the operating system version, verbatim in whatever format the operating system reports it, to the upgrade check. The intention is that the upgrade server can use this information to filter out (or maybe just mark) potentially unsupported upgrades.	2024-08-28 08:31:10 +02:00
Syncthing Release Automation	713cf357ce	gui, man, authors: Update docs, translations, and contributors	2024-08-26 03:45:23 +00:00
Jakob BorgandGitHub	5342bec1b7	lib/protocol: Further interface refactor (#9396 ) This is a symmetric change to #9375 -- where that PR changed the protocol->model interface, this changes the model->protocol one.	2024-08-24 12:45:10 +02:00
Emil LundbergandGitHub	7df75e681d	gui: Replace global "Panel padding decrease" style with targeted class (#9659 ) Transplanted from https://github.com/emlun/syncthing/pull/8 (meta-PR into https://github.com/syncthing/syncthing/pull/9175) by request of @acolomb (see: https://github.com/emlun/syncthing/pull/8#discussion_r1724470574). This padding decrease currently applies to _all_ collapsible panels, but this padding decrease may not be appropriate for all collapsible panels. In particular, it will not be appropriate for the collapsible panels introduced in https://github.com/emlun/syncthing/pull/8.	2024-08-21 15:02:45 +02:00
Jakob Borg GitHub Ross Smith II	8dc826b234	build: use Go 1.23, require minimum 1.22 (#9651 ) 🥳 --------- Co-authored-by: Ross Smith II <ross@smithii.com>	2024-08-19 20:26:08 +02:00