commit 11a0f1c68d301481439e7e773e9d22f14776a47f · oppi.li/indigo

+208 -128

api/atproto/cbor_gen.go

··· 129 return fmt.Errorf("RepoStrongRef: map struct too large (%d)", extra) 130 } 131 132 - var name string 133 n := extra 134 135 for i := uint64(0); i < n; i++ { 136 137 - { 138 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 139 - if err != nil { 140 return err 141 } 142 - 143 - name = string(sval) 144 } 145 146 - switch name { 147 // t.Cid (string) (string) 148 case "cid": 149 ··· 180 181 default: 182 // Field doesn't exist on this type, so ignore it 183 - cbg.ScanForLinks(r, func(cid.Cid) {}) 184 } 185 } 186 ··· 492 return fmt.Errorf("SyncSubscribeRepos_Commit: map struct too large (%d)", extra) 493 } 494 495 - var name string 496 n := extra 497 498 for i := uint64(0); i < n; i++ { 499 500 - { 501 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 502 - if err != nil { 503 return err 504 } 505 - 506 - name = string(sval) 507 } 508 509 - switch name { 510 // t.Ops ([]*atproto.SyncSubscribeRepos_RepoOp) (slice) 511 case "ops": 512 ··· 767 768 default: 769 // Field doesn't exist on this type, so ignore it 770 - cbg.ScanForLinks(r, func(cid.Cid) {}) 771 } 772 } 773 ··· 901 return fmt.Errorf("SyncSubscribeRepos_Handle: map struct too large (%d)", extra) 902 } 903 904 - var name string 905 n := extra 906 907 for i := uint64(0); i < n; i++ { 908 909 - { 910 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 911 - if err != nil { 912 return err 913 } 914 - 915 - name = string(sval) 916 } 917 918 - switch name { 919 // t.Did (string) (string) 920 case "did": 921 ··· 978 979 default: 980 // Field doesn't exist on this type, so ignore it 981 - cbg.ScanForLinks(r, func(cid.Cid) {}) 982 } 983 } 984 ··· 1126 return fmt.Errorf("SyncSubscribeRepos_Identity: map struct too large (%d)", extra) 1127 } 1128 1129 - var name string 1130 n := extra 1131 1132 for i := uint64(0); i < n; i++ { 1133 1134 - { 1135 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1136 - if err != nil { 1137 return err 1138 } 1139 - 1140 - name = string(sval) 1141 } 1142 1143 - switch name { 1144 // t.Did (string) (string) 1145 case "did": 1146 ··· 1213 1214 default: 1215 // Field doesn't exist on this type, so ignore it 1216 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1217 } 1218 } 1219 ··· 1377 return fmt.Errorf("SyncSubscribeRepos_Account: map struct too large (%d)", extra) 1378 } 1379 1380 - var name string 1381 n := extra 1382 1383 for i := uint64(0); i < n; i++ { 1384 1385 - { 1386 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1387 - if err != nil { 1388 return err 1389 } 1390 - 1391 - name = string(sval) 1392 } 1393 1394 - switch name { 1395 // t.Did (string) (string) 1396 case "did": 1397 ··· 1482 1483 default: 1484 // Field doesn't exist on this type, so ignore it 1485 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1486 } 1487 } 1488 ··· 1585 return fmt.Errorf("SyncSubscribeRepos_Info: map struct too large (%d)", extra) 1586 } 1587 1588 - var name string 1589 n := extra 1590 1591 for i := uint64(0); i < n; i++ { 1592 1593 - { 1594 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1595 - if err != nil { 1596 return err 1597 } 1598 - 1599 - name = string(sval) 1600 } 1601 1602 - switch name { 1603 // t.Name (string) (string) 1604 case "name": 1605 ··· 1635 1636 default: 1637 // Field doesn't exist on this type, so ignore it 1638 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1639 } 1640 } 1641 ··· 1775 return fmt.Errorf("SyncSubscribeRepos_Migrate: map struct too large (%d)", extra) 1776 } 1777 1778 - var name string 1779 n := extra 1780 1781 for i := uint64(0); i < n; i++ { 1782 1783 - { 1784 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1785 - if err != nil { 1786 return err 1787 } 1788 - 1789 - name = string(sval) 1790 } 1791 1792 - switch name { 1793 // t.Did (string) (string) 1794 case "did": 1795 ··· 1862 1863 default: 1864 // Field doesn't exist on this type, so ignore it 1865 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1866 } 1867 } 1868 ··· 1967 return fmt.Errorf("SyncSubscribeRepos_RepoOp: map struct too large (%d)", extra) 1968 } 1969 1970 - var name string 1971 n := extra 1972 1973 for i := uint64(0); i < n; i++ { 1974 1975 - { 1976 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1977 - if err != nil { 1978 return err 1979 } 1980 - 1981 - name = string(sval) 1982 } 1983 1984 - switch name { 1985 // t.Cid (util.LexLink) (struct) 1986 case "cid": 1987 ··· 2027 2028 default: 2029 // Field doesn't exist on this type, so ignore it 2030 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2031 } 2032 } 2033 ··· 2138 return fmt.Errorf("SyncSubscribeRepos_Tombstone: map struct too large (%d)", extra) 2139 } 2140 2141 - var name string 2142 n := extra 2143 2144 for i := uint64(0); i < n; i++ { 2145 2146 - { 2147 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2148 - if err != nil { 2149 return err 2150 } 2151 - 2152 - name = string(sval) 2153 } 2154 2155 - switch name { 2156 // t.Did (string) (string) 2157 case "did": 2158 ··· 2204 2205 default: 2206 // Field doesn't exist on this type, so ignore it 2207 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2208 } 2209 } 2210 ··· 2301 return fmt.Errorf("LabelDefs_SelfLabels: map struct too large (%d)", extra) 2302 } 2303 2304 - var name string 2305 n := extra 2306 2307 for i := uint64(0); i < n; i++ { 2308 2309 - { 2310 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2311 - if err != nil { 2312 return err 2313 } 2314 - 2315 - name = string(sval) 2316 } 2317 2318 - switch name { 2319 // t.LexiconTypeID (string) (string) 2320 case "$type": 2321 ··· 2390 2391 default: 2392 // Field doesn't exist on this type, so ignore it 2393 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2394 } 2395 } 2396 ··· 2456 return fmt.Errorf("LabelDefs_SelfLabel: map struct too large (%d)", extra) 2457 } 2458 2459 - var name string 2460 n := extra 2461 2462 for i := uint64(0); i < n; i++ { 2463 2464 - { 2465 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2466 - if err != nil { 2467 return err 2468 } 2469 - 2470 - name = string(sval) 2471 } 2472 2473 - switch name { 2474 // t.Val (string) (string) 2475 case "val": 2476 ··· 2485 2486 default: 2487 // Field doesn't exist on this type, so ignore it 2488 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2489 } 2490 } 2491 ··· 2790 return fmt.Errorf("LabelDefs_Label: map struct too large (%d)", extra) 2791 } 2792 2793 - var name string 2794 n := extra 2795 2796 for i := uint64(0); i < n; i++ { 2797 2798 - { 2799 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2800 - if err != nil { 2801 return err 2802 } 2803 - 2804 - name = string(sval) 2805 } 2806 2807 - switch name { 2808 // t.Cid (string) (string) 2809 case "cid": 2810 ··· 2986 2987 default: 2988 // Field doesn't exist on this type, so ignore it 2989 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2990 } 2991 } 2992 ··· 3077 return fmt.Errorf("LabelSubscribeLabels_Labels: map struct too large (%d)", extra) 3078 } 3079 3080 - var name string 3081 n := extra 3082 3083 for i := uint64(0); i < n; i++ { 3084 3085 - { 3086 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3087 - if err != nil { 3088 return err 3089 } 3090 - 3091 - name = string(sval) 3092 } 3093 3094 - switch name { 3095 // t.Seq (int64) (int64) 3096 case "seq": 3097 { ··· 3170 3171 default: 3172 // Field doesn't exist on this type, so ignore it 3173 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3174 } 3175 } 3176 ··· 3273 return fmt.Errorf("LabelSubscribeLabels_Info: map struct too large (%d)", extra) 3274 } 3275 3276 - var name string 3277 n := extra 3278 3279 for i := uint64(0); i < n; i++ { 3280 3281 - { 3282 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3283 - if err != nil { 3284 return err 3285 } 3286 - 3287 - name = string(sval) 3288 } 3289 3290 - switch name { 3291 // t.Name (string) (string) 3292 case "name": 3293 ··· 3323 3324 default: 3325 // Field doesn't exist on this type, so ignore it 3326 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3327 } 3328 } 3329 ··· 3527 return fmt.Errorf("LabelDefs_LabelValueDefinition: map struct too large (%d)", extra) 3528 } 3529 3530 - var name string 3531 n := extra 3532 3533 for i := uint64(0); i < n; i++ { 3534 3535 - { 3536 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3537 - if err != nil { 3538 return err 3539 } 3540 - 3541 - name = string(sval) 3542 } 3543 3544 - switch name { 3545 // t.Blurs (string) (string) 3546 case "blurs": 3547 ··· 3681 3682 default: 3683 // Field doesn't exist on this type, so ignore it 3684 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3685 } 3686 } 3687 ··· 3793 return fmt.Errorf("LabelDefs_LabelValueDefinitionStrings: map struct too large (%d)", extra) 3794 } 3795 3796 - var name string 3797 n := extra 3798 3799 for i := uint64(0); i < n; i++ { 3800 3801 - { 3802 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3803 - if err != nil { 3804 return err 3805 } 3806 - 3807 - name = string(sval) 3808 } 3809 3810 - switch name { 3811 // t.Lang (string) (string) 3812 case "lang": 3813 ··· 3844 3845 default: 3846 // Field doesn't exist on this type, so ignore it 3847 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3848 } 3849 } 3850

··· 129 return fmt.Errorf("RepoStrongRef: map struct too large (%d)", extra) 130 } 131 132 n := extra 133 134 + nameBuf := make([]byte, 5) 135 for i := uint64(0); i < n; i++ { 136 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 137 + if err != nil { 138 + return err 139 + } 140 141 + if !ok { 142 + // Field doesn't exist on this type, so ignore it 143 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 144 return err 145 } 146 + continue 147 } 148 149 + switch string(nameBuf[:nameLen]) { 150 // t.Cid (string) (string) 151 case "cid": 152 ··· 183 184 default: 185 // Field doesn't exist on this type, so ignore it 186 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 187 + return err 188 + } 189 } 190 } 191 ··· 497 return fmt.Errorf("SyncSubscribeRepos_Commit: map struct too large (%d)", extra) 498 } 499 500 n := extra 501 502 + nameBuf := make([]byte, 6) 503 for i := uint64(0); i < n; i++ { 504 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 505 + if err != nil { 506 + return err 507 + } 508 509 + if !ok { 510 + // Field doesn't exist on this type, so ignore it 511 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 512 return err 513 } 514 + continue 515 } 516 517 + switch string(nameBuf[:nameLen]) { 518 // t.Ops ([]*atproto.SyncSubscribeRepos_RepoOp) (slice) 519 case "ops": 520 ··· 775 776 default: 777 // Field doesn't exist on this type, so ignore it 778 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 779 + return err 780 + } 781 } 782 } 783 ··· 911 return fmt.Errorf("SyncSubscribeRepos_Handle: map struct too large (%d)", extra) 912 } 913 914 n := extra 915 916 + nameBuf := make([]byte, 6) 917 for i := uint64(0); i < n; i++ { 918 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 919 + if err != nil { 920 + return err 921 + } 922 923 + if !ok { 924 + // Field doesn't exist on this type, so ignore it 925 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 926 return err 927 } 928 + continue 929 } 930 931 + switch string(nameBuf[:nameLen]) { 932 // t.Did (string) (string) 933 case "did": 934 ··· 991 992 default: 993 // Field doesn't exist on this type, so ignore it 994 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 995 + return err 996 + } 997 } 998 } 999 ··· 1141 return fmt.Errorf("SyncSubscribeRepos_Identity: map struct too large (%d)", extra) 1142 } 1143 1144 n := extra 1145 1146 + nameBuf := make([]byte, 6) 1147 for i := uint64(0); i < n; i++ { 1148 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1149 + if err != nil { 1150 + return err 1151 + } 1152 1153 + if !ok { 1154 + // Field doesn't exist on this type, so ignore it 1155 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1156 return err 1157 } 1158 + continue 1159 } 1160 1161 + switch string(nameBuf[:nameLen]) { 1162 // t.Did (string) (string) 1163 case "did": 1164 ··· 1231 1232 default: 1233 // Field doesn't exist on this type, so ignore it 1234 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1235 + return err 1236 + } 1237 } 1238 } 1239 ··· 1397 return fmt.Errorf("SyncSubscribeRepos_Account: map struct too large (%d)", extra) 1398 } 1399 1400 n := extra 1401 1402 + nameBuf := make([]byte, 6) 1403 for i := uint64(0); i < n; i++ { 1404 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1405 + if err != nil { 1406 + return err 1407 + } 1408 1409 + if !ok { 1410 + // Field doesn't exist on this type, so ignore it 1411 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1412 return err 1413 } 1414 + continue 1415 } 1416 1417 + switch string(nameBuf[:nameLen]) { 1418 // t.Did (string) (string) 1419 case "did": 1420 ··· 1505 1506 default: 1507 // Field doesn't exist on this type, so ignore it 1508 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1509 + return err 1510 + } 1511 } 1512 } 1513 ··· 1610 return fmt.Errorf("SyncSubscribeRepos_Info: map struct too large (%d)", extra) 1611 } 1612 1613 n := extra 1614 1615 + nameBuf := make([]byte, 7) 1616 for i := uint64(0); i < n; i++ { 1617 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1618 + if err != nil { 1619 + return err 1620 + } 1621 1622 + if !ok { 1623 + // Field doesn't exist on this type, so ignore it 1624 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1625 return err 1626 } 1627 + continue 1628 } 1629 1630 + switch string(nameBuf[:nameLen]) { 1631 // t.Name (string) (string) 1632 case "name": 1633 ··· 1663 1664 default: 1665 // Field doesn't exist on this type, so ignore it 1666 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1667 + return err 1668 + } 1669 } 1670 } 1671 ··· 1805 return fmt.Errorf("SyncSubscribeRepos_Migrate: map struct too large (%d)", extra) 1806 } 1807 1808 n := extra 1809 1810 + nameBuf := make([]byte, 9) 1811 for i := uint64(0); i < n; i++ { 1812 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1813 + if err != nil { 1814 + return err 1815 + } 1816 1817 + if !ok { 1818 + // Field doesn't exist on this type, so ignore it 1819 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1820 return err 1821 } 1822 + continue 1823 } 1824 1825 + switch string(nameBuf[:nameLen]) { 1826 // t.Did (string) (string) 1827 case "did": 1828 ··· 1895 1896 default: 1897 // Field doesn't exist on this type, so ignore it 1898 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1899 + return err 1900 + } 1901 } 1902 } 1903 ··· 2002 return fmt.Errorf("SyncSubscribeRepos_RepoOp: map struct too large (%d)", extra) 2003 } 2004 2005 n := extra 2006 2007 + nameBuf := make([]byte, 6) 2008 for i := uint64(0); i < n; i++ { 2009 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2010 + if err != nil { 2011 + return err 2012 + } 2013 2014 + if !ok { 2015 + // Field doesn't exist on this type, so ignore it 2016 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2017 return err 2018 } 2019 + continue 2020 } 2021 2022 + switch string(nameBuf[:nameLen]) { 2023 // t.Cid (util.LexLink) (struct) 2024 case "cid": 2025 ··· 2065 2066 default: 2067 // Field doesn't exist on this type, so ignore it 2068 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2069 + return err 2070 + } 2071 } 2072 } 2073 ··· 2178 return fmt.Errorf("SyncSubscribeRepos_Tombstone: map struct too large (%d)", extra) 2179 } 2180 2181 n := extra 2182 2183 + nameBuf := make([]byte, 4) 2184 for i := uint64(0); i < n; i++ { 2185 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2186 + if err != nil { 2187 + return err 2188 + } 2189 2190 + if !ok { 2191 + // Field doesn't exist on this type, so ignore it 2192 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2193 return err 2194 } 2195 + continue 2196 } 2197 2198 + switch string(nameBuf[:nameLen]) { 2199 // t.Did (string) (string) 2200 case "did": 2201 ··· 2247 2248 default: 2249 // Field doesn't exist on this type, so ignore it 2250 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2251 + return err 2252 + } 2253 } 2254 } 2255 ··· 2346 return fmt.Errorf("LabelDefs_SelfLabels: map struct too large (%d)", extra) 2347 } 2348 2349 n := extra 2350 2351 + nameBuf := make([]byte, 6) 2352 for i := uint64(0); i < n; i++ { 2353 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2354 + if err != nil { 2355 + return err 2356 + } 2357 2358 + if !ok { 2359 + // Field doesn't exist on this type, so ignore it 2360 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2361 return err 2362 } 2363 + continue 2364 } 2365 2366 + switch string(nameBuf[:nameLen]) { 2367 // t.LexiconTypeID (string) (string) 2368 case "$type": 2369 ··· 2438 2439 default: 2440 // Field doesn't exist on this type, so ignore it 2441 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2442 + return err 2443 + } 2444 } 2445 } 2446 ··· 2506 return fmt.Errorf("LabelDefs_SelfLabel: map struct too large (%d)", extra) 2507 } 2508 2509 n := extra 2510 2511 + nameBuf := make([]byte, 3) 2512 for i := uint64(0); i < n; i++ { 2513 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2514 + if err != nil { 2515 + return err 2516 + } 2517 2518 + if !ok { 2519 + // Field doesn't exist on this type, so ignore it 2520 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2521 return err 2522 } 2523 + continue 2524 } 2525 2526 + switch string(nameBuf[:nameLen]) { 2527 // t.Val (string) (string) 2528 case "val": 2529 ··· 2538 2539 default: 2540 // Field doesn't exist on this type, so ignore it 2541 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2542 + return err 2543 + } 2544 } 2545 } 2546 ··· 2845 return fmt.Errorf("LabelDefs_Label: map struct too large (%d)", extra) 2846 } 2847 2848 n := extra 2849 2850 + nameBuf := make([]byte, 3) 2851 for i := uint64(0); i < n; i++ { 2852 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2853 + if err != nil { 2854 + return err 2855 + } 2856 2857 + if !ok { 2858 + // Field doesn't exist on this type, so ignore it 2859 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2860 return err 2861 } 2862 + continue 2863 } 2864 2865 + switch string(nameBuf[:nameLen]) { 2866 // t.Cid (string) (string) 2867 case "cid": 2868 ··· 3044 3045 default: 3046 // Field doesn't exist on this type, so ignore it 3047 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3048 + return err 3049 + } 3050 } 3051 } 3052 ··· 3137 return fmt.Errorf("LabelSubscribeLabels_Labels: map struct too large (%d)", extra) 3138 } 3139 3140 n := extra 3141 3142 + nameBuf := make([]byte, 6) 3143 for i := uint64(0); i < n; i++ { 3144 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3145 + if err != nil { 3146 + return err 3147 + } 3148 3149 + if !ok { 3150 + // Field doesn't exist on this type, so ignore it 3151 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3152 return err 3153 } 3154 + continue 3155 } 3156 3157 + switch string(nameBuf[:nameLen]) { 3158 // t.Seq (int64) (int64) 3159 case "seq": 3160 { ··· 3233 3234 default: 3235 // Field doesn't exist on this type, so ignore it 3236 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3237 + return err 3238 + } 3239 } 3240 } 3241 ··· 3338 return fmt.Errorf("LabelSubscribeLabels_Info: map struct too large (%d)", extra) 3339 } 3340 3341 n := extra 3342 3343 + nameBuf := make([]byte, 7) 3344 for i := uint64(0); i < n; i++ { 3345 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3346 + if err != nil { 3347 + return err 3348 + } 3349 3350 + if !ok { 3351 + // Field doesn't exist on this type, so ignore it 3352 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3353 return err 3354 } 3355 + continue 3356 } 3357 3358 + switch string(nameBuf[:nameLen]) { 3359 // t.Name (string) (string) 3360 case "name": 3361 ··· 3391 3392 default: 3393 // Field doesn't exist on this type, so ignore it 3394 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3395 + return err 3396 + } 3397 } 3398 } 3399 ··· 3597 return fmt.Errorf("LabelDefs_LabelValueDefinition: map struct too large (%d)", extra) 3598 } 3599 3600 n := extra 3601 3602 + nameBuf := make([]byte, 14) 3603 for i := uint64(0); i < n; i++ { 3604 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3605 + if err != nil { 3606 + return err 3607 + } 3608 3609 + if !ok { 3610 + // Field doesn't exist on this type, so ignore it 3611 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3612 return err 3613 } 3614 + continue 3615 } 3616 3617 + switch string(nameBuf[:nameLen]) { 3618 // t.Blurs (string) (string) 3619 case "blurs": 3620 ··· 3754 3755 default: 3756 // Field doesn't exist on this type, so ignore it 3757 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3758 + return err 3759 + } 3760 } 3761 } 3762 ··· 3868 return fmt.Errorf("LabelDefs_LabelValueDefinitionStrings: map struct too large (%d)", extra) 3869 } 3870 3871 n := extra 3872 3873 + nameBuf := make([]byte, 11) 3874 for i := uint64(0); i < n; i++ { 3875 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3876 + if err != nil { 3877 + return err 3878 + } 3879 3880 + if !ok { 3881 + // Field doesn't exist on this type, so ignore it 3882 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3883 return err 3884 } 3885 + continue 3886 } 3887 3888 + switch string(nameBuf[:nameLen]) { 3889 // t.Lang (string) (string) 3890 case "lang": 3891 ··· 3922 3923 default: 3924 // Field doesn't exist on this type, so ignore it 3925 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3926 + return err 3927 + } 3928 } 3929 } 3930

+494 -304

api/bsky/cbor_gen.go

··· 338 return fmt.Errorf("FeedPost: map struct too large (%d)", extra) 339 } 340 341 - var name string 342 n := extra 343 344 for i := uint64(0); i < n; i++ { 345 346 - { 347 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 348 - if err != nil { 349 return err 350 } 351 - 352 - name = string(sval) 353 } 354 355 - switch name { 356 // t.Tags ([]string) (slice) 357 case "tags": 358 ··· 627 628 default: 629 // Field doesn't exist on this type, so ignore it 630 - cbg.ScanForLinks(r, func(cid.Cid) {}) 631 } 632 } 633 ··· 728 return fmt.Errorf("FeedRepost: map struct too large (%d)", extra) 729 } 730 731 - var name string 732 n := extra 733 734 for i := uint64(0); i < n; i++ { 735 736 - { 737 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 738 - if err != nil { 739 return err 740 } 741 - 742 - name = string(sval) 743 } 744 745 - switch name { 746 // t.LexiconTypeID (string) (string) 747 case "$type": 748 ··· 788 789 default: 790 // Field doesn't exist on this type, so ignore it 791 - cbg.ScanForLinks(r, func(cid.Cid) {}) 792 } 793 } 794 ··· 893 return fmt.Errorf("FeedPost_Entity: map struct too large (%d)", extra) 894 } 895 896 - var name string 897 n := extra 898 899 for i := uint64(0); i < n; i++ { 900 901 - { 902 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 903 - if err != nil { 904 return err 905 } 906 - 907 - name = string(sval) 908 } 909 910 - switch name { 911 // t.Type (string) (string) 912 case "type": 913 ··· 953 954 default: 955 // Field doesn't exist on this type, so ignore it 956 - cbg.ScanForLinks(r, func(cid.Cid) {}) 957 } 958 } 959 ··· 1028 return fmt.Errorf("FeedPost_ReplyRef: map struct too large (%d)", extra) 1029 } 1030 1031 - var name string 1032 n := extra 1033 1034 for i := uint64(0); i < n; i++ { 1035 1036 - { 1037 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1038 - if err != nil { 1039 return err 1040 } 1041 - 1042 - name = string(sval) 1043 } 1044 1045 - switch name { 1046 // t.Root (atproto.RepoStrongRef) (struct) 1047 case "root": 1048 ··· 1086 1087 default: 1088 // Field doesn't exist on this type, so ignore it 1089 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1090 } 1091 } 1092 ··· 1174 return fmt.Errorf("FeedPost_TextSlice: map struct too large (%d)", extra) 1175 } 1176 1177 - var name string 1178 n := extra 1179 1180 for i := uint64(0); i < n; i++ { 1181 1182 - { 1183 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1184 - if err != nil { 1185 return err 1186 } 1187 - 1188 - name = string(sval) 1189 } 1190 1191 - switch name { 1192 // t.End (int64) (int64) 1193 case "end": 1194 { ··· 1244 1245 default: 1246 // Field doesn't exist on this type, so ignore it 1247 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1248 } 1249 } 1250 ··· 1332 return fmt.Errorf("EmbedImages: map struct too large (%d)", extra) 1333 } 1334 1335 - var name string 1336 n := extra 1337 1338 for i := uint64(0); i < n; i++ { 1339 1340 - { 1341 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1342 - if err != nil { 1343 return err 1344 } 1345 - 1346 - name = string(sval) 1347 } 1348 1349 - switch name { 1350 // t.LexiconTypeID (string) (string) 1351 case "$type": 1352 ··· 1410 1411 default: 1412 // Field doesn't exist on this type, so ignore it 1413 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1414 } 1415 } 1416 ··· 1488 return fmt.Errorf("EmbedExternal: map struct too large (%d)", extra) 1489 } 1490 1491 - var name string 1492 n := extra 1493 1494 for i := uint64(0); i < n; i++ { 1495 1496 - { 1497 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1498 - if err != nil { 1499 return err 1500 } 1501 - 1502 - name = string(sval) 1503 } 1504 1505 - switch name { 1506 // t.LexiconTypeID (string) (string) 1507 case "$type": 1508 ··· 1537 1538 default: 1539 // Field doesn't exist on this type, so ignore it 1540 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1541 } 1542 } 1543 ··· 1673 return fmt.Errorf("EmbedExternal_External: map struct too large (%d)", extra) 1674 } 1675 1676 - var name string 1677 n := extra 1678 1679 for i := uint64(0); i < n; i++ { 1680 1681 - { 1682 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1683 - if err != nil { 1684 return err 1685 } 1686 - 1687 - name = string(sval) 1688 } 1689 1690 - switch name { 1691 // t.Uri (string) (string) 1692 case "uri": 1693 ··· 1744 1745 default: 1746 // Field doesn't exist on this type, so ignore it 1747 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1748 } 1749 } 1750 ··· 1850 return fmt.Errorf("EmbedImages_Image: map struct too large (%d)", extra) 1851 } 1852 1853 - var name string 1854 n := extra 1855 1856 for i := uint64(0); i < n; i++ { 1857 1858 - { 1859 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1860 - if err != nil { 1861 return err 1862 } 1863 - 1864 - name = string(sval) 1865 } 1866 1867 - switch name { 1868 // t.Alt (string) (string) 1869 case "alt": 1870 ··· 1919 1920 default: 1921 // Field doesn't exist on this type, so ignore it 1922 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1923 } 1924 } 1925 ··· 2027 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) 2028 } 2029 2030 - var name string 2031 n := extra 2032 2033 for i := uint64(0); i < n; i++ { 2034 2035 - { 2036 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2037 - if err != nil { 2038 return err 2039 } 2040 - 2041 - name = string(sval) 2042 } 2043 2044 - switch name { 2045 // t.LexiconTypeID (string) (string) 2046 case "$type": 2047 ··· 2078 2079 default: 2080 // Field doesn't exist on this type, so ignore it 2081 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2082 } 2083 } 2084 ··· 2364 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 2365 } 2366 2367 - var name string 2368 n := extra 2369 2370 for i := uint64(0); i < n; i++ { 2371 2372 - { 2373 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2374 - if err != nil { 2375 return err 2376 } 2377 - 2378 - name = string(sval) 2379 } 2380 2381 - switch name { 2382 // t.LexiconTypeID (string) (string) 2383 case "$type": 2384 ··· 2556 2557 default: 2558 // Field doesn't exist on this type, so ignore it 2559 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2560 } 2561 } 2562 ··· 2634 return fmt.Errorf("EmbedRecord: map struct too large (%d)", extra) 2635 } 2636 2637 - var name string 2638 n := extra 2639 2640 for i := uint64(0); i < n; i++ { 2641 2642 - { 2643 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2644 - if err != nil { 2645 return err 2646 } 2647 - 2648 - name = string(sval) 2649 } 2650 2651 - switch name { 2652 // t.LexiconTypeID (string) (string) 2653 case "$type": 2654 ··· 2683 2684 default: 2685 // Field doesn't exist on this type, so ignore it 2686 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2687 } 2688 } 2689 ··· 2784 return fmt.Errorf("FeedLike: map struct too large (%d)", extra) 2785 } 2786 2787 - var name string 2788 n := extra 2789 2790 for i := uint64(0); i < n; i++ { 2791 2792 - { 2793 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2794 - if err != nil { 2795 return err 2796 } 2797 - 2798 - name = string(sval) 2799 } 2800 2801 - switch name { 2802 // t.LexiconTypeID (string) (string) 2803 case "$type": 2804 ··· 2844 2845 default: 2846 // Field doesn't exist on this type, so ignore it 2847 - cbg.ScanForLinks(r, func(cid.Cid) {}) 2848 } 2849 } 2850 ··· 2929 return fmt.Errorf("RichtextFacet: map struct too large (%d)", extra) 2930 } 2931 2932 - var name string 2933 n := extra 2934 2935 for i := uint64(0); i < n; i++ { 2936 2937 - { 2938 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2939 - if err != nil { 2940 return err 2941 } 2942 - 2943 - name = string(sval) 2944 } 2945 2946 - switch name { 2947 // t.Index (bsky.RichtextFacet_ByteSlice) (struct) 2948 case "index": 2949 ··· 3016 3017 default: 3018 // Field doesn't exist on this type, so ignore it 3019 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3020 } 3021 } 3022 ··· 3104 return fmt.Errorf("RichtextFacet_ByteSlice: map struct too large (%d)", extra) 3105 } 3106 3107 - var name string 3108 n := extra 3109 3110 for i := uint64(0); i < n; i++ { 3111 3112 - { 3113 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3114 - if err != nil { 3115 return err 3116 } 3117 - 3118 - name = string(sval) 3119 } 3120 3121 - switch name { 3122 // t.ByteEnd (int64) (int64) 3123 case "byteEnd": 3124 { ··· 3174 3175 default: 3176 // Field doesn't exist on this type, so ignore it 3177 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3178 } 3179 } 3180 ··· 3259 return fmt.Errorf("RichtextFacet_Link: map struct too large (%d)", extra) 3260 } 3261 3262 - var name string 3263 n := extra 3264 3265 for i := uint64(0); i < n; i++ { 3266 3267 - { 3268 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3269 - if err != nil { 3270 return err 3271 } 3272 - 3273 - name = string(sval) 3274 } 3275 3276 - switch name { 3277 // t.Uri (string) (string) 3278 case "uri": 3279 ··· 3299 3300 default: 3301 // Field doesn't exist on this type, so ignore it 3302 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3303 } 3304 } 3305 ··· 3384 return fmt.Errorf("RichtextFacet_Mention: map struct too large (%d)", extra) 3385 } 3386 3387 - var name string 3388 n := extra 3389 3390 for i := uint64(0); i < n; i++ { 3391 3392 - { 3393 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3394 - if err != nil { 3395 return err 3396 } 3397 - 3398 - name = string(sval) 3399 } 3400 3401 - switch name { 3402 // t.Did (string) (string) 3403 case "did": 3404 ··· 3424 3425 default: 3426 // Field doesn't exist on this type, so ignore it 3427 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3428 } 3429 } 3430 ··· 3509 return fmt.Errorf("RichtextFacet_Tag: map struct too large (%d)", extra) 3510 } 3511 3512 - var name string 3513 n := extra 3514 3515 for i := uint64(0); i < n; i++ { 3516 3517 - { 3518 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3519 - if err != nil { 3520 return err 3521 } 3522 - 3523 - name = string(sval) 3524 } 3525 3526 - switch name { 3527 // t.Tag (string) (string) 3528 case "tag": 3529 ··· 3549 3550 default: 3551 // Field doesn't exist on this type, so ignore it 3552 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3553 } 3554 } 3555 ··· 3643 return fmt.Errorf("EmbedRecordWithMedia: map struct too large (%d)", extra) 3644 } 3645 3646 - var name string 3647 n := extra 3648 3649 for i := uint64(0); i < n; i++ { 3650 3651 - { 3652 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3653 - if err != nil { 3654 return err 3655 } 3656 - 3657 - name = string(sval) 3658 } 3659 3660 - switch name { 3661 // t.LexiconTypeID (string) (string) 3662 case "$type": 3663 ··· 3712 3713 default: 3714 // Field doesn't exist on this type, so ignore it 3715 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3716 } 3717 } 3718 ··· 3813 return fmt.Errorf("FeedDefs_NotFoundPost: map struct too large (%d)", extra) 3814 } 3815 3816 - var name string 3817 n := extra 3818 3819 for i := uint64(0); i < n; i++ { 3820 3821 - { 3822 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3823 - if err != nil { 3824 return err 3825 } 3826 - 3827 - name = string(sval) 3828 } 3829 3830 - switch name { 3831 // t.Uri (string) (string) 3832 case "uri": 3833 ··· 3871 3872 default: 3873 // Field doesn't exist on this type, so ignore it 3874 - cbg.ScanForLinks(r, func(cid.Cid) {}) 3875 } 3876 } 3877 ··· 3979 return fmt.Errorf("GraphBlock: map struct too large (%d)", extra) 3980 } 3981 3982 - var name string 3983 n := extra 3984 3985 for i := uint64(0); i < n; i++ { 3986 3987 - { 3988 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3989 - if err != nil { 3990 return err 3991 } 3992 - 3993 - name = string(sval) 3994 } 3995 3996 - switch name { 3997 // t.LexiconTypeID (string) (string) 3998 case "$type": 3999 ··· 4030 4031 default: 4032 // Field doesn't exist on this type, so ignore it 4033 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4034 } 4035 } 4036 ··· 4283 return fmt.Errorf("GraphList: map struct too large (%d)", extra) 4284 } 4285 4286 - var name string 4287 n := extra 4288 4289 for i := uint64(0); i < n; i++ { 4290 4291 - { 4292 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4293 - if err != nil { 4294 return err 4295 } 4296 - 4297 - name = string(sval) 4298 } 4299 4300 - switch name { 4301 // t.Name (string) (string) 4302 case "name": 4303 ··· 4465 4466 default: 4467 // Field doesn't exist on this type, so ignore it 4468 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4469 } 4470 } 4471 ··· 4596 return fmt.Errorf("GraphListitem: map struct too large (%d)", extra) 4597 } 4598 4599 - var name string 4600 n := extra 4601 4602 for i := uint64(0); i < n; i++ { 4603 4604 - { 4605 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4606 - if err != nil { 4607 return err 4608 } 4609 - 4610 - name = string(sval) 4611 } 4612 4613 - switch name { 4614 // t.List (string) (string) 4615 case "list": 4616 ··· 4658 4659 default: 4660 // Field doesn't exist on this type, so ignore it 4661 - cbg.ScanForLinks(r, func(cid.Cid) {}) 4662 } 4663 } 4664 ··· 4934 return fmt.Errorf("FeedGenerator: map struct too large (%d)", extra) 4935 } 4936 4937 - var name string 4938 n := extra 4939 4940 for i := uint64(0); i < n; i++ { 4941 4942 - { 4943 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4944 - if err != nil { 4945 return err 4946 } 4947 - 4948 - name = string(sval) 4949 } 4950 4951 - switch name { 4952 // t.Did (string) (string) 4953 case "did": 4954 ··· 5139 5140 default: 5141 // Field doesn't exist on this type, so ignore it 5142 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5143 } 5144 } 5145 ··· 5247 return fmt.Errorf("GraphListblock: map struct too large (%d)", extra) 5248 } 5249 5250 - var name string 5251 n := extra 5252 5253 for i := uint64(0); i < n; i++ { 5254 5255 - { 5256 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5257 - if err != nil { 5258 return err 5259 } 5260 - 5261 - name = string(sval) 5262 } 5263 5264 - switch name { 5265 // t.LexiconTypeID (string) (string) 5266 case "$type": 5267 ··· 5298 5299 default: 5300 // Field doesn't exist on this type, so ignore it 5301 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5302 } 5303 } 5304 ··· 5386 return fmt.Errorf("EmbedDefs_AspectRatio: map struct too large (%d)", extra) 5387 } 5388 5389 - var name string 5390 n := extra 5391 5392 for i := uint64(0); i < n; i++ { 5393 5394 - { 5395 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5396 - if err != nil { 5397 return err 5398 } 5399 - 5400 - name = string(sval) 5401 } 5402 5403 - switch name { 5404 // t.Width (int64) (int64) 5405 case "width": 5406 { ··· 5456 5457 default: 5458 // Field doesn't exist on this type, so ignore it 5459 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5460 } 5461 } 5462 ··· 5638 return fmt.Errorf("FeedThreadgate: map struct too large (%d)", extra) 5639 } 5640 5641 - var name string 5642 n := extra 5643 5644 for i := uint64(0); i < n; i++ { 5645 5646 - { 5647 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5648 - if err != nil { 5649 return err 5650 } 5651 - 5652 - name = string(sval) 5653 } 5654 5655 - switch name { 5656 // t.Post (string) (string) 5657 case "post": 5658 ··· 5778 5779 default: 5780 // Field doesn't exist on this type, so ignore it 5781 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5782 } 5783 } 5784 ··· 5863 return fmt.Errorf("FeedThreadgate_ListRule: map struct too large (%d)", extra) 5864 } 5865 5866 - var name string 5867 n := extra 5868 5869 for i := uint64(0); i < n; i++ { 5870 5871 - { 5872 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5873 - if err != nil { 5874 return err 5875 } 5876 - 5877 - name = string(sval) 5878 } 5879 5880 - switch name { 5881 // t.List (string) (string) 5882 case "list": 5883 ··· 5903 5904 default: 5905 // Field doesn't exist on this type, so ignore it 5906 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5907 } 5908 } 5909 ··· 5965 return fmt.Errorf("FeedThreadgate_MentionRule: map struct too large (%d)", extra) 5966 } 5967 5968 - var name string 5969 n := extra 5970 5971 for i := uint64(0); i < n; i++ { 5972 5973 - { 5974 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 5975 - if err != nil { 5976 return err 5977 } 5978 - 5979 - name = string(sval) 5980 } 5981 5982 - switch name { 5983 // t.LexiconTypeID (string) (string) 5984 case "$type": 5985 ··· 5994 5995 default: 5996 // Field doesn't exist on this type, so ignore it 5997 - cbg.ScanForLinks(r, func(cid.Cid) {}) 5998 } 5999 } 6000 ··· 6056 return fmt.Errorf("FeedThreadgate_FollowingRule: map struct too large (%d)", extra) 6057 } 6058 6059 - var name string 6060 n := extra 6061 6062 for i := uint64(0); i < n; i++ { 6063 6064 - { 6065 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6066 - if err != nil { 6067 return err 6068 } 6069 - 6070 - name = string(sval) 6071 } 6072 6073 - switch name { 6074 // t.LexiconTypeID (string) (string) 6075 case "$type": 6076 ··· 6085 6086 default: 6087 // Field doesn't exist on this type, so ignore it 6088 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6089 } 6090 } 6091 ··· 6151 return fmt.Errorf("GraphStarterpack_FeedItem: map struct too large (%d)", extra) 6152 } 6153 6154 - var name string 6155 n := extra 6156 6157 for i := uint64(0); i < n; i++ { 6158 6159 - { 6160 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6161 - if err != nil { 6162 return err 6163 } 6164 - 6165 - name = string(sval) 6166 } 6167 6168 - switch name { 6169 // t.Uri (string) (string) 6170 case "uri": 6171 ··· 6180 6181 default: 6182 // Field doesn't exist on this type, so ignore it 6183 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6184 } 6185 } 6186 ··· 6414 return fmt.Errorf("GraphStarterpack: map struct too large (%d)", extra) 6415 } 6416 6417 - var name string 6418 n := extra 6419 6420 for i := uint64(0); i < n; i++ { 6421 6422 - { 6423 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6424 - if err != nil { 6425 return err 6426 } 6427 - 6428 - name = string(sval) 6429 } 6430 6431 - switch name { 6432 // t.List (string) (string) 6433 case "list": 6434 ··· 6595 6596 default: 6597 // Field doesn't exist on this type, so ignore it 6598 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6599 } 6600 } 6601 ··· 6720 return fmt.Errorf("LabelerService: map struct too large (%d)", extra) 6721 } 6722 6723 - var name string 6724 n := extra 6725 6726 for i := uint64(0); i < n; i++ { 6727 6728 - { 6729 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6730 - if err != nil { 6731 return err 6732 } 6733 - 6734 - name = string(sval) 6735 } 6736 6737 - switch name { 6738 // t.LexiconTypeID (string) (string) 6739 case "$type": 6740 ··· 6800 6801 default: 6802 // Field doesn't exist on this type, so ignore it 6803 - cbg.ScanForLinks(r, func(cid.Cid) {}) 6804 } 6805 } 6806 ··· 6916 return fmt.Errorf("LabelerDefs_LabelerPolicies: map struct too large (%d)", extra) 6917 } 6918 6919 - var name string 6920 n := extra 6921 6922 for i := uint64(0); i < n; i++ { 6923 6924 - { 6925 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6926 - if err != nil { 6927 return err 6928 } 6929 - 6930 - name = string(sval) 6931 } 6932 6933 - switch name { 6934 // t.LabelValues ([]*string) (slice) 6935 case "labelValues": 6936 ··· 7033 7034 default: 7035 // Field doesn't exist on this type, so ignore it 7036 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7037 } 7038 } 7039 ··· 7204 return fmt.Errorf("EmbedVideo: map struct too large (%d)", extra) 7205 } 7206 7207 - var name string 7208 n := extra 7209 7210 for i := uint64(0); i < n; i++ { 7211 7212 - { 7213 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7214 - if err != nil { 7215 return err 7216 } 7217 - 7218 - name = string(sval) 7219 } 7220 7221 - switch name { 7222 // t.Alt (string) (string) 7223 case "alt": 7224 ··· 7343 7344 default: 7345 // Field doesn't exist on this type, so ignore it 7346 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7347 } 7348 } 7349 ··· 7425 return fmt.Errorf("EmbedVideo_Caption: map struct too large (%d)", extra) 7426 } 7427 7428 - var name string 7429 n := extra 7430 7431 for i := uint64(0); i < n; i++ { 7432 7433 - { 7434 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7435 - if err != nil { 7436 return err 7437 } 7438 - 7439 - name = string(sval) 7440 } 7441 7442 - switch name { 7443 // t.File (util.LexBlob) (struct) 7444 case "file": 7445 ··· 7474 7475 default: 7476 // Field doesn't exist on this type, so ignore it 7477 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7478 } 7479 } 7480 ··· 7656 return fmt.Errorf("FeedPostgate: map struct too large (%d)", extra) 7657 } 7658 7659 - var name string 7660 n := extra 7661 7662 for i := uint64(0); i < n; i++ { 7663 7664 - { 7665 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7666 - if err != nil { 7667 return err 7668 } 7669 - 7670 - name = string(sval) 7671 } 7672 7673 - switch name { 7674 // t.Post (string) (string) 7675 case "post": 7676 ··· 7796 7797 default: 7798 // Field doesn't exist on this type, so ignore it 7799 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7800 } 7801 } 7802 ··· 7858 return fmt.Errorf("FeedPostgate_DisableRule: map struct too large (%d)", extra) 7859 } 7860 7861 - var name string 7862 n := extra 7863 7864 for i := uint64(0); i < n; i++ { 7865 7866 - { 7867 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7868 - if err != nil { 7869 return err 7870 } 7871 - 7872 - name = string(sval) 7873 } 7874 7875 - switch name { 7876 // t.LexiconTypeID (string) (string) 7877 case "$type": 7878 ··· 7887 7888 default: 7889 // Field doesn't exist on this type, so ignore it 7890 - cbg.ScanForLinks(r, func(cid.Cid) {}) 7891 } 7892 } 7893

··· 338 return fmt.Errorf("FeedPost: map struct too large (%d)", extra) 339 } 340 341 n := extra 342 343 + nameBuf := make([]byte, 9) 344 for i := uint64(0); i < n; i++ { 345 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 346 + if err != nil { 347 + return err 348 + } 349 350 + if !ok { 351 + // Field doesn't exist on this type, so ignore it 352 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 353 return err 354 } 355 + continue 356 } 357 358 + switch string(nameBuf[:nameLen]) { 359 // t.Tags ([]string) (slice) 360 case "tags": 361 ··· 630 631 default: 632 // Field doesn't exist on this type, so ignore it 633 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 634 + return err 635 + } 636 } 637 } 638 ··· 733 return fmt.Errorf("FeedRepost: map struct too large (%d)", extra) 734 } 735 736 n := extra 737 738 + nameBuf := make([]byte, 9) 739 for i := uint64(0); i < n; i++ { 740 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 741 + if err != nil { 742 + return err 743 + } 744 745 + if !ok { 746 + // Field doesn't exist on this type, so ignore it 747 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 748 return err 749 } 750 + continue 751 } 752 753 + switch string(nameBuf[:nameLen]) { 754 // t.LexiconTypeID (string) (string) 755 case "$type": 756 ··· 796 797 default: 798 // Field doesn't exist on this type, so ignore it 799 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 800 + return err 801 + } 802 } 803 } 804 ··· 903 return fmt.Errorf("FeedPost_Entity: map struct too large (%d)", extra) 904 } 905 906 n := extra 907 908 + nameBuf := make([]byte, 5) 909 for i := uint64(0); i < n; i++ { 910 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 911 + if err != nil { 912 + return err 913 + } 914 915 + if !ok { 916 + // Field doesn't exist on this type, so ignore it 917 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 918 return err 919 } 920 + continue 921 } 922 923 + switch string(nameBuf[:nameLen]) { 924 // t.Type (string) (string) 925 case "type": 926 ··· 966 967 default: 968 // Field doesn't exist on this type, so ignore it 969 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 970 + return err 971 + } 972 } 973 } 974 ··· 1043 return fmt.Errorf("FeedPost_ReplyRef: map struct too large (%d)", extra) 1044 } 1045 1046 n := extra 1047 1048 + nameBuf := make([]byte, 6) 1049 for i := uint64(0); i < n; i++ { 1050 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1051 + if err != nil { 1052 + return err 1053 + } 1054 1055 + if !ok { 1056 + // Field doesn't exist on this type, so ignore it 1057 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1058 return err 1059 } 1060 + continue 1061 } 1062 1063 + switch string(nameBuf[:nameLen]) { 1064 // t.Root (atproto.RepoStrongRef) (struct) 1065 case "root": 1066 ··· 1104 1105 default: 1106 // Field doesn't exist on this type, so ignore it 1107 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1108 + return err 1109 + } 1110 } 1111 } 1112 ··· 1194 return fmt.Errorf("FeedPost_TextSlice: map struct too large (%d)", extra) 1195 } 1196 1197 n := extra 1198 1199 + nameBuf := make([]byte, 5) 1200 for i := uint64(0); i < n; i++ { 1201 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1202 + if err != nil { 1203 + return err 1204 + } 1205 1206 + if !ok { 1207 + // Field doesn't exist on this type, so ignore it 1208 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1209 return err 1210 } 1211 + continue 1212 } 1213 1214 + switch string(nameBuf[:nameLen]) { 1215 // t.End (int64) (int64) 1216 case "end": 1217 { ··· 1267 1268 default: 1269 // Field doesn't exist on this type, so ignore it 1270 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1271 + return err 1272 + } 1273 } 1274 } 1275 ··· 1357 return fmt.Errorf("EmbedImages: map struct too large (%d)", extra) 1358 } 1359 1360 n := extra 1361 1362 + nameBuf := make([]byte, 6) 1363 for i := uint64(0); i < n; i++ { 1364 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1365 + if err != nil { 1366 + return err 1367 + } 1368 1369 + if !ok { 1370 + // Field doesn't exist on this type, so ignore it 1371 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1372 return err 1373 } 1374 + continue 1375 } 1376 1377 + switch string(nameBuf[:nameLen]) { 1378 // t.LexiconTypeID (string) (string) 1379 case "$type": 1380 ··· 1438 1439 default: 1440 // Field doesn't exist on this type, so ignore it 1441 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1442 + return err 1443 + } 1444 } 1445 } 1446 ··· 1518 return fmt.Errorf("EmbedExternal: map struct too large (%d)", extra) 1519 } 1520 1521 n := extra 1522 1523 + nameBuf := make([]byte, 8) 1524 for i := uint64(0); i < n; i++ { 1525 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1526 + if err != nil { 1527 + return err 1528 + } 1529 1530 + if !ok { 1531 + // Field doesn't exist on this type, so ignore it 1532 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1533 return err 1534 } 1535 + continue 1536 } 1537 1538 + switch string(nameBuf[:nameLen]) { 1539 // t.LexiconTypeID (string) (string) 1540 case "$type": 1541 ··· 1570 1571 default: 1572 // Field doesn't exist on this type, so ignore it 1573 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1574 + return err 1575 + } 1576 } 1577 } 1578 ··· 1708 return fmt.Errorf("EmbedExternal_External: map struct too large (%d)", extra) 1709 } 1710 1711 n := extra 1712 1713 + nameBuf := make([]byte, 11) 1714 for i := uint64(0); i < n; i++ { 1715 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1716 + if err != nil { 1717 + return err 1718 + } 1719 1720 + if !ok { 1721 + // Field doesn't exist on this type, so ignore it 1722 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1723 return err 1724 } 1725 + continue 1726 } 1727 1728 + switch string(nameBuf[:nameLen]) { 1729 // t.Uri (string) (string) 1730 case "uri": 1731 ··· 1782 1783 default: 1784 // Field doesn't exist on this type, so ignore it 1785 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1786 + return err 1787 + } 1788 } 1789 } 1790 ··· 1890 return fmt.Errorf("EmbedImages_Image: map struct too large (%d)", extra) 1891 } 1892 1893 n := extra 1894 1895 + nameBuf := make([]byte, 11) 1896 for i := uint64(0); i < n; i++ { 1897 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1898 + if err != nil { 1899 + return err 1900 + } 1901 1902 + if !ok { 1903 + // Field doesn't exist on this type, so ignore it 1904 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1905 return err 1906 } 1907 + continue 1908 } 1909 1910 + switch string(nameBuf[:nameLen]) { 1911 // t.Alt (string) (string) 1912 case "alt": 1913 ··· 1962 1963 default: 1964 // Field doesn't exist on this type, so ignore it 1965 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1966 + return err 1967 + } 1968 } 1969 } 1970 ··· 2072 return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) 2073 } 2074 2075 n := extra 2076 2077 + nameBuf := make([]byte, 9) 2078 for i := uint64(0); i < n; i++ { 2079 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2080 + if err != nil { 2081 + return err 2082 + } 2083 2084 + if !ok { 2085 + // Field doesn't exist on this type, so ignore it 2086 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2087 return err 2088 } 2089 + continue 2090 } 2091 2092 + switch string(nameBuf[:nameLen]) { 2093 // t.LexiconTypeID (string) (string) 2094 case "$type": 2095 ··· 2126 2127 default: 2128 // Field doesn't exist on this type, so ignore it 2129 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2130 + return err 2131 + } 2132 } 2133 } 2134 ··· 2414 return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 2415 } 2416 2417 n := extra 2418 2419 + nameBuf := make([]byte, 20) 2420 for i := uint64(0); i < n; i++ { 2421 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2422 + if err != nil { 2423 + return err 2424 + } 2425 2426 + if !ok { 2427 + // Field doesn't exist on this type, so ignore it 2428 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2429 return err 2430 } 2431 + continue 2432 } 2433 2434 + switch string(nameBuf[:nameLen]) { 2435 // t.LexiconTypeID (string) (string) 2436 case "$type": 2437 ··· 2609 2610 default: 2611 // Field doesn't exist on this type, so ignore it 2612 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2613 + return err 2614 + } 2615 } 2616 } 2617 ··· 2689 return fmt.Errorf("EmbedRecord: map struct too large (%d)", extra) 2690 } 2691 2692 n := extra 2693 2694 + nameBuf := make([]byte, 6) 2695 for i := uint64(0); i < n; i++ { 2696 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2697 + if err != nil { 2698 + return err 2699 + } 2700 2701 + if !ok { 2702 + // Field doesn't exist on this type, so ignore it 2703 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2704 return err 2705 } 2706 + continue 2707 } 2708 2709 + switch string(nameBuf[:nameLen]) { 2710 // t.LexiconTypeID (string) (string) 2711 case "$type": 2712 ··· 2741 2742 default: 2743 // Field doesn't exist on this type, so ignore it 2744 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2745 + return err 2746 + } 2747 } 2748 } 2749 ··· 2844 return fmt.Errorf("FeedLike: map struct too large (%d)", extra) 2845 } 2846 2847 n := extra 2848 2849 + nameBuf := make([]byte, 9) 2850 for i := uint64(0); i < n; i++ { 2851 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2852 + if err != nil { 2853 + return err 2854 + } 2855 2856 + if !ok { 2857 + // Field doesn't exist on this type, so ignore it 2858 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2859 return err 2860 } 2861 + continue 2862 } 2863 2864 + switch string(nameBuf[:nameLen]) { 2865 // t.LexiconTypeID (string) (string) 2866 case "$type": 2867 ··· 2907 2908 default: 2909 // Field doesn't exist on this type, so ignore it 2910 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2911 + return err 2912 + } 2913 } 2914 } 2915 ··· 2994 return fmt.Errorf("RichtextFacet: map struct too large (%d)", extra) 2995 } 2996 2997 n := extra 2998 2999 + nameBuf := make([]byte, 8) 3000 for i := uint64(0); i < n; i++ { 3001 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3002 + if err != nil { 3003 + return err 3004 + } 3005 3006 + if !ok { 3007 + // Field doesn't exist on this type, so ignore it 3008 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3009 return err 3010 } 3011 + continue 3012 } 3013 3014 + switch string(nameBuf[:nameLen]) { 3015 // t.Index (bsky.RichtextFacet_ByteSlice) (struct) 3016 case "index": 3017 ··· 3084 3085 default: 3086 // Field doesn't exist on this type, so ignore it 3087 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3088 + return err 3089 + } 3090 } 3091 } 3092 ··· 3174 return fmt.Errorf("RichtextFacet_ByteSlice: map struct too large (%d)", extra) 3175 } 3176 3177 n := extra 3178 3179 + nameBuf := make([]byte, 9) 3180 for i := uint64(0); i < n; i++ { 3181 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3182 + if err != nil { 3183 + return err 3184 + } 3185 3186 + if !ok { 3187 + // Field doesn't exist on this type, so ignore it 3188 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3189 return err 3190 } 3191 + continue 3192 } 3193 3194 + switch string(nameBuf[:nameLen]) { 3195 // t.ByteEnd (int64) (int64) 3196 case "byteEnd": 3197 { ··· 3247 3248 default: 3249 // Field doesn't exist on this type, so ignore it 3250 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3251 + return err 3252 + } 3253 } 3254 } 3255 ··· 3334 return fmt.Errorf("RichtextFacet_Link: map struct too large (%d)", extra) 3335 } 3336 3337 n := extra 3338 3339 + nameBuf := make([]byte, 5) 3340 for i := uint64(0); i < n; i++ { 3341 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3342 + if err != nil { 3343 + return err 3344 + } 3345 3346 + if !ok { 3347 + // Field doesn't exist on this type, so ignore it 3348 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3349 return err 3350 } 3351 + continue 3352 } 3353 3354 + switch string(nameBuf[:nameLen]) { 3355 // t.Uri (string) (string) 3356 case "uri": 3357 ··· 3377 3378 default: 3379 // Field doesn't exist on this type, so ignore it 3380 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3381 + return err 3382 + } 3383 } 3384 } 3385 ··· 3464 return fmt.Errorf("RichtextFacet_Mention: map struct too large (%d)", extra) 3465 } 3466 3467 n := extra 3468 3469 + nameBuf := make([]byte, 5) 3470 for i := uint64(0); i < n; i++ { 3471 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3472 + if err != nil { 3473 + return err 3474 + } 3475 3476 + if !ok { 3477 + // Field doesn't exist on this type, so ignore it 3478 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3479 return err 3480 } 3481 + continue 3482 } 3483 3484 + switch string(nameBuf[:nameLen]) { 3485 // t.Did (string) (string) 3486 case "did": 3487 ··· 3507 3508 default: 3509 // Field doesn't exist on this type, so ignore it 3510 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3511 + return err 3512 + } 3513 } 3514 } 3515 ··· 3594 return fmt.Errorf("RichtextFacet_Tag: map struct too large (%d)", extra) 3595 } 3596 3597 n := extra 3598 3599 + nameBuf := make([]byte, 5) 3600 for i := uint64(0); i < n; i++ { 3601 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3602 + if err != nil { 3603 + return err 3604 + } 3605 3606 + if !ok { 3607 + // Field doesn't exist on this type, so ignore it 3608 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3609 return err 3610 } 3611 + continue 3612 } 3613 3614 + switch string(nameBuf[:nameLen]) { 3615 // t.Tag (string) (string) 3616 case "tag": 3617 ··· 3637 3638 default: 3639 // Field doesn't exist on this type, so ignore it 3640 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3641 + return err 3642 + } 3643 } 3644 } 3645 ··· 3733 return fmt.Errorf("EmbedRecordWithMedia: map struct too large (%d)", extra) 3734 } 3735 3736 n := extra 3737 3738 + nameBuf := make([]byte, 6) 3739 for i := uint64(0); i < n; i++ { 3740 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3741 + if err != nil { 3742 + return err 3743 + } 3744 3745 + if !ok { 3746 + // Field doesn't exist on this type, so ignore it 3747 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3748 return err 3749 } 3750 + continue 3751 } 3752 3753 + switch string(nameBuf[:nameLen]) { 3754 // t.LexiconTypeID (string) (string) 3755 case "$type": 3756 ··· 3805 3806 default: 3807 // Field doesn't exist on this type, so ignore it 3808 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3809 + return err 3810 + } 3811 } 3812 } 3813 ··· 3908 return fmt.Errorf("FeedDefs_NotFoundPost: map struct too large (%d)", extra) 3909 } 3910 3911 n := extra 3912 3913 + nameBuf := make([]byte, 8) 3914 for i := uint64(0); i < n; i++ { 3915 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3916 + if err != nil { 3917 + return err 3918 + } 3919 3920 + if !ok { 3921 + // Field doesn't exist on this type, so ignore it 3922 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3923 return err 3924 } 3925 + continue 3926 } 3927 3928 + switch string(nameBuf[:nameLen]) { 3929 // t.Uri (string) (string) 3930 case "uri": 3931 ··· 3969 3970 default: 3971 // Field doesn't exist on this type, so ignore it 3972 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3973 + return err 3974 + } 3975 } 3976 } 3977 ··· 4079 return fmt.Errorf("GraphBlock: map struct too large (%d)", extra) 4080 } 4081 4082 n := extra 4083 4084 + nameBuf := make([]byte, 9) 4085 for i := uint64(0); i < n; i++ { 4086 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4087 + if err != nil { 4088 + return err 4089 + } 4090 4091 + if !ok { 4092 + // Field doesn't exist on this type, so ignore it 4093 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4094 return err 4095 } 4096 + continue 4097 } 4098 4099 + switch string(nameBuf[:nameLen]) { 4100 // t.LexiconTypeID (string) (string) 4101 case "$type": 4102 ··· 4133 4134 default: 4135 // Field doesn't exist on this type, so ignore it 4136 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4137 + return err 4138 + } 4139 } 4140 } 4141 ··· 4388 return fmt.Errorf("GraphList: map struct too large (%d)", extra) 4389 } 4390 4391 n := extra 4392 4393 + nameBuf := make([]byte, 17) 4394 for i := uint64(0); i < n; i++ { 4395 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4396 + if err != nil { 4397 + return err 4398 + } 4399 4400 + if !ok { 4401 + // Field doesn't exist on this type, so ignore it 4402 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4403 return err 4404 } 4405 + continue 4406 } 4407 4408 + switch string(nameBuf[:nameLen]) { 4409 // t.Name (string) (string) 4410 case "name": 4411 ··· 4573 4574 default: 4575 // Field doesn't exist on this type, so ignore it 4576 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4577 + return err 4578 + } 4579 } 4580 } 4581 ··· 4706 return fmt.Errorf("GraphListitem: map struct too large (%d)", extra) 4707 } 4708 4709 n := extra 4710 4711 + nameBuf := make([]byte, 9) 4712 for i := uint64(0); i < n; i++ { 4713 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4714 + if err != nil { 4715 + return err 4716 + } 4717 4718 + if !ok { 4719 + // Field doesn't exist on this type, so ignore it 4720 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4721 return err 4722 } 4723 + continue 4724 } 4725 4726 + switch string(nameBuf[:nameLen]) { 4727 // t.List (string) (string) 4728 case "list": 4729 ··· 4771 4772 default: 4773 // Field doesn't exist on this type, so ignore it 4774 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4775 + return err 4776 + } 4777 } 4778 } 4779 ··· 5049 return fmt.Errorf("FeedGenerator: map struct too large (%d)", extra) 5050 } 5051 5052 n := extra 5053 5054 + nameBuf := make([]byte, 19) 5055 for i := uint64(0); i < n; i++ { 5056 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5057 + if err != nil { 5058 + return err 5059 + } 5060 5061 + if !ok { 5062 + // Field doesn't exist on this type, so ignore it 5063 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5064 return err 5065 } 5066 + continue 5067 } 5068 5069 + switch string(nameBuf[:nameLen]) { 5070 // t.Did (string) (string) 5071 case "did": 5072 ··· 5257 5258 default: 5259 // Field doesn't exist on this type, so ignore it 5260 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5261 + return err 5262 + } 5263 } 5264 } 5265 ··· 5367 return fmt.Errorf("GraphListblock: map struct too large (%d)", extra) 5368 } 5369 5370 n := extra 5371 5372 + nameBuf := make([]byte, 9) 5373 for i := uint64(0); i < n; i++ { 5374 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5375 + if err != nil { 5376 + return err 5377 + } 5378 5379 + if !ok { 5380 + // Field doesn't exist on this type, so ignore it 5381 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5382 return err 5383 } 5384 + continue 5385 } 5386 5387 + switch string(nameBuf[:nameLen]) { 5388 // t.LexiconTypeID (string) (string) 5389 case "$type": 5390 ··· 5421 5422 default: 5423 // Field doesn't exist on this type, so ignore it 5424 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5425 + return err 5426 + } 5427 } 5428 } 5429 ··· 5511 return fmt.Errorf("EmbedDefs_AspectRatio: map struct too large (%d)", extra) 5512 } 5513 5514 n := extra 5515 5516 + nameBuf := make([]byte, 6) 5517 for i := uint64(0); i < n; i++ { 5518 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5519 + if err != nil { 5520 + return err 5521 + } 5522 5523 + if !ok { 5524 + // Field doesn't exist on this type, so ignore it 5525 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5526 return err 5527 } 5528 + continue 5529 } 5530 5531 + switch string(nameBuf[:nameLen]) { 5532 // t.Width (int64) (int64) 5533 case "width": 5534 { ··· 5584 5585 default: 5586 // Field doesn't exist on this type, so ignore it 5587 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5588 + return err 5589 + } 5590 } 5591 } 5592 ··· 5768 return fmt.Errorf("FeedThreadgate: map struct too large (%d)", extra) 5769 } 5770 5771 n := extra 5772 5773 + nameBuf := make([]byte, 13) 5774 for i := uint64(0); i < n; i++ { 5775 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 5776 + if err != nil { 5777 + return err 5778 + } 5779 5780 + if !ok { 5781 + // Field doesn't exist on this type, so ignore it 5782 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 5783 return err 5784 } 5785 + continue 5786 } 5787 5788 + switch string(nameBuf[:nameLen]) { 5789 // t.Post (string) (string) 5790 case "post": 5791 ··· 5911 5912 default: 5913 // Field doesn't exist on this type, so ignore it 5914 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 5915 + return err 5916 + } 5917 } 5918 } 5919 ··· 5998 return fmt.Errorf("FeedThreadgate_ListRule: map struct too large (%d)", extra) 5999 } 6000 6001 n := extra 6002 6003 + nameBuf := make([]byte, 5) 6004 for i := uint64(0); i < n; i++ { 6005 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6006 + if err != nil { 6007 + return err 6008 + } 6009 6010 + if !ok { 6011 + // Field doesn't exist on this type, so ignore it 6012 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6013 return err 6014 } 6015 + continue 6016 } 6017 6018 + switch string(nameBuf[:nameLen]) { 6019 // t.List (string) (string) 6020 case "list": 6021 ··· 6041 6042 default: 6043 // Field doesn't exist on this type, so ignore it 6044 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6045 + return err 6046 + } 6047 } 6048 } 6049 ··· 6105 return fmt.Errorf("FeedThreadgate_MentionRule: map struct too large (%d)", extra) 6106 } 6107 6108 n := extra 6109 6110 + nameBuf := make([]byte, 5) 6111 for i := uint64(0); i < n; i++ { 6112 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6113 + if err != nil { 6114 + return err 6115 + } 6116 6117 + if !ok { 6118 + // Field doesn't exist on this type, so ignore it 6119 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6120 return err 6121 } 6122 + continue 6123 } 6124 6125 + switch string(nameBuf[:nameLen]) { 6126 // t.LexiconTypeID (string) (string) 6127 case "$type": 6128 ··· 6137 6138 default: 6139 // Field doesn't exist on this type, so ignore it 6140 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6141 + return err 6142 + } 6143 } 6144 } 6145 ··· 6201 return fmt.Errorf("FeedThreadgate_FollowingRule: map struct too large (%d)", extra) 6202 } 6203 6204 n := extra 6205 6206 + nameBuf := make([]byte, 5) 6207 for i := uint64(0); i < n; i++ { 6208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6209 + if err != nil { 6210 + return err 6211 + } 6212 6213 + if !ok { 6214 + // Field doesn't exist on this type, so ignore it 6215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6216 return err 6217 } 6218 + continue 6219 } 6220 6221 + switch string(nameBuf[:nameLen]) { 6222 // t.LexiconTypeID (string) (string) 6223 case "$type": 6224 ··· 6233 6234 default: 6235 // Field doesn't exist on this type, so ignore it 6236 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6237 + return err 6238 + } 6239 } 6240 } 6241 ··· 6301 return fmt.Errorf("GraphStarterpack_FeedItem: map struct too large (%d)", extra) 6302 } 6303 6304 n := extra 6305 6306 + nameBuf := make([]byte, 3) 6307 for i := uint64(0); i < n; i++ { 6308 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6309 + if err != nil { 6310 + return err 6311 + } 6312 6313 + if !ok { 6314 + // Field doesn't exist on this type, so ignore it 6315 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6316 return err 6317 } 6318 + continue 6319 } 6320 6321 + switch string(nameBuf[:nameLen]) { 6322 // t.Uri (string) (string) 6323 case "uri": 6324 ··· 6333 6334 default: 6335 // Field doesn't exist on this type, so ignore it 6336 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6337 + return err 6338 + } 6339 } 6340 } 6341 ··· 6569 return fmt.Errorf("GraphStarterpack: map struct too large (%d)", extra) 6570 } 6571 6572 n := extra 6573 6574 + nameBuf := make([]byte, 17) 6575 for i := uint64(0); i < n; i++ { 6576 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6577 + if err != nil { 6578 + return err 6579 + } 6580 6581 + if !ok { 6582 + // Field doesn't exist on this type, so ignore it 6583 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6584 return err 6585 } 6586 + continue 6587 } 6588 6589 + switch string(nameBuf[:nameLen]) { 6590 // t.List (string) (string) 6591 case "list": 6592 ··· 6753 6754 default: 6755 // Field doesn't exist on this type, so ignore it 6756 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6757 + return err 6758 + } 6759 } 6760 } 6761 ··· 6880 return fmt.Errorf("LabelerService: map struct too large (%d)", extra) 6881 } 6882 6883 n := extra 6884 6885 + nameBuf := make([]byte, 9) 6886 for i := uint64(0); i < n; i++ { 6887 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6888 + if err != nil { 6889 + return err 6890 + } 6891 6892 + if !ok { 6893 + // Field doesn't exist on this type, so ignore it 6894 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6895 return err 6896 } 6897 + continue 6898 } 6899 6900 + switch string(nameBuf[:nameLen]) { 6901 // t.LexiconTypeID (string) (string) 6902 case "$type": 6903 ··· 6963 6964 default: 6965 // Field doesn't exist on this type, so ignore it 6966 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6967 + return err 6968 + } 6969 } 6970 } 6971 ··· 7081 return fmt.Errorf("LabelerDefs_LabelerPolicies: map struct too large (%d)", extra) 7082 } 7083 7084 n := extra 7085 7086 + nameBuf := make([]byte, 21) 7087 for i := uint64(0); i < n; i++ { 7088 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7089 + if err != nil { 7090 + return err 7091 + } 7092 7093 + if !ok { 7094 + // Field doesn't exist on this type, so ignore it 7095 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7096 return err 7097 } 7098 + continue 7099 } 7100 7101 + switch string(nameBuf[:nameLen]) { 7102 // t.LabelValues ([]*string) (slice) 7103 case "labelValues": 7104 ··· 7201 7202 default: 7203 // Field doesn't exist on this type, so ignore it 7204 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7205 + return err 7206 + } 7207 } 7208 } 7209 ··· 7374 return fmt.Errorf("EmbedVideo: map struct too large (%d)", extra) 7375 } 7376 7377 n := extra 7378 7379 + nameBuf := make([]byte, 11) 7380 for i := uint64(0); i < n; i++ { 7381 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7382 + if err != nil { 7383 + return err 7384 + } 7385 7386 + if !ok { 7387 + // Field doesn't exist on this type, so ignore it 7388 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7389 return err 7390 } 7391 + continue 7392 } 7393 7394 + switch string(nameBuf[:nameLen]) { 7395 // t.Alt (string) (string) 7396 case "alt": 7397 ··· 7516 7517 default: 7518 // Field doesn't exist on this type, so ignore it 7519 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7520 + return err 7521 + } 7522 } 7523 } 7524 ··· 7600 return fmt.Errorf("EmbedVideo_Caption: map struct too large (%d)", extra) 7601 } 7602 7603 n := extra 7604 7605 + nameBuf := make([]byte, 4) 7606 for i := uint64(0); i < n; i++ { 7607 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7608 + if err != nil { 7609 + return err 7610 + } 7611 7612 + if !ok { 7613 + // Field doesn't exist on this type, so ignore it 7614 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7615 return err 7616 } 7617 + continue 7618 } 7619 7620 + switch string(nameBuf[:nameLen]) { 7621 // t.File (util.LexBlob) (struct) 7622 case "file": 7623 ··· 7652 7653 default: 7654 // Field doesn't exist on this type, so ignore it 7655 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7656 + return err 7657 + } 7658 } 7659 } 7660 ··· 7836 return fmt.Errorf("FeedPostgate: map struct too large (%d)", extra) 7837 } 7838 7839 n := extra 7840 7841 + nameBuf := make([]byte, 21) 7842 for i := uint64(0); i < n; i++ { 7843 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7844 + if err != nil { 7845 + return err 7846 + } 7847 7848 + if !ok { 7849 + // Field doesn't exist on this type, so ignore it 7850 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 7851 return err 7852 } 7853 + continue 7854 } 7855 7856 + switch string(nameBuf[:nameLen]) { 7857 // t.Post (string) (string) 7858 case "post": 7859 ··· 7979 7980 default: 7981 // Field doesn't exist on this type, so ignore it 7982 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 7983 + return err 7984 + } 7985 } 7986 } 7987 ··· 8043 return fmt.Errorf("FeedPostgate_DisableRule: map struct too large (%d)", extra) 8044 } 8045 8046 n := extra 8047 8048 + nameBuf := make([]byte, 5) 8049 for i := uint64(0); i < n; i++ { 8050 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 8051 + if err != nil { 8052 + return err 8053 + } 8054 8055 + if !ok { 8056 + // Field doesn't exist on this type, so ignore it 8057 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 8058 return err 8059 } 8060 + continue 8061 } 8062 8063 + switch string(nameBuf[:nameLen]) { 8064 // t.LexiconTypeID (string) (string) 8065 case "$type": 8066 ··· 8075 8076 default: 8077 // Field doesn't exist on this type, so ignore it 8078 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 8079 + return err 8080 + } 8081 } 8082 } 8083

+13 -8

api/cbor_gen.go

··· 230 return fmt.Errorf("CreateOp: map struct too large (%d)", extra) 231 } 232 233 - var name string 234 n := extra 235 236 for i := uint64(0); i < n; i++ { 237 238 - { 239 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 240 - if err != nil { 241 return err 242 } 243 - 244 - name = string(sval) 245 } 246 247 - switch name { 248 // t.Sig (string) (string) 249 case "sig": 250 ··· 335 336 default: 337 // Field doesn't exist on this type, so ignore it 338 - cbg.ScanForLinks(r, func(cid.Cid) {}) 339 } 340 } 341

··· 230 return fmt.Errorf("CreateOp: map struct too large (%d)", extra) 231 } 232 233 n := extra 234 235 + nameBuf := make([]byte, 11) 236 for i := uint64(0); i < n; i++ { 237 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 238 + if err != nil { 239 + return err 240 + } 241 242 + if !ok { 243 + // Field doesn't exist on this type, so ignore it 244 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 245 return err 246 } 247 + continue 248 } 249 250 + switch string(nameBuf[:nameLen]) { 251 // t.Sig (string) (string) 252 case "sig": 253 ··· 338 339 default: 340 // Field doesn't exist on this type, so ignore it 341 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 342 + return err 343 + } 344 } 345 } 346

+13 -8

api/chat/cbor_gen.go

··· 97 return fmt.Errorf("ActorDeclaration: map struct too large (%d)", extra) 98 } 99 100 - var name string 101 n := extra 102 103 for i := uint64(0); i < n; i++ { 104 105 - { 106 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 107 - if err != nil { 108 return err 109 } 110 - 111 - name = string(sval) 112 } 113 114 - switch name { 115 // t.LexiconTypeID (string) (string) 116 case "$type": 117 ··· 137 138 default: 139 // Field doesn't exist on this type, so ignore it 140 - cbg.ScanForLinks(r, func(cid.Cid) {}) 141 } 142 } 143

··· 97 return fmt.Errorf("ActorDeclaration: map struct too large (%d)", extra) 98 } 99 100 n := extra 101 102 + nameBuf := make([]byte, 13) 103 for i := uint64(0); i < n; i++ { 104 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 105 + if err != nil { 106 + return err 107 + } 108 109 + if !ok { 110 + // Field doesn't exist on this type, so ignore it 111 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 112 return err 113 } 114 + continue 115 } 116 117 + switch string(nameBuf[:nameLen]) { 118 // t.LexiconTypeID (string) (string) 119 case "$type": 120 ··· 140 141 default: 142 // Field doesn't exist on this type, so ignore it 143 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 144 + return err 145 + } 146 } 147 } 148

+39 -24

atproto/data/cbor_gen.go

··· 78 return fmt.Errorf("GenericRecord: map struct too large (%d)", extra) 79 } 80 81 - var name string 82 n := extra 83 84 for i := uint64(0); i < n; i++ { 85 86 - { 87 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 88 - if err != nil { 89 return err 90 } 91 - 92 - name = string(sval) 93 } 94 95 - switch name { 96 // t.Type (string) (string) 97 case "$type": 98 ··· 107 108 default: 109 // Field doesn't exist on this type, so ignore it 110 - cbg.ScanForLinks(r, func(cid.Cid) {}) 111 } 112 } 113 ··· 196 return fmt.Errorf("LegacyBlobSchema: map struct too large (%d)", extra) 197 } 198 199 - var name string 200 n := extra 201 202 for i := uint64(0); i < n; i++ { 203 204 - { 205 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 206 - if err != nil { 207 return err 208 } 209 - 210 - name = string(sval) 211 } 212 213 - switch name { 214 // t.Cid (string) (string) 215 case "cid": 216 ··· 236 237 default: 238 // Field doesn't exist on this type, so ignore it 239 - cbg.ScanForLinks(r, func(cid.Cid) {}) 240 } 241 } 242 ··· 359 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 360 } 361 362 - var name string 363 n := extra 364 365 for i := uint64(0); i < n; i++ { 366 367 - { 368 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 369 - if err != nil { 370 return err 371 } 372 - 373 - name = string(sval) 374 } 375 376 - switch name { 377 // t.Ref (data.CIDLink) (struct) 378 case "ref": 379 ··· 435 436 default: 437 // Field doesn't exist on this type, so ignore it 438 - cbg.ScanForLinks(r, func(cid.Cid) {}) 439 } 440 } 441

··· 78 return fmt.Errorf("GenericRecord: map struct too large (%d)", extra) 79 } 80 81 n := extra 82 83 + nameBuf := make([]byte, 5) 84 for i := uint64(0); i < n; i++ { 85 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 86 + if err != nil { 87 + return err 88 + } 89 90 + if !ok { 91 + // Field doesn't exist on this type, so ignore it 92 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 93 return err 94 } 95 + continue 96 } 97 98 + switch string(nameBuf[:nameLen]) { 99 // t.Type (string) (string) 100 case "$type": 101 ··· 110 111 default: 112 // Field doesn't exist on this type, so ignore it 113 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 114 + return err 115 + } 116 } 117 } 118 ··· 201 return fmt.Errorf("LegacyBlobSchema: map struct too large (%d)", extra) 202 } 203 204 n := extra 205 206 + nameBuf := make([]byte, 8) 207 for i := uint64(0); i < n; i++ { 208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 209 + if err != nil { 210 + return err 211 + } 212 213 + if !ok { 214 + // Field doesn't exist on this type, so ignore it 215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 216 return err 217 } 218 + continue 219 } 220 221 + switch string(nameBuf[:nameLen]) { 222 // t.Cid (string) (string) 223 case "cid": 224 ··· 244 245 default: 246 // Field doesn't exist on this type, so ignore it 247 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 248 + return err 249 + } 250 } 251 } 252 ··· 369 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 370 } 371 372 n := extra 373 374 + nameBuf := make([]byte, 8) 375 for i := uint64(0); i < n; i++ { 376 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 377 + if err != nil { 378 + return err 379 + } 380 381 + if !ok { 382 + // Field doesn't exist on this type, so ignore it 383 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 384 return err 385 } 386 + continue 387 } 388 389 + switch string(nameBuf[:nameLen]) { 390 // t.Ref (data.CIDLink) (struct) 391 case "ref": 392 ··· 448 449 default: 450 // Field doesn't exist on this type, so ignore it 451 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 452 + return err 453 + } 454 } 455 } 456

+26 -16

events/cbor_gen.go

··· 101 return fmt.Errorf("EventHeader: map struct too large (%d)", extra) 102 } 103 104 - var name string 105 n := extra 106 107 for i := uint64(0); i < n; i++ { 108 109 - { 110 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 111 - if err != nil { 112 return err 113 } 114 - 115 - name = string(sval) 116 } 117 118 - switch name { 119 // t.MsgType (string) (string) 120 case "t": 121 ··· 156 157 default: 158 // Field doesn't exist on this type, so ignore it 159 - cbg.ScanForLinks(r, func(cid.Cid) {}) 160 } 161 } 162 ··· 245 return fmt.Errorf("ErrorFrame: map struct too large (%d)", extra) 246 } 247 248 - var name string 249 n := extra 250 251 for i := uint64(0); i < n; i++ { 252 253 - { 254 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 255 - if err != nil { 256 return err 257 } 258 - 259 - name = string(sval) 260 } 261 262 - switch name { 263 // t.Error (string) (string) 264 case "error": 265 ··· 285 286 default: 287 // Field doesn't exist on this type, so ignore it 288 - cbg.ScanForLinks(r, func(cid.Cid) {}) 289 } 290 } 291

··· 101 return fmt.Errorf("EventHeader: map struct too large (%d)", extra) 102 } 103 104 n := extra 105 106 + nameBuf := make([]byte, 2) 107 for i := uint64(0); i < n; i++ { 108 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 109 + if err != nil { 110 + return err 111 + } 112 113 + if !ok { 114 + // Field doesn't exist on this type, so ignore it 115 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 116 return err 117 } 118 + continue 119 } 120 121 + switch string(nameBuf[:nameLen]) { 122 // t.MsgType (string) (string) 123 case "t": 124 ··· 159 160 default: 161 // Field doesn't exist on this type, so ignore it 162 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 163 + return err 164 + } 165 } 166 } 167 ··· 250 return fmt.Errorf("ErrorFrame: map struct too large (%d)", extra) 251 } 252 253 n := extra 254 255 + nameBuf := make([]byte, 7) 256 for i := uint64(0); i < n; i++ { 257 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 258 + if err != nil { 259 + return err 260 + } 261 262 + if !ok { 263 + // Field doesn't exist on this type, so ignore it 264 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 265 return err 266 } 267 + continue 268 } 269 270 + switch string(nameBuf[:nameLen]) { 271 // t.Error (string) (string) 272 case "error": 273 ··· 293 294 default: 295 // Field doesn't exist on this type, so ignore it 296 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 297 + return err 298 + } 299 } 300 } 301

+5 -1

go.mod

··· 14 github.com/flosch/pongo2/v6 v6.0.0 15 github.com/go-redis/cache/v9 v9.0.0 16 github.com/goccy/go-json v0.10.2 17 github.com/golang-jwt/jwt v3.2.2+incompatible 18 github.com/gorilla/websocket v1.5.1 19 github.com/hashicorp/go-retryablehttp v0.7.5 ··· 53 github.com/samber/slog-echo v1.8.0 54 github.com/stretchr/testify v1.9.0 55 github.com/urfave/cli/v2 v2.25.7 56 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c 57 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 58 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b 59 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1 ··· 79 require ( 80 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect 81 github.com/go-redis/redis v6.15.9+incompatible // indirect 82 github.com/hashicorp/golang-lru v1.0.2 // indirect 83 github.com/jackc/puddle/v2 v2.2.1 // indirect 84 github.com/klauspost/compress v1.17.3 // indirect ··· 91 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 // indirect 92 go.uber.org/zap v1.26.0 // indirect 93 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect 94 ) 95 96 require (

··· 14 github.com/flosch/pongo2/v6 v6.0.0 15 github.com/go-redis/cache/v9 v9.0.0 16 github.com/goccy/go-json v0.10.2 17 + github.com/gocql/gocql v1.7.0 18 github.com/golang-jwt/jwt v3.2.2+incompatible 19 github.com/gorilla/websocket v1.5.1 20 github.com/hashicorp/go-retryablehttp v0.7.5 ··· 54 github.com/samber/slog-echo v1.8.0 55 github.com/stretchr/testify v1.9.0 56 github.com/urfave/cli/v2 v2.25.7 57 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e 58 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 59 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b 60 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1 ··· 80 require ( 81 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect 82 github.com/go-redis/redis v6.15.9+incompatible // indirect 83 + github.com/golang/snappy v0.0.3 // indirect 84 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect 85 github.com/hashicorp/golang-lru v1.0.2 // indirect 86 github.com/jackc/puddle/v2 v2.2.1 // indirect 87 github.com/klauspost/compress v1.17.3 // indirect ··· 94 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 // indirect 95 go.uber.org/zap v1.26.0 // indirect 96 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect 97 + gopkg.in/inf.v0 v0.9.1 // indirect 98 ) 99 100 require (

+14 -2

go.sum

··· 71 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= 72 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= 73 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= 74 github.com/brianvoe/gofakeit/v6 v6.25.0 h1:ZpFjktOpLZUeF8q223o0rUuXtA+m5qW5srjvVi+JkXk= 75 github.com/brianvoe/gofakeit/v6 v6.25.0/go.mod h1:Xj58BMSnFqcn/fAQeSK+/PLtC5kSb7FJIq4JyGa8vEs= 76 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= ··· 152 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0= 153 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= 154 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= 155 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= 156 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= 157 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= ··· 189 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 190 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= 191 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 192 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 193 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 194 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= ··· 231 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= 232 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 h1:6UKoz5ujsI55KNpsJH3UwCq3T8kKbZwNZBNPuTTje8U= 233 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1/go.mod h1:YvJ2f6MplWDhfxiUC3KpyTy76kYUZA4W3pTv/wdKQ9Y= 234 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= 235 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= 236 github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI= ··· 616 github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= 617 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 h1:5HZfQkwe0mIfyDmc1Em5GqlNRzcdtlv4HTNmdpt7XH0= 618 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11/go.mod h1:Wlo/SzPmxVp6vXpGt/zaXhHH0fn4IxgqZc82aKg6bpQ= 619 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c h1:UsxJNcLPfyLyVaA4iusIrsLAqJn/xh36Qgb8emqtXzk= 620 - github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so= 621 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E= 622 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8= 623 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 h1:yJ9/LwIGIk/c0CdoavpC9RNSGSruIspSZtxG3Nnldic= ··· 1061 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= 1062 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= 1063 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= 1064 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= 1065 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= 1066 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

··· 71 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= 72 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= 73 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= 74 + github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY= 75 + github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k= 76 + github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY= 77 + github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4= 78 github.com/brianvoe/gofakeit/v6 v6.25.0 h1:ZpFjktOpLZUeF8q223o0rUuXtA+m5qW5srjvVi+JkXk= 79 github.com/brianvoe/gofakeit/v6 v6.25.0/go.mod h1:Xj58BMSnFqcn/fAQeSK+/PLtC5kSb7FJIq4JyGa8vEs= 80 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= ··· 156 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0= 157 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= 158 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= 159 + github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus= 160 + github.com/gocql/gocql v1.7.0/go.mod h1:vnlvXyFZeLBF0Wy+RS8hrOdbn0UWsWtdg07XJnFxZ+4= 161 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= 162 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= 163 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= ··· 195 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 196 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= 197 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= 198 + github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA= 199 + github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= 200 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 201 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= 202 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= ··· 239 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= 240 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 h1:6UKoz5ujsI55KNpsJH3UwCq3T8kKbZwNZBNPuTTje8U= 241 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1/go.mod h1:YvJ2f6MplWDhfxiUC3KpyTy76kYUZA4W3pTv/wdKQ9Y= 242 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8= 243 + github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4= 244 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= 245 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= 246 github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI= ··· 626 github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= 627 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 h1:5HZfQkwe0mIfyDmc1Em5GqlNRzcdtlv4HTNmdpt7XH0= 628 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11/go.mod h1:Wlo/SzPmxVp6vXpGt/zaXhHH0fn4IxgqZc82aKg6bpQ= 629 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4= 630 + github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so= 631 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E= 632 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8= 633 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 h1:yJ9/LwIGIk/c0CdoavpC9RNSGSruIspSZtxG3Nnldic= ··· 1071 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= 1072 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= 1073 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= 1074 + gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc= 1075 + gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= 1076 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= 1077 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= 1078 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

+39 -24

lex/util/cbor_gen.go

··· 78 return fmt.Errorf("CborChecker: map struct too large (%d)", extra) 79 } 80 81 - var name string 82 n := extra 83 84 for i := uint64(0); i < n; i++ { 85 86 - { 87 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 88 - if err != nil { 89 return err 90 } 91 - 92 - name = string(sval) 93 } 94 95 - switch name { 96 // t.Type (string) (string) 97 case "$type": 98 ··· 107 108 default: 109 // Field doesn't exist on this type, so ignore it 110 - cbg.ScanForLinks(r, func(cid.Cid) {}) 111 } 112 } 113 ··· 196 return fmt.Errorf("LegacyBlob: map struct too large (%d)", extra) 197 } 198 199 - var name string 200 n := extra 201 202 for i := uint64(0); i < n; i++ { 203 204 - { 205 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 206 - if err != nil { 207 return err 208 } 209 - 210 - name = string(sval) 211 } 212 213 - switch name { 214 // t.Cid (string) (string) 215 case "cid": 216 ··· 236 237 default: 238 // Field doesn't exist on this type, so ignore it 239 - cbg.ScanForLinks(r, func(cid.Cid) {}) 240 } 241 } 242 ··· 359 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 360 } 361 362 - var name string 363 n := extra 364 365 for i := uint64(0); i < n; i++ { 366 367 - { 368 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 369 - if err != nil { 370 return err 371 } 372 - 373 - name = string(sval) 374 } 375 376 - switch name { 377 // t.Ref (util.LexLink) (struct) 378 case "ref": 379 ··· 435 436 default: 437 // Field doesn't exist on this type, so ignore it 438 - cbg.ScanForLinks(r, func(cid.Cid) {}) 439 } 440 } 441

··· 78 return fmt.Errorf("CborChecker: map struct too large (%d)", extra) 79 } 80 81 n := extra 82 83 + nameBuf := make([]byte, 5) 84 for i := uint64(0); i < n; i++ { 85 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 86 + if err != nil { 87 + return err 88 + } 89 90 + if !ok { 91 + // Field doesn't exist on this type, so ignore it 92 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 93 return err 94 } 95 + continue 96 } 97 98 + switch string(nameBuf[:nameLen]) { 99 // t.Type (string) (string) 100 case "$type": 101 ··· 110 111 default: 112 // Field doesn't exist on this type, so ignore it 113 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 114 + return err 115 + } 116 } 117 } 118 ··· 201 return fmt.Errorf("LegacyBlob: map struct too large (%d)", extra) 202 } 203 204 n := extra 205 206 + nameBuf := make([]byte, 8) 207 for i := uint64(0); i < n; i++ { 208 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 209 + if err != nil { 210 + return err 211 + } 212 213 + if !ok { 214 + // Field doesn't exist on this type, so ignore it 215 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 216 return err 217 } 218 + continue 219 } 220 221 + switch string(nameBuf[:nameLen]) { 222 // t.Cid (string) (string) 223 case "cid": 224 ··· 244 245 default: 246 // Field doesn't exist on this type, so ignore it 247 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 248 + return err 249 + } 250 } 251 } 252 ··· 369 return fmt.Errorf("BlobSchema: map struct too large (%d)", extra) 370 } 371 372 n := extra 373 374 + nameBuf := make([]byte, 8) 375 for i := uint64(0); i < n; i++ { 376 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 377 + if err != nil { 378 + return err 379 + } 380 381 + if !ok { 382 + // Field doesn't exist on this type, so ignore it 383 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 384 return err 385 } 386 + continue 387 } 388 389 + switch string(nameBuf[:nameLen]) { 390 // t.Ref (util.LexLink) (struct) 391 case "ref": 392 ··· 448 449 default: 450 // Field doesn't exist on this type, so ignore it 451 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 452 + return err 453 + } 454 } 455 } 456

+78 -48

lex/util/cbor_gen_test.go

··· 254 return fmt.Errorf("basicSchema: map struct too large (%d)", extra) 255 } 256 257 - var name string 258 n := extra 259 260 for i := uint64(0); i < n; i++ { 261 262 - { 263 - sval, err := cbg.ReadStringWithMax(cr, 8192) 264 - if err != nil { 265 return err 266 } 267 - 268 - name = string(sval) 269 } 270 271 - switch name { 272 // t.Bool (bool) (bool) 273 case "bool": 274 ··· 430 431 default: 432 // Field doesn't exist on this type, so ignore it 433 - cbg.ScanForLinks(r, func(cid.Cid) {}) 434 } 435 } 436 ··· 567 return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra) 568 } 569 570 - var name string 571 n := extra 572 573 for i := uint64(0); i < n; i++ { 574 575 - { 576 - sval, err := cbg.ReadStringWithMax(cr, 8192) 577 - if err != nil { 578 return err 579 } 580 - 581 - name = string(sval) 582 } 583 584 - switch name { 585 // t.Arr ([]string) (slice) 586 case "arr": 587 ··· 680 681 default: 682 // Field doesn't exist on this type, so ignore it 683 - cbg.ScanForLinks(r, func(cid.Cid) {}) 684 } 685 } 686 ··· 779 return fmt.Errorf("ipldSchema: map struct too large (%d)", extra) 780 } 781 782 - var name string 783 n := extra 784 785 for i := uint64(0); i < n; i++ { 786 787 - { 788 - sval, err := cbg.ReadStringWithMax(cr, 8192) 789 - if err != nil { 790 return err 791 } 792 - 793 - name = string(sval) 794 } 795 796 - switch name { 797 // t.A (util.LexLink) (struct) 798 case "a": 799 ··· 840 841 default: 842 // Field doesn't exist on this type, so ignore it 843 - cbg.ScanForLinks(r, func(cid.Cid) {}) 844 } 845 } 846 ··· 1059 return fmt.Errorf("basicOldSchema: map struct too large (%d)", extra) 1060 } 1061 1062 - var name string 1063 n := extra 1064 1065 for i := uint64(0); i < n; i++ { 1066 1067 - { 1068 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1069 - if err != nil { 1070 return err 1071 } 1072 - 1073 - name = string(sval) 1074 } 1075 1076 - switch name { 1077 // t.A (string) (string) 1078 case "a": 1079 ··· 1224 1225 default: 1226 // Field doesn't exist on this type, so ignore it 1227 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1228 } 1229 } 1230 ··· 1361 return fmt.Errorf("basicOldSchemaInner: map struct too large (%d)", extra) 1362 } 1363 1364 - var name string 1365 n := extra 1366 1367 for i := uint64(0); i < n; i++ { 1368 1369 - { 1370 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1371 - if err != nil { 1372 return err 1373 } 1374 - 1375 - name = string(sval) 1376 } 1377 1378 - switch name { 1379 // t.H (string) (string) 1380 case "h": 1381 ··· 1474 1475 default: 1476 // Field doesn't exist on this type, so ignore it 1477 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1478 } 1479 } 1480 ··· 1558 return fmt.Errorf("ipldOldSchema: map struct too large (%d)", extra) 1559 } 1560 1561 - var name string 1562 n := extra 1563 1564 for i := uint64(0); i < n; i++ { 1565 1566 - { 1567 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1568 - if err != nil { 1569 return err 1570 } 1571 - 1572 - name = string(sval) 1573 } 1574 1575 - switch name { 1576 // t.A (util.LexLink) (struct) 1577 case "a": 1578 ··· 1608 1609 default: 1610 // Field doesn't exist on this type, so ignore it 1611 - cbg.ScanForLinks(r, func(cid.Cid) {}) 1612 } 1613 } 1614

··· 254 return fmt.Errorf("basicSchema: map struct too large (%d)", extra) 255 } 256 257 n := extra 258 259 + nameBuf := make([]byte, 7) 260 for i := uint64(0); i < n; i++ { 261 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 262 + if err != nil { 263 + return err 264 + } 265 266 + if !ok { 267 + // Field doesn't exist on this type, so ignore it 268 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 269 return err 270 } 271 + continue 272 } 273 274 + switch string(nameBuf[:nameLen]) { 275 // t.Bool (bool) (bool) 276 case "bool": 277 ··· 433 434 default: 435 // Field doesn't exist on this type, so ignore it 436 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 437 + return err 438 + } 439 } 440 } 441 ··· 572 return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra) 573 } 574 575 n := extra 576 577 + nameBuf := make([]byte, 6) 578 for i := uint64(0); i < n; i++ { 579 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 580 + if err != nil { 581 + return err 582 + } 583 584 + if !ok { 585 + // Field doesn't exist on this type, so ignore it 586 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 587 return err 588 } 589 + continue 590 } 591 592 + switch string(nameBuf[:nameLen]) { 593 // t.Arr ([]string) (slice) 594 case "arr": 595 ··· 688 689 default: 690 // Field doesn't exist on this type, so ignore it 691 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 692 + return err 693 + } 694 } 695 } 696 ··· 789 return fmt.Errorf("ipldSchema: map struct too large (%d)", extra) 790 } 791 792 n := extra 793 794 + nameBuf := make([]byte, 1) 795 for i := uint64(0); i < n; i++ { 796 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 797 + if err != nil { 798 + return err 799 + } 800 801 + if !ok { 802 + // Field doesn't exist on this type, so ignore it 803 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 804 return err 805 } 806 + continue 807 } 808 809 + switch string(nameBuf[:nameLen]) { 810 // t.A (util.LexLink) (struct) 811 case "a": 812 ··· 853 854 default: 855 // Field doesn't exist on this type, so ignore it 856 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 857 + return err 858 + } 859 } 860 } 861 ··· 1074 return fmt.Errorf("basicOldSchema: map struct too large (%d)", extra) 1075 } 1076 1077 n := extra 1078 1079 + nameBuf := make([]byte, 1) 1080 for i := uint64(0); i < n; i++ { 1081 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1082 + if err != nil { 1083 + return err 1084 + } 1085 1086 + if !ok { 1087 + // Field doesn't exist on this type, so ignore it 1088 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1089 return err 1090 } 1091 + continue 1092 } 1093 1094 + switch string(nameBuf[:nameLen]) { 1095 // t.A (string) (string) 1096 case "a": 1097 ··· 1242 1243 default: 1244 // Field doesn't exist on this type, so ignore it 1245 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1246 + return err 1247 + } 1248 } 1249 } 1250 ··· 1381 return fmt.Errorf("basicOldSchemaInner: map struct too large (%d)", extra) 1382 } 1383 1384 n := extra 1385 1386 + nameBuf := make([]byte, 1) 1387 for i := uint64(0); i < n; i++ { 1388 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1389 + if err != nil { 1390 + return err 1391 + } 1392 1393 + if !ok { 1394 + // Field doesn't exist on this type, so ignore it 1395 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1396 return err 1397 } 1398 + continue 1399 } 1400 1401 + switch string(nameBuf[:nameLen]) { 1402 // t.H (string) (string) 1403 case "h": 1404 ··· 1497 1498 default: 1499 // Field doesn't exist on this type, so ignore it 1500 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1501 + return err 1502 + } 1503 } 1504 } 1505 ··· 1583 return fmt.Errorf("ipldOldSchema: map struct too large (%d)", extra) 1584 } 1585 1586 n := extra 1587 1588 + nameBuf := make([]byte, 1) 1589 for i := uint64(0); i < n; i++ { 1590 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1591 + if err != nil { 1592 + return err 1593 + } 1594 1595 + if !ok { 1596 + // Field doesn't exist on this type, so ignore it 1597 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1598 return err 1599 } 1600 + continue 1601 } 1602 1603 + switch string(nameBuf[:nameLen]) { 1604 // t.A (util.LexLink) (struct) 1605 case "a": 1606 ··· 1636 1637 default: 1638 // Field doesn't exist on this type, so ignore it 1639 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1640 + return err 1641 + } 1642 } 1643 } 1644

+26 -16

mst/cbor_gen.go

··· 104 return fmt.Errorf("nodeData: map struct too large (%d)", extra) 105 } 106 107 - var name string 108 n := extra 109 110 for i := uint64(0); i < n; i++ { 111 112 - { 113 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 114 - if err != nil { 115 return err 116 } 117 - 118 - name = string(sval) 119 } 120 121 - switch name { 122 // t.Entries ([]mst.treeEntry) (slice) 123 case "e": 124 ··· 184 185 default: 186 // Field doesn't exist on this type, so ignore it 187 - cbg.ScanForLinks(r, func(cid.Cid) {}) 188 } 189 } 190 ··· 312 return fmt.Errorf("treeEntry: map struct too large (%d)", extra) 313 } 314 315 - var name string 316 n := extra 317 318 for i := uint64(0); i < n; i++ { 319 320 - { 321 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 322 - if err != nil { 323 return err 324 } 325 - 326 - name = string(sval) 327 } 328 329 - switch name { 330 // t.KeySuffix ([]uint8) (slice) 331 case "k": 332 ··· 415 416 default: 417 // Field doesn't exist on this type, so ignore it 418 - cbg.ScanForLinks(r, func(cid.Cid) {}) 419 } 420 } 421

··· 104 return fmt.Errorf("nodeData: map struct too large (%d)", extra) 105 } 106 107 n := extra 108 109 + nameBuf := make([]byte, 1) 110 for i := uint64(0); i < n; i++ { 111 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 112 + if err != nil { 113 + return err 114 + } 115 116 + if !ok { 117 + // Field doesn't exist on this type, so ignore it 118 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 119 return err 120 } 121 + continue 122 } 123 124 + switch string(nameBuf[:nameLen]) { 125 // t.Entries ([]mst.treeEntry) (slice) 126 case "e": 127 ··· 187 188 default: 189 // Field doesn't exist on this type, so ignore it 190 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 191 + return err 192 + } 193 } 194 } 195 ··· 317 return fmt.Errorf("treeEntry: map struct too large (%d)", extra) 318 } 319 320 n := extra 321 322 + nameBuf := make([]byte, 1) 323 for i := uint64(0); i < n; i++ { 324 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 325 + if err != nil { 326 + return err 327 + } 328 329 + if !ok { 330 + // Field doesn't exist on this type, so ignore it 331 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 332 return err 333 } 334 + continue 335 } 336 337 + switch string(nameBuf[:nameLen]) { 338 // t.KeySuffix ([]uint8) (slice) 339 case "k": 340 ··· 423 424 default: 425 // Field doesn't exist on this type, so ignore it 426 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 427 + return err 428 + } 429 } 430 } 431

+26 -16

repo/cbor_gen.go

··· 194 return fmt.Errorf("SignedCommit: map struct too large (%d)", extra) 195 } 196 197 - var name string 198 n := extra 199 200 for i := uint64(0); i < n; i++ { 201 202 - { 203 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 204 - if err != nil { 205 return err 206 } 207 - 208 - name = string(sval) 209 } 210 211 - switch name { 212 // t.Did (string) (string) 213 case "did": 214 ··· 319 320 default: 321 // Field doesn't exist on this type, so ignore it 322 - cbg.ScanForLinks(r, func(cid.Cid) {}) 323 } 324 } 325 ··· 477 return fmt.Errorf("UnsignedCommit: map struct too large (%d)", extra) 478 } 479 480 - var name string 481 n := extra 482 483 for i := uint64(0); i < n; i++ { 484 485 - { 486 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 487 - if err != nil { 488 return err 489 } 490 - 491 - name = string(sval) 492 } 493 494 - switch name { 495 // t.Did (string) (string) 496 case "did": 497 ··· 579 580 default: 581 // Field doesn't exist on this type, so ignore it 582 - cbg.ScanForLinks(r, func(cid.Cid) {}) 583 } 584 } 585

··· 194 return fmt.Errorf("SignedCommit: map struct too large (%d)", extra) 195 } 196 197 n := extra 198 199 + nameBuf := make([]byte, 7) 200 for i := uint64(0); i < n; i++ { 201 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 202 + if err != nil { 203 + return err 204 + } 205 206 + if !ok { 207 + // Field doesn't exist on this type, so ignore it 208 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 209 return err 210 } 211 + continue 212 } 213 214 + switch string(nameBuf[:nameLen]) { 215 // t.Did (string) (string) 216 case "did": 217 ··· 322 323 default: 324 // Field doesn't exist on this type, so ignore it 325 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 326 + return err 327 + } 328 } 329 } 330 ··· 482 return fmt.Errorf("UnsignedCommit: map struct too large (%d)", extra) 483 } 484 485 n := extra 486 487 + nameBuf := make([]byte, 7) 488 for i := uint64(0); i < n; i++ { 489 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 490 + if err != nil { 491 + return err 492 + } 493 494 + if !ok { 495 + // Field doesn't exist on this type, so ignore it 496 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 497 return err 498 } 499 + continue 500 } 501 502 + switch string(nameBuf[:nameLen]) { 503 // t.Did (string) (string) 504 case "did": 505 ··· 587 588 default: 589 // Field doesn't exist on this type, so ignore it 590 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 591 + return err 592 + } 593 } 594 } 595

+13 -8

util/labels/cbor_gen.go

··· 285 return fmt.Errorf("UnsignedLabel: map struct too large (%d)", extra) 286 } 287 288 - var name string 289 n := extra 290 291 for i := uint64(0); i < n; i++ { 292 293 - { 294 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 295 - if err != nil { 296 return err 297 } 298 - 299 - name = string(sval) 300 } 301 302 - switch name { 303 // t.Cid (string) (string) 304 case "cid": 305 ··· 458 459 default: 460 // Field doesn't exist on this type, so ignore it 461 - cbg.ScanForLinks(r, func(cid.Cid) {}) 462 } 463 } 464

··· 285 return fmt.Errorf("UnsignedLabel: map struct too large (%d)", extra) 286 } 287 288 n := extra 289 290 + nameBuf := make([]byte, 3) 291 for i := uint64(0); i < n; i++ { 292 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 293 + if err != nil { 294 + return err 295 + } 296 297 + if !ok { 298 + // Field doesn't exist on this type, so ignore it 299 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 300 return err 301 } 302 + continue 303 } 304 305 + switch string(nameBuf[:nameLen]) { 306 // t.Cid (string) (string) 307 case "cid": 308 ··· 461 462 default: 463 // Field doesn't exist on this type, so ignore it 464 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 465 + return err 466 + } 467 } 468 } 469